@p4code/cli 0.6.54 → 0.7.0

package/dist/bin.mjs

@@ -52,12 +52,12 @@ import * as SqlClient from "effect/unstable/sql/SqlClient";
 import * as SqlSchema from "effect/unstable/sql/SqlSchema";
 import * as PlatformError from "effect/PlatformError";
 import * as Migrator from "effect/unstable/sql/Migrator";
+import * as Clock from "effect/Clock";
 import * as NodeUtil from "node:util";
 import * as Cause from "effect/Cause";
 import * as Exit from "effect/Exit";
 import * as NodeReadline from "node:readline";
 import * as NodeFSP from "node:fs/promises";
-import * as Clock from "effect/Clock";
 import * as Headers$1 from "effect/unstable/http/Headers";
 import * as HttpRouter$1 from "effect/unstable/http/HttpRouter";
 import * as NodeStream from "@effect/platform-node/NodeStream";
@@ -263,7 +263,7 @@ const make$123 = () => {
 const layer$124 = Layer.sync(NetService, make$123);
 //#endregion
 //#region package.json
-var version$1 = "0.6.54";
+var version$1 = "0.7.0";
 //#endregion
 //#region ../../packages/shared/src/serverInstance.ts
 /**
@@ -3015,6 +3015,10 @@ const ExecutionEnvironmentCapabilities = Schema$1.Struct({
 	/** Server understands thread.scheduled-task.create / cancel and fires
 	pending tasks. Same version-skew contract as threadSettlement. */
 	threadScheduledTasks: Schema$1.optionalKey(Schema$1.Boolean),
+	/** Server holds thread.turn.start with queueIfBusy until the running turn
+	ends and understands thread.queued-message.send / remove. Same
+	version-skew contract as threadSettlement. */
+	threadMessageQueue: Schema$1.optionalKey(Schema$1.Boolean),
 	/** Server exposes the pull-request list, detail, activity, diff, and mutation APIs. Absent on
 	servers from before the pull-request workspace shipped, so clients must not probe them. */
 	pullRequests: Schema$1.optionalKey(Schema$1.Boolean),
@@ -3341,6 +3345,18 @@ const OrchestrationScheduledTask = Schema$1.Struct({
 	cancelledAt: Schema$1.NullOr(IsoDateTime).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
 	failure: Schema$1.NullOr(Schema$1.String).pipe(Schema$1.withDecodingDefault(Effect.succeed(null)))
 });
+/**
+* A user message sent while the thread was busy, held until the running turn
+* ends. The server sends queued messages one per turn in order; steering one
+* sends it into the running turn right away, and removing it drops it.
+*/
+const OrchestrationQueuedMessage = Schema$1.Struct({
+	messageId: MessageId,
+	text: Schema$1.String,
+	attachments: Schema$1.Array(ChatAttachment),
+	modelSelection: Schema$1.optional(ModelSelection),
+	createdAt: IsoDateTime
+});
 const SourceProposedPlanReference = Schema$1.Struct({
 	threadId: ThreadId,
 	planId: OrchestrationProposedPlanId
@@ -3599,10 +3615,12 @@ const OrchestrationThread = Schema$1.Struct({
 	snoozedAt: Schema$1.optional(Schema$1.NullOr(IsoDateTime)),
 	pinnedAt: Schema$1.optional(Schema$1.NullOr(IsoDateTime)),
 	pinOrderKey: Schema$1.optional(Schema$1.NullOr(Schema$1.String)),
+	parentThreadId: Schema$1.optional(Schema$1.NullOr(ThreadId)),
 	deletedAt: Schema$1.NullOr(IsoDateTime),
 	messages: Schema$1.Array(OrchestrationMessage),
 	proposedPlans: Schema$1.Array(OrchestrationProposedPlan).pipe(Schema$1.withDecodingDefault(Effect.succeed([]))),
 	scheduledTasks: Schema$1.optional(Schema$1.Array(OrchestrationScheduledTask)),
+	queuedMessages: Schema$1.optional(Schema$1.Array(OrchestrationQueuedMessage)),
 	activities: Schema$1.Array(OrchestrationThreadActivity),
 	checkpoints: Schema$1.Array(OrchestrationCheckpointSummary),
 	session: Schema$1.NullOr(OrchestrationSession)
@@ -3766,6 +3784,7 @@ const OrchestrationThreadShell = Schema$1.Struct({
 	snoozedAt: Schema$1.optional(Schema$1.NullOr(IsoDateTime)),
 	pinnedAt: Schema$1.optional(Schema$1.NullOr(IsoDateTime)),
 	pinOrderKey: Schema$1.optional(Schema$1.NullOr(Schema$1.String)),
+	parentThreadId: Schema$1.optional(Schema$1.NullOr(ThreadId)),
 	session: Schema$1.NullOr(OrchestrationSession),
 	latestUserMessageAt: Schema$1.NullOr(IsoDateTime),
 	hasPendingApprovals: Schema$1.Boolean,
@@ -3937,6 +3956,8 @@ const ThreadCreateCommand = Schema$1.Struct({
 	unpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
+	/** Links a sub-thread to the thread that spawned it. */
+	parentThreadId: Schema$1.optional(ThreadId),
 	createdAt: IsoDateTime
 });
 /**
@@ -4145,6 +4166,8 @@ const ThreadTurnStartCommand = Schema$1.Struct({
 		activityId: EventId,
 		outcome: Schema$1.String
 	})),
+	/** Hold the message until the running turn ends instead of steering into it. */
+	queueIfBusy: Schema$1.optional(Schema$1.Boolean),
 	createdAt: IsoDateTime
 });
 const ClientThreadTurnStartCommand = Schema$1.Struct({
@@ -4165,6 +4188,22 @@ const ClientThreadTurnStartCommand = Schema$1.Struct({
 	unpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	bootstrap: Schema$1.optional(ThreadTurnStartBootstrap),
 	sourceProposedPlan: Schema$1.optional(SourceProposedPlanReference),
+	queueIfBusy: Schema$1.optional(Schema$1.Boolean),
+	createdAt: IsoDateTime
+});
+/** Sends a queued message now: it steers into the running turn, or starts one when idle. */
+const ThreadQueuedMessageSendCommand = Schema$1.Struct({
+	type: Schema$1.Literal("thread.queued-message.send"),
+	commandId: CommandId,
+	threadId: ThreadId,
+	messageId: MessageId,
+	createdAt: IsoDateTime
+});
+const ThreadQueuedMessageRemoveCommand = Schema$1.Struct({
+	type: Schema$1.Literal("thread.queued-message.remove"),
+	commandId: CommandId,
+	threadId: ThreadId,
+	messageId: MessageId,
 	createdAt: IsoDateTime
 });
 const ThreadTurnInterruptCommand = Schema$1.Struct({
@@ -4273,6 +4312,8 @@ const DispatchableClientOrchestrationCommand = Schema$1.Union([
 	ThreadPullRequestUnlinkCommand,
 	ThreadComputerUseGrantSetCommand,
 	ThreadTurnStartCommand,
+	ThreadQueuedMessageSendCommand,
+	ThreadQueuedMessageRemoveCommand,
 	ThreadTurnInterruptCommand,
 	ThreadApprovalRespondCommand,
 	ThreadUserInputRespondCommand,
@@ -4308,6 +4349,8 @@ const ClientOrchestrationCommand = Schema$1.Union([
 	ThreadPullRequestUnlinkCommand,
 	ThreadComputerUseGrantSetCommand,
 	ClientThreadTurnStartCommand,
+	ThreadQueuedMessageSendCommand,
+	ThreadQueuedMessageRemoveCommand,
 	ThreadTurnInterruptCommand,
 	ThreadApprovalRespondCommand,
 	ThreadUserInputRespondCommand,
@@ -4498,6 +4541,8 @@ const OrchestrationEventType = Schema$1.Literals([
 	"thread.pull-requests-updated",
 	"thread.computer-use-grant-set",
 	"thread.message-sent",
+	"thread.message-queued",
+	"thread.queued-message-removed",
 	"thread.turn-start-requested",
 	"thread.turn-interrupt-requested",
 	"thread.approval-response-requested",
@@ -4573,6 +4618,8 @@ const ThreadCreatedPayload$1 = Schema$1.Struct({
 	* messages into this one. Optional so events from pre-fork servers decode.
 	*/
 	forkedFromThreadId: Schema$1.optional(ThreadId),
+	/** The spawning thread for a sub-thread. Optional so older events decode. */
+	parentThreadId: Schema$1.optional(ThreadId),
 	createdAt: IsoDateTime,
 	updatedAt: IsoDateTime
 });
@@ -4685,6 +4732,17 @@ const ThreadMessageSentPayload = Schema$1.Struct({
 	createdAt: IsoDateTime,
 	updatedAt: IsoDateTime
 });
+const ThreadMessageQueuedPayload$1 = Schema$1.Struct({
+	threadId: ThreadId,
+	message: OrchestrationQueuedMessage
+});
+const ThreadQueuedMessageRemovedPayload$1 = Schema$1.Struct({
+	threadId: ThreadId,
+	messageId: MessageId,
+	/** "sent" when it left the queue as a turn or steer, "removed" when dropped. */
+	reason: Schema$1.Literals(["sent", "removed"]),
+	removedAt: IsoDateTime
+});
 const ThreadTurnStartRequestedPayload = Schema$1.Struct({
 	threadId: ThreadId,
 	messageId: MessageId,
@@ -4985,6 +5043,16 @@ const OrchestrationEvent = Schema$1.Union([
 		type: Schema$1.Literal("thread.message-sent"),
 		payload: ThreadMessageSentPayload
 	}),
+	Schema$1.Struct({
+		...EventBaseFields,
+		type: Schema$1.Literal("thread.message-queued"),
+		payload: ThreadMessageQueuedPayload$1
+	}),
+	Schema$1.Struct({
+		...EventBaseFields,
+		type: Schema$1.Literal("thread.queued-message-removed"),
+		payload: ThreadQueuedMessageRemovedPayload$1
+	}),
 	Schema$1.Struct({
 		...EventBaseFields,
 		type: Schema$1.Literal("thread.turn-start-requested"),
@@ -11212,6 +11280,7 @@ const ClientSettingsSchema = Schema$1.Struct({
 	composerControlsExpanded: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	confirmThreadArchive: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false))),
 	confirmThreadDelete: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
+	queueFollowUpMessages: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	dismissedProviderUpdateNotificationKeys: Schema$1.Array(TrimmedNonEmptyString).pipe(Schema$1.withDecodingDefault(Effect.succeed([]))),
 	diffIgnoreWhitespace: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	computerUsePermissionHosts: ComputerUsePermissionHosts.pipe(Schema$1.withDecodingDefault(Effect.succeed({}))),
@@ -12005,6 +12074,7 @@ Schema$1.Struct({
 	composerControlsExpanded: Schema$1.optionalKey(Schema$1.Boolean),
 	confirmThreadArchive: Schema$1.optionalKey(Schema$1.Boolean),
 	confirmThreadDelete: Schema$1.optionalKey(Schema$1.Boolean),
+	queueFollowUpMessages: Schema$1.optionalKey(Schema$1.Boolean),
 	diffIgnoreWhitespace: Schema$1.optionalKey(Schema$1.Boolean),
 	computerUsePermissionHosts: Schema$1.optionalKey(ComputerUsePermissionHosts),
 	environmentIdentificationMode: Schema$1.optionalKey(EnvironmentIdentificationMode),
@@ -13573,7 +13643,8 @@ const ThreadSpawnInput = Schema$1.Struct({
 	compressMode: Schema$1.optional(CompressMode),
 	unpromptedSubagents: Schema$1.optional(Schema$1.Boolean),
 	fusion: Schema$1.optional(Schema$1.Boolean.annotate({ description: "Create two new threads as a separate Fusion pair, then start the supervisor with prompt. The builder stays empty until advised. Leaves the caller and its existing pair unchanged. Cannot be combined with fusionWatcher." })),
-	fusionWatcher: Schema$1.optional(Schema$1.Boolean.annotate({ description: "Set true only when creating the watcher to pair with the current thread. Defaults to the saved Fusion supervisor model. No special user command syntax is required." }))
+	fusionWatcher: Schema$1.optional(Schema$1.Boolean.annotate({ description: "Set true only when creating the watcher to pair with the current thread. Defaults to the saved Fusion supervisor model. No special user command syntax is required." })),
+	workspace: Schema$1.optional(Schema$1.Literals(["worktree", "shared"]).annotate({ description: "Where the sub-thread works. 'worktree' (the default for plain spawns in a git project) gives it its own git worktree and branch started from this thread's current HEAD commit, so parallel sub-threads never edit the same files; land it later with thread_merge_child. Commit first: uncommitted edits here are not visible to it. 'shared' runs it in this thread's checkout. Fusion spawns always share." }))
 });
 const ThreadSpawnResult = Schema$1.Struct({
 	/** Watchable with `thread_watch_events`, and addressable by every tool here. */
@@ -13581,7 +13652,71 @@ const ThreadSpawnResult = Schema$1.Struct({
 	projectId: ProjectId,
 	title: TrimmedNonEmptyString,
 	pairId: Schema$1.optional(ThreadPairId),
-	watcherThreadId: Schema$1.optional(ThreadId)
+	watcherThreadId: Schema$1.optional(ThreadId),
+	/** Set when the sub-thread got its own worktree. */
+	branch: Schema$1.optional(TrimmedNonEmptyString),
+	worktreePath: Schema$1.optional(TrimmedNonEmptyString),
+	baseCommitSha: Schema$1.optional(TrimmedNonEmptyString),
+	/** This thread had uncommitted changes the sub-thread cannot see. */
+	parentDirty: Schema$1.optional(Schema$1.Boolean)
+});
+const SubThreadState = Schema$1.Literals([
+	"running",
+	"needs-input",
+	"completed",
+	"failed",
+	"missing"
+]);
+const ThreadWaitInput = Schema$1.Struct({
+	threadIds: Schema$1.Array(ThreadId).check(Schema$1.isMinLength(1), Schema$1.isMaxLength(16)).annotate({ description: "Sub-threads to wait on, from thread_spawn. Up to 16." }),
+	mode: Schema$1.optional(Schema$1.Literals(["all", "any"]).annotate({ description: "'all' (default) returns once every sub-thread has stopped running; 'any' returns as soon as one stops, so you can merge or answer it while the rest keep working." })),
+	timeoutSeconds: Schema$1.optional(Schema$1.Int.check(Schema$1.isBetween({
+		minimum: 1,
+		maximum: 300
+	})).annotate({ description: "Longest wait before returning the current states with timedOut true. Default 45. Call again to keep waiting." }))
+});
+const ThreadWaitChild = Schema$1.Struct({
+	threadId: ThreadId,
+	title: Schema$1.NullOr(TrimmedNonEmptyString),
+	/** running, needs-input (a question or approval waits), completed, failed, or missing. */
+	state: SubThreadState,
+	branch: Schema$1.NullOr(TrimmedNonEmptyString),
+	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
+	/** The latest reply, trimmed to 1500 characters. */
+	lastAssistantMessage: Schema$1.NullOr(Schema$1.String),
+	lastError: Schema$1.NullOr(Schema$1.String)
+});
+const ThreadWaitResult = Schema$1.Struct({
+	timedOut: Schema$1.Boolean,
+	children: Schema$1.Array(ThreadWaitChild)
+});
+const ThreadMessageInput = Schema$1.Struct({
+	threadId: ThreadId.annotate({ description: "A sub-thread this thread spawned." }),
+	text: TrimmedNonEmptyString.annotate({ description: "Message to send. If the sub-thread is still working it is queued and sent when its turn ends." })
+});
+const ThreadMessageResult = Schema$1.Struct({
+	threadId: ThreadId,
+	messageId: MessageId
+});
+const ThreadMergeChildInput = Schema$1.Struct({ threadId: ThreadId.annotate({ description: "A finished sub-thread whose branch should land in this thread's worktree." }) });
+const ThreadMergeChildResult = Schema$1.Struct({
+	threadId: ThreadId,
+	/**
+	* merged: a merge commit landed. up-to-date: nothing new. conflicted: the
+	* merge was aborted, this worktree is unchanged, and conflictedFiles lists
+	* what the sub-thread must resolve. refused: nothing ran; see detail.
+	*/
+	outcome: Schema$1.Literals([
+		"merged",
+		"up-to-date",
+		"conflicted",
+		"refused"
+	]),
+	childBranch: Schema$1.optional(TrimmedNonEmptyString),
+	parentBranch: Schema$1.optional(Schema$1.NullOr(TrimmedNonEmptyString)),
+	mergeCommitSha: Schema$1.optional(TrimmedNonEmptyString),
+	conflictedFiles: Schema$1.optional(Schema$1.Array(Schema$1.String)),
+	detail: Schema$1.optional(Schema$1.String)
 });
 const ThreadPairCreateInput = Schema$1.Struct({
 	watcherThreadId: Schema$1.optional(ThreadId.annotate({ description: "Legacy pairing: use an existing spawned supervisor and keep this chat as builder. Omit to keep this chat and its history as supervisor and create a new empty builder, idle until advised." })),
@@ -18632,6 +18767,54 @@ var _062_ProviderResetCreditAttempts_default = Effect.gen(function* () {
     WHERE outcome IS NULL OR outcome = 'failed'`;
 });
 //#endregion
+//#region src/persistence/Migrations/064_ProjectionThreadQueuedMessages.ts
+/**
+* User messages sent while a thread was busy, held until its turn ends. A row
+* exists only while the message waits; sending or removing it deletes the row.
+*/
+var _064_ProjectionThreadQueuedMessages_default = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* sql`
+    CREATE TABLE IF NOT EXISTS projection_thread_queued_messages (
+      message_id TEXT PRIMARY KEY,
+      thread_id TEXT NOT NULL,
+      text TEXT NOT NULL,
+      attachments_json TEXT NOT NULL,
+      model_selection_json TEXT,
+      created_at TEXT NOT NULL
+    )
+  `;
+	yield* sql`
+    CREATE INDEX IF NOT EXISTS idx_projection_thread_queued_messages_thread_created
+    ON projection_thread_queued_messages(thread_id, created_at)
+  `;
+});
+//#endregion
+//#region src/persistence/Migrations/065_ProjectionThreadsParentThread.ts
+/**
+* Links a sub-thread to the thread that spawned it, so a parent keeps control
+* of its children across restarts and clients can group them under it.
+*/
+var _065_ProjectionThreadsParentThread_default = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* sql`
+    ALTER TABLE projection_threads
+    ADD COLUMN parent_thread_id TEXT
+  `;
+	yield* sql`
+    CREATE INDEX IF NOT EXISTS idx_projection_threads_parent_thread
+    ON projection_threads(parent_thread_id)
+  `;
+});
+//#endregion
+//#region src/persistence/Migrations/066_OrchestrationEventTypeSequenceIndex.ts
+var _066_OrchestrationEventTypeSequenceIndex_default = Effect.gen(function* () {
+	yield* (yield* SqlClient.SqlClient)`
+    CREATE INDEX IF NOT EXISTS idx_orchestration_events_type_sequence
+    ON orchestration_events(event_type, sequence)
+  `;
+});
+//#endregion
 //#region src/persistence/Migrations/001_OrchestrationEvents.ts
 var _001_OrchestrationEvents_default = Effect.gen(function* () {
 	const sql = yield* SqlClient.SqlClient;
@@ -20828,6 +21011,21 @@ const migrationEntries = [
 		63,
 		"RemoveThreadSettlement",
 		_063_RemoveThreadSettlement_default
+	],
+	[
+		64,
+		"ProjectionThreadQueuedMessages",
+		_064_ProjectionThreadQueuedMessages_default
+	],
+	[
+		65,
+		"ProjectionThreadsParentThread",
+		_065_ProjectionThreadsParentThread_default
+	],
+	[
+		66,
+		"OrchestrationEventTypeSequenceIndex",
+		_066_OrchestrationEventTypeSequenceIndex_default
 	]
 ];
 const makeMigrationLoader = (throughId) => Migrator.fromRecord(Object.fromEntries(migrationEntries.filter(([id]) => throughId === void 0 || id <= throughId).map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -20889,14 +21087,25 @@ const runGuardedMigrations = Effect.fn("runGuardedMigrations")(function* (input)
 		appliedMigrationId: appliedId,
 		targetMigrationId: targetId
 	}));
+	const snapshotStartedAt = yield* Clock.currentTimeMillis;
 	yield* captureDatabaseSnapshot(input.dbPath).pipe(Effect.tapCause((cause) => Effect.logError("Refusing to migrate without a database snapshot").pipe(Effect.annotateLogs({
 		dbPath: input.dbPath,
 		cause
 	}))));
+	yield* Effect.logInfo("database migration snapshot completed", {
+		durationMs: (yield* Clock.currentTimeMillis) - snapshotStartedAt,
+		appliedMigrationId: appliedId,
+		targetMigrationId: targetId
+	});
+	const migrationStartedAt = yield* Clock.currentTimeMillis;
 	const executed = yield* runMigrations(input.options).pipe(Effect.tapCause(() => markDatabaseRestorePending(input.dbPath).pipe(Effect.andThen(Effect.logError("Migration failed; the database will be restored on the next start").pipe(Effect.annotateLogs({
 		appliedMigrationId: appliedId,
 		targetMigrationId: targetId
 	}))), Effect.tapError((cause) => Effect.logError("Could not mark the database for restore").pipe(Effect.annotateLogs({ cause }))), Effect.ignore)));
+	yield* Effect.logInfo("database migrations completed", {
+		durationMs: (yield* Clock.currentTimeMillis) - migrationStartedAt,
+		executed: executed.length
+	});
 	yield* discardSnapshotQuietly(input.dbPath);
 	return executed;
 });
@@ -36027,15 +36236,18 @@ const OrchestrationEventPersistedRowSchema = Schema$1.Struct({
 });
 const ReadFromSequenceRequestSchema = Schema$1.Struct({
 	sequenceExclusive: NonNegativeInt,
+	throughSequence: NonNegativeInt,
 	limit: Schema$1.Number
 });
 const ReadFromSequenceOfTypesRequestSchema = Schema$1.Struct({
 	sequenceExclusive: NonNegativeInt,
+	throughSequence: NonNegativeInt,
 	limit: Schema$1.Number,
 	eventTypes: Schema$1.Array(OrchestrationEventType)
 });
 const ReadFromSequenceOfThreadRequestSchema = Schema$1.Struct({
 	sequenceExclusive: NonNegativeInt,
+	throughSequence: NonNegativeInt,
 	limit: Schema$1.Number,
 	threadId: Schema$1.String
 });
@@ -36155,6 +36367,7 @@ const makeEventStore = Effect.gen(function* () {
           metadata_json AS "metadata"
         FROM orchestration_events
         WHERE sequence > ${request.sequenceExclusive}
+          AND sequence <= ${request.throughSequence}
         ORDER BY sequence ASC
         LIMIT ${request.limit}
       `
@@ -36176,10 +36389,21 @@ const makeEventStore = Effect.gen(function* () {
           payload_json AS "payload",
           metadata_json AS "metadata"
         FROM orchestration_events
-        WHERE sequence > ${request.sequenceExclusive}
-          AND ${sql.in("event_type", request.eventTypes)}
+        WHERE sequence IN (
+          SELECT sequence FROM (
+            ${sql.join(" UNION ALL ")(request.eventTypes.map((eventType) => sql`
+                SELECT sequence FROM (
+                  SELECT sequence FROM orchestration_events
+                  WHERE event_type = ${eventType}
+                    AND sequence > ${request.sequenceExclusive}
+                    AND sequence <= ${request.throughSequence}
+                  ORDER BY sequence ASC LIMIT ${request.limit}
+                )
+              `))}
+          )
+          ORDER BY sequence ASC LIMIT ${request.limit}
+        )
         ORDER BY sequence ASC
-        LIMIT ${request.limit}
       `
 	});
 	const readEventRowsFromSequenceOfThread = SqlSchema.findAll({
@@ -36202,6 +36426,7 @@ const makeEventStore = Effect.gen(function* () {
         WHERE aggregate_kind = 'thread'
           AND stream_id = ${request.threadId}
           AND sequence > ${request.sequenceExclusive}
+          AND sequence <= ${request.throughSequence}
         ORDER BY sequence ASC
         LIMIT ${request.limit}
       `
@@ -36264,6 +36489,7 @@ const makeEventStore = Effect.gen(function* () {
 		});
 		const readPage = (cursor, remaining) => Stream.fromEffect(readRows({
 			sequenceExclusive: cursor,
+			throughSequence: options?.throughSequence ?? Number.MAX_SAFE_INTEGER,
 			limit: Math.min(remaining, READ_PAGE_SIZE)
 		}).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$4("OrchestrationEventStore.readFromSequence:query", "OrchestrationEventStore.readFromSequence:decodeRows")), Effect.flatMap((rows) => Effect.forEach(rows, (row) => decodeEvent(row).pipe(Effect.mapError(toPersistenceDecodeError("OrchestrationEventStore.readFromSequence:rowToEvent"))))))).pipe(Stream.flatMap((events) => {
 			if (events.length === 0) return Stream.empty;
@@ -37223,6 +37449,8 @@ const ThreadUnpinnedPayload = ThreadUnpinnedPayload$1;
 const ThreadSnoozedPayload = ThreadSnoozedPayload$1;
 const ThreadUnsnoozedPayload = ThreadUnsnoozedPayload$1;
 const MessageSentPayloadSchema = ThreadMessageSentPayload;
+const ThreadMessageQueuedPayload = ThreadMessageQueuedPayload$1;
+const ThreadQueuedMessageRemovedPayload = ThreadQueuedMessageRemovedPayload$1;
 const ThreadProposedPlanUpsertedPayload = ThreadProposedPlanUpsertedPayload$1;
 const ThreadScheduledTaskCreatedPayload = ThreadScheduledTaskCreatedPayload$1;
 const ThreadScheduledTaskCancelledPayload = ThreadScheduledTaskCancelledPayload$1;
@@ -37440,6 +37668,7 @@ function projectEvent(model, event) {
 				computerUseHostId: payload.computerUseHostId ?? null,
 				branch: payload.branch,
 				worktreePath: payload.worktreePath,
+				parentThreadId: payload.parentThreadId ?? null,
 				latestTurn: null,
 				createdAt: payload.createdAt,
 				updatedAt: payload.updatedAt,
@@ -37641,6 +37870,24 @@ function projectEvent(model, event) {
 				})
 			};
 		});
+		case "thread.message-queued": return Effect.gen(function* () {
+			const payload = yield* decodeForEvent(ThreadMessageQueuedPayload, event.payload, event.type, "payload");
+			const thread = nextBase.threads.find((entry) => entry.id === payload.threadId);
+			if (!thread) return nextBase;
+			return {
+				...nextBase,
+				threads: updateThread(nextBase.threads, payload.threadId, { queuedMessages: [...(thread.queuedMessages ?? []).filter((entry) => entry.messageId !== payload.message.messageId), payload.message] })
+			};
+		});
+		case "thread.queued-message-removed": return Effect.gen(function* () {
+			const payload = yield* decodeForEvent(ThreadQueuedMessageRemovedPayload, event.payload, event.type, "payload");
+			const thread = nextBase.threads.find((entry) => entry.id === payload.threadId);
+			if (!thread) return nextBase;
+			return {
+				...nextBase,
+				threads: updateThread(nextBase.threads, payload.threadId, { queuedMessages: (thread.queuedMessages ?? []).filter((entry) => entry.messageId !== payload.messageId) })
+			};
+		});
 		case "thread.scheduled-task.created": return Effect.gen(function* () {
 			const payload = yield* decodeForEvent(ThreadScheduledTaskCreatedPayload, event.payload, event.type, "payload");
 			const thread = nextBase.threads.find((entry) => entry.id === payload.threadId);
@@ -37788,7 +38035,7 @@ function archiveWorkspaceLifecycle(cleanup, updatedAt) {
 function findActiveThreadPair(readModel, threadId) {
 	return (readModel.threadPairs ?? []).find((pair) => pair.detachedAt === null && (pair.implementerThreadId === threadId || pair.watcherThreadId === threadId));
 }
-const QUEUED_TURN_START_GRACE_MS = 120 * 1e3;
+const QUEUED_TURN_START_GRACE_MS$1 = 120 * 1e3;
 /**
 * Blocked-on-you work derived from the thread's retained activities: an
 * approval or user-input request with no later resolution for the same
@@ -37842,7 +38089,16 @@ function threadHasQueuedTurnStart(thread, occurredAt) {
 		thread.latestTurn.completedAt
 	].map((candidate) => candidate == null ? Number.NEGATIVE_INFINITY : Date.parse(candidate)));
 	const queuedAgeMs = Date.parse(occurredAt) - latestUserMessageAtMs;
-	return thread.session?.status !== "error" && Number.isFinite(latestUserMessageAtMs) && latestUserMessageAtMs > latestTurnAtMs && Math.abs(queuedAgeMs) <= QUEUED_TURN_START_GRACE_MS;
+	return thread.session?.status !== "error" && Number.isFinite(latestUserMessageAtMs) && latestUserMessageAtMs > latestTurnAtMs && Math.abs(queuedAgeMs) <= QUEUED_TURN_START_GRACE_MS$1;
+}
+/**
+* A thread is busy while a turn runs or one is about to: the session is
+* starting or running, or a sent message has not been adopted by a turn yet.
+* Queued messages wait for this to clear.
+*/
+function isThreadBusy(thread, occurredAt) {
+	const status = thread.session?.status;
+	return status === "running" || status === "starting" || threadHasQueuedTurnStart(thread, occurredAt);
 }
 function withEventBase(input) {
 	return Crypto.Crypto.pipe(Effect.flatMap((crypto) => crypto.randomUUIDv4.pipe(Effect.map((eventId) => ({
@@ -38017,6 +38273,15 @@ const decideCommand = Effect.fn("decideCommand")(function* ({ command, readModel
 				commandType: command.type,
 				detail: `Sidechat parent '${sidechatParent.id}' belongs to a different project.`
 			});
+			const spawningParent = command.parentThreadId === void 0 ? null : yield* requireThreadNotArchived({
+				readModel,
+				command,
+				threadId: command.parentThreadId
+			});
+			if (spawningParent && spawningParent.projectId !== command.projectId) return yield* new OrchestrationCommandInvariantError({
+				commandType: command.type,
+				detail: `Parent thread '${spawningParent.id}' belongs to a different project.`
+			});
 			return {
 				...yield* withEventBase({
 					aggregateKind: "thread",
@@ -38037,6 +38302,7 @@ const decideCommand = Effect.fn("decideCommand")(function* ({ command, readModel
 					computerUseHostId: sidechatParent ? null : command.computerUseHostId ?? null,
 					branch: sidechatParent ? sidechatParent.branch : command.branch,
 					worktreePath: sidechatParent ? sidechatParent.worktreePath : command.worktreePath,
+					...spawningParent ? { parentThreadId: spawningParent.id } : {},
 					createdAt: command.createdAt,
 					updatedAt: command.createdAt
 				}
@@ -39013,6 +39279,25 @@ const decideCommand = Effect.fn("decideCommand")(function* ({ command, readModel
 				commandType: command.type,
 				detail: budgetBlock
 			});
+			if (command.queueIfBusy === true && isThreadBusy(targetThread, command.createdAt)) return {
+				...yield* withEventBase({
+					aggregateKind: "thread",
+					aggregateId: command.threadId,
+					occurredAt: command.createdAt,
+					commandId: command.commandId
+				}),
+				type: "thread.message-queued",
+				payload: {
+					threadId: command.threadId,
+					message: {
+						messageId: command.message.messageId,
+						text: command.message.text,
+						attachments: command.message.attachments,
+						...command.modelSelection !== void 0 ? { modelSelection: command.modelSelection } : {},
+						createdAt: command.createdAt
+					}
+				}
+			};
 			if (activePair?.watcherThreadId === command.threadId && targetThread.interactionMode !== "default") return yield* decideCommandSequence({
 				readModel,
 				commands: [{
@@ -39101,6 +39386,56 @@ const decideCommand = Effect.fn("decideCommand")(function* ({ command, readModel
 				turnStartRequestedEvent
 			];
 		}
+		case "thread.queued-message.send":
+		case "thread.queued-message.remove": {
+			const thread = yield* requireThread({
+				readModel,
+				command,
+				threadId: command.threadId
+			});
+			const queued = (thread.queuedMessages ?? []).find((entry) => entry.messageId === command.messageId);
+			if (queued === void 0) return yield* new OrchestrationCommandInvariantError({
+				commandType: command.type,
+				detail: `Message '${command.messageId}' is not queued on thread '${command.threadId}'.`
+			});
+			const removedEvent = {
+				...yield* withEventBase({
+					aggregateKind: "thread",
+					aggregateId: command.threadId,
+					occurredAt: command.createdAt,
+					commandId: command.commandId
+				}),
+				type: "thread.queued-message-removed",
+				payload: {
+					threadId: command.threadId,
+					messageId: command.messageId,
+					reason: command.type === "thread.queued-message.send" ? "sent" : "removed",
+					removedAt: command.createdAt
+				}
+			};
+			if (command.type === "thread.queued-message.remove") return removedEvent;
+			const turnStart = yield* decideCommand({
+				readModel,
+				command: {
+					type: "thread.turn.start",
+					commandId: command.commandId,
+					threadId: command.threadId,
+					message: {
+						messageId: queued.messageId,
+						role: "user",
+						text: queued.text,
+						attachments: queued.attachments
+					},
+					...queued.modelSelection !== void 0 ? { modelSelection: queued.modelSelection } : {},
+					runtimeMode: thread.runtimeMode,
+					interactionMode: thread.interactionMode,
+					compressMode: thread.compressMode,
+					unpromptedSubagents: thread.unpromptedSubagents,
+					createdAt: command.createdAt
+				}
+			});
+			return [removedEvent, ...Array.isArray(turnStart) ? turnStart : [turnStart]];
+		}
 		case "thread.turn.interrupt":
 			yield* requireThread({
 				readModel,
@@ -39297,13 +39632,13 @@ const decideCommand = Effect.fn("decideCommand")(function* ({ command, readModel
 			});
 			return events;
 		}
-		case "thread.session.set":
-			yield* requireThread({
+		case "thread.session.set": {
+			const thread = yield* requireThread({
 				readModel,
 				command,
 				threadId: command.threadId
 			});
-			return {
+			const sessionSetEvent = {
 				...yield* withEventBase({
 					aggregateKind: "thread",
 					aggregateId: command.threadId,
@@ -39317,6 +39652,26 @@ const decideCommand = Effect.fn("decideCommand")(function* ({ command, readModel
 					session: command.session
 				}
 			};
+			const queuedHead = thread.queuedMessages?.[0];
+			const previousStatus = thread.session?.status;
+			if (queuedHead === void 0 || command.session.status !== "ready" && command.session.status !== "stopped" || previousStatus !== "running" && previousStatus !== "starting") return sessionSetEvent;
+			const settledReadModel = yield* projectEvent(readModel, {
+				...sessionSetEvent,
+				sequence: readModel.snapshotSequence + 1
+			}).pipe(Effect.orDie);
+			const settledThread = settledReadModel.threads.find((entry) => entry.id === thread.id);
+			if (settledThread === void 0 || isThreadBusy(settledThread, command.createdAt)) return sessionSetEvent;
+			return [sessionSetEvent, ...yield* decideCommandSequence({
+				readModel: settledReadModel,
+				commands: [{
+					type: "thread.queued-message.send",
+					commandId: CommandId.make(`queued-message:${queuedHead.messageId}`),
+					threadId: command.threadId,
+					messageId: queuedHead.messageId,
+					createdAt: command.createdAt
+				}]
+			}).pipe(Effect.catchTag("OrchestrationCommandInvariantError", () => Effect.succeed([])))];
+		}
 		case "thread.message.assistant.delta":
 			yield* requireThread({
 				readModel,
@@ -39679,7 +40034,12 @@ const makeOrchestrationEngine = Effect.gen(function* () {
 		})));
 	};
 	yield* projectionPipeline.bootstrap;
+	const readModelStartedAt = yield* Clock.currentTimeMillis;
 	commandReadModel = yield* projectionSnapshotQuery.getCommandReadModel();
+	yield* Effect.logInfo("orchestration command read model loaded", {
+		durationMs: (yield* Clock.currentTimeMillis) - readModelStartedAt,
+		sequence: commandReadModel.snapshotSequence
+	});
 	const worker = Effect.forever(Queue.take(commandQueue).pipe(Effect.flatMap(processEnvelope)));
 	yield* Effect.forkScoped(worker);
 	yield* Effect.logDebug("orchestration engine started").pipe(Effect.annotateLogs({ sequence: commandReadModel.snapshotSequence }));
@@ -39863,6 +40223,19 @@ const GetProjectionThreadScheduledTaskInput = Schema$1.Struct({ taskId: Orchestr
 const ListProjectionThreadScheduledTasksInput = Schema$1.Struct({ threadId: ThreadId });
 var ProjectionThreadScheduledTaskRepository = class extends Context.Service()("@p4code/cli/persistence/Services/ProjectionThreadScheduledTasks/ProjectionThreadScheduledTaskRepository") {};
 //#endregion
+//#region src/persistence/Services/ProjectionThreadQueuedMessages.ts
+const ProjectionThreadQueuedMessage = Schema$1.Struct({
+	messageId: MessageId,
+	threadId: ThreadId,
+	text: Schema$1.String,
+	attachments: Schema$1.fromJsonString(Schema$1.Array(ChatAttachment)),
+	modelSelection: Schema$1.NullOr(Schema$1.fromJsonString(ModelSelection)),
+	createdAt: IsoDateTime
+});
+const DeleteProjectionThreadQueuedMessageInput = Schema$1.Struct({ messageId: MessageId });
+const DeleteProjectionThreadQueuedMessagesByThreadInput = Schema$1.Struct({ threadId: ThreadId });
+var ProjectionThreadQueuedMessageRepository = class extends Context.Service()("@p4code/cli/persistence/Services/ProjectionThreadQueuedMessages/ProjectionThreadQueuedMessageRepository") {};
+//#endregion
 //#region src/persistence/Services/ProjectionThreadSessions.ts
 /**
 * ProjectionThreadSessionRepository - Repository interface for thread sessions.
@@ -39993,6 +40366,7 @@ const ProjectionThread = Schema$1.Struct({
 	snoozedAt: Schema$1.NullOr(IsoDateTime),
 	pinnedAt: Schema$1.NullOr(IsoDateTime),
 	pinOrderKey: Schema$1.NullOr(Schema$1.String),
+	parentThreadId: Schema$1.optional(Schema$1.NullOr(ThreadId)),
 	latestUserMessageAt: Schema$1.NullOr(IsoDateTime),
 	pendingApprovalCount: NonNegativeInt,
 	pendingUserInputCount: NonNegativeInt,
@@ -40646,6 +41020,62 @@ const makeProjectionThreadScheduledTaskRepository = Effect.gen(function* () {
 });
 const ProjectionThreadScheduledTaskRepositoryLive = Layer.effect(ProjectionThreadScheduledTaskRepository, makeProjectionThreadScheduledTaskRepository);
 //#endregion
+//#region src/persistence/Layers/ProjectionThreadQueuedMessages.ts
+const makeProjectionThreadQueuedMessageRepository = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const upsertRow = SqlSchema.void({
+		Request: ProjectionThreadQueuedMessage,
+		execute: (row) => sql`
+      INSERT INTO projection_thread_queued_messages (
+        message_id,
+        thread_id,
+        text,
+        attachments_json,
+        model_selection_json,
+        created_at
+      )
+      VALUES (
+        ${row.messageId},
+        ${row.threadId},
+        ${row.text},
+        ${row.attachments},
+        ${row.modelSelection},
+        ${row.createdAt}
+      )
+      ON CONFLICT (message_id)
+      DO UPDATE SET
+        thread_id = excluded.thread_id,
+        text = excluded.text,
+        attachments_json = excluded.attachments_json,
+        model_selection_json = excluded.model_selection_json,
+        created_at = excluded.created_at
+    `
+	});
+	const deleteRow = SqlSchema.void({
+		Request: DeleteProjectionThreadQueuedMessageInput,
+		execute: ({ messageId }) => sql`
+      DELETE FROM projection_thread_queued_messages
+      WHERE message_id = ${messageId}
+    `
+	});
+	const deleteThreadRows = SqlSchema.void({
+		Request: DeleteProjectionThreadQueuedMessagesByThreadInput,
+		execute: ({ threadId }) => sql`
+      DELETE FROM projection_thread_queued_messages
+      WHERE thread_id = ${threadId}
+    `
+	});
+	const upsert = (row) => upsertRow(row).pipe(Effect.mapError(toPersistenceSqlError("ProjectionThreadQueuedMessageRepository.upsert:query")));
+	const deleteByMessageId = (input) => deleteRow(input).pipe(Effect.mapError(toPersistenceSqlError("ProjectionThreadQueuedMessageRepository.deleteByMessageId:query")));
+	const deleteByThreadId = (input) => deleteThreadRows(input).pipe(Effect.mapError(toPersistenceSqlError("ProjectionThreadQueuedMessageRepository.deleteByThreadId:query")));
+	return {
+		upsert,
+		deleteByMessageId,
+		deleteByThreadId
+	};
+});
+const ProjectionThreadQueuedMessageRepositoryLive = Layer.effect(ProjectionThreadQueuedMessageRepository, makeProjectionThreadQueuedMessageRepository);
+//#endregion
 //#region src/persistence/Layers/ProjectionThreadSessions.ts
 const makeProjectionThreadSessionRepository = Effect.gen(function* () {
 	const sql = yield* SqlClient.SqlClient;
@@ -40984,6 +41414,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           snoozed_at,
           pinned_at,
           pin_order_key,
+          parent_thread_id,
           latest_user_message_at,
           pending_approval_count,
           pending_user_input_count,
@@ -41020,6 +41451,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           ${row.snoozedAt},
           ${row.pinnedAt},
           ${row.pinOrderKey},
+          ${row.parentThreadId ?? null},
           ${row.latestUserMessageAt},
           ${row.pendingApprovalCount},
           ${row.pendingUserInputCount},
@@ -41056,6 +41488,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           snoozed_at = excluded.snoozed_at,
           pinned_at = excluded.pinned_at,
           pin_order_key = excluded.pin_order_key,
+          parent_thread_id = COALESCE(excluded.parent_thread_id, projection_threads.parent_thread_id),
           latest_user_message_at = excluded.latest_user_message_at,
           pending_approval_count = excluded.pending_approval_count,
           pending_user_input_count = excluded.pending_user_input_count,
@@ -41097,6 +41530,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
           pin_order_key AS "pinOrderKey",
+          parent_thread_id AS "parentThreadId",
           latest_user_message_at AS "latestUserMessageAt",
           pending_approval_count AS "pendingApprovalCount",
           pending_user_input_count AS "pendingUserInputCount",
@@ -41140,6 +41574,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
           pin_order_key AS "pinOrderKey",
+          parent_thread_id AS "parentThreadId",
           latest_user_message_at AS "latestUserMessageAt",
           pending_approval_count AS "pendingApprovalCount",
           pending_user_input_count AS "pendingUserInputCount",
@@ -41189,6 +41624,7 @@ const ORCHESTRATION_PROJECTOR_NAMES = {
 	threadMessages: "projection.thread-messages",
 	threadProposedPlans: "projection.thread-proposed-plans",
 	threadScheduledTasks: "projection.thread-scheduled-tasks",
+	threadQueuedMessages: "projection.thread-queued-messages",
 	threadActivities: "projection.thread-activities",
 	threadSessions: "projection.thread-sessions",
 	threadTurns: "projection.thread-turns",
@@ -41400,6 +41836,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 	const projectionThreadMessageRepository = yield* ProjectionThreadMessageRepository;
 	const projectionThreadProposedPlanRepository = yield* ProjectionThreadProposedPlanRepository;
 	const projectionThreadScheduledTaskRepository = yield* ProjectionThreadScheduledTaskRepository;
+	const projectionThreadQueuedMessageRepository = yield* ProjectionThreadQueuedMessageRepository;
 	const projectionThreadActivityRepository = yield* ProjectionThreadActivityRepository;
 	const projectionThreadSessionRepository = yield* ProjectionThreadSessionRepository;
 	const projectionTurnRepository = yield* ProjectionTurnRepository;
@@ -41619,6 +42056,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 					snoozedAt: null,
 					pinnedAt: null,
 					pinOrderKey: null,
+					parentThreadId: event.payload.parentThreadId ?? null,
 					latestUserMessageAt: null,
 					pendingApprovalCount: 0,
 					pendingUserInputCount: 0,
@@ -41936,6 +42374,27 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 			default: return;
 		}
 	});
+	const applyThreadQueuedMessagesProjection = Effect.fn("applyThreadQueuedMessagesProjection")(function* (event) {
+		switch (event.type) {
+			case "thread.message-queued":
+				yield* projectionThreadQueuedMessageRepository.upsert({
+					messageId: event.payload.message.messageId,
+					threadId: event.payload.threadId,
+					text: event.payload.message.text,
+					attachments: event.payload.message.attachments,
+					modelSelection: event.payload.message.modelSelection ?? null,
+					createdAt: event.payload.message.createdAt
+				});
+				return;
+			case "thread.queued-message-removed":
+				yield* projectionThreadQueuedMessageRepository.deleteByMessageId({ messageId: event.payload.messageId });
+				return;
+			case "thread.deleted":
+				yield* projectionThreadQueuedMessageRepository.deleteByThreadId({ threadId: event.payload.threadId });
+				return;
+			default: return;
+		}
+	});
 	const applyThreadScheduledTasksProjection = Effect.fn("applyThreadScheduledTasksProjection")(function* (event) {
 		switch (event.type) {
 			case "thread.scheduled-task.created":
@@ -42327,74 +42786,214 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 	const projectors = [
 		{
 			name: ORCHESTRATION_PROJECTOR_NAMES.projects,
+			eventTypes: [
+				"project.created",
+				"project.meta-updated",
+				"project.deleted"
+			],
 			apply: applyProjectsProjection
 		},
 		{
 			name: ORCHESTRATION_PROJECTOR_NAMES.threadPairs,
+			eventTypes: [
+				"thread.message-sent",
+				"thread-pair.created",
+				"thread-pair.gate-opened",
+				"thread-pair.gate-advanced",
+				"thread-pair.gate-resolved",
+				"thread-pair.detached",
+				"thread-pair.cursor-advanced",
+				"thread-pair.triage-advanced"
+			],
 			apply: applyThreadPairsProjection
 		},
 		{
 			name: ORCHESTRATION_PROJECTOR_NAMES.threadMessages,
+			eventTypes: [
+				"thread.created",
+				"thread.message-sent",
+				"thread.reverted"
+			],
 			apply: applyThreadMessagesProjection
 		},
 		{
 			name: ORCHESTRATION_PROJECTOR_NAMES.threadProposedPlans,
+			eventTypes: ["thread.proposed-plan-upserted", "thread.reverted"],
 			apply: applyThreadProposedPlansProjection
 		},
 		{
 			name: ORCHESTRATION_PROJECTOR_NAMES.threadScheduledTasks,
+			eventTypes: [
+				"thread.scheduled-task.created",
+				"thread.scheduled-task.cancelled",
+				"thread.scheduled-task.fired"
+			],
 			apply: applyThreadScheduledTasksProjection
 		},
+		{
+			name: ORCHESTRATION_PROJECTOR_NAMES.threadQueuedMessages,
+			eventTypes: [
+				"thread.message-queued",
+				"thread.queued-message-removed",
+				"thread.deleted"
+			],
+			apply: applyThreadQueuedMessagesProjection
+		},
 		{
 			name: ORCHESTRATION_PROJECTOR_NAMES.threadActivities,
+			eventTypes: ["thread.activity-appended", "thread.reverted"],
 			apply: applyThreadActivitiesProjection
 		},
 		{
 			name: ORCHESTRATION_PROJECTOR_NAMES.threadSessions,
+			eventTypes: ["thread.session-set"],
 			apply: applyThreadSessionsProjection
 		},
 		{
 			name: ORCHESTRATION_PROJECTOR_NAMES.threadTurns,
+			eventTypes: [
+				"thread.turn-start-requested",
+				"thread.activity-appended",
+				"thread.session-set",
+				"thread.message-sent",
+				"thread.turn-interrupt-requested",
+				"thread.turn-diff-completed",
+				"thread.reverted"
+			],
 			apply: applyThreadTurnsProjection
 		},
 		{
 			name: ORCHESTRATION_PROJECTOR_NAMES.checkpoints,
+			eventTypes: [],
 			apply: applyCheckpointsProjection
 		},
 		{
 			name: ORCHESTRATION_PROJECTOR_NAMES.pendingApprovals,
+			eventTypes: ["thread.activity-appended", "thread.approval-response-requested"],
 			apply: applyPendingApprovalsProjection
 		},
 		{
 			name: ORCHESTRATION_PROJECTOR_NAMES.threads,
+			eventTypes: [
+				"thread.created",
+				"thread.archived",
+				"thread.unarchived",
+				"thread.settled",
+				"thread.unsettled",
+				"thread.snoozed",
+				"thread.unsnoozed",
+				"thread.pinned",
+				"thread.unpinned",
+				"thread.pin-reordered",
+				"thread.meta-updated",
+				"thread.runtime-mode-set",
+				"thread.interaction-mode-set",
+				"thread.compress-mode-set",
+				"thread.unprompted-subagents-set",
+				"thread.pull-requests-updated",
+				"thread.computer-use-grant-set",
+				"thread.deleted",
+				"thread.message-sent",
+				"thread.proposed-plan-upserted",
+				"thread.activity-appended",
+				"thread.approval-response-requested",
+				"thread.user-input-response-requested",
+				"thread.session-set",
+				"thread.turn-diff-completed",
+				"thread.reverted"
+			],
 			apply: applyThreadsProjection
 		}
 	];
-	const runProjectorForEvent = Effect.fn("runProjectorForEvent")(function* (projector, event) {
+	const runProjectorBatch = Effect.fn("runProjectorBatch")(function* (projector, events) {
+		const lastEvent = events.at(-1);
+		if (lastEvent === void 0) return;
 		const attachmentSideEffects = {
 			deletedThreadIds: /* @__PURE__ */ new Set(),
 			prunedThreadRelativePaths: /* @__PURE__ */ new Map()
 		};
-		yield* sql.withTransaction(projector.apply(event, attachmentSideEffects).pipe(Effect.flatMap(() => projectionStateRepository.upsert({
-			projector: projector.name,
-			lastAppliedSequence: event.sequence,
-			updatedAt: event.occurredAt
-		}))));
+		yield* sql.withTransaction(Effect.gen(function* () {
+			for (const event of events) yield* projector.apply(event, attachmentSideEffects);
+			yield* projectionStateRepository.upsert({
+				projector: projector.name,
+				lastAppliedSequence: lastEvent.sequence,
+				updatedAt: lastEvent.occurredAt
+			});
+		}));
 		yield* runAttachmentSideEffects(attachmentSideEffects).pipe(Effect.catch((cause) => Effect.logWarning("failed to apply projected attachment side-effects", {
 			projector: projector.name,
+			sequence: lastEvent.sequence,
+			cause
+		})));
+	});
+	const bootstrapProjector = Effect.fn("bootstrapProjector")(function* (projector, head) {
+		const stateRow = yield* projectionStateRepository.getByProjector({ projector: projector.name });
+		const cursor = Option.isSome(stateRow) ? stateRow.value.lastAppliedSequence : 0;
+		if (cursor >= head.sequence) return;
+		const startedAt = yield* Clock.currentTimeMillis;
+		let replayedEvents = 0;
+		yield* eventStore.readFromSequence(cursor, Number.MAX_SAFE_INTEGER, {
+			eventTypes: projector.eventTypes,
+			throughSequence: head.sequence
+		}).pipe(Stream.grouped(500), Stream.runForEach((events) => Effect.gen(function* () {
+			let batch = [];
+			for (const event of events) if (event.type === "thread.created" || event.type === "thread.archived" || event.type === "thread.reverted" || event.type === "thread.deleted") {
+				yield* runProjectorBatch(projector, batch);
+				batch = [];
+				yield* runProjectorBatch(projector, [event]);
+			} else batch.push(event);
+			yield* runProjectorBatch(projector, batch);
+			replayedEvents += events.length;
+		})), Effect.withTracerEnabled(false));
+		yield* projectionStateRepository.upsert({
+			projector: projector.name,
+			lastAppliedSequence: head.sequence,
+			updatedAt: head.occurredAt
+		});
+		yield* Effect.logInfo("orchestration projection replay completed", {
+			projector: projector.name,
+			fromSequence: cursor,
+			throughSequence: head.sequence,
+			replayedEvents,
+			durationMs: (yield* Clock.currentTimeMillis) - startedAt
+		});
+	});
+	const projectEvent = (event) => Effect.gen(function* () {
+		const attachmentSideEffects = {
+			deletedThreadIds: /* @__PURE__ */ new Set(),
+			prunedThreadRelativePaths: /* @__PURE__ */ new Map()
+		};
+		yield* sql.withTransaction(Effect.gen(function* () {
+			for (const projector of projectors) if (projector.eventTypes.includes(event.type)) yield* projector.apply(event, attachmentSideEffects);
+			yield* sql`
+            INSERT INTO projection_state ${sql.insert(projectors.map((projector) => ({
+				projector: projector.name,
+				last_applied_sequence: event.sequence,
+				updated_at: event.occurredAt
+			})))}
+            ON CONFLICT(projector) DO UPDATE SET
+              last_applied_sequence = excluded.last_applied_sequence,
+              updated_at = excluded.updated_at
+          `;
+		}));
+		yield* runAttachmentSideEffects(attachmentSideEffects).pipe(Effect.catch((cause) => Effect.logWarning("failed to apply projected attachment side-effects", {
 			sequence: event.sequence,
 			eventType: event.type,
 			cause
 		})));
-	});
-	const bootstrapProjector = (projector) => projectionStateRepository.getByProjector({ projector: projector.name }).pipe(Effect.flatMap((stateRow) => Stream.runForEach(eventStore.readFromSequence(Option.isSome(stateRow) ? stateRow.value.lastAppliedSequence : 0, Number.MAX_SAFE_INTEGER), (event) => runProjectorForEvent(projector, event))));
-	const projectEvent = (event) => Effect.forEach(projectors, (projector) => runProjectorForEvent(projector, event), { concurrency: 1 }).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path$1.Path, path), Effect.provideService(ServerConfig$1, serverConfig), Effect.asVoid, Effect.catchTag("SqlError", (sqlError) => Effect.fail(toPersistenceSqlError("ProjectionPipeline.projectEvent:query")(sqlError))));
-	return {
-		bootstrap: Effect.forEach(projectors, bootstrapProjector, { concurrency: 1 }).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path$1.Path, path), Effect.provideService(ServerConfig$1, serverConfig), Effect.asVoid, Effect.tap(() => Effect.logDebug("orchestration projection pipeline bootstrapped").pipe(Effect.annotateLogs({ projectors: projectors.length }))), Effect.catchTag("SqlError", (sqlError) => Effect.fail(toPersistenceSqlError("ProjectionPipeline.bootstrap:query")(sqlError)))),
+	}).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path$1.Path, path), Effect.provideService(ServerConfig$1, serverConfig), Effect.catchTag("SqlError", (sqlError) => Effect.fail(toPersistenceSqlError("ProjectionPipeline.projectEvent:query")(sqlError))));
+	return {
+		bootstrap: Effect.gen(function* () {
+			const head = (yield* sql`
+        SELECT sequence, occurred_at AS "occurredAt"
+        FROM orchestration_events ORDER BY sequence DESC LIMIT 1
+      `)[0];
+			if (head !== void 0) for (const projector of projectors) yield* bootstrapProjector(projector, head);
+		}).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path$1.Path, path), Effect.provideService(ServerConfig$1, serverConfig), Effect.tap(() => Effect.logDebug("orchestration projection pipeline bootstrapped", { projectors: projectors.length })), Effect.catchTag("SqlError", (sqlError) => Effect.fail(toPersistenceSqlError("ProjectionPipeline.bootstrap:query")(sqlError)))),
 		projectEvent
 	};
 });
-const OrchestrationProjectionPipelineLive = Layer.effect(OrchestrationProjectionPipeline, makeOrchestrationProjectionPipeline()).pipe(Layer.provideMerge(ProjectionProjectRepositoryLive), Layer.provideMerge(ProjectionThreadRepositoryLive), Layer.provideMerge(ProjectionThreadMessageRepositoryLive), Layer.provideMerge(ProjectionThreadProposedPlanRepositoryLive), Layer.provideMerge(ProjectionThreadScheduledTaskRepositoryLive), Layer.provideMerge(ProjectionThreadActivityRepositoryLive), Layer.provideMerge(ProjectionThreadSessionRepositoryLive), Layer.provideMerge(ProjectionTurnRepositoryLive), Layer.provideMerge(ProjectionPendingApprovalRepositoryLive), Layer.provideMerge(ProjectionStateRepositoryLive));
+const OrchestrationProjectionPipelineLive = Layer.effect(OrchestrationProjectionPipeline, makeOrchestrationProjectionPipeline()).pipe(Layer.provideMerge(ProjectionProjectRepositoryLive), Layer.provideMerge(ProjectionThreadRepositoryLive), Layer.provideMerge(ProjectionThreadMessageRepositoryLive), Layer.provideMerge(ProjectionThreadProposedPlanRepositoryLive), Layer.provideMerge(ProjectionThreadScheduledTaskRepositoryLive), Layer.provideMerge(ProjectionThreadQueuedMessageRepositoryLive), Layer.provideMerge(ProjectionThreadActivityRepositoryLive), Layer.provideMerge(ProjectionThreadSessionRepositoryLive), Layer.provideMerge(ProjectionTurnRepositoryLive), Layer.provideMerge(ProjectionPendingApprovalRepositoryLive), Layer.provideMerge(ProjectionStateRepositoryLive));
 //#endregion
 //#region src/persistence/Services/ProjectionCheckpoints.ts
 /**
@@ -42496,6 +43095,10 @@ function deriveLocalBranchNameFromRemoteRef$1(branchName) {
 	if (firstSeparatorIndex <= 0 || firstSeparatorIndex === branchName.length - 1) return branchName;
 	return branchName.slice(firstSeparatorIndex + 1);
 }
+function buildTemporaryWorktreeBranchName(randomHex) {
+	const token = randomHex(4).toLowerCase().replace(/[^0-9a-f]/g, "").slice(0, 8);
+	return `${WORKTREE_BRANCH_PREFIX}/${token}`;
+}
 function isTemporaryWorktreeBranch(refName) {
 	return TEMP_WORKTREE_BRANCH_PATTERN.test(refName.trim().toLowerCase());
 }
@@ -43170,6 +43773,24 @@ function mapScheduledTaskRow(row) {
 		failure: row.failure
 	};
 }
+function mapQueuedMessageRow(row) {
+	return {
+		messageId: row.messageId,
+		text: row.text,
+		attachments: row.attachments,
+		...row.modelSelection !== null ? { modelSelection: row.modelSelection } : {},
+		createdAt: row.createdAt
+	};
+}
+function groupQueuedMessagesByThread(rows) {
+	const byThread = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const messages = byThread.get(row.threadId) ?? [];
+		messages.push(mapQueuedMessageRow(row));
+		byThread.set(row.threadId, messages);
+	}
+	return byThread;
+}
 function groupScheduledTasksByThread(rows) {
 	const byThread = /* @__PURE__ */ new Map();
 	for (const row of rows) {
@@ -43516,6 +44137,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
           pin_order_key AS "pinOrderKey",
+          parent_thread_id AS "parentThreadId",
           latest_user_message_at AS "latestUserMessageAt",
           pending_approval_count AS "pendingApprovalCount",
           pending_user_input_count AS "pendingUserInputCount",
@@ -43562,6 +44184,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
           pin_order_key AS "pinOrderKey",
+          parent_thread_id AS "parentThreadId",
           latest_user_message_at AS "latestUserMessageAt",
           pending_approval_count AS "pendingApprovalCount",
           pending_user_input_count AS "pendingUserInputCount",
@@ -43610,6 +44233,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
           pin_order_key AS "pinOrderKey",
+          parent_thread_id AS "parentThreadId",
           latest_user_message_at AS "latestUserMessageAt",
           pending_approval_count AS "pendingApprovalCount",
           pending_user_input_count AS "pendingUserInputCount",
@@ -43675,6 +44299,33 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           failure
         FROM projection_thread_scheduled_tasks
         ORDER BY thread_id ASC, run_at ASC, task_id ASC
+      `
+	});
+	const queuedMessageColumns = sql`
+    message_id AS "messageId",
+    thread_id AS "threadId",
+    text,
+    attachments_json AS "attachments",
+    model_selection_json AS "modelSelection",
+    created_at AS "createdAt"
+  `;
+	const listThreadQueuedMessageRows = SqlSchema.findAll({
+		Request: Schema$1.Void,
+		Result: ProjectionThreadQueuedMessage,
+		execute: () => sql`
+        SELECT ${queuedMessageColumns}
+        FROM projection_thread_queued_messages
+        ORDER BY thread_id ASC, rowid ASC
+      `
+	});
+	const listThreadQueuedMessageRowsByThread = SqlSchema.findAll({
+		Request: ThreadIdLookupInput,
+		Result: ProjectionThreadQueuedMessage,
+		execute: ({ threadId }) => sql`
+        SELECT ${queuedMessageColumns}
+        FROM projection_thread_queued_messages
+        WHERE thread_id = ${threadId}
+        ORDER BY rowid ASC
       `
 	});
 	const listThreadScheduledTaskRowsByThread = SqlSchema.findAll({
@@ -44117,6 +44768,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
           pin_order_key AS "pinOrderKey",
+          parent_thread_id AS "parentThreadId",
           latest_user_message_at AS "latestUserMessageAt",
           pending_approval_count AS "pendingApprovalCount",
           pending_user_input_count AS "pendingUserInputCount",
@@ -44731,9 +45383,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 		listLatestTurnRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getSnapshot:listLatestTurns:query", "ProjectionSnapshotQuery.getSnapshot:listLatestTurns:decodeRows"))),
 		listProjectionStateRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getSnapshot:listProjectionState:query", "ProjectionSnapshotQuery.getSnapshot:listProjectionState:decodeRows"))),
 		listThreadPairRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getSnapshot:listThreadPairs:query", "ProjectionSnapshotQuery.getSnapshot:listThreadPairs:decodeRows"))),
-		listThreadScheduledTaskRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getSnapshot:listThreadScheduledTasks:query", "ProjectionSnapshotQuery.getSnapshot:listThreadScheduledTasks:decodeRows")))
-	])).pipe(Effect.flatMap(([projectRows, threadRows, messageRows, proposedPlanRows, activityRows, sessionRows, checkpointRows, turnRows, latestTurnRows, stateRows, threadPairRows, scheduledTaskRows]) => Effect.gen(function* () {
+		listThreadScheduledTaskRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getSnapshot:listThreadScheduledTasks:query", "ProjectionSnapshotQuery.getSnapshot:listThreadScheduledTasks:decodeRows"))),
+		listThreadQueuedMessageRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getSnapshot:listThreadQueuedMessages:query", "ProjectionSnapshotQuery.getSnapshot:listThreadQueuedMessages:decodeRows")))
+	])).pipe(Effect.flatMap(([projectRows, threadRows, messageRows, proposedPlanRows, activityRows, sessionRows, checkpointRows, turnRows, latestTurnRows, stateRows, threadPairRows, scheduledTaskRows, queuedMessageRows]) => Effect.gen(function* () {
 		const scheduledTasksByThread = groupScheduledTasksByThread(scheduledTaskRows);
+		const queuedMessagesByThread = groupQueuedMessagesByThread(queuedMessageRows);
 		const messagesByThread = /* @__PURE__ */ new Map();
 		const proposedPlansByThread = /* @__PURE__ */ new Map();
 		const activitiesByThread = /* @__PURE__ */ new Map();
@@ -44862,10 +45516,12 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			snoozedAt: row.snoozedAt,
 			pinnedAt: row.pinnedAt,
 			pinOrderKey: row.pinOrderKey ?? null,
+			parentThreadId: row.parentThreadId ?? null,
 			deletedAt: row.deletedAt,
 			messages: messagesByThread.get(row.threadId) ?? [],
 			proposedPlans: proposedPlansByThread.get(row.threadId) ?? [],
 			scheduledTasks: scheduledTasksByThread.get(row.threadId) ?? [],
+			queuedMessages: queuedMessagesByThread.get(row.threadId) ?? [],
 			activities: activitiesByThread.get(row.threadId) ?? [],
 			checkpoints: checkpointsByThread.get(row.threadId) ?? [],
 			session: sessionsByThread.get(row.threadId) ?? null
@@ -44977,9 +45633,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 		listLatestTurnRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getCommandReadModel:listLatestTurns:query", "ProjectionSnapshotQuery.getCommandReadModel:listLatestTurns:decodeRows"))),
 		listProjectionStateRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getCommandReadModel:listProjectionState:query", "ProjectionSnapshotQuery.getCommandReadModel:listProjectionState:decodeRows"))),
 		listThreadPairRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getCommandReadModel:listThreadPairs:query", "ProjectionSnapshotQuery.getCommandReadModel:listThreadPairs:decodeRows"))),
-		listThreadScheduledTaskRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getCommandReadModel:listThreadScheduledTasks:query", "ProjectionSnapshotQuery.getCommandReadModel:listThreadScheduledTasks:decodeRows")))
-	])).pipe(Effect.flatMap(([projectRows, threadRows, proposedPlanRows, sessionRows, latestTurnRows, stateRows, threadPairRows, scheduledTaskRows]) => Effect.sync(() => {
+		listThreadScheduledTaskRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getCommandReadModel:listThreadScheduledTasks:query", "ProjectionSnapshotQuery.getCommandReadModel:listThreadScheduledTasks:decodeRows"))),
+		listThreadQueuedMessageRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getCommandReadModel:listThreadQueuedMessages:query", "ProjectionSnapshotQuery.getCommandReadModel:listThreadQueuedMessages:decodeRows")))
+	])).pipe(Effect.flatMap(([projectRows, threadRows, proposedPlanRows, sessionRows, latestTurnRows, stateRows, threadPairRows, scheduledTaskRows, queuedMessageRows]) => Effect.sync(() => {
 		const scheduledTasksByThread = groupScheduledTasksByThread(scheduledTaskRows);
+		const queuedMessagesByThread = groupQueuedMessagesByThread(queuedMessageRows);
 		let updatedAt = null;
 		const projects = [];
 		const threads = [];
@@ -45078,10 +45736,12 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 				snoozedAt: row.snoozedAt,
 				pinnedAt: row.pinnedAt,
 				pinOrderKey: row.pinOrderKey ?? null,
+				parentThreadId: row.parentThreadId ?? null,
 				deletedAt: row.deletedAt,
 				messages: [],
 				proposedPlans: proposedPlansByThread.get(row.threadId) ?? [],
 				scheduledTasks: scheduledTasksByThread.get(row.threadId) ?? [],
+				queuedMessages: queuedMessagesByThread.get(row.threadId) ?? [],
 				activities: [],
 				checkpoints: [],
 				session: sessionByThread.get(row.threadId) ?? null
@@ -45151,6 +45811,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 				snoozedAt: row.snoozedAt,
 				pinnedAt: row.pinnedAt,
 				pinOrderKey: row.pinOrderKey ?? null,
+				parentThreadId: row.parentThreadId ?? null,
 				session: sessionByThread.get(row.threadId) ?? null,
 				latestUserMessageAt: row.latestUserMessageAt,
 				hasPendingApprovals: row.pendingApprovalCount > 0,
@@ -45224,6 +45885,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 				snoozedAt: row.snoozedAt,
 				pinnedAt: row.pinnedAt,
 				pinOrderKey: row.pinOrderKey ?? null,
+				parentThreadId: row.parentThreadId ?? null,
 				session: sessionByThread.get(row.threadId) ?? null,
 				latestUserMessageAt: row.latestUserMessageAt,
 				hasPendingApprovals: row.pendingApprovalCount > 0,
@@ -45367,6 +46029,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			snoozedAt: threadRow.value.snoozedAt,
 			pinnedAt: threadRow.value.pinnedAt,
 			pinOrderKey: threadRow.value.pinOrderKey ?? null,
+			parentThreadId: threadRow.value.parentThreadId ?? null,
 			session: Option.isSome(sessionRow) ? mapSessionRow(sessionRow.value) : null,
 			latestUserMessageAt: threadRow.value.latestUserMessageAt,
 			hasPendingApprovals: threadRow.value.pendingApprovalCount > 0,
@@ -45398,7 +46061,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 		})).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:listActivities:query", "ProjectionSnapshotQuery.getThreadDetailById:listActivities:decodeRows")), Effect.map((rows) => rows.map(mapThreadActivityRow)));
 		const threadRow = yield* getThreadRowById({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:getThread:query", "ProjectionSnapshotQuery.getThreadDetailById:getThread:decodeRow")));
 		if (Option.isNone(threadRow)) return Option.none();
-		const [messageRows, proposedPlanRows, activities, checkpointRows, turnRows, latestTurnRow, sessionRow, scheduledTaskRows] = yield* Effect.all([
+		const [messageRows, proposedPlanRows, activities, checkpointRows, turnRows, latestTurnRow, sessionRow, scheduledTaskRows, queuedMessageRows] = yield* Effect.all([
 			(bounds === void 0 ? listThreadMessageRowsByThread({ threadId }) : listThreadMessageRowsByThreadWindow({
 				threadId,
 				...bounds
@@ -45409,7 +46072,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			listTurnSummaryRowsByThread({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:listTurnSummaries:query", "ProjectionSnapshotQuery.getThreadDetailById:listTurnSummaries:decodeRows"))),
 			getLatestTurnRowByThread({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:getLatestTurn:query", "ProjectionSnapshotQuery.getThreadDetailById:getLatestTurn:decodeRow"))),
 			getThreadSessionRowByThread({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:getSession:query", "ProjectionSnapshotQuery.getThreadDetailById:getSession:decodeRow"))),
-			listThreadScheduledTaskRowsByThread({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:listScheduledTasks:query", "ProjectionSnapshotQuery.getThreadDetailById:listScheduledTasks:decodeRows")))
+			listThreadScheduledTaskRowsByThread({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:listScheduledTasks:query", "ProjectionSnapshotQuery.getThreadDetailById:listScheduledTasks:decodeRows"))),
+			listThreadQueuedMessageRowsByThread({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:listQueuedMessages:query", "ProjectionSnapshotQuery.getThreadDetailById:listQueuedMessages:decodeRows")))
 		]);
 		const thread = {
 			id: threadRow.value.threadId,
@@ -45441,6 +46105,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			snoozedAt: threadRow.value.snoozedAt,
 			pinnedAt: threadRow.value.pinnedAt,
 			pinOrderKey: threadRow.value.pinOrderKey ?? null,
+			parentThreadId: threadRow.value.parentThreadId ?? null,
 			deletedAt: null,
 			messages: messageRows.map((row) => {
 				const message = {
@@ -45457,6 +46122,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			}),
 			proposedPlans: proposedPlanRows.map(mapProposedPlanRow),
 			scheduledTasks: scheduledTaskRows.map(mapScheduledTaskRow),
+			queuedMessages: queuedMessageRows.map(mapQueuedMessageRow),
 			activities,
 			checkpoints: checkpointRows.map((row) => ({
 				turnId: row.turnId,
@@ -48273,6 +48939,7 @@ const make$96 = Effect.gen(function* () {
 			threadPinning: true,
 			threadFork: true,
 			threadScheduledTasks: true,
+			threadMessageQueue: true,
 			...serverSelfUpdate === null ? {} : { serverSelfUpdate },
 			...serverServiceSupervised ? { serverServiceSupervised } : {}
 		}
@@ -58019,11 +58686,22 @@ const requireThreadControlTarget = Effect.fn("mcp.requireThreadControlTarget")(f
 		invocation,
 		threadId: invocation.threadId
 	};
-	if (!invocation.controlThreadIds?.has(requested)) return yield* new ThreadControlNotPermittedError({ threadId: requested });
-	return {
+	if (invocation.controlThreadIds?.has(requested)) return {
 		invocation,
 		threadId: requested
 	};
+	if (yield* isChildOfInvocationThread(invocation.threadId, requested)) return {
+		invocation,
+		threadId: requested
+	};
+	return yield* new ThreadControlNotPermittedError({ threadId: requested });
+});
+/** Whether `childThreadId` was spawned by `parentThreadId` as a sub-thread. */
+const isChildOfInvocationThread = Effect.fn("mcp.isChildOfInvocationThread")(function* (parentThreadId, childThreadId) {
+	const query = yield* Effect.serviceOption(ProjectionSnapshotQuery);
+	if (Option.isNone(query)) return false;
+	const shell = yield* query.value.getThreadShellById(childThreadId).pipe(Effect.catch(() => Effect.succeed(Option.none())));
+	return Option.isSome(shell) && shell.value.parentThreadId === parentThreadId;
 });
 /**
 * The guard on starting a thread, which is a different question from acting on
@@ -67235,7 +67913,7 @@ function parseCpaModelDefinitions(json, provider) {
 			id,
 			name: stringOr(raw.display_name) ?? id,
 			family: familyOf(id),
-			...created ? { releaseDate: (/* @__PURE__ */ new Date(created * 1e3)).toISOString() } : {},
+			...created ? { releaseDate: DateTime.formatIso(DateTime.makeUnsafe(created * 1e3)) } : {},
 			...contextTokens ? { contextTokens } : {},
 			...Array.isArray(levels) ? { effort: levels.filter((level) => typeof level === "string") } : {}
 		}];
@@ -67294,7 +67972,7 @@ function parseOpenRouter(json) {
 			id,
 			name: (stringOr(raw.name) ?? id).replace(/^[^:]+:\s*/, ""),
 			family: familyOf(id),
-			...created ? { releaseDate: (/* @__PURE__ */ new Date(created * 1e3)).toISOString() } : {},
+			...created ? { releaseDate: DateTime.formatIso(DateTime.makeUnsafe(created * 1e3)) } : {},
 			...contextTokens ? { contextTokens } : {}
 		});
 	}
@@ -94144,6 +94822,31 @@ const makeCodexSessionRuntime = (options) => Effect.gen(function* () {
 				...options.fusionPromptSettings ? { fusionPromptSettings: options.fusionPromptSettings } : {},
 				...input.unpromptedSubagents !== void 0 ? { unpromptedSubagents: input.unpromptedSubagents } : {}
 			});
+			const activeSession = yield* Ref.get(sessionRef);
+			if (activeSession.status === "running" && activeSession.activeTurnId !== void 0) {
+				const steeredTurnId = activeSession.activeTurnId;
+				const steerExit = yield* client.raw.request("turn/steer", {
+					threadId: providerThreadId,
+					expectedTurnId: steeredTurnId,
+					input: params.input
+				}).pipe(Effect.exit);
+				if (Exit.isSuccess(steerExit)) {
+					const steeredProviderThreadId = currentProviderThreadId(yield* Ref.get(sessionRef));
+					return {
+						threadId: options.threadId,
+						turnId: steeredTurnId,
+						...steeredProviderThreadId ? { resumeCursor: { threadId: steeredProviderThreadId } } : {}
+					};
+				}
+				if (findActiveCodexTurnId(yield* client.request("thread/read", {
+					threadId: providerThreadId,
+					includeTurns: true
+				})) === steeredTurnId) {
+					yield* Effect.logWarning("Codex turn/steer failed while the turn is still running.", { cause: steerExit.cause });
+					return yield* Effect.failCause(steerExit.cause);
+				}
+				yield* Effect.logInfo("Codex turn ended before the steer landed; starting a new turn.");
+			}
 			const { collaborationMode: attachedCollaborationMode, ...paramsWithoutCollaboration } = params;
 			const lastCollaborationMode = yield* Ref.get(lastCollaborationModeRef);
 			const requestParams = attachedCollaborationMode !== void 0 && lastCollaborationMode !== null && isSameCollaborationMode(attachedCollaborationMode, lastCollaborationMode) ? paramsWithoutCollaboration : params;
@@ -125052,6 +125755,86 @@ const make$36 = Effect.gen(function* () {
 				...cleanup === void 0 ? {} : { cleanup }
 			});
 		}
+		const finishMergedCleanup = Effect.fn("ThreadWorkspaceLifecycle.finishMergedCleanup")(function* (input) {
+			yield* record({
+				threadIds,
+				lifecycle: {
+					status: "cleanup-pending",
+					detail: "Merged context recorded; workspace cleanup is pending.",
+					pullRequestNumber: input.merged.pullRequestNumber,
+					mergeCommitSha: input.merged.mergeCommitSha,
+					updatedAt: now,
+					...cleanup === void 0 ? {} : { cleanup }
+				}
+			});
+			yield* cleanGeneratedFiles();
+			if (cleanup === void 0 || cleanup.worktree) yield* gitWorkflow.removeWorktree({
+				cwd: project.workspaceRoot,
+				path: worktreePath,
+				...cleanup?.forceWorktree ? { force: true } : {}
+			});
+			if (cleanup === void 0 || cleanup.localBranch) yield* git.execute({
+				operation: "ThreadWorkspaceLifecycle.deleteBranch",
+				cwd: project.workspaceRoot,
+				args: [
+					"update-ref",
+					"-d",
+					`refs/heads/${input.branch}`,
+					input.branchCommitSha
+				]
+			}).pipe(Effect.catchCause((cause) => gitWorkflow.createWorktree({
+				cwd: project.workspaceRoot,
+				refName: input.branch,
+				path: worktreePath
+			}).pipe(Effect.andThen(Effect.failCause(cause)))));
+			const detail = cleanup === void 0 ? "Merged worktree and branch removed; thread context preserved." : "Selected archive resources removed; thread context preserved.";
+			yield* record({
+				threadIds,
+				lifecycle: {
+					status: "cleaned",
+					detail,
+					pullRequestNumber: input.merged.pullRequestNumber,
+					mergeCommitSha: input.merged.mergeCommitSha,
+					updatedAt: DateTime.formatIso(yield* DateTime.now)
+				}
+			});
+			return {
+				outcome: "cleaned",
+				detail
+			};
+		});
+		const parentThread = requestedThread.parentThreadId == null ? void 0 : snapshot.threads.find((thread) => thread.id === requestedThread.parentThreadId);
+		if (parentThread !== void 0 && !cleanup?.remoteBranch) {
+			if (yield* git.execute({
+				operation: "ThreadWorkspaceLifecycle.landedInParent",
+				cwd: parentThread.worktreePath ?? project.workspaceRoot,
+				args: [
+					"merge-base",
+					"--is-ancestor",
+					`refs/heads/${branch}`,
+					"HEAD"
+				],
+				allowNonZeroExit: true
+			}).pipe(Effect.map((result) => result.exitCode === 0), Effect.orElseSucceed(() => false))) {
+				const branchCommitSha = (yield* git.execute({
+					operation: "ThreadWorkspaceLifecycle.branchCommit",
+					cwd: project.workspaceRoot,
+					args: [
+						"rev-parse",
+						"--verify",
+						`refs/heads/${branch}^{commit}`
+					]
+				})).stdout.trim();
+				return yield* finishMergedCleanup({
+					branch,
+					branchCommitSha,
+					merged: {
+						mergeCommitSha: branchCommitSha,
+						pullRequestNumber: null
+					}
+				});
+			}
+		}
 		const refs = yield* gitWorkflow.listRefs({
 			cwd: project.workspaceRoot,
 			includeMatchingRemoteRefs: true,
@@ -125164,52 +125947,11 @@ const make$36 = Effect.gen(function* () {
 				}).pipe(Effect.result))._tag === "Failure") return yield* workspaceRefusal("Cleanup refused because the remote branch could not be removed.");
 			}
 		}
-		yield* record({
-			threadIds,
-			lifecycle: {
-				status: "cleanup-pending",
-				detail: "Merged context recorded; workspace cleanup is pending.",
-				pullRequestNumber: merged.pullRequestNumber,
-				mergeCommitSha: merged.mergeCommitSha,
-				updatedAt: now,
-				...cleanup === void 0 ? {} : { cleanup }
-			}
-		});
-		yield* cleanGeneratedFiles();
-		if (cleanup === void 0 || cleanup.worktree) yield* gitWorkflow.removeWorktree({
-			cwd: project.workspaceRoot,
-			path: worktreePath,
-			...cleanup?.forceWorktree ? { force: true } : {}
-		});
-		if (cleanup === void 0 || cleanup.localBranch) yield* git.execute({
-			operation: "ThreadWorkspaceLifecycle.deleteBranch",
-			cwd: project.workspaceRoot,
-			args: [
-				"update-ref",
-				"-d",
-				`refs/heads/${branch}`,
-				branchCommitResult.stdout.trim()
-			]
-		}).pipe(Effect.catchCause((cause) => gitWorkflow.createWorktree({
-			cwd: project.workspaceRoot,
-			refName: branch,
-			path: worktreePath
-		}).pipe(Effect.andThen(Effect.failCause(cause)))));
-		const detail = cleanup === void 0 ? "Merged worktree and branch removed; thread context preserved." : "Selected archive resources removed; thread context preserved.";
-		yield* record({
-			threadIds,
-			lifecycle: {
-				status: "cleaned",
-				detail,
-				pullRequestNumber: merged.pullRequestNumber,
-				mergeCommitSha: merged.mergeCommitSha,
-				updatedAt: DateTime.formatIso(yield* DateTime.now)
-			}
+		return yield* finishMergedCleanup({
+			branch,
+			branchCommitSha: branchCommitResult.stdout.trim(),
+			merged
 		});
-		return {
-			outcome: "cleaned",
-			detail
-		};
 	});
 	const cleanup = (threadId) => cleanupRaw(threadId).pipe(mapLifecycleError);
 	return {
@@ -133212,7 +133954,7 @@ function projectSetupScriptCompatibilityDetail(error) {
 	}
 }
 function isThreadDetailEvent(event) {
-	return event.type === "thread.message-sent" || event.type === "thread.archived" || event.type === "thread.unarchived" || event.type === "thread.deleted" || event.type === "thread.meta-updated" || event.type === "thread.proposed-plan-upserted" || event.type === "thread.scheduled-task.created" || event.type === "thread.scheduled-task.cancelled" || event.type === "thread.scheduled-task.fired" || event.type === "thread.activity-appended" || event.type === "thread.turn-diff-completed" || event.type === "thread.reverted" || event.type === "thread.session-set";
+	return event.type === "thread.message-sent" || event.type === "thread.message-queued" || event.type === "thread.queued-message-removed" || event.type === "thread.archived" || event.type === "thread.unarchived" || event.type === "thread.deleted" || event.type === "thread.meta-updated" || event.type === "thread.proposed-plan-upserted" || event.type === "thread.scheduled-task.created" || event.type === "thread.scheduled-task.cancelled" || event.type === "thread.scheduled-task.fired" || event.type === "thread.activity-appended" || event.type === "thread.turn-diff-completed" || event.type === "thread.reverted" || event.type === "thread.session-set";
 }
 const PROVIDER_STATUS_DEBOUNCE_MS = 200;
 const SHELL_RESUME_MAX_GAP = 1e3;
@@ -135254,7 +135996,7 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 			const next = new Map(records);
 			next.set(tokenHash, {
 				tokenHash,
-				scope: scopeWith(!spawnedThreads.has(threadId), spawnedThreads.get(threadId) === true),
+				scope: scopeWith(!(spawnedThreads.has(threadId) || request.spawned === true), spawnedThreads.get(threadId) === true),
 				controlThreadIds: /* @__PURE__ */ new Set(),
 				lastAliveAt: issuedAt
 			});
@@ -135657,7 +136399,8 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (options)
 			issue: "Could not read thread pairs, so the session's Fusion role is unknown. Refusing to issue an MCP credential that would carry no role.",
 			cause
 		}))) : yield* Effect.logWarning("No projection service, so an MCP credential is issued with no Fusion role. A pair whose event this process never saw will be ungated.", { threadId }).pipe(Effect.as(void 0));
-		const threadTitle = Option.isSome(projectionQuery) ? yield* projectionQuery.value.getThreadShellById(threadId).pipe(Effect.map((thread) => Option.isSome(thread) ? thread.value.title : void 0), Effect.catch(() => Effect.succeed(void 0))) : void 0;
+		const shell = Option.isSome(projectionQuery) ? yield* projectionQuery.value.getThreadShellById(threadId).pipe(Effect.map(Option.getOrUndefined), Effect.catch(() => Effect.succeed(void 0))) : void 0;
+		const threadTitle = shell?.title;
 		const credential = yield* issueActiveMcpCredential({
 			threadId,
 			...threadTitle ? { threadTitle } : {},
@@ -135666,7 +136409,8 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (options)
 			computerUseAccess,
 			...watchThreadIds !== void 0 ? { watchThreadIds } : {},
 			...adviseThreadIds !== void 0 ? { adviseThreadIds } : {},
-			...fusionRole !== void 0 ? { fusionRole } : {}
+			...fusionRole !== void 0 ? { fusionRole } : {},
+			...shell?.parentThreadId != null ? { spawned: true } : {}
 		});
 		if (credential) yield* Effect.sync(() => setMcpProviderSession(credential.config));
 		return credential;
@@ -138151,6 +138895,196 @@ const TaskToolkitHandlersLive = TaskToolkit.toLayer({
 	})
 });
 //#endregion
+//#region ../../packages/shared/src/threadPendingWork.ts
+/**
+* A user message the server has not started a turn for yet, within the window
+* where adoption is still plausible. Mirrors `hasQueuedTurnStart` in
+* client-runtime, which owns the same window for settle/snooze decisions.
+*/
+const QUEUED_TURN_START_GRACE_MS = 120 * 1e3;
+function hasQueuedTurn(input, nowMs) {
+	if (input.latestUserMessageAt == null) return false;
+	if (input.session?.status === "error") return false;
+	const messageAtMs = Date.parse(input.latestUserMessageAt);
+	if (Number.isNaN(messageAtMs)) return false;
+	if (Math.abs(nowMs - messageAtMs) > QUEUED_TURN_START_GRACE_MS) return false;
+	const turn = input.latestTurn;
+	if (turn === null) return true;
+	return [
+		turn.requestedAt,
+		turn.startedAt,
+		turn.completedAt
+	].every((candidate) => candidate == null || Date.parse(candidate) < messageAtMs);
+}
+/**
+* What the thread is waiting on, or null when it is genuinely idle. A running
+* session answers null: the agent is working, which callers already show.
+*/
+function resolveThreadPendingWork(input, options) {
+	const nowMs = Date.parse(options.now);
+	if (Number.isNaN(nowMs)) return null;
+	if (input.session?.status === "starting" || input.session?.status === "running") return null;
+	if (hasQueuedTurn(input, nowMs)) return "queued";
+	if (input.session === null) return null;
+	if (input.hasBackgroundTasks === true) return "background";
+	if (input.scheduledWakeAt != null) {
+		const wakeAtMs = Date.parse(input.scheduledWakeAt);
+		if (!Number.isNaN(wakeAtMs) && wakeAtMs > nowMs) return "scheduled";
+	}
+	return null;
+}
+//#endregion
+//#region src/mcp/toolkits/threads/subThreadState.ts
+/**
+* Where a sub-thread stands, for a parent deciding what to do next. A
+* question or approval outranks running: the session keeps reporting running
+* while it waits, but nothing moves until someone answers.
+*/
+function resolveSubThreadState(shell, now) {
+	if (shell === void 0) return "missing";
+	if (shell.archivedAt !== null) return "completed";
+	if (shell.hasPendingApprovals || shell.hasPendingUserInput) return "needs-input";
+	const status = shell.session?.status;
+	if (status === "running" || status === "starting") return "running";
+	if (resolveThreadPendingWork(shell, { now }) !== null) return "running";
+	if (status === "error" || shell.latestTurn?.state === "error") return "failed";
+	return "completed";
+}
+/** Whether a wait in `mode` is over for these states. */
+function isSubThreadWaitSatisfied(states, mode) {
+	const stopped = (state) => state !== "running";
+	return mode === "any" ? states.some(stopped) : states.every(stopped);
+}
+//#endregion
+//#region src/orchestration/SubThreadWorkspace.ts
+/**
+* Git steps for sub-threads: a child gets its own worktree branched from the
+* parent's current HEAD, and lands by merging back into the parent's worktree.
+*/
+const repositoryLocks = /* @__PURE__ */ new Map();
+const withRepositoryLock = (repositoryRoot) => {
+	let lock = repositoryLocks.get(repositoryRoot);
+	if (lock === void 0) {
+		lock = Semaphore.makeUnsafe(1);
+		repositoryLocks.set(repositoryRoot, lock);
+	}
+	return lock.withPermits(1);
+};
+const runGit = (operation, cwd, args) => Effect.gen(function* () {
+	return yield* (yield* GitVcsDriver).execute({
+		operation: `SubThreadWorkspace.${operation}`,
+		cwd,
+		args,
+		allowNonZeroExit: true
+	});
+});
+/** The branch checked out at `cwd`, or null on a detached HEAD. */
+const currentBranch = (cwd) => runGit("currentBranch", cwd, [
+	"symbolic-ref",
+	"--quiet",
+	"--short",
+	"HEAD"
+]).pipe(Effect.map((result) => result.exitCode === 0 ? result.stdout.trim() || null : null));
+/** Whether `cwd` has uncommitted changes, untracked files included. */
+const hasUncommittedChanges = (cwd) => runGit("status", cwd, ["status", "--porcelain"]).pipe(Effect.map((result) => result.stdout.trim().length > 0));
+const headCommit = (cwd) => runGit("headCommit", cwd, [
+	"rev-parse",
+	"--verify",
+	"HEAD^{commit}"
+]).pipe(Effect.map((result) => result.exitCode === 0 ? result.stdout.trim() : null));
+/** Creates the child's worktree on a new branch at the parent's HEAD commit. */
+const provisionChildWorktree = Effect.fn("SubThreadWorkspace.provisionChildWorktree")(function* (input) {
+	const gitWorkflow = yield* GitWorkflowService;
+	return yield* Effect.gen(function* () {
+		const baseCommitSha = yield* headCommit(input.parentCwd);
+		if (baseCommitSha === null) return null;
+		const parentBranch = yield* currentBranch(input.parentCwd);
+		const parentDirty = yield* hasUncommittedChanges(input.parentCwd);
+		const created = yield* gitWorkflow.createWorktree({
+			cwd: input.repositoryRoot,
+			refName: baseCommitSha,
+			newRefName: input.branch,
+			...parentBranch !== null ? { baseRefName: parentBranch } : {},
+			path: null
+		});
+		return {
+			worktreePath: created.worktree.path,
+			branch: created.worktree.refName,
+			baseCommitSha,
+			parentBranch,
+			parentDirty
+		};
+	}).pipe(withRepositoryLock(input.repositoryRoot));
+});
+/** Undoes `provisionChildWorktree` when the thread it was made for never appeared. */
+const discardChildWorktree = Effect.fn("SubThreadWorkspace.discardChildWorktree")(function* (input) {
+	yield* (yield* GitWorkflowService).removeWorktree({
+		cwd: input.repositoryRoot,
+		path: input.worktreePath,
+		force: true
+	}).pipe(Effect.ignore);
+	yield* runGit("deleteBranch", input.repositoryRoot, [
+		"branch",
+		"-D",
+		input.branch
+	]).pipe(Effect.ignore);
+});
+/**
+* Merges the child's branch into the parent's worktree. A conflict is aborted
+* so the parent stays clean, and the conflicted files come back for the child
+* to resolve on its own branch.
+*/
+const mergeChildIntoParent = Effect.fn("SubThreadWorkspace.mergeChildIntoParent")(function* (input) {
+	const childBranch = yield* currentBranch(input.childCwd);
+	if (childBranch === null) return {
+		outcome: "refused",
+		detail: "The child worktree is on a detached HEAD."
+	};
+	if (yield* hasUncommittedChanges(input.childCwd)) return {
+		outcome: "refused",
+		detail: `The child has uncommitted changes on '${childBranch}'. Ask it to commit first.`
+	};
+	if (yield* hasUncommittedChanges(input.parentCwd)) return {
+		outcome: "refused",
+		detail: "The parent worktree has uncommitted changes. Commit or stash them before merging."
+	};
+	return yield* Effect.gen(function* () {
+		const parentBranch = yield* currentBranch(input.parentCwd);
+		const merge = yield* runGit("merge", input.parentCwd, [
+			"merge",
+			"--no-ff",
+			"--no-edit",
+			`refs/heads/${childBranch}`
+		]);
+		if (merge.exitCode === 0) {
+			const mergeCommitSha = (yield* headCommit(input.parentCwd)) ?? "";
+			return {
+				outcome: /already up[ -]to[ -]date/i.test(merge.stdout) ? "up-to-date" : "merged",
+				childBranch,
+				parentBranch,
+				mergeCommitSha
+			};
+		}
+		const conflicted = yield* runGit("conflictedFiles", input.parentCwd, [
+			"diff",
+			"--name-only",
+			"--diff-filter=U"
+		]);
+		yield* runGit("abortMerge", input.parentCwd, ["merge", "--abort"]);
+		const conflictedFiles = conflicted.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+		if (conflictedFiles.length === 0) return {
+			outcome: "refused",
+			detail: `git merge failed: ${merge.stderr.trim() || merge.stdout.trim()}`
+		};
+		return {
+			outcome: "conflicted",
+			childBranch,
+			parentBranch,
+			conflictedFiles
+		};
+	}).pipe(withRepositoryLock(input.repositoryRoot));
+});
+//#endregion
 //#region src/orchestration/fusionEvidenceReport.ts
 /**
 * Shared shape of one Fusion review's evidence rows.
@@ -138581,7 +139515,7 @@ const AskUserQuestionTool = Tool.make("ask_user_question", {
 	]
 }).annotate(Tool.Title, "Ask user question").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
 const ThreadSpawnTool = Tool.make("thread_spawn", {
-	description: "Start a new agent thread and send it a first message, then return its id. Use it to hand a piece of work to a fresh thread - a subtask you just planned, a job that wants its own transcript. For activation here or a new Fusion in this chat, use thread_pair_create with no watcherThreadId so this chat becomes Supervisor and its new Builder starts empty. Set fusion true only for an explicitly separate pair to create two new threads and send prompt to its supervisor, which plans and directs the builder later, even when this thread already belongs to a pair. Set fusionWatcher true only for legacy current-chat-as-builder pairing. Both use saved Fusion role models unless overridden. Act on the user's request; no special command syntax is required. The new thread inherits this one's project, model, permission mode, interaction mode, compression and subagent policy, and every one of those can be set here instead - what you set is already in force for the first turn, so a thread never has to be corrected after it starts. Set modelSelection to run it on another model: give the model id, and leave instanceId out to keep this thread's provider instance. Once started it can be watched with thread_watch_events and changed later with thread_configure. A thread that was itself started this way cannot start another.",
+	description: "Start a new agent thread and send it a first message, then return its id. Use it to hand a piece of work to a fresh thread - a subtask you just planned, a job that wants its own transcript. For activation here or a new Fusion in this chat, use thread_pair_create with no watcherThreadId so this chat becomes Supervisor and its new Builder starts empty. Set fusion true only for an explicitly separate pair to create two new threads and send prompt to its supervisor, which plans and directs the builder later, even when this thread already belongs to a pair. Set fusionWatcher true only for legacy current-chat-as-builder pairing. Both use saved Fusion role models unless overridden. Act on the user's request; no special command syntax is required. The new thread inherits this one's project, model, permission mode, interaction mode, compression and subagent policy, and every one of those can be set here instead - what you set is already in force for the first turn, so a thread never has to be corrected after it starts. Set modelSelection to run it on another model: give the model id, and leave instanceId out to keep this thread's provider instance. Once started it can be watched with thread_watch_events and changed later with thread_configure. A thread that was itself started this way cannot start another. A plain spawn is a sub-thread: it gets its own git worktree and branch from this thread's current HEAD commit (commit first), so several can work in parallel; wait on them with thread_wait, follow up with thread_message, land each with thread_merge_child, and remove it with thread_cleanup.",
 	parameters: ThreadSpawnInput,
 	success: ThreadSpawnResult,
 	failure: ThreadControlToolError,
@@ -138590,8 +139524,11 @@ const ThreadSpawnTool = Tool.make("thread_spawn", {
 		McpSessionRegistry,
 		OrchestrationEngineService,
 		ProjectionThreadRepository,
+		ProjectionSnapshotQuery,
 		ServerSettingsService,
 		ProviderRegistry,
+		GitWorkflowService,
+		GitVcsDriver,
 		Crypto.Crypto
 	]
 }).annotate(Tool.Title, "Start a thread").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
@@ -138648,6 +139585,7 @@ const ThreadCleanupTool = Tool.make("thread_cleanup", {
 		ProjectionThreadRepository,
 		ProjectionThreadSessionRepository,
 		ThreadWorkspaceLifecycleService,
+		TerminalManager,
 		Crypto.Crypto
 	]
 }).annotate(Tool.Title, "Archive and clean up thread").annotate(Tool.Readonly, false).annotate(Tool.Destructive, true).annotate(Tool.Idempotent, true);
@@ -138736,7 +139674,44 @@ const ThreadContextUpdateTool = Tool.make("thread_context_update", {
 		Crypto.Crypto
 	]
 }).annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
-const ThreadToolkit = Toolkit.make(ThreadContextReadTool, ThreadContextUpdateTool, ThreadPlanReadTool, ThreadPlanUpdateTool, AskUserQuestionTool, ThreadSpawnTool, ThreadPairCreateTool, ThreadPairDetachTool, ThreadConfigureTool, ThreadCleanupTool, ThreadSnoozeTool, ThreadRenameTool, MemoryAppendTool, AssetCompressTool);
+const ThreadWaitTool = Tool.make("thread_wait", {
+	description: "Wait for sub-threads you spawned to stop working, then return each one's state (running, needs-input, completed, failed, missing), branch, worktree and latest reply. mode 'all' (default) waits for every one; 'any' returns at the first, so you can merge or answer it while the others continue. Returns timedOut true after timeoutSeconds (default 45) with the current states; call again to keep waiting. Use this instead of polling thread_watch_events.",
+	parameters: ThreadWaitInput,
+	success: ThreadWaitResult,
+	failure: ThreadControlToolError,
+	dependencies: [
+		McpInvocationContext,
+		OrchestrationEngineService,
+		ProjectionSnapshotQuery,
+		ThreadEventStreamService,
+		ProjectionThreadMessageRepository
+	]
+}).annotate(Tool.Title, "Wait for sub-threads").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
+const ThreadMessageTool = Tool.make("thread_message", {
+	description: "Send a follow-up message to a sub-thread you spawned: a correction, an answer, or a request to resolve merge conflicts. If it is still working, the message waits until its current turn ends.",
+	parameters: ThreadMessageInput,
+	success: ThreadMessageResult,
+	failure: ThreadControlToolError,
+	dependencies: [
+		McpInvocationContext,
+		OrchestrationEngineService,
+		ProjectionSnapshotQuery,
+		Crypto.Crypto
+	]
+}).annotate(Tool.Title, "Message a sub-thread").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
+const ThreadMergeChildTool = Tool.make("thread_merge_child", {
+	description: "Merge a finished sub-thread's branch into this thread's worktree with a merge commit. Both worktrees must be committed and the sub-thread must have stopped. On conflict the merge is aborted, this worktree is left unchanged, and conflictedFiles lists the files: send them to the sub-thread with thread_message (ask it to merge this thread's branch, resolve, and commit), wait, then merge again. After landing, remove the sub-thread with thread_cleanup.",
+	parameters: ThreadMergeChildInput,
+	success: ThreadMergeChildResult,
+	failure: ThreadControlToolError,
+	dependencies: [
+		McpInvocationContext,
+		ProjectionSnapshotQuery,
+		GitWorkflowService,
+		GitVcsDriver
+	]
+}).annotate(Tool.Title, "Merge a sub-thread").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
+const ThreadToolkit = Toolkit.make(ThreadContextReadTool, ThreadContextUpdateTool, ThreadPlanReadTool, ThreadPlanUpdateTool, AskUserQuestionTool, ThreadSpawnTool, ThreadWaitTool, ThreadMessageTool, ThreadMergeChildTool, ThreadPairCreateTool, ThreadPairDetachTool, ThreadConfigureTool, ThreadCleanupTool, ThreadSnoozeTool, ThreadRenameTool, MemoryAppendTool, AssetCompressTool);
 //#endregion
 //#region src/orchestration/pendingMcpUserInputs.ts
 /**
@@ -138830,6 +139805,15 @@ const dispatchControl = Effect.fn("mcp.threads.dispatchControl")(function* (comm
 		detail: cause.message
 	})));
 });
+/** Events that can change a sub-thread's wait state; streaming deltas cannot. */
+const SUB_THREAD_WAKE_EVENTS = /* @__PURE__ */ new Set([
+	"thread.session-set",
+	"thread.turn-completed",
+	"thread.turn-start-requested",
+	"thread.activity-appended",
+	"thread.archived",
+	"thread.deleted"
+]);
 const newCommandId = Effect.gen(function* () {
 	const crypto = yield* Crypto.Crypto;
 	return CommandId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
@@ -139146,6 +140130,39 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 		const unpromptedSubagents = input.unpromptedSubagents ?? template.unpromptedSubagents === 1;
 		const threadId = ThreadId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
 		const createdAt = DateTime.formatIso(yield* DateTime.now);
+		const isFusionSpawn = input.fusion === true || input.fusionWatcher === true;
+		if (isFusionSpawn && input.workspace === "worktree") return yield* new ThreadSpawnNotPermittedError({
+			threadId: invocation.threadId,
+			detail: "Fusion spawns share this thread's checkout; omit workspace or pass 'shared'."
+		});
+		let childWorkspace = null;
+		if (!isFusionSpawn && input.workspace !== "shared" && !isChatProject(projectId)) {
+			const project = yield* (yield* ProjectionSnapshotQuery).getProjectShellById(projectId).pipe(Effect.map(Option.getOrUndefined), Effect.mapError((cause) => new ThreadSpawnNotPermittedError({
+				threadId: invocation.threadId,
+				detail: `the project could not be read to create a worktree: ${cause.message}`
+			})));
+			if (project !== void 0) {
+				const repositoryRoot = project.workspaceRoot;
+				const parentCwd = projectId === template.projectId ? template.worktreePath ?? repositoryRoot : repositoryRoot;
+				const hex = (yield* crypto.randomUUIDv4.pipe(Effect.orDie)).replaceAll("-", "");
+				const provisioned = yield* provisionChildWorktree({
+					repositoryRoot,
+					parentCwd,
+					branch: buildTemporaryWorktreeBranchName((bytes) => hex.slice(0, bytes * 2))
+				}).pipe(Effect.mapError((cause) => new ThreadSpawnNotPermittedError({
+					threadId: invocation.threadId,
+					detail: `the sub-thread's worktree could not be created: ${cause.message}`
+				})));
+				if (provisioned !== null) childWorkspace = {
+					...provisioned,
+					repositoryRoot
+				};
+			}
+			if (childWorkspace === null && input.workspace === "worktree") return yield* new ThreadSpawnNotPermittedError({
+				threadId: invocation.threadId,
+				detail: "the project is not a git repository with a commit, so it cannot have worktrees"
+			});
+		}
 		yield* dispatchControl({
 			type: "thread.create",
 			commandId: yield* newCommandId,
@@ -139157,10 +140174,11 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 			interactionMode,
 			compressMode,
 			unpromptedSubagents,
-			branch: null,
-			worktreePath: null,
+			branch: childWorkspace?.branch ?? null,
+			worktreePath: childWorkspace?.worktreePath ?? null,
+			...isFusionSpawn || projectId !== template.projectId ? {} : { parentThreadId: invocation.threadId },
 			createdAt
-		}, threadId);
+		}, threadId).pipe(Effect.tapError(() => childWorkspace === null ? Effect.void : discardChildWorktree(childWorkspace)));
 		yield* registry.recordSpawnedThread({
 			providerSessionId: invocation.providerSessionId,
 			threadId,
@@ -139229,7 +140247,13 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 			threadId,
 			projectId,
 			title: input.title,
-			...fusionPair
+			...fusionPair,
+			...childWorkspace === null ? {} : {
+				branch: childWorkspace.branch,
+				worktreePath: childWorkspace.worktreePath,
+				baseCommitSha: childWorkspace.baseCommitSha,
+				parentDirty: childWorkspace.parentDirty
+			}
 		};
 	}),
 	thread_pair_create: (input) => Effect.gen(function* () {
@@ -139486,6 +140510,11 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 		})));
 		const archivedThreadIds = result.events?.filter((event) => event.type === "thread.archived").map((event) => event.payload.threadId) ?? [];
 		archivedThreadIds.forEach(queueThreadWorkspaceCleanup);
+		const terminals = yield* TerminalManager;
+		yield* Effect.forEach(archivedThreadIds, (archivedThreadId) => terminals.close({ threadId: archivedThreadId }).pipe(Effect.catch((error) => Effect.logWarning("failed to close thread terminals after archive", {
+			threadId: archivedThreadId,
+			error: error.message
+		}))), { discard: true });
 		const stopRequested = new Set(result.events?.filter((event) => event.type === "thread.session-stop-requested").map((event) => event.payload.threadId) ?? []);
 		const session = yield* sessions.getByThreadId({ threadId }).pipe(Effect.mapError((cause) => new ThreadControlRejectedError({
 			threadId,
@@ -139648,6 +140677,126 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 			estimatedTokensAfter: estimateTokens(compressed),
 			warnings: validation.warnings
 		};
+	}),
+	thread_wait: (input) => Effect.gen(function* () {
+		const invocation = yield* requireThreadCapability();
+		const threadIds = [...new Set(input.threadIds)];
+		for (const threadId of threadIds) yield* requireThreadControlTarget(threadId);
+		const query = yield* ProjectionSnapshotQuery;
+		const engine = yield* OrchestrationEngineService;
+		const eventStream = yield* ThreadEventStreamService;
+		const messages = yield* ProjectionThreadMessageRepository;
+		const mode = input.mode ?? "all";
+		const rejected = (detail) => new ThreadControlRejectedError({
+			threadId: invocation.threadId,
+			commandType: "thread_wait",
+			detail
+		});
+		const check = Effect.gen(function* () {
+			const shells = yield* Effect.forEach(threadIds, (threadId) => query.getThreadShellById(threadId).pipe(Effect.map(Option.getOrUndefined)));
+			const now = DateTime.formatIso(yield* DateTime.now);
+			const states = shells.map((shell) => resolveSubThreadState(shell, now));
+			return {
+				shells,
+				states,
+				done: isSubThreadWaitSatisfied(states, mode)
+			};
+		}).pipe(Effect.mapError((cause) => rejected(cause.message)));
+		const head = yield* engine.latestSequence;
+		const initial = yield* check;
+		const settled = initial.done ? Option.some(initial) : yield* Stream.mergeAll(threadIds.map((threadId) => eventStream.watch({
+			threadId,
+			afterSequence: head
+		})), { concurrency: "unbounded" }).pipe(Stream.filter((item) => item.kind === "event" && SUB_THREAD_WAKE_EVENTS.has(item.event.type)), Stream.mapEffect(() => check), Stream.filter((result) => result.done), Stream.runHead, Effect.mapError((cause) => rejected(cause.message)), Effect.timeoutOption(Duration.seconds(input.timeoutSeconds ?? 45)), Effect.map(Option.flatten));
+		const final = Option.isSome(settled) ? settled.value : yield* check;
+		const children = yield* Effect.forEach(threadIds, (threadId, index) => Effect.gen(function* () {
+			const shell = final.shells[index];
+			const assistantMessageId = shell?.latestTurn?.assistantMessageId ?? null;
+			const reply = assistantMessageId === null ? null : yield* messages.getByMessageId({ messageId: assistantMessageId }).pipe(Effect.map((row) => Option.isSome(row) ? row.value.text : null), Effect.catch(() => Effect.succeed(null)));
+			return {
+				threadId,
+				title: shell?.title ?? null,
+				state: final.states[index] ?? "missing",
+				branch: shell?.branch ?? null,
+				worktreePath: shell?.worktreePath ?? null,
+				lastAssistantMessage: reply === null ? null : reply.length > 1500 ? `${reply.slice(0, 1500)}…` : reply,
+				lastError: shell?.session?.lastError ?? null
+			};
+		}));
+		return {
+			timedOut: Option.isNone(settled),
+			children
+		};
+	}),
+	thread_message: (input) => Effect.gen(function* () {
+		const { invocation, threadId } = yield* requireThreadControlTarget(input.threadId);
+		const rejected = (detail) => new ThreadControlRejectedError({
+			threadId,
+			commandType: "thread_message",
+			detail
+		});
+		if (threadId === invocation.threadId) return yield* rejected("Message a sub-thread, not this thread.");
+		const shell = yield* (yield* ProjectionSnapshotQuery).getThreadShellById(threadId).pipe(Effect.map(Option.getOrUndefined), Effect.mapError((cause) => rejected(cause.message)));
+		if (shell === void 0) return yield* rejected("The sub-thread is archived or no longer exists.");
+		const crypto = yield* Crypto.Crypto;
+		const messageId = MessageId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
+		yield* dispatchControl({
+			type: "thread.turn.start",
+			commandId: yield* newCommandId,
+			threadId,
+			message: {
+				messageId,
+				role: "user",
+				text: input.text,
+				attachments: []
+			},
+			modelSelection: shell.modelSelection,
+			runtimeMode: shell.runtimeMode,
+			interactionMode: shell.interactionMode,
+			compressMode: shell.compressMode,
+			unpromptedSubagents: shell.unpromptedSubagents,
+			queueIfBusy: true,
+			createdAt: DateTime.formatIso(yield* DateTime.now)
+		}, threadId);
+		return {
+			threadId,
+			messageId
+		};
+	}),
+	thread_merge_child: (input) => Effect.gen(function* () {
+		const { invocation, threadId } = yield* requireThreadControlTarget(input.threadId);
+		const refused = (detail) => Effect.succeed({
+			threadId,
+			outcome: "refused",
+			detail
+		});
+		const query = yield* ProjectionSnapshotQuery;
+		const readShell = (id) => query.getThreadShellById(id).pipe(Effect.map(Option.getOrUndefined), Effect.mapError((cause) => new ThreadControlRejectedError({
+			threadId,
+			commandType: "thread_merge_child",
+			detail: cause.message
+		})));
+		const child = yield* readShell(threadId);
+		const parent = yield* readShell(invocation.threadId);
+		if (child === void 0 || parent === void 0) return yield* refused("The sub-thread or this thread is archived or no longer exists.");
+		if (child.parentThreadId !== invocation.threadId) return yield* refused("Only a sub-thread this thread spawned can be merged into it.");
+		if (child.worktreePath === null) return yield* refused("The sub-thread shares this checkout, so there is nothing to merge.");
+		const status = child.session?.status;
+		if (status === "running" || status === "starting") return yield* refused("The sub-thread is still working. Wait for it with thread_wait.");
+		const project = yield* query.getProjectShellById(child.projectId).pipe(Effect.map(Option.getOrUndefined), Effect.catch(() => Effect.succeed(void 0)));
+		if (project === void 0) return yield* refused("The project could not be read.");
+		return {
+			threadId,
+			...yield* mergeChildIntoParent({
+				repositoryRoot: project.workspaceRoot,
+				parentCwd: parent.worktreePath ?? project.workspaceRoot,
+				childCwd: child.worktreePath
+			}).pipe(Effect.mapError((cause) => new ThreadControlRejectedError({
+				threadId,
+				commandType: "thread_merge_child",
+				detail: cause.message
+			})))
+		};
 	})
 });
 //#endregion
@@ -142904,12 +144053,30 @@ Layer.effect(RuntimeReceiptBus, makeRuntimeReceiptBusTest);
 * the scope closes. A finalizer shuts down the queue.
 *
 * @param process - The effect to run for each queued item.
+* @param mergeAdjacent - Optional pure merge of adjacent queued items. Returning
+*   undefined preserves the next item as a processing boundary. No item waits
+*   for another to arrive; each dequeue merges at most 64 already queued items.
 * @returns A `DrainableWorker` with `queue` and `drain`.
 */
-const makeDrainableWorker = (process) => Effect.gen(function* () {
+const makeDrainableWorker = (process, mergeAdjacent) => Effect.gen(function* () {
 	const queue = yield* Effect.acquireRelease(TxQueue.unbounded(), TxQueue.shutdown);
 	const outstanding = yield* TxRef.make(0);
-	yield* TxQueue.take(queue).pipe(Effect.tap((a) => Effect.ensuring(process(a), TxRef.update(outstanding, (n) => n - 1))), Effect.forever, Effect.forkScoped);
+	yield* Effect.gen(function* () {
+		let item = yield* TxQueue.take(queue);
+		let count = 1;
+		if (mergeAdjacent !== void 0) while (count < 64 && !(yield* TxQueue.isEmpty(queue))) {
+			const next = yield* TxQueue.peek(queue);
+			const merged = mergeAdjacent(item, next);
+			if (merged === void 0) break;
+			yield* TxQueue.take(queue);
+			item = merged;
+			count += 1;
+		}
+		return {
+			item,
+			count
+		};
+	}).pipe(Effect.tx).pipe(Effect.tap(({ item, count }) => Effect.ensuring(process(item), TxRef.update(outstanding, (n) => n - count))), Effect.forever, Effect.forkScoped);
 	const drain = TxRef.get(outstanding).pipe(Effect.tap((n) => n > 0 ? Effect.txRetry : Effect.void), Effect.tx);
 	const enqueue = (element) => TxQueue.offer(queue, element).pipe(Effect.tap(() => TxRef.update(outstanding, (n) => n + 1)), Effect.tx);
 	return {
@@ -142997,6 +144164,22 @@ const COMPRESS_MODE_BY_THREAD_CACHE_CAPACITY = 1e4;
 const COMPRESS_MODE_BY_THREAD_TTL = Duration.minutes(120);
 const MAX_BUFFERED_ASSISTANT_CHARS = 24e3;
 const STRICT_PROVIDER_LIFECYCLE_GUARD = process.env.P4CODE_STRICT_PROVIDER_LIFECYCLE_GUARD !== "0";
+function coalesceAssistantDeltas(left, right) {
+	if (left.source !== "runtime" || right.source !== "runtime") return void 0;
+	const a = left.event;
+	const b = right.event;
+	if (a.type !== "content.delta" || b.type !== "content.delta" || a.payload.streamKind !== "assistant_text" || b.payload.streamKind !== "assistant_text" || a.turnId === void 0 || a.itemId === void 0 || a.provider !== b.provider || a.providerInstanceId !== b.providerInstanceId || a.threadId !== b.threadId || a.turnId !== b.turnId || a.itemId !== b.itemId || a.requestId !== b.requestId || a.payload.contentIndex !== b.payload.contentIndex || a.payload.summaryIndex !== b.payload.summaryIndex || a.providerRefs?.providerTurnId !== b.providerRefs?.providerTurnId || a.providerRefs?.providerItemId !== b.providerRefs?.providerItemId || a.providerRefs?.providerRequestId !== b.providerRefs?.providerRequestId || a.payload.delta.length + b.payload.delta.length > MAX_BUFFERED_ASSISTANT_CHARS) return void 0;
+	return {
+		source: "runtime",
+		event: {
+			...a,
+			payload: {
+				...a.payload,
+				delta: a.payload.delta + b.payload.delta
+			}
+		}
+	};
+}
 function toTurnId$1(value) {
 	return value === void 0 ? void 0 : TurnId.make(String(value));
 }
@@ -144035,7 +145218,7 @@ const make$9 = Effect.gen(function* () {
 			cause: Cause.pretty(cause)
 		});
 	}));
-	const worker = yield* makeDrainableWorker(processInputSafely);
+	const worker = yield* makeDrainableWorker(processInputSafely, coalesceAssistantDeltas);
 	const start = () => Effect.gen(function* () {
 		yield* Effect.forkScoped(Stream.runForEach(providerService.streamEvents, (event) => worker.enqueue({
 			source: "runtime",