@overdeck/desktop 0.45.23 → 0.46.0

package/server/{specialists-JVO00bs7.js → specialists-CNfYO3G2.js}

@@ -1,45 +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, in as shouldCommitLegacyWorkspaceArtifacts, ir as FsError, kn as listProjectsSync, mr as init_errors, nn as init_state_read_home, t as init_config_yaml, tt as resolveModel, yn as getProjectSync, zn as resolveProjectFromIssueSync } from "./config-yaml-DvyMuOle.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-CzaSOgul.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-ftABRAmc.js";
-import { a as init_event_store, n as getEventStore } from "./event-store-tdiY5eDZ.js";
-import { k as normalizeChannelReplyPayload, o as getHarnessBehavior, t as init_src, x as DomainEvent } from "./src-U7_kTPEE.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-A7quS5KJ.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-CreaCkjW.js";
-import { d as isTerminalIssueStage, o as init_agents, u as getIssueStageSync } from "./agents-B4Bjbkfv.js";
-import { n as ensureSessionContextBriefingFile, r as init_briefing_freshness } from "./briefing-freshness-DWdW7vUm.js";
-import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-Ca0YTWDw.js";
-import { An as writeChannelsBridgeMcpConfig, Ar as init_codex_auth, At as deliverAgentPermissionDecision, Bn as getAgentDir, Cn as validateProviderHealth, Cr as getAgentRuntimeStateSync, F as init_tier_escalation, G as resumeAgent, Gt as transitionIssueToInProgress, H as restartAgent, Hn as getAgentState, In as clearAgentTroubled, Lt as BRIDGE_TOKEN_HEADER, Nt as setAgentDeliveryMethod, P as decideEscalation, Pn as clearAgentPaused, Q as operatorInterventionEvent, Rt as init_bridge_token, Sn as init_provider_health, Sr as getAgentRuntimeState, Tr as saveAgentRuntimeState, V as recoverAgent, Wn as getAgentStateSync, X as messageAgent, Xt as resolveStaffing, Z as init_operator_interventions, Zn as markAgentStoppedState, ar as setAgentPaused, at as saveSessionId, b as init_agents$1, bn as getProviderExportsForModel, cr as wipeAgentStateDirs, dn as piFifoPaths, et as getActivity, fn as init_ohmypi_fifo, fr as init_pty_token, ft as stopAgent, gr as clearReadySignal, hr as resolvePtySupervisorScriptPath, i as listRunningAgents, in as getProviderAuthMode, ir as saveAgentStateSync, kn as dismissDevChannelsDialog, kr as checkCodexAuthStatus, kt as deliverAgentMessage, lr as writeAgentStateJsonSync, mr as init_pty_supervisor_locate, nt as getLatestSessionIdSync, pn as ohmypiFifoPaths, pr as writePtyToken, qt as init_staffing, r as listAgentStates, rr as saveAgentState, rt as getSessionId, tn as getAgentRuntimeBaseCommand, tt as getLatestSessionId, un as init_pi_fifo, vn as determineModel, vr as normalizeAgentId, xr as waitForReadySignal, yn as getProviderEnvForModel, zt as writeBridgeTokenSync } from "./queries-6d7Cdtm7.js";
-import { a as performHandoff, i as checkAllTriggers, s as getAgentHealth, t as getCloisterService } from "./service-DCpB_SGd.js";
-import { o as init_persistent_logger, s as logAgentLifecycleSync } from "./session-history-CVZDpS3c.js";
-import { t as init_behavior } from "./behavior-B_-4EKF3.js";
-import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-B4itFzDo.js";
-import { n as init_issue_service_singleton, r as issue_service_singleton_exports } from "./issue-service-singleton-B5ushCvE.js";
-import { o as getInternalTokenSync, s as init_internal_token } from "./internal-token-Bb4XeV2x.js";
+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 init_paths, di as resolveOhmypiExtensionPath, ei as encodeClaudeProjectDir, f as loadConfigSync, gr as init_issue_id, h as jsYaml, hn as init_state_plane, hr as extractPrefixSync, m as init_js_yaml, si as getOverdeckHome, t as init_config_yaml, tt as resolveModel, ui as packageRoot, vn as parsePorcelainStatusPaths, vr as parseIssueIdSync, wn as shouldCommitLegacyWorkspaceArtifacts, zn as getProjectSync } from "./config-yaml-CmOPzmBb.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-BjuxvjdS.js";
+import { B as sendKeysAsync, D as killSession, H as sessionExists, M as listSessionNames, N as listSessions, Q as BLANKED_PROVIDER_ENV, T as isHarnessProcessAlive, U as sessionExistsSync, V as sendRawKeystroke, W as setOption, et as buildChildEnvWithoutTmuxSync, g as findManagedServerPidSync, i as capturePane, m as exactPaneTarget, o as capturePaneText, s as createSession, tt as init_child_env, w as init_tmux } from "./tmux-B1Wbxz5o.js";
+import { a as init_event_store, n as getEventStore } from "./event-store-zY5MJHgF.js";
+import { N as normalizeChannelReplyPayload, T as DomainEvent, n as COMPOSER_COMMAND_MANIFEST, s as getHarnessBehavior, t as init_src } from "./src-CRmCHlma.js";
+import { K as stateToOverdeckParamsForDb, S as setReviewStatusSync, U as init_agent_state_sync, V as AGENT_COLUMNS_FOR_DB, f as init_review_status, m as loadReviewStatuses, o as clearWorkspaceStuck, u as getReviewStatusSync } from "./review-status-yljtTd-q.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-C4Zj0WmE.js";
+import { d as isTerminalIssueStage, o as init_agents, u as getIssueStageSync } from "./agents-C5rWYhb6.js";
+import { n as ensureSessionContextBriefingFile, r as init_briefing_freshness } from "./briefing-freshness-DHmCSLar.js";
+import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-Bgcub5kW.js";
+import { $ as operatorInterventionEvent, $n as getAgentDir, An as getProviderExportsForModel, Bn as dismissDevChannelsDialog, Dr as init_pty_supervisor_locate, Er as writePtyToken, F as init_tier_escalation, Fr as getAgentRuntimeState, G as resumeAgent, Gt as assertWorkspaceStackHealthyForSpawn, H as restartAgent, Hr as checkCodexAuthStatus, Ht as BRIDGE_TOKEN_HEADER, Ir as getAgentRuntimeStateSync, Jt as init_spawn_prep, Mn as init_provider_health, Mt as deliverAgentMessage, Nn as validateProviderHealth, Nt as deliverAgentPermissionDecision, On as determineModel, Or as resolvePtySupervisorScriptPath, P as decideEscalation, Pr as waitForReadySignal, Q as init_operator_interventions, Qt as init_staffing, Rr as saveAgentRuntimeState, Rt as setAgentDeliveryMethod, Sr as writeAgentStateJsonSync, Tr as init_pty_token, Un as writeChannelsBridgeMcpConfig, Ur as init_codex_auth, Ut as init_bridge_token, V as recoverAgent, 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 normalizeAgentId, kr as clearReadySignal, 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-DHJm7bTd.js";
+import { a as performHandoff, i as checkAllTriggers, s as getAgentHealth, t as getCloisterService } from "./service-Br9rpBNA.js";
+import { o as init_persistent_logger, s as logAgentLifecycleSync } from "./session-history-BUyK29eq.js";
+import { t as init_behavior } from "./behavior-CfIg6pKp.js";
+import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-DZ8Zn2nQ.js";
+import { n as init_issue_service_singleton, r as issue_service_singleton_exports } from "./issue-service-singleton-DmCh7EHj.js";
+import { o as getInternalTokenSync, s as init_internal_token } from "./internal-token-DvMTQSOS.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-DfeyBDwA.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-B3_AHDfr.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-DbOs1e9Q.js";
-import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-B0pmAz0a.js";
-import { a as requireModelOverrideSync, i as normalizeModelOverrideSync, n as init_launcher_generator, r as init_model_validation, t as generateLauncherScriptSync } from "./launcher-generator-CHVm7bGT.js";
-import { a as init_claude_permissions, o as resolvePermissionModeSync, r as getClaudePermissionFlagsStringSync, t as BYPASS_PERMISSION_MODE } from "./claude-permissions-H_5wHQZQ.js";
-import { h as workspaceContextFile, l as piGlobalContextFile, o as init_layers } from "./layers-DzxSTGNA.js";
-import { n as init_harness_binary, r as prepareHarnessLaunch } from "./harness-binary-CVio2m-u.js";
-import { a as init_stack_health, i as getWorkspaceStackHealth } from "./stack-health-puygdaMd.js";
-import { l as init_dag, o as getDispatchableItems } from "./dag-CdOjJVDT.js";
-import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-qHJBhy3Z.js";
-import { a as loadCloisterConfigSync, r as init_config } from "./config-DjLOdbgT.js";
-import { c as isStateMigrated, o as init_state_home } from "./state-home-CIGjwNfJ.js";
-import { a as init_lifecycle_io, c as updatePlanStatus, s as transitionXBriefOnMain } from "./lifecycle-io-D8iNBcux.js";
-import { _ as init_codex_conversation_parser, 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 } from "./conversation-service-Du-MTNpJ.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-CzEov_fq.js";
-import { Dt as classifyMemoryPressure, It as getSystemHealthSnapshot, Pt as getResourceConfig } from "./deacon-pRnyD5w9.js";
-import { o as stopWorkspaceDocker, r as init_workspace_manager } from "./workspace-manager-hLUv3ADC.js";
-import { a as init_jsonl_parser, o as normalizeModelName } from "./jsonl-parser-Dhflo1SH.js";
-import { r as init_in_flight_guard, t as createInFlightGuard } from "./in-flight-guard-aQ1IxeI3.js";
-import { a as loadWorkspaceMetadataSync } from "./workspace-metadata-CskwzzhL.js";
-import { basename, delimiter, dirname, join, resolve } from "node:path";
+import { l as resolveWorkspaceRepoRootsSync, o as resolvePrimaryWorkspaceRepoDirSync, r as init_project_repos } from "./project-repos-C0nuoBGv.js";
+import { a as generateXBriefFilename, o as init_lifecycle } from "./lifecycle-CTdOWYMi.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-VHvc0Ssp.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-BUpYsOZg.js";
+import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population--YUXU999.js";
+import { d as generateLauncherScriptSync, f as init_launcher_generator, g as requireModelOverrideSync, h as normalizeModelOverrideSync, m as init_model_validation, p as MODEL_ID_PATTERN } from "./tmux-dedup-DbN6MGzM.js";
+import { a as init_claude_permissions, o as resolvePermissionModeSync, r as getClaudePermissionFlagsStringSync, t as BYPASS_PERMISSION_MODE } from "./claude-permissions-CN0cSCPp.js";
+import { E as init_layers, I as workspaceContextFile, k as piGlobalContextFile } from "./assemble-DnffNpOo.js";
+import { i as prepareHarnessLaunch, r as init_harness_binary } from "./harness-binary-DqkftwTb.js";
+import { a as getWorkspaceStackHealth, s as init_stack_health } from "./stack-health-DqSqx0zv.js";
+import { l as init_dag, o as getDispatchableItems } from "./dag-ombYYt4s.js";
+import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-CqMqM1Mb.js";
+import { a as loadCloisterConfigSync, r as init_config } from "./config-B2IMcBxx.js";
+import { c as isStateMigrated, o as init_state_home } from "./state-home-BYV7qZTW.js";
+import { a as init_lifecycle_io, c as updatePlanStatus, s as transitionXBriefOnMain } from "./lifecycle-io-D-lGdzK3.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-5aCnq1zR.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-mkLC6G_t.js";
+import { B as getBook, H as liveOrderIssueLookup, T as resolveLiveFlywheelRunId, w as readFlywheelLaunchMetadata, y as getFlywheelRunDir, z as computeBookProgress } from "./flywheel-BiT3odRb.js";
+import { Ft as getResourceConfig, Lt as getSystemHealthSnapshot, Ot as classifyMemoryPressure } from "./deacon-hi9KLPLT.js";
+import { o as stopWorkspaceDocker, r as init_workspace_manager } from "./workspace-manager-CwO-Hek7.js";
+import { a as init_jsonl_parser, o as normalizeModelName } from "./jsonl-parser-DJOH_O-w.js";
+import { r as init_in_flight_guard, t as createInFlightGuard } from "./in-flight-guard-Bq3epG58.js";
+import { a as loadWorkspaceMetadataSync } from "./workspace-metadata-CQv00QwK.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";
@@ -51,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();
@@ -85,6 +87,7 @@ init_projects();
 init_providers();
 init_harness_policy();
 init_tier_table();
+init_js_yaml();
 init_config_yaml();
 init_child_env();
 init_tmux();
@@ -100,6 +103,7 @@ init_cost();
 init_behavior();
 init_persistent_logger();
 init_tracker_config();
+init_project_repos();
 init_lifecycle();
 init_review_status();
 init_io();
@@ -200,10 +204,12 @@ init_layers();
 init_harness_binary();
 init_ohmypi_fifo();
 init_pi_fifo();
+init_runtime_command();
 init_stack_health();
 init_launcher_generator();
 init_dag();
 init_staffing();
+init_spawn_prep();
 init_harness_resolve();
 init_bridge_token();
 init_operator_interventions();
@@ -215,6 +221,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);
@@ -229,6 +256,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");
@@ -364,7 +395,215 @@ async function waitForSessionRespawn(sessionName, timeoutMs) {
 	return Effect.runPromise(sessionExists(sessionName));
 }
 //#endregion
+//#region routes/dashboard-auth.ts
+init_state_read_home();
+init_state_plane();
+init_types();
+init_issue_lifecycle();
+init_codex_auth();
+init_config();
+init_state_home();
+init_internal_token();
+const DASHBOARD_SESSION_COOKIE = "overdeck_session";
+const DASHBOARD_CSRF_HEADER = "x-overdeck-csrf-token";
+const DASHBOARD_SESSION_MAX_AGE_SECONDS = 3600 * 24 * 30;
+let browserSessionToken;
+let browserCsrfToken;
+function getDashboardSessionToken() {
+	if (browserSessionToken) return browserSessionToken;
+	const override = process.env["OVERDECK_DASHBOARD_SESSION_TOKEN"];
+	if (override) {
+		browserSessionToken = override;
+		return browserSessionToken;
+	}
+	const internal = getInternalTokenSync();
+	browserSessionToken = internal ? createHmac("sha256", internal).update("overdeck-dashboard-session-v1").digest("base64url") : randomBytes(32).toString("base64url");
+	return browserSessionToken;
+}
+function dashboardCsrfToken() {
+	if (browserCsrfToken) return browserCsrfToken;
+	const override = process.env["OVERDECK_DASHBOARD_CSRF_TOKEN"];
+	if (override) {
+		browserCsrfToken = override;
+		return browserCsrfToken;
+	}
+	const internal = getInternalTokenSync();
+	browserCsrfToken = internal ? createHmac("sha256", internal).update("overdeck-dashboard-csrf-v1").digest("base64url") : randomBytes(32).toString("base64url");
+	return browserCsrfToken;
+}
+function constantTimeTokenEqual$1(provided, expected) {
+	if (!provided) return false;
+	return timingSafeEqual(createHash$1("sha256").update(provided).digest(), createHash$1("sha256").update(expected).digest());
+}
+function cookieValue(cookieHeader, name) {
+	if (!cookieHeader) return void 0;
+	for (const part of cookieHeader.split(";")) {
+		const [rawKey, ...rawValue] = part.trim().split("=");
+		if (rawKey !== name) continue;
+		try {
+			return decodeURIComponent(rawValue.join("="));
+		} catch {
+			return;
+		}
+	}
+}
+function dashboardSessionCookieHeader(options = {}) {
+	const secure = options.secure ? "; Secure" : "";
+	return `${DASHBOARD_SESSION_COOKIE}=${encodeURIComponent(getDashboardSessionToken())}; Path=/; HttpOnly; SameSite=Strict; Max-Age=${DASHBOARD_SESSION_MAX_AGE_SECONDS}${secure}`;
+}
+function hasDashboardInternalTokenHeaders(headers) {
+	const expected = getInternalTokenSync();
+	if (!expected) return false;
+	if (constantTimeTokenEqual$1(getHeaderFromMap(headers, "x-overdeck-internal-token"), expected)) return true;
+	const authorization = getHeaderFromMap(headers, "authorization");
+	if (authorization) {
+		const [scheme, token] = authorization.split(/\s+/);
+		if (scheme?.toLowerCase() === "bearer" && constantTimeTokenEqual$1(token, expected)) return true;
+	}
+	return false;
+}
+function hasDashboardInternalToken(request) {
+	return hasDashboardInternalTokenHeaders(request.headers);
+}
+function hasDashboardAuthHeaders(headers) {
+	return hasDashboardInternalTokenHeaders(headers) || constantTimeTokenEqual$1(cookieValue(getHeaderFromMap(headers, "cookie"), "overdeck_session"), getDashboardSessionToken());
+}
+function hasDashboardAuth(request) {
+	return hasDashboardAuthHeaders(request.headers);
+}
+function isJsonContentType(headers) {
+	const contentType = getHeaderFromMap(headers, "content-type");
+	if (!contentType) return false;
+	const [mime] = contentType.toLowerCase().split(";");
+	return mime.trim() === "application/json";
+}
+function hasTrustedExactOrigin(headers) {
+	const origin = getHeaderFromMap(headers, "origin");
+	if (!origin) return false;
+	const normalized = normalizeOrigin(origin);
+	return !!normalized && getTrustedOrigins().includes(normalized);
+}
+function hasValidCsrfToken(headers) {
+	return constantTimeTokenEqual$1(getHeaderFromMap(headers, DASHBOARD_CSRF_HEADER), dashboardCsrfToken());
+}
+function rejectUnsafeDashboardMutationRequest(request) {
+	const authError = rejectUnauthorizedDashboardRequest(request);
+	if (authError) return authError;
+	const headers = request.headers;
+	if (!isJsonContentType(headers)) return jsonResponse({ error: "Content-Type must be application/json" }, { status: 400 });
+	if (hasDashboardInternalToken(request)) return null;
+	if (getHeaderFromMap(headers, "origin") && !hasTrustedExactOrigin(headers)) return jsonResponse({ error: "Invalid origin" }, { status: 403 });
+	if (!hasValidCsrfToken(headers)) return jsonResponse({ error: "Invalid CSRF token" }, { status: 403 });
+	return null;
+}
+function ipv4ToInt(value) {
+	const parts = value.split(".");
+	if (parts.length !== 4) return null;
+	let result = 0;
+	for (const part of parts) {
+		const octet = Number(part);
+		if (!Number.isInteger(octet) || octet < 0 || octet > 255) return null;
+		result = (result << 8 | octet) >>> 0;
+	}
+	return result;
+}
+/** RFC1918 private ranges — Docker bridges always fall inside one of these. */
+function isRfc1918(ip) {
+	return (ip & 4278190080) >>> 0 === 167772160 || (ip & 4293918720) >>> 0 === 2886729728 || (ip & 4294901760) >>> 0 === 3232235520;
+}
+/**
+* True when `addr` is the IP of a container on one of THIS host's Docker bridge
+* interfaces (docker0 / br-*). Such a peer can only be a process running on this
+* machine — our own host-local Traefik fronting overdeck.localhost, or another
+* Overdeck container — never a LAN client (a direct LAN hit to the 0.0.0.0
+* API port arrives with a LAN peer that is not inside any Docker bridge subnet).
+*
+* Pure for testability: the interface map is injected. We only ever trust
+* RFC1918 bridge subnets, so a misconfigured public-range br-* cannot widen
+* trust beyond the local Docker fabric.
+*/
+function peerIsHostLocalDockerBridge(addr, interfaces) {
+	const peer = ipv4ToInt(addr);
+	if (peer === null) return false;
+	for (const [name, addrs] of Object.entries(interfaces)) {
+		if (name !== "docker0" && !name.startsWith("br-")) continue;
+		for (const info of addrs ?? []) {
+			if (info.family !== "IPv4") continue;
+			const ifaceIp = ipv4ToInt(info.address);
+			const mask = ipv4ToInt(info.netmask);
+			if (ifaceIp === null || mask === null) continue;
+			const network = (ifaceIp & mask) >>> 0;
+			if (!isRfc1918(network)) continue;
+			if ((peer & mask) >>> 0 === network) return true;
+		}
+	}
+	return false;
+}
+/**
+* True when `addr` shares an RFC1918 subnet with one of THIS process's own
+* network interfaces. This is the in-container counterpart of
+* peerIsHostLocalDockerBridge: inside a container the Docker bridge is
+* invisible — the container sees only its veth endpoints (eth0/eth1), so the
+* docker0/br-* name filter never matches and the host-local Traefik fronting
+* the stack 401'd every session mint (first hit live on the PAN-1737 UAT
+* stack). A peer inside one of the container's attached Docker-network
+* subnets can only be another container on those networks — the server
+* publishes no host port (Traefik labels only), so no LAN client can ever
+* present such an address. Only consulted when running inside a container.
+*/
+function peerIsLocalContainerNetwork(addr, interfaces) {
+	const peer = ipv4ToInt(addr);
+	if (peer === null) return false;
+	for (const addrs of Object.values(interfaces)) for (const info of addrs ?? []) {
+		if (info.family !== "IPv4" || info.internal) continue;
+		const ifaceIp = ipv4ToInt(info.address);
+		const mask = ipv4ToInt(info.netmask);
+		if (ifaceIp === null || mask === null) continue;
+		const network = (ifaceIp & mask) >>> 0;
+		if (!isRfc1918(network)) continue;
+		if ((peer & mask) >>> 0 === network) return true;
+	}
+	return false;
+}
+/** Docker creates /.dockerenv in every container — stable in-container signal. */
+const runningInContainer = existsSync("/.dockerenv");
+/**
+* A request we trust to mint a session because it originated from this machine —
+* the local browser hitting the dashboard directly (127.0.0.1), or the
+* host-local Traefik that fronts overdeck.localhost. In Docker, that Traefik reaches
+* the host server from a Docker-bridge IP (e.g. 172.18.0.2), NOT 127.0.0.1, so
+* a literal-loopback check alone silently breaks the zero-step bootstrap for
+* every overdeck.localhost user — their session mint 401s and no cookie is ever set.
+*
+* This is the auto-bootstrap that removes the manual one-time #overdeck_token
+* step: any browser on overdeck.localhost gets a session with no user action. It is
+* NOT a security downgrade for the LAN — the raw API ports bind 0.0.0.0, but a
+* direct LAN hit has a non-loopback, non-Docker-bridge peer and is rejected. We
+* read ONLY the real TCP peer (request.remoteAddress), never X-Forwarded-For,
+* which a caller could spoof.
+*/
+function isLoopbackPeer(request) {
+	const remoteAddress = request.remoteAddress;
+	const raw = remoteAddress && typeof remoteAddress === "object" && "_tag" in remoteAddress ? Option.getOrElse(remoteAddress, () => "") : typeof remoteAddress === "string" ? remoteAddress : "";
+	if (!raw) return false;
+	const addr = raw.startsWith("::ffff:") ? raw.slice(7) : raw;
+	if (addr === "127.0.0.1" || addr === "::1") return true;
+	if (peerIsHostLocalDockerBridge(addr, networkInterfaces())) return true;
+	return runningInContainer && peerIsLocalContainerNetwork(addr, networkInterfaces());
+}
+function rejectUnauthorizedDashboardSessionMintRequest(request) {
+	if (!getInternalTokenSync()) return jsonResponse({ error: "dashboard session token not configured" }, { status: 503 });
+	if (!hasDashboardInternalToken(request) && !isLoopbackPeer(request)) return jsonResponse({ error: "unauthorized" }, { status: 401 });
+	return null;
+}
+function rejectUnauthorizedDashboardRequest(request) {
+	if (!getInternalTokenSync()) return jsonResponse({ error: "dashboard session token not configured" }, { status: 503 });
+	if (!hasDashboardAuth(request)) return jsonResponse({ error: "unauthorized" }, { status: 401 });
+	return null;
+}
+//#endregion
 //#region routes/jsonl-resolver.ts
+init_acp_conversation_parser();
 init_codex_conversation_parser();
 init_ohmypi_conversation_parser();
 init_pi_conversation_parser();
@@ -390,6 +629,8 @@ init_conversation_service();
 *                       order no longer reflects time-recency. We disambiguate
 *                       across all listed IDs by JSONL mtime.
 *   3. runtime state  — in-process mirror, populated by hooks
+*   4. agents registry — the DB row's session_id recorded at spawn; survives
+*                        janitor removal of the agent directory
 *
 * Async-only (fs/promises) because this code path runs inside the dashboard
 * server's event loop.
@@ -475,6 +716,10 @@ async function resolveClaudeSessionId(agentId, opts = {}) {
 		const runtimeState = await (opts.getRuntimeStateAsync ?? ((id) => Effect.runPromise(getAgentRuntimeState(id))))(agentId);
 		if (runtimeState?.claudeSessionId) return runtimeState.claudeSessionId;
 	} catch {}
+	if (!opts.agentsDirOverride) {
+		const registrySessionId = getAgentStateSync(agentId)?.sessionId?.trim();
+		if (registrySessionId) return registrySessionId;
+	}
 	return null;
 }
 /**
@@ -532,7 +777,7 @@ async function readRecordedState(agentId, opts) {
 * Resolve the harness for transcript routing. Reads state.json, then
 * self-corrects when the recorded value is stale.
 *
-* Trust an explicit non-default harness (codex / pi / ohmypi) — it was chosen
+* Trust an explicit non-default harness (codex / pi / ohmypi / acp) — it was chosen
 * by resolveHarness at spawn time and is not the generic fallback. The
 * 'claude-code' default, however, goes stale in one observed case: a
 * wipe-and-respawn that changed the provider-default harness left state.json
@@ -550,8 +795,9 @@ async function readRecordedState(agentId, opts) {
 */
 async function resolveAgentHarness(agentId, opts = {}) {
 	const recorded = (await readRecordedState(agentId, opts)).harness;
-	if (recorded === "codex" || recorded === "pi" || recorded === "ohmypi") return recorded;
+	if (recorded === "codex" || recorded === "pi" || recorded === "ohmypi" || recorded === "acp") return recorded;
 	if (await agentHasClaudeTranscript(agentId, opts)) return recorded ?? "claude-code";
+	if (await resolveAcpTranscriptPath(agentId, opts)) return "acp";
 	if (await resolveCodexRolloutPath(agentId, opts)) return "codex";
 	if (await resolvePiSessionPath(agentId, opts)) return "ohmypi";
 	return recorded;
@@ -581,7 +827,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-Dg7Is5yb.js");
+	const { findRolloutPath, findLatestRollout } = await import("./codex-BdEsUFWh.js");
 	const threadId = (await readOptional(join(agentDir, "codex-thread-id")))?.trim();
 	if (threadId) {
 		const rollout = findRolloutPath(codexHome, threadId);
@@ -589,6 +835,11 @@ async function resolveCodexRolloutPath(agentId, opts = {}) {
 	}
 	return findLatestRollout(codexHome);
 }
+/** Resolve the normalized transcript written by the persistent ACP host. */
+async function resolveAcpTranscriptPath(agentId, opts = {}) {
+	const transcriptPath = join(opts.agentsDirOverride ?? join(getOverdeckHome(), "agents"), agentId, "acp-session.jsonl");
+	return await pathExists$1(transcriptPath) ? transcriptPath : null;
+}
 /**
 * Resolve the pi/kimi session JSONL (PAN-1908). Pi writes its session transcript
 * as `<iso-ts>_<session-id>.jsonl` either in the agent dir's `sessions/` subdir
@@ -599,6 +850,7 @@ async function resolveCodexRolloutPath(agentId, opts = {}) {
 async function resolvePiSessionPath(agentId, opts = {}) {
 	const agentDir = join(opts.agentsDirOverride ?? join(getOverdeckHome(), "agents"), agentId);
 	const NON_TRANSCRIPT = new Set([
+		"acp-session.jsonl",
 		"cost-events.jsonl",
 		"activity.jsonl",
 		"pending-events.jsonl"
@@ -637,6 +889,7 @@ async function resolveJsonlPath(agentId, workspacePath, opts = {}) {
 	const behavior = behaviorForHarness(harness);
 	if (behavior.transcriptKind === "codex-rollout-jsonl") return resolveCodexRolloutPath(agentId, opts);
 	if (behavior.transcriptKind === "ohmypi-jsonl") return resolvePiSessionPath(agentId, opts);
+	if (behavior.transcriptKind === "acp-jsonl") return resolveAcpTranscriptPath(agentId, opts);
 	const claudeSessionId = await resolveClaudeSessionId(agentId, opts);
 	if (!claudeSessionId) {
 		logTranscriptResolution(agentId, `missing-session-id:${harness ?? "unknown"}`, `failed harness=${harness ?? "unknown"} reason=no-session-id checked=session.id,sessions.json,runtime-state`, opts);
@@ -808,7 +1061,7 @@ async function getWorkAgentLifecycleStateSnapshot(agentOrIssueId) {
 		runtimeState: runtime,
 		agentStatus,
 		canStartFresh: (!hasLiveTmuxSession || hasLiveTmuxSession && isStopped) && (!requiresSessionResetBeforeFreshStart || isOrphaned),
-		canResumeSession: !isRunning && hasResumableBackingState && (isStopped || isCrashed),
+		canResumeSession: !isRunning && hasSavedSession && hasResumableBackingState && (isStopped || isCrashed),
 		canRestartWithContext: hasAgentState && hasWorkspace,
 		canResetSession: hasSavedSession && hasResumableBackingState,
 		requiresSessionResetBeforeFreshStart,
@@ -960,41 +1213,130 @@ 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"] : []
-	];
+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: [
@@ -1003,67 +1345,200 @@ async function spawnPanCommandDetached(input) {
 			spawnLogHandle.fd
 		]
 	});
+	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.
+*/
+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();
@@ -1083,7 +1558,7 @@ function emitStartAgentPhase(issueId, phase, status, reason, details = {}) {
 	});
 }
 const INTERNAL_TOKEN_HEADER = "x-overdeck-internal-token";
-function constantTimeTokenEqual$1(provided, expected) {
+function constantTimeTokenEqual(provided, expected) {
 	if (!provided) return false;
 	const providedBuffer = Buffer.from(provided, "utf8");
 	const expectedBuffer = Buffer.from(expected, "utf8");
@@ -1109,7 +1584,7 @@ async function validateAgentRuntimeEventAuth(request) {
 			error: "internal token not configured"
 		}, { status: 503 })
 	};
-	if (constantTimeTokenEqual$1(getHeaderFromMap(request.headers, INTERNAL_TOKEN_HEADER), expected)) return { ok: true };
+	if (constantTimeTokenEqual(getHeaderFromMap(request.headers, INTERNAL_TOKEN_HEADER), expected)) return { ok: true };
 	return {
 		ok: false,
 		response: jsonResponse({
@@ -1118,16 +1593,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,
@@ -1311,13 +1776,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();
@@ -1474,6 +1940,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);
@@ -1607,7 +2089,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);
@@ -1617,12 +2099,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,
@@ -1639,7 +2122,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,
@@ -1725,7 +2208,7 @@ const getAgentOutputRoute = HttpRouter.add("GET", "/api/agents/:id/output", http
 			} catch {}
 			let stdout;
 			if (isRemote && vmName) {
-				const { getRemoteAgentOutput } = await import("./remote-agents-CRCg1L4H.js");
+				const { getRemoteAgentOutput } = await import("./remote-agents-C1bssi41.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") {
@@ -1790,6 +2273,20 @@ async function buildConversationResponse(id) {
 				streaming: false
 			};
 		}
+		if (harness === "acp") {
+			const sessionFile = await resolveAcpTranscriptPath(id);
+			if (!sessionFile || !existsSync(sessionFile)) return EMPTY_CONVERSATION;
+			const result = await parseAcpConversationMessages(sessionFile);
+			return {
+				...result,
+				messages: result.messages.map((message) => message.role === "assistant" ? {
+					...message,
+					completedAt: message.completedAt ?? message.createdAt,
+					streaming: false
+				} : message),
+				streaming: false
+			};
+		}
 		let jsonlPath = null;
 		const pinnedSessionId = await readLauncherPinnedSessionId(id);
 		if (pinnedSessionId) {
@@ -1864,6 +2361,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) {
@@ -1879,6 +2722,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 {
@@ -1895,9 +2787,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");
@@ -2146,7 +3039,7 @@ async function cleanupConversationAttachments(name) {
 *  sessions that the lifecycle poller missed. */
 async function cleanupOrphanedConversationAttachments() {
 	try {
-		const { listConversations } = await import("./conversations-6mPANqvL.js");
+		const { listConversations } = await import("./conversations-C34dyIb9.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, {
@@ -2424,7 +3317,7 @@ async function stopConversationRuntime(conv, name) {
 function shellQuote(str) {
 	return "'" + str.replace(/'/g, "'\"'\"'") + "'";
 }
-const SAFE_MODEL_PATTERN = /^[a-zA-Z0-9_.:\/-]+$/;
+const SAFE_MODEL_PATTERN = MODEL_ID_PATTERN;
 const SAFE_EFFORT_PATTERN = /^(low|medium|high)$/;
 const SAFE_ISSUE_ID_PATTERN = /^[A-Z0-9]+-[0-9]+$/;
 const PI_CONVERSATION_SOURCE_CONTRACT = [
@@ -2436,7 +3329,7 @@ async function resolveAllowedHarness(requested, model) {
 	if (!model) return "claude-code";
 	return resolveHarness({
 		model,
-		explicit: requested === "ohmypi" || requested === "claude-code" || requested === "codex" ? requested : void 0
+		explicit: requested === "ohmypi" || requested === "claude-code" || requested === "codex" || requested === "acp" ? requested : void 0
 	});
 }
 async function isInsideGitWorkTree(dir) {
@@ -2518,6 +3411,10 @@ function shouldUseSupervisorForConversation(harness, options = {}) {
 	return getHarnessBehavior(harness).supportsPtySupervisor && process.env.OVERDECK_DOCKER_WORKSPACE !== "1" && process.env.PAN_DOCKER !== "1";
 }
 async function waitForConversationRuntimeReady(tmuxSession, harness, mode) {
+	if (harness === "acp") {
+		await waitForAcpHostReady(tmuxSession);
+		return;
+	}
 	const transcriptKind = getHarnessBehavior(harness).transcriptKind;
 	if (transcriptKind === "ohmypi-jsonl") {
 		if (!await waitForPiTuiReady(tmuxSession)) throw new Error(`Pi (ohmypi) did not become interactive in ${tmuxSession} within the startup window — MCP server connections are likely still in progress. Retry once MCP servers finish connecting, or check ~/.claude/mcp.json for a slow/hanging server.`);
@@ -2533,7 +3430,7 @@ async function handleConversationSwitchModel(name, body) {
 	const currentHarness = conv.harness ?? "claude-code";
 	const requestedHarness = body["harness"];
 	let harness = currentHarness;
-	if (requestedHarness === "ohmypi" || requestedHarness === "pi" || requestedHarness === "claude-code" || requestedHarness === "codex") {
+	if (requestedHarness === "ohmypi" || requestedHarness === "pi" || requestedHarness === "claude-code" || requestedHarness === "codex" || requestedHarness === "acp") {
 		const requestedRuntime = requestedHarness === "pi" ? "ohmypi" : requestedHarness;
 		if (requestedRuntime !== currentHarness) {
 			const policyModel = model ?? conv.model ?? "";
@@ -2567,6 +3464,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();
@@ -2576,7 +3488,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 {
@@ -2686,14 +3599,25 @@ async function spawnConversationSession(tmuxSession, cwd, claudeSessionId, model
 	let providerExportsStr = "";
 	let piFields;
 	let codexFields;
+	let acpFields;
 	let codexTransport;
-	if (model) {
+	if (behavior.launchCommandKind === "acp-host") {
+		if (!model) throw new Error("ACP conversation requires a model");
+		if (!SAFE_MODEL_PATTERN.test(model)) throw new Error("Invalid model name");
+		const sessionIdPath = join(getOverdeckHome(), "agents", tmuxSession, "acp-session-id");
+		const resumeSessionId = resume ? await readFile(sessionIdPath, "utf-8").then((value) => value.trim() || void 0).catch(() => void 0) : void 0;
+		await rm(sessionIdPath, { force: true });
+		acpFields = {
+			...getAcpLauncherFields(tmuxSession, model, cwd, harnessLaunch.binaryPath, "work"),
+			resumeSessionId
+		};
+		runtimeCommand = "acp-host";
+	} else if (model) {
 		if (!SAFE_MODEL_PATTERN.test(model)) throw new Error("Invalid model name");
 		runtimeCommand = await getAgentRuntimeBaseCommand(model, void 0, void 0, harness);
 		const mode = resolvePermissionModeSync();
 		if (!runtimeCommand.includes("--permission-mode")) runtimeCommand = `${runtimeCommand} --permission-mode ${mode === "auto" ? "auto" : BYPASS_PERMISSION_MODE}`;
 		providerExportsStr = (await getProviderExportsForModel(model)).trim();
-		await getProviderEnvForModel(model);
 		if (behavior.transcriptKind === "ohmypi-jsonl") {
 			if (getProviderForModelSync(model).name === "openai") {
 				const auth = await getOhmypiCodexAuthStatus({ refreshIfExpired: true });
@@ -2725,7 +3649,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-Dg7Is5yb.js");
+			const { initCodexHome, extractThreadIdFromRollout } = await import("./codex-BdEsUFWh.js");
 			initCodexHome(codexHome, {
 				trustedDir: cwd,
 				approvalPolicy: codexApprovalPolicy,
@@ -2755,7 +3679,7 @@ async function spawnConversationSession(tmuxSession, cwd, claudeSessionId, model
 		await writePtyToken(tmuxSession);
 	}
 	let channelsBridgeMcpConfig;
-	if (!piFields && !codexFields && !plainFork && isClaudeCodeChannelsEnabled() && (!model || getProviderForModelSync(model).name === "anthropic") && process.env.CLAUDE_CODE_USE_BEDROCK !== "1" && process.env.CLAUDE_CODE_USE_VERTEX !== "1" && process.env.CLAUDE_CODE_USE_FOUNDRY !== "1" && process.env.OVERDECK_DOCKER_WORKSPACE !== "1" && process.env.PAN_DOCKER !== "1") {
+	if (!piFields && !codexFields && !acpFields && !plainFork && isClaudeCodeChannelsEnabled() && (!model || getProviderForModelSync(model).name === "anthropic") && process.env.CLAUDE_CODE_USE_BEDROCK !== "1" && process.env.CLAUDE_CODE_USE_VERTEX !== "1" && process.env.CLAUDE_CODE_USE_FOUNDRY !== "1" && process.env.OVERDECK_DOCKER_WORKSPACE !== "1" && process.env.PAN_DOCKER !== "1") {
 		channelsBridgeMcpConfig = join(stateDir, "agent-mcp.json");
 		writeBridgeTokenSync(tmuxSession);
 		await writeChannelsBridgeMcpConfig(channelsBridgeMcpConfig, tmuxSession);
@@ -2769,19 +3693,19 @@ async function spawnConversationSession(tmuxSession, cwd, claudeSessionId, model
 		unsetProviderEnv: true,
 		overdeckEnv: {
 			...issueId ? { issueId } : {},
-			...piFields || codexFields || useSupervisor ? { agentId: tmuxSession } : {}
+			...piFields || codexFields || acpFields || useSupervisor ? { agentId: tmuxSession } : {}
 		},
 		extraEnvExports: [harnessLaunch.pathExport, `export OVERDECK_DASHBOARD_URL="http://127.0.0.1:${process.env["API_PORT"] ?? process.env["PORT"] ?? "3011"}"`],
 		providerExports: providerExportsStr || void 0,
 		trapHup: true,
 		baseCommand: runtimeCommand,
-		appendSystemPromptFiles: piFields ? await piConversationSystemPromptFiles(cwd) : codexFields ? [] : await claudeConversationSystemPromptFiles(cwd),
+		appendSystemPromptFiles: piFields ? await piConversationSystemPromptFiles(cwd) : codexFields || acpFields ? [] : await claudeConversationSystemPromptFiles(cwd),
 		model: launcherModel,
-		...piFields ?? codexFields ?? {
+		...piFields ?? codexFields ?? acpFields ?? {
 			resumeSessionId: resume ? claudeSessionId : void 0,
 			sessionId: resume ? void 0 : claudeSessionId
 		},
-		extraArgs: !piFields && effort ? `--effort "${effort}"` : void 0,
+		extraArgs: !piFields && !acpFields && effort ? `--effort "${effort}"` : void 0,
 		keepAlive: true,
 		fileMode: 448,
 		channelsBridgeMcpConfig,
@@ -2794,7 +3718,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-ZTdJAy9M.js");
+		const { preTrustDirectory } = await import("./workspace-manager-CDTKjjdU.js");
 		preTrustDirectory(cwd);
 	} catch {}
 	try {
@@ -2811,7 +3735,7 @@ async function spawnConversationSession(tmuxSession, cwd, claudeSessionId, model
 		const codexHomeDir = codexFields.codexHome;
 		(async () => {
 			try {
-				const { waitForCodexRollout, extractThreadIdFromRollout, writeThreadId } = await import("./codex-Dg7Is5yb.js");
+				const { waitForCodexRollout, extractThreadIdFromRollout, writeThreadId } = await import("./codex-BdEsUFWh.js");
 				const rollout = await waitForCodexRollout(codexHomeDir, 12e4);
 				if (rollout) {
 					const threadId = extractThreadIdFromRollout(rollout);
@@ -2887,10 +3811,14 @@ async function handleConversationCreate(body, deps) {
 				await spawnConversationSession(tmuxSession, cwd, claudeSessionId, model, effort, issueId, false, harness);
 				console.log(`[conversations] tmux session ${tmuxSession} spawned, sessionId: ${claudeSessionId}`);
 				await waitForConversationRuntimeReady(tmuxSession, harness, "spawn");
-				if (message) await deliverAgentMessage(tmuxSession, message, "conversation-message", resolveConversationDeliveryMethod(conv));
+				if (message) {
+					const delivery = await deliverAgentMessage(tmuxSession, message, "conversation-message", resolveConversationDeliveryMethod(conv));
+					if (harness === "acp" && !delivery.ok) throw new Error(`ACP initial prompt did not land: ${delivery.failure ?? "unknown failure"}`);
+				}
 			} catch (spawnErr) {
 				const msg = spawnErr instanceof Error ? spawnErr.message : String(spawnErr);
 				console.error(`[conversations] background spawn failed for ${tmuxSession}: ${msg}`);
+				if (harness === "acp") await stopConversationRuntime(conv, name);
 				updateSpawnError(name, msg);
 				getEventStore().emitOnly({
 					type: "conversation.created",
@@ -2976,6 +3904,9 @@ async function handleConversationResume(name, body, deps) {
 				reattached: false,
 				sessionAlive: true
 			});
+		} catch (error) {
+			if (harness === "acp") await stopConversationRuntime(conv, name);
+			throw error;
 		} finally {
 			respawn.done();
 		}
@@ -3010,13 +3941,16 @@ async function handleConversationRestartAll(deps) {
 		const results = [];
 		for (const conv of convs) {
 			const respawn = markRespawnPending(conv.tmuxSession);
+			let attemptedHarness = conv.harness ?? "claude-code";
 			try {
 				await Effect.runPromise(killSession(conv.tmuxSession).pipe(Effect.catch(() => Effect.succeed(void 0))));
 				const oldSessionId = conv.claudeSessionId;
 				const sessionFileForResume = await deps.resolveSessionFile(conv);
 				const canResume = !!oldSessionId && !!sessionFileForResume && existsSync(sessionFileForResume);
 				const harness = await resolveAllowedHarness(conv.harness, conv.model);
+				attemptedHarness = harness;
 				await spawnConversationSession(conv.tmuxSession, conv.cwd, oldSessionId ?? randomUUID$1(), conv.model ?? void 0, conv.effort ?? void 0, conv.issueId ?? void 0, canResume, harness);
+				if (harness === "acp") await waitForConversationRuntimeReady(conv.tmuxSession, harness, "respawn");
 				setConversationHarness(conv.name, harness);
 				markConversationActive(conv.name);
 				results.push({
@@ -3027,6 +3961,7 @@ async function handleConversationRestartAll(deps) {
 			} catch (err) {
 				const msg = err instanceof Error ? err.message : String(err);
 				console.error(`[conversations] Failed to restart ${conv.name}:`, msg);
+				if (attemptedHarness === "acp") await stopConversationRuntime(conv, conv.name);
 				results.push({
 					name: conv.name,
 					model: conv.model,
@@ -3230,6 +4165,7 @@ function pickDeliverAs(bodyDeliverAs) {
 }
 function resolveConversationDeliveryMethod(conv) {
 	const harness = conv.harness ?? "claude-code";
+	if (harness === "acp") return "auto";
 	if (isPiControlChannelHarness(harness)) return "auto";
 	if (harness === "codex" && loadConfigSync().config.codex?.transport !== "tui") return "auto";
 	return conv.deliveryMethod ?? (getHarnessBehavior(harness).deliveryKind === "rpc-fifo" ? "tmux" : "auto");
@@ -3690,14 +4626,14 @@ 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-DXdfprGr.js"));
+	const { INTERNAL_TOKEN_HEADER, getInternalTokenSync } = yield* Effect.promise(() => import("./internal-token-M9omeXM1.js"));
 	const expected = getInternalTokenSync();
 	if (!expected) return jsonResponse({
 		ok: false,
 		error: "internal token not configured"
 	}, { status: 503 });
 	const rawHeader = request.headers[INTERNAL_TOKEN_HEADER];
-	if (!constantTimeTokenEqual$1(Array.isArray(rawHeader) ? rawHeader[0] : rawHeader, expected)) return jsonResponse({
+	if (!constantTimeTokenEqual(Array.isArray(rawHeader) ? rawHeader[0] : rawHeader, expected)) return jsonResponse({
 		ok: false,
 		error: "forbidden"
 	}, { status: 403 });
@@ -3826,6 +4762,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.
@@ -3946,6 +4883,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;
 	}
 };
@@ -3957,7 +4913,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-CpfvuVmm.js"));
+	const { getHealthHistory } = yield* Effect.promise(() => import("./health-events-_xfTaOUs.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());
@@ -3970,9 +4926,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-hZpxIw1E.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,
@@ -3998,7 +4963,7 @@ function emitAgentRuntimeEvent(id, body, timestamp) {
 				detail: String(decoded.failure)
 			}, { status: 400 })
 		};
-		const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-CnzFKSAQ.js"));
+		const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-hZpxIw1E.js"));
 		yield* (yield* AgentStateService).emit(decoded.success);
 		return {
 			ok: true,
@@ -4080,7 +5045,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-CnzFKSAQ.js"));
+	const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-hZpxIw1E.js"));
 	const snapshot = yield* (yield* AgentStateService).get(id);
 	if (!snapshot) return jsonResponse({
 		success: false,
@@ -4265,8 +5230,8 @@ function createAgentStopHandler(lifecycleEvent) {
 		yield* stopAgent(id);
 		if (stateBeforeStop?.issueId) yield* Effect.promise(async () => {
 			try {
-				const { resolveProjectFromIssueSync } = await import("./projects-9SkRpES9.js");
-				const { findWorkspacePath } = await import("./archive-planning-zkJb3BeM.js");
+				const { resolveProjectFromIssueSync } = await import("./projects-B03Wr-xc.js");
+				const { findWorkspacePath } = await import("./archive-planning-0FJ6Xd3b.js");
 				const issueLower = stateBeforeStop.issueId.toLowerCase();
 				const workspacePath = findWorkspacePath(resolveProjectFromIssueSync(stateBeforeStop.issueId)?.projectPath ?? process.cwd(), issueLower);
 				if (workspacePath) {
@@ -4402,9 +5367,18 @@ const postAgentUnpauseRoute = HttpRouter.add("POST", "/api/agents/:id/unpause",
 		payload: buildAgentControlEventPayload(updatedState, toAgentStatusPayload(stateBeforeUnpause.status), hasLiveTmuxSession)
 	});
 	invalidateAgentsCache();
+	let resumeTriggered = false;
+	if ((yield* getWorkAgentLifecycleState(id)).canResumeSession && updatedState.troubled !== true) {
+		resumeTriggered = true;
+		yield* Effect.promise(() => appendAgentLifecycleLog(id, "agent.unpause_immediate_resume_triggered"));
+		import("./resume-u9byntrq.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));
+	}
 	return jsonResponse({
 		success: true,
-		agent: updatedState
+		agent: updatedState,
+		resumeTriggered
 	});
 })));
 const postAgentUntroubledRoute = HttpRouter.add("POST", "/api/agents/:id/untroubled", httpHandler(Effect.gen(function* () {
@@ -4442,6 +5416,7 @@ const postAgentUntroubledRoute = HttpRouter.add("POST", "/api/agents/:id/untroub
 init_config_yaml();
 init_agents$1();
 init_harness_policy();
+init_model_validation();
 init_operator_interventions();
 init_projects();
 init_tmux();
@@ -5090,7 +6065,6 @@ const postAgentsRestartWithConfigRoute = HttpRouter.add("POST", "/api/agents/res
 })));
 //#endregion
 //#region routes/agents/control.ts
-init_config();
 init_jsonl_parser();
 init_model_validation();
 init_paths();
@@ -5244,12 +6218,328 @@ const postAgentSwitchModelRoute = HttpRouter.add("POST", "/api/agents/:id/switch
 	return jsonResponse({ error: `Agent ${(yield* HttpRouter.params)["id"] ?? ""} model is locked once the agent is spawned` }, { status: 409 });
 })));
 //#endregion
+//#region ../../lib/orders/eligibility.ts
+function evaluateOrderDispatchEligibility(input) {
+	const issueId = input.issueId.toUpperCase();
+	const item = input.book.items.find((candidate) => candidate.issue.toUpperCase() === issueId);
+	if (!item) {
+		const overrideUsed = input.offBook === true;
+		return {
+			eligible: overrideUsed,
+			overrideUsed,
+			...overrideUsed ? {} : {
+				code: "off-book",
+				message: `Issue ${issueId} is not in active order book ${input.book.id}; work-agent dispatch is blocked. Retry with --off-book only for an intentional exception.`
+			},
+			conditions: [{
+				key: "book-membership",
+				met: overrideUsed,
+				detail: overrideUsed ? `Issue ${issueId} is outside the book and the operator supplied --off-book.` : `Issue ${issueId} is not a member of ${input.book.id}.`
+			}]
+		};
+	}
+	const terminalByIssue = new Map(input.progress.items.map((progress) => [progress.issue.toUpperCase(), progress.terminal]));
+	for (const [issue, terminal] of input.prerequisiteTerminal ?? []) if (!terminalByIssue.has(issue.toUpperCase())) terminalByIssue.set(issue.toUpperCase(), terminal);
+	const unmetPrereq = item.prereqs.find((prereq) => terminalByIssue.get(prereq.toUpperCase()) !== true);
+	const prereqsMet = unmetPrereq === void 0;
+	const otherInFlight = input.book.items.filter((candidate) => candidate.issue.toUpperCase() !== issueId && input.inFlightIssues.has(candidate.issue.toUpperCase()));
+	const laneBBlocker = item.lane === "B" ? otherInFlight.find((candidate) => candidate.lane === "B") : void 0;
+	const laneAInFlight = otherInFlight.filter((candidate) => candidate.lane === "A").length;
+	const laneSlotFree = item.lane === "B" ? laneBBlocker === void 0 : laneAInFlight < input.book.settings.laneAConcurrency;
+	const postureOpen = input.book.settings.posture === "open";
+	const prdReverified = !item.reVerify;
+	const conditions = [
+		{
+			key: "book-membership",
+			met: true,
+			detail: `${issueId} is a member of ${input.book.id}.`
+		},
+		{
+			key: "pickup-posture",
+			met: postureOpen,
+			detail: postureOpen ? "Order-book pickup posture is OPEN." : "Order-book pickup posture is DRAIN."
+		},
+		{
+			key: "lane-slot",
+			met: laneSlotFree,
+			detail: item.lane === "B" ? laneBBlocker ? `Lane B is occupied by ${laneBBlocker.issue}.` : "Lane B has no issue in flight." : `${laneAInFlight}/${input.book.settings.laneAConcurrency} Lane A slots are in flight.`
+		},
+		{
+			key: "prerequisites",
+			met: prereqsMet,
+			detail: unmetPrereq ? `Prerequisite ${unmetPrereq.toUpperCase()} is not terminal.` : "Every prerequisite is landed or parked."
+		},
+		{
+			key: "prd-reverified",
+			met: prdReverified,
+			detail: prdReverified ? "No PRD re-verification is pending." : `${issueId} requires PRD re-verification before dispatch.`
+		}
+	];
+	if (!postureOpen) return {
+		eligible: false,
+		overrideUsed: false,
+		code: "book-draining",
+		message: `Issue ${issueId} cannot start because order book ${input.book.id} is in DRAIN posture; no new book items may dispatch.`,
+		conditions
+	};
+	if (unmetPrereq) return {
+		eligible: false,
+		overrideUsed: false,
+		code: "prerequisite-unmet",
+		message: `Issue ${issueId} cannot start because prerequisite ${unmetPrereq.toUpperCase()} has not landed or been parked.`,
+		conditions
+	};
+	if (!prdReverified) return {
+		eligible: false,
+		overrideUsed: false,
+		code: "reverify-required",
+		message: `Issue ${issueId} cannot start until its PRD has been re-verified against current main.`,
+		conditions
+	};
+	if (laneBBlocker) return {
+		eligible: false,
+		overrideUsed: false,
+		code: "lane-b-busy",
+		message: `Issue ${issueId} cannot start in Lane B because ${laneBBlocker.issue} is still in flight; Lane B allows one active issue at a time.`,
+		conditions
+	};
+	if (item.lane === "A" && !laneSlotFree) return {
+		eligible: false,
+		overrideUsed: false,
+		code: "lane-a-full",
+		message: `Issue ${issueId} cannot start in Lane A because ${laneAInFlight} issues are already in flight and laneAConcurrency is ${input.book.settings.laneAConcurrency}.`,
+		conditions
+	};
+	return {
+		eligible: true,
+		overrideUsed: false,
+		conditions
+	};
+}
+//#endregion
+//#region ../../lib/orders/dispatch-gate.ts
+init_review_status();
+init_projects();
+function stateRootFor(projectRoot) {
+	const project = findProjectByPathSync(projectRoot);
+	if (!project) throw new Error(`No configured project contains ${projectRoot}`);
+	return resolveStateReadHomeSync(project).root;
+}
+function defaultInFlightIssues(_bookId, issueIds) {
+	const inFlight = /* @__PURE__ */ new Set();
+	for (const issueId of issueIds) {
+		const lifecycle = getWorkAgentLifecycleStateSync(issueId);
+		const review = getReviewStatusSync(issueId);
+		if (lifecycle.isRunning || review !== null && review.reviewStatus !== "pending") inFlight.add(issueId.toUpperCase());
+	}
+	return inFlight;
+}
+const booklessDecision = {
+	eligible: true,
+	overrideUsed: false,
+	conditions: []
+};
+async function checkActiveOrderDispatch(projectRoot, issueId, options = {}, deps = {}) {
+	const runId = await (deps.resolveRunId ?? resolveLiveFlywheelRunId)();
+	if (!runId) return {
+		ordersBound: false,
+		decision: booklessDecision
+	};
+	const launch = await (deps.readLaunch ?? readFlywheelLaunchMetadata)(runId);
+	const bookId = launch?.orders?.bookId;
+	if (!bookId) return {
+		ordersBound: false,
+		runId,
+		decision: booklessDecision
+	};
+	const stateRoot = (deps.stateRoot ?? stateRootFor)(launch?.workspace ?? projectRoot);
+	const book = (deps.getOrderBook ?? getBook)(stateRoot, bookId);
+	if (!book) throw new Error(`Active Flywheel run ${runId} references missing order book ${bookId}`);
+	const progress = (deps.computeProgress ?? computeBookProgress)(book);
+	const prerequisiteIds = [...new Set(book.items.flatMap((item) => item.prereqs.map((prereq) => prereq.toUpperCase())))];
+	const prerequisiteState = (deps.issueLookup ?? liveOrderIssueLookup)(prerequisiteIds);
+	const prerequisiteTerminal = new Map(prerequisiteIds.map((prereq) => {
+		const state = prerequisiteState.get(prereq);
+		return [prereq, state ? !state.open || state.parked : false];
+	}));
+	const inFlightIssues = new Set((deps.inFlightIssues ?? defaultInFlightIssues)(book.id, book.items.filter((item) => !progress.items.find((entry) => entry.issue === item.issue)?.terminal).map((item) => item.issue)));
+	for (const reserved of deps.reservedIssues ?? []) inFlightIssues.add(reserved.toUpperCase());
+	return {
+		ordersBound: true,
+		runId,
+		bookId,
+		decision: evaluateOrderDispatchEligibility({
+			book,
+			progress,
+			issueId,
+			inFlightIssues,
+			prerequisiteTerminal,
+			offBook: options.offBook
+		})
+	};
+}
+async function recordOffBookOverride(runId, bookId, issueId, actor = process.env["OVERDECK_AGENT_ID"] ?? "operator") {
+	const runDir = getFlywheelRunDir(runId);
+	const path = join(runDir, "orders-overrides.jsonl");
+	await mkdir(runDir, { recursive: true });
+	await appendFile(path, `${JSON.stringify({
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		runId,
+		bookId,
+		issueId: issueId.toUpperCase(),
+		actor,
+		override: "off-book"
+	})}\n`, "utf8");
+	return path;
+}
+//#endregion
+//#region ../../lib/orders/dispatch-reservation.ts
+var OrderDispatchReservationError = class extends Error {
+	constructor(check) {
+		super(check.decision.message ?? "Order-book dispatch is blocked.");
+		this.check = check;
+		this.name = "OrderDispatchReservationError";
+	}
+};
+const DEFAULT_STALE_MS = 900 * 1e3;
+const processLocks = /* @__PURE__ */ new Map();
+let reservationSequence = 0;
+async function withProcessLock(key, action) {
+	const previous = processLocks.get(key) ?? Promise.resolve();
+	let release;
+	const current = new Promise((resolve) => {
+		release = resolve;
+	});
+	const tail = previous.then(() => current);
+	processLocks.set(key, tail);
+	await previous;
+	try {
+		return await action();
+	} finally {
+		release();
+		if (processLocks.get(key) === tail) processLocks.delete(key);
+	}
+}
+function paths(root) {
+	return {
+		state: join(root, "orders-dispatch-reservations.json"),
+		temp: join(root, `orders-dispatch-reservations.${process.pid}.tmp`),
+		lock: join(root, "orders-dispatch-reservations.lock")
+	};
+}
+async function acquireFileLock(path, staleMs, now) {
+	try {
+		await mkdir(path);
+		return;
+	} catch (error) {
+		if ((typeof error === "object" && error !== null && "code" in error ? error.code : void 0) !== "EEXIST") throw error;
+	}
+	if (await stat$1(path).then((value) => now.getTime() - value.mtimeMs).catch(() => 0) <= staleMs) throw new Error("Another order-book dispatch admission is in progress; retry after it finishes.");
+	await rm(path, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(path);
+}
+async function readReservations(path) {
+	try {
+		const parsed = JSON.parse(await readFile(path, "utf8"));
+		return Array.isArray(parsed) ? parsed : [];
+	} catch (error) {
+		if ((typeof error === "object" && error !== null && "code" in error ? error.code : void 0) === "ENOENT") return [];
+		throw error;
+	}
+}
+async function writeReservations(path, tempPath, reservations) {
+	await writeFile(tempPath, `${JSON.stringify(reservations, null, 2)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+	await rename(tempPath, path);
+}
+function freshReservations(reservations, now, staleMs) {
+	return reservations.filter((reservation) => {
+		const reservedAt = Date.parse(reservation.reservedAt);
+		return Number.isFinite(reservedAt) && now.getTime() - reservedAt <= staleMs;
+	});
+}
+async function reserveActiveOrderDispatch(projectRoot, issueId, options = {}, deps = {}) {
+	const initial = await checkActiveOrderDispatch(projectRoot, issueId, options, deps);
+	if (!initial.ordersBound || !initial.runId || !initial.bookId || !initial.decision.eligible) return {
+		check: initial,
+		release: async () => {}
+	};
+	const root = (deps.reservationRoot ?? getFlywheelRunDir)(initial.runId);
+	await mkdir(root, { recursive: true });
+	const reservationPaths = paths(root);
+	const staleMs = deps.staleMs ?? DEFAULT_STALE_MS;
+	const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+	const reservationId = `${process.pid}-${now.getTime()}-${reservationSequence++}`;
+	let check = initial;
+	await withProcessLock(reservationPaths.lock, async () => {
+		await acquireFileLock(reservationPaths.lock, staleMs, now);
+		try {
+			const current = freshReservations(await readReservations(reservationPaths.state), now, staleMs);
+			check = await checkActiveOrderDispatch(projectRoot, issueId, options, {
+				...deps,
+				reservedIssues: new Set(current.filter((reservation) => reservation.bookId === initial.bookId).map((reservation) => reservation.issueId))
+			});
+			if (!check.decision.eligible) return;
+			current.push({
+				id: reservationId,
+				bookId: initial.bookId,
+				issueId: issueId.toUpperCase(),
+				reservedAt: now.toISOString()
+			});
+			await writeReservations(reservationPaths.state, reservationPaths.temp, current);
+		} finally {
+			await rm(reservationPaths.lock, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	if (!check.decision.eligible) return {
+		check,
+		release: async () => {}
+	};
+	if (options.recordOverride && check.decision.overrideUsed) await (deps.recordOverride ?? recordOffBookOverride)(initial.runId, initial.bookId, issueId);
+	let released = false;
+	return {
+		check,
+		release: async () => {
+			if (released) return;
+			released = true;
+			const releasedAt = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+			await withProcessLock(reservationPaths.lock, async () => {
+				await acquireFileLock(reservationPaths.lock, staleMs, releasedAt);
+				try {
+					const current = freshReservations(await readReservations(reservationPaths.state), releasedAt, staleMs).filter((reservation) => reservation.id !== reservationId);
+					await writeReservations(reservationPaths.state, reservationPaths.temp, current);
+				} finally {
+					await rm(reservationPaths.lock, {
+						recursive: true,
+						force: true
+					});
+				}
+			});
+		}
+	};
+}
+async function withActiveOrderDispatchReservation(projectRoot, issueId, options, action, deps = {}) {
+	const reservation = await reserveActiveOrderDispatch(projectRoot, issueId, options, deps);
+	if (!reservation.check.decision.eligible) return { check: reservation.check };
+	try {
+		return {
+			check: reservation.check,
+			result: await action()
+		};
+	} finally {
+		await reservation.release();
+	}
+}
+//#endregion
 //#region ../../lib/xbrief/auto-synthesize.ts
-init_state_read_home();
-init_state_plane();
-init_types();
-init_codex_auth();
-init_state_home();
 init_io();
 function cleanMarkdownLine(line) {
 	return line.replace(/^[-*+]\s+\[[ xX]\]\s+/, "").replace(/^[-*+]\s+/, "").replace(/^#+\s+/, "").replace(/`([^`]+)`/g, "$1").trim();
@@ -5365,222 +6655,21 @@ const writeAutoStartXBrief = (projectRoot, workspacePath, issue) => Effect.tryPr
 	})
 });
 //#endregion
-//#region routes/dashboard-auth.ts
-init_issue_lifecycle();
-init_internal_token();
-const DASHBOARD_SESSION_COOKIE = "overdeck_session";
-const DASHBOARD_CSRF_HEADER = "x-overdeck-csrf-token";
-const DASHBOARD_SESSION_MAX_AGE_SECONDS = 3600 * 24 * 30;
-let browserSessionToken;
-let browserCsrfToken;
-function getDashboardSessionToken() {
-	if (browserSessionToken) return browserSessionToken;
-	const override = process.env["OVERDECK_DASHBOARD_SESSION_TOKEN"];
-	if (override) {
-		browserSessionToken = override;
-		return browserSessionToken;
-	}
-	const internal = getInternalTokenSync();
-	browserSessionToken = internal ? createHmac("sha256", internal).update("overdeck-dashboard-session-v1").digest("base64url") : randomBytes(32).toString("base64url");
-	return browserSessionToken;
-}
-function dashboardCsrfToken() {
-	if (browserCsrfToken) return browserCsrfToken;
-	const override = process.env["OVERDECK_DASHBOARD_CSRF_TOKEN"];
-	if (override) {
-		browserCsrfToken = override;
-		return browserCsrfToken;
-	}
-	const internal = getInternalTokenSync();
-	browserCsrfToken = internal ? createHmac("sha256", internal).update("overdeck-dashboard-csrf-v1").digest("base64url") : randomBytes(32).toString("base64url");
-	return browserCsrfToken;
-}
-function constantTimeTokenEqual(provided, expected) {
-	if (!provided) return false;
-	return timingSafeEqual(createHash$1("sha256").update(provided).digest(), createHash$1("sha256").update(expected).digest());
-}
-function cookieValue(cookieHeader, name) {
-	if (!cookieHeader) return void 0;
-	for (const part of cookieHeader.split(";")) {
-		const [rawKey, ...rawValue] = part.trim().split("=");
-		if (rawKey !== name) continue;
-		try {
-			return decodeURIComponent(rawValue.join("="));
-		} catch {
-			return;
-		}
-	}
-}
-function dashboardSessionCookieHeader(options = {}) {
-	const secure = options.secure ? "; Secure" : "";
-	return `${DASHBOARD_SESSION_COOKIE}=${encodeURIComponent(getDashboardSessionToken())}; Path=/; HttpOnly; SameSite=Strict; Max-Age=${DASHBOARD_SESSION_MAX_AGE_SECONDS}${secure}`;
-}
-function hasDashboardInternalTokenHeaders(headers) {
-	const expected = getInternalTokenSync();
-	if (!expected) return false;
-	if (constantTimeTokenEqual(getHeaderFromMap(headers, "x-overdeck-internal-token"), expected)) return true;
-	const authorization = getHeaderFromMap(headers, "authorization");
-	if (authorization) {
-		const [scheme, token] = authorization.split(/\s+/);
-		if (scheme?.toLowerCase() === "bearer" && constantTimeTokenEqual(token, expected)) return true;
-	}
-	return false;
-}
-function hasDashboardInternalToken(request) {
-	return hasDashboardInternalTokenHeaders(request.headers);
-}
-function hasDashboardAuthHeaders(headers) {
-	return hasDashboardInternalTokenHeaders(headers) || constantTimeTokenEqual(cookieValue(getHeaderFromMap(headers, "cookie"), "overdeck_session"), getDashboardSessionToken());
-}
-function hasDashboardAuth(request) {
-	return hasDashboardAuthHeaders(request.headers);
-}
-function isJsonContentType(headers) {
-	const contentType = getHeaderFromMap(headers, "content-type");
-	if (!contentType) return false;
-	const [mime] = contentType.toLowerCase().split(";");
-	return mime.trim() === "application/json";
-}
-function hasTrustedExactOrigin(headers) {
-	const origin = getHeaderFromMap(headers, "origin");
-	if (!origin) return false;
-	const normalized = normalizeOrigin(origin);
-	return !!normalized && getTrustedOrigins().includes(normalized);
-}
-function hasValidCsrfToken(headers) {
-	return constantTimeTokenEqual(getHeaderFromMap(headers, DASHBOARD_CSRF_HEADER), dashboardCsrfToken());
-}
-function rejectUnsafeDashboardMutationRequest(request) {
-	const authError = rejectUnauthorizedDashboardRequest(request);
-	if (authError) return authError;
-	const headers = request.headers;
-	if (!isJsonContentType(headers)) return jsonResponse({ error: "Content-Type must be application/json" }, { status: 400 });
-	if (hasDashboardInternalToken(request)) return null;
-	if (getHeaderFromMap(headers, "origin") && !hasTrustedExactOrigin(headers)) return jsonResponse({ error: "Invalid origin" }, { status: 403 });
-	if (!hasValidCsrfToken(headers)) return jsonResponse({ error: "Invalid CSRF token" }, { status: 403 });
-	return null;
-}
-function ipv4ToInt(value) {
-	const parts = value.split(".");
-	if (parts.length !== 4) return null;
-	let result = 0;
-	for (const part of parts) {
-		const octet = Number(part);
-		if (!Number.isInteger(octet) || octet < 0 || octet > 255) return null;
-		result = (result << 8 | octet) >>> 0;
-	}
-	return result;
-}
-/** RFC1918 private ranges — Docker bridges always fall inside one of these. */
-function isRfc1918(ip) {
-	return (ip & 4278190080) >>> 0 === 167772160 || (ip & 4293918720) >>> 0 === 2886729728 || (ip & 4294901760) >>> 0 === 3232235520;
-}
-/**
-* True when `addr` is the IP of a container on one of THIS host's Docker bridge
-* interfaces (docker0 / br-*). Such a peer can only be a process running on this
-* machine — our own host-local Traefik fronting overdeck.localhost, or another
-* Overdeck container — never a LAN client (a direct LAN hit to the 0.0.0.0
-* API port arrives with a LAN peer that is not inside any Docker bridge subnet).
-*
-* Pure for testability: the interface map is injected. We only ever trust
-* RFC1918 bridge subnets, so a misconfigured public-range br-* cannot widen
-* trust beyond the local Docker fabric.
-*/
-function peerIsHostLocalDockerBridge(addr, interfaces) {
-	const peer = ipv4ToInt(addr);
-	if (peer === null) return false;
-	for (const [name, addrs] of Object.entries(interfaces)) {
-		if (name !== "docker0" && !name.startsWith("br-")) continue;
-		for (const info of addrs ?? []) {
-			if (info.family !== "IPv4") continue;
-			const ifaceIp = ipv4ToInt(info.address);
-			const mask = ipv4ToInt(info.netmask);
-			if (ifaceIp === null || mask === null) continue;
-			const network = (ifaceIp & mask) >>> 0;
-			if (!isRfc1918(network)) continue;
-			if ((peer & mask) >>> 0 === network) return true;
-		}
-	}
-	return false;
-}
-/**
-* True when `addr` shares an RFC1918 subnet with one of THIS process's own
-* network interfaces. This is the in-container counterpart of
-* peerIsHostLocalDockerBridge: inside a container the Docker bridge is
-* invisible — the container sees only its veth endpoints (eth0/eth1), so the
-* docker0/br-* name filter never matches and the host-local Traefik fronting
-* the stack 401'd every session mint (first hit live on the PAN-1737 UAT
-* stack). A peer inside one of the container's attached Docker-network
-* subnets can only be another container on those networks — the server
-* publishes no host port (Traefik labels only), so no LAN client can ever
-* present such an address. Only consulted when running inside a container.
-*/
-function peerIsLocalContainerNetwork(addr, interfaces) {
-	const peer = ipv4ToInt(addr);
-	if (peer === null) return false;
-	for (const addrs of Object.values(interfaces)) for (const info of addrs ?? []) {
-		if (info.family !== "IPv4" || info.internal) continue;
-		const ifaceIp = ipv4ToInt(info.address);
-		const mask = ipv4ToInt(info.netmask);
-		if (ifaceIp === null || mask === null) continue;
-		const network = (ifaceIp & mask) >>> 0;
-		if (!isRfc1918(network)) continue;
-		if ((peer & mask) >>> 0 === network) return true;
-	}
-	return false;
-}
-/** Docker creates /.dockerenv in every container — stable in-container signal. */
-const runningInContainer = existsSync("/.dockerenv");
-/**
-* A request we trust to mint a session because it originated from this machine —
-* the local browser hitting the dashboard directly (127.0.0.1), or the
-* host-local Traefik that fronts overdeck.localhost. In Docker, that Traefik reaches
-* the host server from a Docker-bridge IP (e.g. 172.18.0.2), NOT 127.0.0.1, so
-* a literal-loopback check alone silently breaks the zero-step bootstrap for
-* every overdeck.localhost user — their session mint 401s and no cookie is ever set.
-*
-* This is the auto-bootstrap that removes the manual one-time #overdeck_token
-* step: any browser on overdeck.localhost gets a session with no user action. It is
-* NOT a security downgrade for the LAN — the raw API ports bind 0.0.0.0, but a
-* direct LAN hit has a non-loopback, non-Docker-bridge peer and is rejected. We
-* read ONLY the real TCP peer (request.remoteAddress), never X-Forwarded-For,
-* which a caller could spoof.
-*/
-function isLoopbackPeer(request) {
-	const remoteAddress = request.remoteAddress;
-	const raw = remoteAddress && typeof remoteAddress === "object" && "_tag" in remoteAddress ? Option.getOrElse(remoteAddress, () => "") : typeof remoteAddress === "string" ? remoteAddress : "";
-	if (!raw) return false;
-	const addr = raw.startsWith("::ffff:") ? raw.slice(7) : raw;
-	if (addr === "127.0.0.1" || addr === "::1") return true;
-	if (peerIsHostLocalDockerBridge(addr, networkInterfaces())) return true;
-	return runningInContainer && peerIsLocalContainerNetwork(addr, networkInterfaces());
-}
-function rejectUnauthorizedDashboardSessionMintRequest(request) {
-	if (!getInternalTokenSync()) return jsonResponse({ error: "dashboard session token not configured" }, { status: 503 });
-	if (!hasDashboardInternalToken(request) && !isLoopbackPeer(request)) return jsonResponse({ error: "unauthorized" }, { status: 401 });
-	return null;
-}
-function rejectUnauthorizedDashboardRequest(request) {
-	if (!getInternalTokenSync()) return jsonResponse({ error: "dashboard session token not configured" }, { status: 503 });
-	if (!hasDashboardAuth(request)) return jsonResponse({ error: "unauthorized" }, { status: 401 });
-	return null;
-}
-//#endregion
 //#region routes/agents/spawn-helpers.ts
 init_child_env();
 init_agents$1();
 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-CRCg1L4H.js"));
-		const { createFlyProviderFromConfig } = yield* Effect.promise(() => import("./remote-4tiENDaI.js"));
-		const { loadConfigSync: loadPanConfig } = yield* Effect.promise(() => import("./config-DUIhMN_T.js"));
+		const { spawnRemoteAgent, checkRemoteSpendCap } = yield* Effect.promise(() => import("./remote-agents-C1bssi41.js"));
+		const { createFlyProviderFromConfig } = yield* Effect.promise(() => import("./remote-CVGUhXMV.js"));
+		const { loadConfigSync: loadPanConfig } = yield* Effect.promise(() => import("./config-DV-grfQc.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-Yb2bd3Fq.js"));
+		const { buildWorkAgentPrompt, getTrackerContext } = yield* Effect.promise(() => import("./work-agent-prompt-C-vuP3_J.js"));
 		const trackerContext = yield* Effect.promise(() => getTrackerContext(issueId, workspacePath));
 		const agentPrompt = yield* Effect.promise(() => buildWorkAgentPrompt({
 			issueId,
@@ -5896,16 +6985,30 @@ 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();
 init_io();
 init_read_model();
 init_domain_services();
 init_tmux();
+function orderDispatchConflict(decision) {
+	if (decision.eligible) return null;
+	return {
+		status: 409,
+		body: {
+			error: decision.message ?? "Order-book dispatch is blocked.",
+			code: decision.code ?? "order-dispatch-blocked",
+			conditions: decision.conditions
+		}
+	};
+}
 /**
 * PAN-2386: emit a dashboard activity event when start-agent refuses to spawn
 * because the workspace is dirty. Kept as a pure function so the refusal path
@@ -5925,20 +7028,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) {
@@ -5974,6 +7074,7 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 	const { issueId, projectId } = body;
 	const autoStart = body.auto === true;
 	const guardrailAcknowledged = body.guardrailAcknowledged === true;
+	const offBook = body.offBook === true;
 	const requestedHostOverride = body.host === true || body.allowHost === true;
 	if (!issueId) return jsonResponse({ error: "issueId required" }, { status: 400 });
 	const legacyFields = [
@@ -6029,6 +7130,8 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 	const resolvedProject = resolveProjectFromIssueSync(String(issueId));
 	const projectConfig = resolvedProject ? getProjectSync(resolvedProject.projectKey) : null;
 	const projectPath = projectConfig?.path ?? getProjectPath(projectId, issuePrefix);
+	const orderConflict = orderDispatchConflict((yield* Effect.promise(() => checkActiveOrderDispatch(projectPath, issueId, { offBook }))).decision);
+	if (orderConflict) return jsonResponse(orderConflict.body, { status: orderConflict.status });
 	const workspacePath = join(projectPath, "workspaces", `feature-${issueLower}`);
 	if (!existsSync(workspacePath)) try {
 		const nodeDir = dirname(process.execPath);
@@ -6128,7 +7231,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}`
 		});
@@ -6173,10 +7276,18 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 	}
 	if (!isRemote) {
 		emitStartAgentPhase(issueId, "stackHealthGate", "start", "checking workspace docker stack health", { workspacePath });
-		const stackHealth = yield* getWorkspaceStackHealth(issueId, {
+		let stackHealth = yield* getWorkspaceStackHealth(issueId, {
 			projectConfig,
 			workspacePath
 		});
+		if (!stackHealth.healthy && !allowHost) {
+			emitStartAgentPhase(issueId, "stackHealthGate", "start", "stack unhealthy — attempting workspace stack rebuild", { workspacePath });
+			yield* Effect.promise(() => assertWorkspaceStackHealthyForSpawn(issueId, "work", false, workspacePath).catch(() => void 0));
+			stackHealth = yield* getWorkspaceStackHealth(issueId, {
+				projectConfig,
+				workspacePath
+			});
+		}
 		if (!stackHealth.healthy) {
 			yield* Effect.promise(() => appendAgentLifecycleLog(agentSessionName, "agent.start_blocked_stack_unhealthy", {
 				issueId,
@@ -6278,7 +7389,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-t6V-3Dcj.js");
+			const { appendSessionEntry, getProjectConfigFromWorkspacePath, resolveProjectForIssue } = await import("./record-CtroO946.js");
 			await appendSessionEntry(resolveProjectForIssue(issueId) ?? getProjectConfigFromWorkspacePath(workspacePath), issueId, {
 				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 				reason: "start",
@@ -6291,7 +7402,10 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 		if (getReviewStatusSync(issueId)?.stuckReason === "planning_auto_handoff_failed") clearWorkspaceStuck(issueId);
 	};
 	if (isRemote && workspaceMetadata) {
-		const response = yield* Effect.promise(() => spawnAfterClearingStartGates({
+		const admitted = yield* Effect.promise(() => withActiveOrderDispatchReservation(projectPath, issueId, {
+			offBook,
+			recordOverride: true
+		}, () => spawnAfterClearingStartGates({
 			agentSessionName,
 			gate: startGateBlock,
 			initialState: initialAgentState,
@@ -6305,7 +7419,10 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 				lifecycle
 			})),
 			isSuccessful: (remoteResponse) => remoteResponse.status >= 200 && remoteResponse.status < 300
-		}));
+		})));
+		const admittedConflict = orderDispatchConflict(admitted.check.decision);
+		if (admittedConflict) return jsonResponse(admittedConflict.body, { status: admittedConflict.status });
+		const response = admitted.result;
 		if (response.status < 200 || response.status >= 300) return response;
 		yield* Effect.promise(commitClearedGates);
 		yield* Effect.promise(markWorkStartAccepted);
@@ -6373,11 +7490,14 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 		console.warn(`[start-agent] Failed to check workspace status for ${issueId}: ${message}`);
 	}
 	const bodyHarness = body.harness;
-	const userPickedHarness = bodyHarness === "ohmypi" || bodyHarness === "claude-code" || bodyHarness === "codex" ? bodyHarness : null;
+	const userPickedHarness = bodyHarness === "ohmypi" || bodyHarness === "claude-code" || bodyHarness === "codex" || bodyHarness === "acp" ? bodyHarness : null;
 	let effectiveHarness = null;
 	if (userPickedHarness !== null) effectiveHarness = (yield* Effect.promise(async () => canUseHarnessSync(userPickedHarness, spawnModel, await getProviderAuthMode(spawnModel)))).allowed ? userPickedHarness : "claude-code";
 	const spawnPanCommand = async (args, cwd) => {
-		const activityId = await spawnAfterClearingStartGates({
+		const admitted = await withActiveOrderDispatchReservation(projectPath, issueId, {
+			offBook,
+			recordOverride: false
+		}, () => spawnAfterClearingStartGates({
 			agentSessionName,
 			gate: gatesCommitted ? null : startGateBlock,
 			initialState: initialAgentState,
@@ -6389,9 +7509,10 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 				args,
 				cwd
 			})
-		});
+		}));
+		if (!admitted.check.decision.eligible || !admitted.result) throw new OrderDispatchReservationError(admitted.check);
 		await commitClearedGates();
-		return activityId;
+		return admitted.result;
 	};
 	const updateIssueStatus = async () => {
 		await Effect.runPromise(lifecycle.transitionTo(issueId, "in_progress").pipe(Effect.catch(() => Effect.void)));
@@ -6475,7 +7596,8 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 			issueId,
 			model: spawnModel,
 			harness: effectiveHarness,
-			allowHost
+			allowHost,
+			offBook
 		}), workspacePath));
 		yield* Effect.promise(markWorkStartAccepted);
 		emitStartAgentPhase(issueId, "spawn", "success", "local work agent spawn requested", {
@@ -6506,6 +7628,10 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 			fallbackStatus: fallbackState.status
 		}));
 		invalidateAgentsCache();
+		if (error instanceof OrderDispatchReservationError) {
+			const conflict = orderDispatchConflict(error.check.decision);
+			return jsonResponse(conflict.body, { status: conflict.status });
+		}
 		const output = String(error?.output ?? error?.message ?? "");
 		if (output.includes(`Workspace docker stack for ${issueId}`) && output.includes("is not healthy")) {
 			const failedStackHealth = yield* getWorkspaceStackHealth(issueId, {
@@ -6713,16 +7839,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-BQM3a8z5.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-DxDfBTjr.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-DrXa1CpW.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-DTEMyIu4.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) {
@@ -6739,15 +7875,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-DVj0hvaL.js"));
+	const { getAllSpecialistStatus, getAllProjectSpecialistStatuses } = yield* Effect.promise(() => import("./specialists-Tdezg_6N.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-DVj0hvaL.js"));
-	const { clearHookSync } = yield* Effect.promise(() => import("./hooks-ltecuFqZ.js"));
+	const { getAllSpecialists, isRunning, getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-Tdezg_6N.js"));
+	const { clearHookSync } = yield* Effect.promise(() => import("./hooks-BnJsxlSq.js"));
 	const specialists = getAllSpecialists();
 	const results = [];
 	for (const specialist of specialists) {
@@ -6782,7 +7918,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",
@@ -6803,7 +7939,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-BXhav38U.js"));
+		const { reportSpecialistCompletion } = yield* Effect.promise(() => import("./specialist-completion-Br48eiDP.js"));
 		if (yield* reportSpecialistCompletion(normalizedIssueId, {
 			status,
 			notes
@@ -6847,10 +7983,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-BVwDrVrz.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-DVj0hvaL.js");
+			const { getTmuxSessionName, updateRunMetadata, makeSpecialistRegistryKey } = await import("./specialists-Tdezg_6N.js");
 			const projectKey = resolveProjectFromIssueSync(normalizedIssueId)?.projectKey;
 			const tmuxSession = projectKey ? getTmuxSessionName(`${specialist}-agent`, projectKey, normalizedIssueId) : getTmuxSessionName(`${specialist}-agent`);
 			saveAgentRuntimeState(tmuxSession, {
@@ -6869,7 +8022,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-C45ouoZ6.js");
+			const { updateSpecialistHandoffStatus } = await import("./specialist-handoff-logger-DK-GTz4s.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);
@@ -6881,10 +8034,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-Dry_Ka_D.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-CI6cwyyC.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) {
@@ -6893,11 +8048,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-ch-F-5Ci.js");
+			const { onInspectComplete } = await import("./inspect-agent-BVwDrVrz.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);
@@ -6909,7 +8064,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-Cr5PQwFC.js");
+					const { initEventStore } = await import("./event-store-ELqkVOn0.js");
 					await (await initEventStore()).appendAsync({
 						type: "test.passed",
 						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -6962,8 +8117,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-DoThH6aj.js");
-				const { messageAgent, spawnAgent, getAgentStateSync } = await import("./agents-FlIgQ3ql.js");
+				const { sessionExists } = await import("./tmux-DQ6jB76i.js");
+				const { messageAgent, spawnAgent, getAgentStateSync } = await import("./agents-BKKkxKgK.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}`);
@@ -6977,19 +8132,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-C1Kg8n7t.js");
+			const { deliverReviewVerdictFeedback } = await import("./review-verdict-feedback-BPDn4li_.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-CI6cwyyC.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",
@@ -7018,7 +8192,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-DJ3RzKxW.js"));
+	const { cleanupAllLogsSync } = yield* Effect.promise(() => import("./specialist-logs-Cl5-hqT8.js"));
 	const results = cleanupAllLogsSync();
 	return jsonResponse({
 		success: true,
@@ -7028,7 +8202,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-DVj0hvaL.js"));
+	const { getAllProjectSpecialistStatuses } = yield* Effect.promise(() => import("./specialists-Tdezg_6N.js"));
 	return jsonResponse(yield* Effect.promise(() => getAllProjectSpecialistStatuses()));
 })));
 const postSpecialistWakeRoute = HttpRouter.add("POST", "/api/specialists/:name/wake", httpHandler(Effect.gen(function* () {
@@ -7072,7 +8246,7 @@ const postSpecialistReportStatusRoute = HttpRouter.add("POST", "/api/specialists
 		"blocked",
 		"failed"
 	].includes(status)) {
-		const { getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-DVj0hvaL.js"));
+		const { getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-Tdezg_6N.js"));
 		saveAgentRuntimeState(getTmuxSessionName(name), {
 			state: "idle",
 			lastActivity: (/* @__PURE__ */ new Date()).toISOString()
@@ -7171,6 +8345,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();
@@ -7193,7 +8368,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-DVj0hvaL.js"));
+	const { getTmuxSessionName, makeSpecialistRegistryKey, getRunMetadata } = yield* Effect.promise(() => import("./specialists-Tdezg_6N.js"));
 	const tmuxSession = getRunMetadata(project, makeSpecialistRegistryKey(type, issueId)).tmuxSession ?? getTmuxSessionName(type, project, issueId);
 	yield* Effect.promise(() => Effect.runPromise(killSession(tmuxSession)).catch(() => {}));
 	saveAgentRuntimeState(tmuxSession, {
@@ -7220,7 +8395,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-DJ3RzKxW.js"));
+	const { listRunLogsSync } = yield* Effect.promise(() => import("./specialist-logs-Cl5-hqT8.js"));
 	return jsonResponse(listRunLogsSync(project, type, {
 		limit,
 		offset
@@ -7231,7 +8406,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-DJ3RzKxW.js"));
+	const { getRunLogPath, isRunLogActive } = yield* Effect.promise(() => import("./specialist-logs-Cl5-hqT8.js"));
 	const logPath = getRunLogPath(project, type, runId);
 	if (!existsSync(logPath)) return jsonResponse({ error: "Run log not found" }, { status: 404 });
 	const encoder = new TextEncoder();
@@ -7290,7 +8465,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-DJ3RzKxW.js"));
+	const { getRunLogSync, parseLogMetadata } = yield* Effect.promise(() => import("./specialist-logs-Cl5-hqT8.js"));
 	const content = getRunLogSync(project, type, runId);
 	if (!content) return jsonResponse({ error: "Run log not found" }, { status: 404 });
 	return jsonResponse({
@@ -7304,7 +8479,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-DVj0hvaL.js"));
+	const { terminateSpecialist } = yield* Effect.promise(() => import("./specialists-Tdezg_6N.js"));
 	yield* Effect.promise(() => terminateSpecialist(project, type));
 	return jsonResponse({
 		success: true,
@@ -7316,7 +8491,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-DVj0hvaL.js"));
+	const { pauseGracePeriod } = yield* Effect.promise(() => import("./specialists-Tdezg_6N.js"));
 	if (pauseGracePeriod(project, type)) return jsonResponse({
 		success: true,
 		message: "Grace period paused"
@@ -7328,7 +8503,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-DVj0hvaL.js"));
+	const { resumeGracePeriod } = yield* Effect.promise(() => import("./specialists-Tdezg_6N.js"));
 	if (resumeGracePeriod(project, type)) return jsonResponse({
 		success: true,
 		message: "Grace period resumed"
@@ -7340,7 +8515,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-DVj0hvaL.js"));
+	const { exitGracePeriod } = yield* Effect.promise(() => import("./specialists-Tdezg_6N.js"));
 	exitGracePeriod(project, type);
 	return jsonResponse({
 		success: true,
@@ -7352,7 +8527,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-DVj0hvaL.js"));
+	const { getGracePeriodState } = yield* Effect.promise(() => import("./specialists-Tdezg_6N.js"));
 	const state = getGracePeriodState(project, type);
 	if (state) return jsonResponse(state);
 	else return jsonResponse({ error: "No active grace period" }, { status: 404 });
@@ -7361,7 +8536,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-DtrYvGJ-.js"));
+	const { loadContextDigest } = yield* Effect.promise(() => import("./specialist-context-cVbGnTa3.js"));
 	const digest = loadContextDigest(project, type);
 	if (digest) return jsonResponse({ digest });
 	else return jsonResponse({ error: "No context digest found" }, { status: 404 });
@@ -7370,7 +8545,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-DtrYvGJ-.js"));
+	const { regenerateContextDigest } = yield* Effect.promise(() => import("./specialist-context-cVbGnTa3.js"));
 	const digest = yield* Effect.promise(() => regenerateContextDigest(project, type));
 	if (digest) return jsonResponse({
 		digest,
@@ -7389,7 +8564,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-DVj0hvaL.js"));
+	const { signalSpecialistCompletion } = yield* Effect.promise(() => import("./specialists-Tdezg_6N.js"));
 	signalSpecialistCompletion(project, type, {
 		status,
 		notes
@@ -7423,8 +8598,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-DJ3RzKxW.js"));
-	const { getSpecialistRetention } = yield* Effect.promise(() => import("./projects-9SkRpES9.js"));
+	const { cleanupOldLogsSync } = yield* Effect.promise(() => import("./specialist-logs-Cl5-hqT8.js"));
+	const { getSpecialistRetention } = yield* Effect.promise(() => import("./projects-B03Wr-xc.js"));
 	const retention = getSpecialistRetention(project);
 	const deleted = cleanupOldLogsSync(project, type, {
 		maxDays: retention.max_days,
@@ -7445,21 +8620,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-DJRO8EG8.js"));
+	const { killAllReviewerSessions } = yield* Effect.promise(() => import("./review-agent-CD4RCI0Y.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-DJRO8EG8.js"));
+	const { spawnReviewRoleForIssue } = yield* Effect.promise(() => import("./review-agent-CD4RCI0Y.js"));
 	const prUrl = getReviewStatusSync(issueId)?.prUrl;
 	const result = yield* spawnReviewRoleForIssue({
 		issueId,
@@ -7608,6 +8785,6 @@ const specialistsProjectRouteLayer = Layer.mergeAll(getProjectSpecialistStatusRo
 */
 const specialistsRouteLayer = Layer.mergeAll(specialistsLegacyRouteLayer, specialistsProjectRouteLayer);
 //#endregion
-export { runInBatches as $, handleConversationDelete as A, stopConversationRuntime as B, isPiControlChannelHarness as C, conversationNeedsRunningRepair as D, validateConversationControlAckOrigin as E, isInsideGitWorkTree as F, cleanupOrphanedConversationAttachments as G, waitForPiTuiReady as H, resolveAllowedHarness as I, extractConversationAttachmentPaths as J, cleanupUnreferencedConversationAttachments as K, shouldReportUnresolvedLiveSession as L, handleConversationResume as M, handleConversationStop as N, conversationSessionAliveFromState as O, handleConversationSwitchModel as P, removeConversationAttachment as Q, spawnConversationSession as R, handleConversationThinkingLevel as S, jsonStringResponse as St, resolveConversationDeliveryMethod as T, waitForTmuxSession as U, tmuxSessionExists as V, cleanupConversationAttachments as W, hasConversationAttachment as X, getConversationAttachmentsRoot as Y, isManagedConversationAttachmentPath as Z, handleConversationCodexApproval as _, validateOrigin as _t, agentsRouteLayer as a, panCliInvocation as at, handleConversationDeliveryMethod as b, getDefaultCwd as bt, hasDashboardInternalToken as c, resolveAgentHarness as ct, rejectUnsafeDashboardMutationRequest as d, resolveJsonlPath as dt, evaluateSpawnGuardrails as et, saveAgentStateAndEmitEvent as f, resolvePiSessionPath as ft, handleConversationAbort as g, isTrustedOriginForHost as gt, deliverConversationViaControlChannel as h, getHeaderFromMap as ht, validateSpecialistAutoCompleteMetadata as i, getWorkAgentLifecycleStateSync as it, handleConversationRestartAll as j, handleConversationCreate as k, rejectUnauthorizedDashboardRequest as l, resolveClaudeSessionId as lt, codexConversationPendingInput as m, waitForSessionRespawn as mt, _serverManagedMerges as n, resolveAgentGitInfo as nt, dashboardCsrfToken as o, spawnPanCli as ot, saveAgentStateAndEmitEventProgram as p, isRespawnPending as pt, ensureConversationAttachmentDir as q, firePostMergeLifecycle as r, resolveConversationGitInfo as rt, dashboardSessionCookieHeader as s, readLauncherPinnedSessionId as st, specialistsRouteLayer as t, invalidateAgentsCache as tt, rejectUnauthorizedDashboardSessionMintRequest as u, resolveCodexRolloutPath as ut, handleConversationCompact as v, validateOriginHeaders as vt, pickDeliverAs as w, handleConversationPlanAction as x, jsonResponse as xt, handleConversationControlAck as y, httpHandler as yt, startConversationModelBackfill as z };
+export { composerCommandConfirmationFromBody as $, resolveAllowedHarness as A, cleanupUnreferencedConversationAttachments as B, handleConversationCreate as C, isTrustedOriginForHost as Ct, handleConversationStop as D, getDefaultCwd as Dt, handleConversationResume as E, httpHandler 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, jsonResponse as Ot, stopConversationRuntime as P, ComposerCommandConfirmationError as Q, cleanupConversationAttachments as R, conversationSessionAliveFromState as S, getHeaderFromMap as St, handleConversationRestartAll as T, validateOriginHeaders as Tt, getConversationAttachmentsRoot as U, ensureConversationAttachmentDir as V, hasConversationAttachment as W, resolvePolicy as X, handleComposerCommandMessage as Y, ComposerCommandParseError as Z, isPiControlChannelHarness as _, rejectUnauthorizedDashboardRequest as _t, agentsRouteLayer as a, panCliInvocation as at, validateConversationControlAckOrigin as b, isRespawnPending as bt, codexConversationPendingInput as c, resolveAcpTranscriptPath as ct, handleConversationCodexApproval as d, resolveCodexRolloutPath as dt, evaluateSpawnGuardrails as et, handleConversationCompact as f, resolveJsonlPath as ft, handleConversationThinkingLevel as g, hasDashboardInternalToken as gt, handleConversationPlanAction as h, dashboardSessionCookieHeader as ht, validateSpecialistAutoCompleteMetadata as i, getWorkAgentLifecycleStateSync as it, shouldReportUnresolvedLiveSession as j, isInsideGitWorkTree as k, jsonStringResponse as kt, deliverConversationViaControlChannel as l, resolveAgentHarness as lt, handleConversationDeliveryMethod as m, dashboardCsrfToken as mt, _serverManagedMerges as n, resolveAgentGitInfo as nt, saveAgentStateAndEmitEvent as o, spawnPanCli as ot, handleConversationControlAck as p, resolvePiSessionPath as pt, runInBatches as q, firePostMergeLifecycle as r, resolveConversationGitInfo as rt, saveAgentStateAndEmitEventProgram as s, readLauncherPinnedSessionId as st, specialistsRouteLayer as t, invalidateAgentsCache as tt, handleConversationAbort as u, resolveClaudeSessionId as ut, pickDeliverAs as v, rejectUnauthorizedDashboardSessionMintRequest as vt, handleConversationDelete as w, validateOrigin as wt, conversationNeedsRunningRepair as x, waitForSessionRespawn as xt, resolveConversationDeliveryMethod as y, rejectUnsafeDashboardMutationRequest as yt, cleanupOrphanedConversationAttachments as z };
 
-//# sourceMappingURL=specialists-JVO00bs7.js.map
+//# sourceMappingURL=specialists-CNfYO3G2.js.map