@p4code/cli 0.4.7 → 0.4.9

package/dist/bin.mjs

@@ -52,6 +52,7 @@ 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 NodeUtil from "node:util";
 import * as Cause from "effect/Cause";
 import * as Exit from "effect/Exit";
 import * as NodeReadline from "node:readline";
@@ -127,7 +128,7 @@ const closeServer = (server) => {
 * NetService - Service tag for startup networking helpers.
 */
 var NetService = class extends Context.Service()("@p4code/shared/Net/NetService") {};
-const make$92 = () => {
+const make$93 = () => {
 	/**
 	* Returns true when a TCP server can bind to {host, port}.
 	* `EADDRNOTAVAIL` is treated as available so IPv6-absent hosts don't fail
@@ -236,10 +237,10 @@ const make$92 = () => {
 		})
 	};
 };
-const layer$82 = Layer.sync(NetService, make$92);
+const layer$82 = Layer.sync(NetService, make$93);
 //#endregion
 //#region package.json
-var version = "0.4.7";
+var version = "0.4.9";
 //#endregion
 //#region src/config.ts
 /**
@@ -260,8 +261,8 @@ var ServerConfig$1 = class extends Context.Service()("@p4code/cli/config/ServerC
 	/** @deprecated Import and use `layerTest` from this module. */
 	static layerTest = (cwd, baseDirOrPrefix) => layerTest$3(cwd, baseDirOrPrefix);
 };
-const make$91 = (config) => ServerConfig$1.of(config);
-const layer$81 = (config) => Layer.succeed(ServerConfig$1, make$91(config));
+const make$92 = (config) => ServerConfig$1.of(config);
+const layer$81 = (config) => Layer.succeed(ServerConfig$1, make$92(config));
 const deriveServerPaths = Effect.fn(function* (baseDir, devUrl, options = {}) {
 	const { join } = yield* Path.Path;
 	const stateDir = join(baseDir, devUrl !== void 0 && !options.baseDirIsExplicit ? "dev" : "userdata");
@@ -1321,6 +1322,7 @@ const ServerSelfUpdateCapability = Schema$1.Literals([
 	"desktop-managed"
 ]);
 const ExecutionEnvironmentCapabilities = Schema$1.Struct({
+	threadLifecycleV2: Schema$1.optionalKey(Schema$1.Boolean),
 	repositoryIdentity: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false))),
 	connectionProbe: Schema$1.optionalKey(Schema$1.Boolean),
 	/** Server understands thread.settle / thread.unsettle commands. Absent on
@@ -2001,7 +2003,31 @@ const ThreadWorkspaceLifecycle = Schema$1.Struct({
 	mergeCommitSha: Schema$1.NullOr(TrimmedNonEmptyString),
 	updatedAt: IsoDateTime
 });
+const ThreadLifecycle = Schema$1.Literals([
+	"active",
+	"done",
+	"archived"
+]);
+const ThreadLifecycleReason = Schema$1.Literals([
+	"created",
+	"manual",
+	"inactivity",
+	"pull-request",
+	"user",
+	"activity",
+	"archive",
+	"restore"
+]);
+/** Optional during mixed-version support; v2 servers populate every field. */
+const ThreadCompletionFields = {
+	lifecycle: Schema$1.optional(ThreadLifecycle),
+	lifecycleChangedAt: Schema$1.optional(IsoDateTime),
+	lifecycleReason: Schema$1.optional(ThreadLifecycleReason),
+	doneAt: Schema$1.optional(Schema$1.NullOr(IsoDateTime)),
+	lastEngagedAt: Schema$1.optional(IsoDateTime)
+};
 const OrchestrationThread = Schema$1.Struct({
+	...ThreadCompletionFields,
 	id: ThreadId,
 	projectId: ProjectId,
 	title: TrimmedNonEmptyString,
@@ -2105,6 +2131,7 @@ const OrchestrationProjectShell = Schema$1.Struct({
 	updatedAt: IsoDateTime
 });
 const OrchestrationThreadShell = Schema$1.Struct({
+	...ThreadCompletionFields,
 	id: ThreadId,
 	projectId: ProjectId,
 	title: TrimmedNonEmptyString,
@@ -2362,6 +2389,25 @@ const ThreadUnsettleCommand = Schema$1.Struct({
 	threadId: ThreadId,
 	reason: Schema$1.Literal("user")
 });
+const ThreadCompleteCommand = Schema$1.Struct({
+	type: Schema$1.Literal("thread.complete"),
+	commandId: CommandId,
+	threadId: ThreadId
+});
+const ThreadReopenCommand = Schema$1.Struct({
+	type: Schema$1.Literal("thread.reopen"),
+	commandId: CommandId,
+	threadId: ThreadId
+});
+/** Server effects propose completion against the engagement state they inspected. */
+const ThreadAutoCompleteCommand = Schema$1.Struct({
+	type: Schema$1.Literal("thread.complete.auto"),
+	commandId: CommandId,
+	threadId: ThreadId,
+	reason: Schema$1.Literals(["inactivity", "pull-request"]),
+	expectedLastEngagedAt: IsoDateTime,
+	eligibleAt: IsoDateTime
+});
 const ThreadSnoozeCommand = Schema$1.Struct({
 	type: Schema$1.Literal("thread.snooze"),
 	commandId: CommandId,
@@ -2590,6 +2636,8 @@ const DispatchableClientOrchestrationCommand = Schema$1.Union([
 	ThreadArchiveCommand,
 	ThreadUnarchiveCommand,
 	ThreadSettleCommand,
+	ThreadCompleteCommand,
+	ThreadReopenCommand,
 	ThreadUnsettleCommand,
 	ThreadSnoozeCommand,
 	ThreadUnsnoozeCommand,
@@ -2624,6 +2672,8 @@ const ClientOrchestrationCommand = Schema$1.Union([
 	ThreadArchiveCommand,
 	ThreadUnarchiveCommand,
 	ThreadSettleCommand,
+	ThreadCompleteCommand,
+	ThreadReopenCommand,
 	ThreadUnsettleCommand,
 	ThreadSnoozeCommand,
 	ThreadUnsnoozeCommand,
@@ -2763,6 +2813,7 @@ const ThreadRevertCompleteCommand = Schema$1.Struct({
 	createdAt: IsoDateTime
 });
 const InternalOrchestrationCommand = Schema$1.Union([
+	ThreadAutoCompleteCommand,
 	ThreadSessionSetCommand,
 	ThreadSessionForceStopConvergeCommand,
 	ThreadTurnCompleteCommand,
@@ -2856,6 +2907,7 @@ const ProjectDeletedPayload$1 = Schema$1.Struct({
 	deletedAt: IsoDateTime
 });
 const ThreadCreatedPayload$1 = Schema$1.Struct({
+	...ThreadCompletionFields,
 	threadId: ThreadId,
 	projectId: ProjectId,
 	title: TrimmedNonEmptyString,
@@ -2879,20 +2931,24 @@ const ThreadDeletedPayload$1 = Schema$1.Struct({
 	deletedAt: IsoDateTime
 });
 const ThreadArchivedPayload$1 = Schema$1.Struct({
+	...ThreadCompletionFields,
 	threadId: ThreadId,
 	archivedAt: IsoDateTime,
 	updatedAt: IsoDateTime
 });
 const ThreadUnarchivedPayload$1 = Schema$1.Struct({
+	...ThreadCompletionFields,
 	threadId: ThreadId,
 	updatedAt: IsoDateTime
 });
 const ThreadSettledPayload$1 = Schema$1.Struct({
+	...ThreadCompletionFields,
 	threadId: ThreadId,
 	settledAt: IsoDateTime,
 	updatedAt: IsoDateTime
 });
 const ThreadUnsettledPayload$1 = Schema$1.Struct({
+	...ThreadCompletionFields,
 	threadId: ThreadId,
 	reason: Schema$1.Literals(["user", "activity"]),
 	updatedAt: IsoDateTime
@@ -3696,6 +3752,7 @@ Schema$1.Struct({
 	headRefName: TrimmedNonEmptyString,
 	state: ChangeRequestState,
 	updatedAt: Schema$1.Option(Schema$1.DateTimeUtc),
+	terminalAt: Schema$1.optional(Schema$1.NullOr(IsoDateTime)),
 	isCrossRepository: Schema$1.optional(Schema$1.Boolean),
 	headRepositoryNameWithOwner: Schema$1.optional(Schema$1.NullOr(TrimmedNonEmptyString)),
 	headRepositoryOwnerLogin: Schema$1.optional(Schema$1.NullOr(TrimmedNonEmptyString))
@@ -7637,6 +7694,7 @@ const STATIC_KEYBINDING_COMMANDS = [
 	"preview.zoomOut",
 	"preview.resetZoom",
 	"commandPalette.toggle",
+	"workspace.searchContents",
 	"composer.stash",
 	"chat.new",
 	"chat.newLocal",
@@ -8482,6 +8540,7 @@ const SourceControlWritingStyleSettings = Schema$1.Struct({
 });
 const DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL = Duration.seconds(30);
 const ServerSettings = Schema$1.Struct({
+	threadAutoCompleteAfterDays: Schema$1.NullOr(SidebarAutoSettleAfterDays).pipe(Schema$1.withDecodingDefault(Effect.succeed(3))),
 	enableAssistantStreaming: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false))),
 	enableProviderUpdateChecks: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	/**
@@ -8699,6 +8758,7 @@ const OpenCodeSettingsPatch = Schema$1.Struct({
 	customModels: Schema$1.optionalKey(Schema$1.Array(Schema$1.String))
 });
 const ServerSettingsPatch = Schema$1.Struct({
+	threadAutoCompleteAfterDays: Schema$1.optionalKey(Schema$1.NullOr(SidebarAutoSettleAfterDays)),
 	enableAssistantStreaming: Schema$1.optionalKey(Schema$1.Boolean),
 	enableProviderUpdateChecks: Schema$1.optionalKey(Schema$1.Boolean),
 	enableToolCallNarration: Schema$1.optionalKey(Schema$1.Boolean),
@@ -9611,6 +9671,23 @@ const ProjectSearchEntriesResult = Schema$1.Struct({
 	entries: Schema$1.Array(ProjectEntry),
 	truncated: Schema$1.Boolean
 });
+const ProjectSearchContentsInput = Schema$1.Struct({
+	cwd: TrimmedNonEmptyString,
+	query: Schema$1.String.check(Schema$1.isNonEmpty(), Schema$1.isMaxLength(256)),
+	limit: PositiveInt.check(Schema$1.isLessThanOrEqualTo(500))
+});
+const ProjectSearchContentsResult = Schema$1.Struct({
+	matches: Schema$1.Array(Schema$1.Struct({
+		path: TrimmedNonEmptyString,
+		lineNumber: PositiveInt,
+		lineContent: Schema$1.String,
+		matchRanges: Schema$1.Array(Schema$1.Struct({
+			start: NonNegativeInt,
+			end: NonNegativeInt
+		}))
+	})),
+	truncated: Schema$1.Boolean
+});
 const ProjectListEntriesInput = Schema$1.Struct({ cwd: TrimmedNonEmptyString });
 const ProjectListEntriesResult = Schema$1.Struct({
 	entries: Schema$1.Array(ProjectEntry),
@@ -10002,6 +10079,18 @@ const ThreadRenameResult = Schema$1.Struct({
 	threadId: ThreadId,
 	title: TrimmedNonEmptyString
 });
+const ThreadPlanUpdateInput = Schema$1.Struct({
+	explanation: Schema$1.optional(TrimmedNonEmptyString),
+	plan: Schema$1.Array(Schema$1.Struct({
+		step: TrimmedNonEmptyString,
+		status: Schema$1.Literals([
+			"pending",
+			"in_progress",
+			"completed"
+		])
+	}))
+});
+const ThreadPlanUpdateResult = Schema$1.Struct({ threadId: ThreadId });
 /**
 * Which thread a control tool acts on.
 *
@@ -10040,13 +10129,16 @@ const ThreadSpawnInput = Schema$1.Struct({
 	interactionMode: Schema$1.optional(ProviderInteractionMode),
 	compressMode: Schema$1.optional(CompressMode),
 	unpromptedSubagents: Schema$1.optional(Schema$1.Boolean),
-	fusionWatcher: Schema$1.optional(Schema$1.Boolean.annotate({ description: "Set true only when creating the watcher for a Fusion pair. The server requires explicit user approval before creating the thread." }))
+	fusion: Schema$1.optional(Schema$1.Boolean.annotate({ description: "Create two new threads as a separate Fusion pair, then start the builder with prompt. 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." }))
 });
 const ThreadSpawnResult = Schema$1.Struct({
 	/** Watchable with `thread_watch_events`, and addressable by every tool here. */
 	threadId: ThreadId,
 	projectId: ProjectId,
-	title: TrimmedNonEmptyString
+	title: TrimmedNonEmptyString,
+	pairId: Schema$1.optional(ThreadPairId),
+	watcherThreadId: Schema$1.optional(ThreadId)
 });
 const ThreadPairCreateInput = Schema$1.Struct({
 	watcherThreadId: ThreadId.annotate({ description: "The supervisor thread to pair with this session's own builder thread. It must have been created by this session through thread_spawn." }),
@@ -10218,12 +10310,6 @@ var ThreadSpawnNotPermittedError = class extends Schema$1.TaggedErrorClass()("Th
 		return `Thread ${this.threadId} cannot start another thread: ${this.detail}`;
 	}
 };
-/** Fusion watcher and pair creation require fresh user authorization from this exact thread. */
-var ThreadPairApprovalRequiredError = class extends Schema$1.TaggedErrorClass()("ThreadPairApprovalRequiredError", { threadId: ThreadId }) {
-	get message() {
-		return `Thread ${this.threadId} cannot create a Fusion watcher or pair without explicit user approval. The latest user message must invoke /fusion or $fusion on its own line, or affirm the immediately preceding assistant proposal that names Fusion and asks for approval.`;
-	}
-};
 /** The orchestration engine declined or failed a thread control command. */
 var ThreadControlRejectedError = class extends Schema$1.TaggedErrorClass()("ThreadControlRejectedError", {
 	threadId: ThreadId,
@@ -10238,7 +10324,6 @@ const ThreadControlToolError = Schema$1.Union([
 	ThreadToolUnavailableError,
 	ThreadControlNotPermittedError,
 	ThreadSpawnNotPermittedError,
-	ThreadPairApprovalRequiredError,
 	ThreadControlRejectedError,
 	ThreadRenameRejectedError,
 	MemoryAppendFailedError,
@@ -10262,6 +10347,45 @@ const ThreadWatchEventsResult = Schema$1.Struct({
 	/** True when more events for this thread exist past the returned page. */
 	hasMore: Schema$1.Boolean
 });
+/** Compact review limits are server-owned, independent of raw event paging. */
+const THREAD_REVIEW_SCAN_LIMIT = 2e3;
+const THREAD_REVIEW_ITEM_MAX_BYTES = 8e3;
+const ThreadWatchReviewInput = Schema$1.Struct({
+	threadId: ThreadId,
+	afterSequence: Schema$1.optional(NonNegativeInt),
+	throughSequence: Schema$1.optional(NonNegativeInt.annotate({ description: "Inclusive fixed review boundary. Omit on the first page to capture the head; reuse the returned boundary on every subsequent page." }))
+});
+const ReviewSourceFields = {
+	firstSequence: NonNegativeInt,
+	lastSequence: NonNegativeInt,
+	truncated: Schema$1.Boolean
+};
+const ThreadReviewItem = Schema$1.Union([Schema$1.Struct({
+	...ReviewSourceFields,
+	kind: Schema$1.Literal("message"),
+	messageId: Schema$1.String,
+	turnId: Schema$1.NullOr(Schema$1.String),
+	role: Schema$1.String,
+	/** Apply append/replace by message identity across page boundaries. */
+	operation: Schema$1.Literals(["append", "replace"]),
+	complete: Schema$1.Boolean,
+	text: Schema$1.String
+}), Schema$1.Struct({
+	...ReviewSourceFields,
+	kind: Schema$1.Literal("event"),
+	type: Schema$1.String,
+	/** JSON evidence excerpt. Truncated excerpts require targeted raw recovery. */
+	payload: Schema$1.String
+})]);
+const ThreadWatchReviewResult = Schema$1.Struct({
+	threadId: ThreadId,
+	items: Schema$1.Array(ThreadReviewItem),
+	throughSequence: NonNegativeInt,
+	/** Resume from the source scan cursor, even when items is empty. */
+	nextAfterSequence: NonNegativeInt,
+	hasMore: Schema$1.Boolean,
+	scannedEvents: NonNegativeInt
+});
 var WatchToolUnavailableError = class extends Schema$1.TaggedErrorClass()("WatchToolUnavailableError", {
 	capability: Schema$1.Literal("watch"),
 	environmentId: EnvironmentId,
@@ -11527,6 +11651,7 @@ const WS_METHODS = {
 	projectsRemove: "projects.remove",
 	projectsListEntries: "projects.listEntries",
 	projectsReadFile: "projects.readFile",
+	projectsSearchContents: "projects.searchContents",
 	projectsSearchEntries: "projects.searchEntries",
 	projectsWriteFile: "projects.writeFile",
 	shellOpenInEditor: "shell.openInEditor",
@@ -12237,6 +12362,11 @@ const WsSourceControlPublishRepositoryRpc = Rpc.make(WS_METHODS.sourceControlPub
 	success: SourceControlPublishRepositoryResult,
 	error: Schema$1.Union([SourceControlRepositoryError, EnvironmentAuthorizationError])
 });
+const WsProjectsSearchContentsRpc = Rpc.make(WS_METHODS.projectsSearchContents, {
+	payload: ProjectSearchContentsInput,
+	success: ProjectSearchContentsResult,
+	error: Schema$1.Union([ProjectSearchEntriesError, EnvironmentAuthorizationError])
+});
 const WsProjectsSearchEntriesRpc = Rpc.make(WS_METHODS.projectsSearchEntries, {
 	payload: ProjectSearchEntriesInput,
 	success: ProjectSearchEntriesResult,
@@ -12502,7 +12632,7 @@ const WsSubscribeAuthAccessRpc = Rpc.make(WS_METHODS.subscribeAuthAccess, {
 	error: Schema$1.Union([AuthAccessStreamError, EnvironmentAuthorizationError]),
 	stream: true
 });
-const WsRpcGroup = RpcGroup.make(WsServerProbeRpc, WsServerGetConfigRpc, WsServerRefreshProvidersRpc, WsServerUpdateProviderRpc, WsServerUpdateServerRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetProviderUsageRpc, WsBtwAskRpc, WsBtwCancelRpc, WsServerGetUsageSummaryRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsPullRequestsListRpc, WsPullRequestsListStatsRpc, WsPullRequestsDetailRpc, WsPullRequestsActivityRpc, WsPullRequestsDiffFileContentsRpc, WsPullRequestsRunActionRpc, WsPullRequestsUpdateRpc, WsPullRequestsCommentRpc, WsPullRequestsUpdateCommentRpc, WsPullRequestsSubmitReviewRpc, WsPullRequestsReplyToThreadRpc, WsPullRequestsSetThreadResolutionRpc, WsPullRequestsSetReactionRpc, WsPullRequestsInvalidateRpc, WsPullRequestsReviewerCandidatesRpc, WsPullRequestsRequestReviewersRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsAssetsCreateUrlRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsPreviewOpenRpc, WsPreviewNavigateRpc, WsPreviewResizeRpc, WsPreviewRefreshRpc, WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, WsSubscribePreviewEventsRpc, WsSubscribeDiscoveredLocalServersRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsTasksListRpc, WsTasksGetRpc, WsTasksCreateRpc, WsTasksUpdateRpc, WsTasksDeleteRpc, WsTasksStartThreadRpc, WsFeedListRpc, WsFeedRefreshRpc, WsFeedSourcesListRpc, WsFeedSourcesUpsertRpc, WsFeedSourcesDeleteRpc, WsFeedMarkReadRpc, WsFeedCleanupRpc, WsSubscribeTasksRpc, WsHubGetSyncStatusRpc, WsHubConnectRpc, WsHubDisconnectRpc, WsHubSetSyncModeRpc, WsHubSetShareModeRpc, WsHubMintTokenRpc, WsSkillsSyncRpc, WsSkillsPublishRpc, WsSkillsPublishAllRpc, WsSkillsUnpublishRpc, WsAssetsReadRpc, WsAssetsSaveRpc, WsAssetsDeleteRpc, WsAssetsCreateLocalRpc, WsAssetsRemoveLocalRpc, WsSkillRegistrySearchRpc, WsSkillRegistryFetchRpc, WsMcpListRpc, WsMcpSaveRpc, WsMcpRemoveRpc, WsMcpSetSecretRpc, WsMcpOAuthBeginRpc, WsMcpOAuthDisconnectRpc, WsTrackerStatusRpc, WsTrackerSetApiKeyRpc, WsTrackerClearApiKeyRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationSearchThreadsRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
+const WsRpcGroup = RpcGroup.make(WsServerProbeRpc, WsServerGetConfigRpc, WsServerRefreshProvidersRpc, WsServerUpdateProviderRpc, WsServerUpdateServerRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetProviderUsageRpc, WsBtwAskRpc, WsBtwCancelRpc, WsServerGetUsageSummaryRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsPullRequestsListRpc, WsPullRequestsListStatsRpc, WsPullRequestsDetailRpc, WsPullRequestsActivityRpc, WsPullRequestsDiffFileContentsRpc, WsPullRequestsRunActionRpc, WsPullRequestsUpdateRpc, WsPullRequestsCommentRpc, WsPullRequestsUpdateCommentRpc, WsPullRequestsSubmitReviewRpc, WsPullRequestsReplyToThreadRpc, WsPullRequestsSetThreadResolutionRpc, WsPullRequestsSetReactionRpc, WsPullRequestsInvalidateRpc, WsPullRequestsReviewerCandidatesRpc, WsPullRequestsRequestReviewersRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchContentsRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsAssetsCreateUrlRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsPreviewOpenRpc, WsPreviewNavigateRpc, WsPreviewResizeRpc, WsPreviewRefreshRpc, WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, WsSubscribePreviewEventsRpc, WsSubscribeDiscoveredLocalServersRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsTasksListRpc, WsTasksGetRpc, WsTasksCreateRpc, WsTasksUpdateRpc, WsTasksDeleteRpc, WsTasksStartThreadRpc, WsFeedListRpc, WsFeedRefreshRpc, WsFeedSourcesListRpc, WsFeedSourcesUpsertRpc, WsFeedSourcesDeleteRpc, WsFeedMarkReadRpc, WsFeedCleanupRpc, WsSubscribeTasksRpc, WsHubGetSyncStatusRpc, WsHubConnectRpc, WsHubDisconnectRpc, WsHubSetSyncModeRpc, WsHubSetShareModeRpc, WsHubMintTokenRpc, WsSkillsSyncRpc, WsSkillsPublishRpc, WsSkillsPublishAllRpc, WsSkillsUnpublishRpc, WsAssetsReadRpc, WsAssetsSaveRpc, WsAssetsDeleteRpc, WsAssetsCreateLocalRpc, WsAssetsRemoveLocalRpc, WsSkillRegistrySearchRpc, WsSkillRegistryFetchRpc, WsMcpListRpc, WsMcpSaveRpc, WsMcpRemoveRpc, WsMcpSetSecretRpc, WsMcpOAuthBeginRpc, WsMcpOAuthDisconnectRpc, WsTrackerStatusRpc, WsTrackerSetApiKeyRpc, WsTrackerClearApiKeyRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationSearchThreadsRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
 //#endregion
 //#region ../../packages/shared/src/oauthScope.ts
 const OAUTH_SCOPE_TOKEN = /^[\u0021\u0023-\u005b\u005d-\u007e]+$/u;
@@ -12648,7 +12778,7 @@ function deriveAuthClientMetadata(input) {
 //#endregion
 //#region src/auth/EnvironmentAuthPolicy.ts
 var EnvironmentAuthPolicy = class extends Context.Service()("@p4code/cli/auth/EnvironmentAuthPolicy") {};
-const make$90 = Effect.gen(function* () {
+const make$91 = Effect.gen(function* () {
 	const config = yield* ServerConfig$1;
 	const isRemoteReachable = isRemoteReachableHost(config.host);
 	const policy = config.mode === "desktop" ? isRemoteReachable ? "remote-reachable" : "desktop-managed-local" : isRemoteReachable ? "remote-reachable" : "loopback-browser";
@@ -12666,7 +12796,7 @@ const make$90 = Effect.gen(function* () {
 	};
 	return EnvironmentAuthPolicy.of({ getDescriptor: () => Effect.succeed(descriptor).pipe(Effect.withSpan("EnvironmentAuthPolicy.getDescriptor")) });
 });
-const layer$80 = Layer.effect(EnvironmentAuthPolicy, make$90);
+const layer$80 = Layer.effect(EnvironmentAuthPolicy, make$91);
 //#endregion
 //#region src/persistence/Errors.ts
 function summarizeSchemaIssue(issue) {
@@ -12847,7 +12977,7 @@ function toPersistenceSqlOrDecodeError$6(sqlOperation, decodeOperation, correlat
 		cause
 	});
 }
-const make$89 = Effect.gen(function* () {
+const make$90 = Effect.gen(function* () {
 	const sql = yield* SqlClient.SqlClient;
 	const createSessionRow = SqlSchema.void({
 		Request: CreateAuthSessionInput,
@@ -12981,7 +13111,7 @@ const make$89 = Effect.gen(function* () {
 		setLastConnectedAt
 	};
 });
-const layer$79 = Layer.effect(AuthSessionRepository, make$89);
+const layer$79 = Layer.effect(AuthSessionRepository, make$90);
 //#endregion
 //#region src/auth/ServerSecretStore.ts
 const secretStoreErrorContext = {
@@ -13048,7 +13178,7 @@ const isSecretStoreError = Schema$1.is(SecretStoreError);
 const isPlatformError = (value) => Predicate.isTagged(value, "PlatformError");
 const isSecretAlreadyExistsError = (error) => "cause" in error && isPlatformError(error.cause) && error.cause.reason._tag === "AlreadyExists";
 var ServerSecretStore = class extends Context.Service()("@p4code/cli/auth/ServerSecretStore") {};
-const make$88 = Effect.gen(function* () {
+const make$89 = Effect.gen(function* () {
 	const crypto = yield* Crypto.Crypto;
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -13124,7 +13254,7 @@ const make$88 = Effect.gen(function* () {
 		remove
 	});
 });
-const layer$78 = Layer.effect(ServerSecretStore, make$88);
+const layer$78 = Layer.effect(ServerSecretStore, make$89);
 //#endregion
 //#region src/auth/SessionStore.ts
 var MalformedSessionTokenError = class extends Schema$1.TaggedErrorClass()("MalformedSessionTokenError", {}) {
@@ -13362,7 +13492,7 @@ function toAuthClientSession(input) {
 		current: false
 	};
 }
-const make$87 = Effect.gen(function* () {
+const make$88 = Effect.gen(function* () {
 	const crypto = yield* Crypto.Crypto;
 	const serverConfig = yield* ServerConfig$1;
 	const secretStore = yield* ServerSecretStore;
@@ -13676,7 +13806,7 @@ const make$87 = Effect.gen(function* () {
 		markDisconnected
 	});
 });
-const layer$77 = Layer.effect(SessionStore, make$87).pipe(Layer.provideMerge(layer$79));
+const layer$77 = Layer.effect(SessionStore, make$88).pipe(Layer.provideMerge(layer$79));
 //#endregion
 //#region src/persistence/AuthPairingLinks.ts
 const AuthPairingLinkRecord = Schema$1.Struct({
@@ -13737,7 +13867,7 @@ function toPersistenceSqlOrDecodeError$5(sqlOperation, decodeOperation, correlat
 		cause
 	});
 }
-const make$86 = Effect.gen(function* () {
+const make$87 = Effect.gen(function* () {
 	const sql = yield* SqlClient.SqlClient;
 	const createPairingLinkRow = SqlSchema.void({
 		Request: CreateAuthPairingLinkInput,
@@ -13872,7 +14002,7 @@ const make$86 = Effect.gen(function* () {
 		getByCredential
 	};
 });
-const layer$76 = Layer.effect(AuthPairingLinkRepository, make$86);
+const layer$76 = Layer.effect(AuthPairingLinkRepository, make$87);
 //#endregion
 //#region src/auth/PairingGrantStore.ts
 var UnknownBootstrapCredentialError = class extends Schema$1.TaggedErrorClass()("UnknownBootstrapCredentialError", {}) {
@@ -13967,7 +14097,7 @@ const DEV_STARTUP_TTL_HOURS = Duration.hours(24);
 const PAIRING_TOKEN_ALPHABET = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
 const PAIRING_TOKEN_LENGTH = 12;
 const PAIRING_TOKEN_REJECTION_LIMIT = Math.floor(256 / 32) * 32;
-const make$85 = Effect.gen(function* () {
+const make$86 = Effect.gen(function* () {
 	const crypto = yield* Crypto.Crypto;
 	const config = yield* ServerConfig$1;
 	const pairingLinks = yield* AuthPairingLinkRepository;
@@ -14165,7 +14295,7 @@ const make$85 = Effect.gen(function* () {
 		consume
 	});
 });
-const layer$75 = Layer.effect(PairingGrantStore, make$85).pipe(Layer.provideMerge(layer$76));
+const layer$75 = Layer.effect(PairingGrantStore, make$86).pipe(Layer.provideMerge(layer$76));
 //#endregion
 //#region src/persistence/DatabaseSnapshot.ts
 /**
@@ -16111,6 +16241,31 @@ var _054_ProjectionThreadScheduledTasks_default = Effect.gen(function* () {
   `;
 });
 //#endregion
+//#region src/persistence/Migrations/055_ThreadCompletionLifecycle.ts
+var _055_ThreadCompletionLifecycle_default = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* sql`ALTER TABLE projection_threads ADD COLUMN lifecycle TEXT NOT NULL DEFAULT 'active'`;
+	yield* sql`ALTER TABLE projection_threads ADD COLUMN lifecycle_reason TEXT NOT NULL DEFAULT 'created'`;
+	yield* sql`ALTER TABLE projection_threads ADD COLUMN lifecycle_changed_at TEXT`;
+	yield* sql`ALTER TABLE projection_threads ADD COLUMN last_engaged_at TEXT`;
+	yield* sql`
+    UPDATE projection_threads SET
+      lifecycle = CASE WHEN archived_at IS NOT NULL THEN 'archived'
+        WHEN settled_override = 'settled' THEN 'done' ELSE 'active' END,
+      lifecycle_reason = CASE WHEN archived_at IS NOT NULL THEN 'archive'
+        WHEN settled_override = 'settled' THEN 'manual' ELSE 'created' END,
+      lifecycle_changed_at = COALESCE(archived_at, settled_at, created_at),
+      last_engaged_at = MAX(created_at, COALESCE(latest_user_message_at, created_at),
+        COALESCE((SELECT MAX(message.updated_at) FROM projection_thread_messages message
+          WHERE message.thread_id = projection_threads.thread_id AND message.role IN ('user', 'assistant')), created_at)),
+      settled_override = CASE WHEN settled_override = 'settled' THEN 'settled' ELSE 'active' END
+  `;
+	yield* sql`CREATE INDEX idx_projection_threads_lifecycle_sweep
+    ON projection_threads(lifecycle, deleted_at, thread_id)`;
+	yield* sql`CREATE INDEX idx_projection_threads_lifecycle_inactivity
+    ON projection_threads(lifecycle, deleted_at, last_engaged_at, thread_id)`;
+});
+//#endregion
 //#region src/persistence/Migrations.ts
 /**
 * MigrationsLive - Migration runner with inline loader
@@ -16401,6 +16556,11 @@ const migrationEntries = [
 		54,
 		"ProjectionThreadScheduledTasks",
 		_054_ProjectionThreadScheduledTasks_default
+	],
+	[
+		55,
+		"ThreadCompletionLifecycle",
+		_055_ThreadCompletionLifecycle_default
 	]
 ];
 const makeMigrationLoader = (throughId) => Migrator.fromRecord(Object.fromEntries(migrationEntries.filter(([id]) => throughId === void 0 || id <= throughId).map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -16996,12 +17156,42 @@ function dropStaleContextWindowActivities(activities) {
 		return [index === breakdownIndex ? activity : withoutContextWindowBreakdown$1(activity)];
 	});
 }
+function toolLifecycleIdentity(activity) {
+	return asTrimmedString$2(asRecord$6(asRecord$6(activity.payload)?.data)?.toolCallId);
+}
+/** Clients retain fields missing from a completion when folding an update. */
+function completionPreservesUpdate(update, completion) {
+	const updatePayload = asRecord$6(update.payload);
+	const completionPayload = asRecord$6(completion.payload);
+	if (!updatePayload || !completionPayload) return false;
+	return Object.entries(updatePayload).every(([key, value]) => key === "status" || NodeUtil.isDeepStrictEqual(value, completionPayload[key]));
+}
+/** Remove only updates superseded by a later completion in the same turn. */
+function dropSupersededToolUpdatedActivities(activities) {
+	const lastCompletionIndexByKey = /* @__PURE__ */ new Map();
+	for (let index = 0; index < activities.length; index += 1) {
+		const activity = activities[index];
+		if (activity.kind !== "tool.completed") continue;
+		const identity = toolLifecycleIdentity(activity);
+		if (!identity) continue;
+		const key = `${activity.turnId ?? ""}\u0000${identity}`;
+		lastCompletionIndexByKey.set(key, index);
+	}
+	if (lastCompletionIndexByKey.size === 0) return activities;
+	return activities.filter((activity, index) => {
+		if (activity.kind !== "tool.updated") return true;
+		const identity = toolLifecycleIdentity(activity);
+		if (!identity) return true;
+		const completionIndex = lastCompletionIndexByKey.get(`${activity.turnId ?? ""}\u0000${identity}`);
+		return completionIndex === void 0 || completionIndex <= index || !completionPreservesUpdate(activity, activities[completionIndex]);
+	});
+}
 function projectThreadDetailSnapshot(snapshot) {
 	return {
 		...snapshot,
 		thread: {
 			...snapshot.thread,
-			activities: dropStaleContextWindowActivities(snapshot.thread.activities).map(projectActivityPayload)
+			activities: dropSupersededToolUpdatedActivities(dropStaleContextWindowActivities(snapshot.thread.activities).map(projectActivityPayload))
 		}
 	};
 }
@@ -17399,7 +17589,7 @@ function parseBearerToken(request) {
 	const token = header.slice(7).trim();
 	return token.length > 0 ? token : null;
 }
-const make$84 = Effect.gen(function* () {
+const make$85 = Effect.gen(function* () {
 	const policy = yield* EnvironmentAuthPolicy;
 	const bootstrapCredentials = yield* PairingGrantStore;
 	const sessions = yield* SessionStore;
@@ -17594,7 +17784,7 @@ const make$84 = Effect.gen(function* () {
 		issueStartupPairingUrl
 	});
 });
-const layer$74 = Layer.effect(EnvironmentAuth, make$84).pipe(Layer.provideMerge(layer$75), Layer.provideMerge(layer$77), Layer.provideMerge(layer$80));
+const layer$74 = Layer.effect(EnvironmentAuth, make$85).pipe(Layer.provideMerge(layer$75), Layer.provideMerge(layer$77), Layer.provideMerge(layer$80));
 const storageLayer = Layer.mergeAll(layer$78, layerConfig);
 const runtimeLayer = layer$74.pipe(Layer.provideMerge(storageLayer));
 //#endregion
@@ -19432,7 +19622,7 @@ const DEFAULT_LIMITS = {
 	windowMillis: FAILURE_WINDOW_MS,
 	blockMillis: BLOCK_DURATION_MS
 };
-const make$83 = Effect.fn("HubAuthThrottle.make")(function* (limits = DEFAULT_LIMITS) {
+const make$84 = Effect.fn("HubAuthThrottle.make")(function* (limits = DEFAULT_LIMITS) {
 	const state = yield* Ref.make(initialThrottleState);
 	return HubAuthThrottle.of({
 		shouldRefuse: Effect.gen(function* () {
@@ -19446,7 +19636,7 @@ const make$83 = Effect.fn("HubAuthThrottle.make")(function* (limits = DEFAULT_LI
 		})
 	});
 });
-const layer$73 = Layer.effect(HubAuthThrottle, make$83());
+const layer$73 = Layer.effect(HubAuthThrottle, make$84());
 //#endregion
 //#region src/hub/HubAuth.ts
 /**
@@ -21166,7 +21356,7 @@ function stripDefaultServerSettings(current, defaults) {
 	}
 	return Object.is(current, defaults) ? void 0 : current;
 }
-const make$82 = Effect.gen(function* () {
+const make$83 = Effect.gen(function* () {
 	const { settingsPath } = yield* ServerConfig$1;
 	const fs = yield* FileSystem.FileSystem;
 	const pathService = yield* Path.Path;
@@ -21387,7 +21577,7 @@ const make$82 = Effect.gen(function* () {
 		}
 	};
 });
-const layer$71 = Layer.effect(ServerSettingsService, make$82);
+const layer$71 = Layer.effect(ServerSettingsService, make$83);
 //#endregion
 //#region src/pathExpansion.ts
 /**
@@ -21764,7 +21954,7 @@ function claudeEntryFromRegistration(registration) {
 	};
 }
 var ClaudeMcpFiles = class extends Context.Service()("@p4code/cli/mcp/ClaudeMcpFiles") {};
-const make$81 = Effect.gen(function* () {
+const make$82 = Effect.gen(function* () {
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const services = yield* Effect.context();
@@ -21831,7 +22021,7 @@ const make$81 = Effect.gen(function* () {
 		removeProject: (projectDir, name) => removeAt(Effect.succeed(projectFile(projectDir)))(name)
 	};
 });
-const layer$70 = Layer.effect(ClaudeMcpFiles, make$81);
+const layer$70 = Layer.effect(ClaudeMcpFiles, make$82);
 Layer.succeed(ClaudeMcpFiles, {
 	readUser: Effect.succeed([]),
 	readUserAt: () => Effect.succeed([]),
@@ -21969,7 +22159,7 @@ const decodeClientRegistration = Schema$1.decodeUnknownExit(ClientRegistrationRe
 const decodeTokenResponse = Schema$1.decodeUnknownExit(TokenResponse);
 var McpOAuth = class extends Context.Service()("@p4code/cli/mcp/McpOAuth") {};
 const registryError = (detail) => new McpRegistryError({ detail });
-const make$80 = Effect.gen(function* () {
+const make$81 = Effect.gen(function* () {
 	const config = yield* ServerConfig$1;
 	const secrets = yield* ServerSecretStore;
 	const http = yield* HttpClient.HttpClient;
@@ -22289,7 +22479,7 @@ const make$80 = Effect.gen(function* () {
 		accessTokenFor
 	};
 });
-const layer$69 = Layer.effect(McpOAuth, make$80);
+const layer$69 = Layer.effect(McpOAuth, make$81);
 Layer.succeed(McpOAuth, {
 	statusFor: () => Effect.succeed(Option.none()),
 	begin: () => Effect.fail(new McpRegistryError({ detail: "OAuth sign-in is not available." })),
@@ -22307,7 +22497,7 @@ const decodeRegistration$1 = Schema$1.decodeUnknownExit(RegistrationFromJson$1);
 const encodeRegistration = Schema$1.encodeSync(RegistrationFromJson$1);
 var McpRegistry = class extends Context.Service()("@p4code/cli/mcp/McpRegistry") {};
 const slotsOf = (registration) => registration.secrets ?? [];
-const make$79 = Effect.gen(function* () {
+const make$80 = Effect.gen(function* () {
 	const config = yield* ServerConfig$1;
 	const secrets = yield* ServerSecretStore;
 	const oauth = yield* McpOAuth;
@@ -22481,7 +22671,7 @@ const make$79 = Effect.gen(function* () {
 		resolveForSessionAtClaudeUserConfigPath
 	};
 });
-const layer$68 = Layer.effect(McpRegistry, make$79);
+const layer$68 = Layer.effect(McpRegistry, make$80);
 //#endregion
 //#region src/sync/skillDirectory.ts
 /**
@@ -22860,7 +23050,7 @@ const formatHubLink = (input) => encodeStoredHubLink({
 	shareMode: input.shareMode
 });
 const fromEnvironment = (environment) => validateHubLink(environment.P4CODE_HUB_URL ?? "", environment.P4CODE_HUB_TOKEN ?? "");
-const make$78 = Effect.fn("HubLink.make")(function* (environment) {
+const make$79 = Effect.fn("HubLink.make")(function* (environment) {
 	const secrets = yield* ServerSecretStore;
 	const env = environment ?? process.env;
 	const fromEnv = fromEnvironment(env);
@@ -22926,7 +23116,7 @@ const make$78 = Effect.fn("HubLink.make")(function* (environment) {
 		})
 	};
 });
-const layer$67 = Layer.effect(HubLink, make$78());
+const layer$67 = Layer.effect(HubLink, make$79());
 //#endregion
 //#region src/sync/HubAssetClient.ts
 /**
@@ -22959,7 +23149,7 @@ const decodeAssetListPage = Schema$1.decodeUnknownEffect(AssetListPage);
 const decodeConflictBody$1 = Schema$1.decodeUnknownEffect(ConflictBody$1);
 const decodeAsset = Schema$1.decodeUnknownEffect(AgentAsset);
 var HubAssetClient = class extends Context.Service()("@p4code/cli/sync/HubAssetClient") {};
-const make$77 = Effect.gen(function* () {
+const make$78 = Effect.gen(function* () {
 	const http = yield* HttpClient.HttpClient;
 	const link = yield* HubLink;
 	const requireSettings = Effect.gen(function* () {
@@ -23041,7 +23231,7 @@ const make$77 = Effect.gen(function* () {
 		remove
 	};
 });
-const layer$66 = Layer.effect(HubAssetClient, make$77);
+const layer$66 = Layer.effect(HubAssetClient, make$78);
 //#endregion
 //#region src/sync/mcpRegistrationFiles.ts
 /**
@@ -23647,7 +23837,7 @@ const EMPTY_REPORT = {
 	unavailable: null
 };
 var AssetSync = class extends Context.Service()("@p4code/cli/sync/AssetSync") {};
-const make$76 = Effect.gen(function* () {
+const make$77 = Effect.gen(function* () {
 	const client = yield* HubAssetClient;
 	const link = yield* HubLink;
 	const settingsStore = yield* ServerSettingsService;
@@ -24357,7 +24547,7 @@ const make$76 = Effect.gen(function* () {
 		removeLocal
 	};
 });
-const layer$65 = Layer.effect(AssetSync, make$76);
+const layer$65 = Layer.effect(AssetSync, make$77);
 //#endregion
 //#region src/provider/CompressPrompts.ts
 /**
@@ -25434,6 +25624,30 @@ function toPersistenceSqlOrDecodeError$4(sqlOperation, decodeOperation) {
 }
 const makeEventStore = Effect.gen(function* () {
 	const sql = yield* SqlClient.SqlClient;
+	const readReviewRows = SqlSchema.findAll({
+		Request: Schema$1.Struct({
+			afterSequence: NonNegativeInt,
+			throughSequence: NonNegativeInt,
+			limit: NonNegativeInt
+		}),
+		Result: Schema$1.Struct({
+			sequence: NonNegativeInt,
+			type: Schema$1.String,
+			aggregateKind: Schema$1.String,
+			aggregateId: Schema$1.String,
+			payloadJson: Schema$1.String
+		}),
+		execute: (request) => sql`
+      SELECT sequence, event_type AS "type", aggregate_kind AS "aggregateKind",
+        stream_id AS "aggregateId",
+        substr(payload_json, 1, ${8001}) AS "payloadJson"
+      FROM orchestration_events
+      WHERE sequence > ${request.afterSequence} AND sequence <= ${request.throughSequence}
+      ORDER BY sequence ASC
+      LIMIT ${Math.min(request.limit, THREAD_REVIEW_SCAN_LIMIT)}
+    `
+	});
+	const readReviewPage = (input) => readReviewRows(input).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$4("OrchestrationEventStore.readReviewPage:query", "OrchestrationEventStore.readReviewPage:decode")));
 	const appendEventRow = SqlSchema.findOne({
 		Request: AppendEventRequestSchema,
 		Result: OrchestrationEventPersistedRowSchema,
@@ -25603,6 +25817,7 @@ const makeEventStore = Effect.gen(function* () {
 		append,
 		readByCommandId,
 		readFromSequence,
+		readReviewPage,
 		readAll: () => readFromSequence(0, Number.MAX_SAFE_INTEGER)
 	};
 });
@@ -25727,6 +25942,99 @@ function toProjectorDecodeError(eventType) {
 	});
 }
 //#endregion
+//#region ../../packages/shared/src/taskAgentKind.ts
+/** Unknown task types remain agents; only known background types are excluded. */
+function classifyTaskAgentKind(input) {
+	const taskType = input.taskType ?? input.subagentType;
+	const nonAgent = taskType != null && (INERT_TASK_TYPES.has(taskType) || MONITOR_TASK_TYPES.has(taskType));
+	if (input.agentId?.trim()) return taskType == null || nonAgent ? "background" : "agent";
+	return nonAgent ? "background" : "agent";
+}
+//#endregion
+//#region src/orchestration/ThreadBackgroundLiveness.ts
+/**
+* ThreadBackgroundLivenessService - in-memory per-thread background liveness
+* for the sidebar status pill.
+*
+* The turn can settle while native background work runs on (subagent fleets,
+* workflow runs, Monitor watch loops); the shell previously showed nothing.
+* Ingestion records task lifecycle transitions and the shell query reads the
+* derived state at mapping time — no persistence, no migration. After a
+* server restart the registry is empty until new task events arrive, which
+* matches reality: orphaned background work is not live.
+*
+* "monitoring" is reserved for watch loops (monitor tasks and background
+* shells) when they are the ONLY live work; any agent work presents as
+* "working".
+*
+* @module ThreadBackgroundLivenessService
+*/
+const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+	"completed",
+	"failed",
+	"stopped",
+	"cancelled",
+	"interrupted"
+]);
+var ThreadBackgroundLivenessService = class extends Context.Service()("@p4code/cli/orchestration/ThreadBackgroundLiveness/ThreadBackgroundLivenessService") {};
+function make$76() {
+	const stateByThreadId = /* @__PURE__ */ new Map();
+	const stateFor = (threadId) => {
+		const existing = stateByThreadId.get(threadId);
+		if (existing) return existing;
+		const created = {
+			agents: /* @__PURE__ */ new Set(),
+			monitors: /* @__PURE__ */ new Set(),
+			tasks: /* @__PURE__ */ new Map()
+		};
+		stateByThreadId.set(threadId, created);
+		return created;
+	};
+	const drop = (threadId, taskId) => {
+		const state = stateByThreadId.get(threadId);
+		if (!state) return;
+		state.agents.delete(taskId);
+		state.monitors.delete(taskId);
+		if (state.tasks.size === 0) stateByThreadId.delete(threadId);
+	};
+	return {
+		recordTaskLiveness: (input) => {
+			const state = stateFor(input.threadId);
+			const previous = state.tasks.get(input.taskId);
+			const taskType = input.taskType ?? previous?.taskType;
+			const agentId = input.agentId ?? previous?.agentId;
+			if (input.kind === "completed" || input.status !== void 0 && TERMINAL_STATUSES.has(input.status)) {
+				state.tasks.delete(input.taskId);
+				drop(input.threadId, input.taskId);
+				return;
+			}
+			state.tasks.set(input.taskId, {
+				taskType,
+				agentId
+			});
+			drop(input.threadId, input.taskId);
+			if (input.status === "idle") return;
+			if (taskType !== void 0 && INERT_TASK_TYPES.has(taskType)) return;
+			if (agentId !== void 0 && classifyTaskAgentKind({
+				taskType,
+				agentId
+			}) === "background") return;
+			(taskType !== void 0 && MONITOR_TASK_TYPES.has(taskType) ? state.monitors : state.agents).add(input.taskId);
+		},
+		clearThreadLiveness: (threadId) => {
+			stateByThreadId.delete(threadId);
+		},
+		getThreadBackgroundLiveness: (threadId) => {
+			const state = stateByThreadId.get(threadId);
+			if (!state) return null;
+			if (state.agents.size > 0) return "working";
+			if (state.monitors.size > 0) return "monitoring";
+			return null;
+		}
+	};
+}
+const layer$64 = Layer.effect(ThreadBackgroundLivenessService, Effect.sync(make$76));
+//#endregion
 //#region ../../packages/shared/src/path.ts
 function isWindowsDrivePath(value) {
 	return /^[a-zA-Z]:([/\\]|$)/.test(value);
@@ -25805,6 +26113,74 @@ function requireThreadAbsent(input) {
 	return Effect.fail(invariantError(input.command.type, `Thread '${input.threadId}' already exists and cannot be created twice.`));
 }
 //#endregion
+//#region src/orchestration/ThreadCompletion.ts
+const ENGAGEMENT_ACTIVITY_KINDS = /* @__PURE__ */ new Set([
+	"approval.requested",
+	"user-input.requested",
+	"tool.started",
+	"tool.updated",
+	"tool.completed",
+	"task.started",
+	"task.progress",
+	"task.updated",
+	"task.completed",
+	"turn.plan.updated"
+]);
+function isThreadEngagement(event) {
+	switch (event.type) {
+		case "thread.message-sent": return "text" in event.payload && typeof event.payload.text === "string" && event.payload.text.length > 0;
+		case "thread.session-set": return "session" in event.payload && (event.payload.session.status === "starting" || event.payload.session.status === "running");
+		case "thread.activity-appended": return "activity" in event.payload && ENGAGEMENT_ACTIVITY_KINDS.has(event.payload.activity.kind);
+		case "thread.proposed-plan-upserted":
+		case "thread.pinned": return true;
+		default: return false;
+	}
+}
+function completionState(thread) {
+	return {
+		lifecycle: thread.lifecycle ?? (thread.archivedAt !== null ? "archived" : thread.settledOverride === "settled" ? "done" : "active"),
+		lifecycleReason: thread.lifecycleReason ?? (thread.settledOverride === "settled" ? "manual" : "created"),
+		lifecycleChangedAt: thread.lifecycleChangedAt ?? thread.archivedAt ?? thread.settledAt ?? thread.createdAt,
+		lastEngagedAt: thread.lastEngagedAt ?? thread.createdAt,
+		doneAt: thread.doneAt ?? thread.settledAt
+	};
+}
+/** Transition metadata is shared by in-memory and persisted projections. */
+function completionAfterEvent(thread, event) {
+	const state = completionState(thread);
+	if (isThreadEngagement(event)) state.lastEngagedAt = state.lastEngagedAt > event.occurredAt ? state.lastEngagedAt : event.occurredAt;
+	switch (event.type) {
+		case "thread.settled": return {
+			...state,
+			lifecycle: "done",
+			doneAt: event.payload.settledAt,
+			lifecycleReason: event.payload.lifecycleReason ?? "manual",
+			lifecycleChangedAt: event.payload.lifecycleChangedAt ?? event.payload.settledAt
+		};
+		case "thread.unsettled": return {
+			...state,
+			lifecycle: "active",
+			doneAt: null,
+			lifecycleReason: event.payload.lifecycleReason ?? event.payload.reason,
+			lifecycleChangedAt: event.payload.lifecycleChangedAt ?? event.payload.updatedAt,
+			lastEngagedAt: event.payload.lastEngagedAt ?? (state.lastEngagedAt > event.payload.updatedAt ? state.lastEngagedAt : event.payload.updatedAt)
+		};
+		case "thread.archived": return {
+			...state,
+			lifecycle: "archived",
+			lifecycleReason: "archive",
+			lifecycleChangedAt: event.payload.lifecycleChangedAt ?? event.payload.archivedAt
+		};
+		case "thread.unarchived": return {
+			...state,
+			lifecycle: state.doneAt !== null ? "done" : "active",
+			lifecycleReason: "restore",
+			lifecycleChangedAt: event.payload.lifecycleChangedAt ?? event.payload.updatedAt
+		};
+		default: return state;
+	}
+}
+//#endregion
 //#region src/attachmentPaths.ts
 function normalizeAttachmentRelativePath(rawRelativePath) {
 	const normalized = NodePath.normalize(rawRelativePath).replace(/^[/\\]+/, "");
@@ -26220,6 +26596,10 @@ function createEmptyReadModel(nowIso) {
 function projectEvent(model, event) {
 	const nextBase = {
 		...model,
+		threads: event.aggregateKind !== "thread" ? model.threads : model.threads.map((thread) => thread.id === event.aggregateId ? {
+			...thread,
+			...completionAfterEvent(thread, event)
+		} : thread),
 		snapshotSequence: event.sequence,
 		updatedAt: event.occurredAt
 	};
@@ -26327,8 +26707,13 @@ function projectEvent(model, event) {
 				latestTurn: null,
 				createdAt: payload.createdAt,
 				updatedAt: payload.updatedAt,
+				lifecycle: "active",
+				lifecycleReason: "created",
+				lifecycleChangedAt: payload.createdAt,
+				lastEngagedAt: payload.createdAt,
+				doneAt: null,
+				settledOverride: "active",
 				archivedAt: null,
-				settledOverride: null,
 				settledAt: null,
 				snoozedUntil: null,
 				snoozedAt: null,
@@ -26376,7 +26761,7 @@ function projectEvent(model, event) {
 		case "thread.unsettled": return decodeForEvent(ThreadUnsettledPayload, event.payload, event.type, "payload").pipe(Effect.map((payload) => ({
 			...nextBase,
 			threads: updateThread(nextBase.threads, payload.threadId, {
-				settledOverride: payload.reason === "user" ? "active" : null,
+				settledOverride: "active",
 				settledAt: null,
 				updatedAt: payload.updatedAt
 			})
@@ -26736,7 +27121,7 @@ const decideCommandSequence = Effect.fn("decideCommandSequence")(function* ({ co
 	}
 	return plannedEvents;
 });
-const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(function* ({ command, readModel }) {
+const decideCommand = Effect.fn("decideCommand")(function* ({ command, readModel }) {
 	switch (command.type) {
 		case "project.create":
 			yield* requireProjectAbsent({
@@ -27376,12 +27761,19 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 			}
 			return events;
 		}
+		case "thread.complete":
+		case "thread.complete.auto":
 		case "thread.settle": {
 			const thread = yield* requireThreadNotArchived({
 				readModel,
 				command,
 				threadId: command.threadId
 			});
+			const occurredAt = yield* nowIso$8;
+			if (command.type === "thread.complete.auto" && (completionState(thread).lastEngagedAt !== command.expectedLastEngagedAt || !(Date.parse(command.expectedLastEngagedAt) < Date.parse(command.eligibleAt)) || !(Date.parse(command.eligibleAt) <= Date.parse(occurredAt)) || thread.pinnedAt != null)) return yield* new OrchestrationCommandInvariantError({
+				commandType: command.type,
+				detail: "Thread engagement changed or automatic completion is no longer eligible"
+			});
 			if (thread.session?.status === "starting" || thread.session?.status === "running") return yield* new OrchestrationCommandInvariantError({
 				commandType: command.type,
 				detail: `thread ${command.threadId} has an active session and cannot be settled`
@@ -27390,7 +27782,6 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 				commandType: command.type,
 				detail: `thread ${command.threadId} has a pending approval or user-input request and cannot be settled`
 			});
-			const occurredAt = yield* nowIso$8;
 			if (threadHasQueuedTurnStart(thread, occurredAt)) return yield* new OrchestrationCommandInvariantError({
 				commandType: command.type,
 				detail: `thread ${command.threadId} has a queued turn start and cannot be settled`
@@ -27425,6 +27816,7 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 				}
 			}];
 		}
+		case "thread.reopen":
 		case "thread.unsettle": {
 			const thread = yield* requireThreadNotArchived({
 				readModel,
@@ -27443,7 +27835,7 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 				type: "thread.unsettled",
 				payload: {
 					threadId: command.threadId,
-					reason: command.reason,
+					reason: "user",
 					updatedAt: alreadyPinnedActive ? thread.updatedAt : occurredAt
 				}
 			};
@@ -27800,7 +28192,7 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 				}
 			};
 			const lifecycleResetEvents = [];
-			if (targetThread.settledOverride !== null) lifecycleResetEvents.push({
+			if (targetThread.settledOverride === "settled") lifecycleResetEvents.push({
 				...yield* withEventBase({
 					aggregateKind: "thread",
 					aggregateId: command.threadId,
@@ -28051,7 +28443,7 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 				}
 			};
 			const isSessionActivity = command.session.status === "starting" || command.session.status === "running";
-			if (thread.settledOverride === null || !isSessionActivity) return sessionSetEvent;
+			if (thread.settledOverride !== "settled" || !isSessionActivity) return sessionSetEvent;
 			return [{
 				...yield* withEventBase({
 					aggregateKind: "thread",
@@ -28202,7 +28594,7 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 				}
 			};
 			const wakesSettledThread = command.activity.kind === "approval.requested" || command.activity.kind === "user-input.requested";
-			if (thread.settledOverride === null || !wakesSettledThread) return activityAppendedEvent;
+			if (thread.settledOverride !== "settled" || !wakesSettledThread) return activityAppendedEvent;
 			return [{
 				...yield* withEventBase({
 					aggregateKind: "thread",
@@ -28227,6 +28619,74 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 		}
 	}
 });
+const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(function* (input) {
+	const { command, readModel } = input;
+	if (input.hasLiveBackgroundWork && (command.type === "thread.settle" || command.type === "thread.complete" || command.type === "thread.complete.auto")) return yield* new OrchestrationCommandInvariantError({
+		commandType: command.type,
+		detail: "Thread has live background work and cannot be completed"
+	});
+	const decided = yield* decideCommand(input);
+	const events = Array.isArray(decided) ? [...decided] : [decided];
+	const target = "threadId" in command ? readModel.threads.find((thread) => thread.id === command.threadId) : void 0;
+	const engagement = events.find(isThreadEngagement);
+	if (target && target.archivedAt === null && completionState(target).lifecycle === "done" && engagement && !events.some((event) => event.type === "thread.unsettled")) events.unshift({
+		...yield* withEventBase({
+			aggregateKind: "thread",
+			aggregateId: target.id,
+			occurredAt: engagement.occurredAt,
+			commandId: command.commandId
+		}),
+		type: "thread.unsettled",
+		payload: {
+			threadId: target.id,
+			reason: "activity",
+			updatedAt: engagement.occurredAt
+		}
+	});
+	return events.map((event) => {
+		if (event.type === "thread.created") return {
+			...event,
+			payload: {
+				...event.payload,
+				lifecycle: "active",
+				lifecycleReason: "created",
+				lifecycleChangedAt: event.payload.createdAt,
+				lastEngagedAt: event.payload.createdAt,
+				doneAt: null
+			}
+		};
+		const eventThread = readModel.threads.find((thread) => thread.id === event.aggregateId);
+		if (!eventThread) return event;
+		switch (event.type) {
+			case "thread.settled":
+			case "thread.unsettled":
+			case "thread.archived":
+			case "thread.unarchived": {
+				const previous = completionState(eventThread);
+				const state = completionAfterEvent(eventThread, {
+					...event,
+					sequence: readModel.snapshotSequence + 1
+				});
+				if (event.type === "thread.settled") state.lifecycleReason = previous.lifecycle === "done" ? previous.lifecycleReason : command.type === "thread.complete.auto" ? command.reason : "manual";
+				if (event.type === "thread.settled" && previous.lifecycle === "done" || event.type === "thread.unsettled" && previous.lifecycle === "active" && (command.type === "thread.reopen" || command.type === "thread.unsettle")) return {
+					...event,
+					payload: {
+						...event.payload,
+						...previous
+					}
+				};
+				return {
+					...event,
+					payload: {
+						...event.payload,
+						...state
+					}
+				};
+			}
+			default: return event;
+		}
+	});
+});
 //#endregion
 //#region src/orchestration/Services/ProjectionPipeline.ts
 /**
@@ -28267,6 +28727,7 @@ const makeOrchestrationEngine = Effect.gen(function* () {
 	const projectionPipeline = yield* OrchestrationProjectionPipeline;
 	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
 	const crypto = yield* Crypto.Crypto;
+	const backgroundLiveness = yield* ThreadBackgroundLivenessService;
 	const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
 	let commandReadModel = createEmptyReadModel(yield* nowIso);
 	const commandQueue = yield* Queue.unbounded();
@@ -28314,7 +28775,8 @@ const makeOrchestrationEngine = Effect.gen(function* () {
 			}
 			const eventBase = yield* decideOrchestrationCommand({
 				command: envelope.command,
-				readModel: commandReadModel
+				readModel: commandReadModel,
+				hasLiveBackgroundWork: "threadId" in envelope.command && backgroundLiveness.getThreadBackgroundLiveness(envelope.command.threadId) !== null
 			}).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.mapError((cause) => isOrchestrationCommandInvariantError(cause) ? cause : new OrchestrationCommandInvariantError({
 				commandType: envelope.command.type,
 				detail: "Failed to generate an event identifier.",
@@ -28416,7 +28878,7 @@ const makeOrchestrationEngine = Effect.gen(function* () {
 		latestSequence: Effect.sync(() => commandReadModel.snapshotSequence)
 	};
 });
-const OrchestrationEngineLive = Layer.effect(OrchestrationEngineService, makeOrchestrationEngine);
+const OrchestrationEngineLive = Layer.effect(OrchestrationEngineService, makeOrchestrationEngine).pipe(Layer.provide(layer$64));
 //#endregion
 //#region src/persistence/Services/ProjectionPendingApprovals.ts
 /**
@@ -28682,6 +29144,7 @@ var ProjectionTurnRepository = class extends Context.Service()("@p4code/cli/pers
 * @module ProjectionThreadRepository
 */
 const ProjectionThread = Schema$1.Struct({
+	...ThreadCompletionFields,
 	threadId: ThreadId,
 	projectId: ProjectId,
 	title: Schema$1.String,
@@ -29684,6 +30147,10 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           archived_at,
           settled_override,
           settled_at,
+          lifecycle,
+          lifecycle_reason,
+          lifecycle_changed_at,
+          last_engaged_at,
           snoozed_until,
           snoozed_at,
           pinned_at,
@@ -29714,6 +30181,10 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           ${row.archivedAt},
           ${row.settledOverride},
           ${row.settledAt},
+          ${row.lifecycle ?? (row.archivedAt !== null ? "archived" : row.settledOverride === "settled" ? "done" : "active")},
+          ${row.lifecycleReason ?? (row.settledOverride === "settled" ? "manual" : "created")},
+          ${row.lifecycleChangedAt ?? row.settledAt ?? row.createdAt},
+          ${row.lastEngagedAt ?? row.latestUserMessageAt ?? row.createdAt},
           ${row.snoozedUntil},
           ${row.snoozedAt},
           ${row.pinnedAt},
@@ -29744,6 +30215,10 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           archived_at = excluded.archived_at,
           settled_override = excluded.settled_override,
           settled_at = excluded.settled_at,
+          lifecycle = excluded.lifecycle,
+          lifecycle_reason = excluded.lifecycle_reason,
+          lifecycle_changed_at = excluded.lifecycle_changed_at,
+          last_engaged_at = excluded.last_engaged_at,
           snoozed_until = excluded.snoozed_until,
           snoozed_at = excluded.snoozed_at,
           pinned_at = excluded.pinned_at,
@@ -29779,6 +30254,10 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           archived_at AS "archivedAt",
           settled_override AS "settledOverride",
           settled_at AS "settledAt",
+          lifecycle AS "lifecycle",
+          lifecycle_reason AS "lifecycleReason",
+          lifecycle_changed_at AS "lifecycleChangedAt",
+          last_engaged_at AS "lastEngagedAt",
           snoozed_until AS "snoozedUntil",
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
@@ -29816,6 +30295,10 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           archived_at AS "archivedAt",
           settled_override AS "settledOverride",
           settled_at AS "settledAt",
+          lifecycle AS "lifecycle",
+          lifecycle_reason AS "lifecycleReason",
+          lifecycle_changed_at AS "lifecycleChangedAt",
+          last_engaged_at AS "lastEngagedAt",
           snoozed_until AS "snoozedUntil",
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
@@ -29853,6 +30336,14 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
 const ProjectionThreadRepositoryLive = Layer.effect(ProjectionThreadRepository, makeProjectionThreadRepository);
 //#endregion
 //#region src/orchestration/Layers/ProjectionPipeline.ts
+/**
+* Tasks the agent started that never reported a terminal status. A task that
+* outlives its turn is the case worth surfacing: the session goes back to idle
+* while the task keeps running, so nothing else in the shell shows the work.
+*
+* Counted rather than flagged so a lost completion can only strand one task,
+* and read as a boolean by the shell.
+*/
 const ORCHESTRATION_PROJECTOR_NAMES = {
 	projects: "projection.projects",
 	threads: "projection.threads",
@@ -29898,14 +30389,6 @@ function extractActivityTaskId(payload) {
 	const taskId = payload.taskId;
 	return typeof taskId === "string" && taskId.length > 0 ? taskId : null;
 }
-/**
-* Tasks the agent started that never reported a terminal status. A task that
-* outlives its turn is the case worth surfacing: the session goes back to idle
-* while the task keeps running, so nothing else in the shell shows the work.
-*
-* Counted rather than flagged so a lost completion can only strand one task,
-* and read as a boolean by the shell.
-*/
 function deriveBackgroundTaskCountFromActivities(activities) {
 	const openTaskIds = /* @__PURE__ */ new Set();
 	const ordered = [...activities].toSorted((left, right) => left.createdAt.localeCompare(right.createdAt) || left.activityId.localeCompare(right.activityId));
@@ -30248,7 +30731,12 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 					createdAt: event.payload.createdAt,
 					updatedAt: event.payload.updatedAt,
 					archivedAt: null,
-					settledOverride: null,
+					lifecycle: "active",
+					lifecycleReason: "created",
+					lifecycleChangedAt: event.payload.createdAt,
+					lastEngagedAt: event.payload.createdAt,
+					doneAt: null,
+					settledOverride: "active",
 					settledAt: null,
 					snoozedUntil: null,
 					snoozedAt: null,
@@ -30268,6 +30756,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					archivedAt: event.payload.archivedAt,
 					updatedAt: event.payload.updatedAt
 				});
@@ -30278,6 +30767,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					archivedAt: null,
 					updatedAt: event.payload.updatedAt
 				});
@@ -30288,6 +30778,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					settledOverride: "settled",
 					settledAt: event.payload.settledAt,
 					updatedAt: event.payload.updatedAt
@@ -30299,7 +30790,8 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
-					settledOverride: event.payload.reason === "user" ? "active" : null,
+					...completionAfterEvent(existingRow.value, event),
+					settledOverride: "active",
 					settledAt: null,
 					updatedAt: event.payload.updatedAt
 				});
@@ -30310,6 +30802,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					snoozedUntil: event.payload.snoozedUntil,
 					snoozedAt: event.payload.snoozedAt,
 					updatedAt: event.payload.updatedAt
@@ -30321,6 +30814,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					snoozedUntil: null,
 					snoozedAt: null,
 					updatedAt: event.payload.updatedAt
@@ -30332,6 +30826,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					pinnedAt: event.payload.pinnedAt,
 					...event.payload.pinOrderKey === void 0 ? {} : { pinOrderKey: event.payload.pinOrderKey },
 					updatedAt: event.payload.updatedAt
@@ -30343,6 +30838,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					pinnedAt: null,
 					pinOrderKey: null,
 					updatedAt: event.payload.updatedAt
@@ -30354,6 +30850,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					pinOrderKey: event.payload.pinOrderKey,
 					updatedAt: event.payload.updatedAt
 				});
@@ -30364,6 +30861,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					...event.payload.title !== void 0 ? { title: event.payload.title } : {},
 					...event.payload.modelSelection !== void 0 ? { modelSelection: event.payload.modelSelection } : {},
 					...event.payload.branch !== void 0 ? { branch: event.payload.branch } : {},
@@ -30378,6 +30876,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					runtimeMode: event.payload.runtimeMode,
 					updatedAt: event.payload.updatedAt
 				});
@@ -30388,6 +30887,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					interactionMode: event.payload.interactionMode,
 					updatedAt: event.payload.updatedAt
 				});
@@ -30398,6 +30898,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					compressMode: event.payload.compressMode,
 					updatedAt: event.payload.updatedAt
 				});
@@ -30408,6 +30909,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					unpromptedSubagents: event.payload.unpromptedSubagents ? 1 : 0,
 					updatedAt: event.payload.updatedAt
 				});
@@ -30419,6 +30921,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					deletedAt: event.payload.deletedAt,
 					updatedAt: event.payload.deletedAt
 				});
@@ -30433,6 +30936,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					updatedAt: event.occurredAt
 				});
 				yield* refreshThreadShellSummary(event.payload.threadId);
@@ -30443,6 +30947,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					latestTurnId: event.payload.session.activeTurnId,
 					updatedAt: event.occurredAt
 				});
@@ -30454,6 +30959,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				if (Option.isNone(existingRow)) return;
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					latestTurnId: event.payload.turnId,
 					updatedAt: event.occurredAt
 				});
@@ -30476,6 +30982,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				}
 				yield* projectionThreadRepository.upsert({
 					...existingRow.value,
+					...completionAfterEvent(existingRow.value, event),
 					latestTurnId,
 					updatedAt: event.occurredAt
 				});
@@ -31002,84 +31509,6 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 });
 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));
 //#endregion
-//#region src/orchestration/ThreadBackgroundLiveness.ts
-/**
-* ThreadBackgroundLivenessService - in-memory per-thread background liveness
-* for the sidebar status pill.
-*
-* The turn can settle while native background work runs on (subagent fleets,
-* workflow runs, Monitor watch loops); the shell previously showed nothing.
-* Ingestion records task lifecycle transitions and the shell query reads the
-* derived state at mapping time — no persistence, no migration. After a
-* server restart the registry is empty until new task events arrive, which
-* matches reality: orphaned background work is not live.
-*
-* "monitoring" is reserved for watch loops (monitor tasks and background
-* shells) when they are the ONLY live work; any agent work presents as
-* "working".
-*
-* @module ThreadBackgroundLivenessService
-*/
-const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
-	"completed",
-	"failed",
-	"stopped",
-	"cancelled",
-	"interrupted"
-]);
-var ThreadBackgroundLivenessService = class extends Context.Service()("@p4code/cli/orchestration/ThreadBackgroundLiveness/ThreadBackgroundLivenessService") {};
-function make$75() {
-	const stateByThreadId = /* @__PURE__ */ new Map();
-	const stateFor = (threadId) => {
-		const existing = stateByThreadId.get(threadId);
-		if (existing) return existing;
-		const created = {
-			agents: /* @__PURE__ */ new Set(),
-			monitors: /* @__PURE__ */ new Set()
-		};
-		stateByThreadId.set(threadId, created);
-		return created;
-	};
-	const drop = (threadId, taskId) => {
-		const state = stateByThreadId.get(threadId);
-		if (!state) return;
-		state.agents.delete(taskId);
-		state.monitors.delete(taskId);
-		if (state.agents.size === 0 && state.monitors.size === 0) stateByThreadId.delete(threadId);
-	};
-	return {
-		recordTaskLiveness: (input) => {
-			const taskType = input.taskType;
-			if (taskType !== void 0 && INERT_TASK_TYPES.has(taskType)) {
-				drop(input.threadId, input.taskId);
-				return;
-			}
-			if (input.agentId !== void 0 && (taskType === void 0 || MONITOR_TASK_TYPES.has(taskType))) {
-				drop(input.threadId, input.taskId);
-				return;
-			}
-			if (input.kind === "completed" || input.status === "idle" || input.status !== void 0 && TERMINAL_STATUSES.has(input.status)) {
-				drop(input.threadId, input.taskId);
-				return;
-			}
-			drop(input.threadId, input.taskId);
-			const state = stateFor(input.threadId);
-			(taskType !== void 0 && MONITOR_TASK_TYPES.has(taskType) ? state.monitors : state.agents).add(input.taskId);
-		},
-		clearThreadLiveness: (threadId) => {
-			stateByThreadId.delete(threadId);
-		},
-		getThreadBackgroundLiveness: (threadId) => {
-			const state = stateByThreadId.get(threadId);
-			if (!state) return null;
-			if (state.agents.size > 0) return "working";
-			if (state.monitors.size > 0) return "monitoring";
-			return null;
-		}
-	};
-}
-const layer$64 = Layer.effect(ThreadBackgroundLivenessService, Effect.sync(make$75));
-//#endregion
 //#region src/persistence/Services/ProjectionCheckpoints.ts
 /**
 * ProjectionCheckpointRepository - Projection repository interface for checkpoints.
@@ -31647,12 +32076,12 @@ const runProcessCore = Effect.fn("processRunner.runProcessCore")(function* (spaw
 		stderrInvalidUtf8: stderr.invalidUtf8
 	};
 });
-const make$74 = Effect.fn("ProcessRunner.make")(function* () {
+const make$75 = Effect.fn("ProcessRunner.make")(function* () {
 	const spawner = yield* ChildProcessSpawner$1.ChildProcessSpawner;
 	const run = (input) => finalizeRunProcess(runProcessCore(spawner, input), input);
 	return ProcessRunner.of({ run });
 });
-const layer$63 = Layer.effect(ProcessRunner, make$74());
+const layer$63 = Layer.effect(ProcessRunner, make$75());
 //#endregion
 //#region src/project/RepositoryIdentityResolver.ts
 const DEFAULT_REPOSITORY_IDENTITY_CACHE_CAPACITY = 512;
@@ -31743,7 +32172,7 @@ const resolveRepositoryIdentityFromCacheKey = Effect.fn("RepositoryIdentityResol
 		rootPath: cacheKey
 	}) : null;
 });
-const make$73 = Effect.fn("RepositoryIdentityResolver.make")(function* (options = {}) {
+const make$74 = Effect.fn("RepositoryIdentityResolver.make")(function* (options = {}) {
 	const processRunner = yield* ProcessRunner;
 	const repositoryIdentityCache = yield* Cache.makeWith((cacheKey) => resolveRepositoryIdentityFromCacheKey(cacheKey).pipe(Effect.provideService(ProcessRunner, processRunner)), {
 		capacity: options.cacheCapacity ?? DEFAULT_REPOSITORY_IDENTITY_CACHE_CAPACITY,
@@ -31758,7 +32187,7 @@ const make$73 = Effect.fn("RepositoryIdentityResolver.make")(function* (options
 	});
 	return RepositoryIdentityResolver.of({ resolve });
 });
-const layer$62 = Layer.effect(RepositoryIdentityResolver, make$73()).pipe(Layer.provide(layer$63));
+const layer$62 = Layer.effect(RepositoryIdentityResolver, make$74()).pipe(Layer.provide(layer$63));
 //#endregion
 //#region src/orchestration/Layers/ProjectionSnapshotQuery.ts
 const decodeReadModel = Schema$1.decodeUnknownEffect(OrchestrationReadModel);
@@ -32114,6 +32543,10 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           archived_at AS "archivedAt",
           settled_override AS "settledOverride",
           settled_at AS "settledAt",
+          lifecycle AS "lifecycle",
+          lifecycle_reason AS "lifecycleReason",
+          lifecycle_changed_at AS "lifecycleChangedAt",
+          last_engaged_at AS "lastEngagedAt",
           snoozed_until AS "snoozedUntil",
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
@@ -32151,6 +32584,10 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           archived_at AS "archivedAt",
           settled_override AS "settledOverride",
           settled_at AS "settledAt",
+          lifecycle AS "lifecycle",
+          lifecycle_reason AS "lifecycleReason",
+          lifecycle_changed_at AS "lifecycleChangedAt",
+          last_engaged_at AS "lastEngagedAt",
           snoozed_until AS "snoozedUntil",
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
@@ -32190,6 +32627,10 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           archived_at AS "archivedAt",
           settled_override AS "settledOverride",
           settled_at AS "settledAt",
+          lifecycle AS "lifecycle",
+          lifecycle_reason AS "lifecycleReason",
+          lifecycle_changed_at AS "lifecycleChangedAt",
+          last_engaged_at AS "lastEngagedAt",
           snoozed_until AS "snoozedUntil",
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
@@ -32654,6 +33095,10 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           archived_at AS "archivedAt",
           settled_override AS "settledOverride",
           settled_at AS "settledAt",
+          lifecycle AS "lifecycle",
+          lifecycle_reason AS "lifecycleReason",
+          lifecycle_changed_at AS "lifecycleChangedAt",
+          last_engaged_at AS "lastEngagedAt",
           snoozed_until AS "snoozedUntil",
           snoozed_at AS "snoozedAt",
           pinned_at AS "pinnedAt",
@@ -33346,6 +33791,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			archivedAt: row.archivedAt,
 			settledOverride: row.settledOverride,
 			settledAt: row.settledAt,
+			lifecycle: row.lifecycle,
+			lifecycleReason: row.lifecycleReason,
+			lifecycleChangedAt: row.lifecycleChangedAt,
+			lastEngagedAt: row.lastEngagedAt,
+			doneAt: row.settledAt,
 			snoozedUntil: row.snoozedUntil,
 			snoozedAt: row.snoozedAt,
 			pinnedAt: row.pinnedAt,
@@ -33489,6 +33939,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 				archivedAt: row.archivedAt,
 				settledOverride: row.settledOverride,
 				settledAt: row.settledAt,
+				lifecycle: row.lifecycle,
+				lifecycleReason: row.lifecycleReason,
+				lifecycleChangedAt: row.lifecycleChangedAt,
+				lastEngagedAt: row.lastEngagedAt,
+				doneAt: row.settledAt,
 				snoozedUntil: row.snoozedUntil,
 				snoozedAt: row.snoozedAt,
 				pinnedAt: row.pinnedAt,
@@ -33555,6 +34010,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 				archivedAt: row.archivedAt,
 				settledOverride: row.settledOverride,
 				settledAt: row.settledAt,
+				lifecycle: row.lifecycle,
+				lifecycleReason: row.lifecycleReason,
+				lifecycleChangedAt: row.lifecycleChangedAt,
+				lastEngagedAt: row.lastEngagedAt,
+				doneAt: row.settledAt,
 				snoozedUntil: row.snoozedUntil,
 				snoozedAt: row.snoozedAt,
 				pinnedAt: row.pinnedAt,
@@ -33621,6 +34081,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 				archivedAt: row.archivedAt,
 				settledOverride: row.settledOverride,
 				settledAt: row.settledAt,
+				lifecycle: row.lifecycle,
+				lifecycleReason: row.lifecycleReason,
+				lifecycleChangedAt: row.lifecycleChangedAt,
+				lastEngagedAt: row.lastEngagedAt,
+				doneAt: row.settledAt,
 				snoozedUntil: row.snoozedUntil,
 				snoozedAt: row.snoozedAt,
 				pinnedAt: row.pinnedAt,
@@ -33735,6 +34200,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			archivedAt: threadRow.value.archivedAt,
 			settledOverride: threadRow.value.settledOverride,
 			settledAt: threadRow.value.settledAt,
+			lifecycle: threadRow.value.lifecycle,
+			lifecycleReason: threadRow.value.lifecycleReason,
+			lifecycleChangedAt: threadRow.value.lifecycleChangedAt,
+			lastEngagedAt: threadRow.value.lastEngagedAt,
+			doneAt: threadRow.value.settledAt,
 			snoozedUntil: threadRow.value.snoozedUntil,
 			snoozedAt: threadRow.value.snoozedAt,
 			pinnedAt: threadRow.value.pinnedAt,
@@ -33802,6 +34272,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			archivedAt: threadRow.value.archivedAt,
 			settledOverride: threadRow.value.settledOverride,
 			settledAt: threadRow.value.settledAt,
+			lifecycle: threadRow.value.lifecycle,
+			lifecycleReason: threadRow.value.lifecycleReason,
+			lifecycleChangedAt: threadRow.value.lifecycleChangedAt,
+			lastEngagedAt: threadRow.value.lastEngagedAt,
+			doneAt: threadRow.value.settledAt,
 			snoozedUntil: threadRow.value.snoozedUntil,
 			snoozedAt: threadRow.value.snoozedAt,
 			pinnedAt: threadRow.value.pinnedAt,
@@ -33927,9 +34402,185 @@ const OrchestrationProjectionSnapshotQueryLive = Layer.effect(ProjectionSnapshot
 //#region src/orchestration/Services/ThreadEventStream.ts
 var ThreadEventStreamService = class extends Context.Service()("@p4code/cli/orchestration/Services/ThreadEventStream/ThreadEventStreamService") {};
 //#endregion
+//#region src/orchestration/ThreadReviewProjection.ts
+const isMessagePayload = Schema$1.is(ThreadMessageSentPayload);
+const MAX_MESSAGE_IDENTITY_LENGTH = 1024;
+const MAX_PREVIEW_DEPTH = 12;
+const MAX_PREVIEW_NODES = 512;
+const TRUNCATION_MARKER$1 = "\n[truncated; recover source events]\n";
+function excerpt(text, length) {
+	if (text.length <= length) return text;
+	const sideLength = Math.max(0, Math.floor((length - 36) / 2));
+	return text.slice(0, sideLength).replace(/[\uD800-\uDBFF]$/, "") + TRUNCATION_MARKER$1 + (sideLength > 0 ? text.slice(-sideLength).replace(/^[\uDC00-\uDFFF]/, "") : "");
+}
+/** Serialize only a bounded prefix, without walking or copying an oversized tool result. */
+function payloadPreview(payload) {
+	let remainingNodes = MAX_PREVIEW_NODES;
+	function* parts(value, depth) {
+		if (--remainingNodes < 0 || depth > MAX_PREVIEW_DEPTH) {
+			yield TRUNCATION_MARKER$1;
+			return;
+		}
+		if (typeof value === "string") yield JSON.stringify(excerpt(value, THREAD_REVIEW_ITEM_MAX_BYTES));
+		else if (value === null || typeof value !== "object") yield JSON.stringify(value) ?? "null";
+		else {
+			const array = Array.isArray(value);
+			yield array ? "[" : "{";
+			let first = true;
+			for (const key in value) {
+				if (!Object.hasOwn(value, key)) continue;
+				if (remainingNodes <= 0) {
+					yield TRUNCATION_MARKER$1;
+					break;
+				}
+				if (!first) yield ",";
+				first = false;
+				if (!array) yield JSON.stringify(excerpt(key, THREAD_REVIEW_ITEM_MAX_BYTES)) + ":";
+				yield* parts(value[key], depth + 1);
+			}
+			yield array ? "]" : "}";
+		}
+	}
+	let text = "";
+	let truncated = false;
+	for (const part of parts(payload, 0)) {
+		if (part.includes(TRUNCATION_MARKER$1) || part.includes(JSON.stringify(TRUNCATION_MARKER$1).slice(1, -1))) truncated = true;
+		const remaining = THREAD_REVIEW_ITEM_MAX_BYTES - text.length;
+		if (part.length > remaining) {
+			text += part.slice(0, remaining);
+			truncated = true;
+			break;
+		}
+		text += part;
+	}
+	return {
+		text,
+		truncated
+	};
+}
+function fitItem(item) {
+	let result = item;
+	let bytes = Buffer.byteLength(JSON.stringify(result));
+	while (bytes > THREAD_REVIEW_ITEM_MAX_BYTES) {
+		const text = result.kind === "message" ? result.text : result.payload;
+		const length = Math.max(36, Math.floor(text.length / 2));
+		result = result.kind === "message" ? {
+			...result,
+			text: excerpt(text, length),
+			truncated: true
+		} : {
+			...result,
+			payload: excerpt(text, length),
+			truncated: true
+		};
+		bytes = Buffer.byteLength(JSON.stringify(result));
+	}
+	return result;
+}
+/** Page-local folds follow the projector: streaming appends; nonempty completion replaces. */
+function createThreadReviewPage(input) {
+	const items = [];
+	const messageIndexes = /* @__PURE__ */ new Map();
+	let nextAfterSequence = input.afterSequence;
+	let scannedEvents = 0;
+	let itemBytes = 0;
+	const envelopeBytes = Buffer.byteLength(JSON.stringify({
+		threadId: input.threadId,
+		items: [],
+		throughSequence: input.throughSequence,
+		nextAfterSequence: Number.MAX_SAFE_INTEGER,
+		hasMore: false,
+		scannedEvents: Number.MAX_SAFE_INTEGER
+	}));
+	function offer(event, sourceTruncated = false) {
+		if (event.sequence > input.throughSequence) return false;
+		if (event.aggregateKind !== "thread" || event.aggregateId !== input.threadId) {
+			nextAfterSequence = event.sequence;
+			scannedEvents += 1;
+			return true;
+		}
+		let item;
+		let index;
+		let messageKey;
+		if (event.type === "thread.message-sent" && !sourceTruncated && isMessagePayload(event.payload) && event.payload.role === "assistant" && !event.payload.attachments?.length && event.payload.messageId.length + (event.payload.turnId?.length ?? 0) <= MAX_MESSAGE_IDENTITY_LENGTH) {
+			const payload = event.payload;
+			messageKey = JSON.stringify([payload.turnId, payload.messageId]);
+			index = messageIndexes.get(messageKey);
+			const previous = index === void 0 ? void 0 : items[index];
+			const previousMessage = previous?.kind === "message" ? previous : void 0;
+			const replaces = !payload.streaming && payload.text.length > 0;
+			const part = excerpt(payload.text, THREAD_REVIEW_ITEM_MAX_BYTES);
+			item = fitItem({
+				kind: "message",
+				firstSequence: previousMessage?.firstSequence ?? event.sequence,
+				lastSequence: event.sequence,
+				messageId: payload.messageId,
+				turnId: payload.turnId,
+				role: payload.role,
+				operation: replaces ? "replace" : previousMessage?.operation ?? "append",
+				complete: !payload.streaming,
+				text: replaces ? part : (previousMessage?.text ?? "") + part,
+				truncated: part !== payload.text || !replaces && (previousMessage?.truncated ?? false)
+			});
+		} else {
+			const preview = sourceTruncated && typeof event.payload === "string" ? {
+				text: event.payload,
+				truncated: true
+			} : payloadPreview(event.payload);
+			item = fitItem({
+				kind: "event",
+				type: event.type,
+				firstSequence: event.sequence,
+				lastSequence: event.sequence,
+				payload: preview.text,
+				truncated: preview.truncated
+			});
+		}
+		const previousBytes = index === void 0 ? 0 : Buffer.byteLength(JSON.stringify(items[index]));
+		const nextBytes = itemBytes - previousBytes + Buffer.byteLength(JSON.stringify(item));
+		if (index === void 0 && items.length >= 100 || envelopeBytes + nextBytes + items.length + 1 > 48e3) return false;
+		if (index === void 0) {
+			if (messageKey !== void 0) messageIndexes.set(messageKey, items.length);
+			items.push(item);
+		} else items[index] = item;
+		itemBytes = nextBytes;
+		nextAfterSequence = event.sequence;
+		scannedEvents += 1;
+		return true;
+	}
+	return {
+		offer,
+		offerStored(row) {
+			if (row.payloadJson.length <= 8e3) try {
+				return offer({
+					...row,
+					payload: JSON.parse(row.payloadJson)
+				});
+			} catch {}
+			return offer({
+				...row,
+				payload: row.payloadJson.slice(0, THREAD_REVIEW_ITEM_MAX_BYTES)
+			}, true);
+		},
+		finish(exhausted) {
+			if (exhausted) nextAfterSequence = Math.max(nextAfterSequence, input.throughSequence);
+			return {
+				threadId: input.threadId,
+				items: items.toSorted((a, b) => a.lastSequence - b.lastSequence),
+				throughSequence: input.throughSequence,
+				nextAfterSequence,
+				hasMore: nextAfterSequence < input.throughSequence,
+				scannedEvents
+			};
+		}
+	};
+}
+//#endregion
 //#region src/orchestration/Layers/ThreadEventStream.ts
+const REVIEW_SOURCE_PAGE_SIZE = 100;
 const makeThreadEventStream = Effect.gen(function* () {
 	const engine = yield* OrchestrationEngineService;
+	const eventStore = yield* OrchestrationEventStore;
 	const isThreadEvent = (threadId) => (event) => event.aggregateKind === "thread" && event.aggregateId === threadId;
 	const watch = (input) => Stream.unwrap(Effect.gen(function* () {
 		const matchesThread = isThreadEvent(input.threadId);
@@ -33971,9 +34622,38 @@ const makeThreadEventStream = Effect.gen(function* () {
 			hasMore
 		};
 	});
+	const readReview = Effect.fn("ThreadEventStream.readReview")(function* (input) {
+		const headSequence = yield* engine.latestSequence;
+		const throughSequence = Math.min(input.throughSequence ?? headSequence, headSequence);
+		const afterSequence = input.afterSequence ?? 0;
+		const page = createThreadReviewPage({
+			threadId: input.threadId,
+			afterSequence,
+			throughSequence
+		});
+		if (afterSequence >= throughSequence) return page.finish(true);
+		let cursor = afterSequence;
+		let scanned = 0;
+		while (scanned < 2e3 && cursor < throughSequence) {
+			const limit = Math.min(REVIEW_SOURCE_PAGE_SIZE, THREAD_REVIEW_SCAN_LIMIT - scanned);
+			const rows = yield* eventStore.readReviewPage({
+				afterSequence: cursor,
+				throughSequence,
+				limit
+			});
+			for (const row of rows) {
+				if (!page.offerStored(row)) return page.finish(false);
+				cursor = row.sequence;
+				scanned += 1;
+			}
+			if (rows.length < limit) return page.finish(true);
+		}
+		return page.finish(false);
+	});
 	return ThreadEventStreamService.of({
 		watch,
-		read
+		read,
+		readReview
 	});
 });
 const ThreadEventStreamLive = Layer.effect(ThreadEventStreamService, makeThreadEventStream);
@@ -33990,7 +34670,7 @@ const OrchestrationProjectionPipelineLayerLive = OrchestrationProjectionPipeline
 const ThreadBackgroundLivenessLayerLive = layer$64;
 const OrchestrationInfrastructureLayerLive = Layer.mergeAll(OrchestrationProjectionSnapshotQueryLive, OrchestrationEventInfrastructureLayerLive, OrchestrationProjectionPipelineLayerLive, ThreadBackgroundLivenessLayerLive);
 const OrchestrationEngineLayerLive = OrchestrationEngineLive.pipe(Layer.provide(OrchestrationInfrastructureLayerLive));
-const OrchestrationLayerLive = Layer.mergeAll(OrchestrationInfrastructureLayerLive, OrchestrationEngineLayerLive, ThreadEventStreamLive.pipe(Layer.provide(OrchestrationEngineLayerLive)));
+const OrchestrationLayerLive = Layer.mergeAll(OrchestrationInfrastructureLayerLive, OrchestrationEngineLayerLive, ThreadEventStreamLive.pipe(Layer.provide(OrchestrationEngineLayerLive), Layer.provide(OrchestrationEventStoreLive)));
 //#endregion
 //#region ../../packages/shared/src/keybindings.ts
 const DEFAULT_KEYBINDINGS = [
@@ -34462,7 +35142,7 @@ function mergeWithDefaultKeybindings(custom) {
 * Keybindings - Service tag for keybinding configuration operations.
 */
 var Keybindings = class extends Context.Service()("@p4code/cli/keybindings") {};
-const make$72 = Effect.gen(function* () {
+const make$73 = Effect.gen(function* () {
 	const { keybindingsConfigPath } = yield* ServerConfig$1;
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -34723,7 +35403,7 @@ const make$72 = Effect.gen(function* () {
 		}))
 	};
 });
-const layer$61 = Layer.effect(Keybindings, make$72);
+const layer$61 = Layer.effect(Keybindings, make$73);
 //#endregion
 //#region src/process/externalLauncher.ts
 /**
@@ -34950,7 +35630,7 @@ const launchEditorProcess = Effect.fn("externalLauncher.launchEditorProcess")(fu
 		cause
 	}));
 });
-const make$71 = Effect.gen(function* () {
+const make$72 = Effect.gen(function* () {
 	const spawner = yield* ChildProcessSpawner$1.ChildProcessSpawner;
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -34961,7 +35641,7 @@ const make$71 = Effect.gen(function* () {
 		launchEditor: (input) => provideCommandResolutionServices(Effect.flatMap(resolveEditorLaunch(input), (launch) => launchEditorProcess(launch).pipe(Effect.provideService(ChildProcessSpawner$1.ChildProcessSpawner, spawner))))
 	});
 });
-const layer$60 = Layer.effect(ExternalLauncher, make$71);
+const layer$60 = Layer.effect(ExternalLauncher, make$72);
 //#endregion
 //#region src/orchestration/Services/OrchestrationReactor.ts
 /**
@@ -34979,7 +35659,7 @@ var OrchestrationReactor = class extends Context.Service()("@p4code/cli/orchestr
 //#endregion
 //#region src/serverLifecycleEvents.ts
 var ServerLifecycleEvents = class extends Context.Service()("@p4code/cli/serverLifecycleEvents") {};
-const make$70 = Effect.gen(function* () {
+const make$71 = Effect.gen(function* () {
 	const pubsub = yield* PubSub.unbounded();
 	const state = yield* Ref.make({
 		sequence: 0,
@@ -35003,7 +35683,7 @@ const make$70 = Effect.gen(function* () {
 		}
 	};
 });
-const layer$59 = Layer.effect(ServerLifecycleEvents, make$70);
+const layer$59 = Layer.effect(ServerLifecycleEvents, make$71);
 //#endregion
 //#region src/telemetry/Identify.ts
 const CodexAuthJsonSchema = Schema$1.Struct({ tokens: Schema$1.Struct({ account_id: Schema$1.String }) });
@@ -35176,7 +35856,7 @@ var AnalyticsService = class AnalyticsService extends Context.Service()("@p4code
 	/** No-op layer for callers that intentionally disable telemetry. */
 	static layerTest = Layer.succeed(AnalyticsService, inert);
 };
-const make$69 = Effect.gen(function* () {
+const make$70 = Effect.gen(function* () {
 	const telemetryConfig = yield* TelemetryEnvConfig;
 	const posthogKey = telemetryConfig.posthogKey.trim();
 	if (!telemetryConfig.enabled || posthogKey === "") return inert;
@@ -35246,7 +35926,7 @@ const make$69 = Effect.gen(function* () {
 		flush
 	});
 });
-const layer$58 = Layer.effect(AnalyticsService, make$69);
+const layer$58 = Layer.effect(AnalyticsService, make$70);
 AnalyticsService.layerTest;
 //#endregion
 //#region src/service/pinnedRuntime.ts
@@ -35593,7 +36273,7 @@ var BootServiceInstallError = class extends Schema$1.TaggedErrorClass()("BootSer
 	}
 };
 var BootService = class extends Context.Service()("@p4code/cli/service/bootService") {};
-const make$68 = Effect.fn("cloud.boot_service.make")(function* (input) {
+const make$69 = Effect.fn("cloud.boot_service.make")(function* (input) {
 	const hostExecPath = yield* HostProcessExecutablePath;
 	const hostArguments = yield* HostProcessArguments;
 	const host = input.host ?? {
@@ -35815,7 +36495,7 @@ const make$68 = Effect.fn("cloud.boot_service.make")(function* (input) {
 		logPath
 	});
 });
-const layer$57 = (input) => Layer.effect(BootService, make$68(input));
+const layer$57 = (input) => Layer.effect(BootService, make$69(input));
 //#endregion
 //#region src/service/selfUpdate.ts
 /**
@@ -35890,7 +36570,7 @@ const resolveServerSelfUpdateCapability = Effect.fn("cloud.server_self_update.re
 	return null;
 });
 var ServerSelfUpdate = class extends Context.Service()("@p4code/cli/service/selfUpdate/ServerSelfUpdate") {};
-const make$67 = Effect.fn("cloud.server_self_update.make")(function* (options) {
+const make$68 = Effect.fn("cloud.server_self_update.make")(function* (options) {
 	const serverConfig = yield* ServerConfig$1;
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -36040,7 +36720,7 @@ const make$67 = Effect.fn("cloud.server_self_update.make")(function* (options) {
 	});
 	return ServerSelfUpdate.of({ update });
 });
-const layer$56 = Layer.effect(ServerSelfUpdate, make$67()).pipe(Layer.provide(layer$63));
+const layer$56 = Layer.effect(ServerSelfUpdate, make$68()).pipe(Layer.provide(layer$63));
 //#endregion
 //#region src/environment/ServerEnvironmentLabel.ts
 const ServerEnvironmentLabelCommandProbe = Schema$1.Literals(["macos-computer-name", "linux-pretty-hostname"]);
@@ -36172,7 +36852,7 @@ function platformArch(architecture) {
 		default: return "other";
 	}
 }
-const make$66 = Effect.gen(function* () {
+const make$67 = Effect.gen(function* () {
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const serverConfig = yield* ServerConfig$1;
@@ -36221,6 +36901,7 @@ const make$66 = Effect.gen(function* () {
 			connectionProbe: true,
 			pullRequests: true,
 			threadSettlement: true,
+			threadLifecycleV2: true,
 			threadSnooze: true,
 			threadPinning: true,
 			threadFork: true,
@@ -36239,7 +36920,7 @@ const make$66 = Effect.gen(function* () {
 * state. It intentionally has no fallback Layer.succeed value: callers must
 * provide the external platform services and a ServerConfig.
 */
-const layer$55 = Layer.effect(ServerEnvironment, make$66).pipe(Layer.provide(layer$63));
+const layer$55 = Layer.effect(ServerEnvironment, make$67).pipe(Layer.provide(layer$63));
 //#endregion
 //#region src/provider/Services/ProviderSessionReaper.ts
 var ProviderSessionReaper = class extends Context.Service()("@p4code/cli/provider/Services/ProviderSessionReaper") {};
@@ -36381,7 +37062,7 @@ const maybeOpenBrowser = (target) => Effect.gen(function* () {
 	yield* (yield* ExternalLauncher).launchBrowser(target).pipe(Effect.catch(() => Effect.logInfo("browser auto-open unavailable", { hint: `Open ${target} in your browser.` })));
 });
 const runStartupPhase = (phase, effect) => effect.pipe(Effect.annotateSpans({ "startup.phase": phase }), Effect.withSpan(`server.startup.${phase}`));
-const make$65 = Effect.gen(function* () {
+const make$66 = Effect.gen(function* () {
 	const serverConfig = yield* ServerConfig$1;
 	const keybindings = yield* Keybindings;
 	const orchestrationReactor = yield* OrchestrationReactor;
@@ -36522,7 +37203,7 @@ const make$65 = Effect.gen(function* () {
 		enqueueCommand: commandGate.enqueueCommand
 	};
 });
-const layer$54 = Layer.effect(ServerRuntimeStartup, make$65);
+const layer$54 = Layer.effect(ServerRuntimeStartup, make$66);
 //#endregion
 //#region src/serverRuntimeState.ts
 const PersistedServerRuntimeState = Schema$1.Struct({
@@ -36679,7 +37360,7 @@ function expandHomePath$2(input, path) {
 	if (input.startsWith("~/") || input.startsWith("~\\")) return path.join(NodeOS.homedir(), input.slice(2));
 	return input;
 }
-const make$64 = Effect.gen(function* () {
+const make$65 = Effect.gen(function* () {
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const statWorkspaceRoot = Effect.fn("WorkspacePaths.statWorkspaceRoot")(function* (workspaceRoot, normalizedWorkspaceRoot, phase) {
@@ -36736,7 +37417,7 @@ const make$64 = Effect.gen(function* () {
 		resolveRelativePathWithinRoot
 	});
 });
-const layer$53 = Layer.effect(WorkspacePaths, make$64);
+const layer$53 = Layer.effect(WorkspacePaths, make$65);
 //#endregion
 //#region src/cli/project.ts
 const isEnvironmentHttpCommonError = Schema$1.is(EnvironmentHttpCommonError);
@@ -36871,7 +37552,7 @@ const findActiveProjectTarget = Effect.fn("findActiveProjectTarget")(function* (
 		operation: "resolveProjectTarget",
 		identifier: input.identifier
 	});
-	const activeProjects = input.snapshot.projects.filter((project) => project.deletedAt === null);
+	const activeProjects = input.snapshot.projects.filter((project) => project.deletedAt == null);
 	const exactIdMatch = activeProjects.find((project) => project.id === trimmedIdentifier);
 	if (exactIdMatch) return {
 		id: exactIdMatch.id,
@@ -36895,7 +37576,7 @@ const findActiveProjectTarget = Effect.fn("findActiveProjectTarget")(function* (
 	};
 });
 const fetchLiveOrchestrationSnapshot = (origin, bearerToken) => Effect.gen(function* () {
-	return yield* (yield* makeLiveServerClient(origin)).orchestration.snapshot({ headers: { authorization: `Bearer ${bearerToken}` } });
+	return yield* (yield* makeLiveServerClient(origin)).orchestration.shellSnapshot({ headers: { authorization: `Bearer ${bearerToken}` } });
 }).pipe(withProjectCliLiveServerTimeout, Effect.mapError(projectCommandErrorFromLiveServerRequest));
 const dispatchLiveOrchestrationCommand = (origin, bearerToken, command) => Effect.gen(function* () {
 	yield* (yield* makeLiveServerClient(origin)).orchestration.dispatch({
@@ -36904,7 +37585,7 @@ const dispatchLiveOrchestrationCommand = (origin, bearerToken, command) => Effec
 	});
 }).pipe(withProjectCliLiveServerTimeout, Effect.mapError(projectCommandErrorFromLiveServerRequest));
 const getOfflineSnapshot = Effect.fn("getOfflineSnapshot")(function* () {
-	return yield* (yield* ProjectionSnapshotQuery).getSnapshot();
+	return yield* (yield* ProjectionSnapshotQuery).getCommandReadModel();
 });
 const tryResolveLiveProjectExecutionMode = Effect.fn("tryResolveLiveProjectExecutionMode")(function* (environmentAuth, config) {
 	const runtimeState = yield* readPersistedServerRuntimeState(config.serverRuntimeStatePath);
@@ -36952,7 +37633,7 @@ const projectAddCommand = Command.make("add", {
 	title: Flag.string("title").pipe(Flag.withDescription("Optional project title."), Flag.optional)
 }).pipe(Command.withDescription("Add a project."), Command.withHandler((flags) => runProjectMutation(flags, Effect.fn("projectAddMutation")(function* ({ snapshot, dispatch }) {
 	const workspaceRoot = yield* normalizeWorkspaceRootForProjectCommand(flags.workspaceRoot);
-	const existingProject = snapshot.projects.find((project) => project.deletedAt === null && project.workspaceRoot === workspaceRoot);
+	const existingProject = snapshot.projects.find((project) => project.deletedAt == null && project.workspaceRoot === workspaceRoot);
 	if (existingProject) return yield* new ProjectAlreadyExistsError({
 		operation: "addProject",
 		projectId: existingProject.id,
@@ -37919,7 +38600,7 @@ const logP4ProjectFileLoadError = (error) => Effect.logWarning(error).pipe(Effec
 	filePath: error.filePath,
 	errorTag: error._tag
 }));
-const make$63 = Effect.gen(function* () {
+const make$64 = Effect.gen(function* () {
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const load = Effect.fn("P4ProjectFileLoader.load")(function* (workspaceRoot) {
@@ -37940,7 +38621,7 @@ const make$63 = Effect.gen(function* () {
 	});
 	return P4ProjectFileLoader.of({ load });
 });
-const layer$52 = Layer.effect(P4ProjectFileLoader, make$63);
+const layer$52 = Layer.effect(P4ProjectFileLoader, make$64);
 //#endregion
 //#region src/project/ProjectFaviconResolver.ts
 /**
@@ -38015,7 +38696,7 @@ function extractIconHref(source) {
 	return null;
 }
 const optionOnNotFound$1 = (effect) => effect.pipe(Effect.map(Option.some), Effect.catchTags({ PlatformError: (error) => error.reason._tag === "NotFound" ? Effect.succeed(Option.none()) : Effect.fail(error) }));
-const make$62 = Effect.gen(function* () {
+const make$63 = Effect.gen(function* () {
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const workspacePaths = yield* WorkspacePaths;
@@ -38084,7 +38765,7 @@ const make$62 = Effect.gen(function* () {
 	});
 	return ProjectFaviconResolver.of({ resolvePath });
 });
-const layer$51 = Layer.effect(ProjectFaviconResolver, make$62);
+const layer$51 = Layer.effect(ProjectFaviconResolver, make$63);
 //#endregion
 //#region src/assets/AssetAccess.ts
 const ASSET_ROUTE_PREFIX = "/api/assets";
@@ -38495,10 +39176,10 @@ const resolveAsset = Effect.fn("AssetAccess.resolveAsset")(function* (token, rel
 //#endregion
 //#region src/observability/BrowserTraceCollector.ts
 var BrowserTraceCollector = class extends Context.Service()("@p4code/cli/observability/BrowserTraceCollector") {};
-const make$61 = (sink) => BrowserTraceCollector.of({ record: (records) => Effect.sync(() => {
+const make$62 = (sink) => BrowserTraceCollector.of({ record: (records) => Effect.sync(() => {
 	for (const record of records) sink.push(record);
 }) });
-const layer$50 = (sink) => Layer.succeed(BrowserTraceCollector, make$61(sink));
+const layer$50 = (sink) => Layer.succeed(BrowserTraceCollector, make$62(sink));
 //#endregion
 //#region src/auth/http.ts
 const CREDENTIAL_RESPONSE_HEADERS = {
@@ -39820,6 +40501,9 @@ const LIST_REFS_SNAPSHOT_CACHE_CAPACITY = 64;
 const LIST_REFS_SNAPSHOT_CACHE_TTL = Duration.minutes(2);
 const LIST_REFS_REFRESH_COALESCE_TTL = Duration.seconds(5);
 const LIST_REFS_REFRESH_FAILURE_COOLDOWN = Duration.seconds(30);
+const STATUS_STATIC_CACHE_CAPACITY = 2048;
+const STATUS_DEFAULT_BRANCH_CACHE_TTL = Duration.minutes(5);
+const STATUS_ORIGIN_EXISTS_CACHE_TTL = Duration.minutes(5);
 const STATUS_UPSTREAM_REFRESH_ENV = Object.freeze({
 	GCM_INTERACTIVE: "never",
 	GIT_ASKPASS: "",
@@ -40031,6 +40715,9 @@ function isMissingGitCwdError(error) {
 function isNonRepositoryGitStderr(stderr) {
 	return stderr.toLowerCase().includes("not a git repository");
 }
+function isUnbornHeadStderr(stderr) {
+	return stderr.toLowerCase().includes("unknown revision") && stderr.toLowerCase().includes("path not in the working tree");
+}
 const nowUnixNano = DateTime.now.pipe(Effect.map((now) => BigInt(DateTime.toEpochMillis(now)) * 1000000n));
 const addCurrentSpanEvent = (name, attributes) => Effect.gen(function* () {
 	const span = yield* Effect.currentSpan;
@@ -40424,6 +41111,47 @@ const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* () {
 		const cacheKey = normalizeRepositoryPathsCacheKey(cwd);
 		return Cache.get(refresh ? repositoryPathsRefreshCache : repositoryPathsCache, cacheKey);
 	};
+	const defaultBranchCache = yield* Cache.makeWith((gitCommonDir) => Effect.gen(function* () {
+		const path = yield* Path.Path;
+		const fetchCwd = path.basename(gitCommonDir) === ".git" ? path.dirname(gitCommonDir) : gitCommonDir;
+		return yield* executeGit("GitVcsDriver.statusDetails.defaultBranch", fetchCwd, [
+			"--git-dir",
+			gitCommonDir,
+			"symbolic-ref",
+			"refs/remotes/origin/HEAD"
+		], { allowNonZeroExit: true }).pipe(Effect.map((result) => {
+			if (result.exitCode !== 0) return null;
+			return parseDefaultBranchFromRemoteHeadRef(result.stdout, "origin");
+		}));
+	}), {
+		capacity: STATUS_STATIC_CACHE_CAPACITY,
+		timeToLive: Exit.match({
+			onSuccess: () => STATUS_DEFAULT_BRANCH_CACHE_TTL,
+			onFailure: () => Duration.zero
+		})
+	});
+	const originExistsCache = yield* Cache.makeWith((gitCommonDir) => Effect.gen(function* () {
+		const path = yield* Path.Path;
+		const fetchCwd = path.basename(gitCommonDir) === ".git" ? path.dirname(gitCommonDir) : gitCommonDir;
+		return yield* executeGit("GitVcsDriver.statusDetails.originExists", fetchCwd, [
+			"--git-dir",
+			gitCommonDir,
+			"remote",
+			"get-url",
+			"origin"
+		], { allowNonZeroExit: true }).pipe(Effect.map((result) => result.exitCode === 0));
+	}), {
+		capacity: STATUS_STATIC_CACHE_CAPACITY,
+		timeToLive: Exit.match({
+			onSuccess: () => STATUS_ORIGIN_EXISTS_CACHE_TTL,
+			onFailure: () => Duration.zero
+		})
+	});
+	const invalidateStatusStaticCaches = Effect.fn("invalidateStatusStaticCaches")(function* (cwd) {
+		const cacheKey = (yield* resolveRepositoryPaths(cwd).pipe(Effect.catchTags({ GitCommandError: () => Effect.succeed(null) })))?.gitCommonDir ?? normalizeRepositoryPathsCacheKey(cwd);
+		yield* Cache.invalidate(defaultBranchCache, cacheKey);
+		yield* Cache.invalidate(originExistsCache, cacheKey);
+	});
 	const resolveGitCommonDir = Effect.fn("resolveGitCommonDir")(function* (cwd) {
 		const repositoryPaths = yield* resolveRepositoryPaths(cwd);
 		if (repositoryPaths !== null) return repositoryPaths.gitCommonDir;
@@ -40467,10 +41195,16 @@ const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* () {
 			remoteName: upstream.remoteName
 		}));
 	});
-	const resolveDefaultBranchName = (cwd, remoteName) => executeGit("GitVcsDriver.resolveDefaultBranchName", cwd, ["symbolic-ref", `refs/remotes/${remoteName}/HEAD`], { allowNonZeroExit: true }).pipe(Effect.map((result) => {
-		if (result.exitCode !== 0) return null;
-		return parseDefaultBranchFromRemoteHeadRef(result.stdout, remoteName);
-	}));
+	const resolveDefaultBranchName = Effect.fn("resolveDefaultBranchName")(function* (cwd, remoteName) {
+		if (remoteName === "origin") {
+			const repositoryPaths = yield* resolveRepositoryPaths(cwd);
+			if (repositoryPaths) return yield* Cache.get(defaultBranchCache, repositoryPaths.gitCommonDir);
+		}
+		return yield* executeGit("GitVcsDriver.resolveDefaultBranchName", cwd, ["symbolic-ref", `refs/remotes/${remoteName}/HEAD`], { allowNonZeroExit: true }).pipe(Effect.map((result) => {
+			if (result.exitCode !== 0) return null;
+			return parseDefaultBranchFromRemoteHeadRef(result.stdout, remoteName);
+		}));
+	});
 	const remoteBranchExists = (cwd, remoteName, refName) => executeGit("GitVcsDriver.remoteBranchExists", cwd, [
 		"show-ref",
 		"--verify",
@@ -40575,9 +41309,10 @@ const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* () {
 			"HEAD"
 		], { allowNonZeroExit: true }).pipe(Effect.catchTags({ GitCommandError: (error) => isMissingGitCwdError(error) ? Effect.succeed(null) : Effect.fail(error) }));
 		if (branchResult === null) return NON_REPOSITORY_REMOTE_STATUS_DETAILS;
+		let branch;
 		if (branchResult.exitCode !== 0) {
 			if (isNonRepositoryGitStderr(branchResult.stderr)) return NON_REPOSITORY_REMOTE_STATUS_DETAILS;
-			return yield* new GitCommandError({
+			if (!isUnbornHeadStderr(branchResult.stderr)) return yield* new GitCommandError({
 				...gitCommandContext({
 					operation: "GitVcsDriver.statusDetailsRemote.branch",
 					cwd,
@@ -40592,9 +41327,16 @@ const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* () {
 				stdoutLength: branchResult.stdout.length,
 				stderrLength: branchResult.stderr.length
 			});
+			branch = (yield* runGitStdout("GitVcsDriver.statusDetailsRemote.unbornBranch", cwd, [
+				"symbolic-ref",
+				"--quiet",
+				"--short",
+				"HEAD"
+			])).trim() || null;
+		} else {
+			const branchValue = branchResult.stdout.trim();
+			branch = branchValue.length > 0 && branchValue !== "HEAD" ? branchValue : null;
 		}
-		const branchValue = branchResult.stdout.trim();
-		const branch = branchValue.length > 0 && branchValue !== "HEAD" ? branchValue : null;
 		const upstreamRef = (yield* resolveCurrentUpstream(cwd))?.upstreamRef ?? null;
 		let aheadCount = 0;
 		let behindCount = 0;
@@ -40652,18 +41394,53 @@ const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* () {
 				stderrLength: statusResult.stderr.length
 			});
 		}
-		const [unstagedNumstatStdout, stagedNumstatStdout, defaultRefResult, hasPrimaryRemote] = yield* Effect.all([
-			runGitStdout("GitVcsDriver.statusDetails.unstagedNumstat", cwd, ["diff", "--numstat"]),
-			runGitStdout("GitVcsDriver.statusDetails.stagedNumstat", cwd, [
+		const statusCacheKey = (yield* resolveRepositoryPaths(cwd).pipe(Effect.catchTags({ GitCommandError: () => Effect.succeed(null) })))?.gitCommonDir;
+		const [numstatStdout, defaultBranch, hasPrimaryRemote] = yield* Effect.all([
+			executeGitWithStableDiagnostics("GitVcsDriver.statusDetails.numstat", cwd, [
 				"diff",
-				"--cached",
+				"HEAD",
 				"--numstat"
-			]),
-			executeGit("GitVcsDriver.statusDetails.defaultRef", cwd, ["symbolic-ref", "refs/remotes/origin/HEAD"], { allowNonZeroExit: true }),
-			originRemoteExists(cwd).pipe(Effect.orElseSucceed(() => false))
+			], { allowNonZeroExit: true }).pipe(Effect.flatMap((result) => {
+				if (result.exitCode === 0) return Effect.succeed(result.stdout);
+				if (isUnbornHeadStderr(result.stderr)) return Effect.map(Effect.all([runGitStdout("GitVcsDriver.statusDetails.numstat.unborn", cwd, ["diff", "--numstat"]), runGitStdout("GitVcsDriver.statusDetails.numstat.unborn.staged", cwd, [
+					"diff",
+					"--cached",
+					"--numstat"
+				])]), ([unstagedStdout, stagedStdout]) => {
+					const staged = parseNumstatEntries(stagedStdout);
+					const unstaged = parseNumstatEntries(unstagedStdout);
+					const map = /* @__PURE__ */ new Map();
+					for (const entry of [...staged, ...unstaged]) {
+						const existing = map.get(entry.path) ?? {
+							insertions: 0,
+							deletions: 0
+						};
+						existing.insertions += entry.insertions;
+						existing.deletions += entry.deletions;
+						map.set(entry.path, existing);
+					}
+					return Array.from(map.entries()).map(([p, s]) => `${s.insertions}\t${s.deletions}\t${p}`).join("\n");
+				});
+				return Effect.fail(new GitCommandError({
+					...gitCommandContext({
+						operation: "GitVcsDriver.statusDetails.numstat",
+						cwd,
+						args: [
+							"diff",
+							"HEAD",
+							"--numstat"
+						]
+					}),
+					detail: "git diff HEAD --numstat failed.",
+					exitCode: result.exitCode,
+					stdoutLength: result.stdout.length,
+					stderrLength: result.stderr.length
+				}));
+			})),
+			statusCacheKey ? Cache.get(defaultBranchCache, statusCacheKey).pipe(Effect.orElseSucceed(() => null)) : resolveDefaultBranchName(cwd, "origin").pipe(Effect.orElseSucceed(() => null)),
+			statusCacheKey ? Cache.get(originExistsCache, statusCacheKey).pipe(Effect.orElseSucceed(() => false)) : originRemoteExists(cwd).pipe(Effect.orElseSucceed(() => false))
 		], { concurrency: "unbounded" });
 		const statusStdout = statusResult.stdout;
-		const defaultBranch = defaultRefResult.exitCode === 0 ? defaultRefResult.stdout.trim().replace(/^refs\/remotes\/origin\//, "") : null;
 		let refName = null;
 		let upstreamRef = null;
 		let aheadCount = 0;
@@ -40701,18 +41478,12 @@ const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* () {
 		}
 		const isDefaultBranch = refName !== null && (refName === defaultBranch || defaultBranch === null && (refName === "main" || refName === "master"));
 		if (refName && !isDefaultBranch) aheadOfDefaultCount = fallbackAheadCount !== null ? fallbackAheadCount : yield* computeAheadCountAgainstBase(cwd, refName).pipe(Effect.orElseSucceed(() => 0));
-		const stagedEntries = parseNumstatEntries(stagedNumstatStdout);
-		const unstagedEntries = parseNumstatEntries(unstagedNumstatStdout);
+		const numstatEntries = parseNumstatEntries(numstatStdout);
 		const fileStatMap = /* @__PURE__ */ new Map();
-		for (const entry of [...stagedEntries, ...unstagedEntries]) {
-			const existing = fileStatMap.get(entry.path) ?? {
-				insertions: 0,
-				deletions: 0
-			};
-			existing.insertions += entry.insertions;
-			existing.deletions += entry.deletions;
-			fileStatMap.set(entry.path, existing);
-		}
+		for (const entry of numstatEntries) fileStatMap.set(entry.path, {
+			insertions: entry.insertions,
+			deletions: entry.deletions
+		});
 		let insertions = 0;
 		let deletions = 0;
 		const files = Array.from(fileStatMap.entries()).map(([filePath, stat]) => {
@@ -41525,7 +42296,7 @@ const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* () {
 		}
 		return branchNames;
 	}));
-	const withListRefsInvalidation = (cwd, effect) => effect.pipe(Effect.ensuring(invalidateListRefsSnapshot(cwd).pipe(Effect.ignore)));
+	const withListRefsInvalidation = (cwd, effect) => effect.pipe(Effect.ensuring(Effect.all([invalidateListRefsSnapshot(cwd).pipe(Effect.ignore), invalidateStatusStaticCaches(cwd).pipe(Effect.ignore)])));
 	const initRepoWithListRefsInvalidation = (input) => initRepo(input).pipe(Effect.ensuring(Effect.gen(function* () {
 		const cacheKey = normalizeRepositoryPathsCacheKey(input.cwd);
 		yield* Cache.invalidate(repositoryPathsRefreshCache, cacheKey);
@@ -41576,7 +42347,7 @@ const classifyNonZeroExit = (command, stderr) => {
 	if (command === "gh" && (normalized.includes("could not resolve to a pullrequest") || normalized.includes("repository.pullrequest") || normalized.includes("no pull requests found for branch") || normalized.includes("pull request not found")) || command === "glab" && (normalized.includes("merge request not found") || normalized.includes("not found") || normalized.includes("404")) || command === "az" && normalized.includes("pull request") && (normalized.includes("not found") || normalized.includes("does not exist"))) return "not-found";
 	return "command-failed";
 };
-const make$60 = Effect.gen(function* () {
+const make$61 = Effect.gen(function* () {
 	const processRunner = yield* ProcessRunner;
 	const run = Effect.fn("VcsProcess.run")(function* (input) {
 		const baseError = {
@@ -41635,7 +42406,7 @@ const make$60 = Effect.gen(function* () {
 	});
 	return VcsProcess.of({ run });
 });
-const layer$49 = Layer.effect(VcsProcess, make$60).pipe(Layer.provide(layer$63));
+const layer$49 = Layer.effect(VcsProcess, make$61).pipe(Layer.provide(layer$63));
 //#endregion
 //#region src/vcs/VcsDriver.ts
 var VcsDriver = class extends Context.Service()("@p4code/cli/vcs/VcsDriver") {};
@@ -42086,12 +42857,12 @@ const makeVcsDriver = Effect.gen(function* () {
 	const driver = yield* makeVcsDriverShape();
 	return VcsDriver.of(driver);
 });
-const make$59 = Effect.gen(function* () {
+const make$60 = Effect.gen(function* () {
 	const git = yield* makeGitVcsDriverCore();
 	return GitVcsDriver.of(git);
 });
 Layer.effect(VcsDriver, makeVcsDriver);
-const layer$48 = Layer.effect(GitVcsDriver, make$59);
+const layer$48 = Layer.effect(GitVcsDriver, make$60);
 //#endregion
 //#region src/vcs/VcsProjectConfig.ts
 const ProjectVcsConfigJson = fromLenientJson(Schema$1.Struct({
@@ -42123,7 +42894,7 @@ const logVcsProjectConfigError = (error) => Effect.logWarning(error).pipe(Effect
 	configPath: error.configPath,
 	errorTag: error._tag
 }));
-const make$58 = Effect.gen(function* () {
+const make$59 = Effect.gen(function* () {
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const findConfigPath = Effect.fn("VcsProjectConfig.findConfigPath")(function* (cwd) {
@@ -42164,7 +42935,7 @@ const make$58 = Effect.gen(function* () {
 	});
 	return VcsProjectConfig.of({ resolveKind });
 });
-const layer$47 = Layer.effect(VcsProjectConfig, make$58);
+const layer$47 = Layer.effect(VcsProjectConfig, make$59);
 //#endregion
 //#region src/vcs/VcsDriverRegistry.ts
 const DETECTION_CACHE_CAPACITY = 2048;
@@ -42184,7 +42955,7 @@ function parseDetectionCacheKey(key) {
 		cwd: key.slice(separatorIndex + 1)
 	};
 }
-const make$57 = Effect.gen(function* () {
+const make$58 = Effect.gen(function* () {
 	const projectConfig = yield* VcsProjectConfig;
 	const git = yield* makeVcsDriver;
 	const drivers = { git };
@@ -42241,7 +43012,7 @@ const make$57 = Effect.gen(function* () {
 		resolve
 	});
 });
-const layer$46 = Layer.effect(VcsDriverRegistry, make$57).pipe(Layer.provide(layer$47));
+const layer$46 = Layer.effect(VcsDriverRegistry, make$58).pipe(Layer.provide(layer$47));
 //#endregion
 //#region src/checkpointing/CheckpointStore.ts
 /**
@@ -42261,7 +43032,7 @@ const layer$46 = Layer.effect(VcsDriverRegistry, make$57).pipe(Layer.provide(lay
 */
 /** Service tag for checkpoint persistence and restore operations. */
 var CheckpointStore = class extends Context.Service()("@p4code/cli/checkpointing/CheckpointStore") {};
-const make$56 = Effect.gen(function* () {
+const make$57 = Effect.gen(function* () {
 	const vcsRegistry = yield* VcsDriverRegistry;
 	const resolveCheckpoints = Effect.fn("CheckpointStore.resolveCheckpoints")(function* (operation, cwd) {
 		const handle = yield* vcsRegistry.resolve({ cwd });
@@ -42300,7 +43071,7 @@ const make$56 = Effect.gen(function* () {
 		deleteCheckpointRefs
 	});
 });
-const layer$45 = Layer.effect(CheckpointStore, make$56);
+const layer$45 = Layer.effect(CheckpointStore, make$57);
 //#endregion
 //#region src/checkpointing/CheckpointDiffQuery.ts
 /**
@@ -42322,7 +43093,7 @@ function buildTurnDiffResult(input, diff) {
 		diff
 	};
 }
-const make$55 = Effect.gen(function* () {
+const make$56 = Effect.gen(function* () {
 	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
 	const checkpointStore = yield* CheckpointStore;
 	const threadActivities = yield* ProjectionThreadActivityRepository;
@@ -42493,7 +43264,7 @@ const make$55 = Effect.gen(function* () {
 		getFullThreadDiff
 	});
 });
-const layer$44 = Layer.effect(CheckpointDiffQuery, make$55);
+const layer$44 = Layer.effect(CheckpointDiffQuery, make$56);
 //#endregion
 //#region src/orchestration/ThreadLiveEventCoalescer.ts
 const COALESCE_WINDOW = Duration.millis(50);
@@ -42728,11 +43499,11 @@ const makeTextGenerationFromRegistry = (registry) => TextGeneration.of({
 		detail: "This provider does not report account usage."
 	}))))
 });
-const make$54 = Effect.gen(function* () {
+const make$55 = Effect.gen(function* () {
 	const registry = yield* ProviderInstanceRegistry;
 	return makeTextGenerationFromRegistry(registry);
 });
-const layer$43 = Layer.effect(TextGeneration, make$54);
+const layer$43 = Layer.effect(TextGeneration, make$55);
 //#endregion
 //#region src/textGeneration/TextGenerationPresets.ts
 const conventionalCommitsTextGenerationPolicy = {
@@ -43064,7 +43835,7 @@ const serversEqual = (left, right) => {
 	}
 	return true;
 };
-const make$53 = Effect.gen(function* PortDiscoveryMake() {
+const make$54 = Effect.gen(function* PortDiscoveryMake() {
 	const net = yield* NetService;
 	const processRunner = yield* ProcessRunner;
 	const hostPlatform = yield* HostProcessPlatform;
@@ -43215,7 +43986,7 @@ const make$53 = Effect.gen(function* PortDiscoveryMake() {
 		unregisterTerminal
 	});
 }).pipe(Effect.withSpan("PortDiscovery.make"));
-const layer$42 = Layer.effect(PortDiscovery, make$53);
+const layer$42 = Layer.effect(PortDiscovery, make$54);
 //#endregion
 //#region src/terminal/Manager.ts
 /**
@@ -43893,7 +44664,7 @@ function normalizedRuntimeEnv(env) {
 	if (entries.length === 0) return null;
 	return Object.fromEntries(entries.toSorted(([left], [right]) => left.localeCompare(right)));
 }
-const make$52 = Effect.fn("TerminalManager.make")(function* () {
+const make$53 = Effect.fn("TerminalManager.make")(function* () {
 	const { terminalLogsDir } = yield* ServerConfig$1;
 	const ptyAdapter = yield* PtyAdapter;
 	const portDiscovery = yield* PortDiscovery;
@@ -44855,7 +45626,7 @@ const makeWithOptions$1 = Effect.fn("TerminalManager.makeWithOptions")(function*
 		subscribeMetadata
 	});
 });
-const layer$41 = Layer.effect(TerminalManager, make$52()).pipe(Layer.provide(layer$63));
+const layer$41 = Layer.effect(TerminalManager, make$53()).pipe(Layer.provide(layer$63));
 //#endregion
 //#region src/project/ProjectSetupScriptRunner.ts
 var ProjectSetupScriptOperationError = class extends Schema$1.TaggedErrorClass()("ProjectSetupScriptOperationError", {
@@ -44886,7 +45657,7 @@ var ProjectSetupScriptProjectNotFoundError = class extends Schema$1.TaggedErrorC
 };
 Schema$1.Union([ProjectSetupScriptOperationError, ProjectSetupScriptProjectNotFoundError]);
 var ProjectSetupScriptRunner = class extends Context.Service()("@p4code/cli/project/ProjectSetupScriptRunner") {};
-const make$51 = Effect.gen(function* () {
+const make$52 = Effect.gen(function* () {
 	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
 	const terminalManager = yield* TerminalManager;
 	const runForThread = Effect.fn("ProjectSetupScriptRunner.runForThread")(function* (input) {
@@ -44944,7 +45715,7 @@ const make$51 = Effect.gen(function* () {
 	});
 	return ProjectSetupScriptRunner.of({ runForThread });
 });
-const layer$40 = Layer.effect(ProjectSetupScriptRunner, make$51);
+const layer$40 = Layer.effect(ProjectSetupScriptRunner, make$52);
 //#endregion
 //#region src/provider/Services/ProviderRegistry.ts
 var ProviderRegistry = class extends Context.Service()("@p4code/cli/provider/Services/ProviderRegistry") {};
@@ -45041,19 +45812,23 @@ function normalizeAzureDevOpsPullRequestRecord(raw) {
 		baseRefName: normalizeRefName$1(raw.targetRefName),
 		headRefName: normalizeRefName$1(raw.sourceRefName),
 		state: normalizeAzureDevOpsPullRequestState(raw.status),
+		...Option.isSome(raw.closedDate ?? Option.none()) ? { terminalAt: DateTime.formatIso(Option.getOrThrow(raw.closedDate ?? Option.none())) } : {},
 		updatedAt: (raw.closedDate ?? Option.none()).pipe(Option.orElse(() => raw.creationDate ?? Option.none()))
 	};
 }
 const decodeAzureDevOpsPullRequestList = decodeJsonResult(Schema$1.Array(Schema$1.Unknown));
 const decodeAzureDevOpsPullRequest = decodeJsonResult(AzureDevOpsPullRequestSchema);
 const decodeAzureDevOpsPullRequestEntry = Schema$1.decodeUnknownExit(AzureDevOpsPullRequestSchema);
-function decodeAzureDevOpsPullRequestListJson(raw) {
+function decodeAzureDevOpsPullRequestListJson(raw, strict = false) {
 	const result = decodeAzureDevOpsPullRequestList(raw);
 	if (Result.isSuccess(result)) {
 		const pullRequests = [];
 		for (const entry of result.success) {
 			const decodedEntry = decodeAzureDevOpsPullRequestEntry(entry);
-			if (Exit.isFailure(decodedEntry)) continue;
+			if (Exit.isFailure(decodedEntry)) {
+				if (strict) return Result.fail(decodedEntry.cause);
+				continue;
+			}
 			pullRequests.push(normalizeAzureDevOpsPullRequestRecord(decodedEntry.value));
 		}
 		return Result.succeed(pullRequests);
@@ -45271,7 +46046,7 @@ function decodeAzureDevOpsJson(raw, schema, operation, cwd) {
 		cause
 	})));
 }
-const make$50 = Effect.gen(function* () {
+const make$51 = Effect.gen(function* () {
 	const process = yield* VcsProcess;
 	const execute = (input) => process.run({
 		operation: "AzureDevOpsCli.execute",
@@ -45311,7 +46086,7 @@ const make$50 = Effect.gen(function* () {
 				"--top",
 				String(input.limit ?? 20)
 			]
-		}).pipe(Effect.map((result) => result.stdout.trim()), Effect.flatMap((raw) => raw.length === 0 ? Effect.succeed([]) : Effect.sync(() => decodeAzureDevOpsPullRequestListJson(raw)).pipe(Effect.flatMap((decoded) => {
+		}).pipe(Effect.map((result) => result.stdout.trim()), Effect.flatMap((raw) => raw.length === 0 && !input.strict ? Effect.succeed([]) : Effect.sync(() => decodeAzureDevOpsPullRequestListJson(raw, input.strict)).pipe(Effect.flatMap((decoded) => {
 			if (!Result.isSuccess(decoded)) return Effect.fail(new AzureDevOpsPullRequestListDecodeError({
 				operation: "listPullRequests",
 				command: "az",
@@ -45413,7 +46188,7 @@ const make$50 = Effect.gen(function* () {
 		}).pipe(Effect.asVoid)
 	});
 });
-const layer$39 = Layer.effect(AzureDevOpsCli, make$50);
+const layer$39 = Layer.effect(AzureDevOpsCli, make$51);
 //#endregion
 //#region src/sourceControl/SourceControlProviderDiscovery.ts
 function firstNonEmptyLine(text) {
@@ -45613,10 +46388,11 @@ function toChangeRequest$5(summary) {
 		headRefName: summary.headRefName,
 		state: summary.state,
 		updatedAt: summary.updatedAt,
+		...summary.terminalAt == null ? {} : { terminalAt: summary.terminalAt },
 		isCrossRepository: false
 	};
 }
-const make$49 = Effect.gen(function* () {
+const make$50 = Effect.gen(function* () {
 	const azure = yield* AzureDevOpsCli;
 	return SourceControlProvider.of({
 		kind: "azure-devops",
@@ -45627,6 +46403,7 @@ const make$49 = Effect.gen(function* () {
 				headSelector: input.headSelector,
 				...source !== void 0 ? { source } : {},
 				state: input.state,
+				...input.strict !== void 0 ? { strict: input.strict } : {},
 				...input.limit !== void 0 ? { limit: input.limit } : {}
 			}).pipe(Effect.map((items) => items.map(toChangeRequest$5)), Effect.mapError((error) => new SourceControlProviderError({
 				provider: "azure-devops",
@@ -45708,7 +46485,7 @@ const make$49 = Effect.gen(function* () {
 		})))
 	});
 });
-Layer.effect(SourceControlProvider, make$49);
+Layer.effect(SourceControlProvider, make$50);
 //#endregion
 //#region src/sourceControl/bitbucketPullRequests.ts
 const BitbucketRepositoryRefSchema = Schema$1.Struct({
@@ -46085,7 +46862,7 @@ function responseError(operation, response) {
 		responseBodyLength: collected.text.length
 	}))));
 }
-const make$48 = Effect.gen(function* () {
+const make$49 = Effect.gen(function* () {
 	const config = yield* BitbucketApiEnvConfig;
 	const httpClient = yield* HttpClient.HttpClient;
 	const fileSystem = yield* FileSystem.FileSystem;
@@ -46301,7 +47078,7 @@ const make$48 = Effect.gen(function* () {
 		})))
 	});
 });
-const layer$37 = Layer.effect(BitbucketApi, make$48);
+const layer$37 = Layer.effect(BitbucketApi, make$49);
 //#endregion
 //#region src/sourceControl/BitbucketSourceControlProvider.ts
 function toChangeRequest$4(summary) {
@@ -46319,7 +47096,7 @@ function toChangeRequest$4(summary) {
 		...summary.headRepositoryOwnerLogin !== void 0 ? { headRepositoryOwnerLogin: summary.headRepositoryOwnerLogin } : {}
 	};
 }
-const make$47 = Effect.gen(function* () {
+const make$48 = Effect.gen(function* () {
 	const bitbucket = yield* BitbucketApi;
 	return SourceControlProvider.of({
 		kind: "bitbucket",
@@ -46410,7 +47187,7 @@ const make$47 = Effect.gen(function* () {
 		})))
 	});
 });
-Layer.effect(SourceControlProvider, make$47);
+Layer.effect(SourceControlProvider, make$48);
 const makeDiscovery = Effect.gen(function* () {
 	return {
 		type: "api",
@@ -46430,6 +47207,7 @@ const GitHubPullRequestSchema = Schema$1.Struct({
 	headRefName: TrimmedNonEmptyString,
 	state: Schema$1.optional(Schema$1.NullOr(Schema$1.String)),
 	mergedAt: Schema$1.optional(Schema$1.NullOr(Schema$1.String)),
+	closedAt: Schema$1.optional(Schema$1.NullOr(Schema$1.String)),
 	updatedAt: Schema$1.optional(Schema$1.OptionFromNullOr(Schema$1.DateTimeUtcFromString)),
 	isCrossRepository: Schema$1.optional(Schema$1.Boolean),
 	headRepository: Schema$1.optional(Schema$1.NullOr(Schema$1.Struct({
@@ -46453,6 +47231,7 @@ function normalizeGitHubPullRequestRecord(raw) {
 	const headRepositoryName = trimOptionalString$1(raw.headRepository?.name);
 	const headRepositoryOwnerLogin = trimOptionalString$1(raw.headRepositoryOwner?.login) ?? (explicitNameWithOwner?.includes("/") ? explicitNameWithOwner.split("/")[0] ?? null : null);
 	const headRepositoryNameWithOwner = explicitNameWithOwner ?? (headRepositoryOwnerLogin && headRepositoryName ? `${headRepositoryOwnerLogin}/${headRepositoryName}` : null);
+	const terminalAt = normalizeGitHubPullRequestState(raw) === "merged" ? raw.mergedAt ?? null : normalizeGitHubPullRequestState(raw) === "closed" ? raw.closedAt ?? null : null;
 	return {
 		number: raw.number,
 		title: raw.title,
@@ -46461,6 +47240,7 @@ function normalizeGitHubPullRequestRecord(raw) {
 		headRefName: raw.headRefName,
 		state: normalizeGitHubPullRequestState(raw),
 		updatedAt: raw.updatedAt ?? Option.none(),
+		...terminalAt == null ? {} : { terminalAt },
 		...typeof raw.isCrossRepository === "boolean" ? { isCrossRepository: raw.isCrossRepository } : {},
 		...headRepositoryNameWithOwner ? { headRepositoryNameWithOwner } : {},
 		...headRepositoryOwnerLogin ? { headRepositoryOwnerLogin } : {}
@@ -46469,13 +47249,16 @@ function normalizeGitHubPullRequestRecord(raw) {
 const decodeGitHubPullRequestList = decodeJsonResult(Schema$1.Array(Schema$1.Unknown));
 const decodeGitHubPullRequest = decodeJsonResult(GitHubPullRequestSchema);
 const decodeGitHubPullRequestEntry = Schema$1.decodeUnknownExit(GitHubPullRequestSchema);
-function decodeGitHubPullRequestListJson(raw) {
+function decodeGitHubPullRequestListJson(raw, strict = false) {
 	const result = decodeGitHubPullRequestList(raw);
 	if (Result.isSuccess(result)) {
 		const pullRequests = [];
 		for (const entry of result.success) {
 			const decodedEntry = decodeGitHubPullRequestEntry(entry);
-			if (Exit.isFailure(decodedEntry)) continue;
+			if (Exit.isFailure(decodedEntry)) {
+				if (strict) return Result.fail(decodedEntry.cause);
+				continue;
+			}
 			pullRequests.push(normalizeGitHubPullRequestRecord(decodedEntry.value));
 		}
 		return Result.succeed(pullRequests);
@@ -46652,7 +47435,7 @@ function deriveRepositoryCloneUrlsFromCreateOutput(stdout, repository) {
 		sshUrl: `git@${fallbackHost}:${repository}.git`
 	};
 }
-const make$46 = Effect.gen(function* () {
+const make$47 = Effect.gen(function* () {
 	const process = yield* VcsProcess;
 	const execute = (input) => process.run({
 		operation: "GitHubCli.execute",
@@ -46680,7 +47463,7 @@ const make$46 = Effect.gen(function* () {
 				"--limit",
 				String(input.limit ?? 1),
 				"--json",
-				"number,title,url,baseRefName,headRefName,state,mergedAt,isCrossRepository,headRepository,headRepositoryOwner"
+				"number,title,url,baseRefName,headRefName,state,mergedAt,closedAt,isCrossRepository,headRepository,headRepositoryOwner"
 			]
 		}).pipe(Effect.map((result) => result.stdout.trim()), Effect.flatMap((raw) => raw.length === 0 ? Effect.succeed([]) : Effect.sync(() => decodeGitHubPullRequestListJson(raw)).pipe(Effect.flatMap((decoded) => {
 			if (!Result.isSuccess(decoded)) return Effect.fail(new GitHubPullRequestListDecodeError({
@@ -46697,7 +47480,7 @@ const make$46 = Effect.gen(function* () {
 				"view",
 				input.reference,
 				"--json",
-				"number,title,url,baseRefName,headRefName,state,mergedAt,isCrossRepository,headRepository,headRepositoryOwner"
+				"number,title,url,baseRefName,headRefName,state,mergedAt,closedAt,isCrossRepository,headRepository,headRepositoryOwner"
 			]
 		}).pipe(Effect.map((result) => result.stdout.trim()), Effect.flatMap((raw) => Effect.sync(() => decodeGitHubPullRequestJson(raw)).pipe(Effect.flatMap((decoded) => {
 			if (!Result.isSuccess(decoded)) return Effect.fail(new GitHubPullRequestDecodeError({
@@ -46770,7 +47553,7 @@ const make$46 = Effect.gen(function* () {
 		}).pipe(Effect.asVoid)
 	});
 });
-const layer$35 = Layer.effect(GitHubCli, make$46);
+const layer$35 = Layer.effect(GitHubCli, make$47);
 //#endregion
 //#region src/sourceControl/gitHubAuthStatus.ts
 const GitHubAuthStatusAccountSchema = Schema$1.Struct({
@@ -46824,6 +47607,7 @@ function toChangeRequest$3(summary) {
 		headRefName: summary.headRefName,
 		state: summary.state ?? "open",
 		updatedAt: Option.none(),
+		...summary.terminalAt == null ? {} : { terminalAt: summary.terminalAt },
 		...summary.isCrossRepository !== void 0 ? { isCrossRepository: summary.isCrossRepository } : {},
 		...summary.headRepositoryNameWithOwner !== void 0 ? { headRepositoryNameWithOwner: summary.headRepositoryNameWithOwner } : {},
 		...summary.headRepositoryOwnerLogin !== void 0 ? { headRepositoryOwnerLogin: summary.headRepositoryOwnerLogin } : {}
@@ -46871,7 +47655,7 @@ const discovery$1 = {
 	parseAuth: parseGitHubAuth,
 	installHint: "Install the GitHub command-line tool (`gh`) via https://cli.github.com/ or your package manager (for example `brew install gh`)."
 };
-const make$45 = Effect.gen(function* () {
+const make$46 = Effect.gen(function* () {
 	const github = yield* GitHubCli;
 	const listChangeRequests = (input) => {
 		if (input.state === "open") return github.listOpenPullRequests({
@@ -46900,12 +47684,12 @@ const make$45 = Effect.gen(function* () {
 				"--limit",
 				String(input.limit ?? 20),
 				"--json",
-				"number,title,url,baseRefName,headRefName,state,mergedAt,updatedAt,isCrossRepository,headRepository,headRepositoryOwner"
+				"number,title,url,baseRefName,headRefName,state,mergedAt,closedAt,updatedAt,isCrossRepository,headRepository,headRepositoryOwner"
 			]
 		}).pipe(Effect.flatMap((result) => {
 			const raw = result.stdout.trim();
-			if (raw.length === 0) return Effect.succeed([]);
-			return Effect.sync(() => decodeGitHubPullRequestListJson(raw)).pipe(Effect.flatMap((decoded) => Result.isSuccess(decoded) ? Effect.succeed(decoded.success.map((item) => ({
+			if (raw.length === 0 && !input.strict) return Effect.succeed([]);
+			return Effect.sync(() => decodeGitHubPullRequestListJson(raw, input.strict)).pipe(Effect.flatMap((decoded) => Result.isSuccess(decoded) ? Effect.succeed(decoded.success.map((item) => ({
 				...toChangeRequest$3(item),
 				updatedAt: item.updatedAt
 			}))) : Effect.fail(new GitHubChangeRequestListDecodeError({
@@ -46987,7 +47771,7 @@ const make$45 = Effect.gen(function* () {
 		})))
 	});
 });
-Layer.effect(SourceControlProvider, make$45);
+Layer.effect(SourceControlProvider, make$46);
 //#endregion
 //#region src/sourceControl/gitLabMergeRequests.ts
 const GitLabProjectReferenceSchema = Schema$1.Struct({
@@ -47006,6 +47790,8 @@ const GitLabMergeRequestSchema = Schema$1.Struct({
 	source_branch: TrimmedNonEmptyString,
 	target_branch: TrimmedNonEmptyString,
 	state: Schema$1.optional(Schema$1.NullOr(Schema$1.String)),
+	merged_at: Schema$1.optional(Schema$1.NullOr(Schema$1.String)),
+	closed_at: Schema$1.optional(Schema$1.NullOr(Schema$1.String)),
 	updated_at: Schema$1.optional(Schema$1.OptionFromNullOr(Schema$1.DateTimeUtcFromString)),
 	source_project_id: Schema$1.optional(Schema$1.NullOr(Schema$1.Number)),
 	target_project_id: Schema$1.optional(Schema$1.NullOr(Schema$1.Number)),
@@ -47036,6 +47822,7 @@ function normalizeGitLabMergeRequestRecord(raw) {
 	const targetProjectPath = projectPathWithNamespace(raw.target_project);
 	const isCrossRepository = typeof raw.source_project_id === "number" && typeof raw.target_project_id === "number" ? raw.source_project_id !== raw.target_project_id : sourceProjectPath !== null && targetProjectPath !== null ? sourceProjectPath.toLowerCase() !== targetProjectPath.toLowerCase() : void 0;
 	const headRepositoryOwnerLogin = ownerLoginFromPathWithNamespace(sourceProjectPath);
+	const terminalAt = normalizeGitLabMergeRequestState(raw.state) === "merged" ? raw.merged_at ?? null : normalizeGitLabMergeRequestState(raw.state) === "closed" ? raw.closed_at ?? null : null;
 	return {
 		number: raw.iid,
 		title: raw.title,
@@ -47044,6 +47831,7 @@ function normalizeGitLabMergeRequestRecord(raw) {
 		headRefName: raw.source_branch,
 		state: normalizeGitLabMergeRequestState(raw.state),
 		updatedAt: raw.updated_at ?? Option.none(),
+		...terminalAt == null ? {} : { terminalAt },
 		...typeof isCrossRepository === "boolean" ? { isCrossRepository } : {},
 		...sourceProjectPath ? { headRepositoryNameWithOwner: sourceProjectPath } : {},
 		...headRepositoryOwnerLogin ? { headRepositoryOwnerLogin } : {}
@@ -47052,13 +47840,16 @@ function normalizeGitLabMergeRequestRecord(raw) {
 const decodeGitLabMergeRequestList = decodeJsonResult(Schema$1.Array(Schema$1.Unknown));
 const decodeGitLabMergeRequest = decodeJsonResult(GitLabMergeRequestSchema);
 const decodeGitLabMergeRequestEntry = Schema$1.decodeUnknownExit(GitLabMergeRequestSchema);
-function decodeGitLabMergeRequestListJson(raw) {
+function decodeGitLabMergeRequestListJson(raw, strict = false) {
 	const result = decodeGitLabMergeRequestList(raw);
 	if (Result.isSuccess(result)) {
 		const mergeRequests = [];
 		for (const entry of result.success) {
 			const decodedEntry = decodeGitLabMergeRequestEntry(entry);
-			if (Exit.isFailure(decodedEntry)) continue;
+			if (Exit.isFailure(decodedEntry)) {
+				if (strict) return Result.fail(decodedEntry.cause);
+				continue;
+			}
 			mergeRequests.push(normalizeGitLabMergeRequestRecord(decodedEntry.value));
 		}
 		return Result.succeed(mergeRequests);
@@ -47299,7 +48090,7 @@ function parseRepositoryPath(repository) {
 		projectPath
 	};
 }
-const make$44 = Effect.gen(function* () {
+const make$45 = Effect.gen(function* () {
 	const process = yield* VcsProcess;
 	const run = (input, mapError) => process.run({
 		operation: "GitLabCli.execute",
@@ -47336,7 +48127,7 @@ const make$44 = Effect.gen(function* () {
 				"--output",
 				"json"
 			]
-		}).pipe(Effect.map((result) => result.stdout.trim()), Effect.flatMap((raw) => raw.length === 0 ? Effect.succeed([]) : Effect.sync(() => decodeGitLabMergeRequestListJson(raw)).pipe(Effect.flatMap((decoded) => {
+		}).pipe(Effect.map((result) => result.stdout.trim()), Effect.flatMap((raw) => raw.length === 0 && !input.strict ? Effect.succeed([]) : Effect.sync(() => decodeGitLabMergeRequestListJson(raw, input.strict)).pipe(Effect.flatMap((decoded) => {
 			if (!Result.isSuccess(decoded)) return Effect.fail(new GitLabMergeRequestListDecodeError({
 				operation: "listMergeRequests",
 				command: "glab",
@@ -47450,7 +48241,7 @@ const make$44 = Effect.gen(function* () {
 		}).pipe(Effect.asVoid)
 	});
 });
-const layer$33 = Layer.effect(GitLabCli, make$44);
+const layer$33 = Layer.effect(GitLabCli, make$45);
 //#endregion
 //#region src/sourceControl/gitLabAuthStatus.ts
 const HOST_LINE_PATTERN = /^(?:[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?|\[[a-f0-9:.]+\])(?::\d+)?$/iu;
@@ -47497,6 +48288,7 @@ function toChangeRequest$2(summary) {
 		headRefName: summary.headRefName,
 		state: summary.state ?? "open",
 		updatedAt: summary.updatedAt ?? Option.none(),
+		...summary.terminalAt == null ? {} : { terminalAt: summary.terminalAt },
 		...summary.isCrossRepository !== void 0 ? { isCrossRepository: summary.isCrossRepository } : {},
 		...summary.headRepositoryNameWithOwner !== void 0 ? { headRepositoryNameWithOwner: summary.headRepositoryNameWithOwner } : {},
 		...summary.headRepositoryOwnerLogin !== void 0 ? { headRepositoryOwnerLogin: summary.headRepositoryOwnerLogin } : {}
@@ -47547,7 +48339,7 @@ const discovery = {
 	refineUnknownRemote: refineUnknownGitLabRemote,
 	installHint: "Install the GitLab command-line tool (`glab`) from https://gitlab.com/gitlab-org/cli or your package manager (for example `brew install glab`)."
 };
-const make$43 = Effect.gen(function* () {
+const make$44 = Effect.gen(function* () {
 	const gitlab = yield* GitLabCli;
 	return SourceControlProvider.of({
 		kind: "gitlab",
@@ -47558,6 +48350,7 @@ const make$43 = Effect.gen(function* () {
 				headSelector: input.headSelector,
 				...source ? { source } : {},
 				state: input.state,
+				...input.strict !== void 0 ? { strict: input.strict } : {},
 				...input.limit !== void 0 ? { limit: input.limit } : {}
 			}).pipe(Effect.map((items) => items.map(toChangeRequest$2)), Effect.mapError((error) => new SourceControlProviderError({
 				provider: "gitlab",
@@ -47635,7 +48428,7 @@ const make$43 = Effect.gen(function* () {
 		})))
 	});
 });
-Layer.effect(SourceControlProvider, make$43);
+Layer.effect(SourceControlProvider, make$44);
 //#endregion
 //#region src/sourceControl/SourceControlProviderRegistry.ts
 const PROVIDER_DETECTION_CACHE_CAPACITY = 2048;
@@ -47791,12 +48584,12 @@ const makeWithProviders = Effect.fn("makeSourceControlProviderRegistryWithProvid
 		})), { concurrency: "unbounded" })
 	});
 });
-const make$42 = Effect.gen(function* () {
-	const github = yield* make$45;
-	const gitlab = yield* make$43;
-	const bitbucket = yield* make$47;
+const make$43 = Effect.gen(function* () {
+	const github = yield* make$46;
+	const gitlab = yield* make$44;
+	const bitbucket = yield* make$48;
 	const bitbucketDiscovery = yield* makeDiscovery;
-	const azureDevOps = yield* make$49;
+	const azureDevOps = yield* make$50;
 	return yield* makeWithProviders([
 		{
 			kind: "github",
@@ -47820,7 +48613,7 @@ const make$42 = Effect.gen(function* () {
 		}
 	]);
 });
-const layer$31 = Layer.effect(SourceControlProviderRegistry, make$42);
+const layer$31 = Layer.effect(SourceControlProviderRegistry, make$43);
 //#endregion
 //#region src/sourceControl/PrTemplateDetection.ts
 const TEMPLATE_MAX_BYTES = 8e3;
@@ -47942,6 +48735,7 @@ const detectPrTemplate = Effect.fn("detectPrTemplate")(function* (cwd, treeish,
 });
 //#endregion
 //#region src/git/GitManager.ts
+const COMPLETION_PR_LIST_LIMIT = 100;
 var GitManager = class extends Context.Service()("@p4code/cli/git/GitManager") {};
 const COMMIT_TIMEOUT_MS = 10 * 6e4;
 const MAX_PROGRESS_TEXT_LENGTH = 500;
@@ -48190,7 +48984,7 @@ function toPullRequestHeadRemoteInfo(pr) {
 		...pr.headRepositoryOwnerLogin !== void 0 ? { headRepositoryOwnerLogin: pr.headRepositoryOwnerLogin } : {}
 	};
 }
-const make$41 = Effect.gen(function* () {
+const make$42 = Effect.gen(function* () {
 	const gitCore = yield* GitVcsDriver;
 	const sourceControlProviders = yield* SourceControlProviderRegistry;
 	const textGeneration = yield* TextGeneration;
@@ -48568,6 +49362,57 @@ const make$41 = Effect.gen(function* () {
 		if (latestOpenPr) return latestOpenPr;
 		return parsed[0] ?? null;
 	});
+	const threadCompletionPrState = Effect.fn("GitManager.threadCompletionPrState")(function* (input) {
+		const details = yield* gitCore.statusDetails(input.cwd);
+		if (!details.isRepo) return { state: "none" };
+		if (!details.hasOriginRemote) {
+			const remotes = yield* gitCore.execute({
+				operation: "GitManager.threadCompletionPrState.remotes",
+				cwd: input.cwd,
+				args: ["remote"]
+			});
+			if (remotes.stdoutTruncated) return { state: "unknown" };
+			if (remotes.stdout.trim().length === 0) return { state: "none" };
+		}
+		if (details.branch === null || input.branch !== null && details.branch !== input.branch) return { state: "unknown" };
+		const context = yield* resolveBranchHeadContext(input.cwd, {
+			branch: details.branch,
+			upstreamRef: details.upstreamRef
+		});
+		const provider = yield* sourceControlProvider(input.cwd);
+		if (context.headSelectors.length === 0) return { state: "unknown" };
+		const terminalTimes = [];
+		for (const headSelector of context.headSelectors) {
+			const open = yield* provider.listChangeRequests({
+				cwd: input.cwd,
+				headSelector,
+				state: "open",
+				limit: COMPLETION_PR_LIST_LIMIT,
+				strict: true
+			});
+			if (open.some((pr) => matchesBranchHeadContext(toPullRequestInfo(pr), context))) return { state: "open" };
+			if (open.length > 0) return { state: "unknown" };
+			const history = yield* provider.listChangeRequests({
+				cwd: input.cwd,
+				headSelector,
+				state: "all",
+				limit: COMPLETION_PR_LIST_LIMIT,
+				strict: true
+			});
+			if (history.length >= COMPLETION_PR_LIST_LIMIT) return { state: "unknown" };
+			for (const pr of history) {
+				if (!matchesBranchHeadContext(toPullRequestInfo(pr), context)) return { state: "unknown" };
+				if (pr.state === "open") return { state: "open" };
+				if (pr.terminalAt == null || !Number.isFinite(Date.parse(pr.terminalAt))) return { state: "unknown" };
+				terminalTimes.push(DateTime.formatIso(DateTime.makeUnsafe(pr.terminalAt)));
+			}
+		}
+		const terminalAt = terminalTimes.toSorted().at(-1);
+		return terminalAt === void 0 ? { state: "none" } : {
+			state: "terminal",
+			terminalAt
+		};
+	});
 	const buildCompletionToast = Effect.fn("buildCompletionToast")(function* (cwd, result) {
 		const terms = yield* sourceControlProvider(cwd).pipe(Effect.map((provider) => getChangeRequestTerminologyForKind(provider.kind)), Effect.orElseSucceed(() => getChangeRequestTerminologyForKind("unknown")));
 		const summary = summarizeGitActionResult(result, terms);
@@ -49101,6 +49946,7 @@ const make$41 = Effect.gen(function* () {
 		}))));
 	});
 	return GitManager.of({
+		threadCompletionPrState,
 		localStatus,
 		remoteStatus,
 		status,
@@ -49112,7 +49958,7 @@ const make$41 = Effect.gen(function* () {
 		runStackedAction
 	});
 });
-const layer$30 = Layer.effect(GitManager, make$41);
+const layer$30 = Layer.effect(GitManager, make$42);
 //#endregion
 //#region src/git/GitWorkflowService.ts
 var GitWorkflowService = class extends Context.Service()("@p4code/cli/git/GitWorkflowService") {};
@@ -49149,7 +49995,7 @@ function nonRepositoryListRefs() {
 		totalCount: 0
 	};
 }
-const make$40 = Effect.gen(function* () {
+const make$41 = Effect.gen(function* () {
 	const registry = yield* VcsDriverRegistry;
 	const git = yield* GitVcsDriver;
 	const gitManager = yield* GitManager;
@@ -49235,7 +50081,7 @@ const make$40 = Effect.gen(function* () {
 		renameBranch: (input) => ensureGit("GitWorkflowService.renameBranch", input.cwd).pipe(Effect.andThen(git.renameBranch(input)))
 	});
 });
-const layer$29 = Layer.effect(GitWorkflowService, make$40);
+const layer$29 = Layer.effect(GitWorkflowService, make$41);
 //#endregion
 //#region src/pullRequest/PullRequestProvider.ts
 /**
@@ -49596,7 +50442,7 @@ function isReviewerName(value) {
 	const name = value.trim();
 	return name.length > 0 && !name.startsWith("-");
 }
-const make$39 = Effect.gen(function* () {
+const make$40 = Effect.gen(function* () {
 	const azure = yield* AzureDevOpsCli;
 	const detectArgs = ["--detect", "true"];
 	const executeJson = (input) => azure.execute({
@@ -49796,7 +50642,7 @@ const make$39 = Effect.gen(function* () {
 		}).pipe(Effect.asVoid)
 	});
 });
-const layer$28 = Layer.effect(AzureDevOpsPullRequestCli, make$39);
+const layer$28 = Layer.effect(AzureDevOpsPullRequestCli, make$40);
 //#endregion
 //#region src/pullRequest/AzureDevOpsPullRequestProvider.ts
 const CAPABILITIES$3 = {
@@ -49871,7 +50717,7 @@ function toChangeRequest$1(pullRequest) {
 		labels: []
 	};
 }
-const make$38 = Effect.gen(function* () {
+const make$39 = Effect.gen(function* () {
 	const cli = yield* AzureDevOpsPullRequestCli;
 	const fail = (operation) => (error) => new PullRequestProviderError({
 		provider: "azure-devops",
@@ -50611,7 +51457,7 @@ function mergeStrategy(method) {
 		default: return "merge_commit";
 	}
 }
-const make$37 = Effect.gen(function* () {
+const make$38 = Effect.gen(function* () {
 	const bitbucket = yield* BitbucketApi;
 	/**
 	* The repository's own path, and the workspace above it — which the people who may review are
@@ -50891,7 +51737,7 @@ const make$37 = Effect.gen(function* () {
 		}).pipe(Effect.asVoid))
 	});
 });
-const layer$27 = Layer.effect(BitbucketPullRequestApi, make$37);
+const layer$27 = Layer.effect(BitbucketPullRequestApi, make$38);
 //#endregion
 //#region src/pullRequest/BitbucketPullRequestProvider.ts
 const CAPABILITIES$2 = {
@@ -50971,7 +51817,7 @@ function toChangeRequest(pullRequest) {
 		labels: []
 	};
 }
-const make$36 = Effect.gen(function* () {
+const make$37 = Effect.gen(function* () {
 	const api = yield* BitbucketPullRequestApi;
 	const fail = (operation) => (error) => new PullRequestProviderError({
 		provider: "bitbucket",
@@ -52858,7 +53704,7 @@ function actionArgs$1(action, mergeMethod, updateMethod) {
 		case "reopen": return ["reopen"];
 	}
 }
-const make$35 = Effect.gen(function* () {
+const make$36 = Effect.gen(function* () {
 	const github = yield* GitHubCli;
 	/**
 	* The pull request's own node id, which is what a mutation against the pull request itself is
@@ -53578,7 +54424,7 @@ const make$35 = Effect.gen(function* () {
 		})))
 	});
 });
-const layer$26 = Layer.effect(GitHubPullRequestCli, make$35);
+const layer$26 = Layer.effect(GitHubPullRequestCli, make$36);
 //#endregion
 //#region src/pullRequest/GitHubPullRequestProvider.ts
 const CAPABILITIES$1 = {
@@ -53693,7 +54539,7 @@ function loginAvatarUrl(login, host) {
 }
 /** True where markdown would render nothing: whitespace, or only HTML comments. */
 const rendersEmpty = (body) => body.replace(/<!--[\s\S]*?-->/g, "").trim().length === 0;
-const make$34 = Effect.gen(function* () {
+const make$35 = Effect.gen(function* () {
 	const cli = yield* GitHubPullRequestCli;
 	const fail = (operation) => (error) => new PullRequestProviderError({
 		provider: "github",
@@ -54712,7 +55558,7 @@ function actionArgs(action, mergeMethod) {
 		case "reopen": return ["reopen"];
 	}
 }
-const make$33 = Effect.gen(function* () {
+const make$34 = Effect.gen(function* () {
 	const gitlab = yield* GitLabCli;
 	const api = (input) => gitlab.execute({
 		cwd: input.cwd,
@@ -55283,7 +56129,7 @@ const make$33 = Effect.gen(function* () {
 		}).pipe(Effect.asVoid)
 	});
 });
-const layer$25 = Layer.effect(GitLabPullRequestCli, make$33);
+const layer$25 = Layer.effect(GitLabPullRequestCli, make$34);
 //#endregion
 //#region src/pullRequest/GitLabPullRequestProvider.ts
 const CAPABILITIES = {
@@ -55363,7 +56209,7 @@ function reasonFor(error) {
 	if (error._tag === "GitLabCliAuthenticationError") return "unauthenticated";
 	return "failed";
 }
-const make$32 = Effect.gen(function* () {
+const make$33 = Effect.gen(function* () {
 	const cli = yield* GitLabPullRequestCli;
 	const fail = (operation) => (error) => new PullRequestProviderError({
 		provider: "gitlab",
@@ -55506,13 +56352,13 @@ function fromProviders(providers) {
 * The hosts this build can read change requests from. A host with no entry here still shows up
 * in the provider list as unimplemented, so its projects are explained rather than missing.
 */
-const make$31 = Effect.map(Effect.all([
-	make$34,
-	make$32,
-	make$36,
-	make$38
+const make$32 = Effect.map(Effect.all([
+	make$35,
+	make$33,
+	make$37,
+	make$39
 ]), fromProviders);
-const layer$24 = Layer.effect(PullRequestProviderRegistry, make$31).pipe(Layer.provide(layer$26.pipe(Layer.provide(layer$35))), Layer.provide(layer$25.pipe(Layer.provide(layer$33))), Layer.provide(layer$27.pipe(Layer.provide(layer$37))), Layer.provide(layer$28.pipe(Layer.provide(layer$39))));
+const layer$24 = Layer.effect(PullRequestProviderRegistry, make$32).pipe(Layer.provide(layer$26.pipe(Layer.provide(layer$35))), Layer.provide(layer$25.pipe(Layer.provide(layer$33))), Layer.provide(layer$27.pipe(Layer.provide(layer$37))), Layer.provide(layer$28.pipe(Layer.provide(layer$39))));
 //#endregion
 //#region src/pullRequest/PullRequestService.ts
 /**
@@ -55700,7 +56546,7 @@ function repositoryIdentityOf(project) {
 	if (identity.displayName) return identity.displayName;
 	return identity.owner && identity.name ? `${identity.owner}/${identity.name}` : null;
 }
-const make$30 = Effect.gen(function* () {
+const make$31 = Effect.gen(function* () {
 	const registry = yield* PullRequestProviderRegistry;
 	const projections = yield* ProjectionSnapshotQuery;
 	const sourceControlProviders = yield* SourceControlProviderRegistry;
@@ -56670,7 +57516,7 @@ const make$30 = Effect.gen(function* () {
 		invalidate
 	});
 });
-const layer$23 = Layer.effect(PullRequestService, make$30);
+const layer$23 = Layer.effect(PullRequestService, make$31);
 //#endregion
 //#region src/orchestration/ThreadWorkspaceLifecycle.ts
 var ThreadWorkspaceLifecycleError = class extends Data.TaggedError("ThreadWorkspaceLifecycleError") {};
@@ -56714,7 +57560,7 @@ const mapLifecycleError = Effect.mapError((cause) => cause instanceof ThreadWork
 	detail: "Thread workspace lifecycle operation failed.",
 	cause
 }));
-const make$29 = Effect.gen(function* () {
+const make$30 = Effect.gen(function* () {
 	const snapshots = yield* ProjectionSnapshotQuery;
 	const engine = yield* OrchestrationEngineService;
 	const gitWorkflow = yield* GitWorkflowService;
@@ -56968,7 +57814,7 @@ const make$29 = Effect.gen(function* () {
 		record
 	};
 });
-const layer$22 = Layer.effect(ThreadWorkspaceLifecycleService, make$29);
+const layer$22 = Layer.effect(ThreadWorkspaceLifecycleService, make$30);
 //#endregion
 //#region src/textGeneration/BtwRequestCoordinator.ts
 const MAX_PENDING_BTW_CANCELLATIONS = 256;
@@ -59512,7 +60358,7 @@ function makeUpdateState(input) {
 		output: input.output ?? null
 	};
 }
-const make$28 = Effect.fn("ProviderMaintenanceRunner.make")(function* () {
+const make$29 = Effect.fn("ProviderMaintenanceRunner.make")(function* () {
 	const providerRegistry = yield* ProviderRegistry;
 	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 	const httpClient = yield* HttpClient.HttpClient;
@@ -59627,7 +60473,7 @@ const make$28 = Effect.fn("ProviderMaintenanceRunner.make")(function* () {
 	});
 	return ProviderMaintenanceRunner.of({ updateProvider });
 });
-const layer$21 = Layer.effect(ProviderMaintenanceRunner, make$28());
+const layer$21 = Layer.effect(ProviderMaintenanceRunner, make$29());
 //#endregion
 //#region src/provider/Drivers/ClaudeHome.ts
 const resolveClaudeHomePath = Effect.fn("resolveClaudeHomePath")(function* (config) {
@@ -60737,7 +61583,7 @@ Layer.succeed(UsageService, UsageService.of({ readSummary: (input) => Effect.suc
 	},
 	scanDurationMs: 0
 }) }));
-const make$27 = Effect.gen(function* () {
+const make$28 = Effect.gen(function* () {
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const config = yield* ServerConfig$1;
@@ -60975,7 +61821,7 @@ const make$27 = Effect.gen(function* () {
 		};
 	}) };
 });
-const layer$20 = Layer.effect(UsageService, make$27);
+const layer$20 = Layer.effect(UsageService, make$28);
 //#endregion
 //#region src/feed/FeedStore.ts
 const storageFailure = (message) => new FeedError({
@@ -61339,7 +62185,7 @@ const jsonRequest = Effect.fn("FeedService.jsonRequest")(function* (url, token,
 		catch: () => fail("hub_unavailable", "Hub returned invalid JSON.")
 	});
 });
-const make$26 = Effect.gen(function* () {
+const make$27 = Effect.gen(function* () {
 	const hubLink = yield* HubLink;
 	const providers = yield* ProviderInstanceRegistry;
 	const config = yield* ServerConfig$1;
@@ -61577,7 +62423,7 @@ var FeedService = class extends Context.Reference("@p4code/cli/feed/FeedService"
 	markRead: unavailable,
 	cleanup: unavailable
 }) }) {};
-const layer$19 = Layer.effect(FeedService, make$26);
+const layer$19 = Layer.effect(FeedService, make$27);
 const SKILL_MANIFEST_FILENAME = "SKILL.md";
 /**
 * Split a catalogue id (`owner/repo/skill-name`) into its parts.
@@ -61723,7 +62569,7 @@ const emptyFetch = (id, unavailable) => ({
 	skipped: [],
 	unavailable
 });
-const make$25 = Effect.gen(function* () {
+const make$26 = Effect.gen(function* () {
 	const http = yield* HttpClient.HttpClient;
 	const request = Effect.fn("SkillRegistry.request")(function* (url) {
 		return yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.setHeader("accept", "application/json"), HttpClientRequest.setHeader("user-agent", "p4code"))).pipe(Effect.timeout(REQUEST_TIMEOUT_MS));
@@ -61794,7 +62640,7 @@ const make$25 = Effect.gen(function* () {
 		fetch
 	};
 });
-const layer$18 = Layer.effect(SkillRegistry, make$25);
+const layer$18 = Layer.effect(SkillRegistry, make$26);
 //#endregion
 //#region src/mcp/McpInvocationContext.ts
 var McpInvocationContext = class extends Context.Service()("@p4code/cli/mcp/McpInvocationContext") {};
@@ -61897,9 +62743,9 @@ const requireThreadControlTarget = Effect.fn("mcp.requireThreadControlTarget")(f
 * The guard on starting a thread, which is a different question from acting on
 * one: it is not "which thread" but "may this session make more of them".
 */
-const requireThreadSpawn = Effect.fn("mcp.requireThreadSpawn")(function* () {
+const requireThreadSpawn = Effect.fn("mcp.requireThreadSpawn")(function* (fusion = false) {
 	const invocation = yield* requireThreadCapability();
-	if (invocation.mayCreateThreads !== true) return yield* new ThreadSpawnNotPermittedError({
+	if (invocation.mayCreateThreads !== true && !(fusion && invocation.mayCreateFusionPairs === true)) return yield* new ThreadSpawnNotPermittedError({
 		threadId: invocation.threadId,
 		detail: "this thread was itself started by an agent, and spawning goes one level deep so a runaway loop has a bound"
 	});
@@ -62022,7 +62868,7 @@ const classifyResponseError = (context, error) => {
 		});
 	}
 };
-const make$24 = Effect.gen(function* PreviewAutomationBrokerMake() {
+const make$25 = Effect.gen(function* PreviewAutomationBrokerMake() {
 	const crypto = yield* Crypto.Crypto;
 	const state = yield* SynchronizedRef.make({
 		clients: /* @__PURE__ */ new Map(),
@@ -62256,7 +63102,7 @@ const make$24 = Effect.gen(function* PreviewAutomationBrokerMake() {
 		invoke
 	});
 }).pipe(Effect.withSpan("PreviewAutomationBroker.make"));
-const layer$17 = Layer.effect(PreviewAutomationBroker, make$24);
+const layer$17 = Layer.effect(PreviewAutomationBroker, make$25);
 //#endregion
 //#region src/preview/Manager.ts
 /**
@@ -62320,7 +63166,7 @@ const buildIdleSnapshot = (input) => ({
 	viewport: FILL_PREVIEW_VIEWPORT,
 	updatedAt: input.updatedAt
 });
-const make$23 = Effect.gen(function* PreviewManagerMake() {
+const make$24 = Effect.gen(function* PreviewManagerMake() {
 	const serverEpoch = NodeCrypto.randomUUID();
 	const stateRef = yield* SynchronizedRef.make(initialState);
 	const eventsPubSub = yield* PubSub.unbounded();
@@ -62551,12 +63397,15 @@ const make$23 = Effect.gen(function* PreviewManagerMake() {
 		subscribeEvents: PubSub.subscribe(eventsPubSub)
 	});
 }).pipe(Effect.withSpan("PreviewManager.make"));
-const layer$16 = Layer.effect(PreviewManager, make$23);
+const layer$16 = Layer.effect(PreviewManager, make$24);
 //#endregion
 //#region src/workspace/WorkspaceSearchIndex.ts
 const WORKSPACE_INDEX_MAX_ENTRIES = 25e3;
 const WORKSPACE_INDEX_PAGE_SIZE = 25002;
 const WORKSPACE_INDEX_SCAN_TIMEOUT = "15 seconds";
+const CONTENT_SEARCH_TIME_BUDGET_MS = 250;
+const CONTENT_SEARCH_MAX_MATCHES_PER_FILE = 100;
+const CONTENT_INDEX_READY_TIMEOUT_MS = 15e3;
 const WORKSPACE_INDEX_IDLE_TTL = "15 minutes";
 const WORKSPACE_INDEX_SCAN_POLL_INTERVAL = "50 millis";
 var WorkspaceSearchIndexCreateFailed = class extends Schema$1.TaggedErrorClass()("WorkspaceSearchIndexCreateFailed", {
@@ -62650,12 +63499,12 @@ function withDirectoryAncestors(entries) {
 	}
 	return [...entryByPath.values()];
 }
-const createFinder = Effect.fn("WorkspaceSearchIndex.createFinder")(function* (cwd) {
+const createFinder = Effect.fn("WorkspaceSearchIndex.createFinder")(function* (cwd, contentSearch) {
 	const result = yield* Effect.try({
 		try: () => FileFinder.create({
 			basePath: cwd,
 			disableMmapCache: true,
-			disableContentIndexing: true,
+			disableContentIndexing: !contentSearch,
 			aiMode: false,
 			enableFsRootScanning: true,
 			enableHomeDirScanning: true
@@ -62685,8 +63534,8 @@ const waitForScan = (cwd, finder, onFailure) => Effect.try({
 		timeout: WORKSPACE_INDEX_SCAN_TIMEOUT
 	})
 }), Effect.withSpan("WorkspaceSearchIndex.waitForScan"));
-const make$22 = Effect.fn("WorkspaceSearchIndex.make")(function* (cwd) {
-	const finder = yield* Effect.acquireRelease(createFinder(cwd), (finder) => Effect.try({
+const make$23 = Effect.fn("WorkspaceSearchIndex.make")(function* (cwd, contentSearch = false) {
+	const finder = yield* Effect.acquireRelease(createFinder(cwd, contentSearch), (finder) => Effect.try({
 		try: () => finder.destroy(),
 		catch: (cause) => new WorkspaceSearchIndexDestroyFailed({
 			cwd,
@@ -62698,6 +63547,24 @@ const make$22 = Effect.fn("WorkspaceSearchIndex.make")(function* (cwd) {
 		reason: "FileFinder.isScanning threw while creating the index.",
 		cause
 	}));
+	if (contentSearch) {
+		const ready = yield* Effect.tryPromise({
+			try: () => finder.waitForIndexReady(CONTENT_INDEX_READY_TIMEOUT_MS),
+			catch: (cause) => new WorkspaceSearchIndexCreateFailed({
+				cwd,
+				reason: "Content index initialization failed.",
+				cause
+			})
+		});
+		if (!ready.ok) return yield* new WorkspaceSearchIndexCreateFailed({
+			cwd,
+			reason: ready.error
+		});
+		if (!ready.value) return yield* new WorkspaceSearchIndexScanTimedOut({
+			cwd,
+			timeout: WORKSPACE_INDEX_SCAN_TIMEOUT
+		});
+	}
 	const runMixedSearch = Effect.fn("WorkspaceSearchIndex.runMixedSearch")(function* (query, pageSize) {
 		const result = yield* Effect.try({
 			try: () => finder.mixedSearch(query, { pageSize }),
@@ -62748,10 +63615,58 @@ const make$22 = Effect.fn("WorkspaceSearchIndex.make")(function* (cwd) {
 	const search = Effect.fn("WorkspaceSearchIndex.search")(function* (query, limit) {
 		return mapMixedSearchResult(yield* runMixedSearch(query, Math.max(1, limit + 1)), limit);
 	});
+	const searchContents = Effect.fn("WorkspaceSearchIndex.searchContents")(function* (input) {
+		const deadline = performance.now() + CONTENT_SEARCH_TIME_BUDGET_MS;
+		const matches = [];
+		let cursor = null;
+		do {
+			const result = yield* Effect.try({
+				try: () => finder.grep(input.query, {
+					mode: "plain",
+					smartCase: true,
+					maxMatchesPerFile: Math.min(CONTENT_SEARCH_MAX_MATCHES_PER_FILE, input.limit),
+					pageSize: input.limit - matches.length,
+					timeBudgetMs: Math.max(1, Math.ceil(deadline - performance.now())),
+					cursor
+				}),
+				catch: (cause) => new WorkspaceSearchIndexSearchFailed({
+					cwd,
+					queryLength: input.query.length,
+					pageSize: input.limit,
+					reason: "Content search failed.",
+					cause
+				})
+			});
+			if (!result.ok) return yield* new WorkspaceSearchIndexSearchFailed({
+				cwd,
+				queryLength: input.query.length,
+				pageSize: input.limit,
+				reason: result.error
+			});
+			for (const match of result.value.items) {
+				const bytes = Buffer.from(match.lineContent);
+				matches.push({
+					path: toPosixPath(match.relativePath),
+					lineNumber: match.lineNumber,
+					lineContent: match.lineContent,
+					matchRanges: match.matchRanges.map(([start, end]) => ({
+						start: bytes.subarray(0, start).toString().length,
+						end: bytes.subarray(0, end).toString().length
+					}))
+				});
+			}
+			cursor = result.value.nextCursor;
+		} while (matches.length < input.limit && cursor !== null && performance.now() < deadline);
+		return {
+			matches: matches.slice(0, input.limit),
+			truncated: matches.length > input.limit || cursor !== null
+		};
+	});
 	return WorkspaceSearchIndex.of({
 		list,
 		refresh,
-		search
+		search,
+		searchContents
 	});
 });
 /**
@@ -62759,11 +63674,16 @@ const make$22 = Effect.fn("WorkspaceSearchIndex.make")(function* (cwd) {
 * workspace root. WorkspaceSearchIndexMap owns memoization and idle cleanup;
 * using a default cwd here would mix resources from different workspaces.
 */
-const layer$15 = (cwd) => Layer.effect(WorkspaceSearchIndex, make$22(cwd));
+const layer$15 = (cwd) => Layer.effect(WorkspaceSearchIndex, make$23(cwd));
 var WorkspaceSearchIndexMap = class extends LayerMap.Service()("@p4code/cli/workspace/WorkspaceSearchIndexMap", {
 	lookup: layer$15,
 	idleTimeToLive: WORKSPACE_INDEX_IDLE_TTL
 }) {};
+/** Content indexing is allocated only when workspace content search is used. */
+var WorkspaceContentSearchIndexMap = class extends LayerMap.Service()("@p4code/cli/workspace/WorkspaceContentSearchIndexMap", {
+	lookup: (cwd) => Layer.effect(WorkspaceSearchIndex, make$23(cwd, true)),
+	idleTimeToLive: WORKSPACE_INDEX_IDLE_TTL
+}) {};
 //#endregion
 //#region src/workspace/WorkspaceEntries.ts
 var WorkspaceEntriesWindowsPathUnsupportedError = class extends Schema$1.TaggedErrorClass()("WorkspaceEntriesWindowsPathUnsupportedError", {
@@ -62823,9 +63743,10 @@ const resolveBrowseTarget = Effect.fn("WorkspaceEntries.resolveBrowseTarget")(fu
 	if (!input.cwd) return yield* new WorkspaceEntriesCurrentProjectRequiredError({ partialPath: input.partialPath });
 	return path.resolve(expandHomePath$1(input.cwd, path), input.partialPath);
 });
-const make$21 = Effect.gen(function* () {
+const make$22 = Effect.gen(function* () {
 	const path = yield* Path.Path;
 	const workspacePaths = yield* WorkspacePaths;
+	const contentSearchIndexes = yield* WorkspaceContentSearchIndexMap;
 	const workspaceSearchIndexes = yield* WorkspaceSearchIndexMap;
 	const normalizeWorkspaceRoot = Effect.fn("WorkspaceEntries.normalizeWorkspaceRoot")(function* (cwd) {
 		return yield* workspacePaths.normalizeWorkspaceRoot(cwd);
@@ -62890,14 +63811,21 @@ const make$21 = Effect.gen(function* () {
 			return yield* (yield* WorkspaceSearchIndex).list();
 		}).pipe(Effect.provide(workspaceSearchIndexes.get(normalizedCwd)));
 	});
+	const searchContents = Effect.fn("WorkspaceEntries.searchContents")(function* (input) {
+		const cwd = yield* normalizeWorkspaceRoot(input.cwd);
+		return yield* Effect.gen(function* () {
+			return yield* (yield* WorkspaceSearchIndex).searchContents(input);
+		}).pipe(Effect.provide(contentSearchIndexes.get(cwd)));
+	});
 	return WorkspaceEntries.of({
 		browse,
 		list,
 		refresh,
-		search
+		search,
+		searchContents
 	});
 });
-const layer$14 = Layer.effect(WorkspaceEntries, make$21).pipe(Layer.provide(WorkspaceSearchIndexMap.layer));
+const layer$14 = Layer.effect(WorkspaceEntries, make$22).pipe(Layer.provide(WorkspaceSearchIndexMap.layer), Layer.provide(WorkspaceContentSearchIndexMap.layer));
 //#endregion
 //#region src/workspace/WorkspaceFileSystem.ts
 /**
@@ -62956,7 +63884,7 @@ Schema$1.Union([
 ]);
 /** Service tag for workspace file operations. */
 var WorkspaceFileSystem = class extends Context.Service()("@p4code/cli/workspace/WorkspaceFileSystem") {};
-const make$20 = Effect.gen(function* () {
+const make$21 = Effect.gen(function* () {
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const workspacePaths = yield* WorkspacePaths;
@@ -63100,7 +64028,7 @@ const make$20 = Effect.gen(function* () {
 		writeFile
 	});
 });
-const layer$13 = Layer.effect(WorkspaceFileSystem, make$20);
+const layer$13 = Layer.effect(WorkspaceFileSystem, make$21);
 //#endregion
 //#region src/vcs/VcsStatusBroadcaster.ts
 const DEFAULT_VCS_STATUS_REFRESH_INTERVAL = Duration.seconds(30);
@@ -63172,7 +64100,7 @@ function fingerprintStatusPart(status) {
 	return JSON.stringify(status);
 }
 const normalizeCwd = (cwd) => Effect.service(FileSystem.FileSystem).pipe(Effect.flatMap((fs) => fs.realPath(cwd)), Effect.orElseSucceed(() => cwd));
-const make$19 = Effect.gen(function* () {
+const make$20 = Effect.gen(function* () {
 	const workflow = yield* GitWorkflowService;
 	const fs = yield* FileSystem.FileSystem;
 	const changesPubSub = yield* Effect.acquireRelease(PubSub.unbounded(), (pubsub) => PubSub.shutdown(pubsub));
@@ -63396,7 +64324,7 @@ const make$19 = Effect.gen(function* () {
 		streamStatus
 	});
 });
-const layer$12 = Layer.effect(VcsStatusBroadcaster, make$19);
+const layer$12 = Layer.effect(VcsStatusBroadcaster, make$20);
 //#endregion
 //#region src/vcs/VcsProvisioningService.ts
 var VcsProvisioningService = class extends Context.Service()("@p4code/cli/vcs/VcsProvisioningService") {};
@@ -63409,7 +64337,7 @@ function resolveRequestedKind(kind) {
 	}));
 	return Effect.succeed(kind);
 }
-const make$18 = Effect.gen(function* () {
+const make$19 = Effect.gen(function* () {
 	const registry = yield* VcsDriverRegistry;
 	const initRepository = Effect.fn("VcsProvisioningService.initRepository")(function* (input) {
 		const kind = yield* resolveRequestedKind(input.kind);
@@ -63417,11 +64345,11 @@ const make$18 = Effect.gen(function* () {
 	});
 	return VcsProvisioningService.of({ initRepository });
 });
-const layer$11 = Layer.effect(VcsProvisioningService, make$18);
+const layer$11 = Layer.effect(VcsProvisioningService, make$19);
 //#endregion
 //#region src/review/ReviewService.ts
 var ReviewService = class extends Context.Service()("@p4code/cli/review/ReviewService") {};
-const make$17 = Effect.gen(function* () {
+const make$18 = Effect.gen(function* () {
 	const config = yield* ServerConfig$1;
 	const fileSystem = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -63477,7 +64405,7 @@ const make$17 = Effect.gen(function* () {
 	});
 	return ReviewService.of({ getDiffPreview });
 });
-const layer$10 = Layer.effect(ReviewService, make$17);
+const layer$10 = Layer.effect(ReviewService, make$18);
 //#endregion
 //#region src/diagnostics/ProcessDiagnostics.ts
 const PROCESS_QUERY_TIMEOUT_MS = 1e3;
@@ -63772,7 +64700,7 @@ function assertDescendantPid(pid) {
 		}));
 	}));
 }
-const make$16 = Effect.gen(function* () {
+const make$17 = Effect.gen(function* () {
 	const spawner = yield* ChildProcessSpawner$1.ChildProcessSpawner;
 	const read = Effect.gen(function* () {
 		const readAt = yield* DateTime.now;
@@ -63816,7 +64744,7 @@ const make$16 = Effect.gen(function* () {
 		signal
 	});
 });
-const layer$9 = Layer.effect(ProcessDiagnostics, make$16);
+const layer$9 = Layer.effect(ProcessDiagnostics, make$17);
 //#endregion
 //#region src/diagnostics/ProcessResourceMonitor.ts
 const SAMPLE_INTERVAL_MS = 5e3;
@@ -63967,7 +64895,7 @@ function aggregateProcessResourceHistory(input) {
 		}) : Option.none()
 	};
 }
-const make$15 = Effect.gen(function* () {
+const make$16 = Effect.gen(function* () {
 	const spawner = yield* ChildProcessSpawner$1.ChildProcessSpawner;
 	const state = yield* Ref.make({
 		samples: [],
@@ -64016,7 +64944,7 @@ const make$15 = Effect.gen(function* () {
 	});
 	return ProcessResourceMonitor.of({ readHistory });
 });
-const layer$8 = Layer.effect(ProcessResourceMonitor, make$15);
+const layer$8 = Layer.effect(ProcessResourceMonitor, make$16);
 //#endregion
 //#region src/diagnostics/TraceDiagnostics.ts
 var TraceFileReadError = class extends Schema$1.TaggedErrorClass()("TraceFileReadError", {
@@ -64264,7 +65192,7 @@ function readTraceFile(fileSystem, path) {
 		cause
 	})) }));
 }
-const make$14 = Effect.gen(function* () {
+const make$15 = Effect.gen(function* () {
 	const fileSystem = yield* FileSystem.FileSystem;
 	const read = Effect.fn("TraceDiagnostics.read")(function* (options) {
 		const readAt = options.readAt ?? (yield* DateTime.now);
@@ -64308,7 +65236,7 @@ const make$14 = Effect.gen(function* () {
 	});
 	return TraceDiagnostics.of({ read });
 });
-const layer$7 = Layer.effect(TraceDiagnostics, make$14);
+const layer$7 = Layer.effect(TraceDiagnostics, make$15);
 function readTraceDiagnostics(options) {
 	return Effect.gen(function* () {
 		return yield* (yield* TraceDiagnostics).read(options);
@@ -64332,7 +65260,7 @@ const VCS_PROBES = [{
 	installHint: "Install Jujutsu with `brew install jj` or from https://github.com/jj-vcs/jj."
 }];
 var SourceControlDiscovery = class extends Context.Service()("@p4code/cli/sourceControl/SourceControlDiscovery") {};
-const make$13 = Effect.gen(function* () {
+const make$14 = Effect.gen(function* () {
 	const config = yield* ServerConfig$1;
 	const process = yield* VcsProcess;
 	const sourceControlProviders = yield* SourceControlProviderRegistry;
@@ -64381,7 +65309,7 @@ const make$13 = Effect.gen(function* () {
 		sourceControlProviders: sourceControlProviders.discover
 	}) });
 });
-const layer$6 = Layer.effect(SourceControlDiscovery, make$13);
+const layer$6 = Layer.effect(SourceControlDiscovery, make$14);
 //#endregion
 //#region src/sourceControl/SourceControlRepositoryService.ts
 const isSourceControlRepositoryError = Schema$1.is(SourceControlRepositoryError);
@@ -64414,7 +65342,7 @@ function expandHomePath(input, path) {
 	if (input.startsWith("~/") || input.startsWith("~\\")) return path.join(NodeOS.homedir(), input.slice(2));
 	return input;
 }
-const make$12 = Effect.gen(function* () {
+const make$13 = Effect.gen(function* () {
 	const config = yield* ServerConfig$1;
 	const fileSystem = yield* FileSystem.FileSystem;
 	const git = yield* GitVcsDriver;
@@ -64553,7 +65481,7 @@ const make$12 = Effect.gen(function* () {
 		publishRepository: (input) => publishRepository(input).pipe(mapRepositoryError("publishRepository", input.provider))
 	});
 });
-const layer$5 = Layer.effect(SourceControlRepositoryService, make$12);
+const layer$5 = Layer.effect(SourceControlRepositoryService, make$13);
 //#endregion
 //#region src/ws.ts
 /** Matches `p4c hub token add`, so a token minted here and one minted there are the same thing. */
@@ -64659,6 +65587,7 @@ function isThreadDetailEvent(event) {
 }
 const PROVIDER_STATUS_DEBOUNCE_MS = 200;
 const SHELL_RESUME_MAX_GAP = 1e3;
+const THREAD_RESUME_MAX_GAP = 1e3;
 const RPC_REQUIRED_SCOPE = /* @__PURE__ */ new Map([
 	[ORCHESTRATION_WS_METHODS.dispatchCommand, AuthOrchestrationOperateScope],
 	[ORCHESTRATION_WS_METHODS.getTurnDiff, AuthOrchestrationReadScope],
@@ -64745,6 +65674,7 @@ const RPC_REQUIRED_SCOPE = /* @__PURE__ */ new Map([
 	[WS_METHODS.projectsListEntries, AuthOrchestrationReadScope],
 	[WS_METHODS.projectsReadFile, AuthOrchestrationReadScope],
 	[WS_METHODS.projectsSearchEntries, AuthOrchestrationReadScope],
+	[WS_METHODS.projectsSearchContents, AuthOrchestrationReadScope],
 	[WS_METHODS.projectsWriteFile, AuthOrchestrationOperateScope],
 	[WS_METHODS.shellOpenInEditor, AuthOrchestrationOperateScope],
 	[WS_METHODS.filesystemBrowse, AuthOrchestrationReadScope],
@@ -65361,15 +66291,19 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 			const bufferedLiveStream = liveBuffer.stream;
 			if (input.afterSequence !== void 0) {
 				const afterSequence = input.afterSequence;
-				const catchUpStream = orchestrationEngine.readEvents(afterSequence, Number.MAX_SAFE_INTEGER).pipe(Stream.filter(isThisThreadDetailEvent), Stream.map((event) => ({
-					kind: "event",
-					event: projectActivityEvent(event)
-				})), Stream.mapError((cause) => new OrchestrationGetSnapshotError({
-					message: `Failed to replay thread ${input.threadId} events`,
-					cause
-				})));
-				const afterCatchUp = input.requestCompletionMarker === true ? Stream.concat(Stream.fromEffect(liveBuffer.offerAndWait({ kind: "synchronized" }).pipe(Effect.andThen(liveBuffer.takeAll))).pipe(Stream.flatMap((items) => Stream.fromIterable(items))), bufferedLiveStream) : bufferedLiveStream;
-				return Stream.concat(catchUpStream, afterCatchUp);
+				const headSequence = yield* orchestrationEngine.latestSequence;
+				const replayGap = headSequence - afterSequence;
+				if (replayGap >= 0 && replayGap <= THREAD_RESUME_MAX_GAP) {
+					const catchUpStream = (replayGap === 0 ? Stream.empty : orchestrationEngine.readEvents(afterSequence, replayGap)).pipe(Stream.takeWhile((event) => event.sequence <= headSequence), Stream.filter(isThisThreadDetailEvent), Stream.map((event) => ({
+						kind: "event",
+						event: projectActivityEvent(event)
+					})), Stream.mapError((cause) => new OrchestrationGetSnapshotError({
+						message: `Failed to replay thread ${input.threadId} events`,
+						cause
+					})));
+					const afterCatchUp = input.requestCompletionMarker === true ? Stream.concat(Stream.fromEffect(liveBuffer.offerAndWait({ kind: "synchronized" }).pipe(Effect.andThen(liveBuffer.takeAll))).pipe(Stream.flatMap((items) => Stream.fromIterable(items))), bufferedLiveStream) : bufferedLiveStream;
+					return Stream.concat(catchUpStream, afterCatchUp);
+				}
 			}
 			const snapshot = yield* projectionSnapshotQuery.getThreadDetailSnapshot(input.threadId, input.turnLimit === void 0 ? void 0 : { turnLimit: input.turnLimit }).pipe(Effect.mapError((cause) => new OrchestrationGetSnapshotError({
 				message: `Failed to load thread ${input.threadId}`,
@@ -65637,6 +66571,13 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 			...projectEntriesFailureContext(cause),
 			cause
 		}))), { "rpc.aggregate": "workspace" }),
+		[WS_METHODS.projectsSearchContents]: (input) => observeRpcEffect$1(WS_METHODS.projectsSearchContents, workspaceEntries.searchContents(input).pipe(Effect.mapError((cause) => new ProjectSearchEntriesError({
+			cwd: input.cwd,
+			queryLength: input.query.length,
+			limit: input.limit,
+			...projectEntriesFailureContext(cause),
+			cause
+		}))), { "rpc.aggregate": "workspace" }),
 		[WS_METHODS.projectsListEntries]: (input) => observeRpcEffect$1(WS_METHODS.projectsListEntries, workspaceEntries.list(input).pipe(Effect.mapError((cause) => new ProjectListEntriesError({
 			...input,
 			...projectEntriesFailureContext(cause),
@@ -65857,7 +66798,7 @@ function toPersistenceSqlOrDecodeError(sqlOperation, decodeOperation, correlatio
 		cause
 	});
 }
-const make$11 = Effect.gen(function* () {
+const make$12 = Effect.gen(function* () {
 	const sql = yield* SqlClient.SqlClient;
 	const upsertRuntimeRow = SqlSchema.void({
 		Request: ProviderSessionRuntimeDbRowSchema,
@@ -65960,7 +66901,7 @@ const make$11 = Effect.gen(function* () {
 		deleteByThreadId
 	};
 });
-const layer$4 = Layer.effect(ProviderSessionRuntimeRepository, make$11);
+const layer$4 = Layer.effect(ProviderSessionRuntimeRepository, make$12);
 //#endregion
 //#region src/provider/Errors.ts
 /**
@@ -66612,7 +67553,7 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 	const httpServer = yield* HttpServer.HttpServer;
 	const state = yield* SynchronizedRef.make({
 		records: /* @__PURE__ */ new Map(),
-		spawnedThreadIds: /* @__PURE__ */ new Set()
+		spawnedThreads: /* @__PURE__ */ new Map()
 	});
 	const currentTimeMillis = options.now ? Effect.sync(options.now) : Clock.currentTimeMillis;
 	const livenessWindowMs = options.livenessWindowMs ?? DEFAULT_LIVENESS_WINDOW_MS;
@@ -66637,7 +67578,7 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 		if (watchThreadIds.size > 0) capabilities.add("watch");
 		if (adviseThreadIds.size > 0) capabilities.add("advise");
 		const threadId = ThreadId.make(request.threadId);
-		const scopeWith = (mayCreateThreads) => ({
+		const scopeWith = (mayCreateThreads, mayCreateFusionPairs) => ({
 			environmentId,
 			threadId,
 			providerSessionId,
@@ -66646,19 +67587,20 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 			...watchThreadIds.size > 0 ? { watchThreadIds } : {},
 			...adviseThreadIds.size > 0 ? { adviseThreadIds } : {},
 			mayCreateThreads,
+			mayCreateFusionPairs,
 			issuedAt
 		});
-		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
+		yield* SynchronizedRef.update(state, ({ records, spawnedThreads }) => {
 			const next = new Map(pruneDead(records, issuedAt));
 			next.set(tokenHash, {
 				tokenHash,
-				scope: scopeWith(!spawnedThreadIds.has(threadId)),
+				scope: scopeWith(!spawnedThreads.has(threadId), spawnedThreads.get(threadId) === true),
 				controlThreadIds: /* @__PURE__ */ new Set(),
 				lastAliveAt: issuedAt
 			});
 			return {
 				records: next,
-				spawnedThreadIds
+				spawnedThreads
 			};
 		});
 		return { config: {
@@ -66674,12 +67616,12 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 		if (rawToken.length === 0) return void 0;
 		const tokenHash = yield* hashToken(rawToken);
 		const timestamp = yield* currentTimeMillis;
-		return yield* SynchronizedRef.modify(state, ({ records, spawnedThreadIds }) => {
+		return yield* SynchronizedRef.modify(state, ({ records, spawnedThreads }) => {
 			const current = pruneDead(records, timestamp);
 			const record = current.get(tokenHash);
 			if (!record) return [void 0, {
 				records: current,
-				spawnedThreadIds
+				spawnedThreads
 			}];
 			const next = new Map(current);
 			next.set(tokenHash, {
@@ -66693,13 +67635,13 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 				watchThreadIds: /* @__PURE__ */ new Set([...record.scope.watchThreadIds ?? [], ...record.controlThreadIds])
 			}, {
 				records: next,
-				spawnedThreadIds
+				spawnedThreads
 			}];
 		});
 	});
 	const touch = Effect.fn("McpSessionRegistry.touch")(function* (threadId) {
 		const timestamp = yield* currentTimeMillis;
-		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
+		yield* SynchronizedRef.update(state, ({ records, spawnedThreads }) => {
 			const current = pruneDead(records, timestamp);
 			const next = new Map(current);
 			for (const [tokenHash, record] of current) if (record.scope.threadId === threadId) next.set(tokenHash, {
@@ -66708,12 +67650,12 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 			});
 			return {
 				records: next,
-				spawnedThreadIds
+				spawnedThreads
 			};
 		});
 	});
 	const grantWatchThread = Effect.fn("McpSessionRegistry.grantWatchThread")(function* ({ watcherThreadId, watchedThreadId }) {
-		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
+		yield* SynchronizedRef.update(state, ({ records, spawnedThreads }) => {
 			const next = new Map(records);
 			for (const [tokenHash, record] of records) {
 				if (record.scope.threadId !== watcherThreadId) continue;
@@ -66728,12 +67670,12 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 			}
 			return {
 				records: next,
-				spawnedThreadIds
+				spawnedThreads
 			};
 		});
 	});
 	const revokeWatchThread = Effect.fn("McpSessionRegistry.revokeWatchThread")(function* ({ watcherThreadId, watchedThreadId }) {
-		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
+		yield* SynchronizedRef.update(state, ({ records, spawnedThreads }) => {
 			const next = new Map(records);
 			for (const [tokenHash, record] of records) {
 				if (record.scope.threadId !== watcherThreadId) continue;
@@ -66756,12 +67698,12 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 			}
 			return {
 				records: next,
-				spawnedThreadIds
+				spawnedThreads
 			};
 		});
 	});
 	const grantAdviseThread = Effect.fn("McpSessionRegistry.grantAdviseThread")(function* ({ watcherThreadId, advisedThreadId }) {
-		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
+		yield* SynchronizedRef.update(state, ({ records, spawnedThreads }) => {
 			const next = new Map(records);
 			for (const [tokenHash, record] of records) {
 				if (record.scope.threadId !== watcherThreadId) continue;
@@ -66776,12 +67718,12 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 			}
 			return {
 				records: next,
-				spawnedThreadIds
+				spawnedThreads
 			};
 		});
 	});
 	const revokeAdviseThread = Effect.fn("McpSessionRegistry.revokeAdviseThread")(function* ({ watcherThreadId, advisedThreadId }) {
-		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
+		yield* SynchronizedRef.update(state, ({ records, spawnedThreads }) => {
 			const next = new Map(records);
 			for (const [tokenHash, record] of records) {
 				if (record.scope.threadId !== watcherThreadId) continue;
@@ -66804,12 +67746,12 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 			}
 			return {
 				records: next,
-				spawnedThreadIds
+				spawnedThreads
 			};
 		});
 	});
 	const recordSpawnedThread = Effect.fn("McpSessionRegistry.recordSpawnedThread")(function* (input) {
-		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
+		yield* SynchronizedRef.update(state, ({ records, spawnedThreads }) => {
 			const next = new Map(records);
 			for (const [tokenHash, record] of records) if (record.scope.providerSessionId === input.providerSessionId) next.set(tokenHash, {
 				...record,
@@ -66817,13 +67759,13 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 			});
 			return {
 				records: next,
-				spawnedThreadIds: /* @__PURE__ */ new Set([...spawnedThreadIds, input.threadId])
+				spawnedThreads: new Map([...spawnedThreads, [input.threadId, input.mayCreateFusionPairs === true]])
 			};
 		});
 	});
-	const revokeWhere = (predicate) => SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => ({
+	const revokeWhere = (predicate) => SynchronizedRef.update(state, ({ records, spawnedThreads }) => ({
 		records: new Map(Array.from(records).filter(([, record]) => !predicate(record))),
-		spawnedThreadIds
+		spawnedThreads
 	}));
 	return McpSessionRegistry.of({
 		issue,
@@ -66840,19 +67782,19 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 		revokeThread: Effect.fn("McpSessionRegistry.revokeThread")(function* (threadId) {
 			yield* revokeWhere((record) => record.scope.threadId === threadId);
 		}),
-		revokeAll: SynchronizedRef.update(state, ({ spawnedThreadIds }) => ({
+		revokeAll: SynchronizedRef.update(state, ({ spawnedThreads }) => ({
 			records: /* @__PURE__ */ new Map(),
-			spawnedThreadIds
+			spawnedThreads
 		}))
 	});
 });
 let activeMcpSessionRegistry;
-const make$10 = Effect.acquireRelease(makeWithOptions().pipe(Effect.tap((registry) => Effect.sync(() => {
+const make$11 = Effect.acquireRelease(makeWithOptions().pipe(Effect.tap((registry) => Effect.sync(() => {
 	activeMcpSessionRegistry = registry;
 }))), (registry) => Effect.sync(() => {
 	if (activeMcpSessionRegistry === registry) activeMcpSessionRegistry = void 0;
 }));
-const layer$3 = Layer.effect(McpSessionRegistry, make$10);
+const layer$3 = Layer.effect(McpSessionRegistry, make$11);
 const issueActiveMcpCredential = (request) => activeMcpSessionRegistry ? activeMcpSessionRegistry.revokeThread(request.threadId).pipe(Effect.andThen(activeMcpSessionRegistry.issue(request))) : Effect.sync(() => void 0);
 /**
 * Refreshes the liveness of a thread's MCP credential. Called on every provider
@@ -67561,6 +68503,13 @@ const makeProviderSessionReaper = (options) => Effect.gen(function* () {
 				});
 				continue;
 			}
+			if (thread?.backgroundLiveness != null) {
+				yield* Effect.logDebug("provider.session.reaper.skipped-background-work", {
+					threadId: binding.threadId,
+					backgroundLiveness: thread.backgroundLiveness
+				});
+				continue;
+			}
 			if (yield* providerService.stopSession({ threadId: binding.threadId }).pipe(Effect.tap(() => Effect.logInfo("provider.session.reaped", {
 				threadId: binding.threadId,
 				provider: binding.provider,
@@ -67578,14 +68527,18 @@ const makeProviderSessionReaper = (options) => Effect.gen(function* () {
 			totalBindings: bindings.length
 		});
 	});
+	const sweepSafely = () => sweep.pipe(Effect.catch((error) => Effect.logWarning("provider.session.reaper.sweep-failed", { error })), Effect.catchDefect((defect) => Effect.logWarning("provider.session.reaper.sweep-defect", { defect })));
 	const start = () => Effect.gen(function* () {
-		yield* Effect.forkScoped(sweep.pipe(Effect.catch((error) => Effect.logWarning("provider.session.reaper.sweep-failed", { error })), Effect.catchDefect((defect) => Effect.logWarning("provider.session.reaper.sweep-defect", { defect })), Effect.repeat(Schedule.spaced(Duration.millis(sweepIntervalMs)))));
+		yield* Effect.forkScoped(sweepSafely().pipe(Effect.repeat(Schedule.spaced(Duration.millis(sweepIntervalMs)))));
 		yield* Effect.logInfo("provider.session.reaper.started", {
 			inactivityThresholdMs,
 			sweepIntervalMs
 		});
 	});
-	return { start };
+	return {
+		start,
+		sweep: sweepSafely
+	};
 });
 const makeProviderSessionReaperLive = (options) => Layer.effect(ProviderSessionReaper, makeProviderSessionReaper(options));
 const ProviderSessionReaperLive = makeProviderSessionReaperLive();
@@ -69767,7 +70720,7 @@ function formatAskUserQuestionAnswers(answers) {
 * only a one-line reference and the mutable `[fusion-pair]` metadata.
 */
 const FUSION_BUILDER_INSTRUCTIONS = `You are Fusion Builder in an already-created native server pair. Server owns pairing and coordination. Do not inspect or invoke the Fusion skill, create/pair/rename threads, or announce/setup Fusion. Start the user's task directly. Before editing, create and maintain the phase list with your provider's step-tracking tool (Claude Code: TaskCreate for each phase, then TaskUpdate for status, or TodoWrite when that is the tool offered; Codex: update_plan), never the MCP task board tools - one entry per phase in order, exactly one in progress at a time, marked completed at each phase end - so phases render in the task banner. That list holds phase entries only for the whole task; keep step-level or per-file todos out of it. Name each phase in 3-6 words by its outcome, never by a command, file path, or flag, because the banner shows the title verbatim. Prose alone leaves the banner empty. Split it into the fewest substantial phases the task genuinely needs plus a final integration/whole-task phase; most tasks need one to three work phases. Each phase is a complete reviewable slice of behavior. Never split per file, per function, or per trivial step: over-splitting spends review turns instead of finishing the job. Add a phase only when a real review boundary, risky decision, or independent behavior separates the work. Complete exactly one phase per turn, and finish the whole phase in that turn rather than stopping early. Do not run tests, typecheck, lint, or builds per phase; write the tests the change needs, then run verification once in the final phase over the whole task. Exception: a phase whose own correctness is unclear may run the single narrowest check that resolves it. End every phase turn with phase completed, todo status, changed behavior/files, and remaining phases; do not start the next phase in the same turn. Server then wakes the paired Supervisor, which resumes you through ${FUSION_ADVICE_PROMPT_PREFIX}; a user message may also revise or resume the work. Final phase verifies the entire task against the original request and labels it ready for whole-task review. Supervisor is unreachable during your turn. Never spawn/use another Supervisor thread/subagent or attribute Supervisor decisions without ${FUSION_ADVICE_PROMPT_PREFIX}. Within the current phase, continue when straightforward or evidence is clear. For a concrete unresolved tradeoff, correctness risk, or design decision materially needing judgment, stop safely before the risky choice; final response states the exact question and why review is needed. Evaluate/follow Supervisor advice unless conflicting with user request or verified repo state.`;
-const FUSION_WATCHER_INSTRUCTIONS = `You are Fusion Supervisor (watcher) in an already-created native server pair. Server owns pairing and coordination and wakes you with ${FUSION_REVIEW_PROMPT_PREFIX} or ${FUSION_GATE_PROMPT_PREFIX} prompts at builder turn boundaries. A plain message outside such a wake may arrive after your conversational memory of the pair is gone; its [fusion-pair] metadata block is authoritative: the builder thread exists and is the counterpart thread id. Never report that no builder thread exists. To resume supervision, read builder events with thread_watch_events from lastReviewedImplementerSequence with limit 50, paging forward with the last returned sequence rather than requesting a whole range at once, derive phase from artifacts (git log/status, PR, builder events, including its turn.plan.updated phase list), steer with thread_advise, and answer an open gate with thread_gate_respond. When a review or gate wake prompt specifies an explicit event range, that range wins over this metadata. Never poll or wait for the builder; deliver review or advice, then end the turn. Every thread_advise starts a builder turn whose completion wakes you again, so never advise a builder that is idle on an external wait or has nothing actionable; report the state in your own thread and end without advising.`;
+const FUSION_WATCHER_INSTRUCTIONS = `You are Fusion Supervisor (watcher) in an already-created native server pair. Server owns pairing and coordination and wakes you with ${FUSION_REVIEW_PROMPT_PREFIX} or ${FUSION_GATE_PROMPT_PREFIX} prompts at builder turn boundaries. A plain message outside such a wake may arrive after your conversational memory of the pair is gone; its [fusion-pair] metadata block is authoritative: the builder thread exists and is the counterpart thread id. Never report that no builder thread exists. To resume supervision, read builder evidence with thread_watch_review from lastReviewedImplementerSequence, capture its throughSequence on the first page and reuse that fixed bound while paging with nextAfterSequence until hasMore is false (including empty pages). Apply message append/replace operations by identity; recover truncated evidence through targeted raw thread_watch_events source ranges. Retain reviewed requirements and evidence for final review; recover missing context with targeted history reads rather than mandatory raw replay from zero, derive phase from artifacts (git log/status, PR, builder events, including its turn.plan.updated phase list), steer with thread_advise, and answer an open gate with thread_gate_respond. When a review or gate wake prompt specifies an explicit event range, that range wins over this metadata. Never poll or wait for the builder; deliver review or advice, then end the turn. Every thread_advise starts a builder turn whose completion wakes you again, so never advise a builder that is idle on an external wait or has nothing actionable; report the state in your own thread and end without advising.`;
 /**
 * The one-line stand-in for the full block on a message whose session already
 * carries the role instructions.
@@ -91028,7 +91981,7 @@ const makeTerminationError$1 = (handle) => Effect.match(handle.exitCode, {
 //#endregion
 //#region ../../packages/effect-codex-app-server/src/client.ts
 var CodexAppServerClient = class extends Context.Service()("effect-codex-app-server/client/CodexAppServerClient") {};
-const make$9 = Effect.fn("effect-codex-app-server/CodexAppServerClient.make")(function* (stdio, options = {}, terminationError) {
+const make$10 = Effect.fn("effect-codex-app-server/CodexAppServerClient.make")(function* (stdio, options = {}, terminationError) {
 	const requestHandlers = /* @__PURE__ */ new Map();
 	const notificationHandlers = /* @__PURE__ */ new Map();
 	let unknownRequestHandler;
@@ -91095,7 +92048,7 @@ const make$9 = Effect.fn("effect-codex-app-server/CodexAppServerClient.make")(fu
 const layerChildProcess$1 = (handle, options = {}) => Layer.effect(CodexAppServerClient, makeChildProcessClient(handle, options));
 const makeChildProcessClient = Effect.fn("effect-codex-app-server/CodexAppServerClient.makeChildProcessClient")(function* (handle, options) {
 	yield* Stream.runDrain(handle.stderr).pipe(Effect.ignore, Effect.forkScoped);
-	return yield* make$9(makeChildStdio$1(handle), options, makeTerminationError$1(handle));
+	return yield* make$10(makeChildStdio$1(handle), options, makeTerminationError$1(handle));
 });
 const resolveCodexLaunchArgs = (launchArgs, environment = process.env) => environment["P4CODE_CODEX_LAUNCH_ARGS"]?.trim() || launchArgs?.trim() || "";
 const codexLaunchArgv = (launchArgs) => tokenizeCliArgs(launchArgs);
@@ -92118,6 +93071,8 @@ Default mode active; prior mode instructions inactive. Only developer \`<collabo
 
 Prefer reasonable assumptions and execution. Ask only when local discovery cannot answer and a reasonable assumption is risky.
 
+For multi-step work, keep task phases visible with native \`update_plan\`. If that tool is unavailable, use \`mcp__p4_code__thread_plan_update\` instead: send the complete ordered \`plan\` array of \`{ step, status }\`, with statuses \`pending\`, \`in_progress\`, or \`completed\`. Update it as phases finish. Prose alone does not populate the Tasks banner. This fallback tracks this conversation, not task-board tickets.
+
 ${CODEX_STRUCTURED_USER_QUESTIONS}
 ${P4_CODE_BROWSER_TOOL_INSTRUCTIONS}
 </collaboration_mode>`;
@@ -97898,7 +98853,7 @@ const makeTerminationError = (handle) => Effect.match(handle.exitCode, {
 //#endregion
 //#region ../../packages/effect-acp/src/client.ts
 var AcpClient = class extends Context.Service()("effect-acp/client/AcpClient") {};
-const make$8 = Effect.fn("effect-acp/AcpClient.make")(function* (stdio, options = {}, terminationError) {
+const make$9 = Effect.fn("effect-acp/AcpClient.make")(function* (stdio, options = {}, terminationError) {
 	const coreHandlers = {};
 	const notificationHandlers = {
 		sessionUpdate: {
@@ -98056,7 +99011,7 @@ const make$8 = Effect.fn("effect-acp/AcpClient.make")(function* (stdio, options
 const layerChildProcess = (handle, options = {}) => {
 	const stdio = makeChildStdio(handle);
 	const terminationError = makeTerminationError(handle);
-	return Layer.effect(AcpClient, make$8(stdio, options, terminationError));
+	return Layer.effect(AcpClient, make$9(stdio, options, terminationError));
 };
 //#endregion
 //#region ../../packages/shared/src/toolActivity.ts
@@ -98516,7 +99471,7 @@ function formatConfigOptionValue(value) {
 const defaultSessionLoadTimeout = Duration.seconds(90);
 const defaultSessionLoadReplayIdleGap = Duration.seconds(2);
 var AcpSessionRuntime = class extends Context.Service()("@p4code/cli/provider/acp/AcpSessionRuntime") {};
-const make$7 = (options) => Effect.gen(function* () {
+const make$8 = (options) => Effect.gen(function* () {
 	const crypto = yield* Crypto.Crypto;
 	const spawner = yield* ChildProcessSpawner$1.ChildProcessSpawner;
 	const runtimeScope = yield* Scope.Scope;
@@ -98832,7 +99787,7 @@ const make$7 = (options) => Effect.gen(function* () {
 		notify: acp.raw.notify
 	};
 });
-const layer$2 = (options) => Layer.effect(AcpSessionRuntime, make$7(options));
+const layer$2 = (options) => Layer.effect(AcpSessionRuntime, make$8(options));
 function sessionConfigOptionsFromSetup(response) {
 	return response?.configOptions ?? [];
 }
@@ -106293,7 +107248,7 @@ const stringField = (record, key) => {
 	const value = record[key];
 	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 };
-const make$6 = Effect.gen(function* () {
+const make$7 = Effect.gen(function* () {
 	const linear = yield* LinearClient;
 	return { resolve: Effect.fn("TicketResolver.resolve")(function* (reference) {
 		const identifier = parseTicketReference(reference);
@@ -106324,7 +107279,7 @@ const make$6 = Effect.gen(function* () {
 		};
 	}) };
 });
-const layer$1 = Layer.effect(TicketResolver, make$6);
+const layer$1 = Layer.effect(TicketResolver, make$7);
 //#endregion
 //#region src/mcp/toolkits/tasks/tools.ts
 const dependencies = [McpInvocationContext, TaskRepository];
@@ -106863,7 +107818,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. Set fusionWatcher true for a Fusion watcher; the server then requires explicit user approval before creating anything. 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. Set fusion true to create two new threads as a separate Fusion pair and start its builder with prompt, even when this thread already belongs to a pair. Set fusionWatcher true only for a supervisor to pair with the current thread. 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.",
 	parameters: ThreadSpawnInput,
 	success: ThreadSpawnResult,
 	failure: ThreadControlToolError,
@@ -106871,20 +107826,19 @@ const ThreadSpawnTool = Tool.make("thread_spawn", {
 		McpInvocationContext,
 		McpSessionRegistry,
 		OrchestrationEngineService,
-		ProjectionSnapshotQuery,
 		ProjectionThreadRepository,
+		ServerSettingsService,
 		Crypto.Crypto
 	]
 }).annotate(Tool.Title, "Start a thread").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
 const ThreadPairCreateTool = Tool.make("thread_pair_create", {
-	description: "Create a persisted Fusion pair between this agent session's own thread as builder and a supervisor it previously created with thread_spawn. The server refuses unless the latest user message explicitly invokes Fusion or approves the immediately preceding Fusion proposal. Successful creation automatically continues the builder, so never ask the user to resend the task.",
+	description: "Create a persisted Fusion pair between this agent session's own thread as builder and a supervisor it previously created with thread_spawn. Act on the user's request; no special command syntax is required. The current thread must not already belong to an active Fusion pair. Successful creation automatically continues the builder, so never ask the user to resend the task.",
 	parameters: ThreadPairCreateInput,
 	success: ThreadPairCreateResult,
 	failure: ThreadControlToolError,
 	dependencies: [
 		McpInvocationContext,
 		OrchestrationEngineService,
-		ProjectionSnapshotQuery,
 		Crypto.Crypto
 	]
 }).annotate(Tool.Title, "Create a Fusion pair").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
@@ -106972,7 +107926,19 @@ const AssetCompressTool = Tool.make("asset_compress", {
 		Path.Path
 	]
 }).annotate(Tool.Title, "Compress an asset").annotate(Tool.Readonly, false).annotate(Tool.Destructive, true).annotate(Tool.Idempotent, false);
-const ThreadToolkit = Toolkit.make(AskUserQuestionTool, ThreadSpawnTool, ThreadPairCreateTool, ThreadConfigureTool, ThreadSettleTool, ThreadCleanupTool, ThreadSnoozeTool, ThreadRenameTool, MemoryAppendTool, AssetCompressTool);
+const ThreadPlanUpdateTool = Tool.make("thread_plan_update", {
+	description: "Update the current thread's Tasks banner when your provider has no native update_plan or todo tool. Send the complete ordered phase list on every update, with at most one in_progress phase. Use short outcome titles. An empty plan clears the banner. This tracks conversation progress, not task-board tickets.",
+	parameters: ThreadPlanUpdateInput,
+	success: ThreadPlanUpdateResult,
+	failure: ThreadControlToolError,
+	dependencies: [
+		McpInvocationContext,
+		OrchestrationEngineService,
+		ProjectionThreadRepository,
+		Crypto.Crypto
+	]
+}).annotate(Tool.Title, "Update task phases").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
+const ThreadToolkit = Toolkit.make(ThreadPlanUpdateTool, AskUserQuestionTool, ThreadSpawnTool, ThreadPairCreateTool, ThreadConfigureTool, ThreadSettleTool, ThreadCleanupTool, ThreadSnoozeTool, ThreadRenameTool, MemoryAppendTool, AssetCompressTool);
 //#endregion
 //#region src/orchestration/pendingMcpUserInputs.ts
 /**
@@ -107047,29 +108013,6 @@ const newCommandId = Effect.gen(function* () {
 	const crypto = yield* Crypto.Crypto;
 	return CommandId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
 });
-const fusionInvocationLine = /^(?:\/fusion|\$fusion)(?:\s+.*)?$/i;
-const fusionAffirmativeLine = /^(?:approved?|yes(?:,?\s+(?:please|do it))?|ok(?:ay)?|go ahead|do it|proceed)[.!]?$/i;
-function lastNonEmptyLine(text) {
-	return text.split(/\r?\n/).findLast((line) => line.trim().length > 0)?.trim() ?? "";
-}
-function directlyInvokesFusion(text) {
-	return text.split(/\r?\n/).some((line) => fusionInvocationLine.test(line.trim()));
-}
-function asksForFusionApproval(message) {
-	if (message?.role !== "assistant") return false;
-	const text = message.text.toLowerCase();
-	return text.includes("fusion") && (text.includes("approve") || text.includes("approval"));
-}
-const requireFusionApproval = Effect.fn("mcp.threads.requireFusionApproval")(function* (threadId) {
-	const thread = yield* (yield* ProjectionSnapshotQuery).getThreadDetailById(threadId).pipe(Effect.mapError(() => new ThreadPairApprovalRequiredError({ threadId })));
-	if (Option.isNone(thread)) return yield* new ThreadPairApprovalRequiredError({ threadId });
-	const latestUserIndex = thread.value.messages.findLastIndex((message) => message.role === "user");
-	const latestUser = latestUserIndex >= 0 ? thread.value.messages[latestUserIndex] : void 0;
-	if (latestUser !== void 0 && directlyInvokesFusion(latestUser.text)) return;
-	const precedingAssistant = thread.value.messages.slice(0, latestUserIndex).findLast((message) => message.role === "assistant");
-	if (latestUser !== void 0 && fusionAffirmativeLine.test(lastNonEmptyLine(latestUser.text)) && asksForFusionApproval(precedingAssistant)) return;
-	return yield* new ThreadPairApprovalRequiredError({ threadId });
-});
 /**
 * The model a spawned thread starts on.
 *
@@ -107087,6 +108030,42 @@ const resolveSpawnModelSelection = (requested, inherited) => requested === void
 	...requested.options !== void 0 ? { options: requested.options } : {}
 };
 const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
+	thread_plan_update: (input) => Effect.gen(function* () {
+		const { threadId } = yield* requireThreadCapability();
+		const threads = yield* ProjectionThreadRepository;
+		const reject = (detail) => new ThreadControlRejectedError({
+			threadId,
+			commandType: "thread.activity.append",
+			detail
+		});
+		const thread = yield* threads.getById({ threadId }).pipe(Effect.mapError((cause) => reject(cause.message)));
+		if (Option.isNone(thread)) return yield* reject("Current thread does not exist.");
+		if (input.plan.filter((step) => step.status === "in_progress").length > 1) return yield* reject("At most one phase may be in progress.");
+		const crypto = yield* Crypto.Crypto;
+		const createdAt = DateTime.formatIso(yield* DateTime.now);
+		yield* dispatchControl({
+			type: "thread.activity.append",
+			commandId: yield* newCommandId,
+			threadId,
+			createdAt,
+			activity: {
+				id: EventId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie)),
+				createdAt,
+				tone: "info",
+				kind: "turn.plan.updated",
+				summary: "Plan updated",
+				turnId: thread.value.latestTurnId,
+				payload: {
+					...input,
+					plan: input.plan.map((step) => ({
+						step: step.step,
+						status: step.status === "in_progress" ? "inProgress" : step.status
+					}))
+				}
+			}
+		}, threadId);
+		return { threadId };
+	}),
 	ask_user_question: (input) => Effect.gen(function* () {
 		const invocation = yield* requireThreadCapability();
 		const crypto = yield* Crypto.Crypto;
@@ -107158,8 +108137,11 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 		}).pipe(Effect.ensuring(Effect.sync(() => forgetPendingMcpUserInput(invocation.threadId, requestId))));
 	}),
 	thread_spawn: (input) => Effect.gen(function* () {
-		const invocation = yield* requireThreadSpawn();
-		if (input.fusionWatcher === true) yield* requireFusionApproval(invocation.threadId);
+		const invocation = yield* requireThreadSpawn(input.fusion === true);
+		if (input.fusion === true && input.fusionWatcher === true) return yield* new ThreadSpawnNotPermittedError({
+			threadId: invocation.threadId,
+			detail: "Choose a new Fusion pair or a standalone watcher, not both."
+		});
 		const registry = yield* McpSessionRegistry;
 		const threads = yield* ProjectionThreadRepository;
 		const crypto = yield* Crypto.Crypto;
@@ -107173,7 +108155,11 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 		});
 		const template = parent.value;
 		const projectId = input.projectId ?? template.projectId;
-		const modelSelection = resolveSpawnModelSelection(input.modelSelection, template.modelSelection);
+		const settings = input.fusion === true || input.fusionWatcher === true ? yield* (yield* ServerSettingsService).getSettings.pipe(Effect.mapError((cause) => new ThreadSpawnNotPermittedError({
+			threadId: invocation.threadId,
+			detail: `Fusion settings could not be read: ${cause.message}`
+		}))) : void 0;
+		const modelSelection = resolveSpawnModelSelection(input.modelSelection, (input.fusionWatcher === true ? settings?.fusionWatcherModelSelection : settings?.fusionBuilderModelSelection) ?? template.modelSelection);
 		const runtimeMode = input.runtimeMode ?? template.runtimeMode;
 		const interactionMode = input.interactionMode ?? template.interactionMode;
 		const compressMode = input.compressMode ?? template.compressMode;
@@ -107197,8 +108183,42 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 		}, threadId);
 		yield* registry.recordSpawnedThread({
 			providerSessionId: invocation.providerSessionId,
-			threadId
+			threadId,
+			...input.fusionWatcher === true ? { mayCreateFusionPairs: true } : {}
 		});
+		const fusionPair = input.fusion === true ? {
+			pairId: ThreadPairId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie)),
+			watcherThreadId: ThreadId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie))
+		} : void 0;
+		if (fusionPair !== void 0) {
+			yield* dispatchControl({
+				type: "thread.create",
+				commandId: yield* newCommandId,
+				threadId: fusionPair.watcherThreadId,
+				projectId,
+				title: `Review: ${input.title}`,
+				modelSelection: settings?.fusionWatcherModelSelection ?? modelSelection,
+				runtimeMode,
+				interactionMode: "default",
+				compressMode,
+				unpromptedSubagents,
+				branch: null,
+				worktreePath: null,
+				createdAt
+			}, fusionPair.watcherThreadId);
+			yield* registry.recordSpawnedThread({
+				providerSessionId: invocation.providerSessionId,
+				threadId: fusionPair.watcherThreadId
+			});
+			yield* dispatchControl({
+				type: "thread-pair.create",
+				commandId: yield* newCommandId,
+				pairId: fusionPair.pairId,
+				implementerThreadId: threadId,
+				watcherThreadId: fusionPair.watcherThreadId,
+				createdAt
+			}, threadId);
+		}
 		yield* dispatchControl({
 			type: "thread.turn.start",
 			commandId: yield* newCommandId,
@@ -107220,12 +108240,12 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 		return {
 			threadId,
 			projectId,
-			title: input.title
+			title: input.title,
+			...fusionPair
 		};
 	}),
 	thread_pair_create: (input) => Effect.gen(function* () {
 		const { invocation, threadId: watcherThreadId } = yield* requireThreadControlTarget(input.watcherThreadId);
-		yield* requireFusionApproval(invocation.threadId);
 		const crypto = yield* Crypto.Crypto;
 		const pairId = ThreadPairId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
 		const continuationMessageId = MessageId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
@@ -107763,24 +108783,40 @@ const ThreadWatchEventsTool = Tool.make("thread_watch_events", {
 	failure: ThreadWatchToolError,
 	dependencies: [McpInvocationContext, ThreadEventStreamService]
 }).annotate(Tool.Title, "Read watched thread events").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
-const WatchToolkit = Toolkit.make(ThreadWatchEventsTool);
-const WatchToolkitHandlersLive = WatchToolkit.toLayer({ thread_watch_events: (input) => Effect.gen(function* () {
-	yield* requireWatchCapability(input.threadId);
-	const page = yield* (yield* ThreadEventStreamService).read({
-		threadId: input.threadId,
-		...input.afterSequence !== void 0 ? { afterSequence: input.afterSequence } : {},
-		limit: input.limit ?? 50
-	}).pipe(Effect.mapError((cause) => new ThreadWatchFailedError({
-		threadId: input.threadId,
-		detail: cause.message
-	})));
-	return {
-		threadId: input.threadId,
-		events: page.events,
-		headSequence: page.headSequence,
-		hasMore: page.hasMore
-	};
-}) });
+const ThreadWatchReviewTool = Tool.make("thread_watch_review", {
+	description: "Read bounded compact review evidence for an explicitly granted thread. Combines assistant fragments by message identity; preserves user requirements, tool evidence, plans, errors and turn boundaries. Resume with nextAfterSequence and the same throughSequence until hasMore is false, even on empty pages. Message operations append or replace by identity across pages. Truncated evidence includes source sequence ranges for targeted recovery with thread_watch_events; do not treat an excerpt as full proof.",
+	parameters: ThreadWatchReviewInput,
+	success: ThreadWatchReviewResult,
+	failure: ThreadWatchToolError,
+	dependencies: [McpInvocationContext, ThreadEventStreamService]
+}).annotate(Tool.Title, "Read compact thread review").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
+const WatchToolkit = Toolkit.make(ThreadWatchEventsTool, ThreadWatchReviewTool);
+const WatchToolkitHandlersLive = WatchToolkit.toLayer({
+	thread_watch_review: (input) => Effect.gen(function* () {
+		yield* requireWatchCapability(input.threadId);
+		return yield* (yield* ThreadEventStreamService).readReview(input).pipe(Effect.mapError((cause) => new ThreadWatchFailedError({
+			threadId: input.threadId,
+			detail: cause.message
+		})));
+	}),
+	thread_watch_events: (input) => Effect.gen(function* () {
+		yield* requireWatchCapability(input.threadId);
+		const page = yield* (yield* ThreadEventStreamService).read({
+			threadId: input.threadId,
+			...input.afterSequence !== void 0 ? { afterSequence: input.afterSequence } : {},
+			limit: input.limit ?? 50
+		}).pipe(Effect.mapError((cause) => new ThreadWatchFailedError({
+			threadId: input.threadId,
+			detail: cause.message
+		})));
+		return {
+			threadId: input.threadId,
+			events: page.events,
+			headSequence: page.headSequence,
+			hasMore: page.hasMore
+		};
+	})
+});
 //#endregion
 //#region src/mcp/McpHttpServer.ts
 const unauthorized = HttpServerResponse.jsonUnsafe({
@@ -107955,6 +108991,100 @@ var ThreadDeletionReactor = class extends Context.Service()("@p4code/cli/orchest
 //#region src/orchestration/Services/FusionWatcherReactor.ts
 var FusionWatcherReactor = class extends Context.Service()("@p4code/cli/orchestration/Services/FusionWatcherReactor") {};
 //#endregion
+//#region src/orchestration/Layers/ThreadCompletionReactor.ts
+const COMPLETION_SWEEP_BATCH_SIZE = 25;
+const COMPLETION_SWEEP_INTERVAL = Duration.minutes(1);
+const COMPLETION_PR_TIMEOUT = Duration.seconds(10);
+const MILLISECONDS_PER_DAY = 1440 * 60 * 1e3;
+const make$6 = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const settings = yield* ServerSettingsService;
+	const git = yield* GitManager;
+	const engine = yield* OrchestrationEngineService;
+	const crypto = yield* Crypto.Crypto;
+	const mutex = yield* Semaphore.make(1);
+	let cursor = "";
+	const candidates = SqlSchema.findAll({
+		Request: Schema$1.String,
+		Result: Schema$1.Struct({
+			threadId: ThreadId,
+			cwd: Schema$1.String,
+			branch: Schema$1.NullOr(Schema$1.String),
+			lastEngagedAt: IsoDateTime,
+			pinnedAt: Schema$1.NullOr(IsoDateTime),
+			projectDeletedAt: Schema$1.NullOr(IsoDateTime),
+			pendingApprovalCount: Schema$1.Number,
+			pendingUserInputCount: Schema$1.Number,
+			sessionStatus: Schema$1.NullOr(Schema$1.String)
+		}),
+		execute: (afterThreadId) => sql`
+      SELECT t.thread_id AS "threadId", COALESCE(t.worktree_path, p.workspace_root) AS "cwd",
+        t.branch, t.last_engaged_at AS "lastEngagedAt", t.pinned_at AS "pinnedAt",
+        p.deleted_at AS "projectDeletedAt", t.pending_approval_count AS "pendingApprovalCount",
+        t.pending_user_input_count AS "pendingUserInputCount", s.status AS "sessionStatus"
+      FROM projection_threads t
+      JOIN projection_projects p ON p.project_id = t.project_id
+      LEFT JOIN projection_thread_sessions s ON s.thread_id = t.thread_id
+      WHERE t.lifecycle = 'active' AND t.deleted_at IS NULL
+        AND t.thread_id > ${afterThreadId}
+      ORDER BY t.thread_id ASC LIMIT ${COMPLETION_SWEEP_BATCH_SIZE}
+    `
+	});
+	const sweep = Effect.fn("ThreadCompletionReactor.sweep")(function* () {
+		yield* mutex.withPermits(1)(Effect.gen(function* () {
+			const now = yield* Clock.currentTimeMillis;
+			const days = (yield* settings.getSettings).threadAutoCompleteAfterDays;
+			const cutoff = days === null ? null : now - days * MILLISECONDS_PER_DAY;
+			const rows = yield* candidates(cursor);
+			const branchStates = /* @__PURE__ */ new Map();
+			for (const row of rows) {
+				if (row.projectDeletedAt !== null || row.pinnedAt !== null || row.pendingApprovalCount > 0 || row.pendingUserInputCount > 0 || row.sessionStatus === "starting" || row.sessionStatus === "running") continue;
+				const key = `${row.cwd.length}:${row.cwd}${row.branch ?? ""}`;
+				let pr = branchStates.get(key);
+				if (pr === void 0) {
+					pr = yield* git.threadCompletionPrState({
+						cwd: row.cwd,
+						branch: row.branch
+					}).pipe(Effect.timeout(COMPLETION_PR_TIMEOUT), Effect.orElseSucceed(() => ({ state: "unknown" })));
+					branchStates.set(key, pr);
+				}
+				if (pr.state === "unknown" || pr.state === "open") continue;
+				const engagedAt = Date.parse(row.lastEngagedAt);
+				const terminalAt = pr.state === "terminal" ? Date.parse(pr.terminalAt) : null;
+				if (terminalAt !== null && (!Number.isFinite(terminalAt) || terminalAt > now)) continue;
+				const eligible = terminalAt !== null && terminalAt > engagedAt ? {
+					reason: "pull-request",
+					eligibleAt: DateTime.formatIso(DateTime.makeUnsafe(terminalAt))
+				} : cutoff !== null && engagedAt < cutoff ? {
+					reason: "inactivity",
+					eligibleAt: DateTime.formatIso(DateTime.makeUnsafe(cutoff))
+				} : null;
+				if (eligible === null) continue;
+				const commandId = CommandId.make(`server:thread-complete:${yield* crypto.randomUUIDv4}`);
+				yield* engine.dispatch({
+					type: "thread.complete.auto",
+					commandId,
+					threadId: row.threadId,
+					expectedLastEngagedAt: row.lastEngagedAt,
+					...eligible
+				}).pipe(Effect.catch((cause) => Effect.logDebug("Automatic completion did not apply", {
+					threadId: row.threadId,
+					cause
+				})));
+			}
+			cursor = rows.length < COMPLETION_SWEEP_BATCH_SIZE ? "" : rows.at(-1).threadId;
+		}));
+	});
+	return {
+		sweep,
+		start: Effect.fn("ThreadCompletionReactor.start")(function* () {
+			yield* sweep().pipe(Effect.catchCause((cause) => Effect.logWarning("Thread completion sweep failed", { cause })), Effect.repeat(Schedule.spaced(COMPLETION_SWEEP_INTERVAL)), Effect.forkScoped);
+		})
+	};
+});
+var ThreadCompletionReactor = class extends Context.Service()("@p4code/cli/orchestration/Layers/ThreadCompletionReactor") {};
+const ThreadCompletionReactorLive = Layer.effect(ThreadCompletionReactor, make$6);
+//#endregion
 //#region src/orchestration/Services/ScheduledTaskReactor.ts
 /**
 * ScheduledTaskReactor - fires user-created scheduled tasks.
@@ -107975,6 +109105,7 @@ const makeOrchestrationReactor = Effect.gen(function* () {
 	const threadDeletionReactor = yield* ThreadDeletionReactor;
 	const fusionWatcherReactor = yield* FusionWatcherReactor;
 	const scheduledTaskReactor = yield* ScheduledTaskReactor;
+	const completionReactor = yield* ThreadCompletionReactor;
 	return { start: Effect.fn("start")(function* () {
 		yield* providerRuntimeIngestion.start();
 		yield* providerCommandReactor.start();
@@ -107982,6 +109113,7 @@ const makeOrchestrationReactor = Effect.gen(function* () {
 		yield* threadDeletionReactor.start();
 		yield* fusionWatcherReactor.start();
 		yield* scheduledTaskReactor.start();
+		yield* completionReactor.start();
 	}) };
 });
 const OrchestrationReactorLive = Layer.effect(OrchestrationReactor, makeOrchestrationReactor);
@@ -109375,7 +110507,7 @@ const HANDLED_TURN_START_KEY_TTL = Duration.minutes(30);
 const DEFAULT_RUNTIME_MODE = "full-access";
 const DEFAULT_THREAD_TITLE = "New thread";
 const NON_SYSTEM_PROVIDER_STRUCTURED_USER_QUESTIONS = structuredUserQuestionPrompt("your provider's structured user-input question tool");
-const FUSION_PROMOTION_INSTRUCTIONS = `Work independently in this normal thread. Fusion is a silent escalation path, not a startup procedure. Do not inspect Fusion tools/skill, mention Fusion status, or announce that Fusion was not invoked. First analyze the task normally. Only if that analysis reveals a concrete unresolved tradeoff, correctness risk, or design decision materially needing a second opinion, stop before implementation, propose Fusion, and ask the user for explicit approval. The user may approve with ordinary affirmative text such as "approved"; /fusion or $fusion also authorizes Fusion directly without a prior proposal. Do not activate, spawn, or promote until one of those authorizations arrives. UI work, complex logic, task size, unfamiliarity, or duration alone never qualifies.`;
+const FUSION_PROMOTION_INSTRUCTIONS = `Work independently in this normal thread. Fusion is a silent escalation path, not a startup procedure. Do not inspect Fusion tools/skill, mention Fusion status, or announce that Fusion was not invoked. First analyze the task normally. Only if that analysis reveals a concrete unresolved tradeoff, correctness risk, or design decision materially needing a second opinion, stop before implementation, propose Fusion, and ask the user for explicit approval. The user may approve with ordinary affirmative text such as "approved". A direct user request to use or spawn Fusion authorizes Fusion directly without a prior proposal; /fusion and $fusion are optional shortcuts. Do not activate, spawn, or promote until one of those authorizations arrives. UI work, complex logic, task size, unfamiliarity, or duration alone never qualifies.`;
 const isFusionWatcherWakeMessageId = (messageId) => messageId.startsWith("fusion-review:") || messageId.startsWith("fusion-gate:");
 const findActiveFusionPair = (pairs, threadId) => (pairs ?? []).find((pair) => pair.detachedAt === null && (pair.implementerThreadId === threadId || pair.watcherThreadId === threadId));
 const fusionRoleForThread = (pairs, threadId) => {
@@ -110981,7 +112113,7 @@ After restart/context loss, derive phase from workspace git log/status, PR, rece
 const watcherPrompt = (input) => `${FUSION_REVIEW_PROMPT_PREFIX}
 Review completed builder turn ${input.implementerThreadId}.
 
-Call thread_watch_events, threadId ${input.implementerThreadId}, afterSequence ${input.afterSequence}, limit 50; repeat with the last returned event's sequence as afterSequence until you reach ${input.throughSequence}. Never request a whole range in one call: an oversized page exceeds the tool output cap and wastes the turn. Inspect repo when useful.
+Call thread_watch_review, threadId ${input.implementerThreadId}, afterSequence ${input.afterSequence}, throughSequence ${input.throughSequence}. Continue with nextAfterSequence and the same throughSequence until hasMore is false, including empty pages. Apply message append/replace operations by identity across pages. Recover truncated or uncertain evidence with targeted thread_watch_events reads using its source sequence range. Inspect repo when useful.
 
 Always report concise:
 
@@ -110993,7 +112125,7 @@ Determine review boundary from builder's todo status:
 
 - Remaining phases, or final status unclear, and the builder has actionable work: intermediate phase review. Call thread_advise for ${input.implementerThreadId}. With objections, send required corrections and next phase. With none, explicitly approve phase and tell builder to continue next todo phase. Never require tests, typecheck, lint, or builds before the final phase.
 - Builder waiting on an external process or with nothing actionable: no thread_advise. Report the state here and end.
-- Final whole-task phase ready: call thread_watch_events again from afterSequence 0 through ${input.throughSequence}, same limit 50 paging, then inspect full task diff/state. Review original requirements, integration across all phases, verification, and delivery. Advise only for concrete objections or unfinished work; otherwise report no objections and end.
+- Final whole-task phase ready: combine previously reviewed evidence with this delta and inspect the full task diff/state. Review original requirements and later corrections, integration across all phases, verification, and delivery. Recover missing requirements or uncertain prior evidence with targeted compact history reads bounded by throughSequence ${input.throughSequence}, and raw source reads when necessary. Do not replay raw history from zero by default. If prior context is unavailable, recover the requirements before concluding. Advise only for concrete objections or unfinished work; otherwise report no objections and end.
 
 ${watcherPowers(input.implementerThreadId)}
 
@@ -111012,7 +112144,7 @@ const gateKindDescription = (gate) => {
 const gatePrompt = (input) => `${FUSION_GATE_PROMPT_PREFIX}
 Gate ${input.gate.id} is open on builder thread ${input.implementerThreadId}: ${gateKindDescription(input.gate)}. Round ${Math.min(input.gate.round + 1, input.roundCap)} of ${input.roundCap}.
 
-First read delta: thread_watch_events, threadId ${input.implementerThreadId}, afterSequence ${input.afterSequence}, limit 50; repeat with the last returned event's sequence as afterSequence until you reach ${input.throughSequence}. Never request a whole range in one call: an oversized page exceeds the tool output cap and wastes the turn. Inspect repo when useful.
+First read delta: thread_watch_review, threadId ${input.implementerThreadId}, afterSequence ${input.afterSequence}, throughSequence ${input.throughSequence}. Continue with nextAfterSequence and the same throughSequence until hasMore is false, including empty pages. Apply message append/replace operations by identity across pages; recover truncated or uncertain evidence with targeted thread_watch_events reads using its source sequence range. Inspect repo when useful.
 
 Then thread_gate_respond, threadId ${input.implementerThreadId}, gateId ${input.gate.id}:
 
@@ -112745,7 +113877,7 @@ const PlatformServicesLive = Layer.unwrap(Effect.gen(function* () {
 		return layer;
 	}
 }));
-const ReactorLayerLive = Layer.empty.pipe(Layer.provideMerge(OrchestrationReactorLive), Layer.provideMerge(ProviderRuntimeIngestionLive), Layer.provideMerge(ProviderCommandReactorLive), Layer.provideMerge(CheckpointReactorLive), Layer.provideMerge(ThreadDeletionReactorLive), Layer.provideMerge(FusionWatcherReactorLive), Layer.provideMerge(ScheduledTaskReactorLive), Layer.provideMerge(RuntimeReceiptBusLive));
+const ReactorLayerLive = Layer.empty.pipe(Layer.provideMerge(OrchestrationReactorLive), Layer.provideMerge(ProviderRuntimeIngestionLive), Layer.provideMerge(ProviderCommandReactorLive), Layer.provideMerge(CheckpointReactorLive), Layer.provideMerge(ThreadDeletionReactorLive), Layer.provideMerge(FusionWatcherReactorLive), Layer.provideMerge(ScheduledTaskReactorLive), Layer.provideMerge(ThreadCompletionReactorLive), Layer.provideMerge(RuntimeReceiptBusLive));
 const ProviderSessionDirectoryLayerLive = ProviderSessionDirectoryLive.pipe(Layer.provide(layer$4));
 const ProviderLayerLive = ProviderServiceLive.pipe(Layer.provide(ProviderAdapterRegistryLive), Layer.provideMerge(ProviderSessionDirectoryLayerLive));
 const PersistenceLayerLive = Layer.empty.pipe(Layer.provideMerge(layerConfig));