@overdeck/desktop 0.45.24 → 0.47.0

package/server/{specialists-CC4r-c2s.js → specialists-6PWdtWcg.js}

@@ -1,46 +1,47 @@
 import { a as __toCommonJS } from "./rolldown-runtime-DNCzzKnI.js";
-import { A as canUseHarnessSync, Br as getOverdeckHome, D as resolveTieredExecutionEnabled, H as init_providers, I as UnknownModelError, Jn as extractPrefixSync, M as init_harness_policy, Nr as encodeClaudeProjectDir, O as resolveTieredExecutionEnabledForIssue, Qt as parsePorcelainStatusPaths, T as init_tier_table, Tn as init_projects, U as piProviderForModel, Ur as packageRoot, V as getProviderForModelSync, Vr as init_paths, Wr as resolveOhmypiExtensionPath, Yn as init_issue_id, Yt as init_state_plane, Zn as parseIssueIdSync, c as isClaudeCodeChannelsEnabled, f as loadConfigSync, fn as findProjectByPathSync, in as shouldCommitLegacyWorkspaceArtifacts, ir as FsError, kn as listProjectsSync, mr as init_errors, nn as init_state_read_home, rn as resolveStateReadHomeSync, t as init_config_yaml, tt as resolveModel, yn as getProjectSync, zn as resolveProjectFromIssueSync } from "./config-yaml-DySPNmKN.js";
-import { a as init_activity_logger, n as emitActivityEntrySync } from "./activity-logger-DDlOIAML.js";
-import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-BEqFxlJc.js";
-import { $ as init_child_env, B as sendKeysAsync, D as killSession, H as sessionExists, M as listSessionNames, N as listSessions, Q as buildChildEnvWithoutTmuxSync, T as isHarnessProcessAlive, U as sessionExistsSync, V as sendRawKeystroke, W as setOption, X as BLANKED_PROVIDER_ENV, g as findManagedServerPidSync, i as capturePane, m as exactPaneTarget, s as createSession, w as init_tmux } from "./tmux-R7N7y-Mh.js";
-import { a as init_event_store, n as getEventStore } from "./event-store-CQL6NeqB.js";
-import { M as normalizeChannelReplyPayload, o as getHarnessBehavior, t as init_src, w as DomainEvent } from "./src-DtcUOZCq.js";
-import { E as init_agent_state_sync, b as setReviewStatusSync, c as getReviewStatusSync, d as loadReviewStatuses, i as clearWorkspaceStuck, k as stateToOverdeckParamsForDb, l as init_review_status, w as AGENT_COLUMNS_FOR_DB } from "./review-status-kZj_KyCk.js";
-import { a as EventStoreService, c as ReadModelService, d as init_read_model, i as init_issue_lifecycle, s as init_domain_services, t as IssueLifecycle, u as getClosedIssueIdsForReadSource } from "./issue-lifecycle-ojZAzDBP.js";
-import { d as isTerminalIssueStage, o as init_agents, u as getIssueStageSync } from "./agents-EbI0zCJl.js";
-import { n as ensureSessionContextBriefingFile, r as init_briefing_freshness } from "./briefing-freshness-D1wzUIWv.js";
-import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-B2ddP6wq.js";
-import { Ar as saveAgentRuntimeState, At as deliverAgentPermissionDecision, Bt as assertWorkspaceStackHealthyForSpawn, Cr as normalizeAgentId, Dn as validateProviderHealth, Dr as getAgentRuntimeState, En as init_provider_health, Er as waitForReadySignal, F as init_tier_escalation, Fn as writeChannelsBridgeMcpConfig, Fr as init_codex_auth, G as resumeAgent, Gn as getAgentDir, Gt as transitionIssueToInProgress, H as restartAgent, Lt as BRIDGE_TOKEN_HEADER, Nt as setAgentDeliveryMethod, Or as getAgentRuntimeStateSync, P as decideEscalation, Pn as dismissDevChannelsDialog, Pr as checkCodexAuthStatus, Q as operatorInterventionEvent, Rt as init_bridge_token, Sn as determineModel, Ut as init_spawn_prep, V as recoverAgent, Vn as clearAgentTroubled, X as messageAgent, Xt as resolveStaffing, Yn as getAgentStateSync, Z as init_operator_interventions, _r as init_pty_token, an as getProviderAuthMode, at as saveSessionId, b as init_agents$1, br as resolvePtySupervisorScriptPath, cr as saveAgentState, et as getActivity, fn as init_pi_fifo, ft as stopAgent, hn as ohmypiFifoPaths, i as listRunningAgents, kt as deliverAgentMessage, lr as saveAgentStateSync, mn as init_ohmypi_fifo, mr as writeAgentStateJsonSync, nn as getAgentRuntimeBaseCommand, nr as markAgentStoppedState, nt as getLatestSessionIdSync, pn as piFifoPaths, pr as wipeAgentStateDirs, qn as getAgentState, qt as init_staffing, r as listAgentStates, rt as getSessionId, sn as init_runtime_command, tn as getAcpLauncherFields, tt as getLatestSessionId, un as waitForAcpHostReady, ur as setAgentPaused, vr as writePtyToken, wn as getProviderExportsForModel, xr as clearReadySignal, yr as init_pty_supervisor_locate, zn as clearAgentPaused, zt as writeBridgeTokenSync } from "./queries-CjNIf-Ub.js";
-import { a as performHandoff, i as checkAllTriggers, s as getAgentHealth, t as getCloisterService } from "./service-CLeAoU6G.js";
-import { o as init_persistent_logger, s as logAgentLifecycleSync } from "./session-history-BT3IvqhC.js";
-import { t as init_behavior } from "./behavior-B3exJ42O.js";
-import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-G6latr8C.js";
-import { n as init_issue_service_singleton, r as issue_service_singleton_exports } from "./issue-service-singleton-Yx5DdmVJ.js";
-import { o as getInternalTokenSync, s as init_internal_token } from "./internal-token-s0-oKybJ.js";
-import { a as PAN_DIRNAME, i as PAN_CONTINUE_FILENAME, p as init_types } from "./types-hraoaQIp.js";
-import { a as generateXBriefFilename, o as init_lifecycle } from "./lifecycle-yPd___5E.js";
-import { f as readTierOverrides, g as serializeXBriefDocument, h as recordTierPromotion, m as readWorkspacePlanSync, o as init_io, r as findPlan, u as readPlan } from "./io-C9kF1wtJ.js";
-import { B as removeFavorite, E as hasOtherActiveConversationOnTmuxSession, F as markConversationEnded, G as setConversationHarness, K as setConversationModel, M as listConversations, P as markConversationActive, Q as updateConversationDeliveryMethod, S as getConversationByName, W as setConversationEffort, g as backfillConversationModel, h as archiveConversation, k as init_conversations, nt as updateLastAttached, rt as updateSpawnError, x as getConversationById, y as createConversation } from "./conversations-6AfUfbwc.js";
-import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-DKZFMbFt.js";
-import { a as normalizeModelOverrideSync, i as init_model_validation, n as init_launcher_generator, o as requireModelOverrideSync, r as MODEL_ID_PATTERN, t as generateLauncherScriptSync } from "./launcher-generator-BBWG_SiS.js";
-import { a as init_claude_permissions, o as resolvePermissionModeSync, r as getClaudePermissionFlagsStringSync, t as BYPASS_PERMISSION_MODE } from "./claude-permissions-DNWEVV6z.js";
-import { E as init_layers, I as workspaceContextFile, k as piGlobalContextFile } from "./assemble-J2ZZ2C15.js";
-import { i as prepareHarnessLaunch, r as init_harness_binary } from "./harness-binary-DPUi-Pv8.js";
-import { a as getWorkspaceStackHealth, s as init_stack_health } from "./stack-health-DxSdG9cW.js";
-import { l as init_dag, o as getDispatchableItems } from "./dag-B1ucnjDU.js";
-import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-3lNZkyT4.js";
-import { a as loadCloisterConfigSync, r as init_config } from "./config-CKxYiCmX.js";
-import { c as isStateMigrated, o as init_state_home } from "./state-home-Cn_Qu8IX.js";
-import { a as init_lifecycle_io, c as updatePlanStatus, s as transitionXBriefOnMain } from "./lifecycle-io-BREGpnLk.js";
-import { _ as init_codex_conversation_parser, b as parseAcpConversationMessages, c as parseEntireConversation, d as init_pi_conversation_parser, g as parseOhmypiConversationMessages, m as init_ohmypi_conversation_parser, p as parsePiConversationMessages, t as init_conversation_service, v as parseCodexConversationMessages, y as init_acp_conversation_parser } from "./conversation-service-DPJ71F33.js";
-import { _ as parseCodexApprovalPrompt, d as getAgentPendingQuestions$1, f as getAgentWorkspace$1, g as normalizeAwaitingInputPrompt, m as detectAwaitingInputForAgent, o as getRuntimeForAgent, p as scanPendingInputsPromise, s as computeAgentEnrichment, u as getAgentJsonlPath$1 } from "./stuck-remediation-DYuPRYYw.js";
-import { B as getBook, H as liveOrderIssueLookup, T as resolveLiveFlywheelRunId, w as readFlywheelLaunchMetadata, y as getFlywheelRunDir, z as computeBookProgress } from "./flywheel-DHrgCphM.js";
-import { Dt as classifyMemoryPressure, It as getSystemHealthSnapshot, Pt as getResourceConfig } from "./deacon-CU_cAYSR.js";
-import { o as stopWorkspaceDocker, r as init_workspace_manager } from "./workspace-manager-CBhNdzE4.js";
-import { a as init_jsonl_parser, o as normalizeModelName } from "./jsonl-parser-BXSlHwEh.js";
-import { r as init_in_flight_guard, t as createInFlightGuard } from "./in-flight-guard-CAAkqPLu.js";
-import { a as loadWorkspaceMetadataSync } from "./workspace-metadata-_WygnyoX.js";
-import { basename, delimiter, dirname, join, resolve } from "node:path";
+import { A as canUseHarnessSync, Cn as resolveStateReadHomeSync, D as resolveTieredExecutionEnabled, Fr as init_errors, Gn as init_projects, H as init_providers, I as UnknownModelError, M as init_harness_policy, Mn as findProjectByPathSync, O as resolveTieredExecutionEnabledForIssue, Sn as init_state_read_home, T as init_tier_table, Tr as FsError, U as piProviderForModel, V as getProviderForModelSync, Yn as listProjectsSync, ar as resolveProjectFromIssueSync, c as isClaudeCodeChannelsEnabled, ci as getOverdeckHome, di as packageRoot, ei as claudeSessionTranscriptExists, f as loadConfigSync, fi as resolveOhmypiExtensionPath, gr as init_issue_id, h as jsYaml, hn as init_state_plane, hr as extractPrefixSync, li as init_paths, m as init_js_yaml, t as init_config_yaml, ti as encodeClaudeProjectDir, tt as resolveModel, vn as parsePorcelainStatusPaths, vr as parseIssueIdSync, wn as shouldCommitLegacyWorkspaceArtifacts, zn as getProjectSync } from "./config-yaml-CxdwhAIA.js";
+import { n as emitActivityEntryDurable, o as init_activity_logger, r as emitActivityEntrySync } from "./activity-logger-CyteR4JO.js";
+import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-BDQDRopn.js";
+import { B as sendKeysAsync, D as killSession, H as sessionExists, J as init_pane_choice_menu, M as listSessionNames, N as listSessions, T as isHarnessProcessAlive, U as sessionExistsSync, V as sendRawKeystroke, W as setOption, X as paneHasBlockingChoiceMenu, at as buildChildEnvWithoutTmuxSync, g as findManagedServerPidSync, i as capturePane, m as exactPaneTarget, o as capturePaneText, ot as init_child_env, rt as BLANKED_PROVIDER_ENV, s as createSession, w as init_tmux } from "./tmux-CfDHob9M.js";
+import { a as init_event_store, n as getEventStore } from "./event-store-CrHcVC5_.js";
+import { N as normalizeChannelReplyPayload, T as DomainEvent, n as COMPOSER_COMMAND_MANIFEST, s as getHarnessBehavior, t as init_src } from "./src-B948bGVR.js";
+import { C as setReviewStatusSync, Q as stateToOverdeckParamsForDb, Y as init_agent_state_sync, d as getReviewStatusSync, h as loadReviewStatuses, o as clearWorkspaceStuck, p as init_review_status, q as AGENT_COLUMNS_FOR_DB } from "./review-status-CGvlA4o_.js";
+import { a as EventStoreService, c as ReadModelService, d as getClosedIssueIdsForReadSource, f as init_read_model, i as init_issue_lifecycle, s as init_domain_services, t as IssueLifecycle } from "./issue-lifecycle-Birk-ifu.js";
+import { n as logAgentLifecycleSync, t as init_persistent_logger } from "./persistent-logger-H_VjuOu7.js";
+import { d as isTerminalIssueStage, o as init_agents, u as getIssueStageSync } from "./agents-J5mEnekq.js";
+import { n as ensureSessionContextBriefingFile, r as init_briefing_freshness } from "./briefing-freshness-DRqZ8lAz.js";
+import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-DpgYmYqR.js";
+import { $ as operatorInterventionEvent, $n as getAgentDir, An as getProviderExportsForModel, Ar as resolvePtySupervisorScriptPath, Bn as dismissDevChannelsDialog, Br as saveAgentRuntimeState, Dr as init_pty_token, Er as init_resume_contract, F as init_tier_escalation, G as resumeAgent, Gr as init_codex_auth, Gt as assertWorkspaceStackHealthyForSpawn, H as restartAgent, Ht as BRIDGE_TOKEN_HEADER, Ir as waitForReadySignal, Jt as init_spawn_prep, Lr as getAgentRuntimeState, Mn as init_provider_health, Mt as deliverAgentMessage, Nn as validateProviderHealth, Nr as normalizeAgentId, Nt as deliverAgentPermissionDecision, On as determineModel, Or as writePtyToken, P as decideEscalation, Q as init_operator_interventions, Qt as init_staffing, Rr as getAgentRuntimeStateSync, Rt as setAgentDeliveryMethod, Sr as writeAgentStateJsonSync, Tr as buildResumeContract, Un as writeChannelsBridgeMcpConfig, Ut as init_bridge_token, V as recoverAgent, Wr as checkCodexAuthStatus, Wt as writeBridgeTokenSync, X as messageAgent, Xt as transitionIssueToInProgress, Yn as clearAgentTroubled, _r as saveAgentStateSync, b as init_agents$1, bn as init_ohmypi_fifo, cn as getAgentRuntimeBaseCommand, dn as getProviderAuthMode, gn as waitForAcpHostReady, gr as saveAgentState, i as listRunningAgents, it as getSessionId, jr as clearReadySignal, kr as init_pty_supervisor_locate, nn as resolveStaffing, nt as getLatestSessionId, ot as saveSessionId, pn as init_runtime_command, pt as stopAgent, qn as clearAgentPaused, r as listAgentStates, rr as getAgentStateSync, rt as getLatestSessionIdSync, sn as getAcpLauncherFields, tn as resolveIssueWorkModel, tr as getAgentState, tt as getActivity, ur as markAgentStoppedState, vn as init_pi_fifo, vr as setAgentPaused, xn as ohmypiFifoPaths, xr as wipeAgentStateDirs, yn as piFifoPaths } from "./queries-C-MUZaIy.js";
+import { a as performHandoff, i as checkAllTriggers, s as getAgentHealth, t as getCloisterService } from "./service-CD0DvFvD.js";
+import { t as init_behavior } from "./behavior-td6-xhQk.js";
+import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-BcPMElRB.js";
+import { n as init_issue_service_singleton, r as issue_service_singleton_exports } from "./issue-service-singleton-C6ZduvuY.js";
+import { o as getInternalTokenSync, s as init_internal_token } from "./internal-token-DzK385vD.js";
+import { a as PAN_DIRNAME, i as PAN_CONTINUE_FILENAME, p as init_types } from "./types-Cm5ASJbq.js";
+import { l as resolveWorkspaceRepoRootsSync, o as resolvePrimaryWorkspaceRepoDirSync, r as init_project_repos } from "./project-repos-B5pIphKg.js";
+import { a as generateXBriefFilename, o as init_lifecycle } from "./lifecycle-B4Xdb4cY.js";
+import { f as readTierOverrides, g as serializeXBriefDocument, h as recordTierPromotion, m as readWorkspacePlanSync, o as init_io, r as findPlan, u as readPlan } from "./io-B00PBNku.js";
+import { B as removeFavorite, E as hasOtherActiveConversationOnTmuxSession, F as markConversationEnded, G as setConversationHarness, K as setConversationModel, M as listConversations, P as markConversationActive, Q as updateConversationDeliveryMethod, S as getConversationByName, W as setConversationEffort, g as backfillConversationModel, h as archiveConversation, k as init_conversations, nt as updateLastAttached, rt as updateSpawnError, x as getConversationById, y as createConversation } from "./conversations-D0UEdLtk.js";
+import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-B6HpNWRy.js";
+import { C as init_launcher_generator, D as requireModelOverrideSync, E as normalizeModelOverrideSync, S as generateLauncherScriptSync, T as init_model_validation, w as MODEL_ID_PATTERN, x as normalizeFlywheelRunId, y as init_provenance } from "./auto-spawn-consent-CQ9Bi9q6.js";
+import { a as init_claude_permissions, o as resolvePermissionModeSync, r as getClaudePermissionFlagsStringSync, t as BYPASS_PERMISSION_MODE } from "./claude-permissions-CpbpvUQ2.js";
+import { E as init_layers, I as workspaceContextFile, k as piGlobalContextFile } from "./assemble-Bgwqv-Ro.js";
+import { i as prepareHarnessLaunch, r as init_harness_binary } from "./harness-binary-BSpiXaLw.js";
+import { a as getWorkspaceStackHealth, s as init_stack_health } from "./stack-health-DqLTiEu4.js";
+import { l as init_dag, o as getDispatchableItems } from "./dag-BtkgLeqY.js";
+import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-BAJu5MX8.js";
+import { a as loadCloisterConfigSync, r as init_config } from "./config-Bi3u1VK7.js";
+import { c as isStateMigrated, o as init_state_home } from "./state-home-722Dkx92.js";
+import { a as init_lifecycle_io, c as updatePlanStatus, s as transitionXBriefOnMain } from "./lifecycle-io-DCo6s6ks.js";
+import { _ as init_codex_conversation_parser, b as parseAcpConversationMessages, c as parseEntireConversation, d as init_pi_conversation_parser, g as parseOhmypiConversationMessages, m as init_ohmypi_conversation_parser, p as parsePiConversationMessages, t as init_conversation_service, v as parseCodexConversationMessages, y as init_acp_conversation_parser } from "./conversation-service-DBxoYMDl.js";
+import { _ as normalizeAwaitingInputPrompt, d as getAgentPendingQuestions$1, f as getAgentWorkspace$1, h as detectAwaitingInputForAgent, m as scanPendingInputsPromise, o as getRuntimeForAgent, p as isBlockedOnPendingInput, s as computeAgentEnrichment, u as getAgentJsonlPath$1, v as parseCodexApprovalPrompt } from "./stuck-remediation-CC6q3eqQ.js";
+import { B as getBook, H as liveOrderIssueLookup, T as resolveLiveFlywheelRunId, w as readFlywheelLaunchMetadata, y as getFlywheelRunDir, z as computeBookProgress } from "./flywheel-BHx8XuMr.js";
+import { At as classifyMemoryPressure, Lt as getResourceConfig, zt as getSystemHealthSnapshot } from "./deacon-pLRLbPvR.js";
+import { o as stopWorkspaceDocker, r as init_workspace_manager } from "./workspace-manager-BPgTrG66.js";
+import { a as init_jsonl_parser, o as normalizeModelName } from "./jsonl-parser-BDpnGFCl.js";
+import { r as init_in_flight_guard, t as createInFlightGuard } from "./in-flight-guard-D-sSkADM.js";
+import { a as loadWorkspaceMetadataSync } from "./workspace-metadata-DkO_iTLo.js";
+import { basename, delimiter, dirname, isAbsolute, join, resolve } from "node:path";
 import { Cause, Data, Effect, Layer, Option, Schema, Stream } from "effect";
 import { join as join$1 } from "path";
 import { homedir, networkInterfaces } from "node:os";
@@ -52,9 +53,9 @@ import { mkdir as mkdir$1, writeFile as writeFile$1 } from "fs/promises";
 import { exec, execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { createHash as createHash$1, createHmac, randomBytes, randomUUID as randomUUID$1, timingSafeEqual } from "node:crypto";
+import { createInterface } from "node:readline";
 import { pathToFileURL } from "node:url";
 import { request } from "node:http";
-import { createInterface } from "node:readline";
 import * as Result$1 from "effect/Result";
 //#region http-helpers.ts
 init_paths();
@@ -86,21 +87,24 @@ init_projects();
 init_providers();
 init_harness_policy();
 init_tier_table();
+init_js_yaml();
 init_config_yaml();
 init_child_env();
+init_pane_choice_menu();
 init_tmux();
 init_infra();
 init_event_store();
 init_src();
 init_agent_state_sync();
+init_persistent_logger();
 init_agents();
 init_read_model();
 init_briefing_freshness();
 init_domain_services();
 init_cost();
 init_behavior();
-init_persistent_logger();
 init_tracker_config();
+init_project_repos();
 init_lifecycle();
 init_review_status();
 init_io();
@@ -193,6 +197,7 @@ function httpHandler(effect) {
 init_conversations();
 init_pty_supervisor_locate();
 init_pty_token();
+init_resume_contract();
 init_feature_registry_population();
 init_model_validation();
 init_provider_health();
@@ -205,6 +210,7 @@ init_runtime_command();
 init_stack_health();
 init_launcher_generator();
 init_dag();
+init_provenance();
 init_staffing();
 init_spawn_prep();
 init_harness_resolve();
@@ -218,6 +224,27 @@ function addTrustedOrigin(origins, raw) {
 	const normalized = normalizeOrigin(raw.trim());
 	if (normalized) origins.add(normalized);
 }
+/**
+* Last-resort origin config for launches that carry no origin env at all
+* (manual `node dist/...`, ad-hoc re-exec). `pan up` builds its launch env from
+* this same config.yaml, so reading it here keeps every launch path trusting the
+* same Traefik domain instead of 403ing /ws/* into a "Reconnecting" loop.
+*/
+function readTraefikConfigFromYaml() {
+	try {
+		const configPath = join(process.env["OVERDECK_HOME"] || join(homedir(), ".overdeck"), "config.yaml");
+		if (!existsSync(configPath)) return null;
+		const traefik = jsYaml.load(readFileSync(configPath, "utf8"))?.traefik;
+		if (!traefik || typeof traefik !== "object") return null;
+		if (typeof traefik.domain !== "string" || traefik.domain.trim() === "") return null;
+		return {
+			enabled: traefik.enabled === true,
+			domain: traefik.domain.trim()
+		};
+	} catch {
+		return null;
+	}
+}
 function getTrustedOrigins() {
 	if (cachedTrustedOrigins !== void 0) return cachedTrustedOrigins;
 	const port = parseInt(process.env["API_PORT"] ?? process.env["PORT"] ?? "3011", 10);
@@ -232,6 +259,10 @@ function getTrustedOrigins() {
 	for (const origin of trustedOrigins?.split(",") ?? []) addTrustedOrigin(origins, origin);
 	const traefikDomain = process.env["OVERDECK_TRAEFIK_DOMAIN"] ?? process.env["TRAEFIK_DOMAIN"];
 	if (process.env["OVERDECK_TRAEFIK_ENABLED"] === "1" && traefikDomain) addTrustedOrigin(origins, `https://${traefikDomain}`);
+	if (!(process.env["OVERDECK_TRAEFIK_ENABLED"] !== void 0 || traefikDomain !== void 0 || process.env["OVERDECK_TRUSTED_ORIGINS"] !== void 0)) {
+		const fromYaml = readTraefikConfigFromYaml();
+		if (fromYaml?.enabled) addTrustedOrigin(origins, `https://${fromYaml.domain}`);
+	}
 	if (process.env["NODE_ENV"] === "development") {
 		addTrustedOrigin(origins, "http://localhost:3000");
 		addTrustedOrigin(origins, "http://127.0.0.1:3000");
@@ -799,7 +830,7 @@ async function resolveCodexRolloutPath(agentId, opts = {}) {
 	const agentDir = join(opts.agentsDirOverride ?? join(getOverdeckHome(), "agents"), agentId);
 	const codexHome = join(agentDir, "codex-home");
 	if (!await pathExists$1(codexHome)) return null;
-	const { findRolloutPath, findLatestRollout } = await import("./codex-GcHuUF-k.js");
+	const { findRolloutPath, findLatestRollout } = await import("./codex-o8FJwzmy.js");
 	const threadId = (await readOptional(join(agentDir, "codex-thread-id")))?.trim();
 	if (threadId) {
 		const rollout = findRolloutPath(codexHome, threadId);
@@ -898,6 +929,7 @@ function spawnPanCli(args, options = {}) {
 //#endregion
 //#region ../../lib/work-agent-lifecycle.ts
 init_agents$1();
+init_paths();
 init_tmux();
 async function pathExists(path) {
 	try {
@@ -912,9 +944,11 @@ function getWorkAgentLifecycleStateSync(agentOrIssueId) {
 	const agentState = getAgentStateSync(agentId);
 	const runtimeState = getAgentRuntimeStateSync(agentId);
 	const hasAgentState = !!agentState;
-	const hasSavedSession = !!getLatestSessionIdSync(agentId);
+	const sessionId = getLatestSessionIdSync(agentId) ?? null;
+	const hasSavedSession = !!sessionId;
 	const hasLiveTmuxSession = sessionExistsSync(agentId);
 	const hasWorkspace = !!agentState?.workspace && existsSync(agentState.workspace);
+	const hasResumableTranscript = !sessionId || !!agentState?.harness && agentState.harness !== "claude-code" || !agentState?.workspace || claudeSessionTranscriptExists(agentState.workspace, sessionId);
 	const agentStatus = agentState?.status || "unknown";
 	const runtime = runtimeState?.state || "uninitialized";
 	const isCompleted = runtimeState?.resolution === "completed";
@@ -925,7 +959,7 @@ function getWorkAgentLifecycleStateSync(agentOrIssueId) {
 	const isRunningButStuck = isRunning && (runtime === "idle" || runtime === "suspended");
 	const hasResumableBackingState = hasAgentState && hasWorkspace && !isPlaceholder;
 	const isOrphaned = !hasLiveTmuxSession && (hasSavedSession && !hasResumableBackingState || hasAgentState && (!hasWorkspace || isPlaceholder));
-	const requiresSessionResetBeforeFreshStart = hasSavedSession && !hasLiveTmuxSession && hasResumableBackingState && (isStopped || isCrashed);
+	const requiresSessionResetBeforeFreshStart = hasSavedSession && hasResumableTranscript && !hasLiveTmuxSession && hasResumableBackingState && (isStopped || isCrashed);
 	let recommendedAction = "start";
 	let reason;
 	if (isRunningButStuck) {
@@ -943,6 +977,9 @@ function getWorkAgentLifecycleStateSync(agentOrIssueId) {
 	} else if (requiresSessionResetBeforeFreshStart) {
 		recommendedAction = "resume";
 		reason = `Agent ${agentId} has a resumable Claude session. Use 'pan resume ${agentOrIssueId}' to continue it, or 'pan start ${agentOrIssueId} --fresh' to start a new session (e.g. to switch model).`;
+	} else if (hasSavedSession && !hasResumableTranscript && hasResumableBackingState && (isStopped || isCrashed)) {
+		recommendedAction = "start";
+		reason = `Agent ${agentId} has a saved Claude session id but its transcript is missing on disk (jsonl-missing). Start Agent will create a fresh session in the existing workspace.`;
 	} else if (hasAgentState && !hasSavedSession && isStopped) {
 		recommendedAction = "start";
 		reason = `Agent ${agentId} is stopped and has no saved Claude session. Start Agent will create a fresh session in the existing workspace.`;
@@ -955,6 +992,7 @@ function getWorkAgentLifecycleStateSync(agentOrIssueId) {
 		hasAgentState,
 		hasLiveTmuxSession,
 		hasSavedSession,
+		hasResumableTranscript,
 		hasWorkspace,
 		isPlaceholder,
 		isOrphaned,
@@ -966,9 +1004,9 @@ function getWorkAgentLifecycleStateSync(agentOrIssueId) {
 		runtimeState: runtime,
 		agentStatus,
 		canStartFresh: (!hasLiveTmuxSession || hasLiveTmuxSession && isStopped) && (!requiresSessionResetBeforeFreshStart || isOrphaned),
-		canResumeSession: !isRunning && hasSavedSession && hasResumableBackingState && (isStopped || isCrashed),
+		canResumeSession: !isRunning && hasSavedSession && hasResumableTranscript && hasResumableBackingState && (isStopped || isCrashed),
 		canRestartWithContext: hasAgentState && hasWorkspace,
-		canResetSession: hasSavedSession && hasResumableBackingState,
+		canResetSession: hasSavedSession && hasResumableTranscript && hasResumableBackingState,
 		requiresSessionResetBeforeFreshStart,
 		recommendedAction,
 		reason
@@ -979,9 +1017,11 @@ async function getWorkAgentLifecycleStateSnapshot(agentOrIssueId) {
 	const agentState = await Effect.runPromise(getAgentState(agentId));
 	const runtimeState = await Effect.runPromise(getAgentRuntimeState(agentId));
 	const hasAgentState = !!agentState;
-	const hasSavedSession = !!await Effect.runPromise(getLatestSessionId(agentId));
+	const sessionId = await Effect.runPromise(getLatestSessionId(agentId)) ?? null;
+	const hasSavedSession = !!sessionId;
 	const hasLiveTmuxSession = await Effect.runPromise(sessionExists(agentId));
 	const hasWorkspace = !!agentState?.workspace && await pathExists(agentState.workspace);
+	const hasResumableTranscript = !sessionId || !!agentState?.harness && agentState.harness !== "claude-code" || !agentState?.workspace || claudeSessionTranscriptExists(agentState.workspace, sessionId);
 	const agentStatus = agentState?.status || "unknown";
 	const runtime = runtimeState?.state || "uninitialized";
 	const isCompleted = runtimeState?.resolution === "completed";
@@ -992,7 +1032,7 @@ async function getWorkAgentLifecycleStateSnapshot(agentOrIssueId) {
 	const isRunningButStuck = isRunning && (runtime === "idle" || runtime === "suspended");
 	const hasResumableBackingState = hasAgentState && hasWorkspace && !isPlaceholder;
 	const isOrphaned = !hasLiveTmuxSession && (hasSavedSession && !hasResumableBackingState || hasAgentState && (!hasWorkspace || isPlaceholder));
-	const requiresSessionResetBeforeFreshStart = hasSavedSession && !hasLiveTmuxSession && hasResumableBackingState && (isStopped || isCrashed);
+	const requiresSessionResetBeforeFreshStart = hasSavedSession && hasResumableTranscript && !hasLiveTmuxSession && hasResumableBackingState && (isStopped || isCrashed);
 	let recommendedAction = "start";
 	let reason;
 	if (isRunningButStuck) {
@@ -1010,6 +1050,9 @@ async function getWorkAgentLifecycleStateSnapshot(agentOrIssueId) {
 	} else if (requiresSessionResetBeforeFreshStart) {
 		recommendedAction = "resume";
 		reason = `Agent ${agentId} has a resumable Claude session. Use 'pan resume ${agentOrIssueId}' to continue it, or 'pan start ${agentOrIssueId} --fresh' to start a new session (e.g. to switch model).`;
+	} else if (hasSavedSession && !hasResumableTranscript && hasResumableBackingState && (isStopped || isCrashed)) {
+		recommendedAction = "start";
+		reason = `Agent ${agentId} has a saved Claude session id but its transcript is missing on disk (jsonl-missing). Start Agent will create a fresh session in the existing workspace.`;
 	} else if (hasAgentState && !hasSavedSession && isStopped) {
 		recommendedAction = "start";
 		reason = `Agent ${agentId} is stopped and has no saved Claude session. Start Agent will create a fresh session in the existing workspace.`;
@@ -1022,6 +1065,7 @@ async function getWorkAgentLifecycleStateSnapshot(agentOrIssueId) {
 		hasAgentState,
 		hasLiveTmuxSession,
 		hasSavedSession,
+		hasResumableTranscript,
 		hasWorkspace,
 		isPlaceholder,
 		isOrphaned,
@@ -1033,9 +1077,9 @@ async function getWorkAgentLifecycleStateSnapshot(agentOrIssueId) {
 		runtimeState: runtime,
 		agentStatus,
 		canStartFresh: (!hasLiveTmuxSession || hasLiveTmuxSession && isStopped) && (!requiresSessionResetBeforeFreshStart || isOrphaned),
-		canResumeSession: !isRunning && hasSavedSession && hasResumableBackingState && (isStopped || isCrashed),
+		canResumeSession: !isRunning && hasSavedSession && hasResumableTranscript && hasResumableBackingState && (isStopped || isCrashed),
 		canRestartWithContext: hasAgentState && hasWorkspace,
-		canResetSession: hasSavedSession && hasResumableBackingState,
+		canResetSession: hasSavedSession && hasResumableTranscript && hasResumableBackingState,
 		requiresSessionResetBeforeFreshStart,
 		recommendedAction,
 		reason
@@ -1185,111 +1229,357 @@ async function resolveAgentGitInfo(workspacePath, expectedBranch) {
 	};
 }
 //#endregion
-//#region routes/agents/shared.ts
+//#region ../../lib/composer-commands/executors.ts
+const CAPTURED_COMMAND_MAX_OUTPUT_BYTES = 64 * 1024;
+const TRUNCATION_MESSAGE = "\n\nOutput was truncated after 65,536 bytes.";
+function runCapturedCommand(argv, dependencies = {}) {
+	const command = `/pan ${argv.join(" ")}`;
+	const spawnCommand = dependencies.spawnPanCli ?? spawnPanCli;
+	const timeoutMs = dependencies.timeoutMs ?? 3e4;
+	const child = spawnCommand(argv, { stdio: [
+		"ignore",
+		"pipe",
+		"pipe"
+	] });
+	return new Promise((resolve) => {
+		const chunks = [];
+		let bufferedBytes = 0;
+		let settled = false;
+		let timeout;
+		let truncated = false;
+		const appendOutput = (data) => {
+			if (truncated) return;
+			const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+			const remaining = CAPTURED_COMMAND_MAX_OUTPUT_BYTES - Buffer.byteLength(TRUNCATION_MESSAGE) - bufferedBytes;
+			if (buffer.length <= remaining) {
+				chunks.push(buffer);
+				bufferedBytes += buffer.length;
+				return;
+			}
+			if (remaining > 0) {
+				chunks.push(buffer.subarray(0, remaining));
+				bufferedBytes += remaining;
+			}
+			truncated = true;
+		};
+		const output = () => {
+			const captured = Buffer.concat(chunks, bufferedBytes).toString("utf8");
+			return truncated ? `${captured}${TRUNCATION_MESSAGE}` : captured;
+		};
+		const finish = (result) => {
+			if (settled) return;
+			settled = true;
+			if (timeout !== void 0) clearTimeout(timeout);
+			resolve(result);
+		};
+		child.stdout?.on("data", appendOutput);
+		child.stderr?.on("data", appendOutput);
+		child.once("error", (error) => {
+			finish({
+				kind: "captured",
+				status: "failed",
+				command,
+				output: `Command ${command} could not start: ${error.message}`,
+				truncated: false
+			});
+		});
+		child.once("close", (code) => {
+			const captured = output();
+			finish({
+				kind: "captured",
+				status: code === 0 ? "completed" : "failed",
+				command,
+				output: captured || `Command ${command} ${code === 0 ? "completed without output." : `failed with exit code ${code ?? "unknown"}.`}`,
+				truncated
+			});
+		});
+		timeout = setTimeout(() => {
+			stopChild(child);
+			finish({
+				kind: "captured",
+				status: "failed",
+				command,
+				output: `Command ${command} timed out after ${Math.round(timeoutMs / 1e3)} seconds and was stopped.`,
+				truncated: false
+			});
+		}, timeoutMs);
+	});
+}
+function stopChild(child) {
+	child.kill("SIGTERM");
+}
+//#endregion
+//#region ../../lib/composer-commands/detached.ts
 init_paths();
-init_agents$1();
-init_tmux();
-const execAsync$2 = promisify(exec);
-const execFileAsync$2 = promisify(execFile);
-function buildPanStartArgs(input) {
-	return [
-		"start",
-		input.issueId,
-		"--local",
-		"--model",
-		input.model,
-		...input.harness ? ["--harness", input.harness] : [],
-		...input.allowHost ? ["--host", "--yes"] : [],
-		...input.offBook ? ["--off-book"] : []
-	];
+const DETACHED_TRUNCATION_MESSAGE = "\n\nOutput was truncated after 65,536 bytes.";
+function resolveAgentDirectory(overdeckHome, agentId) {
+	if (agentId.length === 0 || agentId === "." || agentId === ".." || agentId.includes("/") || agentId.includes("\\") || isAbsolute(agentId)) throw new Error("Agent ID must be a single filesystem-safe path segment.");
+	return join(resolve(overdeckHome, "agents"), agentId);
+}
+async function readBoundedSpawnOutput(spawnLogPath, startOffset) {
+	const maximumPrefixBytes = CAPTURED_COMMAND_MAX_OUTPUT_BYTES - Buffer.byteLength(DETACHED_TRUNCATION_MESSAGE);
+	const handle = await open(spawnLogPath, "r");
+	try {
+		const stats = await handle.stat();
+		const outputBytes = Math.max(0, stats.size - startOffset);
+		if (outputBytes === 0) return "";
+		const bytesToRead = Math.min(outputBytes, maximumPrefixBytes);
+		const buffer = Buffer.alloc(bytesToRead);
+		const { bytesRead } = await handle.read(buffer, 0, bytesToRead, startOffset);
+		const output = buffer.subarray(0, bytesRead).toString("utf8");
+		return outputBytes > maximumPrefixBytes ? `${output}${DETACHED_TRUNCATION_MESSAGE}` : output;
+	} finally {
+		await handle.close().catch(() => void 0);
+	}
 }
-/**
-* PAN-1985: detached-spawn helper for `pan <args>`, shared between the
-* standard work-spawn route and the restart-fresh route. Opens a spawn.log
-* inside the agent dir (creating the dir if missing — the dir may have been
-* just wiped), spawns `pan` detached with stdio to that log, and resolves
-* with an activity id once the child closes with code 0. Throws an Error
-* with the log contents attached on non-zero exit.
-*/
-async function spawnPanCommandDetached(input) {
+async function appendAgentLifecycleLog(agentId, event, details = {}, overdeckHome = getOverdeckHome()) {
+	const agentDir = resolveAgentDirectory(overdeckHome, agentId);
+	await mkdir(agentDir, { recursive: true });
+	const logLine = JSON.stringify({
+		ts: (/* @__PURE__ */ new Date()).toISOString(),
+		event,
+		...details
+	});
+	await appendFile(join(agentDir, "lifecycle.log"), `${logLine}\n`);
+}
+async function launchPanCommandDetached(input, dependencies = {}) {
 	const { agentSessionName, issueId, role, workspacePath, args } = input;
 	const cwd = input.cwd ?? workspacePath;
-	const activityId = `activity-${Date.now()}`;
-	const agentDir = join(homedir(), ".overdeck", "agents", agentSessionName);
+	const overdeckHome = dependencies.overdeckHome ?? getOverdeckHome();
+	const activityId = input.activityId ?? `activity-${(dependencies.now ?? Date.now)()}`;
+	const agentDir = resolveAgentDirectory(overdeckHome, agentSessionName);
 	await mkdir(agentDir, { recursive: true });
 	const spawnLogPath = join(agentDir, "spawn.log");
 	const spawnLogHandle = await open(spawnLogPath, "a");
-	const invocation = panCliInvocation(args);
-	const child = spawn(invocation.command, invocation.args, {
+	const spawnLogStart = (await spawnLogHandle.stat()).size;
+	const child = (dependencies.spawnPanCli ?? spawnPanCli)(args, {
 		cwd,
 		detached: true,
 		stdio: [
 			"ignore",
 			spawnLogHandle.fd,
 			spawnLogHandle.fd
-		]
+		],
+		env: {
+			...process.env,
+			...input.env
+		}
+	});
+	let spawned = false;
+	let settleSpawn;
+	let rejectSpawn;
+	const spawnPromise = new Promise((resolve, reject) => {
+		settleSpawn = resolve;
+		rejectSpawn = reject;
 	});
+	const completion = commandCompletion(child, {
+		agentSessionName,
+		issueId,
+		role,
+		workspacePath,
+		activityId,
+		args,
+		cwd,
+		spawnLogPath,
+		spawnLogStart,
+		spawnLogHandle,
+		overdeckHome,
+		onSpawn: () => {
+			spawned = true;
+			settleSpawn?.();
+		},
+		onError: (error) => {
+			if (!spawned) rejectSpawn?.(error);
+		}
+	});
+	completion.catch(() => void 0);
+	await spawnPromise;
+	child.unref();
+	return {
+		activityId,
+		spawnLogPath,
+		spawnLogStart,
+		completion
+	};
+}
+function commandCompletion(child, context) {
 	child.once("spawn", () => {
-		appendAgentLifecycleLog(agentSessionName, "agent.work_spawn_process_spawned", {
-			issueId,
-			role,
-			workspacePath,
-			activityId,
+		appendAgentLifecycleLog(context.agentSessionName, "agent.work_spawn_process_spawned", {
+			issueId: context.issueId,
+			role: context.role,
+			workspacePath: context.workspacePath,
+			activityId: context.activityId,
 			pid: child.pid,
-			args,
-			cwd,
-			spawnLogPath
-		}).catch(() => void 0);
+			args: context.args,
+			cwd: context.cwd,
+			spawnLogPath: context.spawnLogPath
+		}, context.overdeckHome).catch(() => void 0).finally(context.onSpawn);
 	});
-	try {
-		const result = await new Promise((resolve, reject) => {
-			child.once("error", (error) => {
-				appendAgentLifecycleLog(agentSessionName, "agent.work_spawn_process_error", {
-					issueId,
-					role,
-					workspacePath,
-					activityId,
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const finish = async (error) => {
+			if (settled) return;
+			settled = true;
+			await context.spawnLogHandle.close().catch(() => void 0);
+			if (error) reject(error);
+			else resolve();
+		};
+		child.once("error", (error) => {
+			(async () => {
+				await appendAgentLifecycleLog(context.agentSessionName, "agent.work_spawn_process_error", {
+					issueId: context.issueId,
+					role: context.role,
+					workspacePath: context.workspacePath,
+					activityId: context.activityId,
 					error: error.message,
-					args,
-					cwd,
-					spawnLogPath
-				}).catch(() => void 0);
-				reject(error);
-			});
-			child.once("close", (code, signal) => {
-				appendAgentLifecycleLog(agentSessionName, "agent.work_spawn_process_closed", {
-					issueId,
-					role,
-					workspacePath,
-					activityId,
+					args: context.args,
+					cwd: context.cwd,
+					spawnLogPath: context.spawnLogPath
+				}, context.overdeckHome).catch(() => void 0);
+				context.onError(error);
+				await finish(error);
+			})();
+		});
+		child.once("close", (code, signal) => {
+			(async () => {
+				await appendAgentLifecycleLog(context.agentSessionName, "agent.work_spawn_process_closed", {
+					issueId: context.issueId,
+					role: context.role,
+					workspacePath: context.workspacePath,
+					activityId: context.activityId,
 					code,
 					signal,
-					args,
-					cwd,
-					spawnLogPath
-				}).catch(() => void 0);
-				resolve({
+					args: context.args,
+					cwd: context.cwd,
+					spawnLogPath: context.spawnLogPath
+				}, context.overdeckHome).catch(() => void 0);
+				if (code === 0) {
+					await finish();
+					return;
+				}
+				const output = await readBoundedSpawnOutput(context.spawnLogPath, context.spawnLogStart).catch(() => "");
+				const error = new Error(output.trim() || `pan ${context.args.join(" ")} exited with code ${code ?? "null"}`);
+				Object.assign(error, {
+					activityId: context.activityId,
+					spawnLogPath: context.spawnLogPath,
 					code,
-					signal
+					signal,
+					output
 				});
-			});
+				await finish(error);
+			})();
 		});
-		if (result.code !== 0) {
-			const output = await readFile(spawnLogPath, "utf-8").catch(() => "");
-			const error = new Error(output.trim() || `pan ${args.join(" ")} exited with code ${result.code ?? "null"}`);
-			Object.assign(error, {
-				activityId,
-				spawnLogPath,
-				code: result.code,
-				signal: result.signal,
-				output
-			});
-			throw error;
-		}
-		return activityId;
-	} finally {
-		await spawnLogHandle.close();
+	});
+}
+async function runDetachedCommand(argv, dependencies = {}) {
+	const issueId = argv[1] ?? "";
+	const parsedIssueId = parseIssueIdSync(issueId);
+	if (!parsedIssueId) return {
+		kind: "terminal-only",
+		status: "rejected",
+		message: `/pan ${argv[0] ?? "command"} requires a canonical issue ID such as PAN-1525.`
+	};
+	const role = argv[0] === "plan" ? "plan" : "work";
+	const agentSessionName = `${role === "plan" ? "planning" : "agent"}-${parsedIssueId.normalized}`;
+	const command = `/pan ${argv.join(" ")}`;
+	const activityId = `activity-${(dependencies.now ?? Date.now)()}`;
+	const emitActivity = dependencies.emitActivity ?? emitActivityEntryDurable;
+	const source = role === "plan" ? "planning-agent" : "work-agent";
+	const emitTransition = (status, level, message, output) => emitActivity({
+		id: activityId,
+		source,
+		level,
+		status,
+		command,
+		message,
+		details: output,
+		output,
+		issueId
+	});
+	await emitTransition("accepted", "info", `Accepted ${command} for ${issueId} as activity ${activityId}.`);
+	let launch;
+	try {
+		launch = await launchPanCommandDetached({
+			agentSessionName,
+			issueId,
+			role,
+			workspacePath: process.cwd(),
+			args: argv,
+			activityId
+		}, dependencies);
+	} catch (error) {
+		const output = error instanceof Error ? error.message : String(error);
+		await emitTransition("failed", "error", `Activity ${activityId} failed to start ${command} for ${issueId}.`, output).catch(() => void 0);
+		throw error;
 	}
+	await emitTransition("running", "info", `Activity ${activityId} is running ${command} for ${issueId}.`).catch(() => void 0);
+	launch.completion.then(async () => {
+		const output = await readBoundedSpawnOutput(launch.spawnLogPath, launch.spawnLogStart).catch(() => "");
+		await emitTransition("completed", "success", `Activity ${activityId} completed ${command} for ${issueId}.`, output || `Command ${command} completed without output.`);
+	}, async (error) => {
+		const activityError = error;
+		const output = activityError.output?.trim() || activityError.message;
+		await emitTransition("failed", "error", `Activity ${activityId} failed ${command} for ${issueId}.`, output);
+	}).catch(() => void 0);
+	return {
+		kind: "activity",
+		status: "accepted",
+		command,
+		activityId: launch.activityId,
+		message: `Started ${command} for ${issueId}. Watch activity ${launch.activityId} or the ${issueId} issue view for progress.`
+	};
+}
+//#endregion
+//#region routes/agents/shared.ts
+init_paths();
+init_agents$1();
+init_activity_logger();
+init_tmux();
+const execAsync$2 = promisify(exec);
+const execFileAsync$2 = promisify(execFile);
+function buildPanStartArgs(input) {
+	return [
+		"start",
+		input.issueId,
+		"--local",
+		"--model",
+		input.model,
+		...input.harness ? ["--harness", input.harness] : [],
+		...input.allowHost ? ["--host", "--yes"] : [],
+		...input.offBook ? ["--off-book"] : []
+	];
+}
+/**
+* PAN-1985: detached-spawn helper for `pan <args>`, shared between the
+* standard work-spawn route and the restart-fresh route. The neutral launcher
+* owns process/log lifecycle; this route-compatible wrapper preserves the
+* original behavior by waiting for a successful child exit.
+*/
+const INTERNAL_STARTED_BY_TOKENS = new Set([
+	"operator:cli:pan-start",
+	"operator:cli:pan-plan",
+	"planning-auto-handoff",
+	"orphan-proposed-reconciler",
+	"workspace-rebuild-recovery",
+	"resume-agent"
+]);
+function resolveRequestedStartedBy(value, internalRequest = false) {
+	if (!internalRequest) return "operator:dashboard";
+	const token = typeof value === "string" ? value.trim() : "";
+	const flywheelRunId = token.startsWith("flywheel:") ? normalizeFlywheelRunId(token.slice(9)) : void 0;
+	if (flywheelRunId) return `flywheel:${flywheelRunId}`;
+	if (!INTERNAL_STARTED_BY_TOKENS.has(token)) throw new Error("Invalid internal startedBy provenance token.");
+	return token;
+}
+async function isInternalAgentRequest(request) {
+	const expected = await readInternalTokenForRequest();
+	if (!expected) return false;
+	return constantTimeTokenEqual(getHeaderFromMap(request.headers, INTERNAL_TOKEN_HEADER), expected);
+}
+async function spawnPanCommandDetached(input, dependencies = {}) {
+	const launch = await launchPanCommandDetached(input, dependencies);
+	await launch.completion;
+	return launch.activityId;
 }
 function emitStartAgentPhase(issueId, phase, status, reason, details = {}) {
 	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -1344,16 +1634,6 @@ async function validateAgentRuntimeEventAuth(request) {
 		}, { status: 403 })
 	};
 }
-async function appendAgentLifecycleLog(agentId, event, details = {}) {
-	const agentDir = join(homedir(), ".overdeck", "agents", agentId);
-	await mkdir(agentDir, { recursive: true });
-	const logLine = JSON.stringify({
-		ts: (/* @__PURE__ */ new Date()).toISOString(),
-		event,
-		...details
-	});
-	await appendFile(join(agentDir, "lifecycle.log"), logLine + "\n");
-}
 function updateRegistryForAgentStart(issueId, workspacePath, agentId) {
 	recordFeatureRegistryLifecycle({
 		issueId,
@@ -1434,8 +1714,10 @@ function buildStoppedAgentLifecycle(agentOrIssueId, state, runtimeData) {
 	const agentId = normalizeAgentId(agentOrIssueId);
 	const hasAgentState = true;
 	const hasLiveTmuxSession = false;
-	const hasSavedSession = !!runtimeData.claudeSessionId || !!getLatestSessionIdSync(agentId);
+	const sessionId = getLatestSessionIdSync(agentId) ?? runtimeData.claudeSessionId ?? null;
+	const hasSavedSession = !!sessionId;
 	const hasWorkspace = typeof state.workspace === "string" && state.workspace.length > 0;
+	const hasResumableTranscript = !sessionId || !!state.harness && state.harness !== "claude-code" || !state.workspace || claudeSessionTranscriptExists(state.workspace, sessionId);
 	const agentStatus = state.status || "unknown";
 	const runtime = runtimeData.state || "uninitialized";
 	const isCompleted = runtimeData.resolution === "completed";
@@ -1446,7 +1728,7 @@ function buildStoppedAgentLifecycle(agentOrIssueId, state, runtimeData) {
 	const isRunningButStuck = false;
 	const hasResumableBackingState = hasWorkspace && !isPlaceholder;
 	const isOrphaned = hasSavedSession && !hasResumableBackingState || !hasWorkspace || isPlaceholder;
-	const requiresSessionResetBeforeFreshStart = hasSavedSession && hasResumableBackingState && (isStopped || isCrashed);
+	const requiresSessionResetBeforeFreshStart = hasSavedSession && hasResumableTranscript && hasResumableBackingState && (isStopped || isCrashed);
 	let recommendedAction = "start";
 	let reason;
 	if (isOrphaned) {
@@ -1455,6 +1737,9 @@ function buildStoppedAgentLifecycle(agentOrIssueId, state, runtimeData) {
 	} else if (requiresSessionResetBeforeFreshStart) {
 		recommendedAction = "resume";
 		reason = `Agent ${agentId} has a resumable Claude session. Use 'pan resume ${agentOrIssueId}' to continue it, or 'pan start ${agentOrIssueId} --fresh' to start a new session (e.g. to switch model).`;
+	} else if (hasSavedSession && !hasResumableTranscript && hasResumableBackingState && (isStopped || isCrashed)) {
+		recommendedAction = "start";
+		reason = `Agent ${agentId} has a saved Claude session id but its transcript is missing on disk (jsonl-missing). Start Agent will create a fresh session in the existing workspace.`;
 	} else if (!hasSavedSession && isStopped) {
 		recommendedAction = "start";
 		reason = `Agent ${agentId} is stopped and has no saved Claude session. Start Agent will create a fresh session in the existing workspace.`;
@@ -1464,6 +1749,7 @@ function buildStoppedAgentLifecycle(agentOrIssueId, state, runtimeData) {
 		hasAgentState,
 		hasLiveTmuxSession,
 		hasSavedSession,
+		hasResumableTranscript,
 		hasWorkspace,
 		isPlaceholder,
 		isOrphaned,
@@ -1475,9 +1761,9 @@ function buildStoppedAgentLifecycle(agentOrIssueId, state, runtimeData) {
 		runtimeState: runtime,
 		agentStatus,
 		canStartFresh: !requiresSessionResetBeforeFreshStart || isOrphaned,
-		canResumeSession: hasSavedSession && hasResumableBackingState && (isStopped || isCrashed),
+		canResumeSession: hasSavedSession && hasResumableTranscript && hasResumableBackingState && (isStopped || isCrashed),
 		canRestartWithContext: hasWorkspace,
-		canResetSession: hasSavedSession && hasResumableBackingState,
+		canResetSession: hasSavedSession && hasResumableTranscript && hasResumableBackingState,
 		requiresSessionResetBeforeFreshStart,
 		recommendedAction,
 		reason
@@ -1537,13 +1823,14 @@ async function getWorkspaceLocation(issueId) {
 		}
 	} catch {}
 }
-async function getGitStatusAsync(workspacePath) {
+async function getGitStatusAsync(issueId, workspacePath) {
 	try {
 		if (!existsSync(workspacePath)) return null;
+		const repoDir = resolvePrimaryWorkspaceRepoDirSync(issueId, workspacePath);
 		const [branchResult, uncommittedResult, commitResult] = await Promise.all([
-			execAsync$2("git rev-parse --abbrev-ref HEAD 2>/dev/null || echo \"\"", { cwd: workspacePath }),
-			execAsync$2("git status --porcelain 2>/dev/null | wc -l", { cwd: workspacePath }),
-			execAsync$2("git log -1 --pretty=format:\"%s\" 2>/dev/null || echo \"\"", { cwd: workspacePath })
+			execAsync$2("git rev-parse --abbrev-ref HEAD 2>/dev/null || echo \"\"", { cwd: repoDir }),
+			execAsync$2("git status --porcelain 2>/dev/null | wc -l", { cwd: repoDir }),
+			execAsync$2("git log -1 --pretty=format:\"%s\" 2>/dev/null || echo \"\"", { cwd: repoDir })
 		]);
 		const branch = branchResult.stdout.trim();
 		const uncommitted = uncommittedResult.stdout.trim();
@@ -1700,6 +1987,22 @@ const getAgentPendingQuestions = getAgentPendingQuestions$1;
 //#region routes/agents/listing.ts
 init_agents$1();
 init_tmux();
+/**
+* PAN-3070 — the health status a live agent row reports.
+*
+* A live tmux session used to mean `healthy` unconditionally, so an agent frozen
+* for hours on an unanswered tool-permission prompt was reported
+* `status: healthy` / `resolution: working` while the Decisions surface
+* simultaneously showed it as needing the operator. Two surfaces answering "is
+* this agent stuck?" from different evidence, and this one stale.
+*
+* `warning` is the value `src/lib/health.ts` already reports for an agent
+* waiting on a human, and it stays inside the fleet-view status set, so a
+* blocked agent is flagged without disappearing from any existing list.
+*/
+function liveAgentHealthStatus(enrichment) {
+	return isBlockedOnPendingInput(enrichment) ? "warning" : "healthy";
+}
 const getAgentsRoute = HttpRouter.add("GET", "/api/agents", httpHandler(Effect.gen(function* () {
 	const now = Date.now();
 	if (agentsCache.data && now - agentsCache.timestamp < 5e3) return jsonResponse(agentsCache.data);
@@ -1833,7 +2136,7 @@ const getAgentsRoute = HttpRouter.add("GET", "/api/agents", httpHandler(Effect.g
 		const enrichment = await Effect.runPromise(computeAgentEnrichment(name, startedAt, hasActiveSpecialist));
 		const workspaceLocation = isRemote ? "remote" : await getWorkspaceLocation(issueId);
 		const workspace = isRemote && remoteState.vmName ? `/workspace (${String(remoteState.vmName)})` : state.workspace || null;
-		const gitStatus = workspace && !isRemote ? await getGitStatusAsync(workspace) : null;
+		const gitStatus = workspace && !isRemote ? await getGitStatusAsync(issueId, workspace) : null;
 		let contextPercent = null;
 		let initialContextPercent = null;
 		const agentCtxDir = join(homedir(), ".overdeck", "agents", name);
@@ -1843,12 +2146,13 @@ const getAgentsRoute = HttpRouter.add("GET", "/api/agents", httpHandler(Effect.g
 			const initCtxFile = join(agentCtxDir, "initial-context-pct");
 			initialContextPercent = parseInt((await readFile(initCtxFile, "utf-8").catch(() => "")).trim(), 10) || null;
 		} catch {}
+		const blockedOnPendingInput = isBlockedOnPendingInput(enrichment);
 		return {
 			id: name,
 			issueId,
 			runtime: state.harness ?? "claude-code",
 			model: state.model || (isPlanning ? "opus" : "sonnet"),
-			status: "healthy",
+			status: liveAgentHealthStatus(enrichment),
 			startedAt,
 			...buildAgentGateFailureSnapshot(state),
 			killCount: health.killCount || 0,
@@ -1865,7 +2169,7 @@ const getAgentsRoute = HttpRouter.add("GET", "/api/agents", httpHandler(Effect.g
 			pendingInputCount: enrichment.pendingInputCount,
 			pendingInputKinds: enrichment.pendingInputKinds,
 			pendingAskUserQuestion: enrichment.pendingAskUserQuestion,
-			resolution: runtimeData?.resolution || enrichment.resolution || "working",
+			resolution: blockedOnPendingInput ? "needs_input" : runtimeData?.resolution || enrichment.resolution || "working",
 			resolutionCount: runtimeData?.resolutionCount || enrichment.resolutionCount || 0,
 			contextPercent,
 			initialContextPercent,
@@ -1951,7 +2255,7 @@ const getAgentOutputRoute = HttpRouter.add("GET", "/api/agents/:id/output", http
 			} catch {}
 			let stdout;
 			if (isRemote && vmName) {
-				const { getRemoteAgentOutput } = await import("./remote-agents-CA3Ihlxj.js");
+				const { getRemoteAgentOutput } = await import("./remote-agents-CLZB3Coc.js");
 				stdout = await getRemoteAgentOutput(id, vmName, parseInt(String(lines), 10) || 100);
 			} else stdout = await Effect.runPromise(capturePane(id, parseInt(String(lines), 10) || 100));
 			if (!stdout || stdout.trim() === "" || stdout.trim() === "Session not found") {
@@ -2104,6 +2408,352 @@ const getAgentTimelineRoute = HttpRouter.add("GET", "/api/agents/:id/timeline",
 	return jsonResponse({ timeline: events.slice(0, limit) });
 })));
 //#endregion
+//#region ../../lib/composer-commands/confirmations.ts
+const COMPOSER_CONFIRMATION_TTL_MS = 300 * 1e3;
+function composerCommandConfirmationFromBody(body) {
+	if (!("confirmationNonce" in body) && !("confirmationText" in body)) return void 0;
+	return {
+		nonce: body["confirmationNonce"],
+		typedText: body["confirmationText"]
+	};
+}
+var ComposerCommandConfirmationError = class extends Error {
+	code = "invalid-confirmation";
+	constructor(message) {
+		super(message);
+		this.name = "ComposerCommandConfirmationError";
+	}
+};
+function createComposerConfirmationStore(dependencies = {}) {
+	const entries = /* @__PURE__ */ new Map();
+	const now = dependencies.now ?? Date.now;
+	const createNonce = dependencies.createNonce ?? (() => randomBytes(24).toString("base64url"));
+	function pruneExpired() {
+		const currentTime = now();
+		for (const [nonce, entry] of entries) if (entry.expiresAt <= currentTime) entries.delete(nonce);
+	}
+	return {
+		issue({ target, argv, policy, display }) {
+			if (policy.safety === "destructive" && !policy.typedConfirmation) throw new Error(`Destructive composer policy for ${display} must define typedConfirmation.`);
+			pruneExpired();
+			const nonce = createNonce();
+			entries.set(nonce, {
+				targetKind: target.kind,
+				targetId: target.id,
+				argv: [...argv],
+				safety: policy.safety,
+				typedText: policy.typedConfirmation,
+				expiresAt: now() + COMPOSER_CONFIRMATION_TTL_MS
+			});
+			return {
+				kind: "confirmation",
+				status: "confirmation_required",
+				nonce,
+				consequence: policy.confirmationText ?? `Running ${display} requires confirmation before Overdeck continues.`,
+				...policy.typedConfirmation ? { typedText: policy.typedConfirmation } : {}
+			};
+		},
+		consume({ target, argv, policy, confirmation }) {
+			if (typeof confirmation.nonce !== "string") throw new ComposerCommandConfirmationError("A valid confirmation nonce is required before this command can run.");
+			const entry = entries.get(confirmation.nonce);
+			entries.delete(confirmation.nonce);
+			if (!entry) throw new ComposerCommandConfirmationError("This command confirmation is missing, invalid, or has already been used. Request a new confirmation and try again.");
+			if (entry.expiresAt <= now()) throw new ComposerCommandConfirmationError("This command confirmation has expired. Request a new confirmation and try again.");
+			if (entry.targetKind !== target.kind || entry.targetId !== target.id || entry.safety !== policy.safety || !sameArgv(entry.argv, argv)) throw new ComposerCommandConfirmationError("This command confirmation does not match the current target or command. Request a new confirmation and try again.");
+			if (policy.safety === "destructive" && (typeof confirmation.typedText !== "string" || confirmation.typedText !== entry.typedText)) throw new ComposerCommandConfirmationError(`Type "${entry.typedText ?? ""}" exactly to confirm this destructive command.`);
+		}
+	};
+}
+function sameArgv(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+const composerConfirmationStore = createComposerConfirmationStore();
+//#endregion
+//#region ../../lib/composer-commands/parser.ts
+var ComposerCommandParseError = class extends Error {
+	constructor(code, message, token, expected) {
+		super(message);
+		this.code = code;
+		this.token = token;
+		this.expected = expected;
+		this.name = "ComposerCommandParseError";
+	}
+};
+const FORBIDDEN_TOKEN = /\$\(|[;|&<>`]/;
+function expectedSyntax(entry) {
+	const args = entry.args.map((argument) => {
+		const name = argument.variadic ? `${argument.name}...` : argument.name;
+		return argument.required ? `<${name}>` : `[${name}]`;
+	});
+	const options = entry.options.length > 0 ? ["[options]"] : [];
+	return [
+		entry.display,
+		...args,
+		...options
+	].join(" ");
+}
+function tokenize(input) {
+	const tokens = [];
+	let current = "";
+	let quote = null;
+	let escaped = false;
+	const pushCurrent = () => {
+		if (current.length === 0) return;
+		tokens.push(current);
+		current = "";
+	};
+	for (const character of input) {
+		if (escaped) {
+			current += character;
+			escaped = false;
+			continue;
+		}
+		if (character === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (quote !== null) {
+			if (character === quote) quote = null;
+			else current += character;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (/\s/.test(character)) {
+			pushCurrent();
+			continue;
+		}
+		current += character;
+	}
+	if (escaped) current += "\\";
+	if (quote !== null) throw new ComposerCommandParseError("missing-argument", `Unclosed ${quote} quote. Close the quoted value before submitting the command.`, quote, `a closing ${quote}`);
+	pushCurrent();
+	return tokens;
+}
+function aliasesForPath(entry) {
+	let candidates = [[]];
+	for (let index = 0; index < entry.path.length; index += 1) {
+		const prefix = entry.path.slice(0, index + 1);
+		const prefixEntry = COMPOSER_COMMAND_MANIFEST.find((candidate) => candidate.path.length === prefix.length && candidate.path.every((part, partIndex) => part === prefix[partIndex]));
+		const names = [entry.path[index], ...prefixEntry?.aliases ?? []];
+		candidates = candidates.flatMap((candidate) => names.map((name) => [...candidate, name]));
+	}
+	return candidates;
+}
+function resolveEntry(tokens) {
+	const match = COMPOSER_COMMAND_MANIFEST.flatMap((entry) => aliasesForPath(entry).filter((path) => path.every((part, index) => tokens[index] === part)).map((path) => ({
+		entry,
+		pathLength: path.length
+	}))).sort((left, right) => right.pathLength - left.pathLength)[0];
+	if (match) return match;
+	const token = tokens[0] ?? "";
+	throw new ComposerCommandParseError("unknown-command", token ? `Unknown Overdeck command "${token}". Type /pan to list available commands.` : "Missing an Overdeck command after /pan. Type /pan to list available commands.", token, "/pan <command>");
+}
+function optionDefinitions(entry) {
+	const definitions = /* @__PURE__ */ new Map();
+	for (const option of entry.options) {
+		const flags = option.flags.split(/[ ,|]+/).filter((part) => part.startsWith("-"));
+		const canonicalFlag = flags.find((flag) => flag.startsWith("--")) ?? flags[0];
+		for (const flag of flags) definitions.set(flag, {
+			option,
+			canonicalFlag
+		});
+	}
+	return definitions;
+}
+function splitFlag(token) {
+	const separator = token.indexOf("=");
+	if (separator === -1) return { flag: token };
+	return {
+		flag: token.slice(0, separator),
+		inlineValue: token.slice(separator + 1)
+	};
+}
+function parseOverdeckComposerCommand(message) {
+	if (!/^\/pan(?:\s|$)/.test(message)) return null;
+	const forbidden = message.match(FORBIDDEN_TOKEN)?.[0];
+	if (forbidden !== void 0) throw new ComposerCommandParseError("forbidden-token", `The token "${forbidden}" is not allowed in /pan commands. Run compound shell syntax in a terminal instead.`, forbidden, "plain arguments without shell operators");
+	const tokens = tokenize(message.slice(4).trim());
+	const { entry, pathLength } = resolveEntry(tokens);
+	const remaining = tokens.slice(pathLength);
+	const definitions = optionDefinitions(entry);
+	const positionals = [];
+	const flags = [];
+	for (let index = 0; index < remaining.length; index += 1) {
+		const token = remaining[index];
+		if (!token.startsWith("-")) {
+			positionals.push(token);
+			continue;
+		}
+		const { flag, inlineValue } = splitFlag(token);
+		const definition = definitions.get(flag);
+		if (definition === void 0) throw new ComposerCommandParseError("unknown-flag", `Unknown flag "${flag}" for ${entry.display}. Expected syntax: ${expectedSyntax(entry)}.`, flag, expectedSyntax(entry));
+		flags.push(definition.canonicalFlag);
+		if (definition.option.valueHint === null) {
+			if (inlineValue !== void 0) throw new ComposerCommandParseError("unknown-flag", `Flag "${flag}" does not accept a value. Expected syntax: ${expectedSyntax(entry)}.`, token, expectedSyntax(entry));
+			continue;
+		}
+		if (inlineValue !== void 0) {
+			if (inlineValue.length === 0 && definition.option.required) throw new ComposerCommandParseError("missing-argument", `Flag "${flag}" requires <${definition.option.valueHint}>. Expected syntax: ${expectedSyntax(entry)}.`, flag, expectedSyntax(entry));
+			if (inlineValue.length > 0) flags.push(inlineValue);
+			continue;
+		}
+		const next = remaining[index + 1];
+		const nextIsFlag = next?.startsWith("-") === true;
+		if (definition.option.required && (next === void 0 || nextIsFlag)) throw new ComposerCommandParseError("missing-argument", `Flag "${flag}" requires <${definition.option.valueHint}>. Expected syntax: ${expectedSyntax(entry)}.`, flag, expectedSyntax(entry));
+		if (next !== void 0 && !nextIsFlag) {
+			flags.push(next);
+			index += 1;
+		}
+	}
+	if (!(entry.args.at(-1)?.variadic === true) && positionals.length > entry.args.length) {
+		const token = positionals[entry.args.length];
+		throw new ComposerCommandParseError("unknown-command", `Unexpected token "${token}" for ${entry.display}. Expected syntax: ${expectedSyntax(entry)}.`, token, expectedSyntax(entry));
+	}
+	const missing = entry.args.find((argument, index) => argument.required && positionals[index] === void 0);
+	if (missing !== void 0) throw new ComposerCommandParseError("missing-argument", `Missing required argument <${missing.name}> for ${entry.display}. Expected syntax: ${expectedSyntax(entry)}.`, missing.name, expectedSyntax(entry));
+	return {
+		entry,
+		argv: [
+			...entry.path,
+			...positionals,
+			...flags
+		]
+	};
+}
+//#endregion
+//#region ../../lib/composer-commands/policy.ts
+init_src();
+const COMPOSER_COMMAND_POLICIES = {
+	start: {
+		mode: "detached",
+		safety: "safe"
+	},
+	plan: {
+		mode: "detached",
+		safety: "safe"
+	},
+	show: {
+		mode: "captured",
+		safety: "safe"
+	},
+	status: {
+		mode: "captured",
+		safety: "safe"
+	},
+	tell: {
+		mode: "captured",
+		safety: "safe"
+	},
+	handoff: {
+		mode: "ui",
+		safety: "dialog",
+		uiAction: "handoff",
+		confirmationText: "This opens the handoff dialog for the selected conversation. Review the destination and focus before continuing."
+	},
+	fork: {
+		mode: "ui",
+		safety: "dialog",
+		uiAction: "fork",
+		confirmationText: "This opens the fork dialog for the selected conversation. Review the fork mode and destination before continuing."
+	}
+};
+const DEFAULT_POLICY = {
+	mode: "terminal-only",
+	safety: "safe"
+};
+function assertPolicyOverlayIntegrity(policies = COMPOSER_COMMAND_POLICIES, manifest = COMPOSER_COMMAND_MANIFEST) {
+	for (const path of Object.keys(policies)) {
+		const matches = manifest.filter((entry) => entry.path.join(" ") === path);
+		if (matches.length !== 1) throw new Error(`Composer command policy path "${path}" must match exactly one manifest entry; found ${matches.length}.`);
+	}
+}
+function resolvePolicy(path) {
+	return COMPOSER_COMMAND_POLICIES[path.join(" ")] ?? DEFAULT_POLICY;
+}
+assertPolicyOverlayIntegrity();
+//#endregion
+//#region ../../lib/composer-commands/router.ts
+const UI_COMMAND_PATTERNS = [{
+	action: "handoff",
+	pattern: /^\/(?:handoff|pan-handoff|pan\s+handoff)(?:\s+([\s\S]+))?$/i
+}, {
+	action: "fork",
+	pattern: /^\/pan\s+fork(?:\s+([\s\S]+))?$/i
+}];
+function isComposerCommandMessage(message) {
+	return UI_COMMAND_PATTERNS.some(({ pattern }) => pattern.test(message)) || /^\/pan(?:\s|$)/.test(message);
+}
+async function handleComposerCommandMessage({ message, target, confirmation }, dependencies = {}) {
+	for (const { action, pattern } of UI_COMMAND_PATTERNS) {
+		const match = message.match(pattern);
+		if (match) {
+			const parsed = parseOverdeckComposerCommand(`/pan ${action}`);
+			const focus = match[1]?.trim();
+			if (focus) parsed.argv.push(focus);
+			return handleComposerCommand({
+				parsed,
+				target,
+				confirmation
+			}, dependencies);
+		}
+	}
+	const parsed = parseOverdeckComposerCommand(message);
+	if (parsed === null) return null;
+	return handleComposerCommand({
+		parsed,
+		target,
+		confirmation
+	}, dependencies);
+}
+async function handleComposerCommand({ parsed, target, confirmation }, dependencies = {}) {
+	const policy = (dependencies.resolvePolicy ?? resolvePolicy)(parsed.entry.path);
+	if (policy.safety !== "safe") {
+		const confirmationStore = dependencies.confirmationStore ?? composerConfirmationStore;
+		if (confirmation === void 0) return confirmationStore.issue({
+			target,
+			argv: parsed.argv,
+			policy,
+			display: parsed.entry.display
+		});
+		confirmationStore.consume({
+			target,
+			argv: parsed.argv,
+			policy,
+			confirmation
+		});
+	}
+	if (policy.mode === "captured") return runCapturedCommand(parsed.argv);
+	if (policy.mode === "detached") return runDetachedCommand(parsed.argv);
+	if (policy.mode === "ui" && policy.uiAction) return uiCommandResult(policy.uiAction, parsed.argv.slice(parsed.entry.path.length).join(" ") || void 0);
+	if (policy.mode === "terminal-only") return {
+		kind: "terminal-only",
+		status: "rejected",
+		message: `${parsed.entry.display} must run in a terminal. Composer execution has not been enabled for this command.`
+	};
+	return missingExecutorResult(parsed.entry.display, policy);
+}
+function uiCommandResult(action, focus) {
+	return {
+		kind: "ui",
+		status: "requires_ui",
+		action,
+		args: focus ? { focus } : {}
+	};
+}
+function missingExecutorResult(display, policy) {
+	return {
+		kind: "terminal-only",
+		status: "rejected",
+		message: `${display} is recognized as a ${policy.mode} command, but its composer executor is not registered yet. Run it in a terminal for now.`
+	};
+}
+function composerCommandResultHttpStatus(result) {
+	return result.kind === "terminal-only" ? 422 : 200;
+}
+//#endregion
 //#region routes/agents/messaging.ts
 init_agents$1();
 async function sendAgentMessage(id, message) {
@@ -2119,6 +2769,55 @@ async function sendAgentMessage(id, message) {
 		remote: true
 	} : { success: true };
 }
+async function handleAgentMessage(id, message, confirmation) {
+	try {
+		if (isComposerCommandMessage(message)) {
+			let agentState;
+			try {
+				agentState = await Effect.runPromise(getAgentState(id));
+			} catch {
+				return jsonResponse({
+					error: `Failed to resolve agent target: ${id}`,
+					code: "agent-resolution-failed"
+				}, { status: 503 });
+			}
+			if (!agentState) return jsonResponse({
+				error: `Agent not found: ${id}`,
+				code: "agent-not-found"
+			}, { status: 404 });
+			if (!agentState.harness) return jsonResponse({
+				error: `Agent harness could not be resolved: ${id}`,
+				code: "agent-harness-unresolved"
+			}, { status: 503 });
+			const result = await handleComposerCommandMessage({
+				message,
+				confirmation,
+				target: {
+					kind: "agent",
+					id,
+					harness: agentState.harness,
+					cwd: agentState.workspace,
+					issueId: agentState.issueId
+				}
+			});
+			if (result !== null) return jsonResponse(result, { status: composerCommandResultHttpStatus(result) });
+		}
+	} catch (error) {
+		if (error instanceof ComposerCommandConfirmationError) return jsonResponse({
+			error: error.message,
+			code: error.code
+		}, { status: 422 });
+		if (!(error instanceof ComposerCommandParseError)) throw error;
+		const status = error.code === "unknown-command" ? 404 : error.code === "unknown-flag" ? 422 : 400;
+		return jsonResponse({
+			error: error.message,
+			code: error.code,
+			token: error.token,
+			expected: error.expected
+		}, { status });
+	}
+	return jsonResponse(await sendAgentMessage(id, message));
+}
 function validateAgentMessageOrigin(request) {
 	const originCheck = validateOrigin(request);
 	if (!originCheck.ok) return {
@@ -2135,9 +2834,10 @@ function postAgentMessageLikeRoute(path) {
 		const originCheck = validateAgentMessageOrigin(yield* HttpServerRequest.HttpServerRequest);
 		if (!originCheck.ok) return originCheck.response;
 		const id = (yield* HttpRouter.params)["id"] ?? "";
-		const { message } = yield* readJsonBody$1;
+		const body = yield* readJsonBody$1;
+		const { message } = body;
 		if (!message) return jsonResponse({ error: "Message required" }, { status: 400 });
-		return yield* Effect.promise(() => sendAgentMessage(id, message)).pipe(Effect.map((result) => jsonResponse(result)));
+		return yield* Effect.promise(() => handleAgentMessage(id, message, composerCommandConfirmationFromBody(body)));
 	})));
 }
 const postAgentMessageRoute = postAgentMessageLikeRoute("/api/agents/:id/message");
@@ -2386,7 +3086,7 @@ async function cleanupConversationAttachments(name) {
 *  sessions that the lifecycle poller missed. */
 async function cleanupOrphanedConversationAttachments() {
 	try {
-		const { listConversations } = await import("./conversations-CAsJF9kh.js");
+		const { listConversations } = await import("./conversations-BKDVpB-3.js");
 		const convNames = new Set(listConversations().map((c) => c.name));
 		const root = getConversationAttachmentsRoot();
 		await runInBatches((await readdir(root, { withFileTypes: true })).filter((entry) => entry.isDirectory() && !convNames.has(entry.name)).map((entry) => join(root, entry.name)), 10, (path) => rm(path, {
@@ -2811,6 +3511,21 @@ async function handleConversationSwitchModel(name, body) {
 function getPtySupervisorSocketPath(agentId) {
 	return join(getOverdeckHome(), "sockets", `pty-${agentId}.sock`);
 }
+/**
+* Pull the supervisor's own failure out of the tmux pane it died in.
+*
+* A supervisor that cannot load its native node-pty exits instantly with an
+* ERR_MODULE_NOT_FOUND on stderr; all the spawn path sees is the socket that
+* never appeared. Reporting only the timeout hides the actual cause and sent
+* an operator hunting the memory governor instead (PAN-3172).
+*/
+function extractSupervisorFailure(paneText) {
+	const lines = paneText.split("\n").map((line) => line.trim()).filter(Boolean);
+	const errors = lines.filter((line) => /error|cannot find|ERR_[A-Z_]+|pty-supervisor:/i.test(line));
+	const chosen = (errors.length > 0 ? errors : lines).slice(-3);
+	if (chosen.length === 0) return null;
+	return chosen.join(" | ").slice(0, 500);
+}
 async function waitForPtySupervisorSocket(agentId, timeoutMs = PTY_SUPERVISOR_SOCKET_WAIT_MS) {
 	const socketPath = getPtySupervisorSocketPath(agentId);
 	const start = Date.now();
@@ -2820,7 +3535,8 @@ async function waitForPtySupervisorSocket(agentId, timeoutMs = PTY_SUPERVISOR_SO
 		} catch {}
 		await new Promise((r) => setTimeout(r, 250));
 	}
-	throw new Error(`Timed out waiting for PTY supervisor socket ${socketPath}`);
+	const failure = extractSupervisorFailure(await capturePaneText(agentId, 40));
+	throw new Error(`Timed out waiting for PTY supervisor socket ${socketPath}` + (failure ? ` — supervisor output: ${failure}` : ""));
 }
 async function extractModelFromSessionFile(sessionFile) {
 	try {
@@ -2980,7 +3696,7 @@ async function spawnConversationSession(tmuxSession, cwd, claudeSessionId, model
 			const codexApprovalPolicy = codexPermMode === "full-access" ? "never" : "on-request";
 			const codexSandboxMode = codexPermMode === "full-access" ? "danger-full-access" : codexPermMode === "read-only" ? "read-only" : "workspace-write";
 			const codexApprovalsReviewer = codexPermMode === "auto-review" ? "auto_review" : void 0;
-			const { initCodexHome, extractThreadIdFromRollout } = await import("./codex-GcHuUF-k.js");
+			const { initCodexHome, extractThreadIdFromRollout } = await import("./codex-o8FJwzmy.js");
 			initCodexHome(codexHome, {
 				trustedDir: cwd,
 				approvalPolicy: codexApprovalPolicy,
@@ -3049,7 +3765,7 @@ async function spawnConversationSession(tmuxSession, cwd, claudeSessionId, model
 	} catch {}
 	console.log(`[claude-invoke] purpose=conversation-session | model=${model || "default"} | source=conversations.ts:spawnConversationSession | session=${tmuxSession} | resume=${resume} | command="${runtimeCommand}"`);
 	try {
-		const { preTrustDirectory } = await import("./workspace-manager-CWT55qeI.js");
+		const { preTrustDirectory } = await import("./workspace-manager-C1F3XsnS.js");
 		preTrustDirectory(cwd);
 	} catch {}
 	try {
@@ -3066,7 +3782,7 @@ async function spawnConversationSession(tmuxSession, cwd, claudeSessionId, model
 		const codexHomeDir = codexFields.codexHome;
 		(async () => {
 			try {
-				const { waitForCodexRollout, extractThreadIdFromRollout, writeThreadId } = await import("./codex-GcHuUF-k.js");
+				const { waitForCodexRollout, extractThreadIdFromRollout, writeThreadId } = await import("./codex-o8FJwzmy.js");
 				const rollout = await waitForCodexRollout(codexHomeDir, 12e4);
 				if (rollout) {
 					const threadId = extractThreadIdFromRollout(rollout);
@@ -3208,6 +3924,7 @@ async function handleConversationResume(name, body, deps) {
 			});
 		}
 		const oldSessionId = conv.claudeSessionId;
+		const resumeCause = conv.status === "ended" ? "operator" : "system";
 		const harness = conv.harness ?? "claude-code";
 		const modelChanged = !!model && model !== conv.model;
 		if (!await validateCwdContainment(conv.cwd)) return jsonResponse({ error: "Invalid cwd" }, { status: 400 });
@@ -3226,6 +3943,13 @@ async function handleConversationResume(name, body, deps) {
 			await spawnConversationSession(conv.tmuxSession, conv.cwd, oldSessionId ?? randomUUID$1(), model, effort, conv.issueId ?? void 0, canResume, harness);
 			await waitForTmuxSession(conv.tmuxSession);
 			await waitForConversationRuntimeReady(conv.tmuxSession, harness, "respawn");
+			const resumeGatePane = await capturePaneText(conv.tmuxSession, 90).catch(() => "");
+			if (resumeGatePane && paneHasBlockingChoiceMenu(resumeGatePane)) console.log(`[conversations] resume contract skipped for ${name} — the harness is showing a blocking choice menu; the operator answers it`);
+			else try {
+				await deliverAgentMessage(conv.tmuxSession, `CONVERSATION RESUME: ${buildResumeContract(resumeCause)}`, "conversation-resume", resolveConversationDeliveryMethod(conv));
+			} catch (err) {
+				console.error(`[conversations] resume contract delivery failed for ${name}:`, err instanceof Error ? err.message : String(err));
+			}
 			markConversationActive(name);
 			return jsonResponse({
 				...conv,
@@ -3957,7 +4681,7 @@ const postInternalAgentPermissionRequestRoute = HttpRouter.add("POST", "/api/int
 		error: "missing agent id"
 	}, { status: 400 });
 	const request = yield* HttpServerRequest.HttpServerRequest;
-	const { INTERNAL_TOKEN_HEADER, getInternalTokenSync } = yield* Effect.promise(() => import("./internal-token-BrcU6qfe.js"));
+	const { INTERNAL_TOKEN_HEADER, getInternalTokenSync } = yield* Effect.promise(() => import("./internal-token-Ias7N8Kg.js"));
 	const expected = getInternalTokenSync();
 	if (!expected) return jsonResponse({
 		ok: false,
@@ -4093,6 +4817,7 @@ const postAgentPermissionResponseRoute = HttpRouter.add("POST", "/api/agents/:id
 * pollers (PAN-1134). Extracted from routes/agents.ts so Pi event polling
 * can reuse bodyToEvent without importing a heavy route module.
 */
+init_src();
 /**
 * Translate a decoded body into an unsigned DomainEvent (no sequence yet).
 * Returns null if the body doesn't map to a runtime event.
@@ -4213,6 +4938,25 @@ const bodyToEvent = (agentId, body, timestamp) => {
 				contextSaturatedAt: source["contextSaturatedAt"]
 			}
 		};
+		case "linear_mcp_auth_required": return {
+			type: "linear_mcp_auth.required",
+			timestamp,
+			payload: {
+				agentId,
+				issueId: source["issueId"] ?? null,
+				authUrl: source["authUrl"] ?? null,
+				expiresAt: source["expiresAt"] ?? null
+			}
+		};
+		case "linear_mcp_auth_healthy": return {
+			type: "linear_mcp_auth.healthy",
+			timestamp,
+			payload: {
+				agentId,
+				issueId: source["issueId"] ?? null,
+				source: "hook"
+			}
+		};
 		default: return null;
 	}
 };
@@ -4224,7 +4968,7 @@ const getAgentHealthHistoryRoute = HttpRouter.add("GET", "/api/agents/:id/health
 	const request = yield* HttpServerRequest.HttpServerRequest;
 	const urlOpt = HttpServerRequest.toURL(request);
 	const hours = Option.isSome(urlOpt) ? urlOpt.value.searchParams.get("hours") ?? "24" : "24";
-	const { getHealthHistory } = yield* Effect.promise(() => import("./health-events-BDOHby5Q.js"));
+	const { getHealthHistory } = yield* Effect.promise(() => import("./health-events-2Z6Wa9SM.js"));
 	const endTime = /* @__PURE__ */ new Date();
 	const startTime = /* @__PURE__ */ new Date(endTime.getTime() - parseInt(hours) * 60 * 60 * 1e3);
 	const events = getHealthHistory(id, startTime.toISOString(), endTime.toISOString());
@@ -4237,9 +4981,18 @@ const getAgentHealthHistoryRoute = HttpRouter.add("GET", "/api/agents/:id/health
 })));
 function emitAgentRuntimeEvent(id, body, timestamp) {
 	return Effect.gen(function* () {
+		let eventBody = body;
+		if (body["kind"] === "linear_mcp_auth_required" || body["kind"] === "linear_mcp_auth_healthy") {
+			const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-C63p_ftq.js"));
+			const snapshot = yield* (yield* AgentStateService).get(id);
+			eventBody = {
+				...body,
+				issueId: snapshot?.currentIssue ?? null
+			};
+		}
 		let raw;
 		try {
-			raw = bodyToEvent(id, body, timestamp);
+			raw = bodyToEvent(id, eventBody, timestamp);
 		} catch (error) {
 			return {
 				ok: false,
@@ -4265,7 +5018,7 @@ function emitAgentRuntimeEvent(id, body, timestamp) {
 				detail: String(decoded.failure)
 			}, { status: 400 })
 		};
-		const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-D5UGKIJL.js"));
+		const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-C63p_ftq.js"));
 		yield* (yield* AgentStateService).emit(decoded.success);
 		return {
 			ok: true,
@@ -4347,7 +5100,7 @@ const getAgentRuntimeRoute = HttpRouter.add("GET", "/api/agents/:id/runtime", ht
 		success: false,
 		error: "missing agent id"
 	}, { status: 400 });
-	const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-D5UGKIJL.js"));
+	const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-C63p_ftq.js"));
 	const snapshot = yield* (yield* AgentStateService).get(id);
 	if (!snapshot) return jsonResponse({
 		success: false,
@@ -4532,8 +5285,8 @@ function createAgentStopHandler(lifecycleEvent) {
 		yield* stopAgent(id);
 		if (stateBeforeStop?.issueId) yield* Effect.promise(async () => {
 			try {
-				const { resolveProjectFromIssueSync } = await import("./projects-vjjcmiN8.js");
-				const { findWorkspacePath } = await import("./archive-planning-BZDgzoEj.js");
+				const { resolveProjectFromIssueSync } = await import("./projects-_n3Zui6K.js");
+				const { findWorkspacePath } = await import("./archive-planning-B2XplFzT.js");
 				const issueLower = stateBeforeStop.issueId.toLowerCase();
 				const workspacePath = findWorkspacePath(resolveProjectFromIssueSync(stateBeforeStop.issueId)?.projectPath ?? process.cwd(), issueLower);
 				if (workspacePath) {
@@ -4673,7 +5426,7 @@ const postAgentUnpauseRoute = HttpRouter.add("POST", "/api/agents/:id/unpause",
 	if ((yield* getWorkAgentLifecycleState(id)).canResumeSession && updatedState.troubled !== true) {
 		resumeTriggered = true;
 		yield* Effect.promise(() => appendAgentLifecycleLog(id, "agent.unpause_immediate_resume_triggered"));
-		import("./resume-BFv1PGpA.js").then(({ resumeAgent }) => resumeAgent(id)).then((result) => {
+		import("./resume-mOREjlYu.js").then(({ resumeAgent }) => resumeAgent(id)).then((result) => {
 			if (!result.success) console.warn(`[agents] immediate resume after unpause failed for ${id}: ${result.error}`);
 		}).catch((err) => console.warn(`[agents] immediate resume after unpause errored for ${id}:`, err));
 	}
@@ -5960,18 +6713,72 @@ const writeAutoStartXBrief = (projectRoot, workspacePath, issue) => Effect.tryPr
 //#region routes/agents/spawn-helpers.ts
 init_child_env();
 init_agents$1();
+function buildAgentStartPlaceholder(input) {
+	return {
+		state: {
+			id: input.agentSessionName,
+			issueId: input.issueId,
+			workspace: input.workspacePath,
+			role: input.role,
+			...input.effectiveHarness ? { harness: input.effectiveHarness } : {},
+			model: "pending-work-spawn",
+			status: "starting",
+			startedAt: input.startedAt,
+			startedBy: input.startedBy,
+			hostOverride: input.allowHost || void 0
+		},
+		event: {
+			type: "agent.started",
+			timestamp: input.startedAt,
+			payload: {
+				agentId: input.agentSessionName,
+				issueId: input.issueId,
+				agent: {
+					id: input.agentSessionName,
+					issueId: input.issueId,
+					workspace: input.workspacePath,
+					status: "starting",
+					startedAt: input.startedAt,
+					role: input.role,
+					startedBy: input.startedBy,
+					...input.effectiveHarness ? { runtime: input.effectiveHarness } : {}
+				}
+			}
+		}
+	};
+}
+function buildContainerStartState(input) {
+	return {
+		id: input.agentSessionName,
+		issueId: input.issueId,
+		...input.effectiveHarness ? { harness: input.effectiveHarness } : {},
+		model: "pending-container-start",
+		status: input.status,
+		startedAt: input.startedAt,
+		workspace: input.workspacePath,
+		role: input.role,
+		startedBy: input.startedBy,
+		hostOverride: input.allowHost || void 0
+	};
+}
+async function requestWorkStartAfterContainers(input) {
+	const activityId = await input.spawnPanCommand(input.args, input.workspacePath);
+	await input.markWorkStartAccepted();
+	await input.updateIssueStatus();
+	return activityId;
+}
 function handleRemoteAgentSpawn(input) {
 	return Effect.gen(function* () {
-		const { issueId, workspacePath, workspaceMetadata, spawnModel, projectPath, spawnGuardrails, lifecycle } = input;
-		const { spawnRemoteAgent, checkRemoteSpendCap } = yield* Effect.promise(() => import("./remote-agents-CA3Ihlxj.js"));
-		const { createFlyProviderFromConfig } = yield* Effect.promise(() => import("./remote-ChgimyYa.js"));
-		const { loadConfigSync: loadPanConfig } = yield* Effect.promise(() => import("./config-DzV30TOm.js"));
+		const { issueId, workspacePath, workspaceMetadata, spawnModel, startedBy, autoSpawnConsentRequired, projectPath, spawnGuardrails, lifecycle } = input;
+		const { spawnRemoteAgent, checkRemoteSpendCap } = yield* Effect.promise(() => import("./remote-agents-CLZB3Coc.js"));
+		const { createFlyProviderFromConfig } = yield* Effect.promise(() => import("./remote-CUhyqjXk.js"));
+		const { loadConfigSync: loadPanConfig } = yield* Effect.promise(() => import("./config-CL3Gyvja.js"));
 		const panConfig = loadPanConfig();
 		const spendCap = checkRemoteSpendCap(panConfig);
 		if (!spendCap.allowed) return jsonResponse({ error: spendCap.message }, { status: 429 });
 		const fly = createFlyProviderFromConfig(panConfig.remote);
 		yield* Effect.promise(() => fly.syncAllCredentials(workspaceMetadata.vmName));
-		const { buildWorkAgentPrompt, getTrackerContext } = yield* Effect.promise(() => import("./work-agent-prompt-Du8Vh2aJ.js"));
+		const { buildWorkAgentPrompt, getTrackerContext } = yield* Effect.promise(() => import("./work-agent-prompt-ByrPAzOy.js"));
 		const trackerContext = yield* Effect.promise(() => getTrackerContext(issueId, workspacePath));
 		const agentPrompt = yield* Effect.promise(() => buildWorkAgentPrompt({
 			issueId,
@@ -5989,6 +6796,8 @@ function handleRemoteAgentSpawn(input) {
 			workspace: workspaceMetadata,
 			prompt: agentPrompt,
 			model: spawnModel,
+			startedBy,
+			autoSpawnConsentRequired,
 			tier: fly.getResiliencyTier()
 		}));
 		yield* saveAgentState({
@@ -5999,7 +6808,8 @@ function handleRemoteAgentSpawn(input) {
 			model: spawnModel,
 			status: "starting",
 			startedAt: state.startedAt,
-			harness: "claude-code"
+			harness: "claude-code",
+			startedBy
 		});
 		updateRegistryForAgentStart(state.issueId, workspacePath, state.id);
 		yield* Effect.promise(() => Effect.runPromise(lifecycle.transitionTo(issueId, "in_progress").pipe(Effect.catch(() => Effect.void))));
@@ -6011,7 +6821,8 @@ function handleRemoteAgentSpawn(input) {
 			model: spawnModel,
 			status: state.status,
 			startedAt: state.startedAt,
-			harness: "claude-code"
+			harness: "claude-code",
+			startedBy
 		}, {
 			type: "agent.started",
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -6025,7 +6836,8 @@ function handleRemoteAgentSpawn(input) {
 					model: spawnModel,
 					status: state.status,
 					startedAt: state.startedAt,
-					lastActivity: state.lastActivity
+					lastActivity: state.lastActivity,
+					startedBy
 				}
 			}
 		});
@@ -6053,7 +6865,7 @@ function handleRemoteAgentSpawn(input) {
 }
 function handleContainerOrchestration(input) {
 	return Effect.gen(function* () {
-		const { issueId, workspacePath, devScript, agentSessionName, role, effectiveHarness, allowHost, spawnModel, spawnGuardrails, projectPath, eventStore, spawnPanCommand, updateIssueStatus } = input;
+		const { issueId, workspacePath, devScript, agentSessionName, role, effectiveHarness, startedBy, allowHost, spawnModel, spawnGuardrails, projectPath, eventStore, spawnPanCommand, markWorkStartAccepted, updateIssueStatus } = input;
 		if (existsSync(workspacePath) && existsSync(devScript)) {
 			let dockerRunning = false;
 			try {
@@ -6122,17 +6934,17 @@ function handleContainerOrchestration(input) {
 					const earlyAgentId = agentSessionName;
 					const earlyStateDir = join(homedir(), ".overdeck", "agents", earlyAgentId);
 					yield* Effect.promise(() => mkdir(earlyStateDir, { recursive: true }));
-					saveAgentStateSync({
-						id: earlyAgentId,
+					saveAgentStateSync(buildContainerStartState({
+						agentSessionName: earlyAgentId,
 						issueId,
-						...effectiveHarness ? { harness: effectiveHarness } : {},
-						model: "pending-container-start",
-						status: "starting",
-						startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-						workspace: workspacePath,
+						workspacePath,
 						role,
-						hostOverride: allowHost || void 0
-					});
+						effectiveHarness,
+						startedBy,
+						allowHost,
+						status: "starting",
+						startedAt: (/* @__PURE__ */ new Date()).toISOString()
+					}));
 					updateRegistryForAgentStart(issueId, workspacePath, earlyAgentId);
 					yield* Effect.promise(() => appendAgentLifecycleLog(earlyAgentId, "agent.start_waiting_for_containers", {
 						issueId,
@@ -6190,16 +7002,17 @@ function handleContainerOrchestration(input) {
 								waitedMs: Date.now() - startTime
 							});
 							if (!healthy) {
-								saveAgentStateSync({
-									id: earlyAgentId,
+								saveAgentStateSync(buildContainerStartState({
+									agentSessionName: earlyAgentId,
 									issueId,
-									...effectiveHarness ? { harness: effectiveHarness } : {},
-									model: "pending-container-start",
+									workspacePath,
+									role,
+									effectiveHarness,
+									startedBy,
+									allowHost,
 									status: "error",
-									startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-									workspace: workspacePath,
-									role
-								});
+									startedAt: (/* @__PURE__ */ new Date()).toISOString()
+								}));
 								return;
 							}
 							for (const nmDir of [join(workspacePath, "node_modules"), join(workspacePath, "src", "dashboard", "frontend", "node_modules")]) try {
@@ -6224,14 +7037,19 @@ function handleContainerOrchestration(input) {
 							emitStartAgentPhase(issueId, "spawn", "start", "starting local work agent after containers became healthy", { workspacePath });
 							emitStartAgentPhase(issueId, "spawn", "success", "local work agent spawn requested after container startup", {
 								workspacePath,
-								activityId: await spawnPanCommand(buildPanStartArgs({
-									issueId,
-									model: spawnModel,
-									harness: effectiveHarness,
-									allowHost
-								}), workspacePath)
+								activityId: await requestWorkStartAfterContainers({
+									args: buildPanStartArgs({
+										issueId,
+										model: spawnModel,
+										harness: effectiveHarness,
+										allowHost
+									}),
+									workspacePath,
+									spawnPanCommand,
+									markWorkStartAccepted,
+									updateIssueStatus
+								})
 							});
-							await updateIssueStatus();
 						} catch (err) {
 							const errorMessage = err instanceof Error ? err.message : String(err);
 							emitStartAgentPhase(issueId, "spawn", "failure", errorMessage, { workspacePath });
@@ -6240,15 +7058,17 @@ function handleContainerOrchestration(input) {
 								error: errorMessage
 							}).catch(() => void 0);
 							try {
-								saveAgentStateSync({
-									id: earlyAgentId,
+								saveAgentStateSync(buildContainerStartState({
+									agentSessionName: earlyAgentId,
 									issueId,
-									model: "pending-container-start",
+									workspacePath,
+									role,
+									effectiveHarness,
+									startedBy,
+									allowHost,
 									status: "error",
-									startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-									workspace: workspacePath,
-									role
-								});
+									startedAt: (/* @__PURE__ */ new Date()).toISOString()
+								}));
 							} catch {}
 							console.error(`[start-agent] Background container startup failed for ${issueId}:`, err);
 						}
@@ -6287,10 +7107,12 @@ function handleContainerOrchestration(input) {
 //#endregion
 //#region routes/agents/spawn.ts
 init_agents$1();
+init_staffing();
 init_operator_interventions();
 init_child_env();
 init_harness_policy();
 init_activity_logger();
+init_issue_id();
 init_projects();
 init_review_status();
 init_state_read_home();
@@ -6328,20 +7150,17 @@ function emitDirtyWorkspaceRefusalActivity(issueId, porcelain) {
 		});
 	} catch {}
 }
-const LEGACY_WORKSPACE_RUNTIME_FILES = new Set([
-	".pan/continue.json",
-	".pan/spec.vbrief.json",
-	".pan/kickoff.md",
-	".pan/sessions.jsonl",
-	".pan/pipeline-verdict.json",
-	".pan/verification-latest.json",
-	".pan/agent-mcp.json"
-]);
+/**
+* Both workspace runtime directories are Overdeck-owned in full, so both get a
+* blanket prefix match. The legacy `.pan/` allowlist only matched the collapsed
+* `?? .pan/` porcelain form plus a closed set of files — but this gate always
+* runs with `--untracked-files=all`, which expands untracked directories into
+* individual paths. A pipeline-authored `.pan/drafts/<ISSUE>.md` therefore read
+* as operator dirt and 409'd the planning→work auto-handoff (PAN-3042).
+*/
 function isOverdeckWorkspaceRuntimePath(path) {
 	if (path === ".overdeck" || path.startsWith(".overdeck/")) return true;
-	if (path === ".pan" || path === ".pan/") return true;
-	if (LEGACY_WORKSPACE_RUNTIME_FILES.has(path)) return true;
-	return path.startsWith(".pan/feedback/") || path.startsWith(".pan/review/") || path.startsWith(".pan/test/") || path.startsWith(".pan/handoff-");
+	return path === ".pan" || path === ".pan/" || path.startsWith(".pan/");
 }
 /** True when git porcelain contains only Overdeck-owned workspace runtime files. */
 function isOnlyOverdeckRuntimeWorkspaceChanges(porcelain) {
@@ -6368,14 +7187,23 @@ async function spawnAfterClearingStartGates(input) {
 	}
 }
 const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect.gen(function* () {
-	const authError = rejectUnsafeDashboardMutationRequest(yield* HttpServerRequest.HttpServerRequest);
+	const request = yield* HttpServerRequest.HttpServerRequest;
+	const authError = rejectUnsafeDashboardMutationRequest(request);
 	if (authError) return authError;
 	const body = yield* readJsonBody$1;
 	const eventStore = yield* EventStoreService;
 	const lifecycle = yield* IssueLifecycle;
 	yield* ReadModelService;
 	const { issueId, projectId } = body;
+	const internalRequest = yield* Effect.promise(() => isInternalAgentRequest(request));
+	let startedBy;
+	try {
+		startedBy = resolveRequestedStartedBy(body.startedBy, internalRequest);
+	} catch (error) {
+		return jsonResponse({ error: error instanceof Error ? error.message : String(error) }, { status: 400 });
+	}
 	const autoStart = body.auto === true;
+	const autoSpawnConsentRequired = internalRequest && body.autoSpawnConsentRequired === true;
 	const guardrailAcknowledged = body.guardrailAcknowledged === true;
 	const offBook = body.offBook === true;
 	const requestedHostOverride = body.host === true || body.allowHost === true;
@@ -6534,7 +7362,7 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 	let spawnModel;
 	try {
 		spawnModel = determineModel({
-			model: body.model,
+			model: body.model ?? resolveIssueWorkModel(issueId),
 			role,
 			spawnKey: `${role}:${issueId}`
 		});
@@ -6692,7 +7520,7 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 			console.warn(`[start-agent] Failed to set plan.status=running (non-fatal): ${planStatusErr?.message ?? planStatusErr}`);
 		}
 		try {
-			const { appendSessionEntry, getProjectConfigFromWorkspacePath, resolveProjectForIssue } = await import("./record-CN0pj4_5.js");
+			const { appendSessionEntry, getProjectConfigFromWorkspacePath, resolveProjectForIssue } = await import("./record-BTwWhtBb.js");
 			await appendSessionEntry(resolveProjectForIssue(issueId) ?? getProjectConfigFromWorkspacePath(workspacePath), issueId, {
 				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 				reason: "start",
@@ -6717,6 +7545,8 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 				workspacePath,
 				workspaceMetadata,
 				spawnModel,
+				startedBy,
+				autoSpawnConsentRequired,
 				projectPath,
 				spawnGuardrails,
 				lifecycle
@@ -6810,7 +7640,11 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 				role,
 				workspacePath,
 				args,
-				cwd
+				cwd,
+				env: {
+					OVERDECK_AGENT_STARTED_BY: startedBy,
+					OVERDECK_AUTO_SPAWN_CONSENT_REQUIRED: autoSpawnConsentRequired ? "1" : "0"
+				}
 			})
 		}));
 		if (!admitted.check.decision.eligible || !admitted.result) throw new OrderDispatchReservationError(admitted.check);
@@ -6827,48 +7661,29 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 		agentSessionName,
 		role,
 		effectiveHarness,
+		startedBy,
 		allowHost,
 		spawnModel,
 		spawnGuardrails,
 		projectPath,
 		eventStore,
 		spawnPanCommand,
+		markWorkStartAccepted,
 		updateIssueStatus
 	});
-	if (containerResponse) {
-		if (containerResponse.status >= 200 && containerResponse.status < 300) yield* Effect.promise(markWorkStartAccepted);
-		return containerResponse;
-	}
+	if (containerResponse) return containerResponse;
 	const placeholderStartedAt = (/* @__PURE__ */ new Date()).toISOString();
-	const placeholderState = {
-		id: agentSessionName,
+	const { state: placeholderState, event: placeholderEvent } = buildAgentStartPlaceholder({
+		agentSessionName,
 		issueId,
-		workspace: workspacePath,
+		workspacePath,
 		role,
-		...effectiveHarness ? { harness: effectiveHarness } : {},
-		model: "pending-work-spawn",
-		status: "starting",
-		startedAt: placeholderStartedAt,
-		hostOverride: allowHost || void 0
-	};
-	const hasLiveTmuxSession = yield* sessionExists(agentSessionName).pipe(Effect.catch(() => Effect.succeed(true)));
-	const placeholderClaim = yield* claimAgentStartPlaceholderProgram(placeholderState, {
-		type: "agent.started",
-		timestamp: placeholderStartedAt,
-		payload: {
-			agentId: agentSessionName,
-			issueId,
-			agent: {
-				id: agentSessionName,
-				issueId,
-				workspace: workspacePath,
-				status: "starting",
-				startedAt: placeholderStartedAt,
-				role,
-				...effectiveHarness ? { runtime: effectiveHarness } : {}
-			}
-		}
-	}, hasLiveTmuxSession);
+		effectiveHarness,
+		startedBy,
+		allowHost,
+		startedAt: placeholderStartedAt
+	});
+	const placeholderClaim = yield* claimAgentStartPlaceholderProgram(placeholderState, placeholderEvent, yield* sessionExists(agentSessionName).pipe(Effect.catch(() => Effect.succeed(true))));
 	if (!placeholderClaim.claimed) {
 		yield* Effect.promise(() => appendAgentLifecycleLog(agentSessionName, "agent.start_placeholder_blocked", {
 			issueId,
@@ -7142,16 +7957,26 @@ const readJsonBody = Effect.gen(function* () {
 const postMergeGuard = createInFlightGuard();
 const _serverManagedMerges = /* @__PURE__ */ new Set();
 function firePostMergeLifecycle(issueId, options) {
-	const started = postMergeGuard.run(issueId, async () => {
-		const projectPath = getProjectPathForIssue(extractPrefixSync(issueId) ?? issueId.split("-")[0]);
-		const { postMergeLifecycle } = await import("./merge-agent-CKkgIBPB.js");
-		await postMergeLifecycle(issueId, projectPath, options?.sourceBranch, options?.verifiedMergedRef ? { verifiedMergedRef: options.verifiedMergedRef } : void 0);
-		console.log(`[merge] post-merge lifecycle completed for ${issueId}`);
-		const { runMergeTrainReconcile } = await import("./merge-train-CHopycP0.js");
-		const outcomes = await runMergeTrainReconcile(issueId);
-		if (outcomes.length > 0) console.log(`[merge-train] reconciled ${outcomes.length} sibling(s) after ${issueId}: ` + outcomes.map((o) => `${o.issueId}=${o.result}`).join(", "));
-	}, (err) => console.error(`[merge] post-merge lifecycle failed for ${issueId}:`, err));
-	if (!started) console.log(`[merge] firePostMergeLifecycle: skipping ${issueId} — already in flight`);
+	const parsedIssueId = parseIssueIdSync(issueId.trim());
+	if (!parsedIssueId) {
+		console.error(`[merge] Refusing post-merge lifecycle for invalid issue ID: ${issueId}`);
+		return false;
+	}
+	const normalizedIssueId = parsedIssueId.normalized.toUpperCase();
+	const started = postMergeGuard.run(normalizedIssueId, async () => {
+		const projectPath = getProjectPathForIssue(parsedIssueId.prefix);
+		const { postMergeLifecycle } = await import("./merge-agent-DQTXZk8z.js");
+		const lifecycleOptions = {
+			...options?.verifiedMergedRef ? { verifiedMergedRef: options.verifiedMergedRef } : {},
+			...options?.verifiedMergedRepos?.length ? { verifiedMergedRepos: options.verifiedMergedRepos } : {}
+		};
+		await postMergeLifecycle(normalizedIssueId, projectPath, options?.sourceBranch, Object.keys(lifecycleOptions).length > 0 ? lifecycleOptions : void 0);
+		console.log(`[merge] post-merge lifecycle completed for ${normalizedIssueId}`);
+		const { runMergeTrainReconcile } = await import("./merge-train-Dmrcus12.js");
+		const outcomes = await runMergeTrainReconcile(normalizedIssueId);
+		if (outcomes.length > 0) console.log(`[merge-train] reconciled ${outcomes.length} sibling(s) after ${normalizedIssueId}: ` + outcomes.map((o) => `${o.issueId}=${o.result}`).join(", "));
+	}, (err) => console.error(`[merge] post-merge lifecycle failed for ${normalizedIssueId}:`, err));
+	if (!started) console.log(`[merge] firePostMergeLifecycle: skipping ${normalizedIssueId} — already in flight`);
 	return started;
 }
 function getProjectPathForIssue(issuePrefix) {
@@ -7168,15 +7993,15 @@ init_io();
 init_domain_services();
 init_tmux();
 const getSpecialistsRoute = HttpRouter.add("GET", "/api/specialists", httpHandler(Effect.gen(function* () {
-	const { getAllSpecialistStatus, getAllProjectSpecialistStatuses } = yield* Effect.promise(() => import("./specialists-DM6bWjsi.js"));
+	const { getAllSpecialistStatus, getAllProjectSpecialistStatuses } = yield* Effect.promise(() => import("./specialists-Bz-wFT7R.js"));
 	return jsonResponse({
 		specialists: yield* Effect.promise(() => getAllSpecialistStatus()),
 		projects: yield* Effect.promise(() => getAllProjectSpecialistStatuses())
 	});
 })));
 const postSpecialistsResetAllRoute = HttpRouter.add("POST", "/api/specialists/reset-all", httpHandler(Effect.gen(function* () {
-	const { getAllSpecialists, isRunning, getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-DM6bWjsi.js"));
-	const { clearHookSync } = yield* Effect.promise(() => import("./hooks-DPVX1rwQ.js"));
+	const { getAllSpecialists, isRunning, getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-Bz-wFT7R.js"));
+	const { clearHookSync } = yield* Effect.promise(() => import("./hooks-D1g1jKLI.js"));
 	const specialists = getAllSpecialists();
 	const results = [];
 	for (const specialist of specialists) {
@@ -7211,7 +8036,7 @@ const postSpecialistsResetAllRoute = HttpRouter.add("POST", "/api/specialists/re
 const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done", httpHandler(Effect.gen(function* () {
 	const body = yield* readJsonBody;
 	const eventStore = yield* EventStoreService;
-	const { specialist, issueId, status, notes, itemId } = body;
+	const { specialist, issueId, status, notes, itemId, runId } = body;
 	const validSpecialists = [
 		"review",
 		"test",
@@ -7232,7 +8057,7 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 	}
 	console.log(`[specialists/done] ${specialist} signaling ${status} for ${normalizedIssueId}`);
 	if (specialist === "merge") {
-		const { reportSpecialistCompletion } = yield* Effect.promise(() => import("./specialist-completion-Ky9wCDpb.js"));
+		const { reportSpecialistCompletion } = yield* Effect.promise(() => import("./specialist-completion-B07XjWD2.js"));
 		if (yield* reportSpecialistCompletion(normalizedIssueId, {
 			status,
 			notes
@@ -7276,10 +8101,27 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 			break;
 	}
 	const updatedStatus = setReviewStatusSync(normalizedIssueId, update);
-	if (specialist === "inspect" && status === "failed") yield* Effect.promise(() => reportTieredInspectFailureEscalation(normalizedIssueId, notes));
+	if (specialist === "inspect" && status === "failed") {
+		yield* Effect.promise(() => reportTieredInspectFailureEscalation(normalizedIssueId, notes));
+		yield* Effect.promise(async () => {
+			try {
+				const failedItemId = itemId ?? getReviewStatusSync(normalizedIssueId)?.inspectBeadId ?? void 0;
+				const project = resolveProjectFromIssueSync(normalizedIssueId);
+				if (project && failedItemId) {
+					const workspacePath = join(project.projectPath, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`);
+					if (existsSync(workspacePath)) {
+						const { onInspectComplete } = await import("./inspect-agent-CUwVmr2h.js");
+						await Effect.runPromise(onInspectComplete(project.projectKey, normalizedIssueId, failedItemId, "failed", workspacePath, notes));
+					}
+				}
+			} catch (err) {
+				console.error(`[specialists/done] Error delivering failed inspect verdict for ${normalizedIssueId}:`, err);
+			}
+		});
+	}
 	yield* Effect.promise(async () => {
 		try {
-			const { getTmuxSessionName, updateRunMetadata, makeSpecialistRegistryKey } = await import("./specialists-DM6bWjsi.js");
+			const { getTmuxSessionName, updateRunMetadata, makeSpecialistRegistryKey } = await import("./specialists-Bz-wFT7R.js");
 			const projectKey = resolveProjectFromIssueSync(normalizedIssueId)?.projectKey;
 			const tmuxSession = projectKey ? getTmuxSessionName(`${specialist}-agent`, projectKey, normalizedIssueId) : getTmuxSessionName(`${specialist}-agent`);
 			saveAgentRuntimeState(tmuxSession, {
@@ -7298,7 +8140,7 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 				});
 				console.log(`[specialists/done] Cleared registry lock for ${registryKey} (${projectKey})`);
 			}
-			const { updateSpecialistHandoffStatus } = await import("./specialist-handoff-logger-CMEwYxa2.js");
+			const { updateSpecialistHandoffStatus } = await import("./specialist-handoff-logger-aKSxbIgD.js");
 			if (await Effect.runPromise(updateSpecialistHandoffStatus(normalizedIssueId, `${specialist}-agent`, status === "passed" ? "completed" : "failed", status === "passed" ? "success" : "failure"))) console.log(`[specialists/done] Updated handoff log: ${specialist}-agent ${normalizedIssueId} → ${status}`);
 		} catch (err) {
 			console.error(`[specialists/done] Error managing specialist state:`, err);
@@ -7310,10 +8152,12 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 			if (project) {
 				const workspacePath = join(project.projectPath, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`);
 				if (existsSync(workspacePath)) {
-					const { getWorkspaceGitInfo } = await import("./git-utils-D0_yhCgF.js");
-					const { HEAD } = await Effect.runPromise(getWorkspaceGitInfo(workspacePath));
-					setReviewStatusSync(normalizedIssueId, { reviewedAtCommit: HEAD });
-					console.log(`[specialists/done] Snapshotted reviewedAtCommit=${HEAD.substring(0, 8)} for ${normalizedIssueId}`);
+					const { formatAnchorShort, snapshotWorkspaceHeadsPromise } = await import("./git-utils-Xg4PFN45.js");
+					const headAnchor = await snapshotWorkspaceHeadsPromise(normalizedIssueId, workspacePath);
+					if (headAnchor) {
+						setReviewStatusSync(normalizedIssueId, { reviewedAtCommit: headAnchor });
+						console.log(`[specialists/done] Snapshotted reviewedAtCommit=${formatAnchorShort(headAnchor)} for ${normalizedIssueId}`);
+					}
 				}
 			}
 		} catch (err) {
@@ -7322,11 +8166,11 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 	});
 	if (specialist === "inspect" && status === "passed") yield* Effect.promise(async () => {
 		try {
-			const { onInspectComplete } = await import("./inspect-agent-Brtz0URj.js");
+			const { onInspectComplete } = await import("./inspect-agent-CUwVmr2h.js");
 			const project = resolveProjectFromIssueSync(normalizedIssueId);
 			if (project) {
 				const workspacePath = join(project.projectPath, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`);
-				if (existsSync(workspacePath)) await Effect.runPromise(onInspectComplete(project.projectKey, normalizedIssueId, itemId, "passed", workspacePath));
+				if (existsSync(workspacePath)) await Effect.runPromise(onInspectComplete(project.projectKey, normalizedIssueId, itemId, "passed", workspacePath, notes));
 			}
 		} catch (err) {
 			console.error(`[specialists/done] Error saving inspect checkpoint:`, err);
@@ -7338,7 +8182,7 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 			if (project) {
 				if (existsSync(join(project.projectPath, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`))) {
 					setReviewStatusSync(normalizedIssueId, { testStatus: "passed" });
-					const { initEventStore } = await import("./event-store-EV2cMiXj.js");
+					const { initEventStore } = await import("./event-store-5UKzh9Jf.js");
 					await (await initEventStore()).appendAsync({
 						type: "test.passed",
 						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -7391,8 +8235,8 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 		if (notes?.toLowerCase().includes("conflict")) yield* Effect.promise(async () => {
 			try {
 				const workAgentId = `agent-${normalizedIssueId.toLowerCase()}`;
-				const { sessionExists } = await import("./tmux-B6z7h_vZ.js");
-				const { messageAgent, spawnAgent, getAgentStateSync } = await import("./agents-wi9NWzs2.js");
+				const { sessionExists } = await import("./tmux-Ctk6RV5l.js");
+				const { messageAgent, spawnAgent, getAgentStateSync } = await import("./agents-ePFVoZbu.js");
 				if (await Effect.runPromise(sessionExists(workAgentId))) {
 					await messageAgent(workAgentId, `MERGE CONFLICT: The merge-agent could not rebase your branch onto main due to conflicts. Please fix this now:\n\n1. git fetch origin main\n2. git rebase origin/main\n3. Resolve any conflicts (git add <file> && git rebase --continue)\n4. git push --force-with-lease\n5. Resubmit: curl -s -X POST http://localhost:3011/api/review/${normalizedIssueId}/request -H "Content-Type: application/json" -d "{}"\n\nConflict details: ${notes}`);
 					console.log(`[specialists/done] Sent rebase instructions to ${workAgentId}`);
@@ -7406,19 +8250,38 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 		try {
 			const project = resolveProjectFromIssueSync(normalizedIssueId);
 			const workspacePath = project ? join(project.projectPath, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`) : void 0;
-			const { deliverReviewVerdictFeedback } = await import("./review-verdict-feedback-CTd4QMBu.js");
+			const { deliverReviewVerdictFeedback } = await import("./review-verdict-feedback-HwF6ODFy.js");
 			const result = await Effect.runPromise(deliverReviewVerdictFeedback({
 				issueId: normalizedIssueId,
 				verdict: status === "failed" ? "failed" : "blocked",
 				notes,
 				workspacePath,
-				prUrl: updatedStatus.prUrl
+				prUrl: updatedStatus.prUrl,
+				...runId ? { runId } : {}
 			}));
 			console.log(`[specialists/done] Delivered review verdict feedback for ${normalizedIssueId} (feedback=${result.feedbackPath ?? "none"}, synthesis=${result.synthesisPath ?? "none"}, prComment=${result.prCommentPosted})`);
 		} catch (err) {
 			console.warn(`[specialists/done] Failed to deliver review verdict feedback: ${err.message}`);
 		}
 	});
+	if (specialist === "review" && status === "failed") yield* Effect.promise(async () => {
+		try {
+			const project = resolveProjectFromIssueSync(normalizedIssueId);
+			if (project) {
+				const workspacePath = join(project.projectPath, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`);
+				if (existsSync(workspacePath)) {
+					const { formatAnchorShort, snapshotWorkspaceHeadsPromise } = await import("./git-utils-Xg4PFN45.js");
+					const reviewedAtCommit = await snapshotWorkspaceHeadsPromise(normalizedIssueId, workspacePath);
+					if (reviewedAtCommit) {
+						setReviewStatusSync(normalizedIssueId, { reviewedAtCommit });
+						console.log(`[specialists/done] Snapshotted blocked reviewedAtCommit=${formatAnchorShort(reviewedAtCommit)} for ${normalizedIssueId}`);
+					}
+				}
+			}
+		} catch (err) {
+			console.error(`[specialists/done] Failed to snapshot blocked reviewedAtCommit for ${normalizedIssueId}:`, err);
+		}
+	});
 	const eventRole = specialistEventRole(specialist);
 	if (eventRole) if (status === "passed") yield* eventStore.append({
 		type: "specialist.completed",
@@ -7447,7 +8310,7 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 	});
 })));
 const postSpecialistsLogsCleanupAllRoute = HttpRouter.add("POST", "/api/specialists/logs/cleanup-all", httpHandler(Effect.gen(function* () {
-	const { cleanupAllLogsSync } = yield* Effect.promise(() => import("./specialist-logs-C5p8G7tx.js"));
+	const { cleanupAllLogsSync } = yield* Effect.promise(() => import("./specialist-logs-Dae-n52_.js"));
 	const results = cleanupAllLogsSync();
 	return jsonResponse({
 		success: true,
@@ -7457,7 +8320,7 @@ const postSpecialistsLogsCleanupAllRoute = HttpRouter.add("POST", "/api/speciali
 	});
 })));
 const getSpecialistsProjectsRoute = HttpRouter.add("GET", "/api/specialists/projects", httpHandler(Effect.gen(function* () {
-	const { getAllProjectSpecialistStatuses } = yield* Effect.promise(() => import("./specialists-DM6bWjsi.js"));
+	const { getAllProjectSpecialistStatuses } = yield* Effect.promise(() => import("./specialists-Bz-wFT7R.js"));
 	return jsonResponse(yield* Effect.promise(() => getAllProjectSpecialistStatuses()));
 })));
 const postSpecialistWakeRoute = HttpRouter.add("POST", "/api/specialists/:name/wake", httpHandler(Effect.gen(function* () {
@@ -7501,7 +8364,7 @@ const postSpecialistReportStatusRoute = HttpRouter.add("POST", "/api/specialists
 		"blocked",
 		"failed"
 	].includes(status)) {
-		const { getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-DM6bWjsi.js"));
+		const { getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-Bz-wFT7R.js"));
 		saveAgentRuntimeState(getTmuxSessionName(name), {
 			state: "idle",
 			lastActivity: (/* @__PURE__ */ new Date()).toISOString()
@@ -7600,6 +8463,7 @@ const specialistsLegacyRouteLayer = Layer.mergeAll(getSpecialistsRoute, getSpeci
 //#endregion
 //#region routes/specialists/project-routes.ts
 init_config_yaml();
+init_project_repos();
 init_projects();
 init_review_status();
 init_tmux();
@@ -7622,7 +8486,7 @@ const postProjectSpecialistKillRoute = HttpRouter.add("POST", "/api/specialists/
 	const issueId = params["issueId"];
 	const type = params["type"];
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { getTmuxSessionName, makeSpecialistRegistryKey, getRunMetadata } = yield* Effect.promise(() => import("./specialists-DM6bWjsi.js"));
+	const { getTmuxSessionName, makeSpecialistRegistryKey, getRunMetadata } = yield* Effect.promise(() => import("./specialists-Bz-wFT7R.js"));
 	const tmuxSession = getRunMetadata(project, makeSpecialistRegistryKey(type, issueId)).tmuxSession ?? getTmuxSessionName(type, project, issueId);
 	yield* Effect.promise(() => Effect.runPromise(killSession(tmuxSession)).catch(() => {}));
 	saveAgentRuntimeState(tmuxSession, {
@@ -7649,7 +8513,7 @@ const getProjectSpecialistRunsRoute = HttpRouter.add("GET", "/api/specialists/:p
 		if (limitParam) limit = parseInt(limitParam, 10);
 		if (offsetParam) offset = parseInt(offsetParam, 10);
 	}
-	const { listRunLogsSync } = yield* Effect.promise(() => import("./specialist-logs-C5p8G7tx.js"));
+	const { listRunLogsSync } = yield* Effect.promise(() => import("./specialist-logs-Dae-n52_.js"));
 	return jsonResponse(listRunLogsSync(project, type, {
 		limit,
 		offset
@@ -7660,7 +8524,7 @@ const getProjectSpecialistRunStreamRoute = HttpRouter.add("GET", "/api/specialis
 	const project = params["project"];
 	const type = params["type"];
 	const runId = params["runId"];
-	const { getRunLogPath, isRunLogActive } = yield* Effect.promise(() => import("./specialist-logs-C5p8G7tx.js"));
+	const { getRunLogPath, isRunLogActive } = yield* Effect.promise(() => import("./specialist-logs-Dae-n52_.js"));
 	const logPath = getRunLogPath(project, type, runId);
 	if (!existsSync(logPath)) return jsonResponse({ error: "Run log not found" }, { status: 404 });
 	const encoder = new TextEncoder();
@@ -7719,7 +8583,7 @@ const getProjectSpecialistRunRoute = HttpRouter.add("GET", "/api/specialists/:pr
 	const project = params["project"];
 	const type = params["type"];
 	const runId = params["runId"];
-	const { getRunLogSync, parseLogMetadata } = yield* Effect.promise(() => import("./specialist-logs-C5p8G7tx.js"));
+	const { getRunLogSync, parseLogMetadata } = yield* Effect.promise(() => import("./specialist-logs-Dae-n52_.js"));
 	const content = getRunLogSync(project, type, runId);
 	if (!content) return jsonResponse({ error: "Run log not found" }, { status: 404 });
 	return jsonResponse({
@@ -7733,7 +8597,7 @@ const postProjectSpecialistRunTerminateRoute = HttpRouter.add("POST", "/api/spec
 	const project = params["project"];
 	const type = params["type"];
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { terminateSpecialist } = yield* Effect.promise(() => import("./specialists-DM6bWjsi.js"));
+	const { terminateSpecialist } = yield* Effect.promise(() => import("./specialists-Bz-wFT7R.js"));
 	yield* Effect.promise(() => terminateSpecialist(project, type));
 	return jsonResponse({
 		success: true,
@@ -7745,7 +8609,7 @@ const postProjectSpecialistGracePauseRoute = HttpRouter.add("POST", "/api/specia
 	const project = params["project"];
 	const type = params["type"];
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { pauseGracePeriod } = yield* Effect.promise(() => import("./specialists-DM6bWjsi.js"));
+	const { pauseGracePeriod } = yield* Effect.promise(() => import("./specialists-Bz-wFT7R.js"));
 	if (pauseGracePeriod(project, type)) return jsonResponse({
 		success: true,
 		message: "Grace period paused"
@@ -7757,7 +8621,7 @@ const postProjectSpecialistGraceResumeRoute = HttpRouter.add("POST", "/api/speci
 	const project = params["project"];
 	const type = params["type"];
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { resumeGracePeriod } = yield* Effect.promise(() => import("./specialists-DM6bWjsi.js"));
+	const { resumeGracePeriod } = yield* Effect.promise(() => import("./specialists-Bz-wFT7R.js"));
 	if (resumeGracePeriod(project, type)) return jsonResponse({
 		success: true,
 		message: "Grace period resumed"
@@ -7769,7 +8633,7 @@ const postProjectSpecialistGraceExitRoute = HttpRouter.add("POST", "/api/special
 	const project = params["project"];
 	const type = params["type"];
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { exitGracePeriod } = yield* Effect.promise(() => import("./specialists-DM6bWjsi.js"));
+	const { exitGracePeriod } = yield* Effect.promise(() => import("./specialists-Bz-wFT7R.js"));
 	exitGracePeriod(project, type);
 	return jsonResponse({
 		success: true,
@@ -7781,7 +8645,7 @@ const getProjectSpecialistGraceRoute = HttpRouter.add("GET", "/api/specialists/:
 	const project = params["project"];
 	const type = params["type"];
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { getGracePeriodState } = yield* Effect.promise(() => import("./specialists-DM6bWjsi.js"));
+	const { getGracePeriodState } = yield* Effect.promise(() => import("./specialists-Bz-wFT7R.js"));
 	const state = getGracePeriodState(project, type);
 	if (state) return jsonResponse(state);
 	else return jsonResponse({ error: "No active grace period" }, { status: 404 });
@@ -7790,7 +8654,7 @@ const getProjectSpecialistContextRoute = HttpRouter.add("GET", "/api/specialists
 	const params = yield* HttpRouter.params;
 	const project = params["project"];
 	const type = params["type"];
-	const { loadContextDigest } = yield* Effect.promise(() => import("./specialist-context-Bn3dCGS2.js"));
+	const { loadContextDigest } = yield* Effect.promise(() => import("./specialist-context-DJ-zFyL3.js"));
 	const digest = loadContextDigest(project, type);
 	if (digest) return jsonResponse({ digest });
 	else return jsonResponse({ error: "No context digest found" }, { status: 404 });
@@ -7799,7 +8663,7 @@ const postProjectSpecialistContextRegenerateRoute = HttpRouter.add("POST", "/api
 	const params = yield* HttpRouter.params;
 	const project = params["project"];
 	const type = params["type"];
-	const { regenerateContextDigest } = yield* Effect.promise(() => import("./specialist-context-Bn3dCGS2.js"));
+	const { regenerateContextDigest } = yield* Effect.promise(() => import("./specialist-context-DJ-zFyL3.js"));
 	const digest = yield* Effect.promise(() => regenerateContextDigest(project, type));
 	if (digest) return jsonResponse({
 		digest,
@@ -7818,7 +8682,7 @@ const postProjectSpecialistCompleteRoute = HttpRouter.add("POST", "/api/speciali
 		"blocked"
 	].includes(status)) return jsonResponse({ error: "Valid status (passed/failed/blocked) is required" }, { status: 400 });
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { signalSpecialistCompletion } = yield* Effect.promise(() => import("./specialists-DM6bWjsi.js"));
+	const { signalSpecialistCompletion } = yield* Effect.promise(() => import("./specialists-Bz-wFT7R.js"));
 	signalSpecialistCompletion(project, type, {
 		status,
 		notes
@@ -7852,8 +8716,8 @@ const postProjectSpecialistLogsCleanupRoute = HttpRouter.add("POST", "/api/speci
 	const params = yield* HttpRouter.params;
 	const project = params["project"];
 	const type = params["type"];
-	const { cleanupOldLogsSync } = yield* Effect.promise(() => import("./specialist-logs-C5p8G7tx.js"));
-	const { getSpecialistRetention } = yield* Effect.promise(() => import("./projects-vjjcmiN8.js"));
+	const { cleanupOldLogsSync } = yield* Effect.promise(() => import("./specialist-logs-Dae-n52_.js"));
+	const { getSpecialistRetention } = yield* Effect.promise(() => import("./projects-_n3Zui6K.js"));
 	const retention = getSpecialistRetention(project);
 	const deleted = cleanupOldLogsSync(project, type, {
 		maxDays: retention.max_days,
@@ -7874,21 +8738,23 @@ const postProjectReviewRestartRoute = HttpRouter.add("POST", "/api/specialists/:
 	const project = params["project"];
 	const issueId = params["issueId"];
 	const { model, harness } = yield* readJsonBody;
-	const { killAllReviewerSessions } = yield* Effect.promise(() => import("./review-agent-DNboMyW4.js"));
+	const { killAllReviewerSessions } = yield* Effect.promise(() => import("./review-agent-BTCNkq2h.js"));
 	const killResult = yield* killAllReviewerSessions(project, issueId);
 	const projectConfig = resolveProjectFromIssueSync(issueId);
 	if (!projectConfig) return jsonResponse({ error: `Cannot resolve project for ${issueId}` }, { status: 404 });
 	const workspacePath = join(projectConfig.projectPath, "workspaces", `feature-${issueId.toLowerCase()}`);
 	if (!existsSync(workspacePath)) return jsonResponse({ error: `Workspace not found: ${workspacePath}` }, { status: 404 });
-	let branch = "unknown";
+	const primaryRepo = resolveWorkspaceRepoRootsSync(issueId, workspacePath)[0];
+	let branch = primaryRepo.sourceBranch;
 	try {
-		const { stdout } = yield* Effect.promise(() => execAsync(`cd "${workspacePath}" && git branch --show-current`, {
+		const { stdout } = yield* Effect.promise(() => execAsync("git branch --show-current", {
+			cwd: resolvePrimaryWorkspaceRepoDirSync(issueId, workspacePath),
 			encoding: "utf-8",
 			timeout: 5e3
 		}));
-		branch = stdout.trim() || "unknown";
+		branch = stdout.trim() || primaryRepo.sourceBranch;
 	} catch {}
-	const { spawnReviewRoleForIssue } = yield* Effect.promise(() => import("./review-agent-DNboMyW4.js"));
+	const { spawnReviewRoleForIssue } = yield* Effect.promise(() => import("./review-agent-BTCNkq2h.js"));
 	const prUrl = getReviewStatusSync(issueId)?.prUrl;
 	const result = yield* spawnReviewRoleForIssue({
 		issueId,
@@ -8037,6 +8903,6 @@ const specialistsProjectRouteLayer = Layer.mergeAll(getProjectSpecialistStatusRo
 */
 const specialistsRouteLayer = Layer.mergeAll(specialistsLegacyRouteLayer, specialistsProjectRouteLayer);
 //#endregion
-export { panCliInvocation as $, resolveAllowedHarness as A, cleanupUnreferencedConversationAttachments as B, handleConversationCreate as C, jsonStringResponse as Ct, handleConversationStop as D, handleConversationResume as E, tmuxSessionExists as F, isManagedConversationAttachmentPath as G, extractConversationAttachmentPaths as H, waitForPiTuiReady as I, evaluateSpawnGuardrails as J, removeConversationAttachment as K, waitForTmuxSession as L, spawnConversationSession as M, startConversationModelBackfill as N, handleConversationSwitchModel as O, stopConversationRuntime as P, getWorkAgentLifecycleStateSync as Q, cleanupConversationAttachments as R, conversationSessionAliveFromState as S, jsonResponse as St, handleConversationRestartAll as T, getConversationAttachmentsRoot as U, ensureConversationAttachmentDir as V, hasConversationAttachment as W, resolveAgentGitInfo as X, invalidateAgentsCache as Y, resolveConversationGitInfo as Z, isPiControlChannelHarness as _, isTrustedOriginForHost as _t, agentsRouteLayer as a, resolveCodexRolloutPath as at, validateConversationControlAckOrigin as b, httpHandler as bt, codexConversationPendingInput as c, dashboardCsrfToken as ct, handleConversationCodexApproval as d, rejectUnauthorizedDashboardRequest as dt, spawnPanCli as et, handleConversationCompact as f, rejectUnauthorizedDashboardSessionMintRequest as ft, handleConversationThinkingLevel as g, getHeaderFromMap as gt, handleConversationPlanAction as h, waitForSessionRespawn as ht, validateSpecialistAutoCompleteMetadata as i, resolveClaudeSessionId as it, shouldReportUnresolvedLiveSession as j, isInsideGitWorkTree as k, deliverConversationViaControlChannel as l, dashboardSessionCookieHeader as lt, handleConversationDeliveryMethod as m, isRespawnPending as mt, _serverManagedMerges as n, resolveAcpTranscriptPath as nt, saveAgentStateAndEmitEvent as o, resolveJsonlPath as ot, handleConversationControlAck as p, rejectUnsafeDashboardMutationRequest as pt, runInBatches as q, firePostMergeLifecycle as r, resolveAgentHarness as rt, saveAgentStateAndEmitEventProgram as s, resolvePiSessionPath as st, specialistsRouteLayer as t, readLauncherPinnedSessionId as tt, handleConversationAbort as u, hasDashboardInternalToken as ut, pickDeliverAs as v, validateOrigin as vt, handleConversationDelete as w, conversationNeedsRunningRepair as x, getDefaultCwd as xt, resolveConversationDeliveryMethod as y, validateOriginHeaders as yt, cleanupOrphanedConversationAttachments as z };
+export { composerCommandConfirmationFromBody as $, resolveAllowedHarness as A, jsonResponse as At, cleanupUnreferencedConversationAttachments as B, handleConversationCreate as C, waitForSessionRespawn as Ct, handleConversationStop as D, validateOriginHeaders as Dt, handleConversationResume as E, validateOrigin as Et, tmuxSessionExists as F, isManagedConversationAttachmentPath as G, extractConversationAttachmentPaths as H, waitForPiTuiReady as I, composerCommandResultHttpStatus as J, removeConversationAttachment as K, waitForTmuxSession as L, spawnConversationSession as M, startConversationModelBackfill as N, handleConversationSwitchModel as O, httpHandler as Ot, stopConversationRuntime as P, ComposerCommandConfirmationError as Q, cleanupConversationAttachments as R, conversationSessionAliveFromState as S, isRespawnPending as St, handleConversationRestartAll as T, isTrustedOriginForHost as Tt, getConversationAttachmentsRoot as U, ensureConversationAttachmentDir as V, hasConversationAttachment as W, resolvePolicy as X, handleComposerCommandMessage as Y, ComposerCommandParseError as Z, isPiControlChannelHarness as _, dashboardSessionCookieHeader as _t, agentsRouteLayer as a, resolveConversationGitInfo as at, validateConversationControlAckOrigin as b, rejectUnauthorizedDashboardSessionMintRequest as bt, codexConversationPendingInput as c, spawnPanCli as ct, handleConversationCodexApproval as d, resolveAgentHarness as dt, evaluateSpawnGuardrails as et, handleConversationCompact as f, resolveClaudeSessionId as ft, handleConversationThinkingLevel as g, dashboardCsrfToken as gt, handleConversationPlanAction as h, resolvePiSessionPath as ht, validateSpecialistAutoCompleteMetadata as i, resolveAgentGitInfo as it, shouldReportUnresolvedLiveSession as j, jsonStringResponse as jt, isInsideGitWorkTree as k, getDefaultCwd as kt, deliverConversationViaControlChannel as l, readLauncherPinnedSessionId as lt, handleConversationDeliveryMethod as m, resolveJsonlPath as mt, _serverManagedMerges as n, isInternalAgentRequest as nt, saveAgentStateAndEmitEvent as o, getWorkAgentLifecycleStateSync as ot, handleConversationControlAck as p, resolveCodexRolloutPath as pt, runInBatches as q, firePostMergeLifecycle as r, resolveRequestedStartedBy as rt, saveAgentStateAndEmitEventProgram as s, panCliInvocation as st, specialistsRouteLayer as t, invalidateAgentsCache as tt, handleConversationAbort as u, resolveAcpTranscriptPath as ut, pickDeliverAs as v, hasDashboardInternalToken as vt, handleConversationDelete as w, getHeaderFromMap as wt, conversationNeedsRunningRepair as x, rejectUnsafeDashboardMutationRequest as xt, resolveConversationDeliveryMethod as y, rejectUnauthorizedDashboardRequest as yt, cleanupOrphanedConversationAttachments as z };
 
-//# sourceMappingURL=specialists-CC4r-c2s.js.map
+//# sourceMappingURL=specialists-6PWdtWcg.js.map