@overdeck/desktop 0.45.22 → 0.45.24

package/server/{queries-ZABd5aXP.js → queries-CjNIf-Ub.js}

@@ -1,48 +1,49 @@
 import { n as __esmMin, o as __toESM } from "./rolldown-runtime-DNCzzKnI.js";
-import { B as getProviderEnvSync, Bt as resolveProjectForIssue, C as TIERED_EXECUTION_DIFFICULTIES, D as resolveTieredExecutionEnabled, Fn as getProjectSwarmHotspots, G as setupCredentialFileAuthSync, H as init_providers, Hn as init_projects, Ht as writeAgentHarnessModelSync, In as getProjectSync, K as ensureOpenAICompatibleProxyRunning, L as clearCredentialFileAuthSync, Lt as readIssueRecordForWorkspaceSync, Mr as AGENTS_DIR, Nn as getIssuePrefix, Nt as init_record, O as resolveTieredExecutionEnabledForIssue, R as getBuiltInDefaultHarness, Rt as readIssueRecordSync, S as DEFAULT_TIERED_EXECUTION_CONFIG, T as init_tier_table, V as getProviderForModelSync, Xr as encodeClaudeProjectDir, _r as require_dist, ci as sessionFilePath, dt as fnv1a32, et as init_roles, f as loadConfigSync, fr as init_issue_id, ft as init_percent, hr as resolveBareNumericIdSync, ii as init_paths, it as getModelCapabilitySync, jr as init_errors, kn as findProjectByPathSync, l as isClaudeCodeChannelsMcpEnabled, lt as resolveModelIdSync, nr as resolveProjectFromIssueSync, oi as packageRoot, ot as hasModelCapabilitySync, q as init_openai_compatible_proxy, ri as getOverdeckHome, si as resolveOhmypiExtensionPath, st as init_model_capabilities, t as init_config_yaml, tt as resolveModel, u as isTldrEnabledSync, ut as fmix32, xn as shouldCommitLegacyWorkspaceArtifacts, xr as FsError, yn as init_state_read_home, yr as ClaudeCredentialParseError } from "./config-yaml-ig8Nwtiw.js";
+import { B as getProviderEnvSync, Br as getOverdeckHome, C as TIERED_EXECUTION_DIFFICULTIES, D as resolveTieredExecutionEnabled, Ft as resolveProjectForIssue, G as setupCredentialFileAuthSync, Gr as sessionFilePath, H as init_providers, Hr as isDevMode, It as writeAgentHarnessModelSync, K as ensureOpenAICompatibleProxyRunning, L as clearCredentialFileAuthSync, Mt as readIssueRecordForWorkspaceSync, Nr as encodeClaudeProjectDir, Nt as readIssueRecordSync, O as resolveTieredExecutionEnabledForIssue, Ot as init_record, Qn as resolveBareNumericIdSync, R as getBuiltInDefaultHarness, S as DEFAULT_TIERED_EXECUTION_CONFIG, T as init_tier_table, Tn as init_projects, Ur as packageRoot, V as getProviderForModelSync, Vr as init_paths, Wr as resolveOhmypiExtensionPath, Yn as init_issue_id, dt as fnv1a32, er as require_dist, et as init_roles, f as loadConfigSync, fn as findProjectByPathSync, ft as init_percent, gn as getIssuePrefix, hr as AGENTS_DIR, in as shouldCommitLegacyWorkspaceArtifacts, ir as FsError, it as getModelCapabilitySync, l as isClaudeCodeChannelsMcpEnabled, lt as resolveModelIdSync, mr as init_errors, nn as init_state_read_home, nr as ClaudeCredentialParseError, ot as hasModelCapabilitySync, q as init_openai_compatible_proxy, st as init_model_capabilities, t as init_config_yaml, tt as resolveModel, u as isTldrEnabledSync, ut as fmix32, vn as getProjectSwarmHotspots, yn as getProjectSync, zn as resolveProjectFromIssueSync } from "./config-yaml-DySPNmKN.js";
 import { a as init_activity_logger, n as emitActivityEntrySync, r as emitActivityTtsSync } from "./activity-logger-DDlOIAML.js";
-import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-D4iNWMA5.js";
-import { B as sendRawKeystroke, D as killSession, E as isPaneDead, H as sessionExistsSync, J as BLANKED_PROVIDER_ENV, L as sendEscapeKeyAsync, M as listSessions, N as listSessionsSync, O as killSessionSync, R as sendKeys, U as setOption, V as sessionExists, Z as init_child_env, a as capturePaneSync, c as createSessionSync, i as capturePane, k as listPaneValues, m as exactPaneTarget, s as createSession, w as init_tmux } from "./tmux-L5LgvGLp.js";
-import { a as init_event_store, i as initEventStore } from "./event-store-TnWdydfB.js";
-import { a as OHMYPI_BEHAVIOR, o as getHarnessBehavior } from "./src-k039WVYY.js";
-import { D as saveOverdeckAgentStateSync, E as listOverdeckAgentStatesSync, T as init_agent_state_sync, c as init_review_status, m as resetPipelineVerdictsForWorkStartSync, w as getOverdeckAgentStateSync } from "./review-status-DFRjDFef.js";
-import { i as countAgentsByStatus, o as init_agents$1 } from "./agents-DXdHmRTC.js";
-import { n as ensureSessionContextBriefingFile, r as init_briefing_freshness } from "./briefing-freshness-C12WgkaB.js";
-import { o as getPricingSync, s as init_cost } from "./cost-Codk1pc2.js";
-import { _ as init_tier_metrics, g as estimateFeedDeliveryTokens, v as recordTierFeedDelivery } from "./cost-sync-D_cre6WM.js";
-import { a as persistCurrentSessionId, d as isAgentStateServiceInProcess, i as logLauncherSessionPinned, l as getRuntimeSnapshot, n as createFreshSessionIdentity, o as init_persistent_logger, r as init_session_history, s as logAgentLifecycleSync, u as init_agent_runtime_mirror } from "./session-history-XdS0JKp3.js";
-import { t as init_behavior } from "./behavior-CGj16clS.js";
-import { i as ensureInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-CXsfxslp.js";
+import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-BEqFxlJc.js";
+import { $ as init_child_env, A as listPaneValues, D as killSession, E as isPaneDead, H as sessionExists, O as killSessionSync, P as listSessionsSync, R as sendEscapeKeyAsync, U as sessionExistsSync, V as sendRawKeystroke, W as setOption, X as BLANKED_PROVIDER_ENV, a as capturePaneSync, c as createSessionSync, i as capturePane, m as exactPaneTarget, s as createSession, w as init_tmux, z as sendKeys } from "./tmux-R7N7y-Mh.js";
+import { a as init_event_store, i as initEventStore } from "./event-store-CQL6NeqB.js";
+import { a as OHMYPI_BEHAVIOR, o as getHarnessBehavior } from "./src-DtcUOZCq.js";
+import { D as listOverdeckAgentStatesSync, E as init_agent_state_sync, O as saveOverdeckAgentStateSync, T as getOverdeckAgentStateSync, h as resetPipelineVerdictsForWorkStartSync, l as init_review_status } from "./review-status-kZj_KyCk.js";
+import { i as countAgentsByStatus, o as init_agents$1 } from "./agents-EbI0zCJl.js";
+import { n as ensureSessionContextBriefingFile, r as init_briefing_freshness } from "./briefing-freshness-D1wzUIWv.js";
+import { o as getPricingSync, s as init_cost } from "./cost-B2ddP6wq.js";
+import { _ as init_tier_metrics, g as estimateFeedDeliveryTokens, v as recordTierFeedDelivery } from "./cost-sync-BsN6ER0n.js";
+import { a as persistCurrentSessionId, d as isAgentStateServiceInProcess, i as logLauncherSessionPinned, l as getRuntimeSnapshot, n as createFreshSessionIdentity, o as init_persistent_logger, r as init_session_history, s as logAgentLifecycleSync, u as init_agent_runtime_mirror } from "./session-history-BT3IvqhC.js";
+import { t as init_behavior } from "./behavior-B3exJ42O.js";
+import { i as ensureInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-s0-oKybJ.js";
 import { i as readReviewStatusMap, n as init_review_status_source, r as isRoleTerminal } from "./review-status-source-CxuEjLGg.js";
-import { m as readWorkspacePlanSync, o as init_io } from "./io-DQR9PMgS.js";
-import { c as bridgeGeminiAuthToCliproxy, d as getCliproxyAuthDir, g as getCliproxyLogPath, l as decodeJwtPayload$1, p as getCliproxyClientEnv, s as bridgeCodexAuthToCliproxySync, v as init_cliproxy } from "./cliproxy-Brf_5MuG.js";
-import { L as normalizeHarness, R as reactivateConversationForSpawn, S as getConversationByName, k as init_conversations, y as createConversation } from "./conversations-bYpM9-kZ.js";
-import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-B-CI9hgE.js";
-import { a as readCavemanVariant, n as init_workspace } from "./workspace-D9ppycdg.js";
-import { a as requireModelOverrideSync, i as normalizeModelOverrideSync, n as init_launcher_generator, o as shellQuoteModelIdSync, r as init_model_validation, t as generateLauncherScriptSync } from "./launcher-generator-COgR2By1.js";
-import { a as init_claude_permissions, r as getClaudePermissionFlagsStringSync } from "./claude-permissions-nSFKH78M.js";
-import { h as workspaceContextFile, o as init_layers } from "./layers-Cp1To4L8.js";
-import { a as extractThreadIdFromRollout, c as initCodexHome, l as init_codex, o as findLatestRollout } from "./codex-CbmztVcc.js";
-import { n as init_harness_binary, r as prepareHarnessLaunch } from "./harness-binary-B2CTcD84.js";
-import { f as init_config, m as loadConfigSync$1 } from "./config-q4Gvd8dq.js";
-import { a as getFlywheelActiveRunIdSync, s as init_control_settings } from "./control-settings-D_odMIaC.js";
-import { n as createTrackerFromConfig, r as init_factory, t as createTracker } from "./factory-BMrK4TrE.js";
-import { a as init_stack_health, i as getWorkspaceStackHealth } from "./stack-health-C-ifC7b0.js";
-import { i as createActiveSlice, l as init_dag, o as getDispatchableItems, s as groupItemsByWave } from "./dag-CJpgf9A3.js";
-import { c as generateFixedPointPromptSync, f as initHookSync, n as checkHookSync, p as init_hooks } from "./hooks-yxRsjk-z.js";
-import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-D5FVQTmy.js";
-import { a as loadCloisterConfigSync, r as init_config$1 } from "./config-DeTsoZdR.js";
-import { t as init_reap_terminal_sessions } from "./reap-terminal-sessions-DG9eiMVz.js";
-import { c as isStateMigrated, o as init_state_home } from "./state-home-CONQvZR0.js";
-import { n as provisionClaudeHooks, t as init_claude_hooks_provision } from "./claude-hooks-provision-D7p5WcKZ.js";
-import { a as init_lifecycle_io, t as appendContinueSessionEntryForIssue } from "./lifecycle-io-taIb0PoH.js";
-import { r as init_swarm_readiness, t as analyzeSwarmReadiness } from "./swarm-readiness-DdmJVX7y.js";
+import { m as readWorkspacePlanSync, o as init_io } from "./io-C9kF1wtJ.js";
+import { c as bridgeGeminiAuthToCliproxy, d as getCliproxyAuthDir, g as getCliproxyLogPath, l as decodeJwtPayload$1, p as getCliproxyClientEnv, s as bridgeCodexAuthToCliproxySync, v as init_cliproxy } from "./cliproxy-C8a1vtTU.js";
+import { L as normalizeHarness, R as reactivateConversationForSpawn, S as getConversationByName, k as init_conversations, y as createConversation } from "./conversations-6AfUfbwc.js";
+import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-DKZFMbFt.js";
+import { a as readCavemanVariant, n as init_workspace } from "./workspace-BPUws1-_.js";
+import { a as normalizeModelOverrideSync, i as init_model_validation, n as init_launcher_generator, o as requireModelOverrideSync, s as shellQuoteModelIdSync, t as generateLauncherScriptSync } from "./launcher-generator-BBWG_SiS.js";
+import { a as init_claude_permissions, r as getClaudePermissionFlagsStringSync } from "./claude-permissions-DNWEVV6z.js";
+import { E as init_layers, I as workspaceContextFile, P as resolveWorkspaceContextFile, c as init_render, i as workspaceContextWithoutProjectLayer, l as renderGlobalLayer, r as init_assemble, u as renderProjectLayer, v as init_harness, y as renderForHarness } from "./assemble-J2ZZ2C15.js";
+import { a as extractThreadIdFromRollout, c as initCodexHome, l as init_codex, o as findLatestRollout } from "./codex-BZXGhUVB.js";
+import { i as prepareHarnessLaunch, r as init_harness_binary } from "./harness-binary-DPUi-Pv8.js";
+import { f as init_config, m as loadConfigSync$1 } from "./config-BZ0sHTju.js";
+import { a as getFlywheelActiveRunIdSync, s as init_control_settings } from "./control-settings-BQp7_4uD.js";
+import { n as createTrackerFromConfig, r as init_factory, t as createTracker } from "./factory-CFibJuaw.js";
+import { a as getWorkspaceStackHealth, s as init_stack_health } from "./stack-health-DxSdG9cW.js";
+import { i as createActiveSlice, l as init_dag, o as getDispatchableItems, s as groupItemsByWave } from "./dag-B1ucnjDU.js";
+import { c as generateFixedPointPromptSync, f as initHookSync, n as checkHookSync, p as init_hooks } from "./hooks-CKZgXlJb.js";
+import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-3lNZkyT4.js";
+import { a as loadCloisterConfigSync, r as init_config$1 } from "./config-CKxYiCmX.js";
+import { t as init_reap_terminal_sessions } from "./reap-terminal-sessions-BtHPo6Xc.js";
+import { c as isStateMigrated, o as init_state_home } from "./state-home-Cn_Qu8IX.js";
+import { n as provisionClaudeHooks, t as init_claude_hooks_provision } from "./claude-hooks-provision-D8GXF3_s.js";
+import { a as init_lifecycle_io, t as appendContinueSessionEntryForIssue } from "./lifecycle-io-BREGpnLk.js";
+import { i as init_git_utils, o as renderWorkspaceGitShowPromise } from "./git-utils-CRw2zLPC.js";
+import { r as init_swarm_readiness, t as analyzeSwarmReadiness } from "./swarm-readiness-DlP_UjHq.js";
 import { dirname, join, relative } from "node:path";
 import { Data, Duration, Effect, FileSystem } from "effect";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, statfsSync, unlinkSync, writeFileSync } from "fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, statfsSync, unlinkSync, writeFileSync } from "fs";
 import { basename as basename$1, dirname as dirname$1, join as join$1, resolve as resolve$1 } from "path";
 import { homedir } from "os";
-import "node:os";
+import { cpus as cpus$1, loadavg as loadavg$1, platform as platform$1, totalmem as totalmem$1 } from "node:os";
 import { chmodSync as chmodSync$1, closeSync as closeSync$1, constants, cpSync, createReadStream as createReadStream$1, existsSync as existsSync$1, mkdirSync as mkdirSync$1, openSync as openSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, renameSync as renameSync$1, rmSync as rmSync$1, statSync as statSync$1, unlinkSync as unlinkSync$1, writeFileSync as writeFileSync$1, writeSync } from "node:fs";
 import { chmod, mkdir, readFile, stat as stat$1, writeFile } from "node:fs/promises";
 import { randomUUID } from "crypto";
@@ -1299,7 +1300,7 @@ function getAgentStateFilePath(agentId) {
 * PAN-1985: wipe agent state directories for an issue, optionally scoped to
 * a role prefix. Used by the restart-fresh and review-restart paths to clean
 * state before respawning — the new agent then reads `.pan/continue.json`,
-* the vBRIEF, the beads, and the branch to pick up where the prior run left
+* the xBRIEF, the beads, and the branch to pick up where the prior run left
 * off. Refuses to run against an empty or unsafe id.
 *
 * - `rolePrefix` omitted: wipes only the work agent dir (`agent-<id>`).
@@ -1712,7 +1713,7 @@ function markAgentRunning(state, options) {
 	assertAgentCanTransitionToRunning(state);
 	const oldStatus = state.status;
 	state.status = "running";
-	state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+	if (state.harness !== "codex") state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
 	if (options?.preserveFailureTracking !== true) clearFailureTrackingFields(state);
 	delete state.stoppedAt;
 	delete state.stoppedByUser;
@@ -1827,6 +1828,33 @@ var init_agent_state = __esmMin((() => {
 function buildDefaultResumeContinueMessage(issueId) {
 	return `You are resuming work on ${issueId}. Read .pan/continue.json for context and pick up where you left off — do not wait for further instructions.`;
 }
+/** Completed marker check: the agent dir's own markers, or the workspace's. */
+function hasCompletionMarkerForAgent(state) {
+	const agentDir = getAgentDir(state.id);
+	if (existsSync(join$1(agentDir, "completed")) || existsSync(join$1(agentDir, "completed.processed"))) return true;
+	const workspace = state.workspace;
+	if (workspace && (existsSync(join$1(workspace, ".pan", "completed")) || existsSync(join$1(workspace, ".pan", "completed.processed")))) return true;
+	return false;
+}
+/**
+* PAN-2974 (root cause B): the resume kickoff is phase-aware. Telling an agent
+* whose work was already handed off (completed marker) to "pick up where you
+* left off — do not wait for further instructions" makes it re-drive pipeline
+* stages on its own authority — 2026-07-21 MIN-882: a post-reboot resume
+* re-ran verification, restored config, and fired `pan review request` /
+* `pan review restart` while the operator was mid-UAT on finished work.
+* A handed-off agent gets a PASSIVE restore instead; only agents that crashed
+* mid-implementation get the aggressive kickoff.
+*/
+function buildResumeContinueMessage(state) {
+	const issueId = state.issueId;
+	if (hasCompletionMarkerForAgent(state)) return [
+		`Your session for ${issueId} was restored after a restart.`,
+		`The work was already handed off — a completed marker exists. Do NOT re-drive pipeline stages (review, test, verify, merge) on your own authority.`,
+		`Stay available for the operator and act only on new instructions.`
+	].join(" ");
+	return buildDefaultResumeContinueMessage(issueId);
+}
 async function buildResumeMessageForAgent(state, fallbackMessage, callerMessage) {
 	if (state.role !== "work" || state.kickoffDelivered !== false) return {
 		message: callerMessage ?? fallbackMessage,
@@ -2415,18 +2443,28 @@ async function getProviderEnvForModel(model) {
 	}
 	throw new Error(`No API key configured for ${provider.displayName}. Configure it in Settings before using model "${model}".`);
 }
-function getClaudeCodeAutoCompactWindowForModel(model) {
-	if (getProviderForModelSync(model).name === "anthropic") return void 0;
+function getClaudeCodeContextPolicyForModel(model) {
+	if (getProviderForModelSync(model).name === "anthropic") return {};
 	const resolvedModel = resolveModelIdSync(model);
-	if (!hasModelCapabilitySync(resolvedModel)) return void 0;
-	return getModelCapabilitySync(resolvedModel).contextWindow;
+	if (GPT_56_MODELS.has(resolvedModel)) return {
+		autoCompactWindow: GPT_56_CODEX_CLIENT_CONTEXT_WINDOW,
+		maxContextTokens: GPT_56_CODEX_CLIENT_CONTEXT_WINDOW
+	};
+	if (!hasModelCapabilitySync(resolvedModel)) return {};
+	const contextWindow = getModelCapabilitySync(resolvedModel).contextWindow;
+	if (KIMI_K3_MODELS.has(resolvedModel)) return {
+		autoCompactWindow: contextWindow,
+		maxContextTokens: contextWindow
+	};
+	return { autoCompactWindow: contextWindow };
 }
 async function getProviderExportsForModel(model) {
 	const envVars = await getProviderEnvForModel(model);
 	const unsetLines = PROVIDER_ENV_KEYS.map((key) => `unset ${key}`);
-	const autoCompactWindow = getClaudeCodeAutoCompactWindowForModel(model);
+	const contextPolicy = getClaudeCodeContextPolicyForModel(model);
 	const exportLines = Object.entries(envVars).map(([k, v]) => `export ${k}="${v.replace(/"/g, "\\\"")}"`);
-	if (autoCompactWindow !== void 0) exportLines.push(`export CLAUDE_CODE_AUTO_COMPACT_WINDOW="${autoCompactWindow}"`);
+	if (contextPolicy.maxContextTokens !== void 0) exportLines.push(`export CLAUDE_CODE_MAX_CONTEXT_TOKENS="${contextPolicy.maxContextTokens}"`);
+	if (contextPolicy.autoCompactWindow !== void 0) exportLines.push(`export CLAUDE_CODE_AUTO_COMPACT_WINDOW="${contextPolicy.autoCompactWindow}"`);
 	return [...unsetLines, ...exportLines].join("\n") + "\n";
 }
 /**
@@ -2448,11 +2486,12 @@ async function buildSpawnEnvForModel(model, baseEnv = process.env) {
 		sanitized[k] = v;
 	}
 	const providerEnv = await getProviderEnvForModel(model);
-	const autoCompactWindow = getClaudeCodeAutoCompactWindowForModel(model);
+	const contextPolicy = getClaudeCodeContextPolicyForModel(model);
 	return {
 		...sanitized,
 		...providerEnv,
-		...autoCompactWindow !== void 0 ? { CLAUDE_CODE_AUTO_COMPACT_WINDOW: String(autoCompactWindow) } : {}
+		...contextPolicy.maxContextTokens !== void 0 ? { CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(contextPolicy.maxContextTokens) } : {},
+		...contextPolicy.autoCompactWindow !== void 0 ? { CLAUDE_CODE_AUTO_COMPACT_WINDOW: String(contextPolicy.autoCompactWindow) } : {}
 	};
 }
 /**
@@ -2492,7 +2531,7 @@ function determineModel(options = {}) {
 	if ((options.role ?? "work") === "work" && !modelOverride && WORK_AGENT_BROKEN_MODELS.has(resolved)) throw new Error(`Resolved work model "${resolved}" is known-broken for work agents. Set roles.work.model to a working model in config.yaml, or pass an explicit --model override.`);
 	return resolved;
 }
-var CLI_PROXY_MODEL_ALIASES, PROVIDER_ENV_KEYS, WORK_AGENT_BROKEN_MODELS;
+var CLI_PROXY_MODEL_ALIASES, PROVIDER_ENV_KEYS, GPT_56_CODEX_CLIENT_CONTEXT_WINDOW, GPT_56_MODELS, KIMI_K3_MODELS, WORK_AGENT_BROKEN_MODELS;
 var init_provider_env = __esmMin((() => {
 	init_config_yaml();
 	init_workspace();
@@ -2517,6 +2556,7 @@ var init_provider_env = __esmMin((() => {
 		"ANTHROPIC_SMALL_FAST_MODEL",
 		"CLAUDE_CODE_SUBAGENT_MODEL",
 		"CLAUDE_CODE_AUTO_COMPACT_WINDOW",
+		"CLAUDE_CODE_MAX_CONTEXT_TOKENS",
 		"OPENAI_API_KEY",
 		"GEMINI_API_KEY",
 		"API_TIMEOUT_MS",
@@ -2529,6 +2569,13 @@ var init_provider_env = __esmMin((() => {
 		"NOUS_API_KEY",
 		"DASHSCOPE_API_KEY"
 	];
+	GPT_56_CODEX_CLIENT_CONTEXT_WINDOW = 372e3;
+	GPT_56_MODELS = new Set([
+		"gpt-5.6-sol",
+		"gpt-5.6-terra",
+		"gpt-5.6-luna"
+	]);
+	KIMI_K3_MODELS = new Set(["k3", "k3[1m]"]);
 	WORK_AGENT_BROKEN_MODELS = /* @__PURE__ */ new Set([]);
 }));
 //#endregion
@@ -2637,6 +2684,34 @@ var init_claude_auth = __esmMin((() => {
 	});
 }));
 //#endregion
+//#region ../../lib/acp/context.ts
+function materializeAcpContextFile(agentDir, workspace) {
+	const sections = [renderGlobalLayer("acp", isDevMode())];
+	const project = findProjectByPathSync(workspace);
+	if (project) sections.push(renderProjectLayer(project.path, "acp"));
+	const workspaceFile = resolveWorkspaceContextFile(workspace);
+	if (existsSync$1(workspaceFile)) {
+		const workspaceContent = readFileSync$1(workspaceFile, "utf8");
+		const workspaceOnly = project ? workspaceContextWithoutProjectLayer(workspaceContent) : workspaceContent;
+		sections.push(renderForHarness(workspaceOnly, "acp").trim());
+	}
+	const content = sections.filter((section) => section.trim().length > 0).join(SECTION_SEPARATOR);
+	const contextPath = join(agentDir, "acp-context.md");
+	mkdirSync$1(dirname(contextPath), { recursive: true });
+	writeFileSync$1(contextPath, `${content.trim()}\n`, { mode: 384 });
+	return contextPath;
+}
+var SECTION_SEPARATOR;
+var init_context = __esmMin((() => {
+	init_assemble();
+	init_harness();
+	init_layers();
+	init_render();
+	init_paths();
+	init_projects();
+	SECTION_SEPARATOR = "\n\n---\n\n";
+}));
+//#endregion
 //#region ../../lib/runtimes/ohmypi-fifo.ts
 /**
 * oh-my-pi (omp) RPC named-pipe lifecycle (PAN-1989).
@@ -2796,6 +2871,8 @@ async function writeLauncherScriptAtomic(launcherScript, content) {
 	await rename$1(tmp, launcherScript);
 }
 async function claudeSystemPromptFiles(workspace, harness) {
+	const behavior = getHarnessBehavior(harness);
+	if (behavior.contextLayerKind === "acp") return [];
 	const files = [];
 	const contextFile = workspaceContextFile(workspace);
 	try {
@@ -2805,14 +2882,13 @@ async function claudeSystemPromptFiles(workspace, harness) {
 		if (!isNodeNotFound(error)) throw error;
 	}
 	files.push(await ensureSessionContextBriefingFile());
-	const behavior = getHarnessBehavior(harness);
 	if (behavior.contextLayerKind === "pi") {
-		const { piGlobalContextFile } = await import("./context-layers-DlQKkHH2.js");
+		const { piGlobalContextFile } = await import("./context-layers-BrPmE__h.js");
 		const globalFile = piGlobalContextFile();
 		if (existsSync(globalFile)) files.unshift(globalFile);
 	}
 	if (behavior.contextLayerKind === "codex") {
-		const { codexGlobalContextFile } = await import("./context-layers-DlQKkHH2.js");
+		const { codexGlobalContextFile } = await import("./context-layers-BrPmE__h.js");
 		const globalFile = codexGlobalContextFile();
 		if (existsSync(globalFile)) files.unshift(globalFile);
 	}
@@ -2868,6 +2944,18 @@ async function getOhmypiLauncherFields(agentId, model) {
 		model
 	};
 }
+function getAcpLauncherFields(agentId, model, workspace, binaryPath, _role) {
+	return {
+		harness: "acp",
+		acpAgentId: agentId,
+		acpProvider: getProviderForModelSync(model).name,
+		acpWorkspace: workspace,
+		acpBinaryPath: binaryPath,
+		acpContextFile: materializeAcpContextFile(getAgentDir(agentId), workspace),
+		model,
+		unsetProviderEnv: true
+	};
+}
 function getCodexLauncherFields(agentId, model, workspacePath, role) {
 	const codexHome = join$1(homedir(), ".overdeck", "agents", agentId, "codex-home");
 	const codexConfig = loadConfigSync().config.codex;
@@ -3029,12 +3117,45 @@ async function waitForCodexAppServerReady(agentId, timeoutSec = 30, deps = {}) {
 	const detail = lastError ? ` Last status error: ${lastError}` : ` Last state: ${lastState}.`;
 	throw new Error(`Timed out waiting for Codex app-server readiness for ${agentId}.${detail}`);
 }
+async function waitForAcpHostReady(agentId, timeoutSec = 30, deps = {}) {
+	const now = deps.now ?? (() => Date.now());
+	const sleep = deps.sleep ?? ((ms) => new Promise((resolveSleep) => setTimeout(resolveSleep, ms)));
+	const sessionExistsForAgent = deps.sessionExists ?? (async (id) => Effect.runPromise(sessionExists(id)));
+	const readText = deps.readText ?? ((path) => readFileSync(path, "utf8"));
+	const pathExists = deps.pathExists ?? existsSync;
+	const agentDir = getAgentDir(agentId);
+	const sessionIdPath = join$1(agentDir, "acp-session-id");
+	const errorPath = join$1(agentDir, "acp-launch-error");
+	const tokenPath = join$1(agentDir, "acp-token");
+	const socketPath = join$1(getOverdeckHome(), "sockets", `acp-${agentId}.sock`);
+	const deadline = now() + timeoutSec * 1e3;
+	while (now() < deadline) {
+		if (pathExists(errorPath)) {
+			const launchError = readText(errorPath).trim();
+			if (launchError) throw new Error(`ACP host ${agentId} failed to start: ${launchError}`);
+		}
+		if (!await sessionExistsForAgent(agentId)) throw new Error(`ACP host session ${agentId} exited before readiness.`);
+		try {
+			const sessionId = readText(sessionIdPath).trim();
+			const token = readText(tokenPath).trim();
+			if (sessionId && token && pathExists(socketPath)) return;
+		} catch (error) {
+			if (!isNodeNotFound(error)) throw error;
+		}
+		await sleep(500);
+	}
+	throw new Error(`Timed out waiting for ACP host readiness for ${agentId}.`);
+}
 async function waitForPromptReady(agentId, harness, timeoutSec = 30) {
 	const readinessKind = harness === "codex" && loadConfigSync().config.codex?.transport !== "tui" ? "codex-app-server-ready" : getHarnessBehavior(harness).readinessKind;
 	if (readinessKind === "codex-app-server-ready") {
 		await waitForCodexAppServerReady(agentId, timeoutSec);
 		return true;
 	}
+	if (readinessKind === "acp-host-ready") {
+		await waitForAcpHostReady(agentId, timeoutSec);
+		return true;
+	}
 	if (readinessKind === "codex-tui-prompt") return waitForCodexTuiReady(agentId, timeoutSec);
 	return waitForReadySignal(agentId, timeoutSec);
 }
@@ -3062,7 +3183,7 @@ async function injectPiPromptTimeMemory(agentId, prompt) {
 			agentRole: agentState.role ?? "work",
 			agentHarness: agentState.harness ?? "claude-code"
 		};
-		const { injectPromptTimeMemory } = await import("./injection-BVNa4MQW.js");
+		const { injectPromptTimeMemory } = await import("./injection-CPUIqNhI.js");
 		const result = await injectPromptTimeMemory({
 			prompt,
 			identity,
@@ -3096,7 +3217,7 @@ async function injectPiConversationMemory(opts, prompt) {
 			agentRole: "work",
 			agentHarness: "ohmypi"
 		};
-		const { injectPromptTimeMemory } = await import("./injection-BVNa4MQW.js");
+		const { injectPromptTimeMemory } = await import("./injection-CPUIqNhI.js");
 		const result = await injectPromptTimeMemory({
 			prompt,
 			identity,
@@ -3157,6 +3278,7 @@ async function getAgentRuntimeBaseCommand(model, agentName, agentDefinition, har
 	const behavior = getHarnessBehavior(harness);
 	if (behavior.launchCommandKind === "ohmypi-rpc") return `omp --mode rpc --model ${quotedModel}`;
 	if (behavior.launchCommandKind === "codex-work-tui") return `codex`;
+	if (behavior.launchCommandKind === "acp-host") return "acp-host";
 	if (process.env.OVERDECK_TEST_HARNESS_COMMAND) return process.env.OVERDECK_TEST_HARNESS_COMMAND;
 	const provider = getProviderForModelSync(validatedModel);
 	const nameFlag = agentName ? ` --name ${agentName}` : "";
@@ -3254,6 +3376,7 @@ async function getRoleRuntimeBaseCommand(model, agentName, role, harness = "clau
 		return `omp --mode rpc --model ${quotedModel}`;
 	}
 	if (behavior.launchCommandKind === "codex-work-tui") return `codex`;
+	if (behavior.launchCommandKind === "acp-host") return "acp-host";
 	if (process.env.OVERDECK_TEST_HARNESS_COMMAND) return process.env.OVERDECK_TEST_HARNESS_COMMAND;
 	const provider = getProviderForModelSync(validatedModel);
 	const requestedDefinitionPath = roleAgentDefinitionPath(role, subRole);
@@ -3278,6 +3401,7 @@ var init_runtime_command = __esmMin((() => {
 	init_briefing_freshness();
 	init_claude_auth();
 	init_layers();
+	init_context();
 	init_behavior();
 	init_codex();
 	init_ohmypi_fifo();
@@ -3517,7 +3641,7 @@ function resolveSlotTierSpawnParams(baseWorkspace, slotItemId, explicitModel, sp
 /**
 * Tiered-execution model resolution for the single work-agent path.
 * Auto-start and non-swarm issues still run one foreground work agent, but
-* the first dispatchable vBRIEF item is the same scheduling unit the agent is
+* the first dispatchable xBRIEF item is the same scheduling unit the agent is
 * about to execute. If tiered execution is enabled for the issue, route that
 * agent through the item's resolved tier; otherwise leave role-default model
 * resolution untouched.
@@ -3620,20 +3744,25 @@ async function transitionIssueToInReview(issueId, workspacePath) {
 async function buildAgentLaunchConfig(opts) {
 	const model = requireModelOverrideSync(opts.model);
 	try {
-		const { injectOverdeckInfraDeny } = await import("./claude-settings-overlay-DHBwjS1X.js");
+		const { injectOverdeckInfraDeny } = await import("./claude-settings-overlay-DWy-Bb4Y.js");
 		await Effect.runPromise(injectOverdeckInfraDeny(opts.workspace));
 	} catch (err) {
 		console.warn(`[agents] injectOverdeckInfraDeny failed for ${opts.agentId} (non-fatal): ${err instanceof Error ? err.message : err}`);
 	}
-	const providerEnv = await getProviderEnvForModel(model);
-	const provider = getProviderForModelSync(model);
-	if (provider.authType === "credential-file") setupCredentialFileAuthSync(provider, opts.workspace);
-	else clearCredentialFileAuthSync(opts.workspace);
-	const providerExports = await getProviderExportsForModel(model);
-	const launchRole = opts.isPlanning ? "plan" : opts.role;
 	const behavior = getHarnessBehavior(opts.harness);
+	const isAcp = behavior.launchCommandKind === "acp-host";
+	const providerEnv = isAcp ? {} : await getProviderEnvForModel(model);
+	if (!isAcp) {
+		const provider = getProviderForModelSync(model);
+		if (provider.authType === "credential-file") setupCredentialFileAuthSync(provider, opts.workspace);
+		else clearCredentialFileAuthSync(opts.workspace);
+	}
+	const providerExports = isAcp ? void 0 : await getProviderExportsForModel(model);
+	const launchRole = opts.isPlanning ? "plan" : opts.role;
 	const piLauncherFields = behavior.usesRpcFifo ? await getOhmypiLauncherFields(opts.agentId, model) : {};
 	const codexLauncherFields = behavior.usesCodexHome ? getCodexLauncherFields(opts.agentId, model, opts.workspace, launchRole) : {};
+	if (isAcp && !opts.harnessBinaryPath) throw new Error("ACP launch requires the executable path resolved by preflight");
+	const acpLauncherFields = isAcp ? getAcpLauncherFields(opts.agentId, model, opts.workspace, opts.harnessBinaryPath, launchRole) : {};
 	if (opts.spawnMode === "resume" && opts.resumeSessionId) return {
 		launcherContent: generateLauncherScriptSync({
 			role: launchRole,
@@ -3644,7 +3773,7 @@ async function buildAgentLaunchConfig(opts) {
 			providerExports,
 			baseCommand: behavior.launchCommandKind !== "claude-code" ? await getAgentRuntimeBaseCommand(model, opts.agentId, launchRole, opts.harness) : `claude ${getClaudePermissionFlagsStringSync()}${roleSystemPromptInjectionSync(roleAgentDefinitionPath(launchRole))}`,
 			resumeSessionId: opts.resumeSessionId,
-			model: behavior.launchCommandKind !== "claude-code" || providerExports.includes("ANTHROPIC_BASE_URL") ? model : void 0,
+			model: behavior.launchCommandKind !== "claude-code" || providerExports?.includes("ANTHROPIC_BASE_URL") ? model : void 0,
 			extraArgs: behavior.launchCommandKind !== "claude-code" ? void 0 : `--name ${opts.agentId}`,
 			appendSystemPromptFiles: await claudeSystemPromptFiles(opts.workspace, opts.harness),
 			extraEnvExports: opts.extraEnvExports,
@@ -3652,7 +3781,8 @@ async function buildAgentLaunchConfig(opts) {
 			supervisorScriptPath: opts.supervisorScriptPath,
 			promptInline: opts.promptInline,
 			...piLauncherFields,
-			...codexLauncherFields
+			...codexLauncherFields,
+			...acpLauncherFields
 		}),
 		providerEnv
 	};
@@ -3676,6 +3806,7 @@ async function buildAgentLaunchConfig(opts) {
 			promptInline: opts.promptInline,
 			...piLauncherFields,
 			...codexLauncherFields,
+			...acpLauncherFields,
 			...opts.channelsBridgeMcpConfig ? {
 				channelsBridgeMcpConfig: opts.channelsBridgeMcpConfig,
 				channelsBridgeServerName: opts.channelsBridgeServerName ?? "overdeck-bridge"
@@ -3701,7 +3832,7 @@ async function retrieveSpawnTimeMemoryContext(input) {
 			agentRole: input.role,
 			agentHarness: input.harness
 		};
-		const { injectPromptTimeMemory } = await import("./injection-BVNa4MQW.js");
+		const { injectPromptTimeMemory } = await import("./injection-CPUIqNhI.js");
 		return (await injectPromptTimeMemory({
 			prompt: input.prompt,
 			identity,
@@ -3792,7 +3923,7 @@ async function assertWorkspaceStackHealthyForSpawn(issueId, role, allowHost = fa
 	record.attempts += 1;
 	spawnStackRebuildState.set(normalizedIssue, record);
 	console.log(`[agents] Workspace stack for ${normalizedIssue} unhealthy (${details}) — rebuilding before spawn (attempt ${record.attempts}/${SPAWN_STACK_REBUILD_MAX_ATTEMPTS})`);
-	const { rebuildWorkspaceStack } = await import("./rebuild-stack-CKjJAI8L.js");
+	const { rebuildWorkspaceStack } = await import("./rebuild-stack-CFvcBHsS.js");
 	const result = await Effect.runPromise(rebuildWorkspaceStack(issueId, { onProgress: (m) => console.log(`[agents]   ${normalizedIssue} stack rebuild: ${m}`) })).catch((err) => ({
 		success: false,
 		error: err instanceof Error ? err.message : String(err)
@@ -4179,22 +4310,27 @@ async function appendChannelDeliveryLog(agentId, entry) {
 		await (await import("fs/promises")).appendFile(join$1(dir, `bridge-${agentId}.log`), `${line}\n`, "utf-8");
 	} catch {}
 }
-function readAppServerTokenSync(agentId) {
+function readSocketTokenSync(agentId, filename) {
 	try {
-		const tokenPath = join$1(overdeckHomeForSockets(), "agents", agentId, "appserver-token");
+		const tokenPath = join$1(overdeckHomeForSockets(), "agents", agentId, filename);
 		if (!existsSync(tokenPath)) return null;
 		return readFileSync(tokenPath, "utf-8").trim() || null;
 	} catch {
 		return null;
 	}
 }
+function readAppServerTokenSync(agentId) {
+	return readSocketTokenSync(agentId, "appserver-token");
+}
+function readAcpTokenSync(agentId) {
+	return readSocketTokenSync(agentId, "acp-token");
+}
 /**
 * POST a JSON body to a Unix-domain socket using node:net + a hand-rolled
 * minimal HTTP/1.1 request. Resolves on a 200-class response, rejects on any
-* error including socket-not-found, connection refused, write timeout, or
-* non-2xx status. Kept tiny on purpose: this is a hot path, only one caller,
-* and the whole point of a fallback to tmux is that we do not need a robust
-* HTTP client here.
+* error including socket-not-found, connection refused, an optional client
+* timeout, or non-2xx status. Kept tiny on purpose because this is a hot path
+* and these local protocol hosts need only a narrow HTTP client.
 */
 async function postUnixSocketJson(socketPath, body, timeoutMs, token, tokenHeader = BRIDGE_TOKEN_HEADER) {
 	const payload = JSON.stringify(body);
@@ -4245,10 +4381,12 @@ async function postUnixSocketJson(socketPath, body, timeoutMs, token, tokenHeade
 				finishErr(/* @__PURE__ */ new Error(`socket POST: status ${status}: ${responseBody.slice(0, 100)}`));
 			});
 		});
-		timeout = setTimeout(() => {
-			req.destroy(/* @__PURE__ */ new Error("socket POST timeout"));
-		}, timeoutMs);
-		timeout.unref?.();
+		if (timeoutMs !== void 0) {
+			timeout = setTimeout(() => {
+				req.destroy(/* @__PURE__ */ new Error("socket POST timeout"));
+			}, timeoutMs);
+			timeout.unref?.();
+		}
 		req.on("error", (err) => {
 			finishErr(err);
 		});
@@ -4258,8 +4396,9 @@ async function postUnixSocketJson(socketPath, body, timeoutMs, token, tokenHeade
 }
 /**
 * Single delivery primitive for orchestrator-to-work-agent messages. Auto mode
-* tries the PTY supervisor socket, then legacy Channels MCP, then tmux. Explicit
-* socket methods are strict and throw instead of falling back.
+* tries persistent protocol hosts, the PTY supervisor socket, legacy Channels
+* MCP, then tmux. Explicit socket methods and ACP targets are strict: ACP prompts
+* cannot fall back to terminal injection because only session/prompt reaches the agent.
 */
 async function deliverAgentMessage(agentId, message, caller = "unknown", deliveryMethod) {
 	const normalizedId = normalizeAgentId(agentId);
@@ -4273,6 +4412,8 @@ async function deliverAgentMessage(agentId, message, caller = "unknown", deliver
 	} catch {
 		resolvedMethod ??= "auto";
 	}
+	const isAcpTarget = state?.harness === "acp";
+	if (isAcpTarget && resolvedMethod !== "auto") throw new Error(`MessageDeliveryFailed: ACP delivery failed for ${normalizedId} (${caller}): ACP requires authenticated host RPC delivery`);
 	if (resolvedMethod === "tmux") {
 		await assertTmuxTargetCanReceive(normalizedId, caller);
 		await Effect.runPromise(sendKeys(normalizedId, message));
@@ -4282,7 +4423,7 @@ async function deliverAgentMessage(agentId, message, caller = "unknown", deliver
 		};
 	}
 	let appServerFailure;
-	if (resolvedMethod === "auto") {
+	if (resolvedMethod === "auto" && !isAcpTarget) {
 		const appServerSocketPath = join$1(overdeckHomeForSockets(), "sockets", `appserver-${normalizedId}.sock`);
 		if (existsSync(appServerSocketPath)) {
 			const appServerToken = readAppServerTokenSync(normalizedId);
@@ -4308,6 +4449,39 @@ async function deliverAgentMessage(agentId, message, caller = "unknown", deliver
 			}
 		}
 	}
+	let acpFailure;
+	if (resolvedMethod === "auto") {
+		const acpSocketPath = join$1(overdeckHomeForSockets(), "sockets", `acp-${normalizedId}.sock`);
+		const acpSocketExists = existsSync(acpSocketPath);
+		if (isAcpTarget || acpSocketExists) {
+			const acpToken = readAcpTokenSync(normalizedId);
+			if (!acpSocketExists) acpFailure = "socket-missing";
+			else if (!acpToken) acpFailure = "acp-token-missing";
+			else try {
+				await postUnixSocketJson(acpSocketPath, {
+					op: "message",
+					content: message,
+					meta: { caller }
+				}, 8e3, acpToken);
+				await appendChannelDeliveryLog(normalizedId, {
+					path: "acp",
+					caller
+				});
+				return {
+					ok: true,
+					path: "acp"
+				};
+			} catch (err) {
+				acpFailure = `socket-post-failed: ${err instanceof Error ? err.message : String(err)}`;
+			}
+			await appendChannelDeliveryLog(normalizedId, {
+				path: "acp",
+				reason: acpFailure,
+				caller
+			});
+			throw new Error(`MessageDeliveryFailed: ACP delivery failed for ${normalizedId} (${caller}): ${acpFailure}`);
+		}
+	}
 	let supervisorFailure;
 	if (resolvedMethod === "auto" || resolvedMethod === "supervisor") {
 		const supervisorSocketPath = join$1(overdeckHomeForSockets(), "sockets", `pty-${normalizedId}.sock`);
@@ -4364,6 +4538,7 @@ async function deliverAgentMessage(agentId, message, caller = "unknown", deliver
 			reason: channelFailure,
 			caller,
 			...appServerFailure ? { appServer: appServerFailure } : {},
+			...acpFailure ? { acp: acpFailure } : {},
 			...supervisorFailure ? { "pty-supervisor": supervisorFailure } : {},
 			...channelFailure ? { channels: channelFailure } : {}
 		});
@@ -4896,6 +5071,12 @@ function stopAgentSync(agentId) {
 		killSessionSync(normalizedId);
 	}
 	killLauncherProcessSync(normalizedId);
+	try {
+		rmSync(join$1(AGENTS_DIR, normalizedId, "git-guard"), {
+			recursive: true,
+			force: true
+		});
+	} catch {}
 	const state = getAgentStateSync(normalizedId);
 	if (state) {
 		if (!state.id) state.id = normalizedId;
@@ -4950,6 +5131,14 @@ var init_termination = __esmMin((() => {
 					throw cause;
 				}
 			}).pipe(Effect.catch(() => Effect.void));
+			yield* Effect.promise(async () => {
+				try {
+					await rm$1(join$1(AGENTS_DIR, normalizedId, "git-guard"), {
+						recursive: true,
+						force: true
+					});
+				} catch {}
+			});
 			const state = yield* getAgentState(normalizedId);
 			if (state) {
 				if (!state.id) state.id = normalizedId;
@@ -5035,18 +5224,18 @@ async function spawnRun(issueId, role, options = {}) {
 		let reapWarmIdle = false;
 		const advancing = role === "review" || role === "test" || role === "ship";
 		try {
-			const { isPaneDead } = await import("./tmux-BAvtac_u.js");
+			const { isPaneDead } = await import("./tmux-B6z7h_vZ.js");
 			if (await Effect.runPromise(isPaneDead(agentId))) reapWarmIdle = true;
 			else if (advancing) {
-				const { getReviewStatusSync } = await import("./review-status-Bnh-rdkY.js");
-				const { isRoleTerminal } = await import("./reap-terminal-sessions-CaMkFOIH.js");
+				const { getReviewStatusSync } = await import("./review-status-btEYlaxA.js");
+				const { isRoleTerminal } = await import("./reap-terminal-sessions-7KeHv1R1.js");
 				const status = getReviewStatusSync(issueId);
 				reapWarmIdle = !!status && isRoleTerminal(role, status);
 			}
 		} catch {}
 		if (!reapWarmIdle) throw new Error(`Role run ${agentId} already running. Use 'pan tell' to message it.`);
 		console.log(`[spawn] ${agentId} is warm-idle from the previous cycle — reaping it for the new ${role} dispatch (PAN-2579)`);
-		const { killSession } = await import("./tmux-BAvtac_u.js");
+		const { killSession } = await import("./tmux-B6z7h_vZ.js");
 		await Effect.runPromise(killSession(agentId)).catch(() => {});
 	}
 	await assertWorkspaceStackHealthyForSpawn(issueId, role, options.allowHost, workspace);
@@ -5056,11 +5245,12 @@ async function spawnRun(issueId, role, options = {}) {
 		role,
 		model: selectedModel
 	});
+	const isAcp = getHarnessBehavior(resolvedHarness).launchCommandKind === "acp-host";
 	const harnessLaunch = await prepareHarnessLaunch(resolvedHarness);
 	assertCodexNativeAuthForSpawn(resolvedHarness, listAgentStates());
 	await ensureLifecycleHooksBeforeLaunch(agentId, resolvedHarness);
 	if (getProviderForModelSync(selectedModel).name === "openai" && await getProviderAuthMode(selectedModel) === "subscription") {
-		const { isCliproxyRunning } = await import("./cliproxy-bONZDBbC.js");
+		const { isCliproxyRunning } = await import("./cliproxy-fHfIeiGd.js");
 		if (!await Effect.runPromise(isCliproxyRunning())) throw new Error("CLIProxyAPI sidecar is not running. GPT subscription role runs route through a local cliproxy process managed by `pan up`. Run `pan up` (or restart the dashboard) before spawning a GPT role run.");
 	}
 	const state = {
@@ -5073,7 +5263,7 @@ async function spawnRun(issueId, role, options = {}) {
 		modelSpawnKey,
 		status: "starting",
 		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		costSoFar: 0,
+		...resolvedHarness === "codex" ? {} : { costSoFar: 0 },
 		hostOverride: options.allowHost || void 0,
 		slotIndex: options.slotIndex,
 		slotItemId: options.slotItemId
@@ -5083,6 +5273,7 @@ async function spawnRun(issueId, role, options = {}) {
 	const shouldDeliverPromptViaTmux = shouldRegisterConversation && resolvedHarness === "claude-code";
 	const shouldDeliverPromptViaPi = shouldRegisterConversation && resolvedHarness === "ohmypi";
 	const shouldDeliverPromptViaCodexTui = shouldRegisterConversation && resolvedHarness === "codex";
+	const shouldDeliverPromptViaAcp = resolvedHarness === "acp";
 	const prompt = options.prompt ? await withSpawnTimeMemoryContext({
 		prompt: options.prompt,
 		issueId,
@@ -5093,26 +5284,29 @@ async function spawnRun(issueId, role, options = {}) {
 	}) : "";
 	let promptFile;
 	const tracksKickoffDelivery = role === "flywheel";
-	if (prompt && (tracksKickoffDelivery || !shouldDeliverPromptViaTmux && !shouldDeliverPromptViaPi && !shouldDeliverPromptViaCodexTui)) {
+	if (prompt && !shouldDeliverPromptViaAcp && (tracksKickoffDelivery || !shouldDeliverPromptViaTmux && !shouldDeliverPromptViaPi && !shouldDeliverPromptViaCodexTui)) {
 		promptFile = join$1(getAgentDir(agentId), "initial-prompt.md");
 		await writeFile$1(promptFile, prompt);
-		if (tracksKickoffDelivery) {
-			state.kickoffDelivered = false;
-			await Effect.runPromise(saveAgentState(state));
-		}
 	}
-	const provider = getProviderForModelSync(selectedModel);
-	if (provider.authType === "credential-file") setupCredentialFileAuthSync(provider, workspace);
-	else clearCredentialFileAuthSync(workspace);
-	const providerExports = await getProviderExportsForModel(selectedModel);
-	const providerEnv = await getProviderEnvForModel(selectedModel);
+	if (prompt && tracksKickoffDelivery) {
+		state.kickoffDelivered = false;
+		await Effect.runPromise(saveAgentState(state));
+	}
+	if (!isAcp) {
+		const provider = getProviderForModelSync(selectedModel);
+		if (provider.authType === "credential-file") setupCredentialFileAuthSync(provider, workspace);
+		else clearCredentialFileAuthSync(workspace);
+	}
+	const providerExports = isAcp ? void 0 : await getProviderExportsForModel(selectedModel);
+	const providerEnv = isAcp ? {} : await getProviderEnvForModel(selectedModel);
 	const piLauncherFields = resolvedHarness === "ohmypi" ? await getOhmypiLauncherFields(agentId, selectedModel) : {};
 	const codexLauncherFields = resolvedHarness === "codex" ? getCodexLauncherFields(agentId, selectedModel, workspace, role) : {};
+	const acpLauncherFields = isAcp ? getAcpLauncherFields(agentId, selectedModel, workspace, harnessLaunch.binaryPath, role) : {};
 	let sessionId;
 	let rawSessionId;
 	if (shouldRegisterConversation) {
-		rawSessionId = options.resumeSessionId ?? randomUUID();
-		try {
+		rawSessionId = isAcp ? options.resumeSessionId : options.resumeSessionId ?? randomUUID();
+		if (!isAcp && rawSessionId) try {
 			const agentDir = getAgentDir(agentId);
 			await mkdir$1(agentDir, { recursive: true });
 			await writeFile$1(join$1(agentDir, "session.id"), rawSessionId, "utf-8");
@@ -5165,14 +5359,15 @@ async function spawnRun(issueId, role, options = {}) {
 		reviewSignal: void 0,
 		trapHup: void 0,
 		...piLauncherFields,
-		...codexLauncherFields
+		...codexLauncherFields,
+		...acpLauncherFields
 	});
 	const launcherScript = join$1(getAgentDir(agentId), "launcher.sh");
 	await writeLauncherScriptAtomic(launcherScript, launcherContent);
 	const claudeCmd = `bash ${launcherScript}`;
 	console.log(`[claude-invoke] purpose=role-run | role=${role} | model=${state.model} | source=agents.ts:spawnRun | session=${agentId} | command="${claudeCmd}"`);
 	try {
-		const { preTrustDirectory } = await import("./workspace-manager-B1WOfKvB.js");
+		const { preTrustDirectory } = await import("./workspace-manager-CWT55qeI.js");
 		preTrustDirectory(workspace);
 	} catch {}
 	clearReadySignal(agentId);
@@ -5197,7 +5392,22 @@ async function spawnRun(issueId, role, options = {}) {
 	await Effect.runPromise(setOption(agentId, "destroy-unattached", "off"));
 	await Effect.runPromise(setOption(exactPaneTarget(agentId), "remain-on-exit", "on"));
 	if (prompt) {
-		if (shouldDeliverPromptViaPi) try {
+		if (shouldDeliverPromptViaAcp) try {
+			await waitForPromptReady(agentId, resolvedHarness, 30);
+			const delivery = await deliverAgentMessage(agentId, prompt, "spawnRun:initial-prompt");
+			if (!delivery.ok) throw new Error(delivery.failure ?? `ACP delivery returned ok=false via ${delivery.path}`);
+			if (tracksKickoffDelivery) {
+				state.kickoffDelivered = true;
+				await Effect.runPromise(saveAgentState(state));
+			}
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			console.error(`[${agentId}] ACP prompt delivery failed:`, message);
+			if (tracksKickoffDelivery) await recordKickoffDeliveryFailure(state, issueId, role);
+			await Effect.runPromise(stopAgent(agentId));
+			throw new Error(`Agent ${agentId} kickoff delivery failed: ${message}`);
+		}
+		else if (shouldDeliverPromptViaPi) try {
 			await writeOhmypiAgentPrompt(agentId, prompt);
 			if (tracksKickoffDelivery) {
 				state.kickoffDelivered = true;
@@ -5242,7 +5452,7 @@ async function spawnAgent(options) {
 	if (await Effect.runPromise(sessionExists(agentId))) throw new Error(`Agent ${agentId} already running. Use 'pan tell' to message it.`);
 	await assertWorkspaceStackHealthyForSpawn(options.issueId, role, options.allowHost, options.workspace);
 	initHookSync(agentId);
-	if (role !== "strike" && role !== "knowledge" && options.slotItemId === void 0 && !readWorkspacePlanSync(options.workspace)) throw new Error(`The required vBRIEF checklist for ${options.issueId} is missing or unreadable. Run planning before spawning a work agent.`);
+	if (role !== "strike" && role !== "knowledge" && options.slotItemId === void 0 && !readWorkspacePlanSync(options.workspace)) throw new Error(`The required xBRIEF checklist for ${options.issueId} is missing or unreadable. Run planning before spawning a work agent.`);
 	const modelSpawnKey = `${role}:${options.issueId}`;
 	const singleTierParams = role === "work" && options.slotItemId === void 0 && options.slotIndex === void 0 ? resolveSingleWorkTierSpawnParams(options.workspace, options.model, modelSpawnKey) : {};
 	const selectedModel = determineModel({
@@ -5252,7 +5462,7 @@ async function spawnAgent(options) {
 	});
 	console.log(`[DEBUG] Selected model: ${selectedModel}`);
 	if (getProviderForModelSync(selectedModel).name === "openai" && await getProviderAuthMode(selectedModel) === "subscription") {
-		const { isCliproxyRunning } = await import("./cliproxy-bONZDBbC.js");
+		const { isCliproxyRunning } = await import("./cliproxy-fHfIeiGd.js");
 		if (!await Effect.runPromise(isCliproxyRunning())) throw new Error("CLIProxyAPI sidecar is not running. GPT subscription agents route through a local cliproxy process managed by `pan up`. Run `pan up` (or restart the dashboard) before spawning a GPT agent.");
 	}
 	const resolvedHarness = await resolveHarness({
@@ -5260,6 +5470,7 @@ async function spawnAgent(options) {
 		role,
 		model: selectedModel
 	});
+	const isAcp = getHarnessBehavior(resolvedHarness).launchCommandKind === "acp-host";
 	const harnessLaunch = await prepareHarnessLaunch(resolvedHarness);
 	assertCodexNativeAuthForSpawn(resolvedHarness, listAgentStates());
 	await ensureLifecycleHooksBeforeLaunch(agentId, resolvedHarness);
@@ -5273,7 +5484,7 @@ async function spawnAgent(options) {
 		modelSpawnKey,
 		status: "starting",
 		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		costSoFar: 0,
+		...resolvedHarness === "codex" ? {} : { costSoFar: 0 },
 		hostOverride: options.allowHost || void 0,
 		sessionId: createFreshSessionIdentity(agentId, resolvedHarness)
 	};
@@ -5282,7 +5493,7 @@ async function spawnAgent(options) {
 	if (role === "work") {
 		try {
 			if (resetPipelineVerdictsForWorkStartSync(options.issueId)) {
-				const { resetPostMergeState } = await import("./merge-agent-B-SnXOoc.js");
+				const { resetPostMergeState } = await import("./merge-agent-CKkgIBPB.js");
 				resetPostMergeState(options.issueId);
 			}
 		} catch (err) {
@@ -5293,7 +5504,7 @@ async function spawnAgent(options) {
 		});
 	}
 	if (role === "work") try {
-		const { writeStoryFeatureContext } = await import("./work-agent-prompt-DLthEPAq.js");
+		const { writeStoryFeatureContext } = await import("./work-agent-prompt-Du8Vh2aJ.js");
 		await writeStoryFeatureContext(options.workspace, options.issueId);
 	} catch (ctxErr) {
 		console.warn(`[agents] Could not write story feature context for ${options.issueId}: ${ctxErr.message}`);
@@ -5332,17 +5543,15 @@ async function spawnAgent(options) {
 	});
 	const promptFile = join$1(getAgentDir(agentId), "initial-prompt.md");
 	const tracksKickoffDelivery = role === "work" || role === "strike";
-	if (prompt) {
-		await writeFile$1(promptFile, prompt);
-		if (tracksKickoffDelivery) {
-			state.kickoffDelivered = false;
-			saveAgentStateSync(state);
-		}
+	if (prompt && !isAcp) await writeFile$1(promptFile, prompt);
+	if (prompt && tracksKickoffDelivery) {
+		state.kickoffDelivered = false;
+		saveAgentStateSync(state);
 	}
 	try {
 		const venvPath = join$1(options.workspace, ".venv");
 		if (isTldrEnabledSync() && existsSync(venvPath)) {
-			const { getTldrDaemonServiceSync } = await import("./tldr-daemon-B8_oT5gx.js");
+			const { getTldrDaemonServiceSync } = await import("./tldr-daemon-BYFkts95.js");
 			const tldrService = getTldrDaemonServiceSync(options.workspace, venvPath);
 			if (!(await tldrService.getStatus()).running) {
 				await tldrService.start(true);
@@ -5372,6 +5581,7 @@ async function spawnAgent(options) {
 		useSupervisor: supervisorLaunch.useSupervisor,
 		supervisorScriptPath: supervisorLaunch.supervisorScriptPath,
 		harness: state.harness ?? "claude-code",
+		harnessBinaryPath: harnessLaunch.binaryPath,
 		sessionId: state.sessionId,
 		extraEnvExports: [harnessLaunch.pathExport, ...flywheelEnvExports(flywheelEnv)],
 		effort: options.effort
@@ -5382,13 +5592,13 @@ async function spawnAgent(options) {
 	const claudeCmd = `bash ${launcherScript}`;
 	console.log(`[claude-invoke] purpose=work-agent | model=${state.model} | source=agents.ts:spawnAgent | session=${agentId} | command="${claudeCmd}"`);
 	try {
-		const { preTrustDirectory } = await import("./workspace-manager-B1WOfKvB.js");
+		const { preTrustDirectory } = await import("./workspace-manager-CWT55qeI.js");
 		preTrustDirectory(options.workspace);
 	} catch {}
 	try {
-		const { isGitHubAppConfigured, generateInstallationToken, configureWorkspaceForBot } = await import("./github-app-CU14oYzP.js");
+		const { isGitHubAppConfigured, generateInstallationToken, configureWorkspaceForBot } = await import("./github-app-ClZ2lk8D.js");
 		if (isGitHubAppConfigured()) {
-			const { findProjectByPathSync } = await import("./projects-BKkwpH6q.js");
+			const { findProjectByPathSync } = await import("./projects-vjjcmiN8.js");
 			const ghRepo = findProjectByPathSync(resolve$1(options.workspace, "..", ".."))?.github_repo;
 			if (ghRepo) {
 				const [owner, repo] = ghRepo.split("/");
@@ -5418,7 +5628,22 @@ async function spawnAgent(options) {
 		sessionHarness: resolvedHarness
 	});
 	const dismissChannelsDialogPromise = channelsBridgeMcpConfig ? dismissDevChannelsDialog(agentId).catch(() => void 0) : null;
-	if (prompt && resolvedHarness === "ohmypi") try {
+	if (prompt && isAcp) try {
+		await waitForPromptReady(agentId, resolvedHarness, 30);
+		const delivery = await deliverAgentMessage(agentId, prompt, "spawnAgent:initial-prompt");
+		if (!delivery.ok) throw new Error(delivery.failure ?? `ACP delivery returned ok=false via ${delivery.path}`);
+		if (tracksKickoffDelivery) {
+			state.kickoffDelivered = true;
+			saveAgentStateSync(state);
+		}
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		console.error(`[${agentId}] ACP prompt delivery failed:`, message);
+		if (tracksKickoffDelivery) await recordKickoffDeliveryFailure(state, options.issueId, role);
+		await Effect.runPromise(stopAgent(agentId));
+		throw new Error(`Agent ${agentId} kickoff delivery failed: ${message}`);
+	}
+	else if (prompt && resolvedHarness === "ohmypi") try {
 		await writeOhmypiAgentPrompt(agentId, prompt);
 		if (tracksKickoffDelivery) {
 			state.kickoffDelivered = true;
@@ -5451,7 +5676,7 @@ async function spawnAgent(options) {
 		const codexHomeForAgent = join$1(homedir(), ".overdeck", "agents", agentId, "codex-home");
 		(async () => {
 			try {
-				const { waitForCodexRollout, extractThreadIdFromRollout, writeThreadId } = await import("./codex-DNyiQDKW.js");
+				const { waitForCodexRollout, extractThreadIdFromRollout, writeThreadId } = await import("./codex-GcHuUF-k.js");
 				const rollout = await waitForCodexRollout(codexHomeForAgent, 12e4);
 				if (rollout) {
 					const threadId = extractThreadIdFromRollout(rollout);
@@ -5488,7 +5713,7 @@ function assertRegisteredSlotCap(issueId, configuredCap) {
 }
 function buildRegisteredSlotPrompt(issueId, baseWorkspace, slot, extraPrompt) {
 	const doc = readWorkspacePlanSync(baseWorkspace);
-	if (!doc) throw new Error(`Registered slot spawn for ${issueId} requires a readable vBRIEF plan in ${baseWorkspace}.`);
+	if (!doc) throw new Error(`Registered slot spawn for ${issueId} requires a readable xBRIEF plan in ${baseWorkspace}.`);
 	const slice = createActiveSlice(doc, {
 		issueId: issueId.toUpperCase(),
 		itemId: slot.slotItemId,
@@ -5503,7 +5728,7 @@ function buildRegisteredSlotPrompt(issueId, baseWorkspace, slot, extraPrompt) {
 		`Branch: ${slot.branch}`,
 		`Workspace: ${slot.workspace}`,
 		"",
-		"You are a registered slot work agent. Implement only the target vBRIEF item below, keep changes scoped to that item, and do not merge this slot branch yourself.",
+		"You are a registered slot work agent. Implement only the target xBRIEF item below, keep changes scoped to that item, and do not merge this slot branch yourself.",
 		"",
 		slice.prompt
 	];
@@ -6079,6 +6304,11 @@ function pickFreshestExistingSessionIdSync(agentId, candidates) {
 function getLatestSessionIdSync(agentId) {
 	const codexThreadId = resolveCodexThreadIdSync(agentId);
 	if (codexThreadId) return codexThreadId;
+	const agentState = getAgentStateSync(agentId);
+	if (agentState?.harness && getHarnessBehavior(agentState.harness).sessionIdSource === "acp-session-id") try {
+		const acpSessionId = readFileSync(join$1(getAgentDir(agentId), "acp-session-id"), "utf-8").trim();
+		if (acpSessionId) return acpSessionId;
+	} catch {}
 	const fromSessionFile = getSessionId(agentId);
 	if (fromSessionFile) return fromSessionFile;
 	const sessionsFile = join$1(getAgentDir(agentId), "sessions.json");
@@ -6100,7 +6330,6 @@ function getLatestSessionIdSync(agentId) {
 			if (threadId) return threadId;
 		}
 	} catch {}
-	const agentState = getAgentStateSync(agentId);
 	if (agentState?.harness && getHarnessBehavior(agentState.harness).sessionIdSource === "transcript-jsonl") {
 		const ohmypiSessionId = resolveLatestOhmypiSessionId(agentId);
 		if (ohmypiSessionId) return ohmypiSessionId;
@@ -6181,6 +6410,10 @@ function queueAgentMail(agentId, message, pendingTurnEndDelivery = false) {
 	mkdirSync(mailDir, { recursive: true });
 	writeFileSync(join$1(mailDir, `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}${pendingTurnEndDelivery ? ".pending" : ""}.md`), `# Message\n\n${message}\n`);
 }
+function resolveAgentDeliveryMethod(state) {
+	if (state?.harness === "acp") return "auto";
+	return resilientDeliveryMethod(state?.deliveryMethod);
+}
 function claimCodexIdleTurn(agentId) {
 	try {
 		unlinkSync(join$1(getAgentDir(agentId), "turn-completed"));
@@ -6225,7 +6458,11 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 		queueAgentMail(normalizedId, message);
 		logAgentLifecycleSync(normalizedId, `messageAgent queued mail without resume: ${gateBlockReason}`);
 		console.log(`[agents] Queued message for ${normalizedId}; ${gateBlockReason}`);
-		return;
+		return {
+			delivered: false,
+			queuedToMail: true,
+			reason: gateBlockReason
+		};
 	}
 	if (getAgentRuntimeStateSync(normalizedId)?.state === "suspended") {
 		const suspendedGate = decideMessageGate();
@@ -6234,15 +6471,22 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 			queueAgentMail(normalizedId, message);
 			logAgentLifecycleSync(normalizedId, `messageAgent queued mail without resume: ${gateBlockReason}`);
 			console.log(`[agents] Queued message for ${normalizedId}; ${gateBlockReason}`);
-			return;
+			return {
+				delivered: false,
+				queuedToMail: true,
+				reason: gateBlockReason
+			};
 		}
 		console.log(`[agents] Auto-resuming suspended agent ${normalizedId} to deliver message`);
-		const { resumeAgent } = await import("./agents-DyHKlq1I.js");
+		const { resumeAgent } = await import("./agents-wi9NWzs2.js");
 		const result = await resumeAgent(normalizedId, message);
 		if (!result.success) throw new Error(`Failed to auto-resume agent: ${result.error}`);
 		if (result.messageDelivered === false) throw new Error(`Agent resumed but ready signal did not fire — message not delivered. Feedback is in the mail queue.`);
 		await appendTellInterventionForUserSource(normalizedId, caller);
-		return;
+		return {
+			delivered: true,
+			queuedToMail: false
+		};
 	}
 	if (agentState && agentState.status === "stopped") {
 		const stoppedGate = decideMessageGate();
@@ -6251,16 +6495,23 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 			queueAgentMail(normalizedId, message);
 			logAgentLifecycleSync(normalizedId, `messageAgent queued mail without resume: ${gateBlockReason}`);
 			console.log(`[agents] Queued message for ${normalizedId}; ${gateBlockReason}`);
-			return;
+			return {
+				delivered: false,
+				queuedToMail: true,
+				reason: gateBlockReason
+			};
 		}
 		console.log(`[agents] Auto-resuming stopped agent ${normalizedId} to deliver feedback (session exists: ${await Effect.runPromise(sessionExists(normalizedId))})`);
-		const { resumeAgent } = await import("./agents-DyHKlq1I.js");
+		const { resumeAgent } = await import("./agents-wi9NWzs2.js");
 		const resumeResult = await resumeAgent(normalizedId, message);
 		queueAgentMail(normalizedId, message);
 		if (resumeResult.success && resumeResult.messageDelivered !== false) {
 			await appendTellInterventionForUserSource(normalizedId, caller);
 			console.log(`[agents] Resumed ${normalizedId} and delivered feedback`);
-			return;
+			return {
+				delivered: true,
+				queuedToMail: true
+			};
 		}
 		if (!resumeResult.success) console.warn(`[agents] Resume failed for ${normalizedId}: ${resumeResult.error} — falling back to fresh launch`);
 		else console.warn(`[agents] Resume succeeded for ${normalizedId} but message not delivered (ready signal timed out) — falling back to fresh launch`);
@@ -6273,7 +6524,11 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 				message: `${normalizedId}: ${stopMsg}`,
 				issueId: agentState.issueId
 			});
-			return;
+			return {
+				delivered: false,
+				queuedToMail: true,
+				reason: stopMsg
+			};
 		}
 		const providerEnv = agentState.model ? await getProviderEnvForModel(agentState.model) : {};
 		if (agentState.model) {
@@ -6291,7 +6546,7 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 		const resumeModel = agentState.model || "claude-sonnet-4-6";
 		const fallbackHarness = agentState.harness ?? "claude-code";
 		const harnessLaunch = await prepareHarnessLaunch(fallbackHarness);
-		const { assertWorkspaceStackHealthyForSpawn } = await import("./agents-DyHKlq1I.js");
+		const { assertWorkspaceStackHealthyForSpawn } = await import("./agents-wi9NWzs2.js");
 		await assertWorkspaceStackHealthyForSpawn(agentState.issueId || normalizedId.replace(/^agent-/, "").toUpperCase(), resumeRole, agentState.hostOverride === true, agentState.workspace);
 		const fallbackPiFields = fallbackHarness === "ohmypi" ? await getOhmypiLauncherFields(normalizedId, resumeModel) : {};
 		const fallbackCodexFields = fallbackHarness === "codex" ? getCodexLauncherFields(normalizedId, resumeModel, agentState.workspace, resumeRole) : {};
@@ -6322,7 +6577,10 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 		saveAgentStateSync(agentState);
 		const ready = await waitForPromptReady(normalizedId, fallbackHarness, 30);
 		const resumeMessage = await buildResumeMessageForAgent(agentState, `You are resuming work on ${agentState.issueId}. Check .pan/feedback/ for specialist feedback that arrived while you were stopped, then continue working.\n\n${message}`, message);
+		let delivered = false;
+		let reason;
 		if (resumeMessage.error) {
+			reason = resumeMessage.error;
 			console.error(`[agents] Fallback-restarted ${normalizedId} but ${resumeMessage.error}`);
 			emitActivityEntrySync({
 				source: "work-agent",
@@ -6331,7 +6589,6 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 				issueId: agentState.issueId
 			});
 		} else if (ready && resumeMessage.message) {
-			let delivered = false;
 			if (fallbackHarness === "claude-code") {
 				const fallbackSessionId = getLatestSessionIdSync(normalizedId);
 				if (fallbackSessionId) {
@@ -6341,28 +6598,48 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 						sessionId: fallbackSessionId,
 						message: resumeMessage.message,
 						caller: "resumeAgent:resume-prompt",
-						deliveryMethod: resilientDeliveryMethod(agentState.deliveryMethod)
+						deliveryMethod: resolveAgentDeliveryMethod(agentState)
 					});
 					delivered = delivery.delivered;
-					if (!delivery.delivered) console.error(`[agents] Fallback resume prompt did not land after ${delivery.attempts} delivery attempts`);
-				} else console.error(`[agents] Fallback-restarted ${normalizedId} but no session id was recorded — feedback in mail queue`);
-			} else delivered = (await deliverAgentMessage(normalizedId, resumeMessage.message, "resumeAgent:resume-prompt", resilientDeliveryMethod(agentState.deliveryMethod))).ok;
+					if (!delivery.delivered) {
+						reason = `resume prompt did not land after ${delivery.attempts} delivery attempts`;
+						console.error(`[agents] Fallback resume prompt did not land after ${delivery.attempts} delivery attempts`);
+					}
+				} else {
+					reason = "no session id was recorded";
+					console.error(`[agents] Fallback-restarted ${normalizedId} but no session id was recorded — feedback in mail queue`);
+				}
+			} else {
+				const delivery = await deliverAgentMessage(normalizedId, resumeMessage.message, "resumeAgent:resume-prompt", resolveAgentDeliveryMethod(agentState));
+				delivered = delivery.ok;
+				if (!delivery.ok) reason = "resume prompt delivery failed";
+			}
 			if (delivered) {
 				if (resumeMessage.redeliveringKickoff) markKickoffRedelivered(agentState);
 				await appendTellInterventionForUserSource(normalizedId, caller);
 				console.log(`[agents] Fallback-restarted ${normalizedId} and delivered feedback`);
 			}
-		} else console.warn(`[agents] Fallback-restarted ${normalizedId} but ready signal not detected — feedback in mail queue`);
-		return;
+		} else {
+			reason = "ready signal not detected";
+			console.warn(`[agents] Fallback-restarted ${normalizedId} but ready signal not detected — feedback in mail queue`);
+		}
+		return {
+			delivered,
+			queuedToMail: true,
+			...reason ? { reason } : {}
+		};
 	}
-	const { loadRemoteAgentState, sendToRemoteAgent } = await import("./remote-agents-D6O_zETW.js");
+	const { loadRemoteAgentState, sendToRemoteAgent } = await import("./remote-agents-CA3Ihlxj.js");
 	const remoteState = loadRemoteAgentState(normalizedId);
 	if (remoteState && remoteState.vmName) {
 		console.log(`[agents] Sending message to remote agent ${normalizedId} on ${remoteState.vmName}`);
 		await sendToRemoteAgent(normalizedId, remoteState.vmName, message);
 		queueAgentMail(normalizedId, message);
 		await appendTellInterventionForUserSource(normalizedId, caller);
-		return;
+		return {
+			delivered: true,
+			queuedToMail: true
+		};
 	}
 	const expectedHarness = agentState?.harness ?? "claude-code";
 	let appServerState;
@@ -6375,31 +6652,46 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 			logAgentLifecycleSync(normalizedId, "messageAgent queued mail for codex turn-end delivery: agent busy");
 			console.log(`[agents] Queued message for ${normalizedId}; codex agent is mid-turn`);
 			await appendTellInterventionForUserSource(normalizedId, caller);
-			return;
+			return {
+				delivered: true,
+				queuedToMail: true,
+				reason: "queued for turn-end delivery"
+			};
 		}
-		const deliveryMethod = resilientDeliveryMethod(agentState?.deliveryMethod);
-		await deliverAgentMessage(normalizedId, message, `messageAgent:${caller}`, deliveryMethod);
+		const deliveryMethod = resolveAgentDeliveryMethod(agentState);
+		const delivery = await deliverAgentMessage(normalizedId, message, `messageAgent:${caller}`, deliveryMethod);
 		queueAgentMail(normalizedId, message);
 		await appendTellInterventionForUserSource(normalizedId, caller);
-		return;
+		return {
+			delivered: delivery.ok,
+			queuedToMail: true
+		};
 	}
 	if (!await Effect.runPromise(sessionExists(normalizedId))) throw new Error(`Agent ${normalizedId} not running`);
 	const panePids = await Effect.runPromise(listPaneValues(normalizedId, "#{pane_pid}"));
 	if (panePids.length > 0 && !await hasAgentRuntimeInSubtree(panePids[0], expectedHarness)) {
 		console.warn(`[agents] ${normalizedId} tmux session is a zombie (no ${expectedHarness} runtime) — attempting resume`);
-		const { resumeAgent } = await import("./agents-DyHKlq1I.js");
+		const { resumeAgent } = await import("./agents-wi9NWzs2.js");
 		const resumeResult = await resumeAgent(normalizedId, message);
 		if (resumeResult.success) {
-			if (resumeResult.messageDelivered !== false) await appendTellInterventionForUserSource(normalizedId, caller);
-			return;
+			const delivered = resumeResult.messageDelivered !== false;
+			if (delivered) await appendTellInterventionForUserSource(normalizedId, caller);
+			return {
+				delivered,
+				queuedToMail: false
+			};
 		}
 		throw new Error(`Agent ${normalizedId} session is dead and resume failed: ${resumeResult.error}`);
 	}
 	if (!await waitForAgentIdle(normalizedId, 5e3)) console.warn(`[agents] ${normalizedId} not at idle prompt after 5s — sending message anyway`);
-	const deliveryMethod = resilientDeliveryMethod(agentState?.deliveryMethod);
-	await deliverAgentMessage(normalizedId, message, `messageAgent:${caller}`, deliveryMethod);
+	const deliveryMethod = resolveAgentDeliveryMethod(agentState);
+	const delivery = await deliverAgentMessage(normalizedId, message, `messageAgent:${caller}`, deliveryMethod);
 	queueAgentMail(normalizedId, message);
 	await appendTellInterventionForUserSource(normalizedId, caller);
+	return {
+		delivered: delivery.ok,
+		queuedToMail: true
+	};
 }
 var USER_MESSAGE_INTERVENTION_SOURCES;
 var init_messaging = __esmMin((() => {
@@ -6468,6 +6760,54 @@ var init_context_overflow = __esmMin((() => {
 	];
 }));
 //#endregion
+//#region ../../lib/agents/session-pointers.ts
+/**
+* Clear every mutable pointer that can make a later launch resume an old
+* session. Claude JSONL transcripts live outside the agent directory and are
+* deliberately never touched.
+*/
+async function clearAgentSessionPointers(agentId) {
+	const agentDir = getAgentDir(agentId);
+	const cleared = [];
+	for (const name of [
+		"session.id",
+		"sessions.json",
+		"codex-thread-id",
+		"launcher.sh"
+	]) {
+		const path = join(agentDir, name);
+		if (!existsSync$1(path)) continue;
+		unlinkSync$1(path);
+		cleared.push(name);
+	}
+	const runtimeFile = join(agentDir, "runtime.json");
+	if (existsSync$1(runtimeFile)) try {
+		const runtime = JSON.parse(readFileSync$1(runtimeFile, "utf-8"));
+		if (Object.prototype.hasOwnProperty.call(runtime, "claudeSessionId")) {
+			delete runtime.claudeSessionId;
+			writeFileSync$1(runtimeFile, JSON.stringify(runtime, null, 2));
+			cleared.push("runtime.json:claudeSessionId");
+		}
+	} catch {}
+	const state = getAgentStateSync(agentId);
+	if (state?.sessionId) {
+		delete state.sessionId;
+		saveAgentStateSync(state);
+		cleared.push("agents.session_id");
+	}
+	await Effect.runPromise(emitAgentEvent(agentId, {
+		kind: "model_set",
+		model: state?.model ?? "unknown",
+		claudeSessionId: null
+	}));
+	cleared.push("runtime.claudeSessionId");
+	return { cleared };
+}
+var init_session_pointers = __esmMin((() => {
+	init_agent_runtime();
+	init_agent_state();
+}));
+//#endregion
 //#region ../../lib/agents/resume.ts
 /**
 * Resume a suspended agent (PAN-80)
@@ -6500,7 +6840,7 @@ async function buildCompactRecoverySeed(agentId) {
 	if (agentState?.workspace && sessionId) {
 		const sessionFile = sessionFilePath(agentState.workspace, sessionId);
 		try {
-			const [{ getConversationCompactionSettings }, { generateSmartSummary }] = await Promise.all([import("./conversation-compaction-CN4-5YYt.js"), import("./smart-compaction-jdMkG1vo.js")]);
+			const [{ getConversationCompactionSettings }, { generateSmartSummary }] = await Promise.all([import("./conversation-compaction-eQB5CkOe.js"), import("./smart-compaction-CV2ukKND.js")]);
 			const settings = getConversationCompactionSettings();
 			summary = (await Effect.runPromise(generateSmartSummary({
 				jsonlPath: sessionFile,
@@ -6511,7 +6851,7 @@ async function buildCompactRecoverySeed(agentId) {
 		} catch (err) {
 			logAgentLifecycleSync(normalizedId, `compact-recovery smart summary failed (${err instanceof Error ? err.message : String(err)}); trying heuristic fallback`);
 			try {
-				const { generateFallbackSummary } = await import("./summary-fork-agEMsPSo.js");
+				const { generateFallbackSummary } = await import("./summary-fork-DpcxN9tf.js");
 				summary = await Effect.runPromise(generateFallbackSummary(sessionFile));
 			} catch (fallbackErr) {
 				logAgentLifecycleSync(normalizedId, `compact-recovery fallback summary failed (${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}); seeding with reseed instructions only`);
@@ -6543,7 +6883,7 @@ async function resumeAgent(agentId, message, opts) {
 	if (gateDecision.decision === "proceed" && gateDecision.warning) logAgentLifecycleSync(normalizedId, `resumeAgent: ${gateDecision.warning}`);
 	if (bypassTroubledGate) logAgentLifecycleSync(normalizedId, `resumeAgent: bypassing troubled gate for explicit compact recovery (${gateBlock?.reason})`);
 	const hasWorkspace = !!agentState?.workspace && existsSync(agentState.workspace);
-	const isPlaceholder = !!agentState && agentState.status === "starting" && typeof agentState.model === "string" && agentState.model.startsWith("pending-");
+	const isPlaceholder = !!agentState && typeof agentState.model === "string" && agentState.model.startsWith("pending-");
 	const allowedRuntimeStates = ["suspended", "idle"];
 	const allowedAgentStatuses = ["stopped", "completed"];
 	const isRunningOrStarting = agentState?.status === "running" || agentState?.status === "starting";
@@ -6636,7 +6976,13 @@ async function resumeAgent(agentId, message, opts) {
 		if (legacyHarnessMigrated) resumeDriftReasons.push(`legacy harness ${priorHarness}→${effectiveHarness} (PAN-1797 re-default)`);
 		const piDeadRecovery = effectiveHarness === "ohmypi" && !piProcessWasAlive && !compactSeed && resumeDriftReasons.length === 0;
 		if (piDeadRecovery) logAgentLifecycleSync(normalizedId, "resumeAgent: dead ohmypi process — fresh-launching for recovery instead of omp --resume (PAN-2009)");
-		const shouldResumeSavedSession = !compactSeed && resumeDriftReasons.length === 0 && !piDeadRecovery;
+		const expectedClaudeJsonl = sessionFilePath(agentState.workspace, sessionId);
+		const claudeJsonlMissingRecovery = effectiveHarness === "claude-code" && !compactSeed && resumeDriftReasons.length === 0 && !existsSync(expectedClaudeJsonl);
+		if (claudeJsonlMissingRecovery) {
+			logAgentLifecycleSync(normalizedId, `resumeAgent: saved Claude transcript is missing at ${expectedClaudeJsonl} — clearing stale pointers and fresh-launching (PAN-2895)`);
+			await clearAgentSessionPointers(normalizedId);
+		}
+		const shouldResumeSavedSession = !compactSeed && resumeDriftReasons.length === 0 && !piDeadRecovery && !claudeJsonlMissingRecovery;
 		if (sessionRotationRefused({
 			compactSeed: Boolean(compactSeed),
 			driftReasons: resumeDriftReasons,
@@ -6657,12 +7003,14 @@ async function resumeAgent(agentId, message, opts) {
 		}
 		const freshSessionId = !shouldResumeSavedSession && effectiveHarness === "claude-code" ? randomUUID() : void 0;
 		if (resumeDriftReasons.length > 0) logAgentLifecycleSync(normalizedId, `resumeAgent: starting fresh session instead of --resume because session origin drifted (${resumeDriftReasons.join(", ")})`);
-		if (freshSessionId) saveSessionId(normalizedId, freshSessionId);
-		else if (!shouldResumeSavedSession) try {
+		if (freshSessionId) {
+			saveSessionId(normalizedId, freshSessionId);
+			agentState.sessionId = freshSessionId;
+		} else if (!shouldResumeSavedSession) try {
 			unlinkSync(join$1(getAgentDir(normalizedId), "session.id"));
 		} catch {}
 		const issueId = agentState.issueId || normalizedId.replace(/^agent-/, "").toUpperCase();
-		const defaultResumeMessage = buildDefaultResumeContinueMessage(issueId);
+		const defaultResumeMessage = buildResumeContinueMessage(agentState);
 		const resumeMessage = compactSeed ? {
 			message: message ? `${compactSeed}\n\n${message}` : compactSeed,
 			redeliveringKickoff: false
@@ -6696,6 +7044,7 @@ async function resumeAgent(agentId, message, opts) {
 			} : {},
 			sessionId: freshSessionId,
 			harness: effectiveHarness,
+			harnessBinaryPath: harnessLaunch.binaryPath,
 			useSupervisor: supervisorLaunch.useSupervisor,
 			supervisorScriptPath: supervisorLaunch.supervisorScriptPath,
 			extraEnvExports: [harnessLaunch.pathExport]
@@ -6711,6 +7060,11 @@ async function resumeAgent(agentId, message, opts) {
 			CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION: "false",
 			...providerEnv
 		} }));
+		if (freshSessionId) await saveAgentRuntimeState(normalizedId, {
+			claudeSessionId: freshSessionId,
+			sessionModel: model,
+			sessionHarness: effectiveHarness
+		});
 		let messageDelivered = false;
 		if (effectiveHarness === "ohmypi") try {
 			await writeOhmypiAgentPrompt(normalizedId, effectiveMessage);
@@ -6720,7 +7074,18 @@ async function resumeAgent(agentId, message, opts) {
 			const msg = err instanceof Error ? err.message : String(err);
 			console.error(`[resumeAgent] ohmypi prompt delivery failed: ${msg}`);
 		}
-		else if (effectiveHarness === "codex") {
+		else if (effectiveHarness === "acp") {
+			const delivery = await deliverInitialPromptWithRetry(normalizedId, effectiveMessage, "resumeAgent:acp-continue");
+			messageDelivered = delivery.ok;
+			if (delivery.ok && resumeMessage.redeliveringKickoff) markKickoffRedelivered(agentState);
+			if (!delivery.ok) {
+				await Effect.runPromise(killSession(normalizedId));
+				return {
+					success: false,
+					error: `ACP continue prompt did not land: ${delivery.failure ?? "unknown failure"}`
+				};
+			}
+		} else if (effectiveHarness === "codex") {
 			const delivery = await deliverInitialPromptWithRetry(normalizedId, effectiveMessage, "resumeAgent:codex-continue", resilientDeliveryMethod(agentState.deliveryMethod));
 			messageDelivered = delivery.ok;
 			if (delivery.ok && resumeMessage.redeliveringKickoff) markKickoffRedelivered(agentState);
@@ -6749,6 +7114,9 @@ async function resumeAgent(agentId, message, opts) {
 		} else if (piDeadRecovery) {
 			console.log(`[agents] Respawned ${normalizedId} fresh because the prior Pi process was dead (archived session ${sessionId})`);
 			logAgentLifecycleSync(normalizedId, `resumeAgent SUCCESS: fresh respawn after dead Pi process (archived sessionId=${sessionId}), messageDelivered=${messageDelivered}`);
+		} else if (claudeJsonlMissingRecovery) {
+			console.log(`[agents] Respawned ${normalizedId} fresh because the saved Claude transcript was missing (stale session ${sessionId}${freshSessionId ? `, new session ${freshSessionId}` : ""})`);
+			logAgentLifecycleSync(normalizedId, `resumeAgent SUCCESS: fresh respawn after missing Claude JSONL (stale sessionId=${sessionId}${freshSessionId ? `, newSessionId=${freshSessionId}` : ""}), messageDelivered=${messageDelivered}`);
 		} else if (!shouldResumeSavedSession) {
 			console.log(`[agents] Respawned ${normalizedId} fresh because session origin drifted (archived session ${sessionId}${freshSessionId ? `, new session ${freshSessionId}` : ""})`);
 			logAgentLifecycleSync(normalizedId, `resumeAgent SUCCESS: fresh respawn after origin drift (archived sessionId=${sessionId}${freshSessionId ? `, newSessionId=${freshSessionId}` : ""}), messageDelivered=${messageDelivered}`);
@@ -6831,6 +7199,7 @@ var init_resume = __esmMin((() => {
 	init_tmux();
 	init_agent_state();
 	init_activity();
+	init_session_pointers();
 	init_delivery();
 	init_identity();
 	init_runtime_state();
@@ -6866,7 +7235,7 @@ var init_graceful_restart = __esmMin((() => {
 //#endregion
 //#region ../../lib/agents/recovery.ts
 function resolveRecoveryResumeSessionId(agentId, harness) {
-	if (harness !== "codex") return void 0;
+	if (harness !== "codex" && harness !== "acp") return void 0;
 	return getLatestSessionIdSync(agentId) ?? void 0;
 }
 async function restartAgent(agentId, opts = {}) {
@@ -6926,6 +7295,7 @@ async function restartAgent(agentId, opts = {}) {
 			role: agentState.role,
 			isPlanning: agentState.role === "plan",
 			harness: effectiveHarness,
+			harnessBinaryPath: harnessLaunch.binaryPath,
 			useSupervisor: supervisorLaunch.useSupervisor,
 			supervisorScriptPath: supervisorLaunch.supervisorScriptPath,
 			extraEnvExports: [harnessLaunch.pathExport]
@@ -6943,18 +7313,20 @@ async function restartAgent(agentId, opts = {}) {
 			GIT_SEQUENCE_EDITOR: "false",
 			...providerEnv
 		} }));
-		const prompt = message || `You are resuming work on ${agentState.issueId}. Read .pan/continue.json for context and pick up where you left off.`;
+		const prompt = message || buildResumeContinueMessage(agentState);
 		if (effectiveHarness === "ohmypi") try {
 			await writeOhmypiAgentPrompt(normalizedId, prompt);
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
 			console.error(`[restartAgent] ohmypi prompt delivery failed for ${normalizedId}: ${msg}`);
 		}
-		else if (await waitForPromptReady(normalizedId, effectiveHarness, 30)) {
+		else {
+			if (!await waitForPromptReady(normalizedId, effectiveHarness, 30)) throw new Error(`${getHarnessBehavior(effectiveHarness).displayName} did not become ready within 30s for ${normalizedId}`);
 			await new Promise((r) => setTimeout(r, 500));
-			if (effectiveHarness === "codex") await deliverAgentMessage(normalizedId, prompt, "restartAgent:continue-prompt", resilientDeliveryMethod(agentState.deliveryMethod));
-			else await Effect.runPromise(sendKeys(normalizedId, prompt));
-		} else console.error(`[restartAgent] ${effectiveHarness === "codex" ? "Codex" : "Claude"} did not become ready within 30s for ${normalizedId}`);
+			if (effectiveHarness === "codex" || effectiveHarness === "acp") {
+				if (!(await deliverAgentMessage(normalizedId, prompt, "restartAgent:continue-prompt", effectiveHarness === "codex" ? resilientDeliveryMethod(agentState.deliveryMethod) : void 0)).ok) throw new Error(`${getHarnessBehavior(effectiveHarness).displayName} continue prompt delivery failed`);
+			} else await Effect.runPromise(sendKeys(normalizedId, prompt));
+		}
 		markAgentRunning(agentState);
 		saveAgentStateSync(agentState);
 		await saveAgentRuntimeState(normalizedId, {
@@ -6965,6 +7337,7 @@ async function restartAgent(agentId, opts = {}) {
 		return { success: true };
 	} catch (error) {
 		const msg = error instanceof Error ? error.message : String(error);
+		await Effect.runPromise(stopAgent(normalizedId)).catch(() => void 0);
 		logAgentLifecycleSync(normalizedId, `restartAgent FAILED: ${msg}`);
 		return {
 			success: false,
@@ -7067,6 +7440,7 @@ async function recoverAgent(agentId, opts = {}) {
 			role: recoveryRole,
 			isPlanning: recoveryRole === "plan",
 			harness: "ohmypi",
+			harnessBinaryPath: harnessLaunch.binaryPath,
 			extraEnvExports: [harnessLaunch.pathExport]
 		});
 		const launcherScript = join$1(getAgentDir(normalizedId), "launcher.sh");
@@ -7090,6 +7464,42 @@ async function recoverAgent(agentId, opts = {}) {
 		logAgentLifecycleSync(normalizedId, `recoverAgent SUCCESS: recoveryCount=${health.recoveryCount} (ohmypi)`);
 		return state;
 	}
+	if (recoveryHarness === "acp") {
+		const resumeSessionId = resolveRecoveryResumeSessionId(normalizedId, recoveryHarness);
+		const { launcherContent, providerEnv: acpProviderEnv } = await buildAgentLaunchConfig({
+			agentId: normalizedId,
+			model: state.model,
+			workspace: state.workspace,
+			role: recoveryRole,
+			isPlanning: recoveryRole === "plan",
+			...resumeSessionId ? {
+				spawnMode: "resume",
+				resumeSessionId
+			} : {},
+			harness: "acp",
+			harnessBinaryPath: harnessLaunch.binaryPath,
+			extraEnvExports: [harnessLaunch.pathExport]
+		});
+		const launcherScript = join$1(getAgentDir(normalizedId), "launcher.sh");
+		await writeLauncherScriptAtomic(launcherScript, launcherContent);
+		await Effect.runPromise(createSession(normalizedId, state.workspace, `bash ${launcherScript}`, { env: {
+			...BLANKED_PROVIDER_ENV,
+			OVERDECK_AGENT_ID: normalizedId,
+			OVERDECK_ISSUE_ID: state.issueId || "",
+			OVERDECK_SESSION_TYPE: recoveryRole,
+			CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION: "false",
+			...acpProviderEnv
+		} }));
+		const delivery = await deliverInitialPromptWithRetry(normalizedId, recoveryPrompt, "recoverAgent:acp-recovery-prompt");
+		if (!delivery.ok) {
+			await Effect.runPromise(stopAgent(normalizedId));
+			throw new Error(`ACP recovery prompt delivery failed for ${normalizedId}: ${delivery.failure ?? "unknown failure"}`);
+		}
+		markAgentRunning(state);
+		saveAgentStateSync(state);
+		logAgentLifecycleSync(normalizedId, `recoverAgent SUCCESS: recoveryCount=${health.recoveryCount} (acp)`);
+		return state;
+	}
 	const recoveryCodexFields = recoveryHarness === "codex" ? getCodexLauncherFields(normalizedId, state.model, state.workspace, recoveryRole) : {};
 	const recoveryLauncherContent = generateLauncherScriptSync({
 		role: recoveryRole,
@@ -7141,7 +7551,7 @@ function generateRecoveryPrompt(state) {
 		`- Started: ${state.startedAt}`,
 		"",
 		"## Recovery Steps",
-		"1. Check the vBRIEF task state: `pan task show " + state.issueId + " <item-id>`",
+		"1. Check the xBRIEF task state: `pan task show " + state.issueId + " <item-id>`",
 		"2. Review recent git commits: `git log --oneline -10`",
 		"3. Check hook for pending work: `pan admin fpp check`",
 		"4. Resume from last known state",
@@ -7191,6 +7601,7 @@ var init_recovery = __esmMin((() => {
 	init_persistent_logger();
 	init_providers();
 	init_conversations();
+	init_behavior();
 	init_tmux();
 	init_agent_state();
 	init_delivery();
@@ -7441,7 +7852,7 @@ var init_tier_escalation = __esmMin((() => {
 * not to respond, so per-event output cost stays ~0 (NFR-1).
 */
 async function runGitShow$1(workspace, sha, args = []) {
-	const { stdout } = await execFileAsync$2("git", [
+	const { stdout } = await execFileAsync$5("git", [
 		"show",
 		sha,
 		...args
@@ -7462,11 +7873,11 @@ async function renderCommitFeedDiff(workspace, sha, feedConfig = DEFAULT_FEED_CO
 		".",
 		...feedConfig.exclude.map((glob) => `:(exclude)${glob}`)
 	] : [];
-	const diff = await gitShow(workspace, sha, pathspecArgs);
+	const diff = await renderWorkspaceGitShowPromise(deps.issueId, workspace, sha, pathspecArgs, gitShow);
 	const maxBytes = feedConfig.max_diff_bytes;
 	if (maxBytes === null || Buffer.byteLength(diff, "utf-8") <= maxBytes) return diff;
 	return [
-		(await gitShow(workspace, sha, ["--stat", ...pathspecArgs])).trimEnd(),
+		(await renderWorkspaceGitShowPromise(deps.issueId, workspace, sha, ["--stat", ...pathspecArgs], gitShow)).trimEnd(),
 		"",
 		`[tiered_execution.feed.max_diff_bytes truncated commit diff: ${Buffer.byteLength(diff, "utf-8")} bytes exceeded ${maxBytes} bytes]`,
 		""
@@ -7508,7 +7919,10 @@ function composeCommitFeedMessage(sha, itemTitle, diff, callout) {
 async function broadcastCommit(options) {
 	const feedConfig = options.feedConfig ?? DEFAULT_FEED_CONFIG;
 	if (shouldSkipFeedSubject(options.commitSubject ?? options.itemTitle, feedConfig)) return [];
-	const renderDiff = options.renderDiff ?? (options.gitShow ? (workspace, sha) => options.gitShow(workspace, sha) : renderCommitFeedDiff);
+	const renderDiff = options.renderDiff ?? ((workspace, sha, config) => renderCommitFeedDiff(workspace, sha, config, {
+		issueId: options.issueId,
+		gitShow: options.gitShow ? (repoPath, repoSha) => options.gitShow(repoPath, repoSha) : void 0
+	}));
 	const deliver = options.deliver ?? deliverAgentMessage;
 	const recordDelivery = options.recordDelivery ?? recordTierFeedDelivery;
 	const now = options.now ?? (() => /* @__PURE__ */ new Date());
@@ -7555,12 +7969,13 @@ async function broadcastCommit(options) {
 	}
 	return deliveries;
 }
-var execFileAsync$2, DEFAULT_FEED_CONFIG;
+var execFileAsync$5, DEFAULT_FEED_CONFIG;
 var init_tier_feed = __esmMin((() => {
+	init_git_utils();
 	init_delivery();
 	init_tier_metrics();
 	init_tier_table();
-	execFileAsync$2 = promisify(execFile);
+	execFileAsync$5 = promisify(execFile);
 	DEFAULT_FEED_CONFIG = DEFAULT_TIERED_EXECUTION_CONFIG.feed;
 }));
 //#endregion
@@ -7680,7 +8095,7 @@ function childItems(item) {
 	return item.items ?? item.subItems ?? [];
 }
 /**
-* Pull the bead's acceptance-criterion titles from its vBRIEF child items
+* Pull the bead's acceptance-criterion titles from its xBRIEF child items
 * (child metadata.kind === 'acceptance_criterion').
 */
 function extractAcceptanceCriteria(item) {
@@ -7774,23 +8189,29 @@ Rules:
 - Do not use any other endpoint or side channel for the verdict.
 - Only review this commit against this bead's acceptance criteria — compile, lint, and tests are the verification gate's job, and code style is the review convoy's job.`;
 }
-async function getCommitDiff(workspacePath, sha) {
-	const { stdout } = await execFileAsync$1("git", ["show", sha], {
-		cwd: workspacePath,
-		encoding: "utf-8",
-		maxBuffer: 10 * 1024 * 1024
+async function getCommitDiff(issueId, workspacePath, sha) {
+	return renderWorkspaceGitShowPromise(issueId, workspacePath, sha, [], async (repoPath, repoSha, args) => {
+		const { stdout } = await execFileAsync$4("git", [
+			"show",
+			repoSha,
+			...args
+		], {
+			cwd: repoPath,
+			encoding: "utf-8",
+			maxBuffer: 10 * 1024 * 1024
+		});
+		return stdout;
 	});
-	return stdout;
 }
 /**
 * Deliver one subscribed commit to the standing supervisor for review:
-* resolve the diff, pull the bead's acceptance criteria from its vBRIEF item
+* resolve the diff, pull the bead's acceptance criteria from its xBRIEF item
 * (plus traced FR text when metadata.traces is present and a PRD draft was
 * provided), and send the composed review request via deliverAgentMessage.
 */
 async function deliverCommitForReview(options) {
 	const deliver = options.deps?.deliver ?? deliverAgentMessage;
-	const diff = await (options.deps?.getDiff ?? getCommitDiff)(options.workspacePath, options.sha);
+	const diff = await (options.deps?.getDiff ?? ((workspacePath, sha) => getCommitDiff(options.issueId, workspacePath, sha)))(options.workspacePath, options.sha);
 	const traces = Array.isArray(options.item.metadata?.traces) ? options.item.metadata.traces : [];
 	const frText = options.prdMarkdown && traces.length > 0 ? extractTracedFrText(options.prdMarkdown, traces) : void 0;
 	const message = buildSupervisorReviewMessage({
@@ -7805,13 +8226,14 @@ async function deliverCommitForReview(options) {
 	});
 	return deliver(options.supervisorAgentId, message, "tier-supervisor:verdict");
 }
-var SUPERVISOR_SUB_ROLE, execFileAsync$1;
+var SUPERVISOR_SUB_ROLE, execFileAsync$4;
 var init_tier_supervisor = __esmMin((() => {
+	init_git_utils();
 	init_delivery();
 	init_spawn_prep();
 	init_spawn();
 	SUPERVISOR_SUB_ROLE = "supervisor";
-	execFileAsync$1 = promisify(execFile);
+	execFileAsync$4 = promisify(execFile);
 }));
 //#endregion
 //#region ../../lib/agents/tier-replay.ts
@@ -7821,7 +8243,7 @@ var init_tier_supervisor = __esmMin((() => {
 * from `git log <base>..HEAD`, oldest commit first.
 */
 async function replayStandingAgent(target, options = {}) {
-	const deps = replayDeps(options.deps);
+	const deps = replayDeps(options.deps, target.issueId);
 	const replayTarget = target.kind === "tier" ? {
 		...target,
 		...resolveReplaySlot(target, deps)
@@ -7846,7 +8268,7 @@ async function replayCrashedStandingAgent(target, options = {}) {
 */
 async function compactAtTierRunBoundary(options) {
 	if (!shouldReplayCompactAtTierRunBoundary(options.compaction)) return null;
-	const deps = replayDeps(options.deps);
+	const deps = replayDeps(options.deps, options.target.issueId);
 	const rerouted = resolveReroutedReplayTarget(options.target);
 	if (!rerouted) {
 		if (options.target.agentId) await deps.stop(options.target.agentId);
@@ -7991,7 +8413,7 @@ async function loadReplayCommits(workspace, base, feedConfig, deps) {
 	return commits;
 }
 async function runGitLog(workspace, base) {
-	const { stdout } = await execFileAsync("git", [
+	const { stdout } = await execFileAsync$3("git", [
 		"log",
 		"--reverse",
 		"--format=%H%x00%s",
@@ -8009,27 +8431,34 @@ async function runGitLog(workspace, base) {
 		};
 	}).filter((entry) => entry.sha.trim().length > 0);
 }
-async function runGitShow(workspace, sha) {
-	const { stdout } = await execFileAsync("git", ["show", sha], {
-		cwd: workspace,
-		encoding: "utf-8",
-		maxBuffer: 16 * 1024 * 1024
+async function runGitShow(issueId, workspace, sha) {
+	return renderWorkspaceGitShowPromise(issueId, workspace, sha, [], async (repoPath, repoSha, args) => {
+		const { stdout } = await execFileAsync$3("git", [
+			"show",
+			repoSha,
+			...args
+		], {
+			cwd: repoPath,
+			encoding: "utf-8",
+			maxBuffer: 16 * 1024 * 1024
+		});
+		return stdout;
 	});
-	return stdout;
 }
-function replayDeps(deps = {}) {
+function replayDeps(deps = {}, issueId) {
 	return {
 		spawn: deps.spawn ?? spawnRun,
 		deliver: deps.deliver ?? deliverAgentMessage,
 		stop: deps.stop ?? stopAgent,
 		gitLog: deps.gitLog ?? runGitLog,
-		gitShow: deps.gitShow ?? runGitShow,
-		renderDiff: deps.renderDiff ?? (deps.gitShow ? (workspace, sha) => deps.gitShow(workspace, sha) : renderCommitFeedDiff),
+		gitShow: deps.gitShow ?? ((workspace, sha) => runGitShow(issueId, workspace, sha)),
+		renderDiff: deps.renderDiff ?? (deps.gitShow ? (workspace, sha) => deps.gitShow(workspace, sha) : (workspace, sha, feedConfig) => renderCommitFeedDiff(workspace, sha, feedConfig, { issueId })),
 		listSlotOwnership: deps.listSlotOwnership ?? listSlotOwnership
 	};
 }
-var execFileAsync, DEFAULT_REPLAY_THRESHOLD;
+var execFileAsync$3, DEFAULT_REPLAY_THRESHOLD;
 var init_tier_replay = __esmMin((() => {
+	init_git_utils();
 	init_model_capabilities();
 	init_delivery();
 	init_spawn();
@@ -8040,7 +8469,7 @@ var init_tier_replay = __esmMin((() => {
 	init_tier_supervisor();
 	init_tier_table();
 	init_termination();
-	execFileAsync = promisify(execFile);
+	execFileAsync$3 = promisify(execFile);
 	DEFAULT_REPLAY_THRESHOLD = .5;
 }));
 //#endregion
@@ -8064,16 +8493,585 @@ var init_agents = __esmMin((() => {
 	init_tier_replay();
 }));
 //#endregion
+//#region ../../lib/system-health/types.ts
+function available(value) {
+	return {
+		status: "available",
+		value
+	};
+}
+function unavailable(reason) {
+	return {
+		status: "unavailable",
+		reason
+	};
+}
+var init_types = __esmMin((() => {}));
+//#endregion
+//#region ../../lib/system-health/darwin.ts
+function parseDarwinMemoryPressure(content) {
+	for (const pattern of [/System-wide memory free percentage:\s*([\d.]+)\s*%/i, /System-wide memory free percentage\s*=\s*([\d.]+)\s*%?/i]) {
+		const match = content.match(pattern);
+		if (!match) continue;
+		const value = Number(match[1]);
+		if (Number.isFinite(value) && value >= 0 && value <= 100) return value;
+	}
+	return null;
+}
+function parseDarwinVmStat(content) {
+	const pageSizeMatch = content.match(/page size of\s+(\d+)\s+bytes/i);
+	if (!pageSizeMatch) return null;
+	const pageSizeBytes = Number(pageSizeMatch[1]);
+	if (!Number.isFinite(pageSizeBytes) || pageSizeBytes <= 0) return null;
+	const pages = /* @__PURE__ */ new Map();
+	for (const line of content.split("\n")) {
+		const match = line.match(/^([^:]+):\s+(\d+)\.?$/);
+		if (!match) continue;
+		const value = Number(match[2]);
+		if (Number.isFinite(value)) pages.set(match[1].trim(), value);
+	}
+	const availablePageNames = [
+		"Pages free",
+		"Pages inactive",
+		"Pages speculative"
+	];
+	const availablePages = availablePageNames.every((name) => pages.has(name)) ? availablePageNames.reduce((sum, name) => sum + pages.get(name), 0) : void 0;
+	const swapIn = pages.get("Swapins");
+	const swapOut = pages.get("Swapouts");
+	return {
+		pageSizeBytes,
+		availableMemoryBytes: availablePages == null ? void 0 : availablePages * pageSizeBytes,
+		swap: swapIn == null || swapOut == null ? void 0 : {
+			pagesIn: swapIn,
+			pagesOut: swapOut
+		}
+	};
+}
+function unitBytes(value, unit) {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed < 0) return null;
+	const multiplier = unit.toUpperCase() === "G" ? 1024 ** 3 : unit.toUpperCase() === "K" ? 1024 : MIB;
+	return Math.round(parsed * multiplier);
+}
+function parseDarwinSwapUsage(content) {
+	const total = content.match(/total\s*=\s*([\d.]+)([KMG])/i);
+	const used = content.match(/used\s*=\s*([\d.]+)([KMG])/i);
+	const free = content.match(/free\s*=\s*([\d.]+)([KMG])/i);
+	if (!total || !used || !free) return null;
+	const totalBytes = unitBytes(total[1], total[2]);
+	const usedBytes = unitBytes(used[1], used[2]);
+	const freeBytes = unitBytes(free[1], free[2]);
+	return totalBytes == null || usedBytes == null || freeBytes == null ? null : {
+		totalBytes,
+		usedBytes,
+		freeBytes
+	};
+}
+function aggregateDarwinCpuCounters(cpuInfo) {
+	if (cpuInfo.length === 0) return null;
+	let idle = 0;
+	let total = 0;
+	for (const cpu of cpuInfo) {
+		const values = Object.values(cpu.times);
+		if (values.some((value) => !Number.isFinite(value) || value < 0)) return null;
+		idle += cpu.times.idle;
+		total += values.reduce((sum, value) => sum + value, 0);
+	}
+	return {
+		idle,
+		total
+	};
+}
+function computeCpuPercent$1(current, previous) {
+	if (!previous) return unavailable("A previous CPU time sample is required.");
+	const totalDelta = current.total - previous.total;
+	const idleDelta = current.idle - previous.idle;
+	if (totalDelta <= 0 || idleDelta < 0 || idleDelta > totalDelta) return unavailable("CPU times did not advance monotonically.");
+	return available(Math.round((totalDelta - idleDelta) / totalDelta * 1e3) / 10);
+}
+function computeSwapActivity(current, previous, elapsedMs, pageSizeBytes) {
+	if (!previous) return unavailable("A previous swap counter sample is required.");
+	const pages = current.pagesIn - previous.pagesIn + current.pagesOut - previous.pagesOut;
+	if (pages < 0 || elapsedMs <= 0) return unavailable("Swap counters or sample timing were invalid.");
+	return available(Math.round(pages * pageSizeBytes * 6e4 / elapsedMs));
+}
+function percent$1(part, total) {
+	if (total <= 0) return 0;
+	return Math.round(part / total * 1e3) / 10;
+}
+async function command(adapters, executable, args) {
+	try {
+		return await adapters.execFile(executable, args, COMMAND_TIMEOUT_MS);
+	} catch {
+		return null;
+	}
+}
+function createDarwinHostHealthCollector(adapters = defaultAdapters$1) {
+	return {
+		platform: "darwin",
+		async sample(previous) {
+			const sampledAtMs = adapters.now();
+			const [pressureOutput, vmStatOutput, swapOutput] = await Promise.all([
+				command(adapters, "memory_pressure", ["-Q"]),
+				command(adapters, "vm_stat", []),
+				command(adapters, "sysctl", ["-n", "vm.swapusage"])
+			]);
+			const pressureFreePercent = pressureOutput == null ? null : parseDarwinMemoryPressure(pressureOutput);
+			const vmStat = vmStatOutput == null ? null : parseDarwinVmStat(vmStatOutput);
+			const swapUsage = swapOutput == null ? null : parseDarwinSwapUsage(swapOutput);
+			const cpuInfo = adapters.cpus();
+			const cpuCounters = aggregateDarwinCpuCounters(cpuInfo);
+			const totalMemoryBytes = adapters.totalMemoryBytes();
+			const availableMemoryBytes = pressureFreePercent != null ? Math.round(totalMemoryBytes * pressureFreePercent / 100) : vmStat?.availableMemoryBytes ?? null;
+			const usedMemoryBytes = Number.isFinite(totalMemoryBytes) && availableMemoryBytes != null ? Math.max(totalMemoryBytes - availableMemoryBytes, 0) : null;
+			const loadAverage1m = adapters.loadAverage1m();
+			const elapsedMs = previous ? sampledAtMs - previous.sampledAtMs : 0;
+			return {
+				platform: "darwin",
+				sampledAtMs,
+				cpuPercent: cpuCounters ? computeCpuPercent$1(cpuCounters, previous?.counters.cpu) : unavailable("macOS CPU times are unavailable."),
+				loadAverage1m: Number.isFinite(loadAverage1m) && loadAverage1m >= 0 ? available(loadAverage1m) : unavailable("The one-minute load average is unavailable."),
+				loadPerCore1m: Number.isFinite(loadAverage1m) && loadAverage1m >= 0 && cpuInfo.length > 0 ? available(Math.round(loadAverage1m / cpuInfo.length * 100) / 100) : unavailable("Load average or CPU core count is unavailable."),
+				totalMemoryBytes: Number.isFinite(totalMemoryBytes) && totalMemoryBytes > 0 ? available(totalMemoryBytes) : unavailable("Total memory is unavailable."),
+				usedMemoryBytes: usedMemoryBytes == null ? unavailable("Used memory cannot be derived.") : available(usedMemoryBytes),
+				availableMemoryBytes: availableMemoryBytes == null ? unavailable("Available memory is unavailable.") : available(availableMemoryBytes),
+				memoryUsedPercent: usedMemoryBytes == null ? unavailable("Memory utilization cannot be derived.") : available(percent$1(usedMemoryBytes, totalMemoryBytes)),
+				memoryPressureSomeAvg10: unavailable("macOS does not expose Linux memory PSI."),
+				memoryPressureFullAvg10: unavailable("macOS does not expose Linux memory PSI."),
+				memoryPressureFreePercent: pressureFreePercent == null ? unavailable("memory_pressure did not report a recognized free percentage.") : available(pressureFreePercent),
+				swapTotalBytes: swapUsage ? available(swapUsage.totalBytes) : unavailable("vm.swapusage is unavailable."),
+				swapUsedBytes: swapUsage ? available(swapUsage.usedBytes) : unavailable("vm.swapusage is unavailable."),
+				swapUsedPercent: swapUsage ? available(percent$1(swapUsage.usedBytes, swapUsage.totalBytes)) : unavailable("vm.swapusage is unavailable."),
+				swapActivityBytesPerMinute: vmStat?.swap ? computeSwapActivity(vmStat.swap, previous?.counters.swap, elapsedMs, vmStat.pageSizeBytes) : unavailable("vm_stat swap activity counters are unavailable."),
+				committedMemoryBytes: unavailable("macOS does not expose Linux Committed_AS."),
+				commitLimitBytes: unavailable("macOS does not expose Linux CommitLimit."),
+				virtualCommitmentPercent: unavailable("macOS virtual commitment is unavailable."),
+				counters: {
+					cpu: cpuCounters,
+					swap: vmStat?.swap ?? null
+				}
+			};
+		}
+	};
+}
+var execFileAsync$2, COMMAND_TIMEOUT_MS, MIB, DARWIN_MEMORY_PRESSURE_DEFAULTS, defaultAdapters$1;
+var init_darwin = __esmMin((() => {
+	init_types();
+	execFileAsync$2 = promisify(execFile);
+	COMMAND_TIMEOUT_MS = 5e3;
+	MIB = 1024 ** 2;
+	DARWIN_MEMORY_PRESSURE_DEFAULTS = Object.freeze({
+		warningFreePercent: 10,
+		criticalFreePercent: 5,
+		swapActivityWarningBytesPerMinute: 64 * MIB,
+		swapActivityCriticalBytesPerMinute: 256 * MIB
+	});
+	defaultAdapters$1 = {
+		execFile: async (command, args, timeoutMs) => {
+			const { stdout } = await execFileAsync$2(command, [...args], {
+				encoding: "utf-8",
+				timeout: timeoutMs
+			});
+			return stdout;
+		},
+		cpus: cpus$1,
+		loadAverage1m: () => loadavg$1()[0] ?? 0,
+		totalMemoryBytes: totalmem$1,
+		now: () => Date.now()
+	};
+}));
+//#endregion
+//#region ../../lib/system-health/linux.ts
+function parseMemInfo(content) {
+	const values = /* @__PURE__ */ new Map();
+	for (const line of content.split("\n")) {
+		const match = line.match(/^(\w+):\s+(\d+)\s+kB$/);
+		if (!match) continue;
+		const value = Number(match[2]);
+		if (Number.isFinite(value)) values.set(match[1], value * KB);
+	}
+	return {
+		memTotalBytes: values.get("MemTotal"),
+		memAvailableBytes: values.get("MemAvailable"),
+		swapTotalBytes: values.get("SwapTotal"),
+		swapFreeBytes: values.get("SwapFree"),
+		committedMemoryBytes: values.get("Committed_AS"),
+		commitLimitBytes: values.get("CommitLimit")
+	};
+}
+function parseProcStat(content) {
+	const lines = content.split("\n");
+	const cpuLine = lines.find((line) => line.startsWith("cpu "));
+	if (!cpuLine) return null;
+	const values = cpuLine.trim().split(/\s+/).slice(1).map(Number);
+	if (values.length < 4 || values.some((value) => !Number.isFinite(value))) return null;
+	const idle = values[3] + (values[4] ?? 0);
+	const total = values.reduce((sum, value) => sum + value, 0);
+	const coreCount = lines.filter((line) => /^cpu\d+\s/.test(line)).length;
+	if (total < 0 || idle < 0) return null;
+	return {
+		cpu: {
+			idle,
+			total
+		},
+		coreCount: Math.max(coreCount, 1)
+	};
+}
+function parseMemoryPressure(content) {
+	const result = {};
+	for (const line of content.split("\n")) {
+		const match = line.match(/^(some|full)\s+.*\bavg10=([^\s]+)/);
+		if (!match) continue;
+		const value = Number(match[2]);
+		if (!Number.isFinite(value) || value < 0) continue;
+		if (match[1] === "some") result.someAvg10 = value;
+		if (match[1] === "full") result.fullAvg10 = value;
+	}
+	return result;
+}
+function parseVmstat(content) {
+	let pagesIn = null;
+	let pagesOut = null;
+	for (const line of content.split("\n")) {
+		const match = line.match(/^(pswpin|pswpout)\s+(\d+)$/);
+		if (!match) continue;
+		const value = Number(match[2]);
+		if (!Number.isFinite(value)) continue;
+		if (match[1] === "pswpin") pagesIn = value;
+		if (match[1] === "pswpout") pagesOut = value;
+	}
+	return pagesIn == null || pagesOut == null ? null : {
+		pagesIn,
+		pagesOut
+	};
+}
+function parseLoadAverage(content) {
+	const value = Number(content.trim().split(/\s+/)[0]);
+	return Number.isFinite(value) && value >= 0 ? value : null;
+}
+function computeCpuPercent(current, previous) {
+	if (!previous) return unavailable("A previous CPU counter sample is required.");
+	const totalDelta = current.total - previous.total;
+	const idleDelta = current.idle - previous.idle;
+	if (totalDelta <= 0 || idleDelta < 0 || idleDelta > totalDelta) return unavailable("CPU counters did not advance monotonically.");
+	return available(Math.round((totalDelta - idleDelta) / totalDelta * 1e3) / 10);
+}
+function computeSwapActivityBytesPerMinute(current, previous, elapsedMs, pageSizeBytes) {
+	if (!previous) return unavailable("A previous swap counter sample is required.");
+	const pageDelta = current.pagesIn - previous.pagesIn + current.pagesOut - previous.pagesOut;
+	if (pageDelta < 0 || elapsedMs <= 0 || !Number.isFinite(pageSizeBytes) || pageSizeBytes <= 0) return unavailable("Swap counters or sample timing were invalid.");
+	return available(Math.round(pageDelta * pageSizeBytes * 6e4 / elapsedMs));
+}
+async function readParsed(adapters, path, parse) {
+	try {
+		return parse(await adapters.readFile(path));
+	} catch {
+		return null;
+	}
+}
+function percent(part, total) {
+	if (total <= 0) return 0;
+	return Math.round(part / total * 1e3) / 10;
+}
+function createLinuxHostHealthCollector(adapters = defaultAdapters) {
+	return {
+		platform: "linux",
+		async sample(previous) {
+			const sampledAtMs = adapters.now();
+			const [memInfo, procStat, pressure, vmstat, loadAverage, pageSizeBytes] = await Promise.all([
+				readParsed(adapters, "/proc/meminfo", parseMemInfo),
+				readParsed(adapters, "/proc/stat", parseProcStat),
+				readParsed(adapters, "/proc/pressure/memory", parseMemoryPressure),
+				readParsed(adapters, "/proc/vmstat", parseVmstat),
+				readParsed(adapters, "/proc/loadavg", parseLoadAverage),
+				adapters.readPageSizeBytes().catch(() => null)
+			]);
+			const totalMemoryBytes = memInfo?.memTotalBytes;
+			const availableMemoryBytes = memInfo?.memAvailableBytes;
+			const usedMemoryBytes = totalMemoryBytes != null && availableMemoryBytes != null ? Math.max(totalMemoryBytes - availableMemoryBytes, 0) : null;
+			const swapTotalBytes = memInfo?.swapTotalBytes;
+			const swapFreeBytes = memInfo?.swapFreeBytes;
+			const swapUsedBytes = swapTotalBytes != null && swapFreeBytes != null ? Math.max(swapTotalBytes - swapFreeBytes, 0) : null;
+			const committedMemoryBytes = memInfo?.committedMemoryBytes;
+			const commitLimitBytes = memInfo?.commitLimitBytes;
+			const cpuCounters = procStat?.cpu ?? null;
+			const swapCounters = vmstat ?? null;
+			const elapsedMs = previous ? sampledAtMs - previous.sampledAtMs : 0;
+			return {
+				platform: "linux",
+				sampledAtMs,
+				cpuPercent: cpuCounters ? computeCpuPercent(cpuCounters, previous?.counters.cpu) : unavailable("The aggregate CPU counters are unavailable."),
+				loadAverage1m: loadAverage == null ? unavailable("The one-minute load average is unavailable.") : available(loadAverage),
+				loadPerCore1m: loadAverage == null || !procStat ? unavailable("Load average or CPU core count is unavailable.") : available(Math.round(loadAverage / procStat.coreCount * 100) / 100),
+				totalMemoryBytes: totalMemoryBytes == null ? unavailable("MemTotal is unavailable.") : available(totalMemoryBytes),
+				usedMemoryBytes: usedMemoryBytes == null ? unavailable("Used memory cannot be derived without MemTotal and MemAvailable.") : available(usedMemoryBytes),
+				availableMemoryBytes: availableMemoryBytes == null ? unavailable("MemAvailable is unavailable.") : available(availableMemoryBytes),
+				memoryUsedPercent: usedMemoryBytes == null || totalMemoryBytes == null ? unavailable("Memory utilization cannot be derived.") : available(percent(usedMemoryBytes, totalMemoryBytes)),
+				memoryPressureSomeAvg10: pressure?.someAvg10 == null ? unavailable("Linux memory PSI some.avg10 is unavailable.") : available(pressure.someAvg10),
+				memoryPressureFullAvg10: pressure?.fullAvg10 == null ? unavailable("Linux memory PSI full.avg10 is unavailable.") : available(pressure.fullAvg10),
+				memoryPressureFreePercent: unavailable("Linux reports memory pressure through PSI."),
+				swapTotalBytes: swapTotalBytes == null ? unavailable("SwapTotal is unavailable.") : available(swapTotalBytes),
+				swapUsedBytes: swapUsedBytes == null ? unavailable("Swap usage cannot be derived without SwapTotal and SwapFree.") : available(swapUsedBytes),
+				swapUsedPercent: swapUsedBytes == null || swapTotalBytes == null ? unavailable("Swap utilization cannot be derived.") : available(percent(swapUsedBytes, swapTotalBytes)),
+				swapActivityBytesPerMinute: swapCounters && pageSizeBytes != null ? computeSwapActivityBytesPerMinute(swapCounters, previous?.counters.swap, elapsedMs, pageSizeBytes) : unavailable("Linux swap activity counters are unavailable."),
+				committedMemoryBytes: committedMemoryBytes == null ? unavailable("Committed_AS is unavailable.") : available(committedMemoryBytes),
+				commitLimitBytes: commitLimitBytes == null ? unavailable("CommitLimit is unavailable.") : available(commitLimitBytes),
+				virtualCommitmentPercent: committedMemoryBytes == null || commitLimitBytes == null ? unavailable("Virtual commitment cannot be derived.") : available(percent(committedMemoryBytes, commitLimitBytes)),
+				counters: {
+					cpu: cpuCounters,
+					swap: swapCounters
+				}
+			};
+		}
+	};
+}
+var execFileAsync$1, KB, LINUX_MEMORY_PRESSURE_DEFAULTS, defaultAdapters;
+var init_linux = __esmMin((() => {
+	init_types();
+	execFileAsync$1 = promisify(execFile);
+	KB = 1024;
+	LINUX_MEMORY_PRESSURE_DEFAULTS = Object.freeze({
+		someWarningAvg10: 5,
+		fullCriticalAvg10: 1,
+		swapActivityWarningBytesPerMinute: 64 * 1024 ** 2,
+		swapActivityCriticalBytesPerMinute: 256 * 1024 ** 2
+	});
+	defaultAdapters = {
+		readFile: (path) => readFile(path, "utf-8"),
+		readPageSizeBytes: async () => {
+			const { stdout } = await execFileAsync$1("getconf", ["PAGESIZE"], {
+				encoding: "utf-8",
+				timeout: 5e3
+			});
+			const value = Number(stdout.trim());
+			if (!Number.isFinite(value) || value <= 0) throw new Error("getconf returned an invalid page size");
+			return value;
+		},
+		now: () => Date.now()
+	};
+}));
+//#endregion
+//#region ../../lib/system-health/collector.ts
+/**
+* Selects the platform host-health collector. Linux and macOS expose native
+* current-pressure signals; unsupported platforms return unavailable signals
+* so callers never mistake missing measurements for measured zeroes.
+*/
+function buildProcessTreeIndex(rows) {
+	const childrenByParent = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const children = childrenByParent.get(row.ppid);
+		if (children) children.push(row.pid);
+		else childrenByParent.set(row.ppid, [row.pid]);
+	}
+	return { childrenByParent };
+}
+function collectDescendantPids(rootPid, index) {
+	const descendants = /* @__PURE__ */ new Set();
+	const queue = [rootPid];
+	while (queue.length > 0) {
+		const pid = queue.shift();
+		if (pid == null || descendants.has(pid)) continue;
+		descendants.add(pid);
+		queue.push(...index.childrenByParent.get(pid) ?? []);
+	}
+	return descendants;
+}
+function createUnsupportedCollector(platform = "unsupported") {
+	const signal = () => unavailable("Host health collection is unsupported on this platform.");
+	return {
+		platform,
+		async sample() {
+			return {
+				platform,
+				sampledAtMs: Date.now(),
+				cpuPercent: signal(),
+				loadAverage1m: signal(),
+				loadPerCore1m: signal(),
+				totalMemoryBytes: signal(),
+				usedMemoryBytes: signal(),
+				availableMemoryBytes: signal(),
+				memoryUsedPercent: signal(),
+				memoryPressureSomeAvg10: signal(),
+				memoryPressureFullAvg10: signal(),
+				memoryPressureFreePercent: signal(),
+				swapTotalBytes: signal(),
+				swapUsedBytes: signal(),
+				swapUsedPercent: signal(),
+				swapActivityBytesPerMinute: signal(),
+				committedMemoryBytes: signal(),
+				commitLimitBytes: signal(),
+				virtualCommitmentPercent: signal(),
+				counters: {
+					cpu: null,
+					swap: null
+				}
+			};
+		}
+	};
+}
+function createHostHealthCollector(selection = {}) {
+	const platform = selection.platform ?? platform$1();
+	if (platform === "linux") return selection.linux ?? createLinuxHostHealthCollector();
+	if (platform === "darwin") return selection.darwin ?? createDarwinHostHealthCollector();
+	return createUnsupportedCollector();
+}
+var init_collector = __esmMin((() => {
+	init_darwin();
+	init_linux();
+	init_types();
+}));
+//#endregion
+//#region ../../lib/runtime-census.ts
+function parseRuntimeProcessTable(output) {
+	return output.split("\n").flatMap((line) => {
+		const match = line.trim().match(/^(\d+)\s+(\d+)\s+([0-9.]+)\s+(\d+)\s+(\S+)(?:\s+(.*))?$/);
+		if (!match) return [];
+		const pid = Number(match[1]);
+		const ppid = Number(match[2]);
+		const cpuPercent = Number(match[3]);
+		const rssKb = Number(match[4]);
+		if (![
+			pid,
+			ppid,
+			cpuPercent,
+			rssKb
+		].every(Number.isFinite)) return [];
+		return [{
+			pid,
+			ppid,
+			cpuPercent,
+			rssBytes: rssKb * 1024,
+			comm: match[5] ?? "",
+			command: match[6] ?? match[5] ?? ""
+		}];
+	});
+}
+async function readRuntimeProcessTable() {
+	const { stdout } = await execFileAsync("ps", ["-eo", "pid=,ppid=,pcpu=,rss=,comm=,args="], {
+		encoding: "utf8",
+		timeout: 1e4
+	});
+	return parseRuntimeProcessTable(String(stdout));
+}
+function buildRuntimeCensus(panes, processes, sampledAt, options) {
+	const panesBySession = /* @__PURE__ */ new Map();
+	for (const pane of panes) {
+		const sessionPanes = panesBySession.get(pane.sessionName);
+		if (sessionPanes) sessionPanes.push(pane);
+		else panesBySession.set(pane.sessionName, [pane]);
+	}
+	const processesByPid = new Map(processes.map((process) => [process.pid, process]));
+	return {
+		sampledAt,
+		available: options.tmuxAvailable,
+		tmuxAvailable: options.tmuxAvailable,
+		processAvailable: options.processAvailable,
+		stale: options.stale ?? false,
+		error: options.error ?? null,
+		panes,
+		sessionNames: new Set(panesBySession.keys()),
+		panesBySession,
+		processesByPid,
+		processTree: buildProcessTreeIndex(processes)
+	};
+}
+function createRuntimeCensusService(deps) {
+	const now = deps.now ?? Date.now;
+	const ttlMs = deps.ttlMs ?? 3e3;
+	let snapshot = null;
+	let inFlight = null;
+	const refresh = () => {
+		if (inFlight) return inFlight;
+		inFlight = Promise.allSettled([deps.listPanes(), deps.readProcesses()]).then(([panesResult, processesResult]) => {
+			const errors = [];
+			if (panesResult.status === "rejected") errors.push(panesResult.reason instanceof Error ? panesResult.reason.message : String(panesResult.reason));
+			if (processesResult.status === "rejected") errors.push(processesResult.reason instanceof Error ? processesResult.reason.message : String(processesResult.reason));
+			snapshot = buildRuntimeCensus(panesResult.status === "fulfilled" ? panesResult.value : snapshot?.panes ?? [], processesResult.status === "fulfilled" ? processesResult.value : [...snapshot?.processesByPid.values() ?? []], now(), {
+				tmuxAvailable: panesResult.status === "fulfilled",
+				processAvailable: processesResult.status === "fulfilled",
+				stale: errors.length > 0,
+				error: errors.length > 0 ? errors.join("; ") : null
+			});
+			return snapshot;
+		}).finally(() => {
+			inFlight = null;
+		});
+		return inFlight;
+	};
+	return {
+		get(options) {
+			if (!options?.fresh && snapshot && now() - snapshot.sampledAt < ttlMs) return Promise.resolve(snapshot);
+			return refresh();
+		},
+		peek() {
+			return snapshot;
+		},
+		reset() {
+			snapshot = null;
+			inFlight = null;
+		}
+	};
+}
+function getRuntimeCensus(options) {
+	return runtimeCensusService.get(options);
+}
+function refreshRuntimeCensus() {
+	return runtimeCensusService.get({ fresh: true });
+}
+function getRuntimeCensusSnapshot() {
+	return runtimeCensusService.peek();
+}
+function panePidsForSession(census, sessionName) {
+	return (census.panesBySession.get(sessionName) ?? []).map((pane) => pane.panePid);
+}
+function descendantPidsForSession(census, sessionName) {
+	const descendants = /* @__PURE__ */ new Set();
+	for (const panePid of panePidsForSession(census, sessionName)) for (const pid of collectDescendantPids(panePid, census.processTree)) descendants.add(pid);
+	return descendants;
+}
+function runtimeCensusHasHarnessProcess(census, sessionName) {
+	if (!census.tmuxAvailable || !census.processAvailable) return true;
+	const panePids = panePidsForSession(census, sessionName);
+	if (panePids.length === 0) return false;
+	for (const panePid of panePids) for (const pid of collectDescendantPids(panePid, census.processTree)) {
+		const comm = census.processesByPid.get(pid)?.comm;
+		if (comm && !KEEPALIVE_FOREGROUND_COMMANDS.has(comm)) return true;
+	}
+	return false;
+}
+var execFileAsync, KEEPALIVE_FOREGROUND_COMMANDS, runtimeCensusService;
+var init_runtime_census = __esmMin((() => {
+	init_collector();
+	execFileAsync = promisify(execFile);
+	KEEPALIVE_FOREGROUND_COMMANDS = new Set([
+		"sleep",
+		"bash",
+		"sh",
+		"dash",
+		"zsh",
+		"ash"
+	]);
+	runtimeCensusService = createRuntimeCensusService({
+		listPanes: async () => {
+			const { listAllPaneRecords } = await import("./tmux-B6z7h_vZ.js");
+			return Effect.runPromise(listAllPaneRecords());
+		},
+		readProcesses: readRuntimeProcessTable
+	});
+}));
+//#endregion
 //#region ../../lib/agents/queries.ts
 function listRunningAgentsSync() {
-	const tmuxSessions = listSessionsSync();
-	const tmuxNames = new Set(tmuxSessions.map((s) => s.name));
+	const census = getRuntimeCensusSnapshot();
+	const tmuxNames = census ? census.sessionNames : new Set(listSessionsSync().map((session) => session.name));
+	const tmuxUnavailable = census?.tmuxAvailable === false;
 	return listOverdeckAgentStatesSync().map((state) => {
 		const normalizedId = normalizeAgentId(state.id);
 		return {
 			...state,
 			id: normalizedId,
-			tmuxActive: tmuxNames.has(normalizedId)
+			tmuxActive: tmuxUnavailable || tmuxNames.has(normalizedId)
 		};
 	});
 }
@@ -8192,23 +9190,24 @@ var listRunningAgents;
 var init_queries = __esmMin((() => {
 	init_agents();
 	init_tmux();
+	init_runtime_census();
 	init_paths();
 	init_agent_rollback_state();
 	init_agent_state_sync();
 	listRunningAgents = () => Effect.gen(function* () {
-		const tmuxSessions = yield* listSessions();
-		const tmuxNames = new Set(tmuxSessions.map((s) => s.name));
+		const runtimeCensus = yield* Effect.promise(() => getRuntimeCensus());
+		const tmuxNames = runtimeCensus.sessionNames;
 		return listOverdeckAgentStatesSync().map((state) => {
 			const normalizedId = normalizeAgentId(state.id);
 			return {
 				...state,
 				id: normalizedId,
-				tmuxActive: tmuxNames.has(normalizedId)
+				tmuxActive: !runtimeCensus.tmuxAvailable || tmuxNames.has(normalizedId)
 			};
 		});
 	});
 }));
 //#endregion
-export { stopAgent as $, init_pty_token as $n, init_ohmypi_fifo as $t, buildCompactRecoverySeed as A, getAgentStateFilePath as An, init_spawn_prep as At, appendActivity as B, recordAgentFailure as Bn, OHMYPI_AGENT_READY_TIMEOUT_SECONDS as Bt, init_slot_reconcile as C, clearAgentTroubled as Cn, probeTranscriptSince as Ct, detectCrashedAgents as D, getAgentDir as Dn, assertWorkspaceStackHealthyForSpawn as Dt, autoRecoverAgents as E, decideResumeGate as En, writeBridgeTokenSync as Et, isContextOverflowTail as F, isRole as Fn, providerDefaultHarnessSync as Ft, init_activity as G, saveAgentStateSync as Gn, getProviderAuthMode as Gt, getLatestSessionId as H, recordStartupSessionExit as Hn, getAgentRuntimeBaseCommand as Ht, init_messaging as I, markAgentRunning as In, resolveImplicitStaffing as It, init_ohmypi as J, setAgentYieldedSync as Jn, injectPiConversationMemory as Jt, saveSessionId as K, setAgentPaused as Kn, getRoleRuntimeBaseCommand as Kt, messageAgent as L, markAgentRunningState as Ln, resolveStaffing as Lt, resumeAgent as M, init_agent_state as Mn, transitionIssueToInProgress as Mt, init_context_overflow as N, isAgentPaused as Nn, transitionIssueToInReview as Nt, recoverAgent as O, getAgentResumeGateBlockReason as On, buildAgentLaunchConfig as Ot, isContextOverflowError as P, isAgentTroubled as Pn, init_staffing as Pt, init_termination as Q, readAgentHarnessModelRecordSync as Qn, piFifoPaths as Qt, init_operator_interventions as R, markAgentStoppedState as Rn, init_resolve_tier as Rt, init_tier_escalation as S, clearAgentPausedSync as Sn, init_transcript_landing as St, reconcileSlotState as T, clearYieldForResumeSync as Tn, init_bridge_token as Tt, getLatestSessionIdSync as U, resetAgentFailureCount as Un, getCodexLauncherFields as Ut, getActivity as V, recordAgentFailureSync as Vn, describeOhmypiSpawnFailure as Vt, getSessionId as W, saveAgentState as Wn, getOhmypiLauncherFields as Wt, spawnAgent as X, writeAgentStateJsonSync as Xn, waitForPromptReady as Xt, init_spawn as Y, wipeAgentStateDirs as Yn, roleAgentDefinitionPath as Yt, spawnRun as Z, init_agent_record_sync as Zn, init_pi_fifo as Zt, spawnTierSupervisor as _, writeChannelsBridgeMcpConfig as _n, init_codex_auth as _r, deliverAgentPermissionDecision as _t, listRunningAgentsSync as a, determineModel as an, normalizeAgentId as ar, getConcurrencyLimits as at, init_tier_feed as b, __testInternals as bn, parseOhmypiSessionCostResultSync as br, setAgentDeliveryMethod as bt, compactAtTierRunBoundary as c, getProviderTmuxFlags as cn, waitForReadySignal as cr, releaseSwarmSlot as ct, replayStandingAgent as d, getOpenAIAuthStatus as dn, init_runtime_state as dr, tryReserveSwarmSlot as dt, ohmypiFifoPaths as en, writePtyToken as er, stopAgentSync as et, shouldReplayCompactAtTierRunBoundary as f, init_openai_auth as fn, saveAgentRuntimeState as fr, workResumeSlotsAvailable as ft, shouldSupervise as g, dismissDevChannelsDialog as gn, checkCodexAuthStatus as gr, deliverAgentMessage as gt, loadPrdDraft as h, decideSupervisorForWorkAgent as hn, applyCodexAuthBurnFlag as hr, setCachedMemoryVerdict as ht, listRunningAgents as i, buildSpawnEnvForModel as in, isQualifiedAgentId as ir, emergencyBrake as it, init_resume as j, getAgentStateSync as jn, retrieveSpawnTimeMemoryContext as jt, restartAgent as k, getAgentState as kn, defaultRunWorkspace as kt, contextWindowForModel as l, init_provider_health as ln, getAgentRuntimeState as lr, resetPatrolDispatchBudget as lt, init_tier_supervisor as m, decideChannelsForWorkAgent as mn, init_agent_runtime as mr, init_memory_verdict_cache as mt, init_queries as n, init_claude_auth as nn, resolvePtySupervisorScriptPath as nr, countRunningSwarmSlotsForIssue as nt, warnOnBareNumericIssueIds as o, getProviderEnvForModel as on, resolveAgentTargetSync as or, init_concurrency as ot, deliverCommitForReview as p, buildDefaultResumeContinueMessage as pn, getAgentRuntimeSnapshot as pr, getCachedMemoryVerdict as pt, createOhmypiRuntimeSync as q, setAgentPausedSync as qn, init_runtime_command as qt, listAgentStates as r, buildCavemanExports as rn, clearReadySignal as rr, describeRunningAgents as rt, init_agents as s, getProviderExportsForModel as sn, waitForAgentIdle as sr, releaseAdvancingSlot as st, dropLegacyAgentStatesMissingRoleAsync as t, getClaudeAuthStatus as tn, init_pty_supervisor_locate as tr, countRunningAgents as tt, replayCrashedStandingAgent as u, validateProviderHealth as un, getAgentRuntimeStateSync as ur, tryReserveAdvancingSlot as ut, supervisorAgentId as v, GOVERNOR_SLOT_PAUSE_REASON_PREFIX as vn, paneShowsCodexAuthBurn as vr, deliverInitialPromptWithRetry as vt, listSlotAssignments as w, clearAgentTroubledSync as wn, BRIDGE_TOKEN_HEADER as wt, decideEscalation as x, clearAgentPaused as xn, captureTranscriptUserRecordSnapshot as xt, broadcastCommit as y, SESSION_EXITED_BEFORE_KICKOFF as yn, init_ohmypi_parser as yr, deliverResumeMessageWithTranscriptConfirmation as yt, operatorInterventionEvent as z, markAgentTroubled as zn, resolveTier as zt };
+export { appendActivity as $, isRole as $n, OHMYPI_AGENT_READY_TIMEOUT_SECONDS as $t, spawnTierSupervisor as A, buildDefaultResumeContinueMessage as An, saveAgentRuntimeState as Ar, deliverAgentPermissionDecision as At, detectCrashedAgents as B, clearAgentPausedSync as Bn, assertWorkspaceStackHealthyForSpawn as Bt, replayCrashedStandingAgent as C, getProviderEnvForModel as Cn, normalizeAgentId as Cr, tryReserveAdvancingSlot as Ct, init_tier_supervisor as D, validateProviderHealth as Dn, getAgentRuntimeState as Dr, init_memory_verdict_cache as Dt, deliverCommitForReview as E, init_provider_health as En, waitForReadySignal as Er, getCachedMemoryVerdict as Et, init_tier_escalation as F, writeChannelsBridgeMcpConfig as Fn, init_codex_auth as Fr, init_transcript_landing as Ft, resumeAgent as G, getAgentDir as Gn, transitionIssueToInProgress as Gt, restartAgent as H, clearAgentTroubledSync as Hn, defaultRunWorkspace as Ht, init_slot_reconcile as I, GOVERNOR_SLOT_PAUSE_REASON_PREFIX as In, paneShowsCodexAuthBurn as Ir, probeTranscriptSince as It, isContextOverflowTail as J, getAgentStateFilePath as Jn, providerDefaultHarnessSync as Jt, init_context_overflow as K, getAgentResumeGateBlockReason as Kn, transitionIssueToInReview as Kt, listSlotAssignments as L, SESSION_EXITED_BEFORE_KICKOFF as Ln, init_ohmypi_parser as Lr, BRIDGE_TOKEN_HEADER as Lt, broadcastCommit as M, decideChannelsForWorkAgent as Mn, init_agent_runtime as Mr, deliverResumeMessageWithTranscriptConfirmation as Mt, init_tier_feed as N, decideSupervisorForWorkAgent as Nn, applyCodexAuthBurnFlag as Nr, setAgentDeliveryMethod as Nt, loadPrdDraft as O, getOpenAIAuthStatus as On, getAgentRuntimeStateSync as Or, setCachedMemoryVerdict as Ot, decideEscalation as P, dismissDevChannelsDialog as Pn, checkCodexAuthStatus as Pr, captureTranscriptUserRecordSnapshot as Pt, operatorInterventionEvent as Q, isAgentTroubled as Qn, resolveTier as Qt, reconcileSlotState as R, __testInternals as Rn, parseOhmypiSessionCostResultSync as Rr, init_bridge_token as Rt, contextWindowForModel as S, determineModel as Sn, isQualifiedAgentId as Sr, resetPatrolDispatchBudget as St, shouldReplayCompactAtTierRunBoundary as T, getProviderTmuxFlags as Tn, waitForAgentIdle as Tr, workResumeSlotsAvailable as Tt, buildCompactRecoverySeed as U, clearYieldForResumeSync as Un, init_spawn_prep as Ut, recoverAgent as V, clearAgentTroubled as Vn, buildAgentLaunchConfig as Vt, init_resume as W, decideResumeGate as Wn, retrieveSpawnTimeMemoryContext as Wt, messageAgent as X, init_agent_state as Xn, resolveStaffing as Xt, init_messaging as Y, getAgentStateSync as Yn, resolveImplicitStaffing as Yt, init_operator_interventions as Z, isAgentPaused as Zn, init_resolve_tier as Zt, init_linux as _, materializeAcpContextFile as _n, init_pty_token as _r, emergencyBrake as _t, listRunningAgentsSync as a, getProviderAuthMode as an, recordAgentFailureSync as ar, saveSessionId as at, init_agents as b, buildCavemanExports as bn, resolvePtySupervisorScriptPath as br, releaseAdvancingSlot as bt, getRuntimeCensus as c, injectPiConversationMemory as cn, saveAgentState as cr, init_spawn as ct, panePidsForSession as d, waitForPromptReady as dn, setAgentPausedSync as dr, init_termination as dt, describeOhmypiSpawnFailure as en, markAgentRunning as er, getActivity as et, refreshRuntimeCensus as f, init_pi_fifo as fn, setAgentYieldedSync as fr, stopAgent as ft, LINUX_MEMORY_PRESSURE_DEFAULTS as g, init_context as gn, readAgentHarnessModelRecordSync as gr, describeRunningAgents as gt, init_collector as h, ohmypiFifoPaths as hn, init_agent_record_sync as hr, countRunningSwarmSlotsForIssue as ht, listRunningAgents as i, getOhmypiLauncherFields as in, recordAgentFailure as ir, init_activity as it, supervisorAgentId as j, buildResumeContinueMessage as jn, getAgentRuntimeSnapshot as jr, deliverInitialPromptWithRetry as jt, shouldSupervise as k, init_openai_auth as kn, init_runtime_state as kr, deliverAgentMessage as kt, getRuntimeCensusSnapshot as l, roleAgentDefinitionPath as ln, saveAgentStateSync as lr, spawnAgent as lt, createHostHealthCollector as m, init_ohmypi_fifo as mn, writeAgentStateJsonSync as mr, countRunningAgents as mt, init_queries as n, getAgentRuntimeBaseCommand as nn, markAgentStoppedState as nr, getLatestSessionIdSync as nt, warnOnBareNumericIssueIds as o, getRoleRuntimeBaseCommand as on, recordStartupSessionExit as or, createOhmypiRuntimeSync as ot, runtimeCensusHasHarnessProcess as p, piFifoPaths as pn, wipeAgentStateDirs as pr, stopAgentSync as pt, isContextOverflowError as q, getAgentState as qn, init_staffing as qt, listAgentStates as r, getCodexLauncherFields as rn, markAgentTroubled as rr, getSessionId as rt, descendantPidsForSession as s, init_runtime_command as sn, resetAgentFailureCount as sr, init_ohmypi as st, dropLegacyAgentStatesMissingRoleAsync as t, getAcpLauncherFields as tn, markAgentRunningState as tr, getLatestSessionId as tt, init_runtime_census as u, waitForAcpHostReady as un, setAgentPaused as ur, spawnRun as ut, DARWIN_MEMORY_PRESSURE_DEFAULTS as v, getClaudeAuthStatus as vn, writePtyToken as vr, getConcurrencyLimits as vt, replayStandingAgent as w, getProviderExportsForModel as wn, resolveAgentTargetSync as wr, tryReserveSwarmSlot as wt, compactAtTierRunBoundary as x, buildSpawnEnvForModel as xn, clearReadySignal as xr, releaseSwarmSlot as xt, init_darwin as y, init_claude_auth as yn, init_pty_supervisor_locate as yr, init_concurrency as yt, autoRecoverAgents as z, clearAgentPaused as zn, writeBridgeTokenSync as zt };
 
-//# sourceMappingURL=queries-ZABd5aXP.js.map
+//# sourceMappingURL=queries-CjNIf-Ub.js.map