feat(cli): move a thread into another project

apps/server/scripts/acp-mock-agent.ts

@@ -82,6 +82,8 @@ const exitAfterRunningCommandLaunch = process.env.T3_ACP_EXIT_AFTER_RUNNING_COMM
 const omitXAiPromptCompleteStopReason =
   process.env.T3_ACP_OMIT_XAI_PROMPT_COMPLETE_STOP_REASON === "1";
 const failLoadSession = process.env.T3_ACP_FAIL_LOAD_SESSION === "1";
+// Advertise no session capabilities, so the agent can neither load nor resume.
+const omitSessionCapabilities = process.env.T3_ACP_OMIT_SESSION_CAPABILITIES === "1";
 const failLoadSessionAfterConfigReplay =
   process.env.T3_ACP_FAIL_LOAD_SESSION_AFTER_CONFIG_REPLAY === "1";
 const emitLoadReplay = process.env.T3_ACP_EMIT_LOAD_REPLAY === "1";
@@ -127,7 +129,11 @@ const permissionRequestCount = Math.max(
   1,
   Number(process.env.T3_ACP_PERMISSION_REQUEST_COUNT ?? "1") || 1,
 );
-const sessionId = "mock-session-1";
+// Real agents mint a new id for every session/new. The fixed id is the default
+// because most tests assert it; set T3_ACP_UNIQUE_SESSION_IDS=1 to get a fresh
+// id per process, as a real agent that cannot reopen sessions would.
+const sessionId =
+  process.env.T3_ACP_UNIQUE_SESSION_IDS === "1" ? `mock-session-${process.pid}` : "mock-session-1";
 
 let currentModeId = antigravityProfile ? "default" : "ask";
 let currentModelId = antigravityProfile ? "gemini-test-low" : "default";
@@ -578,11 +584,15 @@ const program = Effect.gen(function* () {
         info: { name: "t3-acp-mock-agent", version: "0.0.0" },
         ...(omitInitializeModelState ? {} : { _meta: { modelState: modelState() } }),
         capabilities: {
-          session: {
-            ...(supportsSessionLifecycle ? { fork: {}, additionalDirectories: {} } : {}),
-            ...(supportsV2Management ? { delete: {} } : {}),
-            ...(supportsAcpMcp ? { mcp: { acp: {} } } : {}),
-          },
+          ...(omitSessionCapabilities
+            ? {}
+            : {
+                session: {
+                  ...(supportsSessionLifecycle ? { fork: {}, additionalDirectories: {} } : {}),
+                  ...(supportsV2Management ? { delete: {} } : {}),
+                  ...(supportsAcpMcp ? { mcp: { acp: {} } } : {}),
+                },
+              }),
           ...(supportsV2Management ? { providers: {} } : {}),
         },
         ...(initializeAuthMethodId

apps/server/src/cli/thread.test.ts

@@ -1,8 +1,8 @@
 import { assert, it } from "@effect/vitest";
-import { RunId, ThreadId } from "@t3tools/contracts";
+import { ProjectId, RunId, ThreadId } from "@t3tools/contracts";
 import * as Effect from "effect/Effect";
 
-import { type ThreadTools, waitForRun } from "./thread.ts";
+import { moveThread, ThreadToolFailedError, type ThreadTools, waitForRun } from "./thread.ts";
 
 const threadId = ThreadId.make("thread-1");
 const runId = RunId.make("run-1");
@@ -73,3 +73,30 @@ it.effect("--wait reports its run's result when a later run is the one waiting",
     });
   }),
 );
+
+it.effect("move names the --keep-worktree flag when the server refuses a worktree", () =>
+  Effect.gen(function* () {
+    const calls: Array<unknown> = [];
+    const call = ((tool: string, args: unknown) => {
+      calls.push(args);
+      return Effect.fail(
+        new ThreadToolFailedError({
+          tool,
+          detail: `Unable to move_project for thread ${threadId}: Thread ${threadId} has a worktree at /work/tree. Pass keepWorktree to move it without changing that checkout.`,
+        }),
+      );
+    }) as ThreadTools["call"];
+
+    const error = yield* Effect.flip(
+      moveThread({ call }, threadId, ProjectId.make("project-2"), false),
+    );
+
+    assert.strictEqual(
+      error.message,
+      `Unable to move_project for thread ${threadId}: Thread ${threadId} has a worktree at /work/tree. Pass --keep-worktree to move it without changing that checkout.`,
+    );
+    assert.deepStrictEqual(calls, [
+      { threadId, action: "move_project", projectId: ProjectId.make("project-2") },
+    ]);
+  }),
+);

apps/server/src/cli/thread.ts

@@ -163,6 +163,16 @@ const ThreadLaunchResult = Schema.Struct({
   runId: Schema.NullOr(RunId),
 });
 
+const ThreadMoveResult = Schema.Struct({
+  threadId: ThreadId,
+  projectId: ProjectId,
+  worktreePath: Schema.NullOr(Schema.String),
+  /** Set when a No project chat moved out; its files stay in this folder. */
+  scratchFolder: Schema.optional(Schema.String),
+  /** Set when the thread's own agent ran this mid-turn; the move applies at turn end. */
+  movesWhenTurnEnds: Schema.optional(Schema.Literal(true)),
+});
+
 const toolFailureDetail = (result: typeof ToolResult.Type) => {
   const text = result.content?.find((part) => part.text !== undefined)?.text ?? "";
   return Option.match(decodeFailureText(text), {
@@ -699,12 +709,88 @@ const threadShowCommand = Command.make("show", {
   ),
 );
 
+const keepWorktreeFlag = Flag.Boolean("keep-worktree").pipe(
+  Flag.withDescription(
+    "Move a thread that has a worktree and leave that checkout in place. The next turn still runs there. A No project chat does not need it: its scratch folder stays on disk and the next turn starts in the destination.",
+  ),
+  Flag.withDefault(false),
+);
+
+/**
+ * The server names the MCP argument (`keepWorktree`) when it refuses a
+ * worktree; from the CLI that argument is the `--keep-worktree` flag.
+ */
+export const moveThread = (
+  tools: ThreadTools,
+  threadId: ThreadId,
+  projectId: ProjectId,
+  keepWorktree: boolean,
+) =>
+  tools
+    .call(
+      "t3_thread_update",
+      {
+        threadId,
+        action: "move_project",
+        projectId,
+        ...(keepWorktree ? { keepWorktree: true } : {}),
+      },
+      ThreadMoveResult,
+    )
+    .pipe(
+      Effect.mapError((error) =>
+        error._tag === "ThreadToolFailedError"
+          ? new ThreadToolFailedError({
+              tool: error.tool,
+              detail: error.detail.replace("Pass keepWorktree", "Pass --keep-worktree"),
+            })
+          : error,
+      ),
+    );
+
+const threadMoveCommand = Command.make("move", {
+  ...projectLocationFlags,
+  thread: threadArgument,
+  project: Argument.String("project").pipe(
+    Argument.withDescription("Destination project id or a path inside that project."),
+  ),
+  keepWorktree: keepWorktreeFlag,
+  json: jsonFlag,
+}).pipe(
+  Command.withDescription(
+    "Move an idle thread into another project. Refuses a turn in progress, a subagent, a thread that still has a subagent, or a worktree unless --keep-worktree. A No project chat leaves its scratch folder behind, undeleted.",
+  ),
+  Command.withHandler((flags) =>
+    Effect.gen(function* () {
+      const threadId = yield* decodeThreadId(flags.thread);
+      yield* withThreadTools(
+        flags,
+        Effect.fn("cli.thread.move")(function* (tools) {
+          const project = yield* resolveProject(tools, flags.project);
+          const moved = yield* moveThread(tools, threadId, project.id, flags.keepWorktree);
+          yield* flags.json
+            ? printJson(moved)
+            : Console.log(
+                [
+                  `${moved.threadId}  ${moved.projectId}${moved.movesWhenTurnEnds === true ? "  (moves when this turn ends)" : ""}`,
+                  ...(moved.scratchFolder === undefined
+                    ? []
+                    : [`Earlier files stay in ${moved.scratchFolder}`]),
+                ].join("\n"),
+              );
+        }),
+      );
+    }).pipe(reportThreadErrors),
+  ),
+);
+
 export const threadCommand = Command.make("thread").pipe(
-  Command.withDescription("Start, message, and read threads on the running server."),
+  Command.withDescription("Start, message, read, and move threads on the running server."),
   Command.withSubcommands([
     threadListCommand,
     threadStartCommand,
     threadSendCommand,
     threadShowCommand,
+    threadMoveCommand,
   ]),
 );

apps/server/src/environment/ServerEnvironment.test.ts

@@ -220,6 +220,7 @@ it.layer(NodeServices.layer)("ServerEnvironmentLive", (it) => {
       expect(second.capabilities.usagePriceOverrides).toBe(true);
       expect(second.capabilities.threadActiveReorder).toBe(true);
       expect(second.capabilities.threadTitleRegeneration).toBe(true);
+      expect(second.capabilities.threadProjectMove).toBe(true);
       expect(second.capabilities.threadPullRequests).toBe(true);
       expect(second.capabilities.threadPullRequestLinking).toBe(true);
       expect(second.capabilities.serverResolvedCommandContext).toBe(true);

apps/server/src/environment/ServerEnvironment.ts

@@ -247,6 +247,7 @@ export const make = Effect.gen(function* () {
       threadActiveReorder: true,
       threadAutoSettleOptOut: true,
       threadTitleRegeneration: true,
+      threadProjectMove: true,
       commandOutputStreaming: true,
       threadVisitedTracking: true,
       threadPullRequests: true,

apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts

@@ -44,12 +44,16 @@ import * as ProjectService from "../project/ProjectService.ts";
 import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
 import * as SecretRequests from "../secrets/SecretRequests.ts";
 import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
+import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts";
 import * as McpHttpServer from "./McpHttpServer.ts";
 import * as McpInvocationContext from "./McpInvocationContext.ts";
 
 const layerOrchestratorToolkit = McpHttpServer.layerOrchestratorToolkit.pipe(
   Layer.provide(Layer.mock(ThreadLaunchService.ThreadLaunchService)({})),
   Layer.provide(Layer.mock(GitVcsDriver.GitVcsDriver)({})),
+  Layer.provide(
+    Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ namedProjectsRoot: "/unused" }),
+  ),
 );
 
 // Effect returns a declared tool failure as `isError` with its encoded payload