Address thread start MCP review feedback

D3OXY · D3OXY · commit 094c88c9546f · 2026-06-22T13:45:00.000+05:30
diff --git a/apps/server/src/mcp/toolkits/thread/handlers.test.ts b/apps/server/src/mcp/toolkits/thread/handlers.test.ts
@@ -20,6 +20,7 @@ import { GitWorkflowService } from "../../../git/GitWorkflowService.ts";
 import * as BootstrapTurnStartDispatcher from "../../../orchestration/Services/BootstrapTurnStartDispatcher.ts";
 import { OrchestrationEngineService } from "../../../orchestration/Services/OrchestrationEngine.ts";
 import { ProjectionSnapshotQuery } from "../../../orchestration/Services/ProjectionSnapshotQuery.ts";
+import * as ServerRuntimeStartup from "../../../serverRuntimeStartup.ts";
 import * as McpInvocationContext from "../../McpInvocationContext.ts";
 import { ThreadToolkitRegistrationLive } from "../../McpHttpServer.ts";
 import { ThreadStartRuntimeLive } from "./handlers.ts";
@@ -90,14 +91,26 @@ const TestCryptoLive = Layer.sync(Crypto.Crypto, () => {
   });
 });
 
-const makeTestLayer = (commands: OrchestrationCommand[]) => {
+const makeTestLayer = (
+  commands: OrchestrationCommand[],
+  options: { readonly enqueueCalls?: number[] } = {},
+) => {
   const bootstrapTurnStartDispatcherLayer = Layer.mock(
     BootstrapTurnStartDispatcher.BootstrapTurnStartDispatcher,
   )({
     dispatch: (command) =>
       Effect.sync(() => {
         commands.push(command);
-        return { sequence: 1 };
+        return {
+          sequence: 1,
+          branch:
+            command.bootstrap?.prepareWorktree?.branch ??
+            command.bootstrap?.createThread?.branch ??
+            null,
+          worktreePath: command.bootstrap?.prepareWorktree
+            ? "/repo/.worktrees/generated"
+            : (command.bootstrap?.createThread?.worktreePath ?? null),
+        };
       }),
   });
 
@@ -161,10 +174,24 @@ const makeTestLayer = (commands: OrchestrationCommand[]) => {
         streamDomainEvents: Stream.empty,
       }),
     ),
+    Layer.provide(
+      Layer.mock(ServerRuntimeStartup.ServerRuntimeStartup)({
+        awaitCommandReady: Effect.void,
+        markHttpListening: Effect.void,
+        enqueueCommand: (effect) =>
+          Effect.sync(() => {
+            options.enqueueCalls?.push(1);
+          }).pipe(Effect.flatMap(() => effect)),
+      }),
+    ),
   );
 };
 
-const callStartTool = (arguments_: Record<string, unknown>, commands: OrchestrationCommand[]) =>
+const callStartTool = (
+  arguments_: Record<string, unknown>,
+  commands: OrchestrationCommand[],
+  options: { readonly enqueueCalls?: number[] } = {},
+) =>
   Effect.gen(function* () {
     const server = yield* McpServer.McpServer;
     return yield* server
@@ -173,7 +200,7 @@ const callStartTool = (arguments_: Record<string, unknown>, commands: Orchestrat
         Effect.provideService(McpInvocationContext.McpInvocationContext, invocation),
         Effect.provideService(McpSchema.McpServerClient, client),
       );
-  }).pipe(Effect.provide(makeTestLayer(commands)));
+  }).pipe(Effect.provide(makeTestLayer(commands, options)));
 
 it.effect("starts a new worktree thread by default and inherits source settings", () =>
   Effect.gen(function* () {
@@ -184,7 +211,7 @@ it.effect("starts a new worktree thread by default and inherits source settings"
     expect(result.structuredContent).toMatchObject({
       projectId,
       mode: "new_worktree",
-      worktreePath: null,
+      worktreePath: "/repo/.worktrees/generated",
     });
     const command = commands[0];
     expect(command?.type).toBe("thread.turn.start");
@@ -202,6 +229,46 @@ it.effect("starts a new worktree thread by default and inherits source settings"
   }),
 );
 
+it.effect("queues thread starts through server runtime startup", () =>
+  Effect.gen(function* () {
+    const commands: OrchestrationCommand[] = [];
+    const enqueueCalls: number[] = [];
+    const result = yield* callStartTool({ prompt: "Wait for server readiness" }, commands, {
+      enqueueCalls,
+    });
+
+    expect(result.isError).toBe(false);
+    expect(enqueueCalls).toHaveLength(1);
+    expect(commands).toHaveLength(1);
+  }),
+);
+
+it.effect("passes explicit setup script requests for existing worktrees", () =>
+  Effect.gen(function* () {
+    const commands: OrchestrationCommand[] = [];
+    const result = yield* callStartTool(
+      {
+        prompt: "Use existing checkout",
+        mode: "existing_worktree",
+        worktreePath: "/repo/existing",
+        runSetupScript: true,
+      },
+      commands,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.structuredContent).toMatchObject({
+      mode: "existing_worktree",
+      worktreePath: "/repo/existing",
+    });
+    const command = commands[0];
+    expect(command?.type).toBe("thread.turn.start");
+    if (command?.type !== "thread.turn.start") return;
+    expect(command.bootstrap?.prepareWorktree).toBeUndefined();
+    expect(command.bootstrap?.runSetupScript).toBe(true);
+  }),
+);
+
 it.effect("starts current-checkout threads with warning metadata", () =>
   Effect.gen(function* () {
     const commands: OrchestrationCommand[] = [];
diff --git a/apps/server/src/mcp/toolkits/thread/handlers.ts b/apps/server/src/mcp/toolkits/thread/handlers.ts
@@ -3,6 +3,7 @@ import {
   MessageId,
   ThreadId,
   type ModelSelection,
+  type OrchestrationCommand,
   type OrchestrationProjectShell,
   type OrchestrationThreadShell,
 } from "@t3tools/contracts";
@@ -18,6 +19,7 @@ import * as McpInvocationContext from "../../McpInvocationContext.ts";
 import * as BootstrapTurnStartDispatcher from "../../../orchestration/Services/BootstrapTurnStartDispatcher.ts";
 import { ProjectionSnapshotQuery } from "../../../orchestration/Services/ProjectionSnapshotQuery.ts";
 import { GitWorkflowService } from "../../../git/GitWorkflowService.ts";
+import * as ServerRuntimeStartup from "../../../serverRuntimeStartup.ts";
 import {
   ThreadStartToolError,
   type ThreadStartMode,
@@ -60,6 +62,7 @@ const makeActiveThreadStartRuntime = Effect.fn("ThreadToolkit.makeActiveRuntime"
   const crypto = yield* Crypto.Crypto;
   const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
   const gitWorkflow = yield* GitWorkflowService;
+  const startup = yield* ServerRuntimeStartup.ServerRuntimeStartup;
   const uuid = () => crypto.randomUUIDv4.pipe(Effect.orDie);
 
   const makeIds = Effect.fn("ThreadToolkit.makeIds")(function* () {
@@ -186,12 +189,13 @@ const makeActiveThreadStartRuntime = Effect.fn("ThreadToolkit.makeActiveRuntime"
             branch: branch ?? undefined,
           }
         : undefined;
+    const runSetupScript = input.runSetupScript ?? (mode === "new_worktree" ? true : undefined);
 
     if (mode === "existing_worktree" && !worktreePath) {
       return yield* fail("existing_worktree mode requires worktreePath.");
     }
 
-    yield* BootstrapTurnStartDispatcher.dispatchActive({
+    const command: Extract<OrchestrationCommand, { type: "thread.turn.start" }> = {
       type: "thread.turn.start",
       commandId: ids.commandId,
       threadId: ids.threadId,
@@ -216,26 +220,26 @@ const makeActiveThreadStartRuntime = Effect.fn("ThreadToolkit.makeActiveRuntime"
           worktreePath,
           createdAt,
         },
-        ...(prepareWorktree
-          ? {
-              prepareWorktree,
-              runSetupScript: input.runSetupScript ?? true,
-            }
-          : {}),
+        ...(prepareWorktree ? { prepareWorktree } : {}),
+        ...(runSetupScript === undefined ? {} : { runSetupScript }),
       },
       createdAt,
-    }).pipe(
-      Effect.mapError((error) =>
-        fail(error instanceof Error ? error.message : "Failed to start child thread."),
-      ),
-    );
+    };
+
+    const result = yield* startup
+      .enqueueCommand(BootstrapTurnStartDispatcher.dispatchActive(command))
+      .pipe(
+        Effect.mapError((error) =>
+          fail(error instanceof Error ? error.message : "Failed to start child thread."),
+        ),
+      );
 
     return {
       threadId: ids.threadId,
       projectId: project.id,
       mode,
-      branch,
-      worktreePath,
+      branch: result.branch ?? branch,
+      worktreePath: result.worktreePath,
       ...(mode === "current_checkout"
         ? {
             warning:
diff --git a/apps/server/src/orchestration/Services/BootstrapTurnStartDispatcher.ts b/apps/server/src/orchestration/Services/BootstrapTurnStartDispatcher.ts
@@ -54,9 +54,14 @@ function projectSetupScriptCompatibilityDetail(
 }
 
 export interface BootstrapTurnStartDispatcherShape {
-  readonly dispatch: (
-    command: ThreadTurnStartCommand,
-  ) => Effect.Effect<{ readonly sequence: number }, OrchestrationDispatchCommandError>;
+  readonly dispatch: (command: ThreadTurnStartCommand) => Effect.Effect<
+    {
+      readonly sequence: number;
+      readonly branch: string | null;
+      readonly worktreePath: string | null;
+    },
+    OrchestrationDispatchCommandError
+  >;
 }
 
 export class BootstrapTurnStartDispatcher extends Context.Service<
@@ -68,7 +73,7 @@ let activeDispatcher: BootstrapTurnStartDispatcherShape | null = null;
 
 export const dispatchActive = (
   command: ThreadTurnStartCommand,
-): Effect.Effect<{ readonly sequence: number }, OrchestrationDispatchCommandError> => {
+): ReturnType<BootstrapTurnStartDispatcherShape["dispatch"]> => {
   const dispatcher = activeDispatcher;
   if (!dispatcher) {
     return Effect.fail(
@@ -176,6 +181,7 @@ export const layer = Layer.effect(
       let createdThread = false;
       let targetProjectId = bootstrap?.createThread?.projectId;
       let targetProjectCwd = bootstrap?.prepareWorktree?.projectCwd;
+      let targetBranch = bootstrap?.createThread?.branch ?? null;
       let targetWorktreePath = bootstrap?.createThread?.worktreePath ?? null;
 
       const cleanupCreatedThread = () =>
@@ -346,6 +352,7 @@ export const layer = Layer.effect(
             baseRefName: bootstrap.prepareWorktree.baseBranch,
             path: null,
           });
+          targetBranch = worktree.worktree.refName;
           targetWorktreePath = worktree.worktree.path;
           yield* orchestrationEngine.dispatch({
             type: "thread.meta.update",
@@ -359,7 +366,12 @@ export const layer = Layer.effect(
 
         yield* runSetupProgram();
 
-        return yield* orchestrationEngine.dispatch(finalTurnStartCommand);
+        const result = yield* orchestrationEngine.dispatch(finalTurnStartCommand);
+        return {
+          ...result,
+          branch: targetBranch,
+          worktreePath: targetWorktreePath,
+        };
       });
 
       return yield* bootstrapProgram.pipe(
