Commit 477282263a9115f911380b5aec7d4973267e4edc | the-knife

apps/mobile/src/features/threads/ThreadDetailScreen.tsx+14-5

 @@ -173,9 +173,15 @@ export interface ThreadDetailScreenProps {
    * The server has not created this thread yet. "preparing" runs while the
    * queued creation is delivered (a worktree may be checking out); "failed"
    * is a rejected creation whose content went back to the project draft.
+   * `serverOwned` marks a thread the server already created that is still
+   * setting up its worktree; follow-ups queue on the server behind that setup.
    */
   readonly creationState:
-    | { readonly kind: "preparing"; readonly preparingWorktree: boolean }
+    | {
+        readonly kind: "preparing";
+        readonly preparingWorktree: boolean;
+        readonly serverOwned: boolean;
+      }
     | { readonly kind: "failed"; readonly reason: string; readonly onEditTask: () => void }
     | null;
   readonly activePendingApproval: PendingApproval | null;
 @@ -1439,11 +1445,14 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
                         canStopThread={props.canStopThread}
                         environmentId={props.environmentId}
                         projectCwd={props.threadCwd ?? props.projectWorkspaceRoot}
-                        // Follow-ups typed during setup wait in the draft: queueing
+                        // Follow-ups typed before the server creates the thread wait in
-                        // them against a thread id the server may still reject
+                        // the draft: queueing them against a thread id the server may
-                        // would strand them in the outbox.
+                        // still reject would strand them in the outbox.
                         sendBlockedReason={
-                          props.creationState?.kind === "preparing" ? "Starting the task…" : null
+                          props.creationState?.kind === "preparing" &&
+                          !props.creationState.serverOwned
+                            ? "Starting the task…"
+                            : null
                         }
                         draftKey={props.composerDraftKey ?? undefined}
                         followUpBehavior={props.followUpBehavior}

apps/mobile/src/features/threads/ThreadRouteScreen.tsx+4-1

...	@@ -889,7 +889,9 @@ function ThreadRouteContent(	...	@@ -889,7 +889,9 @@ function ThreadRouteContent(
889	]);	889	]);
890	const creationState = ((): ThreadDetailScreenProps["creationState"] => {	890	const creationState = ((): ThreadDetailScreenProps["creationState"] => {
891	if (selectedThreadCreation === null) {	891	if (selectedThreadCreation === null) {
892	return awaitingBootstrapTurn ? { kind: "preparing", preparingWorktree: true } : null;	892	return awaitingBootstrapTurn
		893	? { kind: "preparing", preparingWorktree: true, serverOwned: true }
		894	: null;
893	}	895	}
894	if (selectedThreadCreation.outcome?.kind === "failed") {	896	if (selectedThreadCreation.outcome?.kind === "failed") {
895	return {	897	return {
...	@@ -901,6 +903,7 @@ function ThreadRouteContent(	...	@@ -901,6 +903,7 @@ function ThreadRouteContent(
901	return {	903	return {
902	kind: "preparing",	904	kind: "preparing",
903	preparingWorktree: selectedThreadCreation.message.creation?.workspaceMode === "worktree",	905	preparingWorktree: selectedThreadCreation.message.creation?.workspaceMode === "worktree",
		906	serverOwned: false,
904	};	907	};
905	})();	908	})();
906	if (!environmentId \|\| !threadId) {	909	if (!environmentId \|\| !threadId) {

apps/mobile/src/state/use-thread-composer-state.ts+16-2

...	@@ -677,8 +677,20 @@ export function useThreadComposerState() {	...	@@ -677,8 +677,20 @@ export function useThreadComposerState() {
677	alternateModifier: followUpOverride !== undefined && followUpOverride !== followUpBehavior,	677	alternateModifier: followUpOverride !== undefined && followUpOverride !== followUpBehavior,
678	activeTurnDefault: followUpBehavior,	678	activeTurnDefault: followUpBehavior,
679	});	679	});
680	const followUpDispatchMode =	680	// A send while the worktree is still being set up waits behind that setup,
681	followUpAction === "auto" ? null : followUpAction === "queue" ? "queue" : "auto";	681	// so the server can hold it if the setup ends without a worktree.
		682	// Before detail loads, the shell's latest run can be a queued follow-up
		683	// while its runtime still reports the setup.
		684	const setupRunning = [selectedThreadActivityRun?.status, selectedThreadRuntime?.status].some(
		685	(status) => status === "preparing" \|\| status === "starting",
		686	);
		687	const followUpDispatchMode = setupRunning
		688	? "queue"
		689	: followUpAction === "auto"
		690	? null
		691	: followUpAction === "queue"
		692	? "queue"
		693	: "auto";
682		694
683	const metadata = makeQueuedMessageMetadata();	695	const metadata = makeQueuedMessageMetadata();
684	const messageId = MessageId.make(metadata.messageId);	696	const messageId = MessageId.make(metadata.messageId);
...	@@ -735,7 +747,9 @@ export function useThreadComposerState() {	...	@@ -735,7 +747,9 @@ export function useThreadComposerState() {
735	saveQueuedRunEdit,	747	saveQueuedRunEdit,
736	selectedEnvironmentRuntime?.connectionState,	748	selectedEnvironmentRuntime?.connectionState,
737	selectedEnvironmentRuntime?.serverConfig,	749	selectedEnvironmentRuntime?.serverConfig,
		750	selectedThreadActivityRun?.status,
738	selectedThreadCreation,	751	selectedThreadCreation,
		752	selectedThreadRuntime?.status,
739	selectedThreadShell,	753	selectedThreadShell,
740	uploadThreadFeedback,	754	uploadThreadFeedback,
741	],	755	],

apps/server/src/orchestration-v2/Orchestrator.ts+54-11

 @@ -1269,7 +1269,10 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
       ]);
     });
-  const startNextQueuedRun = (threadId: ThreadId, options?: { readonly failedRunId?: RunId }) =>
+  const startNextQueuedRun = (
+    threadId: ThreadId,
+    options?: { readonly failedRunId?: RunId; readonly endedRunId?: RunId },
+  ) =>
     Effect.gen(function* () {
       // Every terminal run checks the queue. Only a deliverable queued run
       // needs the transcript for provider handoff and legacy import context.
 @@ -1304,15 +1307,22 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
       // Hold the queue so the user decides when to resume it. Validation
       // failures (setup, unsupported handoff) belong to that message alone,
       // and a message queued for another provider is how users recover.
+      // A message queued behind a worktree that was cancelled or never created
+      // would run in the project checkout instead, so it waits for the user.
       const failedRun = latestExecutedRun(projection.runs);
       const failureClass =
         failedRun?.id === options?.failedRunId
           ? latestRootProviderFailure(failedRun, projection.turnItems)?.class
           : undefined;
+      const worktreeMissing =
+        failedRun?.id === options?.endedRunId &&
+        failedRun?.workspacePreparation?.type === "worktree" &&
+        projection.thread.worktreePath === null;
       if (
-        failureClass !== undefined &&
+        worktreeMissing ||
-        failureClass !== "validation_error" &&
+        (failureClass !== undefined &&
-        failedRun?.providerInstanceId === queuedRun.providerInstanceId
+          failureClass !== "validation_error" &&
+          failedRun?.providerInstanceId === queuedRun.providerInstanceId)
       ) {
         const now = yield* DateTime.now;
         yield* writeSystemEvents(
 @@ -4871,9 +4881,22 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         (candidate) => candidate.id === projection.thread.activeProviderThreadId,
       );
       const activeRun = projection.runs.find(isBlockingRun);
+      // A message queued during worktree setup can arrive after that setup failed
+      // without a worktree. It waits, held, like the messages queued before the
+      // failure, instead of starting in the project checkout.
+      const latestRun = latestExecutedRun(projection.runs);
+      const worktreeMissingRun =
+        activeRun === undefined &&
+        dispatchMode.type === "queue_after_active" &&
+        (latestRun?.status === "failed" || latestRun?.status === "interrupted") &&
+        latestRun.workspacePreparation?.type === "worktree" &&
+        projection.thread.worktreePath === null
+          ? latestRun
+          : undefined;
+      const queueBehindRun = activeRun ?? worktreeMissingRun;
       const pendingMergeBackTransfers = pendingMergeBackTransfersForThread(projection);
       const shouldQueue =
-        activeRun !== undefined &&
+        queueBehindRun !== undefined &&
         (dispatchMode.type === "defer_start" ||
           dispatchMode.type === "start_immediately" ||
           dispatchMode.type === "queue_after_active");
 @@ -4888,13 +4911,13 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         const queueProviderThread =
           activeProviderThread ??
           projection.providerThreads.find(
-            (candidate) => candidate.id === activeRun.providerThreadId,
+            (candidate) => candidate.id === queueBehindRun.providerThreadId,
           );
         if (queueProviderThread === undefined) {
           return yield* new OrchestratorDispatchError({
             commandId: command.commandId,
             commandType: command.type,
-            cause: `Active run ${activeRun.id} has no provider thread for queued dispatch.`,
+            cause: `Active run ${queueBehindRun.id} has no provider thread for queued dispatch.`,
           });
         }
         const now = yield* DateTime.now;
 @@ -4948,7 +4971,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         const attemptId = idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 });
         const rootNodeId = idAllocator.derive.rootNode({ runId });
         const checkpointScope =
-          activeRun.status === "preparing"
+          queueBehindRun.status === "preparing" || worktreeMissingRun !== undefined
             ? null
             : yield* runtimePolicy.resolve({ thread: projection.thread, modelSelection }).pipe(
                 Effect.flatMap((resolvedRuntimePolicy) =>
 @@ -4985,7 +5008,8 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
           rootNodeId,
           activeAttemptId: attemptId,
           status: "queued",
-          ...(projection.runs.some(
+          ...(worktreeMissingRun !== undefined ||
+          projection.runs.some(
             (candidate) => candidate.status === "queued" && candidate.queueHeld === true,
           )
             ? { queueHeld: true }
 @@ -8292,6 +8316,20 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         type: "run.updated",
         payload: { ...state.run, status: "preparing", completedAt: null },
       });
+      // Messages held when this preparation failed follow the run again. A hold
+      // from a later run (a stop, say) is not this failure's to release.
+      const failureOwnsQueue = latestExecutedRun(projection.runs)?.id === state.run.id;
+      for (const run of projection.runs) {
+        if (!failureOwnsQueue || run.status !== "queued" || run.queueHeld !== true) continue;
+        yield* emitEvent({
+          type: "run.updated",
+          threadId: command.threadId,
+          runId: run.id,
+          providerInstanceId: run.providerInstanceId,
+          occurredAt: now,
+          payload: { ...run, queueHeld: false },
+        });
+      }
     });
   /**
 @@ -11056,8 +11094,13 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
           threadId,
           startNextQueuedRun(
             threadId,
-            stored.event.type === "run.updated" && stored.event.payload.status === "failed"
+            stored.event.type === "run.updated"
-              ? { failedRunId: stored.event.payload.id }
+              ? {
+                  endedRunId: stored.event.payload.id,
+                  ...(stored.event.payload.status === "failed"
+                    ? { failedRunId: stored.event.payload.id }
+                    : {}),
+                }
               : undefined,
           ),
         )

apps/server/src/orchestration-v2/ThreadLaunchService.test.ts+156

...	@@ -1424,6 +1424,162 @@ it.effect("retries a failed workspace preparation on the same run", () => {	...	@@ -1424,6 +1424,162 @@ it.effect("retries a failed workspace preparation on the same run", () => {
1424	}).pipe(Effect.provide(harness.layer));	1424	}).pipe(Effect.provide(harness.layer));
1425	});	1425	});
1426		1426
		1427	it.effect.each(["fails", "is interrupted"] as const)(
		1428	"holds a message queued during setup when the workspace preparation %s",
		1429	(ending) =>
		1430	Effect.gen(function* () {
		1431	const fetchEntered = yield* Deferred.make<void>();
		1432	const allowFetch = yield* Deferred.make<void>();
		1433	let fetchFailures = 1;
		1434	const harness = makeHarness({
		1435	fetchRemote: () =>
		1436	fetchFailures-- <= 0
		1437	? Effect.void
		1438	: Deferred.succeed(fetchEntered, undefined).pipe(
		1439	Effect.andThen(Deferred.await(allowFetch)),
		1440	Effect.andThen(
		1441	Effect.fail(
		1442	new GitCommandError({
		1443	operation: "GitVcsDriver.fetchRemote",
		1444	command: "git",
		1445	cwd: project.workspaceRoot,
		1446	detail: "Git could not reach the remote.",
		1447	exitCode: 128,
		1448	}),
		1449	),
		1450	),
		1451	),
		1452	});
		1453	yield* Effect.gen(function* () {
		1454	const launches = yield* ThreadLaunch.ThreadLaunchService;
		1455	const threads = yield* ThreadManagement.ThreadManagementService;
		1456	const launched = yield* launches.launch(
		1457	launchInput({
		1458	command: `command:launch:queued-setup-${ending}`,
		1459	thread: `thread:launch:queued-setup-${ending}`,
		1460	message: "First message",
		1461	workspace: { type: "worktree", baseRef: "main", startFromOrigin: true },
		1462	}),
		1463	);
		1464	yield* Deferred.await(fetchEntered);
		1465	const queued = yield* threads.sendToThread({
		1466	projectId,
		1467	commandId: CommandId.make(`command:launch:queued-setup-${ending}:follow-up`),
		1468	threadId: launched.threadId,
		1469	messageId: MessageId.make(`message:launch:queued-setup-${ending}:follow-up`),
		1470	text: "Sent during setup",
		1471	attachments: [],
		1472	mode: "queue",
		1473	createdBy: "user",
		1474	creationSource: "web",
		1475	});
		1476	assert.equal(queued.delivery, "queued");
		1477	if (ending === "fails") {
		1478	yield* Deferred.succeed(allowFetch, undefined);
		1479	} else {
		1480	// An agent stop does not ask to hold the queue.
		1481	yield* threads.dispatch({
		1482	type: "run.interrupt",
		1483	commandId: CommandId.make("command:launch:queued-setup-interrupt"),
		1484	threadId: launched.threadId,
		1485	runId: launched.projection.runs[0]!.id,
		1486	});
		1487	}
		1488
		1489	// Without its worktree the follow-up would start in the project checkout.
		1490	yield* threads.streamStoredEventsFrom({ threadId: launched.threadId }).pipe(
		1491	Stream.filter(
		1492	(stored) =>
		1493	stored.event.type === "run.updated" && stored.event.payload.queueHeld === true,
		1494	),
		1495	Stream.runHead,
		1496	);
		1497	const projection = yield* threads.getThreadProjection(launched.threadId);
		1498	assert.equal(projection.runs.at(-1)?.status, "queued");
		1499	assert.equal(projection.thread.worktreePath, null);
		1500
		1501	if (ending === "fails") {
		1502	// A successful retry lets the held message follow the first turn again.
		1503	yield* launches.retryPreparation({
		1504	commandId: CommandId.make("command:launch:queued-setup-retry"),
		1505	threadId: launched.threadId,
		1506	runId: launched.projection.runs[0]!.id,
		1507	});
		1508	const retried = yield* threads.getThreadProjection(launched.threadId);
		1509	assert.equal(retried.runs.at(-1)?.queueHeld, false);
		1510	}
		1511	}).pipe(Effect.provide(harness.layer));
		1512	}),
		1513	);
		1514
		1515	it.effect.each(["failed", "interrupted"] as const)(
		1516	"holds a message queued during setup that arrives after the setup %s",
		1517	(ending) => {
		1518	let fetchEntered: Deferred.Deferred<void> \| null = null;
		1519	const harness = makeHarness({
		1520	fetchRemote: () =>
		1521	ending === "interrupted"
		1522	? Deferred.succeed(fetchEntered!, undefined).pipe(Effect.andThen(Effect.never))
		1523	: Effect.fail(
		1524	new GitCommandError({
		1525	operation: "GitVcsDriver.fetchRemote",
		1526	command: "git",
		1527	cwd: project.workspaceRoot,
		1528	detail: "Git could not reach the remote.",
		1529	exitCode: 128,
		1530	}),
		1531	),
		1532	});
		1533	return Effect.gen(function* () {
		1534	fetchEntered = yield* Deferred.make<void>();
		1535	const launches = yield* ThreadLaunch.ThreadLaunchService;
		1536	const threads = yield* ThreadManagement.ThreadManagementService;
		1537	const launched = yield* launches.launch(
		1538	launchInput({
		1539	command: `command:launch:late-queued-follow-up-${ending}`,
		1540	thread: `thread:launch:late-queued-follow-up-${ending}`,
		1541	message: "First message",
		1542	workspace: { type: "worktree", baseRef: "main", startFromOrigin: true },
		1543	}),
		1544	);
		1545	if (ending === "interrupted") {
		1546	yield* Deferred.await(fetchEntered);
		1547	// An agent stop does not ask to hold the queue.
		1548	yield* threads.dispatch({
		1549	type: "run.interrupt",
		1550	commandId: CommandId.make("command:launch:late-queued-follow-up:interrupt"),
		1551	threadId: launched.threadId,
		1552	runId: launched.projection.runs[0]!.id,
		1553	});
		1554	}
		1555	yield* threads.streamStoredEventsFrom({ threadId: launched.threadId }).pipe(
		1556	Stream.filter(
		1557	(stored) => stored.event.type === "run.updated" && stored.event.payload.status === ending,
		1558	),
		1559	Stream.runHead,
		1560	);
		1561
		1562	// Queued while setup ran, delivered only after it failed: it must not start
		1563	// in the project checkout.
		1564	const queued = yield* threads.sendToThread({
		1565	projectId,
		1566	commandId: CommandId.make(`command:launch:late-queued-follow-up-${ending}:send`),
		1567	threadId: launched.threadId,
		1568	messageId: MessageId.make(`message:launch:late-queued-follow-up-${ending}:send`),
		1569	text: "Sent during setup",
		1570	attachments: [],
		1571	mode: "queue",
		1572	createdBy: "user",
		1573	creationSource: "web",
		1574	});
		1575	assert.equal(queued.delivery, "queued");
		1576	const projection = yield* threads.getThreadProjection(launched.threadId);
		1577	assert.equal(projection.runs.at(-1)?.status, "queued");
		1578	assert.equal(projection.runs.at(-1)?.queueHeld, true);
		1579	}).pipe(Effect.provide(harness.layer));
		1580	},
		1581	);
		1582
1427	it.effect("a retry reuses a recorded worktree without undoing its branch rename", () => {	1583	it.effect("a retry reuses a recorded worktree without undoing its branch rename", () => {
1428	let setupFailures = 1;	1584	let setupFailures = 1;
1429	const harness = makeHarness({	1585	const harness = makeHarness({

apps/web/src/components/BranchToolbarBranchSelector.tsx+14-1

 @@ -122,6 +122,10 @@ export function BranchToolbarBranchSelector({
     threadEnvironment.updateMetadata,
     "thread metadata update",
   );
+  // An automatic default loses to any launch that lands first; that rejection is expected.
+  const updateEmptyThreadMetadata = useAtomCommand(threadEnvironment.updateMetadata, {
+    reportFailure: false,
+  });
   const switchRef = useAtomCommand(vcsEnvironment.switchRef, {
     reportFailure: false,
   });
 @@ -188,12 +192,14 @@ export function BranchToolbarBranchSelector({
         });
       }
       if (hasServerThread) {
-        void updateThreadMetadata({
+        void (automatic ? updateEmptyThreadMetadata : updateThreadMetadata)({
           environmentId,
           input: {
             threadId: activeThreadId,
             branch,
             worktreePath,
+            // A launched thread records its own worktree; a late default must not reset it.
+            ...(automatic ? { expectedEmpty: true } : {}),
           },
         });
       }
 @@ -228,6 +234,7 @@ export function BranchToolbarBranchSelector({
       effectiveEnvMode,
       draftThread?.environmentSelection,
       stopThreadSession,
+      updateEmptyThreadMetadata,
       updateThreadMetadata,
     ],
   );
 @@ -538,8 +545,13 @@ export function BranchToolbarBranchSelector({
     ? null
     : (defaultBranchName ?? currentGitBranch);
+  // A started thread's server is creating its worktree and records the branch
+  // itself; defaulting it here would reset the thread to the base checkout and
+  // detach the agent that just started.
+  const threadStarted = serverSession !== null;
   useEffect(() => {
     if (
+      threadStarted ||
       effectiveEnvMode !== "worktree" ||
       activeWorktreePath ||
       activeThreadBranch ||
 @@ -553,6 +565,7 @@ export function BranchToolbarBranchSelector({
     activeWorktreePath,
     effectiveEnvMode,
     setThreadBranch,
+    threadStarted,
     worktreeBaseBranchCandidate,
   ]);

apps/web/src/components/ChatView.tsx+51-25

 @@ -3664,6 +3664,14 @@ export default function ChatView(props: ChatViewProps) {
   // Server-side workspace preparation: unlike the local-dispatch flag this
   // survives reloads and shows on remote viewers of the same thread.
   const activeRunPreparing = activeActivityRun?.status === "preparing";
+  // The server queues a message behind a run that is still preparing its
+  // worktree or starting its agent, so a send during setup waits there and
+  // starts on its own instead of being refused.
+  const sendQueuesBehindSetup =
+    isServerThread && (activeRunPreparing || activeActivityRun?.status === "starting");
+  // Such a send skips the local dispatch, so this keeps its thread's composer busy while it is
+  // in flight.
+  const [setupQueueSendThreadKey, setSetupQueueSendThreadKey] = useState<string | null>(null);
   useEffect(() => {
     attachmentPreviewHandoffByMessageIdRef.current = attachmentPreviewHandoffByMessageId;
   }, [attachmentPreviewHandoffByMessageId]);
 @@ -4017,11 +4025,13 @@ export default function ChatView(props: ChatViewProps) {
   // Sends wait for the agent handoff, not for the setup script: an async
   // script keeps the snapshot running while the agent already works, and a
   // follow-up must not be held behind a slow install. Before the first
-  // snapshot arrives the starting session stands in for it.
+  // snapshot arrives the starting session stands in for it. Once the server
+  // has the thread, a send queues behind the setup run instead.
   const worktreeSetupBlocksSend =
-    worktreeSetup !== null
+    !sendQueuesBehindSetup &&
+    (worktreeSetup !== null
       ? worktreeSetup.phase === "running" && !worktreeSetupAgentStarted(worktreeSetup)
-      : isPreparingWorktree;
+      : isPreparingWorktree);
   const cancelWorktreeSetup = useAtomCommand(vcsEnvironment.cancelWorktreeSetup, {
     reportFailure: false,
   });
 @@ -8808,7 +8818,7 @@ export default function ChatView(props: ChatViewProps) {
     if (
       !readEnvironmentScope(environmentId, AuthOrchestrationOperateScope) ||
       !activeThread ||
-      isSendBusy ||
+      (isSendBusy && !sendQueuesBehindSetup) ||
       isConnecting ||
       isRevertingCheckpoint ||
       !clientSettingsHydrated ||
 @@ -9252,7 +9262,7 @@ export default function ChatView(props: ChatViewProps) {
       return;
     }
     const threadIdForSend = activeThread.id;
-    const isFirstMessage = !isServerThread || activeMessageCount === 0;
+    const isFirstMessage = !sendQueuesBehindSetup && (!isServerThread || activeMessageCount === 0);
     const baseBranchForWorktree =
       isFirstMessage && sendEnvMode === "worktree" && !activeThread.worktreePath
         ? activeThreadBranch
 @@ -9309,9 +9319,11 @@ export default function ChatView(props: ChatViewProps) {
       resumeCompactionTokens !== null &&
       !keepFullHistory &&
       messageTextForSend.toLowerCase() !== "/compact";
-    const turnDispatchMode = compactBeforeSend ? "queue" : dispatchMode;
+    const turnDispatchMode = compactBeforeSend || sendQueuesBehindSetup ? "queue" : dispatchMode;
     const shouldQueueBehindActiveRun =
-      compactBeforeSend || (phase === "running" && dispatchMode === "queue");
+      compactBeforeSend ||
+      sendQueuesBehindSetup ||
+      (phase === "running" && dispatchMode === "queue");
     const outgoingMessageText = formatOutgoingPrompt({
       provider: ctxSelectedProvider,
       model: ctxSelectedModel,
 @@ -9460,21 +9472,28 @@ export default function ChatView(props: ChatViewProps) {
       );
       return;
     }
-    beginLocalDispatch({
+    // A send queued behind setup leaves the first send's dispatch and setup card alone.
-      preparingWorktree: multipleModelSelections !== null || Boolean(baseBranchForWorktree),
+    if (sendQueuesBehindSetup) {
-      // Only a draft has a background submission to hide behind its hero.
+      setSetupQueueSendThreadKey(activeThreadKey);
-      submissionIntent:
+    } else {
-        submissionIntent === "background" && !isLocalDraftThread ? "foreground" : submissionIntent,
+      beginLocalDispatch({
-    });
+        preparingWorktree: multipleModelSelections !== null || Boolean(baseBranchForWorktree),
-    setWorktreeSetupRef(
+        // Only a draft has a background submission to hide behind its hero.
-      multipleModelSelections === null && baseBranchForWorktree
+        submissionIntent:
-        ? {
+          submissionIntent === "background" && !isLocalDraftThread
-            environmentId: activeThread.environmentId,
+            ? "foreground"
-            threadId: threadIdForSend,
+            : submissionIntent,
-            ownerKey: worktreeSetupOwnerKey,
+      });
-          }
+      setWorktreeSetupRef(
-        : null,
+        multipleModelSelections === null && baseBranchForWorktree
-    );
+          ? {
+              environmentId: activeThread.environmentId,
+              threadId: threadIdForSend,
+              ownerKey: worktreeSetupOwnerKey,
+            }
+          : null,
+      );
+    }
     const turnAttachmentsPromise = Promise.all(
       composerAttachmentsSnapshot.map(async (attachment) => {
 @@ -10141,11 +10160,12 @@ export default function ChatView(props: ChatViewProps) {
       }
     }
     sendInFlightRef.current = false;
+    setSetupQueueSendThreadKey((current) => (current === activeThreadKey ? null : current));
     if (!turnStartSucceeded) {
       setDockedDraftHeroThreadKey((currentThreadKey) =>
         currentThreadKey === activeThreadKey ? null : currentThreadKey,
       );
-      resetLocalDispatch();
+      if (!sendQueuesBehindSetup) resetLocalDispatch();
     }
   };
 @@ -11652,7 +11672,13 @@ export default function ChatView(props: ChatViewProps) {
                               phase={phase}
                               canInterrupt={canInterruptRunningThread}
                               isConnecting={isConnecting}
-                              isSendBusy={isSendBusy || isSavingQueuedEdit || isResuming}
+                              isSendBusy={
+                                (isSendBusy && !sendQueuesBehindSetup) ||
+                                (setupQueueSendThreadKey !== null &&
+                                  setupQueueSendThreadKey === activeThreadKey) ||
+                                isSavingQueuedEdit ||
+                                isResuming
+                              }
                               canResume={resumableRunId !== null || hasHeldQueuedRuns}
                               isRevertingCheckpoint={isRevertingCheckpoint}
                               sendDisabledReason={
 @@ -11670,7 +11696,7 @@ export default function ChatView(props: ChatViewProps) {
                                             ? "Preparing worktree"
                                             : projectCloneSendBlockReason
                               }
-                              isPreparingWorktree={isPreparingWorktree}
+                              isPreparingWorktree={isPreparingWorktree && !sendQueuesBehindSetup}
                               queuedRunsControl={
                                 isServerThread && activeThread ? (
                                   <QueuedRunsControl

packages/client-runtime/src/operations/commands.ts+3

...	@@ -132,6 +132,8 @@ export interface UpdateThreadMetadataInput extends ThreadCommandInput {	...	@@ -132,6 +132,8 @@ export interface UpdateThreadMetadataInput extends ThreadCommandInput {
132	readonly regenerateTitle?: boolean;	132	readonly regenerateTitle?: boolean;
133	/** Link (object) or unlink (null) a pull request (#8160). */	133	/** Link (object) or unlink (null) a pull request (#8160). */
134	readonly linkedPullRequest?: ThreadLinkedPullRequest \| null;	134	readonly linkedPullRequest?: ThreadLinkedPullRequest \| null;
		135	/** Apply only while no message or run has landed on the thread. */
		136	readonly expectedEmpty?: boolean;
135	}	137	}
136		138
137	export interface SetThreadRuntimeModeInput extends ThreadCommandInput {	139	export interface SetThreadRuntimeModeInput extends ThreadCommandInput {
...	@@ -579,6 +581,7 @@ export const updateThreadMetadata = Effect.fn("EnvironmentCommands.updateThreadM	...	@@ -579,6 +581,7 @@ export const updateThreadMetadata = Effect.fn("EnvironmentCommands.updateThreadM
579	...(input.title === undefined ? {} : { title: input.title }),	581	...(input.title === undefined ? {} : { title: input.title }),
580	...(input.branch === undefined ? {} : { branch: input.branch }),	582	...(input.branch === undefined ? {} : { branch: input.branch }),
581	...(input.worktreePath === undefined ? {} : { worktreePath: input.worktreePath }),	583	...(input.worktreePath === undefined ? {} : { worktreePath: input.worktreePath }),
		584	...(input.expectedEmpty === true ? { expectedEmpty: true } : {}),
582	...(input.regenerateTitle === undefined ? {} : { regenerateTitle: input.regenerateTitle }),	585	...(input.regenerateTitle === undefined ? {} : { regenerateTitle: input.regenerateTitle }),
583	...(input.linkedPullRequest === undefined	586	...(input.linkedPullRequest === undefined
584	? {}	587	? {}

author	maria <maria@kuuro.net> 2026-10-10 21:12:26-03:00
committer	GitHub <noreply@github.com> 2026-10-10 21:12:26-03:00
log	477282263a9115f911380b5aec7d4973267e4edc
tree	3fd42280314dc853955e9eba9aeedd3adbea1f73
parent	5f7294d452a5c6d6e0b7bd2c992478f830fbe212
signature	Signed by PGP key B5690EEEBB952194

fix: worktree threads keep their worktree when the agent starts, and messages sent during setup queue (#17654)