feat(mcp): target thread launches by project#8678

@@ -1341,139 +1625,245 @@ const make = Effect.gen(function* () {
           );
         }
         const parentNodeId = parentRun.rootNodeId;
-        const providers = yield* loadProviders;
         const key = yield* requestKey(input.clientRequestId);
         const created = yield* Effect.forEach(
           input.threads,
           (request, index) =>
             Effect.gen(function* () {
-              const target = yield* resolveTarget({
-                parent,
-                target: request.target,
-                providers,
-              });
-              const runtimeMode = yield* resolveRuntimeMode(
-                parent.thread.runtimeMode,
-                request.runtimeMode,
-              );
-              const interactionMode = yield* resolveInteractionMode(
-                parent.thread.interactionMode,
-                request.interactionMode,
-              );
-              const threadId = stableThreadId({
+              const projectId = yield* resolveProjectId(parent, request.projectId);
+              const commandId = stableCommandId({
                 scope,
                 requestKey: key,
+                operation: "create-thread",
                 index,
               });
-              const title = threadTitle({
-                parentTitle: parent.thread.title,
-                prompt: request.prompt,
-                title: request.title,
-                index,
-              });
-              const createCommandId = stableCommandId({
+              const threadId = stableThreadId({
                 scope,
                 requestKey: key,
-                operation: "create-thread",
                 index,
               });
-              const createCommand = {
-                type: "thread.create",
-                createdBy: "agent",
-                creationSource: "mcp",
-                commandId: createCommandId,
-                threadId,
-                projectId: parent.thread.projectId,
-                title,
-                modelSelection: target.modelSelection,
-                runtimeMode,
-                interactionMode,
-                branch: parent.thread.branch,
-                worktreePath: parent.thread.worktreePath,
-              } as const;
-              yield* threadManagement
-                .withProjectCreationAdmission(
-                  { projectId: parent.thread.projectId, commandId: createCommandId },
-                  (receipt) =>
-                    Effect.gen(function* () {
-                      if (Option.isNone(receipt)) {
-                        const freshParent = yield* loadProjection(scope.threadId);
-                        const freshParentRun = latestActiveRun(freshParent);
-                        if (
-                          freshParent.thread.projectId !== parent.thread.projectId ||
-                          freshParent.thread.deletedAt !== null ||
-                          freshParent.thread.archivedAt !== null ||
-                          freshParentRun === undefined ||
-                          freshParentRun.rootNodeId === null ||
-                          freshParentRun.providerInstanceId !== scope.providerInstanceId
-                        ) {
-                          return yield* failure(
-                            "parent_not_active",
-                            "Thread creation requires an active parent in the target project.",
-                          );
-                        }
-                      }
-                      return yield* threadManagement.dispatch(createCommand);
-                    }),
+              const initialMessageId = stableMessageId({ scope, requestKey: key, index });
+              const launchReceipt = yield* threadManagement
+                .withProjectCreationAdmission({ projectId, commandId }, (receipt) =>
+                  Effect.succeed(receipt),
                 )
                 .pipe(
-                  Effect.mapError((error) =>
-                    isOrchestratorMcpFailure(error)
-                      ? error
-                      : failure(
-                          "orchestration_error",
-                          `Unable to create thread ${index + 1}: ${errorMessage(error)}`,
-                        ),
+                  Effect.mapError(() =>
+                    failure(
+                      "orchestration_error",
+                      `Unable to read the accepted launch for thread ${index + 1}.`,
+                    ),
                   ),
                 );
-              if (request.prompt !== undefined) {
-                yield* threadManagement
-                  .dispatch({
-                    type: "message.dispatch",
-                    createdBy: "agent",
-                    creationSource: "mcp",
-                    commandId: stableCommandId({
-                      scope,
-                      requestKey: key,
-                      operation: "dispatch-thread",
-                      index,
-                    }),
-                    threadId,
-                    messageId: stableMessageId({
-                      scope,
-                      requestKey: key,
-                      index,
-                    }),
-                    text: request.prompt,
-                    attachments: [],
-                    modelSelection: target.modelSelection,
-                    dispatchMode: { type: "start_immediately" },
-                  })
+              if (
+                Option.isSome(launchReceipt) &&
+                (launchReceipt.value.commandType !== "thread.create" ||
+                  launchReceipt.value.threadId !== threadId)
+              ) {
+                return yield* failure(
+                  "invalid_request",
+                  `clientRequestId conflicts with an existing command for thread ${index + 1}.`,
+                );
+              }
+              const acceptedProjection =
+                Option.isSome(launchReceipt) && launchReceipt.value.status === "accepted"
+                  ? Option.some(yield* loadProjection(threadId))
+                  : Option.none<OrchestrationV2ThreadProjection>();
+              if (
+                Option.isSome(acceptedProjection) &&
+                (acceptedProjection.value.thread.id !== threadId ||
+                  acceptedProjection.value.thread.projectId !== projectId)
+              ) {
+                return yield* failure(
+                  "invalid_request",
+                  `clientRequestId was already accepted for a different project at thread ${index + 1}.`,
+                );
+              }
+              const mayReplayDurableRoot = yield* Effect.gen(function* () {
+                if (
+                  Option.isNone(acceptedProjection) ||
+                  acceptedProjection.value.thread.worktreePath !== null ||
+                  request.workspaceStrategy?.type === "new_worktree"
+                ) {
+                  return false;
+                }
+                if (request.prompt === undefined) return true;
+                const messageCommandId = CommandId.make(`${commandId}:initial-message`);
+                const messageReceipt = yield* threadManagement
+                  .withProjectCreationAdmission(
+                    { projectId, commandId: messageCommandId },
+                    (receipt) => Effect.succeed(receipt),
+                  )
                   .pipe(
-                    Effect.mapError((error) =>
+                    Effect.mapError(() =>
                       failure(
                         "orchestration_error",
-                        `Unable to start thread ${index + 1}: ${errorMessage(error)}`,
+                        `Unable to read the accepted initial message for thread ${index + 1}.`,
                       ),
                     ),
                   );
+                if (
+                  Option.isSome(messageReceipt) &&
+                  (messageReceipt.value.commandType !== "message.dispatch" ||
+                    messageReceipt.value.threadId !== threadId)
+                ) {
+                  return yield* failure(
+                    "invalid_request",
+                    `clientRequestId conflicts with an existing initial message for thread ${index + 1}.`,
+                  );
+                }
+                if (Option.isNone(messageReceipt) || messageReceipt.value.status !== "accepted") {
+                  return false;
+                }
+                const initialMessage = acceptedProjection.value.messages.find(
+                  (message) => message.id === initialMessageId,
+                );
+                if (initialMessage?.runId === null || initialMessage?.runId === undefined) {
+                  return false;
+                }
+                const initialRun = acceptedProjection.value.runs.find(
+                  (run) => run.id === initialMessage.runId,
+                );
+                return initialRun !== undefined && initialRun.status !== "preparing";
+              });
+              const target = Option.isSome(acceptedProjection)
+                ? { modelSelection: acceptedProjection.value.thread.modelSelection }
+                : Option.isSome(launchReceipt)
+                  ? { modelSelection: parent.thread.modelSelection }
+                  : yield* resolveTarget({
+                      parent,
+                      target: request.target,
+                      providers: yield* loadProviders,
+                    });
+              const runtimeMode = Option.isSome(acceptedProjection)
+                ? acceptedProjection.value.thread.runtimeMode
+                : resolveLaunchRuntimeMode(parent.thread.runtimeMode, request.runtimeMode);
+              const interactionMode = Option.isSome(acceptedProjection)
+                ? acceptedProjection.value.thread.interactionMode
+                : resolveLaunchInteractionMode(
+                    parent.thread.interactionMode,
+                    request.interactionMode,
+                  );
+              const title = Option.isSome(acceptedProjection)
+                ? acceptedProjection.value.thread.title
+                : threadTitle({
+                    parentTitle: parent.thread.title,
+                    prompt: request.prompt,
+                    title: request.title,
+                    index,
+                  });
+              const workspaceStrategy: ThreadLaunch.ThreadLaunchWorkspaceStrategy = Option.isSome(
+                acceptedProjection,
+              )
+                ? acceptedProjection.value.thread.worktreePath !== null
+                  ? {
+                      type: "existing_worktree",
+                      worktreePath: acceptedProjection.value.thread.worktreePath,
+                      ...(acceptedProjection.value.thread.branch === null
+                        ? {}
+                        : { branch: acceptedProjection.value.thread.branch }),
+                    }
+                  : request.workspaceStrategy?.type === "new_worktree"
+                    ? {
+                        type: "worktree",
+                        baseRef: request.workspaceStrategy.baseRef,
+                        ...(acceptedProjection.value.thread.branch === null
+                          ? request.workspaceStrategy.branch === undefined
+                            ? {}
+                            : { branch: request.workspaceStrategy.branch }
+                          : { branch: acceptedProjection.value.thread.branch }),
+                        ...(request.workspaceStrategy.startFromOrigin === undefined
+                          ? {}
+                          : { startFromOrigin: request.workspaceStrategy.startFromOrigin }),
+                      }
+                    : mayReplayDurableRoot
+                      ? {
+                          type: "root",
+                          ...(acceptedProjection.value.thread.branch === null
+                            ? {}
+                            : { branch: acceptedProjection.value.thread.branch }),
+                        }
+                      : yield* resolveLaunchWorkspace(
+                          parent,
+                          yield* loadLaunchProject(projectId),
+                          request.workspaceStrategy,
+                        )

@@ -2000,6 +2011,7 @@ export const OrchestrationV2Command = Schema.Union([
     modelSelection: ModelSelection,
     runtimeMode: RuntimeMode,
     interactionMode: ProviderInteractionMode,
+    policyCeiling: Schema.optional(OrchestrationV2PolicyCeiling),

@@ -224,6 +282,23 @@ function nextRunOrdinal(projection: OrchestrationV2ThreadProjection): number {
   return projection.runs.length + 1;
 }
 
+function runtimeModeRank(mode: OrchestrationV2AppThread["runtimeMode"]): number {
+  switch (mode) {
+    case "approval-required":
+      return 0;
+    case "auto-accept-edits":
+      return 1;
+    case "auto":
+      return 2;

@@ -1370,67 +1441,46 @@ const make = Effect.gen(function* () {
                 title: request.title,
                 index,
               });
-              yield* threadManagement
-                .dispatch({
-                  type: "thread.create",
-                  createdBy: "agent",
-                  creationSource: "mcp",
+              const launched = yield* threadLaunch
+                .launch({
                   commandId: stableCommandId({
                     scope,
                     requestKey: key,
                     operation: "create-thread",
                     index,
                   }),
                   threadId,
-                  projectId: parent.thread.projectId,
+                  projectId,
                   title,
                   modelSelection: target.modelSelection,
                   runtimeMode,
                   interactionMode,
-                  branch: parent.thread.branch,
-                  worktreePath: parent.thread.worktreePath,
+                  workspaceStrategy: resolveLaunchWorkspace(
+                    parent,
+                    projectId,
+                    request.workspaceStrategy,
+                  ),
+                  ...(request.prompt === undefined
+                    ? {}
+                    : {
+                        initialMessage: {
+                          messageId: stableMessageId({ scope, requestKey: key, index }),
+                          text: request.prompt,
+                          attachments: [],
+                        },
+                      }),
+                  createdBy: "agent",
+                  creationSource: "mcp",
                 })
                 .pipe(
                   Effect.mapError((error) =>
                     failure(
                       "orchestration_error",
-                      `Unable to create thread ${index + 1}: ${errorMessage(error)}`,
+                      `Unable to launch thread ${index + 1}: ${errorMessage(error)}`,
                     ),
                   ),
                 );
-              if (request.prompt !== undefined) {
-                yield* threadManagement
-                  .dispatch({
-                    type: "message.dispatch",
-                    createdBy: "agent",
-                    creationSource: "mcp",
-                    commandId: stableCommandId({
-                      scope,
-                      requestKey: key,
-                      operation: "dispatch-thread",
-                      index,
-                    }),
-                    threadId,
-                    messageId: stableMessageId({
-                      scope,
-                      requestKey: key,
-                      index,
-                    }),
-                    text: request.prompt,
-                    attachments: [],
-                    modelSelection: target.modelSelection,
-                    dispatchMode: { type: "start_immediately" },
-                  })
-                  .pipe(
-                    Effect.mapError((error) =>
-                      failure(
-                        "orchestration_error",
-                        `Unable to start thread ${index + 1}: ${errorMessage(error)}`,
-                      ),
-                    ),
-                  );
-              }
-              const projection = yield* loadProjection(threadId);
+              const projection = launched.projection;
               const run = projection.runs.at(-1);
               yield* threadManagement
                 .dispatch({

@@ -4896,13 +4896,26 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
           cause: `Parent node ${command.parentNodeId} is not the root of run ${command.parentRunId}.`,
         });
       }
-      if (parentProjection.thread.projectId !== targetProjection.thread.projectId) {
+      if (
+        command.targetProjectId === undefined &&
+        parentProjection.thread.projectId !== targetProjection.thread.projectId
+      ) {
         return yield* new OrchestratorDispatchError({
           commandId: command.commandId,
           commandType: command.type,
           cause: `Target thread ${command.targetThreadId} belongs to another project.`,
         });
       }
+      if (
+        command.targetProjectId !== undefined &&

@@ -705,17 +763,219 @@ const make = Effect.gen(function* () {
       .getProjectThread({ projectId, threadId })
       .pipe(Effect.mapError(threadManagementFailure));
 
-  const loadScopedThread = (scope: McpInvocationScope, threadId: ThreadId) =>
+  const resolveProjectId = (
+    parent: OrchestrationV2ThreadProjection,
+    requestedProjectId: ProjectId | undefined,
+  ): Effect.Effect<ProjectId, OrchestratorMcpFailure> =>
+    Effect.gen(function* () {
+      const projectId = requestedProjectId ?? parent.thread.projectId;
+      if (projectId === parent.thread.projectId) return projectId;
+      const project = yield* projects
+        .getById(projectId)
+        .pipe(
+          Effect.mapError((error) =>
+            failure(
+              "orchestration_error",
+              `Unable to read project ${projectId}: ${errorMessage(error)}`,
+            ),
+          ),
+        );
+      if (Option.isNone(project)) {
+        return yield* failure("project_not_found", `Project ${projectId} was not found.`);
+      }
+      return projectId;
+    });
+
+  const loadLaunchProject = (projectId: ProjectId) =>
+    projects.getById(projectId).pipe(
+      Effect.mapError((error) =>
+        failure(
+          "orchestration_error",
+          `Unable to read project ${projectId}: ${errorMessage(error)}`,
+        ),
+      ),
+      Effect.flatMap(
+        Option.match({
+          onNone: () =>
+            Effect.fail(failure("project_not_found", `Project ${projectId} was not found.`)),
+          onSome: Effect.succeed,
+        }),
+      ),
+    );
+
+  const loadScopedThread = (
+    scope: McpInvocationScope,
+    threadId: ThreadId,
+    requestedProjectId?: ProjectId,
+  ) =>
     Effect.gen(function* () {
       yield* requireCapability(scope);
       const parent = yield* loadProjection(scope.threadId);
+      const projectId = yield* resolveProjectId(parent, requestedProjectId);
       const target =
-        threadId === scope.threadId
+        threadId === scope.threadId && projectId === parent.thread.projectId
           ? parent
-          : yield* loadProjectThread(parent.thread.projectId, threadId);
-      return { parent, target } as const;
+          : yield* loadProjectThread(projectId, threadId);
+      return { parent, projectId, target } as const;
     });
 
+  const canonicalPath = (value: string, label: string) =>
+    fileSystem
+      .realPath(value)
+      .pipe(
+        Effect.mapError((error) =>
+          failure("invalid_request", `Unable to resolve ${label}: ${errorMessage(error)}`),
+        ),
+      );
+
+  const detectRepository = (cwd: string, label: string) =>
+    vcsRegistry
+      .detect({ cwd })
+      .pipe(
+        Effect.mapError((error) =>
+          failure("invalid_request", `Unable to inspect ${label}: ${errorMessage(error)}`),
+        ),
+      );
+
+  const canonicalRepositoryMetadata = Effect.fn(
+    "OrchestratorMcpService.canonicalRepositoryMetadata",
+  )(function* (input: { readonly detectionCwd: string; readonly metadataPath: string | null }) {
+    if (input.metadataPath === null) return null;
+    return yield* canonicalPath(
+      path.isAbsolute(input.metadataPath)
+        ? input.metadataPath
+        : path.resolve(input.detectionCwd, input.metadataPath),
+      "repository metadata",
+    );
+  });
+
+  const actualGitBranch = Effect.fn("OrchestratorMcpService.actualGitBranch")(function* (
+    handle: VcsDriverRegistry.VcsDriverHandle,
+    cwd: string,
+  ) {
+    const result = yield* handle.driver
+      .execute({
+        operation: "OrchestratorMcpService.actualGitBranch",
+        cwd,
+        args: ["symbolic-ref", "--quiet", "--short", "HEAD"],
+        allowNonZeroExit: true,
+        timeoutMs: 5_000,
+        maxOutputBytes: 16 * 1024,
+      })
+      .pipe(
+        Effect.mapError((error) =>
+          failure("invalid_request", `Unable to read the workspace branch: ${errorMessage(error)}`),
+        ),
+      );
+    const branch = result.exitCode === 0 ? result.stdout.trim() : "";
+    return branch.length === 0 ? null : branch;
+  });
+
+  const inspectLaunchWorkspace = Effect.fn("OrchestratorMcpService.inspectLaunchWorkspace")(
+    function* (project: Project, candidatePath: string, requireWorktreeRoot: boolean) {
+      const projectRepository = yield* detectRepository(project.workspaceRoot, "project root");
+      if (projectRepository === null) {
+        if (requireWorktreeRoot) {
+          return yield* failure(
+            "invalid_request",
+            `Project ${project.id} does not have a repository with linked worktrees.`,
+          );
+        }
+        return {
+          canonicalExecutionPath: yield* canonicalPath(project.workspaceRoot, "project root"),
+          canonicalWorktreeRoot: null,
+          branch: null,
+        } as const;
+      }
+      if (projectRepository.kind !== "git") {
+        return yield* failure(
+          "invalid_request",
+          `Project ${project.id} uses ${projectRepository.kind}; this launch strategy requires Git.`,
+        );
+      }
+
+      const candidateRepository = yield* detectRepository(candidatePath, "workspace path");
+      if (candidateRepository === null || candidateRepository.kind !== "git") {
+        return yield* failure(
+          "invalid_request",
+          `Workspace path '${candidatePath}' is not a Git workspace for project ${project.id}.`,
+        );
+      }
+      const [canonicalCandidate, canonicalCandidateRoot, projectMetadata, candidateMetadata] =
+        yield* Effect.all([
+          canonicalPath(candidatePath, "workspace path"),
+          canonicalPath(candidateRepository.repository.rootPath, "workspace root"),
+          canonicalRepositoryMetadata({
+            detectionCwd: project.workspaceRoot,
+            metadataPath: projectRepository.repository.metadataPath,
+          }),
+          canonicalRepositoryMetadata({
+            detectionCwd: candidatePath,
+            metadataPath: candidateRepository.repository.metadataPath,
+          }),
+        ]);
+      if (
+        (requireWorktreeRoot && canonicalCandidate !== canonicalCandidateRoot) ||
+        projectMetadata === null ||
+        candidateMetadata === null ||
+        projectMetadata !== candidateMetadata
+      ) {
+        return yield* failure(
+          "invalid_request",
+          `Workspace path '${candidatePath}' is not a workspace of project ${project.id}.`,
+        );
+      }
+      return {
+        canonicalExecutionPath: canonicalCandidate,
+        canonicalWorktreeRoot: canonicalCandidateRoot,
+        branch: yield* actualGitBranch(candidateRepository, canonicalCandidate),
+      } as const;
+    },
+  );
+
+  const resolveLaunchWorkspace = Effect.fn("OrchestratorMcpService.resolveLaunchWorkspace")(
+    function* (
+      parent: OrchestrationV2ThreadProjection,
+      project: Project,
+      requested: OrchestratorMcpCreateThreadsInput["threads"][number]["workspaceStrategy"],
+    ): Effect.fn.Return<ThreadLaunch.ThreadLaunchWorkspaceStrategy, OrchestratorMcpFailure> {
+      if (requested?.type === "new_worktree") {
+        return {
+          type: "worktree",
+          baseRef: requested.baseRef,
+          ...(requested.branch === undefined ? {} : { branch: requested.branch }),
+          ...(requested.startFromOrigin === undefined
+            ? {}
+            : { startFromOrigin: requested.startFromOrigin }),
+        };
+      }
+      const explicitExisting = requested?.type === "existing_worktree" ? requested : undefined;
+      const useParentWorktree =
+        requested === undefined &&
+        project.id === parent.thread.projectId &&
+        parent.thread.worktreePath !== null;
+      if (explicitExisting !== undefined || useParentWorktree) {
+        const requestedPath = explicitExisting?.worktreePath ?? parent.thread.worktreePath!;

@@ -181,6 +194,32 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+function threadLaunchPolicyFailure(
+  error: ThreadLaunch.ThreadLaunchError,
+): OrchestratorMcpFailure | null {
+  if (!isOrchestratorDispatchError(error.cause)) return null;
+  const cause = error.cause.cause;
+  if (isRuntimeModeCeilingError(cause)) {
+    return failure(
+      "runtime_mode_escalation_denied",
+      `Child runtime mode ${cause.targetMode} exceeds the caller ceiling (captured ${cause.capturedCallerMode}; current ${cause.currentCallerMode}).`,
+    );
+  }
+  if (isInteractionModeCeilingError(cause)) {
+    return failure(
+      "interaction_mode_escalation_denied",
+      `Child interaction mode ${cause.targetMode} exceeds the caller ceiling (captured ${cause.capturedCallerMode}; current ${cause.currentCallerMode}).`,
+    );
+  }
+  if (isCallerRunCeilingError(cause)) {
+    return failure(
+      "parent_not_active",
+      "Thread creation requires an active run owned by this MCP provider session.",
+    );
+  }
+  return null;

@@ -705,17 +763,219 @@ const make = Effect.gen(function* () {
       .getProjectThread({ projectId, threadId })
       .pipe(Effect.mapError(threadManagementFailure));
 
-  const loadScopedThread = (scope: McpInvocationScope, threadId: ThreadId) =>
+  const resolveProjectId = (
+    parent: OrchestrationV2ThreadProjection,
+    requestedProjectId: ProjectId | undefined,
+  ): Effect.Effect<ProjectId, OrchestratorMcpFailure> =>
+    Effect.gen(function* () {
+      const projectId = requestedProjectId ?? parent.thread.projectId;
+      if (projectId === parent.thread.projectId) return projectId;
+      const project = yield* projects
+        .getById(projectId)
+        .pipe(
+          Effect.mapError((error) =>
+            failure(
+              "orchestration_error",
+              `Unable to read project ${projectId}: ${errorMessage(error)}`,
+            ),
+          ),
+        );
+      if (Option.isNone(project)) {
+        return yield* failure("project_not_found", `Project ${projectId} was not found.`);
+      }
+      return projectId;
+    });
+
+  const loadLaunchProject = (projectId: ProjectId) =>
+    projects.getById(projectId).pipe(
+      Effect.mapError((error) =>
+        failure(
+          "orchestration_error",
+          `Unable to read project ${projectId}: ${errorMessage(error)}`,
+        ),
+      ),
+      Effect.flatMap(
+        Option.match({
+          onNone: () =>
+            Effect.fail(failure("project_not_found", `Project ${projectId} was not found.`)),
+          onSome: Effect.succeed,
+        }),
+      ),
+    );
+
+  const loadScopedThread = (
+    scope: McpInvocationScope,
+    threadId: ThreadId,
+    requestedProjectId?: ProjectId,
+  ) =>
     Effect.gen(function* () {
       yield* requireCapability(scope);
       const parent = yield* loadProjection(scope.threadId);
+      const projectId = yield* resolveProjectId(parent, requestedProjectId);
       const target =
-        threadId === scope.threadId
+        threadId === scope.threadId && projectId === parent.thread.projectId
           ? parent
-          : yield* loadProjectThread(parent.thread.projectId, threadId);
-      return { parent, target } as const;
+          : yield* loadProjectThread(projectId, threadId);
+      return { parent, projectId, target } as const;
     });
 
+  const canonicalPath = (value: string, label: string) =>
+    fileSystem
+      .realPath(value)
+      .pipe(
+        Effect.mapError((error) =>
+          failure("invalid_request", `Unable to resolve ${label}: ${errorMessage(error)}`),
+        ),
+      );
+
+  const detectRepository = (cwd: string, label: string) =>
+    vcsRegistry
+      .detect({ cwd })
+      .pipe(
+        Effect.mapError((error) =>
+          failure("invalid_request", `Unable to inspect ${label}: ${errorMessage(error)}`),
+        ),
+      );
+
+  const canonicalRepositoryMetadata = Effect.fn(
+    "OrchestratorMcpService.canonicalRepositoryMetadata",
+  )(function* (input: { readonly detectionCwd: string; readonly metadataPath: string | null }) {
+    if (input.metadataPath === null) return null;
+    return yield* canonicalPath(
+      path.isAbsolute(input.metadataPath)
+        ? input.metadataPath
+        : path.resolve(input.detectionCwd, input.metadataPath),
+      "repository metadata",
+    );
+  });
+
+  const actualGitBranch = Effect.fn("OrchestratorMcpService.actualGitBranch")(function* (
+    handle: VcsDriverRegistry.VcsDriverHandle,
+    cwd: string,
+  ) {
+    const result = yield* handle.driver
+      .execute({
+        operation: "OrchestratorMcpService.actualGitBranch",
+        cwd,
+        args: ["symbolic-ref", "--quiet", "--short", "HEAD"],
+        allowNonZeroExit: true,
+        timeoutMs: 5_000,
+        maxOutputBytes: 16 * 1024,
+      })
+      .pipe(
+        Effect.mapError((error) =>
+          failure("invalid_request", `Unable to read the workspace branch: ${errorMessage(error)}`),
+        ),
+      );
+    const branch = result.exitCode === 0 ? result.stdout.trim() : "";
+    return branch.length === 0 ? null : branch;
+  });
+
+  const inspectLaunchWorkspace = Effect.fn("OrchestratorMcpService.inspectLaunchWorkspace")(
+    function* (project: Project, candidatePath: string, requireWorktreeRoot: boolean) {
+      const projectRepository = yield* detectRepository(project.workspaceRoot, "project root");
+      if (projectRepository === null) {
+        if (requireWorktreeRoot) {
+          return yield* failure(
+            "invalid_request",
+            `Project ${project.id} does not have a repository with linked worktrees.`,
+          );
+        }
+        return {
+          canonicalExecutionPath: yield* canonicalPath(project.workspaceRoot, "project root"),
+          canonicalWorktreeRoot: null,
+          branch: null,
+        } as const;
+      }
+      if (projectRepository.kind !== "git") {
+        return yield* failure(
+          "invalid_request",
+          `Project ${project.id} uses ${projectRepository.kind}; this launch strategy requires Git.`,
+        );
+      }
+
+      const candidateRepository = yield* detectRepository(candidatePath, "workspace path");
+      if (candidateRepository === null || candidateRepository.kind !== "git") {
+        return yield* failure(
+          "invalid_request",
+          `Workspace path '${candidatePath}' is not a Git workspace for project ${project.id}.`,
+        );
+      }
+      const [canonicalCandidate, canonicalCandidateRoot, projectMetadata, candidateMetadata] =
+        yield* Effect.all([
+          canonicalPath(candidatePath, "workspace path"),
+          canonicalPath(candidateRepository.repository.rootPath, "workspace root"),
+          canonicalRepositoryMetadata({
+            detectionCwd: project.workspaceRoot,
+            metadataPath: projectRepository.repository.metadataPath,
+          }),
+          canonicalRepositoryMetadata({
+            detectionCwd: candidatePath,
+            metadataPath: candidateRepository.repository.metadataPath,
+          }),
+        ]);
+      if (
+        (requireWorktreeRoot && canonicalCandidate !== canonicalCandidateRoot) ||
+        projectMetadata === null ||
+        candidateMetadata === null ||
+        projectMetadata !== candidateMetadata
+      ) {
+        return yield* failure(
+          "invalid_request",
+          `Workspace path '${candidatePath}' is not a workspace of project ${project.id}.`,
+        );
+      }
+      return {
+        canonicalExecutionPath: canonicalCandidate,
+        canonicalWorktreeRoot: canonicalCandidateRoot,
+        branch: yield* actualGitBranch(candidateRepository, canonicalCandidate),
+      } as const;
+    },
+  );
+
+  const resolveLaunchWorkspace = Effect.fn("OrchestratorMcpService.resolveLaunchWorkspace")(
+    function* (
+      parent: OrchestrationV2ThreadProjection,
+      project: Project,
+      requested: OrchestratorMcpCreateThreadsInput["threads"][number]["workspaceStrategy"],
+    ): Effect.fn.Return<ThreadLaunch.ThreadLaunchWorkspaceStrategy, OrchestratorMcpFailure> {
+      if (requested?.type === "new_worktree") {
+        return {
+          type: "worktree",
+          baseRef: requested.baseRef,
+          ...(requested.branch === undefined ? {} : { branch: requested.branch }),
+          ...(requested.startFromOrigin === undefined
+            ? {}
+            : { startFromOrigin: requested.startFromOrigin }),
+        };
+      }
+      const explicitExisting = requested?.type === "existing_worktree" ? requested : undefined;
+      const useParentWorktree =
+        requested === undefined &&
+        project.id === parent.thread.projectId &&
+        parent.thread.worktreePath !== null;
+      if (explicitExisting !== undefined || useParentWorktree) {
+        const requestedPath = explicitExisting?.worktreePath ?? parent.thread.worktreePath!;
+        const workspace = yield* inspectLaunchWorkspace(project, requestedPath, true);
+        return {
+          type: "existing_worktree",
+          worktreePath: workspace.canonicalWorktreeRoot!,
+          ...(workspace.branch === null ? {} : { branch: workspace.branch }),
+          ...(explicitExisting?.branch === undefined
+            ? {}
+            : { expectedBranch: explicitExisting.branch }),
+        };
+      }
+      const workspace = yield* inspectLaunchWorkspace(project, project.workspaceRoot, false);
+      const expectedBranch = requested?.type === "root" ? requested.branch : undefined;
+      return {
+        type: "root",
+        ...(workspace.branch === null ? {} : { branch: workspace.branch }),

@@ -0,0 +1,524 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+import {
+  EnvironmentId,
+  NodeId,
+  ProjectId,
+  ProviderDriverKind,
+  ProviderInstanceId,
+  RunId,
+  ThreadId,
+  type OrchestrationV2ThreadProjection,
+  type Project,
+  type ServerProvider,
+} from "@t3tools/contracts";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Ref from "effect/Ref";
+
+import * as ThreadLaunch from "../orchestration-v2/ThreadLaunchService.ts";
+import { ThreadManagementService } from "../orchestration-v2/ThreadManagementService.ts";
+import * as ProjectService from "../project/ProjectService.ts";
+import { ProviderRegistry } from "../provider/Services/ProviderRegistry.ts";
+import { ScheduledTaskService } from "../scheduledTasks/ScheduledTaskService.ts";
+import * as VcsDriverRegistryModule from "../vcs/VcsDriverRegistry.ts";
+import { VcsDriverRegistry, type VcsDriverHandle } from "../vcs/VcsDriverRegistry.ts";

@@ -1351,14 +1586,21 @@ const make = Effect.gen(function* () {
                 target: request.target,
                 providers,
               });
-              const runtimeMode = yield* resolveRuntimeMode(
+              const runtimeMode = resolveLaunchRuntimeMode(
                 parent.thread.runtimeMode,
                 request.runtimeMode,
               );
-              const interactionMode = yield* resolveInteractionMode(
+              const interactionMode = resolveLaunchInteractionMode(
                 parent.thread.interactionMode,
                 request.interactionMode,
               );

@@ -202,10 +202,35 @@ export const OrchestratorMcpTaskCancelResult = Schema.Struct({
 });
 export type OrchestratorMcpTaskCancelResult = typeof OrchestratorMcpTaskCancelResult.Type;
 
+export const OrchestratorMcpThreadWorkspaceStrategy = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("root"),
+    branch: Schema.optional(TrimmedNonEmptyString),
+  }),
+  Schema.Struct({
+    type: Schema.Literal("existing_worktree"),
+    worktreePath: TrimmedNonEmptyString,

@@ -452,7 +462,30 @@ export const make = Effect.gen(function* () {
               yield* validateReusableThread(input, candidateThreadId);
             }
 
-            const initialBranch = input.workspaceStrategy.branch ?? null;
+            let initialBranch = input.workspaceStrategy.branch ?? null;
+            if (
+              Option.isNone(launchReceipt) &&
+              input.workspaceStrategy.type !== "worktree" &&
+              input.workspaceStrategy.expectedBranch !== undefined
+            ) {
+              const cwd =
+                input.workspaceStrategy.type === "existing_worktree"
+                  ? input.workspaceStrategy.worktreePath
+                  : project.workspaceRoot;
+              const currentBranch = yield* git

@@ -261,31 +262,56 @@ type CreateThreadsInput = {
       driverKind?: string;
       model?: string;
     };
+    projectId?: string;
+    workspaceStrategy?:
+      | { type: "root"; branch?: string }
+      | { type: "existing_worktree"; worktreePath: string; branch?: string }
+      | { type: "new_worktree"; baseRef: string; branch?: string; startFromOrigin?: boolean };
     runtimeMode?: "inherit" | "approval-required" | "auto-accept-edits" | "full-access";
     interactionMode?: "inherit" | "plan" | "default";
   }>;
   clientRequestId?: string;
 };
 ```
 
-Each entry independently resolves provider, model, and modes. The new threads
-inherit the parent's project, branch, and worktree path, but they have no
-sub-agent lineage. Entries with a prompt immediately dispatch a run; entries
-without a prompt remain idle.
+Each entry independently resolves its project, workspace, provider, model, and modes. With no
+`projectId`, a thread uses the parent's project. With no `workspaceStrategy`, a thread in the
+parent's project reuses the parent's checkout, while a thread in another project uses that
+project's root and never inherits the parent's worktree path. An explicit strategy can use the
+project root, register a known existing worktree for the new thread, or ask `ThreadLaunchService`
+to provision a new worktree. Root and existing-worktree launches inspect the checkout before
+launch. A supplied branch is an expected-branch constraint, not a request to switch branches, and
+the call fails when the checkout is detached or on another branch. Existing-worktree paths are
+canonicalized and must resolve to the physical root of a Git worktree belonging to the selected
+project's repository. A root launch still uses the project's configured workspace root, including
+when that execution directory is a subdirectory of the physical Git worktree.
+
+Project selection does not raise the caller's authority. Provider, model, runtime mode, and
+interaction mode still inherit from the caller, and requested modes cannot exceed its permission
+ceiling. Project model and workspace-mode defaults remain client defaults; the MCP request's

@@ -1485,7 +1724,8 @@ const make = Effect.gen(function* () {
                 );
               return {

@@ -704,17 +730,231 @@ const make = Effect.gen(function* () {
       .getProjectThread({ projectId, threadId })
       .pipe(Effect.mapError(threadManagementFailure));
 
-  const loadScopedThread = (scope: McpInvocationScope, threadId: ThreadId) =>
+  const resolveProjectId = (
+    parent: OrchestrationV2ThreadProjection,
+    requestedProjectId: ProjectId | undefined,
+  ): Effect.Effect<ProjectId, OrchestratorMcpFailure> =>
+    Effect.gen(function* () {
+      const projectId = requestedProjectId ?? parent.thread.projectId;
+      if (projectId === parent.thread.projectId) return projectId;
+      const project = yield* projects
+        .getById(projectId)
+        .pipe(
+          Effect.mapError((error) =>
+            failure(
+              "orchestration_error",
+              `Unable to read project ${projectId}: ${errorMessage(error)}`,
+            ),
+          ),
+        );
+      if (Option.isNone(project)) {
+        return yield* failure("project_not_found", `Project ${projectId} was not found.`);
+      }
+      return projectId;
+    });
+
+  const loadLaunchProject = (projectId: ProjectId) =>
+    projects.getById(projectId).pipe(
+      Effect.mapError((error) =>
+        failure(
+          "orchestration_error",
+          `Unable to read project ${projectId}: ${errorMessage(error)}`,
+        ),
+      ),
+      Effect.flatMap(
+        Option.match({
+          onNone: () =>
+            Effect.fail(failure("project_not_found", `Project ${projectId} was not found.`)),
+          onSome: Effect.succeed,
+        }),
+      ),
+    );
+
+  const loadScopedThread = (
+    scope: McpInvocationScope,
+    threadId: ThreadId,
+    requestedProjectId?: ProjectId,
+  ) =>
     Effect.gen(function* () {
       yield* requireCapability(scope);
       const parent = yield* loadProjection(scope.threadId);
+      const projectId = yield* resolveProjectId(parent, requestedProjectId);
       const target =
-        threadId === scope.threadId
+        threadId === scope.threadId && projectId === parent.thread.projectId
           ? parent
-          : yield* loadProjectThread(parent.thread.projectId, threadId);
-      return { parent, target } as const;
+          : yield* loadProjectThread(projectId, threadId);
+      return { parent, projectId, target } as const;
     });
 
+  const canonicalPath = (value: string, label: string) =>
+    fileSystem
+      .realPath(value)
+      .pipe(
+        Effect.mapError((error) =>
+          failure("invalid_request", `Unable to resolve ${label}: ${errorMessage(error)}`),
+        ),
+      );
+
+  const detectRepository = (cwd: string, label: string) =>
+    vcsRegistry
+      .detect({ cwd })
+      .pipe(
+        Effect.mapError((error) =>
+          failure("invalid_request", `Unable to inspect ${label}: ${errorMessage(error)}`),
+        ),
+      );
+
+  const canonicalRepositoryMetadata = Effect.fn(
+    "OrchestratorMcpService.canonicalRepositoryMetadata",
+  )(function* (input: { readonly detectionCwd: string; readonly metadataPath: string | null }) {
+    if (input.metadataPath === null) return null;
+    return yield* canonicalPath(
+      path.isAbsolute(input.metadataPath)
+        ? input.metadataPath
+        : path.resolve(input.detectionCwd, input.metadataPath),
+      "repository metadata",
+    );
+  });
+
+  const actualGitBranch = Effect.fn("OrchestratorMcpService.actualGitBranch")(function* (
+    handle: VcsDriverRegistry.VcsDriverHandle,
+    cwd: string,
+  ) {
+    const result = yield* handle.driver
+      .execute({
+        operation: "OrchestratorMcpService.actualGitBranch",
+        cwd,
+        args: ["symbolic-ref", "--quiet", "--short", "HEAD"],
+        allowNonZeroExit: true,
+        timeoutMs: 5_000,
+        maxOutputBytes: 16 * 1024,
+      })
+      .pipe(
+        Effect.mapError((error) =>
+          failure("invalid_request", `Unable to read the workspace branch: ${errorMessage(error)}`),
+        ),
+      );
+    const branch = result.exitCode === 0 ? result.stdout.trim() : "";
+    return branch.length === 0 ? null : branch;
+  });
+
+  const inspectLaunchWorkspace = Effect.fn("OrchestratorMcpService.inspectLaunchWorkspace")(
+    function* (project: Project, candidatePath: string, requireWorktreeRoot: boolean) {
+      const projectRepository = yield* detectRepository(project.workspaceRoot, "project root");
+      if (projectRepository === null) {
+        if (requireWorktreeRoot) {
+          return yield* failure(
+            "invalid_request",
+            `Project ${project.id} does not have a repository with linked worktrees.`,
+          );
+        }
+        return {
+          canonicalExecutionPath: yield* canonicalPath(project.workspaceRoot, "project root"),
+          canonicalWorktreeRoot: null,
+          branch: null,
+        } as const;
+      }
+      if (projectRepository.kind !== "git") {
+        return yield* failure(
+          "invalid_request",
+          `Project ${project.id} uses ${projectRepository.kind}; this launch strategy requires Git.`,
+        );
+      }
+
+      const candidateRepository = yield* detectRepository(candidatePath, "workspace path");
+      if (candidateRepository === null || candidateRepository.kind !== "git") {
+        return yield* failure(
+          "invalid_request",
+          `Workspace path '${candidatePath}' is not a Git workspace for project ${project.id}.`,
+        );
+      }
+      const [canonicalCandidate, canonicalCandidateRoot, projectMetadata, candidateMetadata] =
+        yield* Effect.all([
+          canonicalPath(candidatePath, "workspace path"),
+          canonicalPath(candidateRepository.repository.rootPath, "workspace root"),
+          canonicalRepositoryMetadata({
+            detectionCwd: project.workspaceRoot,
+            metadataPath: projectRepository.repository.metadataPath,
+          }),
+          canonicalRepositoryMetadata({
+            detectionCwd: candidatePath,
+            metadataPath: candidateRepository.repository.metadataPath,
+          }),
+        ]);
+      if (
+        (requireWorktreeRoot && canonicalCandidate !== canonicalCandidateRoot) ||
+        projectMetadata === null ||
+        candidateMetadata === null ||
+        projectMetadata !== candidateMetadata
+      ) {
+        return yield* failure(
+          "invalid_request",
+          `Workspace path '${candidatePath}' is not a workspace of project ${project.id}.`,
+        );
+      }
+      return {
+        canonicalExecutionPath: canonicalCandidate,
+        canonicalWorktreeRoot: canonicalCandidateRoot,
+        branch: yield* actualGitBranch(candidateRepository, canonicalCandidate),
+      } as const;
+    },
+  );
+
+  const enforceExpectedBranch = (
+    expected: string | undefined,
+    actual: string | null,
+    cwd: string,
+  ): Effect.Effect<void, OrchestratorMcpFailure> =>
+    expected === undefined || expected === actual
+      ? Effect.void
+      : Effect.fail(
+          failure(
+            "invalid_request",
+            `Workspace '${cwd}' is on ${actual === null ? "a detached HEAD" : `branch '${actual}'`}, not requested branch '${expected}'.`,
+          ),
+        );
+
+  const resolveLaunchWorkspace = Effect.fn("OrchestratorMcpService.resolveLaunchWorkspace")(
+    function* (
+      parent: OrchestrationV2ThreadProjection,
+      project: Project,
+      requested: OrchestratorMcpCreateThreadsInput["threads"][number]["workspaceStrategy"],
+    ): Effect.fn.Return<ThreadLaunch.ThreadLaunchWorkspaceStrategy, OrchestratorMcpFailure> {
+      if (requested?.type === "new_worktree") {
+        return {
+          type: "worktree",
+          baseRef: requested.baseRef,
+          ...(requested.branch === undefined ? {} : { branch: requested.branch }),
+          ...(requested.startFromOrigin === undefined
+            ? {}
+            : { startFromOrigin: requested.startFromOrigin }),
+        };
+      }
+      const explicitExisting = requested?.type === "existing_worktree" ? requested : undefined;
+      const useParentWorktree =
+        requested === undefined &&
+        project.id === parent.thread.projectId &&
+        parent.thread.worktreePath !== null;
+      if (explicitExisting !== undefined || useParentWorktree) {
+        const requestedPath = explicitExisting?.worktreePath ?? parent.thread.worktreePath!;
+        const workspace = yield* inspectLaunchWorkspace(project, requestedPath, true);
+        yield* enforceExpectedBranch(explicitExisting?.branch, workspace.branch, requestedPath);
+        return {
+          type: "existing_worktree",
+          worktreePath: workspace.canonicalWorktreeRoot!,
+          ...(workspace.branch === null ? {} : { branch: workspace.branch }),
+        };
+      }
+      const workspace = yield* inspectLaunchWorkspace(project, project.workspaceRoot, false);
+      const expectedBranch = requested?.type === "root" ? requested.branch : undefined;
+      yield* enforceExpectedBranch(expectedBranch, workspace.branch, project.workspaceRoot);

@@ -1341,139 +1625,192 @@ const make = Effect.gen(function* () {
           );
         }
         const parentNodeId = parentRun.rootNodeId;
-        const providers = yield* loadProviders;
         const key = yield* requestKey(input.clientRequestId);
         const created = yield* Effect.forEach(
           input.threads,
           (request, index) =>
             Effect.gen(function* () {
-              const target = yield* resolveTarget({
-                parent,
-                target: request.target,
-                providers,
-              });
-              const runtimeMode = yield* resolveRuntimeMode(
-                parent.thread.runtimeMode,
-                request.runtimeMode,
-              );
-              const interactionMode = yield* resolveInteractionMode(
-                parent.thread.interactionMode,
-                request.interactionMode,
-              );
-              const threadId = stableThreadId({
+              const projectId = yield* resolveProjectId(parent, request.projectId);
+              const commandId = stableCommandId({
                 scope,
                 requestKey: key,
+                operation: "create-thread",
                 index,
               });
-              const title = threadTitle({
-                parentTitle: parent.thread.title,
-                prompt: request.prompt,
-                title: request.title,
-                index,
-              });
-              const createCommandId = stableCommandId({
+              const threadId = stableThreadId({
                 scope,
                 requestKey: key,
-                operation: "create-thread",
                 index,
               });
-              const createCommand = {
-                type: "thread.create",
-                createdBy: "agent",
-                creationSource: "mcp",
-                commandId: createCommandId,
-                threadId,
-                projectId: parent.thread.projectId,
-                title,
-                modelSelection: target.modelSelection,
-                runtimeMode,
-                interactionMode,
-                branch: parent.thread.branch,
-                worktreePath: parent.thread.worktreePath,
-              } as const;
-              yield* threadManagement
-                .withProjectCreationAdmission(
-                  { projectId: parent.thread.projectId, commandId: createCommandId },
-                  (receipt) =>
-                    Effect.gen(function* () {
-                      if (Option.isNone(receipt)) {
-                        const freshParent = yield* loadProjection(scope.threadId);
-                        const freshParentRun = latestActiveRun(freshParent);
-                        if (
-                          freshParent.thread.projectId !== parent.thread.projectId ||
-                          freshParent.thread.deletedAt !== null ||
-                          freshParent.thread.archivedAt !== null ||
-                          freshParentRun === undefined ||
-                          freshParentRun.rootNodeId === null ||
-                          freshParentRun.providerInstanceId !== scope.providerInstanceId
-                        ) {
-                          return yield* failure(
-                            "parent_not_active",
-                            "Thread creation requires an active parent in the target project.",
-                          );
-                        }
-                      }
-                      return yield* threadManagement.dispatch(createCommand);
-                    }),
+              const initialMessageId = stableMessageId({ scope, requestKey: key, index });
+              const launchReceipt = yield* threadManagement
+                .withProjectCreationAdmission({ projectId, commandId }, (receipt) =>
+                  Effect.succeed(receipt),
                 )
                 .pipe(
-                  Effect.mapError((error) =>
-                    isOrchestratorMcpFailure(error)
-                      ? error
-                      : failure(
-                          "orchestration_error",
-                          `Unable to create thread ${index + 1}: ${errorMessage(error)}`,
-                        ),
+                  Effect.mapError(() =>
+                    failure(
+                      "orchestration_error",
+                      `Unable to read the accepted launch for thread ${index + 1}.`,

@@ -70,7 +75,9 @@ import {
   ThreadManagementService,
 } from "../orchestration-v2/ThreadManagementService.ts";
 import { ProviderRegistry } from "../provider/Services/ProviderRegistry.ts";
+import * as ProjectService from "../project/ProjectService.ts";
 import { ScheduledTaskService } from "../scheduledTasks/ScheduledTaskService.ts";
+import { VcsDriverRegistry, type VcsDriverHandle } from "../vcs/VcsDriverRegistry.ts";

@@ -1370,107 +1638,72 @@ const make = Effect.gen(function* () {
                 title: request.title,
                 index,
               });
-              const createCommandId = stableCommandId({
-                scope,
-                requestKey: key,
-                operation: "create-thread",
-                index,
-              });
-              const createCommand = {
-                type: "thread.create",
-                createdBy: "agent",
-                creationSource: "mcp",
-                commandId: createCommandId,
-                threadId,
-                projectId: parent.thread.projectId,
-                title,
-                modelSelection: target.modelSelection,
-                runtimeMode,
-                interactionMode,
-                branch: parent.thread.branch,
-                worktreePath: parent.thread.worktreePath,
-              } as const;
-              yield* threadManagement
-                .withProjectCreationAdmission(
-                  { projectId: parent.thread.projectId, commandId: createCommandId },
-                  (receipt) =>
-                    Effect.gen(function* () {
-                      if (Option.isNone(receipt)) {
-                        const freshParent = yield* loadProjection(scope.threadId);
-                        const freshParentRun = latestActiveRun(freshParent);
-                        if (
-                          freshParent.thread.projectId !== parent.thread.projectId ||
-                          freshParent.thread.deletedAt !== null ||
-                          freshParent.thread.archivedAt !== null ||
-                          freshParentRun === undefined ||
-                          freshParentRun.rootNodeId === null ||
-                          freshParentRun.providerInstanceId !== scope.providerInstanceId
-                        ) {
-                          return yield* failure(
-                            "parent_not_active",
-                            "Thread creation requires an active parent in the target project.",
-                          );
-                        }
-                      }
-                      return yield* threadManagement.dispatch(createCommand);
-                    }),
-                )
+              const launched = yield* threadLaunch

@@ -1370,107 +1638,72 @@ const make = Effect.gen(function* () {
                 title: request.title,
                 index,
               });
-              const createCommandId = stableCommandId({
-                scope,
-                requestKey: key,
-                operation: "create-thread",
-                index,
-              });
-              const createCommand = {
-                type: "thread.create",
-                createdBy: "agent",
-                creationSource: "mcp",
-                commandId: createCommandId,
-                threadId,
-                projectId: parent.thread.projectId,
-                title,
-                modelSelection: target.modelSelection,
-                runtimeMode,
-                interactionMode,
-                branch: parent.thread.branch,
-                worktreePath: parent.thread.worktreePath,
-              } as const;
-              yield* threadManagement
-                .withProjectCreationAdmission(
-                  { projectId: parent.thread.projectId, commandId: createCommandId },
-                  (receipt) =>
-                    Effect.gen(function* () {
-                      if (Option.isNone(receipt)) {
-                        const freshParent = yield* loadProjection(scope.threadId);
-                        const freshParentRun = latestActiveRun(freshParent);
-                        if (
-                          freshParent.thread.projectId !== parent.thread.projectId ||
-                          freshParent.thread.deletedAt !== null ||
-                          freshParent.thread.archivedAt !== null ||
-                          freshParentRun === undefined ||
-                          freshParentRun.rootNodeId === null ||
-                          freshParentRun.providerInstanceId !== scope.providerInstanceId
-                        ) {
-                          return yield* failure(
-                            "parent_not_active",
-                            "Thread creation requires an active parent in the target project.",
-                          );
-                        }
-                      }
-                      return yield* threadManagement.dispatch(createCommand);
-                    }),
-                )
+              const launched = yield* threadLaunch
+                .launch({
+                  commandId: stableCommandId({
+                    scope,
+                    requestKey: key,
+                    operation: "create-thread",
+                    index,
+                  }),
+                  threadId,
+                  projectId,
+                  title,
+                  modelSelection: target.modelSelection,
+                  runtimeMode,
+                  interactionMode,
+                  policyCeiling: {
+                    callerThreadId: scope.threadId,
+                    runtimeMode: parent.thread.runtimeMode,
+                    interactionMode: parent.thread.interactionMode,
+                  },
+                  workspaceStrategy,
+                  ...(request.prompt === undefined
+                    ? {}
+                    : {
+                        initialMessage: {
+                          messageId: stableMessageId({ scope, requestKey: key, index }),
+                          text: request.prompt,
+                          attachments: [],
+                        },
+                      }),
+                  createdBy: "agent",
+                  creationSource: "mcp",
+                })
                 .pipe(
-                  Effect.mapError((error) =>
-                    failure(
-                      "orchestration_error",
-                      `Unable to create thread ${index + 1}: ${errorMessage(error)}`,
-                    ),
+                  Effect.mapError(
+                    (error) =>
+                      threadLaunchPolicyFailure(error) ??
+                      failure(
+                        "orchestration_error",
+                        `Unable to launch thread ${index + 1}: ${errorMessage(error)}`,
+                      ),

@@ -202,10 +202,35 @@ export const OrchestratorMcpTaskCancelResult = Schema.Struct({
 });
 export type OrchestratorMcpTaskCancelResult = typeof OrchestratorMcpTaskCancelResult.Type;
 
+export const OrchestratorMcpThreadWorkspaceStrategy = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("root"),
+    branch: Schema.optional(TrimmedNonEmptyString),
+  }),
+  Schema.Struct({
+    type: Schema.Literal("existing_worktree"),
+    worktreePath: TrimmedNonEmptyString,
+    branch: Schema.optional(TrimmedNonEmptyString),
+  }),
+  Schema.Struct({
+    type: Schema.Literal("new_worktree"),
+    baseRef: TrimmedNonEmptyString,
+    branch: Schema.optional(TrimmedNonEmptyString),
+    startFromOrigin: Schema.optional(Schema.Boolean),
+  }),
+]).annotate({
+  description:
+    "Workspace for the new thread. Omit to reuse the caller's checkout in the current project, or the target project's root when projectId selects another project.",
+});