Promote expbkmain to bkmain: plan review, session trees, lineage, worktree reclaim

apps/desktop/src/settings/DesktopClientSettings.test.ts

@@ -31,6 +31,7 @@ const clientSettings: ClientSettings = {
   glassOpacity: 80,
   phaseGroupedSidebarEnabled: true,
   planModeEnabled: false,
+  nativePlanReviewEnabled: true,
   providerModelPreferences: {},
   providerRateLimitsEnabled: true,
   resourceMonitorEnabled: false,

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -65,6 +65,9 @@ import {
 } from "../src/orchestration/Services/OrchestrationEngine.ts";
 import { ThreadDeletionReactor } from "../src/orchestration/Services/ThreadDeletionReactor.ts";
 import { OrchestrationReactor } from "../src/orchestration/Services/OrchestrationReactor.ts";
+// T3-CUSTOM(expbkt3): BEGIN — bulk session manager work summaries.
+import { WorkSummaryReactor } from "../src/orchestration/Services/WorkSummaryReactor.ts";
+// T3-CUSTOM(expbkt3): END
 import { ProjectionSnapshotQuery } from "../src/orchestration/Services/ProjectionSnapshotQuery.ts";
 import {
   RuntimeReceiptBus,
@@ -377,6 +380,15 @@ export const makeOrchestrationIntegrationHarness = (
       Layer.provideMerge(providerCommandReactorLayer),
       Layer.provideMerge(checkpointReactorLayer),
       Layer.provideMerge(catchupSummaryReactorLayer),
+      // T3-CUSTOM(expbkt3): BEGIN — bulk session manager work summaries are exercised by
+      // their own reactor test; this harness only needs the dependency satisfied.
+      Layer.provideMerge(
+        Layer.succeed(WorkSummaryReactor, {
+          start: () => Effect.void,
+          drain: Effect.void,
+        }),
+      ),
+      // T3-CUSTOM(expbkt3): END
       Layer.provideMerge(
         Layer.succeed(ThreadDeletionReactor, {
           start: () => Effect.void,

apps/server/src/auth/rpcForkScopes.ts

@@ -35,4 +35,18 @@ export const FORK_RPC_REQUIRED_SCOPES = {
   [WS_FORK_METHODS.usersRevokeSessions]: AuthOrchestrationOperateScope,
   [WS_FORK_METHODS.usersSourceControlProfileSet]: AuthOrchestrationOperateScope,
   [WS_FORK_METHODS.linearIssuesResolve]: AuthOrchestrationReadScope,
+  [WS_FORK_METHODS.planReviewGet]: AuthOrchestrationReadScope,
+  [WS_FORK_METHODS.planReviewList]: AuthOrchestrationReadScope,
+  [WS_FORK_METHODS.planReviewVersionDiff]: AuthOrchestrationReadScope,
+  [WS_FORK_METHODS.subscribePlanReview]: AuthOrchestrationReadScope,
+  [WS_FORK_METHODS.planReviewSaveDraft]: AuthOrchestrationOperateScope,
+  [WS_FORK_METHODS.planReviewCutVersion]: AuthOrchestrationOperateScope,
+  [WS_FORK_METHODS.planReviewUpsertDiscussion]: AuthOrchestrationOperateScope,
+  [WS_FORK_METHODS.planReviewResolveDiscussion]: AuthOrchestrationOperateScope,
+  [WS_FORK_METHODS.planReviewSubmit]: AuthOrchestrationOperateScope,
+  // T3-CUSTOM(expbkt3): archived-session worktree reclaim. Scanning is a read;
+  // exporting writes files and reclaiming deletes them, so both need operate.
+  [WS_FORK_METHODS.sessionArchiveScan]: AuthOrchestrationReadScope,
+  [WS_FORK_METHODS.sessionArchiveExport]: AuthOrchestrationOperateScope,
+  [WS_FORK_METHODS.sessionArchiveReclaim]: AuthOrchestrationOperateScope,
 } as const;

apps/server/src/git/GitManager.test.ts

@@ -300,6 +300,8 @@ function createTextGeneration(
       Effect.die("updateRollingSummary is not exercised by GitManager tests"),
     generateCatchupSummary: () =>
       Effect.die("generateCatchupSummary is not exercised by GitManager tests"),
+    generateWorkSummary: () =>
+      Effect.die("generateWorkSummary is not exercised by GitManager tests"),
     ...overrides,
   };
 
@@ -353,6 +355,7 @@ function createTextGeneration(
       Effect.die("updateRollingSummary is not used by git text generation"),
     generateCatchupSummary: () =>
       Effect.die("generateCatchupSummary is not used by git text generation"),
+    generateWorkSummary: () => Effect.die("generateWorkSummary is not used by git text generation"),
   };
 }
 

apps/server/src/mcp/toolkits/control/handlers.lineage.test.ts

@@ -0,0 +1,138 @@
+// T3-CUSTOM(expbkt3): session lineage on t3_create_session.
+//
+// Covers the full createAsChild matrix: nesting is the agent's call, and the
+// implicit default must never fire for a conductor-scoped external-user token.
+import { expect, it } from "@effect/vitest";
+import { EnvironmentId, ProjectId, ProviderInstanceId, ThreadId, UserId } from "@t3tools/contracts";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+
+import { OrchestrationAccessControl } from "../../../orchestration/Services/AccessControl.ts";
+import * as McpInvocationContext from "../../McpInvocationContext.ts";
+import { T3ControlToolError } from "./tools.ts";
+import { __testing } from "./handlers.ts";
+
+const actorUserId = UserId.make("user-lineage");
+const callerThreadId = ThreadId.make("thread-caller");
+const openProjectId = ProjectId.make("project-open");
+const closedProjectId = ProjectId.make("project-closed");
+const openParentId = ThreadId.make("thread-open-parent");
+const closedParentId = ThreadId.make("thread-closed-parent");
+
+const threads = [
+  { id: callerThreadId, projectId: openProjectId },
+  { id: openParentId, projectId: openProjectId },
+  { id: closedParentId, projectId: closedProjectId },
+];
+
+function makeScope(
+  overrides: Partial<McpInvocationContext.McpInvocationScope> = {},
+): McpInvocationContext.McpInvocationScope {
+  return {
+    principal: "provider-session",
+    actorUserId,
+    environmentId: EnvironmentId.make("environment-lineage"),
+    threadId: callerThreadId,
+    providerSessionId: "provider-session-lineage",
+    providerInstanceId: ProviderInstanceId.make("codex"),
+    capabilities: new Set(["t3.read", "t3.control", "t3.session.create"]),
+    issuedAt: 1,
+    ...overrides,
+  };
+}
+
+const accessControl = OrchestrationAccessControl.of({
+  actorFor: () => Option.some(actorUserId),
+  canAccessThread: () => Effect.succeed(true),
+  canAccessProject: (_userId, projectId) => Effect.succeed(projectId === openProjectId),
+  canTransferThreadOwnership: () => Effect.succeed(false),
+  canTransferProjectOwnership: () => Effect.succeed(false),
+});
+
+const resolve = (input: {
+  readonly scope?: McpInvocationContext.McpInvocationScope;
+  readonly createAsChild?: boolean;
+  readonly parentSessionId?: string;
+}) =>
+  __testing
+    .resolveCreatedSessionParent({
+      operation: "create-session",
+      scope: input.scope ?? makeScope(),
+      threads,
+      createAsChild: input.createAsChild,
+      parentSessionId: input.parentSessionId,
+    })
+    .pipe(Effect.provideService(OrchestrationAccessControl, accessControl));
+
+it.effect("nests under the calling session by default", () =>
+  Effect.gen(function* () {
+    expect(yield* resolve({})).toBe(callerThreadId);
+  }),
+);
+
+it.effect("nests when createAsChild is explicitly true", () =>
+  Effect.gen(function* () {
+    expect(yield* resolve({ createAsChild: true })).toBe(callerThreadId);
+  }),
+);
+
+it.effect("creates a top-level session when createAsChild is false", () =>
+  Effect.gen(function* () {
+    expect(yield* resolve({ createAsChild: false })).toBe(null);
+  }),
+);
+
+it.effect("never parents an external-user token to its conductor thread", () =>
+  Effect.gen(function* () {
+    // scope.threadId here is the user's conductor thread, not a session they
+    // are working in — defaulting to it would build one giant bogus tree.
+    const scope = makeScope({ principal: "external-user" });
+    expect(yield* resolve({ scope })).toBe(null);
+  }),
+);
+
+it.effect("never parents an external operator implicitly", () =>
+  Effect.gen(function* () {
+    const scope = makeScope({ principal: "external-operator" });
+    expect(yield* resolve({ scope })).toBe(null);
+  }),
+);
+
+it.effect("honours an explicit accessible parent", () =>
+  Effect.gen(function* () {
+    expect(yield* resolve({ parentSessionId: openParentId })).toBe(openParentId);
+  }),
+);
+
+it.effect("hides a parent whose project the caller cannot access", () =>
+  Effect.gen(function* () {
+    const error = yield* resolve({ parentSessionId: closedParentId }).pipe(Effect.flip);
+    expect(error).toBeInstanceOf(T3ControlToolError);
+    expect(error.message).toBe(`T3 session ${closedParentId} was not found.`);
+  }),
+);
+
+it.effect("reports an unknown parent as absent", () =>
+  Effect.gen(function* () {
+    const error = yield* resolve({ parentSessionId: "thread-does-not-exist" }).pipe(Effect.flip);
+    expect(error).toBeInstanceOf(T3ControlToolError);
+  }),
+);
+
+it.effect("refuses a contradictory createAsChild:false plus parentSessionId", () =>
+  Effect.gen(function* () {
+    const error = yield* resolve({
+      createAsChild: false,
+      parentSessionId: openParentId,
+    }).pipe(Effect.flip);
+    expect(error).toBeInstanceOf(T3ControlToolError);
+    expect(error.message).toContain("cannot be combined with parentSessionId");
+  }),
+);
+
+it.effect("lets an external operator name a parent without an access check", () =>
+  Effect.gen(function* () {
+    const scope = makeScope({ principal: "external-operator" });
+    expect(yield* resolve({ scope, parentSessionId: closedParentId })).toBe(closedParentId);
+  }),
+);