@overdeck/desktop 0.50.0 → 0.50.3

package/server/{agent-state-FABw8neJ.js → agent-state-Ci6PhjOE.js}

@@ -1,57 +1,58 @@
 import { n as __esmMin, o as __toESM } from "./rolldown-runtime-DNCzzKnI.js";
-import { $t as findProjectByPathSync, Ai as encodeClaudeProjectDir, Br as OPENROUTER_MODEL_CONTEXT_WINDOWS, C as DEFAULT_TIERED_EXECUTION_CONFIG, Dr as init_roles, Dt as queueAutoCommit, E as init_tier_table, Et as pushPendingStateCommits, Gr as init_percent, Gt as shouldCommitLegacyWorkspaceArtifacts, Hi as packageRoot, Ht as init_state_read_home, Ir as resolveModelIdSync, Kn as extractPrefixSync, Lr as CLIPROXY_GPT56_CONTEXT_WINDOW, Nr as hasModelCapabilitySync, O as resolveTieredExecutionEnabled, On as resolveProjectFromIssueSync, Or as resolveModel, Ot as reconcileStatePlaneDrift, Pr as init_model_capabilities, Qr as FsError, Ri as getOverdeckHome, Rr as CLIPROXY_GPT56_LONG_CONTEXT_WINDOW, Tt as init_auto_commit, Ui as resolveOhmypiExtensionPath, Ur as fmix32, Vi as isDevMode, Wi as sessionFilePath, Wr as fnv1a32, Wt as resolveStateReadHomeSync, Xn as resolveBareNumericIdSync, Xr as ClaudeCredentialParseError, Y as init_record, _r as setupCredentialFileAuthSync, an as getProjectSwarmHotspots, at as writeAgentHarnessModelSync, br as init_openai_compatible_proxy, cr as clearCredentialFileAuthSync, d as isTldrEnabledSync, dr as getProviderEnvSync, er as require_dist, et as readIssueRecordForWorkspaceSync, fn as init_projects, fr as getProviderForModelSync, gr as resolveKimiCodeModelAlias, jr as getModelCapabilitySync, k as resolveTieredExecutionEnabledForIssue, ki as claudeSessionTranscriptExists, li as init_errors, lr as getBuiltInDefaultHarness, oi as TmuxError, on as getProjectSync, p as loadConfigSync, pr as init_providers, qn as init_issue_id, rn as getIssuePrefix, rt as resolveProjectForIssue, t as init_config_yaml, tt as readIssueRecordSync, u as isClaudeCodeChannelsMcpEnabled, ui as AGENTS_DIR, vr as ensureOpenAICompatibleProxyRunning, w as TIERED_EXECUTION_DIFFICULTIES, wt as flushAutoCommits, zi as init_paths, zr as GPT56_LONG_CONTEXT_VARIANTS } from "./config-yaml-D60AnTIu.js";
-import { h as loadConfigSync$1, p as init_config } from "./config-NxI9Yl2f.js";
-import { l as init_activity_logger, o as emitActivityEntrySync, s as emitActivityTtsSync } from "./activity-logger-SlTXYCVf.js";
-import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-CJRi_5Wu.js";
-import { n as init_fs_lock, s as withRecordFsLock } from "./fs-lock-DQ_gUxfq.js";
-import { c as withStateGitLock, i as init_record_update, n as clearRecordPipelineClosedOut, s as init_state_git_lock } from "./record-update-BPqpBu3O.js";
-import { $ as init_pane_choice_menu, B as sendKeys, C as init_tmux, D as killSessionSync, E as killSession, G as setOption, H as sendRawKeystroke, P as listSessionsSync, Q as buildChoiceKeystrokes, T as isPaneDead, U as sessionExists, W as sessionExistsSync, a as capturePaneText, c as createSessionSync, ct as BLANKED_PROVIDER_ENV, dt as init_child_env, et as paneChoiceMenuSignature, i as capturePaneSync, k as listPaneValues, nt as parsePaneChoiceMenu, p as exactPaneTarget, r as capturePane, s as createSession, v as getManagedTmuxSocketName, z as sendEscapeKeyAsync } from "./tmux-wnT_hg-s.js";
-import { a as getWorkspaceForIssue, o as init_resolver } from "./resolver-C2QKOf09.js";
-import { a as init_event_store, i as initEventStore } from "./event-store-DTns2XZP.js";
-import { o as OHMYPI_BEHAVIOR, s as getHarnessBehavior } from "./src-CdwN6WY6.js";
-import { a as readVerdictPreservationStatus, d as getOverdeckAgentStateSync, f as init_agent_state_sync, i as init_work_start_verdicts, l as resetWorkStartPipelineVerdicts, m as saveOverdeckAgentStateSync, o as refreshWorkStartReviewedAnchor, p as listOverdeckAgentStatesSync, r as registerPipelineTelemetryAgentReader, t as init_pipeline_agent_reader } from "./pipeline-agent-reader-CeWhQzXC.js";
-import { a as countAgentsByStatus, c as init_agents$2, g as logAgentLifecycleSync, h as init_persistent_logger } from "./agents-DzpQidT8.js";
-import { n as ensureSessionContextBriefingFile, r as init_briefing_freshness } from "./briefing-freshness-ENa_hW_V.js";
-import { a as getFlywheelActiveRunIdSync, c as init_control_settings, j as parseOhmypiSessionSync, k as init_ohmypi_parser } from "./control-settings-Db0uXgVM.js";
-import { _ as init_tier_metrics, g as estimateFeedDeliveryTokens, v as recordTierFeedDelivery } from "./cost-sync-DfmvLT9L.js";
-import { t as init_behavior } from "./behavior-DCg8CIWC.js";
-import { b as init_cliproxy, c as bridgeGeminiAuthToCliproxy, h as getCliproxyClientEnv, l as decodeJwtPayload$1, p as getCliproxyAuthDir, s as bridgeCodexAuthToCliproxySync, v as getCliproxyLogPath } from "./cliproxy-DXDQcR3I.js";
-import { a as init_feature_registry_population, i as resetPostMergeState, n as init_post_merge_state, o as recordFeatureRegistryLifecycle } from "./post-merge-state-DFaf7OI1.js";
-import { i as ensureInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-BeIWG_kT.js";
-import { A as init_conversations, B as reactivateConversationForSpawn, C as getConversationByName, b as createConversation, z as normalizeHarness } from "./conversations-nS6QgYpD.js";
-import { n as readActiveDashboardBundleSync, t as init_active_dashboard_bundle } from "./active-dashboard-bundle-CCqpFWiz.js";
-import { a as readCavemanVariant, n as init_workspace } from "./workspace-BAhMgMaO.js";
-import { C as generateLauncherScriptSync, D as normalizeModelOverrideSync, E as init_model_validation, O as requireModelOverrideSync, S as normalizeFlywheelRunId, _ as init_tmux_dedup, b as init_provenance, f as completeKeyedSubmit, i as init_auto_spawn_consent, k as shellQuoteModelIdSync, s as withAutoSpawnConsentClaim, w as init_launcher_generator, x as isOperatorStartedBy, y as sendKeysDedup } from "./auto-spawn-consent-BesWchEi.js";
-import { a as init_claude_permissions, r as getClaudePermissionFlagsStringSync } from "./claude-permissions-DLrb9ovz.js";
-import { D as init_layers, F as resolveWorkspaceContextFile, L as workspaceContextFile, b as renderForHarness, d as renderProjectLayer, i as workspaceContextWithoutProjectLayer, l as init_render, r as init_assemble, u as renderGlobalLayer, y as init_harness } from "./assemble-B_JgnCbG.js";
-import { a as extractThreadIdFromRollout, c as initCodexHome, l as init_codex, o as findLatestRollout } from "./codex-DYyZL8JD.js";
-import { i as prepareHarnessLaunch, r as init_harness_binary } from "./harness-binary-DChiynaB.js";
-import { n as createTrackerFromConfig, r as init_factory, t as createTracker } from "./factory-CWVKwKFE.js";
-import { c as init_stack_health, o as getWorkspaceStackHealth } from "./stack-health-BKfNaqMm.js";
+import { $r as FsError, $t as findProjectByPathSync, Bi as isDevMode, Br as OPENROUTER_MODEL_CONTEXT_WINDOWS, C as DEFAULT_TIERED_EXECUTION_CONFIG, Dt as queueAutoCommit, E as init_tier_table, Et as pushPendingStateCommits, Gr as fnv1a32, Gt as shouldCommitLegacyWorkspaceArtifacts, Hi as resolveOhmypiExtensionPath, Ht as init_state_read_home, Ir as resolveModelIdSync, Kn as extractPrefixSync, Kr as init_percent, Li as getOverdeckHome, Lr as CLIPROXY_GPT56_CONTEXT_WINDOW, Nr as hasModelCapabilitySync, O as resolveTieredExecutionEnabled, Oi as claudeSessionTranscriptExists, On as resolveProjectFromIssueSync, Or as init_roles, Ot as reconcileStatePlaneDrift, Pr as init_model_capabilities, Ri as init_paths, Rr as CLIPROXY_GPT56_LONG_CONTEXT_WINDOW, Ti as SYNC_SOURCES, Tt as init_auto_commit, Ui as sessionFilePath, Vi as packageRoot, Wr as fmix32, Wt as resolveStateReadHomeSync, Xn as resolveBareNumericIdSync, Y as init_record, Zr as ClaudeCredentialParseError, an as getProjectSwarmHotspots, at as writeAgentHarnessModelSync, cr as clearCredentialFileAuthSync, d as isTldrEnabledSync, di as AGENTS_DIR, dr as getProviderEnvSync, er as require_dist, et as readIssueRecordForWorkspaceSync, fn as init_projects, fr as getProviderForModelSync, gr as resolveKimiCodeModelAlias, jr as getModelCapabilitySync, k as resolveTieredExecutionEnabledForIssue, ki as encodeClaudeProjectDir, kr as resolveModel, lr as getBuiltInDefaultHarness, on as getProjectSync, p as loadConfigSync, pr as init_providers, qn as init_issue_id, rn as getIssuePrefix, rt as resolveProjectForIssue, si as TmuxError, t as init_config_yaml, tt as readIssueRecordSync, u as isClaudeCodeChannelsMcpEnabled, ui as init_errors, vr as setupCredentialFileAuthSync, w as TIERED_EXECUTION_DIFFICULTIES, wt as flushAutoCommits, xr as init_openai_compatible_proxy, yr as ensureOpenAICompatibleProxyRunning, zr as GPT56_LONG_CONTEXT_VARIANTS } from "./config-yaml-Dce9VUd6.js";
+import { h as loadConfigSync$1, p as init_config } from "./config-BUjU7GZQ.js";
+import { l as init_activity_logger, o as emitActivityEntrySync, s as emitActivityTtsSync } from "./activity-logger-DNYDzAOU.js";
+import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-B05o-e2g.js";
+import { n as init_fs_lock, r as isPidDead, s as withRecordFsLock } from "./fs-lock-VCGoXZI5.js";
+import { c as withStateGitLock, i as init_record_update, n as clearRecordPipelineClosedOut, s as init_state_git_lock } from "./record-update-T3PMrwE-.js";
+import { $ as init_pane_choice_menu, B as sendKeys, C as init_tmux, D as killSessionSync, E as killSession, G as setOption, H as sendRawKeystroke, P as listSessionsSync, Q as buildChoiceKeystrokes, T as isPaneDead, U as sessionExists, W as sessionExistsSync, a as capturePaneText, c as createSessionSync, ct as BLANKED_PROVIDER_ENV, dt as init_child_env, et as paneChoiceMenuSignature, i as capturePaneSync, k as listPaneValues, nt as parsePaneChoiceMenu, p as exactPaneTarget, r as capturePane, s as createSession, v as getManagedTmuxSocketName, z as sendEscapeKeyAsync } from "./tmux-l-yvNWhg.js";
+import { a as getWorkspaceForIssue, o as init_resolver } from "./resolver-ChLZFIjB.js";
+import { a as init_event_store, i as initEventStore } from "./event-store-BYOh686E.js";
+import { c as getRuntimeBehavior, o as OHMYPI_BEHAVIOR, s as getHarnessBehavior } from "./src-tnFSfiXX.js";
+import { a as readVerdictPreservationStatus, d as getOverdeckAgentStateSync, f as init_agent_state_sync, i as init_work_start_verdicts, l as resetWorkStartPipelineVerdicts, m as saveOverdeckAgentStateSync, o as refreshWorkStartReviewedAnchor, p as listOverdeckAgentStatesSync, r as registerPipelineTelemetryAgentReader, t as init_pipeline_agent_reader } from "./pipeline-agent-reader-CHugmNSx.js";
+import { a as countAgentsByStatus, c as init_agents$2, g as logAgentLifecycleSync, h as init_persistent_logger } from "./agents-CkngXhQr.js";
+import { n as ensureSessionContextBriefingFile, r as init_briefing_freshness } from "./briefing-freshness-CEoe3yWS.js";
+import { a as getFlywheelActiveRunIdSync, c as init_control_settings, j as parseOhmypiSessionSync, k as init_ohmypi_parser } from "./control-settings-BkaVFRdm.js";
+import { _ as init_tier_metrics, g as estimateFeedDeliveryTokens, v as recordTierFeedDelivery } from "./cost-sync-EFEkMYWz.js";
+import { t as init_behavior } from "./behavior-Bg3yC8jC.js";
+import { b as init_cliproxy, c as bridgeGeminiAuthToCliproxy, h as getCliproxyClientEnv, l as decodeJwtPayload$1, p as getCliproxyAuthDir, s as bridgeCodexAuthToCliproxySync, v as getCliproxyLogPath } from "./cliproxy-QTm2vdgx.js";
+import { a as init_feature_registry_population, i as resetPostMergeState, n as init_post_merge_state, o as recordFeatureRegistryLifecycle } from "./post-merge-state-DGlkiVIO.js";
+import { i as ensureInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-Ci0LxMIq.js";
+import { A as init_conversations, B as reactivateConversationForSpawn, C as getConversationByName, G as setConversationClaudeSessionId, b as createConversation, z as normalizeHarness } from "./conversations-CPXMv_JQ.js";
+import { n as readActiveDashboardBundleSync, t as init_active_dashboard_bundle } from "./active-dashboard-bundle-C-Ars7eG.js";
+import { a as readCavemanVariant, n as init_workspace } from "./workspace-BWYfzfPV.js";
+import { A as init_model_validation, C as generateLauncherScriptSync, D as getClaudeCodeLaunchModelSync, M as requireModelOverrideSync, N as shellQuoteModelIdSync, O as init_kimi_claude_routing, S as normalizeFlywheelRunId, _ as init_tmux_dedup, b as init_provenance, f as completeKeyedSubmit, i as init_auto_spawn_consent, j as normalizeModelOverrideSync, s as withAutoSpawnConsentClaim, w as init_launcher_generator, x as isOperatorStartedBy, y as sendKeysDedup } from "./auto-spawn-consent-CJeQM5e0.js";
+import { a as init_claude_permissions, r as getClaudePermissionFlagsStringSync } from "./claude-permissions-DX5BSnMH.js";
+import { _ as tmuxKillSession, a as extractThreadIdFromRollout, c as initCodexHome, g as tmuxCreateSession, h as init_tmux_cli, l as init_codex, o as findLatestRollout, v as tmuxSessionExists } from "./codex-pffr8qaN.js";
+import { i as prepareHarnessLaunch, r as init_harness_binary } from "./harness-binary-DnRGvN6T.js";
+import { a as resolveMuseSessionPath, i as museSessionId, o as resolveMuseSessionPathSync, r as museDataHome, t as init_muse_session } from "./muse-session-CrSRuauJ.js";
+import { n as createTrackerFromConfig, r as init_factory, t as createTracker } from "./factory-BC18rvHD.js";
+import { c as init_stack_health, o as getWorkspaceStackHealth } from "./stack-health-Y8O3UuPe.js";
 import { i as readReviewStatusMap, n as init_review_status_source, r as isRoleTerminal, s as resolveCanonicalReviewStatus } from "./review-status-source-Jq0BXmn3.js";
-import { N as getProjectPanPaths, P as init_paths$1, h as readWorkspacePlanSync, s as init_io } from "./io-BCtZoXHo.js";
-import { a as getDispatchableItems, c as init_dag, o as groupItemsByWave, r as createActiveSlice } from "./dag-o-dUpw1L.js";
-import { c as generateFixedPointPromptSync, f as initHookSync, n as checkHookSync, p as init_hooks } from "./hooks-DJR1yR9w.js";
-import { a as init_git_utils, l as renderWorkspaceGitShowPromise } from "./git-utils-BdHk8y7g.js";
-import { n as init_workspace_anchor_drift, t as evaluateWorkspaceAnchorDrift } from "./workspace-anchor-drift-B_3kyyxJ.js";
-import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-BplBEbwn.js";
-import { a as loadCloisterConfigSync, r as init_config$1 } from "./config-_qaa1UXH.js";
+import { N as getProjectPanPaths, P as init_paths$1, h as readWorkspacePlanSync, s as init_io } from "./io-Cm4Sf_6P.js";
+import { a as getDispatchableItems, c as init_dag, o as groupItemsByWave, r as createActiveSlice } from "./dag-Drz6Nrnf.js";
+import { c as generateFixedPointPromptSync, f as initHookSync, n as checkHookSync, p as init_hooks } from "./hooks-lPAsUc20.js";
+import { a as init_git_utils, l as renderWorkspaceGitShowPromise } from "./git-utils-D96xW28f.js";
+import { n as init_workspace_anchor_drift, t as evaluateWorkspaceAnchorDrift } from "./workspace-anchor-drift-RJcMD1EV.js";
+import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-CzTFVZ5l.js";
+import { a as loadCloisterConfigSync, r as init_config$1 } from "./config-B-MLcKSo.js";
 import { t as init_reap_terminal_sessions } from "./reap-terminal-sessions-BaDSNR-k.js";
-import { a as init_state_home, c as isStateMigrated } from "./state-home-DhsMqg8W.js";
-import { n as provisionClaudeHooks, t as init_claude_hooks_provision } from "./claude-hooks-provision-fRofvhTN.js";
-import { d as resolveWorkspaceRepoRootsSync, i as init_project_repos } from "./project-repos-CsfvLtmr.js";
-import { a as init_lifecycle_io, t as appendContinueSessionEntryForIssue } from "./lifecycle-io-D7N0vQNj.js";
-import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-tfAOWgng.js";
-import { r as init_swarm_readiness, t as analyzeSwarmReadiness } from "./swarm-readiness-LF8ZF_hc.js";
+import { a as init_state_home, c as isStateMigrated } from "./state-home-CWu1dx9L.js";
+import { n as provisionClaudeHooks, t as init_claude_hooks_provision } from "./claude-hooks-provision-DWrqkc3x.js";
+import { d as resolveWorkspaceRepoRootsSync, i as init_project_repos } from "./project-repos-J6jc42uD.js";
+import { n as parseKimiSessionSync, t as init_kimi_parser } from "./kimi-parser-5VpMzIDq.js";
+import { a as init_lifecycle_io, t as appendContinueSessionEntryForIssue } from "./lifecycle-io-CW__VX8s.js";
+import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-Qq_kEwYh.js";
+import { r as init_swarm_readiness, t as analyzeSwarmReadiness } from "./swarm-readiness-BkVvnCdr.js";
 import { createRequire } from "node:module";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { Data, Duration, Effect, FileSystem } from "effect";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, 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 { cpus as cpus$1, hostname, loadavg as loadavg$1, platform as platform$1, totalmem as totalmem$1 } from "node:os";
+import { cpus as cpus$1, homedir as homedir$1, hostname, 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, fsyncSync, 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, lstat, mkdir, readFile, readdir, readlink, realpath, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import { chmod, lstat, mkdir, readFile, readdir, readlink, realpath, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
 import { createHash, randomUUID } from "crypto";
 import { mkdir as mkdir$1, open as open$1, readFile as readFile$1, readdir as readdir$1, rename as rename$1, rm as rm$1, stat as stat$1, unlink as unlink$1, writeFile as writeFile$1 } from "fs/promises";
 import { ChildProcess } from "effect/unstable/process";
@@ -65,6 +66,7 @@ import { fileURLToPath } from "node:url";
 import { request } from "node:http";
 import { ChildProcessSpawner as ChildProcessSpawner$1 } from "effect/unstable/process/ChildProcessSpawner";
 import { layer } from "@effect/platform-node/NodeServices";
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region ../../lib/agent-runtime-mirror.ts
 /**
 * PAN-800 — in-process mirror of AgentStateService's canonical ref.
@@ -1416,6 +1418,7 @@ var init_provider_health = __esmMin((() => {
 async function getProviderEnvForModel(model, harness) {
 	const provider = getProviderForModelSync(model);
 	if (provider.name === "anthropic") return {};
+	if (provider.name === "meta" && harness === "muse") return {};
 	if (provider.name === "kimi" && harness === "kimi-code") return getProviderEnvSync(provider, "", harness);
 	const { config } = loadConfigSync();
 	if (provider.name === "openrouter") {
@@ -1444,7 +1447,7 @@ async function getProviderEnvForModel(model, harness) {
 }
 function getClaudeCodeContextPolicyForModel(model) {
 	const provider = getProviderForModelSync(model);
-	if (provider.name === "anthropic") return {};
+	if (provider.name === "anthropic") return hasModelCapabilitySync(model) ? { autoCompactWindow: getModelCapabilitySync(resolveModelIdSync(model)).contextWindow } : {};
 	const resolvedModel = resolveModelIdSync(model);
 	if (provider.name === "openrouter") {
 		const openrouterWindow = OPENROUTER_MODEL_CONTEXT_WINDOWS[resolvedModel];
@@ -1464,11 +1467,10 @@ function getClaudeCodeContextPolicyForModel(model) {
 	};
 	if (!hasModelCapabilitySync(resolvedModel)) return {};
 	const contextWindow = getModelCapabilitySync(resolvedModel).contextWindow;
-	if (KIMI_K3_MODELS.has(resolvedModel)) return {
+	return {
 		autoCompactWindow: contextWindow,
 		maxContextTokens: contextWindow
 	};
-	return { autoCompactWindow: contextWindow };
 }
 async function getProviderExportsForModel(model, harness) {
 	const envVars = await getProviderEnvForModel(model, harness);
@@ -1543,7 +1545,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, GPT_56_MODELS, GPT_56_LONG_MODELS, KIMI_K3_MODELS, WORK_AGENT_BROKEN_MODELS;
+var CLI_PROXY_MODEL_ALIASES, PROVIDER_ENV_KEYS, GPT_56_MODELS, GPT_56_LONG_MODELS, WORK_AGENT_BROKEN_MODELS;
 var init_provider_env = __esmMin((() => {
 	init_config_yaml();
 	init_workspace();
@@ -1583,12 +1585,12 @@ var init_provider_env = __esmMin((() => {
 		"QUANTUMLLAMA_API_KEY"
 	];
 	GPT_56_MODELS = new Set([
+		"gpt-6-astra",
 		"gpt-5.6-sol",
 		"gpt-5.6-terra",
 		"gpt-5.6-luna"
 	]);
 	GPT_56_LONG_MODELS = new Set(Object.keys(GPT56_LONG_CONTEXT_VARIANTS));
-	KIMI_K3_MODELS = new Set(["k3", "k3[1m]"]);
 	WORK_AGENT_BROKEN_MODELS = /* @__PURE__ */ new Set([]);
 }));
 //#endregion
@@ -1697,34 +1699,406 @@ var init_claude_auth = __esmMin((() => {
 	});
 }));
 //#endregion
-//#region ../../lib/acp/context.ts
-function materializeAcpContextFile(agentDir, workspace) {
-	const sections = [renderGlobalLayer("acp", isDevMode())];
+//#region ../../lib/context-layers/assemble.ts
+function removeMarkedProjectLayer(content) {
+	const start = content.indexOf(PROJECT_LAYER_START);
+	if (start < 0) return null;
+	const markerEnd = content.indexOf("-->", start + 33);
+	if (markerEnd < 0) return null;
+	const marker = content.slice(start, markerEnd + 3);
+	const lengthMatch = /\schars=(\d+)\s-->$/.exec(marker);
+	if (!lengthMatch) return null;
+	const projectEnd = markerEnd + 4 + Number(lengthMatch[1]);
+	if (content[markerEnd + 3] !== "\n") return null;
+	if (content.slice(projectEnd, projectEnd + 1 + 35) !== `\n<!-- overdeck:project-layer:end -->`) return null;
+	const end = projectEnd + 1;
+	let before = content.slice(0, start);
+	let after = content.slice(end + 35);
+	if (before.endsWith(SECTION_SEPARATOR$1) && after.startsWith(SECTION_SEPARATOR$1)) before = before.slice(0, -7);
+	else if (before.endsWith(SECTION_SEPARATOR$1)) before = before.slice(0, -7);
+	else if (after.startsWith(SECTION_SEPARATOR$1)) after = after.slice(7);
+	return `${before}${after}`.trim();
+}
+/**
+* Remove a project layer embedded by pre-PAN-3779 workspace assembly.
+*
+* New bundles contain no project layer. Legacy marked bundles can be stripped
+* exactly. Ambiguous legacy bundles must be reviewed before launch; silently
+* truncating them would lose memory or status alongside stale project text.
+*/
+function workspaceContextWithoutProjectLayer(content) {
+	if (content.includes("<!-- overdeck:workspace-context:v2 harness-neutral -->")) return content.trim();
+	const marked = removeMarkedProjectLayer(content);
+	if (marked !== null) return marked;
+	if (content.includes("<!-- overdeck:project-layer:start") || content.includes(SECTION_SEPARATOR$1)) throw new Error("Legacy workspace context has no valid project boundary. Review it with pan context edit --layer workspace and preserve its memory/status before rebuilding the workspace context.");
+	return content.trim();
+}
+var SECTION_SEPARATOR$1, PROJECT_LAYER_START;
+var init_assemble = __esmMin((() => {
+	SECTION_SEPARATOR$1 = "\n\n---\n\n";
+	PROJECT_LAYER_START = "<!-- overdeck:project-layer:start";
+}));
+//#endregion
+//#region ../../lib/context-layers/harness.ts
+/**
+* Render a canonical layer body for one harness, or a union of harnesses
+* sharing one physical target file (e.g. AGENTS.md, read natively by both
+* ohmypi and kimi-code — PAN-1837 review fix: rendering AGENTS.md for
+* 'ohmypi' alone stripped every span authored only under
+* {{#harness:kimi-code}}, so Kimi-specific context never survived `pan
+* sync`). A span is kept when it is covered by no harness marker (always-on)
+* or by a marker naming any of the target harnesses; every marker is
+* stripped from the output. Runs of 3+ blank lines left by removed spans
+* collapse to a single blank line so output stays tidy.
+*/
+function renderForHarness(content, harness) {
+	const targets = new Set((Array.isArray(harness) ? harness : [harness]).map((h) => HARNESS_MARKERS[h]));
+	const openCounts = /* @__PURE__ */ new Map();
+	let out = "";
+	let lastIndex = 0;
+	const emit = (text) => {
+		let covered = false;
+		let anyOpen = false;
+		for (const [name, count] of openCounts) if (count > 0) {
+			anyOpen = true;
+			if (targets.has(name)) covered = true;
+		}
+		if (!anyOpen || covered) out += text;
+	};
+	MARKER_RE.lastIndex = 0;
+	let m;
+	while ((m = MARKER_RE.exec(content)) !== null) {
+		emit(content.slice(lastIndex, m.index));
+		const [, kind, name] = m;
+		const delta = kind === "#" ? 1 : -1;
+		openCounts.set(name, (openCounts.get(name) ?? 0) + delta);
+		lastIndex = m.index + m[0].length;
+	}
+	emit(content.slice(lastIndex));
+	return out.replace(/\n{3,}/g, "\n\n");
+}
+/**
+* Lint a context-layer template for malformed harness blocks.
+*
+* Errors: an unclosed `{{#harness:x}}` or a stray `{{/harness:x}}` with no
+* matching open. Warnings: a marker naming a harness Overdeck has no
+* adapter for (allowed for forward compatibility, surfaced so typos —
+* `{{#harness:clade}}` — do not pass silently).
+*/
+function validateTemplate(content) {
+	const issues = [];
+	const openCounts = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	MARKER_RE.lastIndex = 0;
+	let m;
+	while ((m = MARKER_RE.exec(content)) !== null) {
+		const [, kind, name] = m;
+		seen.add(name);
+		if (kind === "#") openCounts.set(name, (openCounts.get(name) ?? 0) + 1);
+		else {
+			const next = (openCounts.get(name) ?? 0) - 1;
+			openCounts.set(name, next);
+			if (next < 0) issues.push({
+				severity: "error",
+				message: `stray closing marker {{/harness:${name}}} with no matching {{#harness:${name}}}`
+			});
+		}
+	}
+	for (const [name, count] of openCounts) if (count > 0) issues.push({
+		severity: "error",
+		message: `unclosed block: {{#harness:${name}}} opened ${count} time(s) without a matching {{/harness:${name}}}`
+	});
+	for (const name of seen) if (!KNOWN_HARNESS_MARKERS.has(name)) issues.push({
+		severity: "warning",
+		message: `unknown harness "${name}" — Overdeck ships adapters for: ${[...KNOWN_HARNESS_MARKERS].join(", ")}`
+	});
+	return {
+		ok: !issues.some((i) => i.severity === "error"),
+		issues
+	};
+}
+var HARNESS_MARKERS, KNOWN_HARNESS_MARKERS, MARKER_RE;
+var init_harness = __esmMin((() => {
+	HARNESS_MARKERS = {
+		"claude-code": "claude",
+		ohmypi: "ohmypi",
+		codex: "codex",
+		acp: "acp",
+		opencode: "opencode",
+		"kimi-code": "kimi-code",
+		muse: "muse"
+	};
+	KNOWN_HARNESS_MARKERS = new Set([
+		"claude",
+		"pi",
+		"ohmypi",
+		"codex",
+		"acp",
+		"kimi-code",
+		"opencode",
+		"muse"
+	]);
+	MARKER_RE = /\{\{([#/])harness:([a-zA-Z0-9_-]+)\}\}/g;
+}));
+//#endregion
+//#region ../../lib/context-layers/layers.ts
+/**
+* Context layer model (PAN-1201).
+*
+* Three layers of context compose at sync time:
+*
+*   global    — ~/.overdeck/context/global.md  (+ global/{skills,agents}/)
+*               Applies to every harness invocation, everywhere.
+*   project   — <projectRoot>/.overdeck/context/project.md
+*               Applies when CWD is under a registered project. Committed.
+*   workspace — <workspace>/.overdeck/context/workspace.md
+*               Auto-assembled by Overdeck at spawn time. Gitignored.
+*
+* The global layer lives under ~/.overdeck (per-machine). Project and
+* Project and workspace context live outside the permanent state plane under
+* `.overdeck/`. Reads retain a `.pan/context/` compatibility fallback.
+*/
+/** `~/.overdeck/context` — the global layer directory. */
+function globalContextDir() {
+	return join$1(getOverdeckHome(), "context");
+}
+/** `~/.overdeck/context/global.md` — the global layer's canonical source. */
+function globalContextFile() {
+	return join$1(globalContextDir(), "global.md");
+}
+/** `<projectRoot>/.overdeck/context` — a registered project's layer directory. */
+function projectContextDir(projectRoot) {
+	return join$1(projectRoot, ".overdeck", "context");
+}
+/** `<projectRoot>/.overdeck/context/project.md` — a project's canonical source. */
+function projectContextFile(projectRoot) {
+	return join$1(projectContextDir(projectRoot), "project.md");
+}
+function legacyProjectContextFile(projectRoot) {
+	return join$1(projectRoot, ".pan", "context", "project.md");
+}
+function resolveProjectContextFile(projectRoot) {
+	const canonical = projectContextFile(projectRoot);
+	return existsSync(canonical) ? canonical : legacyProjectContextFile(projectRoot);
+}
+/** `<workspace>/.overdeck/context` — a workspace's layer directory. */
+function workspaceContextDir(workspacePath) {
+	return join$1(workspacePath, ".overdeck", "context");
+}
+/** `<workspace>/.pan/context/workspace.md` — the auto-assembled bundle. */
+function workspaceContextFile(workspacePath) {
+	return join$1(workspaceContextDir(workspacePath), "workspace.md");
+}
+function legacyWorkspaceContextFile(workspacePath) {
+	return join$1(workspacePath, ".pan", "context", "workspace.md");
+}
+function resolveWorkspaceContextFile(workspacePath) {
+	const canonical = workspaceContextFile(workspacePath);
+	return existsSync(canonical) ? canonical : legacyWorkspaceContextFile(workspacePath);
+}
+/** `~/.overdeck/context/pi-global.md` — the rendered global layer for Pi. */
+function piGlobalContextFile() {
+	return join$1(getOverdeckHome(), "context", "pi-global.md");
+}
+/** `~/.overdeck/context/claude-global.md` — launch-time global context for managed Claude sessions. */
+function claudeGlobalContextFile() {
+	return join$1(getOverdeckHome(), "context", "claude-global.md");
+}
+/** `~/.overdeck/context/codex-global.md` — the rendered global layer for Codex. */
+function codexGlobalContextFile() {
+	return join$1(getOverdeckHome(), "context", "codex-global.md");
+}
+/**
+* Ensure a project's layer dir exists with a stub `project.md`. Idempotent.
+* Returns true when a file was created. Called by `pan projects add`.
+*/
+function ensureProjectLayer(projectRoot) {
+	const file = projectContextFile(projectRoot);
+	if (existsSync(file)) return false;
+	mkdirSync(projectContextDir(projectRoot), { recursive: true });
+	writeFileSync(file, PROJECT_STARTER, "utf-8");
+	return true;
+}
+/** Read a layer's canonical markdown, or '' when the file does not exist. */
+function readLayerContent(file) {
+	return existsSync(file) ? readFileSync(file, "utf-8") : "";
+}
+var PROJECT_STARTER;
+var init_layers = __esmMin((() => {
+	init_paths();
+	PROJECT_STARTER = `# Project Context
+
+Context for this project specifically. \`pan sync\` renders it into the
+project's CLAUDE.md (and equivalents) when CWD is under this project.
+
+This file is committed to the repo; \`workspace.md\` is not.
+`;
+}));
+//#endregion
+//#region ../../lib/context-layers/rules.ts
+/**
+* Bundled engineering rules (PAN-1201).
+*
+* Overdeck ships a small set of engineering rules under sync-sources/rules/.
+* Each rule carries a `scope:` frontmatter key:
+*
+*   universal — distributed everywhere (relevant to anyone running agents)
+*   dev       — distributed only on a overdeck checkout (rules about
+*               developing Overdeck itself)
+*
+* `pan sync` folds the applicable rules into the managed launch context.
+* Their `paths:` frontmatter (Claude Code path-scoping) is dropped on fold —
+* a folded rule is always-on.
+*/
+/**
+* Parse a rule file into `{ scope, body }`. Rules with no frontmatter, or
+* frontmatter without a recognised `scope:`, default to `universal`.
+*/
+function parseRule(name, raw) {
+	const m = FRONTMATTER_RE.exec(raw);
+	let scope = "universal";
+	let body = raw;
+	if (m) {
+		body = raw.slice(m[0].length);
+		const value = m[1].split(/\r?\n/).find((l) => /^\s*scope\s*:/.test(l))?.split(":")[1]?.trim().replace(/['"]/g, "");
+		if (value === "dev" || value === "universal") scope = value;
+	}
+	return {
+		name,
+		scope,
+		body: body.trim()
+	};
+}
+/** Read every bundled rule from sync-sources/rules/, sorted by name. */
+function readBundledRules() {
+	const dir = SYNC_SOURCES.rules;
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir).filter((f) => f.endsWith(".md")).sort().map((f) => parseRule(f.replace(/\.md$/, ""), readFileSync(join$1(dir, f), "utf-8")));
+}
+/**
+* Rule names switched off via `context.rules: { <name>: false }` in
+* config.yaml. Absent keys and `true` mean the rule stays on, so a bundled
+* rule is default-on and the map only ever lists opt-outs.
+*/
+function disabledRuleNames(context) {
+	return new Set(Object.entries(context?.rules ?? {}).filter(([, enabled]) => enabled === false).map(([name]) => name));
+}
+/**
+* Render the applicable bundled rules into one managed instruction section.
+*
+* `includeDev` admits `scope: dev` rules — set it from `isDevMode()` so they
+* only fold in on a overdeck checkout. `disabled` names rules switched off in
+* config (see {@link disabledRuleNames}); callers that render for real
+* distribution or preview must pass it so both surfaces agree. Each rule body
+* is rendered for the target harness so any `{{#harness:*}}` blocks resolve.
+* Returns '' when no rules apply.
+*/
+function renderBundledRules(harness, includeDev, disabled = /* @__PURE__ */ new Set()) {
+	const sections = readBundledRules().filter((r) => (includeDev || r.scope === "universal") && !disabled.has(r.name)).map((r) => {
+		const body = renderForHarness(r.body, harness).trim();
+		return body ? `Source: ${join$1(SYNC_SOURCES.rules, `${r.name}.md`)} (scope: ${r.scope})\n\n${body}` : "";
+	}).filter((s) => s.length > 0);
+	if (sections.length === 0) return "";
+	return `## Overdeck Engineering Rules\n\n${sections.join("\n\n")}`;
+}
+var FRONTMATTER_RE;
+var init_rules = __esmMin((() => {
+	init_paths();
+	init_harness();
+	FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+}));
+//#endregion
+//#region ../../lib/context-layers/render.ts
+/** Render machine context plus bundled rules for a managed harness launch. */
+function renderGlobalLayer(harness, includeDevRules) {
+	const source = globalContextFile();
+	const body = renderForHarness(readLayerContent(source), harness).trim();
+	const sections = [body ? `## Machine context\n\nSource: ${source}\n\n${body}` : "", renderBundledRules(harness, includeDevRules, configDisabledRuleNames())].filter((section) => section.length > 0);
+	return sections.length > 0 ? `# Overdeck managed instructions\n\nThis is a generated composition. Each section identifies its own source; the machine-context file is only one input.\n\n${sections.join("\n\n---\n\n")}` : "";
+}
+/** Resolve config-disabled bundled rules; a broken config disables nothing. */
+function configDisabledRuleNames() {
+	try {
+		return disabledRuleNames(loadConfigSync().config.context);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+/** Render one project's canonical source for a managed harness launch. */
+function renderProjectLayer(projectRoot, harness) {
+	const source = resolveProjectContextFile(projectRoot);
+	const raw = readLayerContent(source);
+	if (raw.trim().length === 0) return "";
+	const body = renderForHarness(raw, harness).trim();
+	return body ? `## Project context\n\nSource: ${source}\n\n${body}` : "";
+}
+var init_render = __esmMin((() => {
+	init_config_yaml();
+	init_harness();
+	init_rules();
+	init_layers();
+}));
+//#endregion
+//#region ../../lib/context-layers/materialize.ts
+/** Build one harness-correct, Overdeck-owned context artifact for a launch. */
+/**
+* Compose global rules, the current project's canonical layer, and the
+* workspace-only portion of a saved workspace bundle for the launch harness.
+*
+* Workspace bundles created before PAN-3779 may contain a project section
+* rendered for whichever harness created the worktree (historically Claude).
+* Strip that structural section and render the canonical project source for
+* the current harness instead. This prevents stale Claude-filtered context
+* from leaking into Codex, OMP, ACP, or Kimi launches and avoids delivering
+* the project layer twice.
+*/
+function renderManagedLaunchContext(workspace, harness) {
+	const sections = [renderGlobalLayer(harness, isDevMode())];
 	const project = findProjectByPathSync(workspace);
-	if (project) sections.push(renderProjectLayer(project.path, "acp"));
+	if (project) sections.push(renderProjectLayer(project.path, harness));
 	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 body = renderForHarness(workspaceContextWithoutProjectLayer(readFileSync$1(workspaceFile, "utf8")), harness).trim();
+		if (body) sections.push(`## Workspace context\n\nSource: ${workspaceFile}\n\n${body}`);
 	}
-	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;
+	return sections.map((section) => section.trim()).filter((section) => section.length > 0).join(SECTION_SEPARATOR).trim();
+}
+/** Atomically materialize launch context at an explicitly Overdeck-owned path. */
+function materializeManagedLaunchContext(targetFile, workspace, harness) {
+	const content = renderManagedLaunchContext(workspace, harness);
+	mkdirSync$1(dirname(targetFile), { recursive: true });
+	const tmp = `${targetFile}.${randomUUID$1()}.tmp`;
+	writeFileSync$1(tmp, content.length > 0 ? `${content}\n` : "", { mode: 384 });
+	renameSync$1(tmp, targetFile);
+	return targetFile;
+}
+/**
+* Stable private artifact used by ordinary non-ACP launchers. The workspace
+* hash keeps paths short and avoids exposing project names in receipts.
+*/
+function materializeSharedManagedLaunchContext(workspace, harness) {
+	const workspaceHash = createHash$1("sha256").update(resolve(workspace)).digest("hex").slice(0, 16);
+	return materializeManagedLaunchContext(join(getOverdeckHome(), "context", "launch", `${harness}-${workspaceHash}.md`), workspace, harness);
 }
 var SECTION_SEPARATOR;
-var init_context = __esmMin((() => {
+var init_materialize = __esmMin((() => {
+	init_paths();
+	init_projects();
 	init_assemble();
 	init_harness();
 	init_layers();
 	init_render();
-	init_paths();
-	init_projects();
 	SECTION_SEPARATOR = "\n\n---\n\n";
 }));
 //#endregion
+//#region ../../lib/acp/context.ts
+function materializeAcpContextFile(agentDir, workspace, harness = "acp") {
+	return materializeManagedLaunchContext(join(agentDir, "acp-context.md"), workspace, harness);
+}
+var init_context = __esmMin((() => {
+	init_materialize();
+}));
+//#endregion
 //#region ../../lib/runtimes/ohmypi-fifo.ts
 /**
 * oh-my-pi (omp) RPC named-pipe lifecycle (PAN-1989).
@@ -1769,7 +2143,7 @@ async function createOhmypiFifoPromise(agentId, home) {
 		mode: 448
 	});
 	if (existsSync$1(paths.fifoPath)) unlinkSync$1(paths.fifoPath);
-	await execAsync$8(`mkfifo -m 600 ${shellQuote$1(paths.fifoPath)}`);
+	await execAsync$9(`mkfifo -m 600 ${shellQuote$2(paths.fifoPath)}`);
 	return paths.fifoPath;
 }
 /**
@@ -1807,14 +2181,14 @@ function writeOhmypiCommandSync(agentId, command, home) {
 		closeSync$1(fd);
 	}
 }
-function shellQuote$1(s) {
+function shellQuote$2(s) {
 	if (/^[A-Za-z0-9._/-]+$/.test(s)) return s;
 	return `'${s.replace(/'/g, `'\\''`)}'`;
 }
-var execAsync$8, OhmypiNotReady, OhmypiFifoError, createOhmypiFifo;
+var execAsync$9, OhmypiNotReady, OhmypiFifoError, createOhmypiFifo;
 var init_ohmypi_fifo = __esmMin((() => {
 	init_paths();
-	execAsync$8 = promisify(exec);
+	execAsync$9 = promisify(exec);
 	OhmypiNotReady = class extends Error {
 		code = "OHMYPI_NOT_READY";
 		constructor(message) {
@@ -1849,6 +2223,28 @@ var init_pi_fifo = __esmMin((() => {
 	Data.TaggedError("PiFifoError");
 }));
 //#endregion
+//#region ../../lib/context-layers/launch-sources.ts
+/** Resolve explicit context inputs without depending on agent lifecycle code. */
+async function claudeSystemPromptFiles(workspace, harness) {
+	const effectiveHarness = harness ?? "claude-code";
+	const behavior = getHarnessBehavior(effectiveHarness);
+	if (behavior.contextLayerKind === "acp" || behavior.contextLayerKind === "opencode" || behavior.contextLayerKind === "muse") return [];
+	const files = [];
+	if (behavior.contextLayerKind === "codex") {
+		const nativeOverride = join(homedir$1(), ".codex", "AGENTS.override.md");
+		const nativeGlobal = existsSync$1(nativeOverride) ? nativeOverride : join(homedir$1(), ".codex", "AGENTS.md");
+		if (existsSync$1(nativeGlobal)) files.push(nativeGlobal);
+	}
+	files.push(materializeSharedManagedLaunchContext(workspace, effectiveHarness));
+	files.push(await ensureSessionContextBriefingFile());
+	return files;
+}
+var init_launch_sources = __esmMin((() => {
+	init_briefing_freshness();
+	init_behavior();
+	init_materialize();
+}));
+//#endregion
 //#region ../../lib/agents/runtime-command.ts
 /** Parse and flatten a role definition's mcpServers frontmatter. */
 function parseRoleMcpServersSync(definitionPath) {
@@ -1883,30 +2279,6 @@ async function writeLauncherScriptAtomic(launcherScript, content) {
 	await writeFile$1(tmp, content, { mode: 493 });
 	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 {
-		await stat$1(contextFile);
-		files.push(contextFile);
-	} catch (error) {
-		if (!isNodeNotFound(error)) throw error;
-	}
-	files.push(await ensureSessionContextBriefingFile());
-	if (behavior.contextLayerKind === "pi") {
-		const { piGlobalContextFile } = await import("./context-layers-Ds1MnEFI.js");
-		const globalFile = piGlobalContextFile();
-		if (existsSync(globalFile)) files.unshift(globalFile);
-	}
-	if (behavior.contextLayerKind === "codex") {
-		const { codexGlobalContextFile } = await import("./context-layers-Ds1MnEFI.js");
-		const globalFile = codexGlobalContextFile();
-		if (existsSync(globalFile)) files.unshift(globalFile);
-	}
-	return files;
-}
 function isNodeNotFound(error) {
 	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
@@ -1928,20 +2300,20 @@ async function hasAgentRuntimeInSubtree(rootPid, harness = "claude-code") {
 		if (seen.has(pid) || !/^\d+$/.test(pid)) continue;
 		seen.add(pid);
 		try {
-			const { stdout: comm } = await execAsync$6(`ps -p ${pid} -o comm=`);
+			const { stdout: comm } = await execAsync$7(`ps -p ${pid} -o comm=`);
 			const name = comm.trim();
-			if (expectedProcessNames.has(name)) return true;
+			if (expectedProcessNames.has(name) || harness === "muse" && name.startsWith("muse-bin-")) return true;
 		} catch {
 			continue;
 		}
 		try {
-			const { stdout: kids } = await execAsync$6(`pgrep -P ${pid}`);
+			const { stdout: kids } = await execAsync$7(`pgrep -P ${pid}`);
 			for (const kid of kids.trim().split("\n").filter(Boolean)) queue.push(kid);
 		} catch {}
 	}
 	return false;
 }
-async function getOhmypiLauncherFields(agentId, model) {
+async function getOhmypiLauncherFields(agentId, model, effort) {
 	const paths = ohmypiFifoPaths(agentId);
 	await mkdir$1(paths.agentDir, {
 		recursive: true,
@@ -1951,39 +2323,45 @@ async function getOhmypiLauncherFields(agentId, model) {
 	if (!ohmypiExtensionPath) throw new Error(`ohmypi extension not built. Run: npm run build\n(looked for dist/extensions/ohmypi.js and packages/ohmypi-extension/dist/index.js under ${packageRoot})`);
 	return {
 		harness: "ohmypi",
+		piEffort: effort ?? "high",
 		piExtensionPath: ohmypiExtensionPath,
 		piFifoPath: await Effect.runPromise(createOhmypiFifo(agentId)),
 		piSessionDir: paths.agentDir,
 		model
 	};
 }
-function getAcpLauncherFields(agentId, model, workspace, binaryPath, _role) {
+function getAcpLauncherFields(agentId, model, workspace, binaryPath, _role, effort) {
 	return {
-		harness: "acp",
+		harness: model.startsWith("opencode/") || model.startsWith("opencode-go/") ? "opencode" : "acp",
 		acpAgentId: agentId,
 		acpProvider: getProviderForModelSync(model).name,
 		acpWorkspace: workspace,
 		acpBinaryPath: binaryPath,
-		acpContextFile: materializeAcpContextFile(getAgentDir(agentId), workspace),
+		acpContextFile: materializeAcpContextFile(getAgentDir(agentId), workspace, model.startsWith("opencode/") || model.startsWith("opencode-go/") ? "opencode" : "acp"),
+		...effort ? { acpEffort: effort } : {},
 		model,
 		unsetProviderEnv: true
 	};
 }
-function getKimiCodeLauncherFields(model) {
+function getKimiCodeLauncherFields(model, effort) {
 	return {
 		harness: "kimi-code",
 		kimiCodeModel: resolveKimiCodeModelAlias(model),
 		kimiCodeYolo: true,
+		...effort ? { kimiCodeEffort: effort } : {},
 		model,
-		unsetProviderEnv: true
+		unsetProviderEnv: true,
+		kimiContextDelivery: "initial-message"
 	};
 }
-function getCodexLauncherFields(agentId, model, workspacePath, role) {
-	const codexHome = join$1(homedir(), ".overdeck", "agents", agentId, "codex-home");
+function getCodexLauncherFields(agentId, model, workspacePath, role, effort) {
+	const codexHome = join$1(homedir(), ".overdeck", "agents", agentId, "codex-home-v2");
 	const codexConfig = loadConfigSync().config.codex;
 	const codexPermMode = codexConfig?.permissionMode ?? "workspace";
 	initCodexHome(codexHome, {
 		trustedDir: workspacePath,
+		model,
+		effort,
 		approvalPolicy: codexPermMode === "full-access" ? "never" : "on-request",
 		sandboxMode: codexPermMode === "full-access" ? "danger-full-access" : codexPermMode === "read-only" ? "read-only" : "workspace-write",
 		approvalsReviewer: codexPermMode === "auto-review" ? "auto_review" : void 0,
@@ -1992,6 +2370,7 @@ function getCodexLauncherFields(agentId, model, workspacePath, role) {
 	return {
 		harness: "codex",
 		codexMode: codexConfig?.transport === "tui" ? "work-tui" : "app-server",
+		codexEffort: effort ?? "high",
 		codexHome,
 		codexSessionDir: join$1(codexHome, "sessions"),
 		model
@@ -2203,6 +2582,7 @@ async function waitForPromptReady(agentId, harness, timeoutSec = 30) {
 		return true;
 	}
 	if (readinessKind === "codex-tui-prompt") return waitForCodexTuiReady(agentId, timeoutSec);
+	if (readinessKind === "muse-tui-prompt") return waitForMuseTuiReady(agentId, timeoutSec);
 	if (readinessKind === "kimi-session-signal") return waitForKimiCodeTuiReady(agentId, timeoutSec);
 	return waitForReadySignal(agentId, timeoutSec);
 }
@@ -2230,7 +2610,7 @@ async function injectPiPromptTimeMemory(agentId, prompt) {
 			agentRole: agentState.role ?? "work",
 			agentHarness: agentState.harness ?? "claude-code"
 		};
-		const { injectPromptTimeMemory } = await import("./injection-BWsgHvrL.js");
+		const { injectPromptTimeMemory } = await import("./injection-Bk_pw2Ei.js");
 		const result = await injectPromptTimeMemory({
 			prompt,
 			identity,
@@ -2264,7 +2644,7 @@ async function injectPiConversationMemory(opts, prompt) {
 			agentRole: "work",
 			agentHarness: "ohmypi"
 		};
-		const { injectPromptTimeMemory } = await import("./injection-BWsgHvrL.js");
+		const { injectPromptTimeMemory } = await import("./injection-Bk_pw2Ei.js");
 		const result = await injectPromptTimeMemory({
 			prompt,
 			identity,
@@ -2312,8 +2692,7 @@ async function getProviderAuthMode(model) {
 *
 * The `harness` parameter (PAN-636) selects between Claude Code (default)
 * and ohmypi/Pi. When the harness uses the ohmypi RPC command, the function
-* short-circuits to a
-* `omp --mode rpc --model <model>` line; the launcher generator then layers
+* returns `omp --mode rpc --model <model>`; the launcher generator then layers
 * --session-dir, --extension, --no-context-files, and the stdin-from-fifo
 * redirect on top via generateLauncherScript. The `agentName` (PAN-982:
 * --name) and `agentDefinition` (PAN-982: --agent) parameters only apply to the
@@ -2321,11 +2700,12 @@ async function getProviderAuthMode(model) {
 */
 async function getAgentRuntimeBaseCommand(model, agentName, agentDefinition, harness = "claude-code", effort) {
 	const validatedModel = requireModelOverrideSync(model);
-	const quotedModel = shellQuoteModelIdSync(validatedModel);
+	const quotedModel = shellQuoteModelIdSync(harness === "claude-code" ? getClaudeCodeLaunchModelSync(validatedModel) : validatedModel);
 	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 (behavior.launchCommandKind === "muse-tui") return "muse";
 	if (behavior.launchCommandKind === "kimi-code-tui") return "kimi-code";
 	if (process.env.OVERDECK_TEST_HARNESS_COMMAND) return process.env.OVERDECK_TEST_HARNESS_COMMAND;
 	const provider = getProviderForModelSync(validatedModel);
@@ -2393,7 +2773,7 @@ function roleSystemPromptInjectionSync(definitionPath, explicitEffort) {
 	mkdirSync(dir, { recursive: true });
 	const stem = basename$1(definitionPath).replace(/\.md$/, "");
 	const outPath = join$1(dir, `${stem}.md`);
-	writeFileSync(outPath, body);
+	writeFileSync(outPath, `Source: ${abs}\n\n${body}`);
 	const flags = [` --append-system-prompt-file '${outPath}'`];
 	const effort = explicitEffort ?? (typeof frontmatter.effort === "string" ? frontmatter.effort : void 0);
 	if (effort) flags.push(` --effort ${effort}`);
@@ -2416,7 +2796,7 @@ function roleSystemPromptInjectionSync(definitionPath, explicitEffort) {
 /** Build a Claude/ohmypi base command for role-based runs. */
 async function getRoleRuntimeBaseCommand(model, agentName, role, harness = "claude-code", subRole, effort) {
 	const validatedModel = requireModelOverrideSync(model);
-	const quotedModel = shellQuoteModelIdSync(validatedModel);
+	const quotedModel = shellQuoteModelIdSync(harness === "claude-code" ? getClaudeCodeLaunchModelSync(validatedModel) : validatedModel);
 	const behavior = getHarnessBehavior(harness);
 	if (behavior.launchCommandKind === "ohmypi-rpc") {
 		const mcpNames = Object.keys(parseRoleMcpServersSync(roleAgentDefinitionPath(role)));
@@ -2425,6 +2805,7 @@ async function getRoleRuntimeBaseCommand(model, agentName, role, harness = "clau
 	}
 	if (behavior.launchCommandKind === "codex-work-tui") return `codex`;
 	if (behavior.launchCommandKind === "acp-host") return "acp-host";
+	if (behavior.launchCommandKind === "muse-tui") return "muse";
 	if (behavior.launchCommandKind === "kimi-code-tui") return "kimi-code";
 	if (process.env.OVERDECK_TEST_HARNESS_COMMAND) return process.env.OVERDECK_TEST_HARNESS_COMMAND;
 	const provider = getProviderForModelSync(validatedModel);
@@ -2442,14 +2823,22 @@ async function getRoleRuntimeBaseCommand(model, agentName, role, harness = "clau
 	if (provider.name === "openai" && await getProviderAuthMode(validatedModel) === "subscription") return `claude${printFlag}${roleInject}${permissionFlags} --model ${shellQuoteModelIdSync(CLI_PROXY_MODEL_ALIASES[validatedModel] ?? validatedModel)}${effortFlag}${nameFlag}`;
 	return `claude${printFlag}${roleInject}${permissionFlags} --model ${quotedModel}${effortFlag}${nameFlag}`;
 }
-var import_dist, execAsync$6, missingRoleDefinitionWarnings, OHMYPI_AGENT_READY_TIMEOUT_SECONDS;
+async function waitForMuseTuiReady(agentId, timeoutSec) {
+	const deadline = Date.now() + timeoutSec * 1e3;
+	while (Date.now() < deadline) {
+		if (!await Effect.runPromise(sessionExists(agentId))) return false;
+		const pane = await Effect.runPromise(capturePane(agentId, 80));
+		if (/^\s*⟩\s/m.test(pane) && /(?:muse-spark|Muse Code)/.test(pane)) return true;
+		await new Promise((resolve) => setTimeout(resolve, 250));
+	}
+	return false;
+}
+var import_dist, execAsync$7, missingRoleDefinitionWarnings, OHMYPI_AGENT_READY_TIMEOUT_SECONDS;
 var init_runtime_command = __esmMin((() => {
 	import_dist = /* @__PURE__ */ __toESM(require_dist(), 1);
 	init_claude_permissions();
 	init_config_yaml();
-	init_briefing_freshness();
 	init_claude_auth();
-	init_layers();
 	init_context();
 	init_behavior();
 	init_codex();
@@ -2463,11 +2852,42 @@ var init_runtime_command = __esmMin((() => {
 	init_agent_state();
 	init_identity();
 	init_provider_env();
-	execAsync$6 = promisify$1(exec$1);
+	init_kimi_claude_routing();
+	init_launch_sources();
+	execAsync$7 = promisify$1(exec$1);
 	missingRoleDefinitionWarnings = /* @__PURE__ */ new Set();
 	OHMYPI_AGENT_READY_TIMEOUT_SECONDS = 120;
 }));
 //#endregion
+//#region ../../lib/runtimes/muse-context.ts
+/** Materialize Overdeck-owned context for Muse's developer-message file input. */
+async function materializeMuseContext(agentId, workspace, roleFile) {
+	museDataHome(agentId);
+	const sections = [renderGlobalLayer("muse", isDevMode())];
+	const project = findProjectByPathSync(workspace);
+	if (project) sections.push(renderProjectLayer(project.path, "muse"));
+	const workspaceLayer = await readFile(resolveWorkspaceContextFile(workspace), "utf8").catch((error) => {
+		if (error.code === "ENOENT") return "";
+		throw error;
+	});
+	sections.push(renderForHarness(project ? workspaceContextWithoutProjectLayer(workspaceLayer) : workspaceLayer, "muse"));
+	if (roleFile) sections.push(await readFile(roleFile, "utf8"));
+	const dir = join(getOverdeckHome(), "agents", agentId);
+	await mkdir(dir, { recursive: true });
+	const path = join(dir, "muse-context.md");
+	await writeFile(path, sections.filter((section) => section.trim()).join("\n\n---\n\n"), { mode: 384 });
+	return path;
+}
+var init_muse_context = __esmMin((() => {
+	init_paths();
+	init_projects();
+	init_render();
+	init_layers();
+	init_harness();
+	init_assemble();
+	init_muse_session();
+}));
+//#endregion
 //#region ../../lib/agents/reopen-guard.ts
 function defaultDeps() {
 	return {
@@ -2830,7 +3250,7 @@ async function transitionIssueToInReview(issueId, workspacePath) {
 async function buildAgentLaunchConfig(opts) {
 	const model = requireModelOverrideSync(opts.model);
 	try {
-		const { injectOverdeckInfraDeny } = await import("./claude-settings-overlay-CMS5Jab5.js");
+		const { injectOverdeckInfraDeny } = await import("./claude-settings-overlay-ALboy05V.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}`);
@@ -2845,11 +3265,19 @@ async function buildAgentLaunchConfig(opts) {
 	}
 	const providerExports = isAcp ? void 0 : await getProviderExportsForModel(model, opts.harness);
 	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) : {};
-	const kimiCodeLauncherFields = behavior.launchCommandKind === "kimi-code-tui" ? getKimiCodeLauncherFields(model) : {};
+	const piLauncherFields = behavior.usesRpcFifo ? await getOhmypiLauncherFields(opts.agentId, model, opts.effort) : {};
+	const codexLauncherFields = behavior.usesCodexHome ? getCodexLauncherFields(opts.agentId, model, opts.workspace, launchRole, opts.effort) : {};
+	const museSavedSession = opts.harness === "muse" && opts.spawnMode === "resume" ? await resolveMuseSessionPath(opts.agentId) : null;
+	const museLauncherFields = opts.harness === "muse" ? {
+		harness: "muse",
+		museModel: model,
+		museEffort: opts.effort,
+		museContextFile: await materializeMuseContext(opts.agentId, opts.workspace, roleAgentDefinitionPath(launchRole)),
+		museResumeSessionId: museSavedSession ? museSessionId(museSavedSession) : void 0
+	} : {};
+	const kimiCodeLauncherFields = behavior.launchCommandKind === "kimi-code-tui" ? getKimiCodeLauncherFields(model, opts.effort) : {};
 	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) : {};
+	const acpLauncherFields = isAcp ? getAcpLauncherFields(opts.agentId, model, opts.workspace, opts.harnessBinaryPath, launchRole, opts.effort) : {};
 	if (opts.spawnMode === "resume" && opts.resumeSessionId) return {
 		launcherContent: generateLauncherScriptSync({
 			role: launchRole,
@@ -2871,7 +3299,8 @@ async function buildAgentLaunchConfig(opts) {
 			...piLauncherFields,
 			...codexLauncherFields,
 			...acpLauncherFields,
-			...kimiCodeLauncherFields
+			...kimiCodeLauncherFields,
+			...museLauncherFields
 		}),
 		providerEnv
 	};
@@ -2898,6 +3327,7 @@ async function buildAgentLaunchConfig(opts) {
 			...codexLauncherFields,
 			...acpLauncherFields,
 			...kimiCodeLauncherFields,
+			...museLauncherFields,
 			...opts.channelsBridgeMcpConfig ? {
 				channelsBridgeMcpConfig: opts.channelsBridgeMcpConfig,
 				channelsBridgeServerName: opts.channelsBridgeServerName ?? "overdeck-bridge"
@@ -2923,7 +3353,7 @@ async function retrieveSpawnTimeMemoryContext(input) {
 			agentRole: input.role,
 			agentHarness: input.harness
 		};
-		const { injectPromptTimeMemory } = await import("./injection-BWsgHvrL.js");
+		const { injectPromptTimeMemory } = await import("./injection-Bk_pw2Ei.js");
 		return (await injectPromptTimeMemory({
 			prompt: input.prompt,
 			identity,
@@ -3023,7 +3453,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-BcBVFJp3.js");
+	const { rebuildWorkspaceStack } = await import("./rebuild-stack-DSQSgPCI.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)
@@ -3042,6 +3472,8 @@ async function assertWorkspaceStackHealthyForSpawn(issueId, role, allowHost = fa
 }
 var spawnStackRebuildState, SPAWN_STACK_REBUILD_COOLDOWN_MS, SPAWN_STACK_REBUILD_MAX_ATTEMPTS;
 var init_spawn_prep = __esmMin((() => {
+	init_muse_context();
+	init_muse_session();
 	init_activity_logger();
 	init_claude_permissions();
 	init_config();
@@ -3661,6 +4093,99 @@ var init_bridge_token = __esmMin((() => {
 	BRIDGE_TOKEN_HEADER = "x-overdeck-bridge-token";
 }));
 //#endregion
+//#region ../../lib/runtimes/kimi-context-envelope.ts
+/** Explicit first-user-message context transport for the native Kimi CLI. */
+function receiptPath(agentId, overdeckHome = getOverdeckHome()) {
+	return join(overdeckHome, "agents", agentId, "kimi-context-delivery.json");
+}
+function readReceipt(agentId, overdeckHome = getOverdeckHome()) {
+	try {
+		const parsed = JSON.parse(readFileSync$1(receiptPath(agentId, overdeckHome), "utf8"));
+		if (parsed.version === 1 && parsed.sessions && typeof parsed.sessions === "object") return parsed;
+	} catch {}
+	return {
+		version: 1,
+		sessions: {}
+	};
+}
+function readManagedKimiSessionId(agentId, overdeckHome = getOverdeckHome()) {
+	try {
+		return readFileSync$1(join(overdeckHome, "agents", agentId, "kimi-session-id"), "utf8").trim() || null;
+	} catch {
+		return null;
+	}
+}
+/** Pure formatter: context first, original task afterward, with hard delimiters. */
+function buildKimiContextEnvelope(contextFiles, taskMessage) {
+	const sections = contextFiles.flatMap((file) => {
+		const content = readFileSync$1(file, "utf8").trim();
+		return content ? [`## Context source: ${file}\n\n${content}`] : [];
+	});
+	if (sections.length === 0) throw new Error("Managed Kimi launch blocked: required launch context was empty or unreadable.");
+	const context = sections.join("\n\n---\n\n");
+	const sha256 = createHash$1("sha256").update(context).digest("hex");
+	const envelope = [
+		KIMI_CONTEXT_START,
+		"Treat this delimited block as managed launch context for this session. Apply it throughout the session.",
+		"",
+		context,
+		KIMI_CONTEXT_END
+	];
+	if (taskMessage.length > 0) envelope.push("", KIMI_TASK_START, taskMessage, KIMI_TASK_END);
+	return {
+		message: envelope.join("\n"),
+		sha256
+	};
+}
+/**
+* Add context only if this exact native Kimi session has not received it.
+* A resume/recovery of the same session therefore keeps task messages clean;
+* a fresh session receives the envelope on its first visible user message.
+*/
+async function prepareKimiMessage(agentId, workspace, taskMessage, options = {}) {
+	const overdeckHome = options.overdeckHome ?? getOverdeckHome();
+	const sessionId = options.sessionId ?? readManagedKimiSessionId(agentId, overdeckHome);
+	if (!sessionId) throw new Error(`Managed Kimi message blocked for ${agentId}: captured kimi-session-id is missing.`);
+	if (readReceipt(agentId, overdeckHome).sessions[sessionId]) return {
+		message: taskMessage,
+		sessionId,
+		contextIncluded: false,
+		overdeckHome
+	};
+	const envelope = buildKimiContextEnvelope(options.contextFiles ?? await claudeSystemPromptFiles(workspace, "kimi-code"), taskMessage);
+	return {
+		message: envelope.message,
+		sessionId,
+		contextIncluded: true,
+		contextSha256: envelope.sha256,
+		overdeckHome
+	};
+}
+/** Persist only after the envelope delivery returned success. */
+function markKimiContextDelivered(agentId, prepared) {
+	if (!prepared.contextIncluded || !prepared.contextSha256) return;
+	const path = receiptPath(agentId, prepared.overdeckHome);
+	const receipt = readReceipt(agentId, prepared.overdeckHome);
+	if (receipt.sessions[prepared.sessionId]?.sha256 === prepared.contextSha256) return;
+	receipt.sessions[prepared.sessionId] = {
+		deliveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+		sha256: prepared.contextSha256
+	};
+	mkdirSync$1(dirname(path), { recursive: true });
+	const tmp = `${path}.${randomUUID$1()}.tmp`;
+	writeFileSync$1(tmp, `${JSON.stringify(receipt, null, 2)}\n`, { mode: 384 });
+	renameSync$1(tmp, path);
+}
+var KIMI_CONTEXT_START, KIMI_CONTEXT_END, KIMI_TASK_START, KIMI_TASK_END;
+var init_kimi_context_envelope = __esmMin((() => {
+	init_launch_sources();
+	init_paths();
+	KIMI_CONTEXT_START = "<overdeck-managed-context version=\"1\">";
+	KIMI_CONTEXT_END = "</overdeck-managed-context>";
+	KIMI_TASK_START = "<overdeck-user-task>";
+	KIMI_TASK_END = "</overdeck-user-task>";
+}));
+//#endregion
 //#region ../../lib/channels/injection-budget.ts
 /** Echo window for one attempt: 2.5s floor + 100ms per KB, capped at 15s. */
 function echoConfirmTimeoutMs(contentLength) {
@@ -4021,16 +4546,27 @@ async function deliverAgentMessage(agentId, message, caller = "unknown", deliver
 	} catch {
 		resolvedMethod ??= "auto";
 	}
-	const isAcpTarget = state?.harness === "acp";
+	const isAcpTarget = state?.harness === "acp" || state?.harness === "opencode";
 	if (isAcpTarget && resolvedMethod !== "auto") throw new Error(`MessageDeliveryFailed: ACP delivery failed for ${normalizedId} (${caller}): ACP requires authenticated host RPC delivery`);
-	if (dedupKey !== void 0) return deliverKeyedAgentMessage(normalizedId, message, caller, resolvedMethod ?? "auto", isAcpTarget, dedupKey);
+	let preparedKimiMessage = opts.preparedKimiContext;
+	if (preparedKimiMessage && preparedKimiMessage.message !== message) throw new Error(`Managed Kimi message blocked for ${normalizedId}: prepared envelope does not match the delivered message.`);
+	const kimiContext = state?.harness === "kimi-code" && state.workspace ? { workspace: state.workspace } : opts.kimiContext;
+	if (kimiContext && !preparedKimiMessage) {
+		preparedKimiMessage = await prepareKimiMessage(normalizedId, kimiContext.workspace, message, { sessionId: kimiContext.sessionId });
+		message = preparedKimiMessage.message;
+	}
+	const completeDelivery = (result) => {
+		if (result.ok && !result.deduplicated && preparedKimiMessage) markKimiContextDelivered(normalizedId, preparedKimiMessage);
+		return result;
+	};
+	if (dedupKey !== void 0) return completeDelivery(await deliverKeyedAgentMessage(normalizedId, message, caller, resolvedMethod ?? "auto", isAcpTarget, dedupKey));
 	if (resolvedMethod === "tmux") {
 		await assertTmuxTargetCanReceive(normalizedId, caller);
 		await Effect.runPromise(sendKeys(normalizedId, message));
-		return {
+		return completeDelivery({
 			ok: true,
 			path: "tmux"
-		};
+		});
 	}
 	let appServerFailure;
 	if (resolvedMethod === "auto" && !isAcpTarget) {
@@ -4050,10 +4586,10 @@ async function deliverAgentMessage(agentId, message, caller = "unknown", deliver
 					path: "app-server",
 					caller
 				});
-				return {
+				return completeDelivery({
 					ok: true,
 					path: "app-server"
-				};
+				});
 			} catch (err) {
 				appServerFailure = `socket-post-failed: ${err instanceof Error ? err.message : String(err)}`;
 			}
@@ -4077,10 +4613,10 @@ async function deliverAgentMessage(agentId, message, caller = "unknown", deliver
 					path: "acp",
 					caller
 				});
-				return {
+				return completeDelivery({
 					ok: true,
 					path: "acp"
-				};
+				});
 			} catch (err) {
 				acpFailure = `socket-post-failed: ${err instanceof Error ? err.message : String(err)}`;
 			}
@@ -4107,10 +4643,10 @@ async function deliverAgentMessage(agentId, message, caller = "unknown", deliver
 				path: "supervisor",
 				caller
 			});
-			return {
+			return completeDelivery({
 				ok: true,
 				path: "supervisor"
-			};
+			});
 		} catch (err) {
 			supervisorFailure = `socket-post-failed: ${err instanceof Error ? err.message : String(err)}`;
 		}
@@ -4134,10 +4670,10 @@ async function deliverAgentMessage(agentId, message, caller = "unknown", deliver
 					caller,
 					...supervisorFailure ? { "pty-supervisor": supervisorFailure } : {}
 				});
-				return {
+				return completeDelivery({
 					ok: true,
 					path: "channels"
-				};
+				});
 			} catch (err) {
 				channelFailure = `socket-post-failed: ${err instanceof Error ? err.message : String(err)}`;
 			}
@@ -4154,18 +4690,18 @@ async function deliverAgentMessage(agentId, message, caller = "unknown", deliver
 		});
 		await assertTmuxTargetCanReceive(normalizedId, caller);
 		await Effect.runPromise(sendKeys(normalizedId, message));
-		return {
+		return completeDelivery({
 			ok: true,
 			path: "tmux",
 			failure: channelFailure ?? supervisorFailure
-		};
+		});
 	}
 	await assertTmuxTargetCanReceive(normalizedId, caller);
 	await Effect.runPromise(sendKeys(normalizedId, message));
-	return {
+	return completeDelivery({
 		ok: true,
 		path: "tmux"
-	};
+	});
 }
 /**
 * Keyed delivery cascade (PAN-2997). Only two tiers may carry a keyed
@@ -4412,6 +4948,7 @@ async function setAgentDeliveryMethod(agentId, deliveryMethod) {
 var SocketPostStatusError, AmbiguousKeyedDeliveryError, RESUME_TRANSCRIPT_CONFIRM_TIMEOUT_MS, RESUME_TRANSCRIPT_CONFIRM_INTERVAL_MS;
 var init_delivery = __esmMin((() => {
 	init_behavior();
+	init_kimi_context_envelope();
 	init_agents();
 	init_runtime_state();
 	init_tmux();
@@ -5398,7 +5935,7 @@ var init_runtime_census = __esmMin((() => {
 	]);
 	runtimeCensusService = createRuntimeCensusService({
 		listPanes: async () => {
-			const { listAllPaneRecords } = await import("./tmux-CYucGrTl.js");
+			const { listAllPaneRecords } = await import("./tmux-aj9rscol.js");
 			return Effect.runPromise(listAllPaneRecords());
 		},
 		readProcesses: readRuntimeProcessTable
@@ -5768,7 +6305,7 @@ async function killLauncherProcessAsync(agentId) {
 	const launcherPath = join$1(AGENTS_DIR, agentId, "launcher.sh");
 	let pidsOut;
 	try {
-		const { stdout } = await execAsync$5(`pgrep -f ${JSON.stringify(launcherPath)}`);
+		const { stdout } = await execAsync$6(`pgrep -f ${JSON.stringify(launcherPath)}`);
 		pidsOut = stdout.trim();
 	} catch {
 		return;
@@ -5823,14 +6360,14 @@ function stopAgentSync(agentId, cause = "system") {
 		lastActivity: (/* @__PURE__ */ new Date()).toISOString()
 	});
 }
-var execAsync$5, stopAgent;
+var execAsync$6, stopAgent;
 var init_termination = __esmMin((() => {
 	init_agents();
 	init_agent_runtime();
 	init_paths();
 	init_tmux();
 	init_errors();
-	execAsync$5 = promisify$1(exec$1);
+	execAsync$6 = promisify$1(exec$1);
 	stopAgent = (agentId, cause = "system") => {
 		const normalizedId = normalizeAgentId(agentId);
 		return Effect.gen(function* () {
@@ -6012,7 +6549,7 @@ async function ensureRegisteredSlotWorktree(issueId, baseWorkspace, slot) {
 			if (expected.filter((root) => !existsSync$1(`${root.target}/.git`)).length === 0) {
 				if ((await Promise.all(expected.map(async (root) => {
 					try {
-						return (await execAsync$4("git branch --show-current", { cwd: root.target })).stdout.trim();
+						return (await execAsync$5("git branch --show-current", { cwd: root.target })).stdout.trim();
 					} catch {
 						return "";
 					}
@@ -6022,7 +6559,7 @@ async function ensureRegisteredSlotWorktree(issueId, baseWorkspace, slot) {
 		}
 		await mkdir(slot.workspace, { recursive: true });
 		try {
-			for (const root of expected) await execAsync$4(await gitBranchExists(root.dir, slot.branch) ? `git worktree add ${JSON.stringify(root.target)} ${JSON.stringify(slot.branch)}` : `git worktree add -b ${JSON.stringify(slot.branch)} ${JSON.stringify(root.target)} ${JSON.stringify(root.sourceBranch)}`, { cwd: root.dir });
+			for (const root of expected) await execAsync$5(await gitBranchExists(root.dir, slot.branch) ? `git worktree add ${JSON.stringify(root.target)} ${JSON.stringify(slot.branch)}` : `git worktree add -b ${JSON.stringify(slot.branch)} ${JSON.stringify(root.target)} ${JSON.stringify(root.sourceBranch)}`, { cwd: root.dir });
 		} catch (error) {
 			throw new Error(`Could not create isolated polyrepo slot workspace ${slot.workspace}: ${error instanceof Error ? error.message : String(error)}`);
 		}
@@ -6031,7 +6568,7 @@ async function ensureRegisteredSlotWorktree(issueId, baseWorkspace, slot) {
 	if (existsSync$1(slot.workspace)) {
 		let branch = "";
 		try {
-			branch = (await execAsync$4("git branch --show-current", { cwd: slot.workspace })).stdout.trim();
+			branch = (await execAsync$5("git branch --show-current", { cwd: slot.workspace })).stdout.trim();
 		} catch {}
 		if (branch === slot.branch) return;
 		throw new Error(`Registered slot workspace is incomplete at ${slot.workspace}; run pan swarm reset before dispatching it.`);
@@ -6041,11 +6578,11 @@ async function ensureRegisteredSlotWorktree(issueId, baseWorkspace, slot) {
 	if (branchExists && !await gitRefsEqual(baseWorkspace, slot.branch, repoRoots[0].sourceBranch)) throw new Error(`Registered slot branch ${slot.branch} is not at ${repoRoots[0].sourceBranch}; refusing to reuse stale work.`);
 	const target = JSON.stringify(slot.workspace);
 	const branch = JSON.stringify(slot.branch);
-	await execAsync$4(branchExists ? `git worktree add ${target} ${branch}` : `git worktree add -b ${branch} ${target} ${JSON.stringify(repoRoots[0].sourceBranch)}`, { cwd: baseWorkspace });
+	await execAsync$5(branchExists ? `git worktree add ${target} ${branch}` : `git worktree add -b ${branch} ${target} ${JSON.stringify(repoRoots[0].sourceBranch)}`, { cwd: baseWorkspace });
 }
 async function gitBranchExists(workspace, branch) {
 	try {
-		await execAsync$4(`git show-ref --verify --quiet ${JSON.stringify(`refs/heads/${branch}`)}`, { cwd: workspace });
+		await execAsync$5(`git show-ref --verify --quiet ${JSON.stringify(`refs/heads/${branch}`)}`, { cwd: workspace });
 		return true;
 	} catch {
 		return false;
@@ -6053,20 +6590,625 @@ async function gitBranchExists(workspace, branch) {
 }
 async function gitRefsEqual(workspace, left, right) {
 	try {
-		const [leftResult, rightResult] = await Promise.all([execAsync$4(`git rev-parse ${JSON.stringify(left)}`, { cwd: workspace }), execAsync$4(`git rev-parse ${JSON.stringify(right)}`, { cwd: workspace })]);
+		const [leftResult, rightResult] = await Promise.all([execAsync$5(`git rev-parse ${JSON.stringify(left)}`, { cwd: workspace }), execAsync$5(`git rev-parse ${JSON.stringify(right)}`, { cwd: workspace })]);
 		return leftResult.stdout.trim() === rightResult.stdout.trim();
 	} catch {
 		return false;
 	}
 }
-var execAsync$4;
+var execAsync$5;
 var init_registered_slot_spawn = __esmMin((() => {
 	init_dag();
 	init_io();
 	init_project_repos();
+	execAsync$5 = promisify(exec);
+}));
+//#endregion
+//#region ../../lib/runtimes/kimi-code.ts
+/**
+* Kimi Code CLI runtime adapter (PAN-1837).
+*
+* Native TUI — not ACP. Kimi writes its own session tree at
+* `<kimiHome>/sessions/<workDirKey>/<sessionId>/agents/main/wire.jsonl`,
+* where `workDirKey = wd_<basename(workDir)>_<sha256(workDir).hex[:12]>`
+* (verified empirically against installed kimi 0.29.2, wi-fixture/D2 — Kimi
+* does not expose this derivation directly). Kimi generates its own session
+* id; it cannot be preset via a launch flag (D2/erratum E1: no --session, no
+* --work-dir). The id is captured post-launch as the session directory that
+* newly appears under the workspace's bucket, then persisted at
+* `~/.overdeck/agents/<id>/kimi-session-id` (mirrors codex's thread-id file)
+* so later introspection calls avoid re-walking the bucket.
+*
+* Delivery: PTY supervisor is primary (KIMI_CODE_BEHAVIOR.supportsPtySupervisor
+* is true, same as claude-code). sendMessage delegates to the existing generic
+* deliverAgentMessage() cascade (supervisor -> channels -> async tmux paste)
+* rather than re-implementing that tiering here — deliverAgentMessage already
+* dispatches on socket existence, not a hardcoded harness list, so kimi-code
+* flows through it for free once its PTY supervisor socket exists.
+*
+* getTokenUsage/getSessionCost delegate to wi8b's parseKimiSessionSync,
+* which sums every usage.record in the wire.jsonl — Kimi's own server-side
+* context cache accounting.
+*/
+/**
+* Compute Kimi's on-disk workDirKey bucket name for a working directory.
+* Verified against `wd_kimi-fixture-scratch_ef33f89ad7cf` (workDir
+* `/tmp/kimi-fixture-scratch`) and several pre-existing real sessions on the
+* machine that produced the wi-fixture capture (e.g.
+* `wd_overdeck_b289e7acb782`, `wd_feature-pan-2858_1dc66dc5021d`).
+*/
+function kimiWorkDirKey(workDir) {
+	const hash = createHash$1("sha256").update(workDir).digest("hex").slice(0, 12);
+	return `wd_${basename(workDir)}_${hash}`;
+}
+/** Absolute path to the session bucket Kimi writes for a working directory. */
+function kimiSessionsRoot(kimiHome, workDir) {
+	return join(kimiHome, "sessions", kimiWorkDirKey(workDir));
+}
+/**
+* Locate wire.jsonl for a specific captured session id under the workspace's
+* bucket. Falls back to the newest session directory when the captured id's
+* wire.jsonl is missing (e.g. never captured, or the id file is stale).
+*/
+function findKimiWirePath(kimiHome, workspace, sessionId) {
+	if (sessionId) {
+		const candidate = join(kimiSessionsRoot(kimiHome, workspace), sessionId, "agents", "main", "wire.jsonl");
+		if (existsSync$1(candidate)) return candidate;
+	}
+	return findLatestKimiSession(kimiHome, workspace);
+}
+/** Fallback: the newest session directory by wire.jsonl mtime under the workspace's bucket. */
+function findLatestKimiSession(kimiHome, workspace) {
+	const bucketDir = kimiSessionsRoot(kimiHome, workspace);
+	let entries;
+	try {
+		entries = readdirSync$1(bucketDir);
+	} catch {
+		return null;
+	}
+	let newest = null;
+	for (const entry of entries) {
+		const wirePath = join(bucketDir, entry, "agents", "main", "wire.jsonl");
+		let mtimeMs;
+		try {
+			mtimeMs = statSync$1(wirePath).mtimeMs;
+		} catch {
+			continue;
+		}
+		if (!newest || mtimeMs > newest.mtimeMs) newest = {
+			path: wirePath,
+			mtimeMs
+		};
+	}
+	return newest?.path ?? null;
+}
+/**
+* Async twin of {@link findKimiWirePath} (PAN-1837 review fix, P2). The
+* dashboard's transcript resolver runs on the event loop and Command Deck
+* polling re-resolves the same session repeatedly, so the sync
+* readdirSync/statSync walk here would block the loop on every poll as a
+* session's history grows. Runtime-side sync callers (kill/spawn lifecycle)
+* keep using the sync versions above — this pair exists only for dashboard
+* routes, per the runtime's own documented sync contract.
+*/
+async function findKimiWirePathAsync(kimiHome, workspace, sessionId) {
+	if (sessionId) {
+		const candidate = join(kimiSessionsRoot(kimiHome, workspace), sessionId, "agents", "main", "wire.jsonl");
+		try {
+			await stat(candidate);
+			return candidate;
+		} catch {}
+	}
+	return findLatestKimiSessionAsync(kimiHome, workspace);
+}
+/** Async twin of {@link findLatestKimiSession} — see {@link findKimiWirePathAsync}. */
+async function findLatestKimiSessionAsync(kimiHome, workspace) {
+	const bucketDir = kimiSessionsRoot(kimiHome, workspace);
+	let entries;
+	try {
+		entries = await readdir(bucketDir);
+	} catch {
+		return null;
+	}
+	let newest = null;
+	for (const entry of entries) {
+		const wirePath = join(bucketDir, entry, "agents", "main", "wire.jsonl");
+		let mtimeMs;
+		try {
+			mtimeMs = (await stat(wirePath)).mtimeMs;
+		} catch {
+			continue;
+		}
+		if (!newest || mtimeMs > newest.mtimeMs) newest = {
+			path: wirePath,
+			mtimeMs
+		};
+	}
+	return newest?.path ?? null;
+}
+function kimiHomeDefault() {
+	return join(homedir$1(), ".kimi-code");
+}
+/**
+* Poll a workspace's Kimi session bucket for a directory that did not exist
+* in `existingBefore`, returning the newest such directory's name (the
+* session id) once one appears. Standalone so both KimiCodeRuntimeSync.spawnAgent
+* and the production `pan start` spawn path (spawn-prep.ts, which builds its
+* own launcher/tmux session rather than delegating to this class) can capture
+* the session id the same way — mirroring codex's standalone
+* waitForCodexRollout/extractThreadIdFromRollout pair.
+*/
+async function waitForNewKimiSession(kimiHome, workspace, existingBefore, timeoutMs = SPAWN_READY_TIMEOUT_MS$1) {
+	const bucketDir = kimiSessionsRoot(kimiHome, workspace);
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		let entries = [];
+		try {
+			entries = readdirSync$1(bucketDir);
+		} catch {
+			entries = [];
+		}
+		const fresh = entries.filter((entry) => !existingBefore.has(entry));
+		if (fresh.length > 0) {
+			let newest = null;
+			for (const name of fresh) {
+				let mtimeMs;
+				try {
+					mtimeMs = statSync$1(join(bucketDir, name)).mtimeMs;
+				} catch {
+					continue;
+				}
+				if (!newest || mtimeMs > newest.mtimeMs) newest = {
+					name,
+					mtimeMs
+				};
+			}
+			if (newest) return newest.name;
+		}
+		await delay(POLL_INTERVAL_MS);
+	}
+	return null;
+}
+/**
+* Async twin of {@link waitForNewKimiSession} (PAN-1837 review fix, P2). The
+* conversation-spawn capture task runs on the dashboard event loop, so its
+* 250ms poll loop must not block on readdirSync/statSync — runtime-side sync
+* callers (kill/spawn lifecycle) keep the sync version above.
+*/
+async function waitForNewKimiSessionAsync(kimiHome, workspace, existingBefore, timeoutMs = SPAWN_READY_TIMEOUT_MS$1) {
+	const bucketDir = kimiSessionsRoot(kimiHome, workspace);
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		let entries = [];
+		try {
+			entries = await readdir(bucketDir);
+		} catch {
+			entries = [];
+		}
+		const fresh = entries.filter((entry) => !existingBefore.has(entry));
+		if (fresh.length > 0) {
+			let newest = null;
+			for (const name of fresh) {
+				let mtimeMs;
+				try {
+					mtimeMs = (await stat(join(bucketDir, name))).mtimeMs;
+				} catch {
+					continue;
+				}
+				if (!newest || mtimeMs > newest.mtimeMs) newest = {
+					name,
+					mtimeMs
+				};
+			}
+			if (newest) return newest.name;
+		}
+		await delay(POLL_INTERVAL_MS);
+	}
+	return null;
+}
+/** Persist the captured session id to `<overdeckHome>/agents/<id>/kimi-session-id` (mirrors codex's thread-id file). */
+function writeKimiSessionId(agentId, sessionId, overdeckHome = getOverdeckHome()) {
+	writeFileSync$1(join(overdeckHome, "agents", agentId, "kimi-session-id"), sessionId, "utf-8");
+}
+/** Deterministic, filesystem-safe lock path for a Kimi session bucket. */
+function kimiCaptureLockPath(bucketKey, overdeckHome = getOverdeckHome()) {
+	return join(overdeckHome, "locks", "kimi-capture", `${createHash$1("sha256").update(bucketKey).digest("hex").slice(0, 24)}.lock`);
+}
+async function readKimiCaptureLockOwner(lockPath) {
+	try {
+		const parsed = JSON.parse(await readFile(join(lockPath, "owner.json"), "utf8"));
+		if (typeof parsed.pid !== "number" || !Number.isInteger(parsed.pid) || parsed.pid <= 0) return {};
+		return parsed;
+	} catch {
+		return {};
+	}
+}
+/**
+* True once the lock directory itself (not owner.json) is older than the
+* stale-age bound. mkdir sets this directory's mtime at creation, and it is
+* never touched again once owner.json (a fresh directory entry) — if ever
+* written — settles, so this is trustworthy even when owner.json itself
+* never made it to disk.
+*/
+async function isKimiCaptureLockDirStale(lockPath) {
+	try {
+		const dirStat = await stat(lockPath);
+		return Date.now() - dirStat.mtimeMs > KIMI_CAPTURE_LOCK_STALE_AGE_MS;
+	} catch {
+		return true;
+	}
+}
+async function acquireKimiCaptureLock(lockPath) {
+	await mkdir(dirname(lockPath), {
+		recursive: true,
+		mode: 448
+	});
+	const deadline = Date.now() + KIMI_CAPTURE_LOCK_MAX_WAIT_MS;
+	for (;;) {
+		try {
+			await mkdir(lockPath, { mode: 448 });
+			const owner = {
+				pid: process.pid,
+				acquiredAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			const tmpPath = join(lockPath, `owner.${process.pid}.${Date.now()}.tmp`);
+			try {
+				await writeFile(tmpPath, JSON.stringify(owner, null, 2), "utf8");
+				await rename(tmpPath, join(lockPath, "owner.json"));
+			} catch (error) {
+				try {
+					await rm(tmpPath, { force: true });
+				} catch {}
+				try {
+					await rm(lockPath, {
+						recursive: true,
+						force: true
+					});
+				} catch {}
+				throw error;
+			}
+			return;
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			const owner = await readKimiCaptureLockOwner(lockPath);
+			if (owner.pid !== void 0) {
+				if (isPidDead(owner.pid)) {
+					await rm(lockPath, {
+						recursive: true,
+						force: true
+					});
+					continue;
+				}
+			} else if (await isKimiCaptureLockDirStale(lockPath)) {
+				await rm(lockPath, {
+					recursive: true,
+					force: true
+				});
+				continue;
+			}
+		}
+		if (Date.now() >= deadline) throw new KimiCaptureLockTimeoutError(lockPath, KIMI_CAPTURE_LOCK_MAX_WAIT_MS);
+		await delay(KIMI_CAPTURE_LOCK_POLL_MS);
+	}
+}
+async function releaseKimiCaptureLock(lockPath) {
+	await rm(lockPath, {
+		recursive: true,
+		force: true
+	});
+}
+async function withKimiSessionCaptureLock(kimiHome, workspace, fn, overdeckHome) {
+	const lockPath = kimiCaptureLockPath(kimiSessionsRoot(kimiHome, workspace), overdeckHome);
+	await acquireKimiCaptureLock(lockPath);
+	try {
+		return await fn();
+	} finally {
+		await releaseKimiCaptureLock(lockPath);
+	}
+}
+/**
+* Launch one managed native Kimi session and persist the identity required by
+* the first-message context guard before any caller can deliver a prompt.
+* Fresh launches snapshot and capture a newly-created native session under the
+* per-workspace lock. Resumes pass `-S` at launcher construction time, reuse
+* that exact identity, and therefore do not wait for a new directory.
+*/
+async function launchAndCaptureManagedKimiSession(options) {
+	const kimiHome = options.kimiHome ?? join(homedir$1(), ".kimi-code");
+	return withKimiSessionCaptureLock(kimiHome, options.workspace, async () => {
+		if (options.resumeSessionId) {
+			await options.launch();
+			writeKimiSessionId(options.agentId, options.resumeSessionId, options.overdeckHome);
+			return options.resumeSessionId;
+		}
+		let existingBefore = /* @__PURE__ */ new Set();
+		try {
+			existingBefore = new Set(await readdir(kimiSessionsRoot(kimiHome, options.workspace)));
+		} catch {}
+		await options.launch();
+		const sessionId = await waitForNewKimiSessionAsync(kimiHome, options.workspace, existingBefore, options.timeoutMs);
+		if (!sessionId) throw new KimiCodeSpawnTimeout(options.agentId);
+		writeKimiSessionId(options.agentId, sessionId, options.overdeckHome);
+		return sessionId;
+	}, options.overdeckHome);
+}
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shellQuote$1(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function pollUntilSessionGone$1(agentId, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (!await tmuxSessionExists(agentId)) return true;
+		await delay(POLL_INTERVAL_MS);
+	}
+	return false;
+}
+function createKimiCodeRuntimeSync(options = {}) {
+	return new KimiCodeRuntimeSync(options);
+}
+var execAsync$4, SPAWN_READY_TIMEOUT_MS$1, POLL_INTERVAL_MS, KimiCodeSpawnTimeout, KIMI_CAPTURE_LOCK_POLL_MS, KIMI_CAPTURE_LOCK_MAX_WAIT_MS, KIMI_CAPTURE_LOCK_STALE_AGE_MS, KimiCaptureLockTimeoutError, KimiCodeRuntimeSync;
+var init_kimi_code = __esmMin((() => {
+	init_tmux();
+	init_agent_state();
+	init_queries();
+	init_delivery();
+	init_pty_supervisor_locate();
+	init_pty_token();
+	init_launcher_generator();
+	init_harness_binary();
+	init_runtime_command();
+	init_kimi_context_envelope();
+	init_kimi_parser();
+	init_paths();
+	init_fs_lock();
+	init_behavior();
+	init_tmux_cli();
 	execAsync$4 = promisify(exec);
+	SPAWN_READY_TIMEOUT_MS$1 = 6e4;
+	POLL_INTERVAL_MS = 250;
+	KimiCodeSpawnTimeout = class extends Error {
+		code = "KIMI_CODE_SPAWN_TIMEOUT";
+		constructor(agentId) {
+			super(`Kimi Code agent ${agentId} did not write a new session under its workDirKey bucket within ${SPAWN_READY_TIMEOUT_MS$1}ms`);
+			this.name = "KimiCodeSpawnTimeout";
+		}
+	};
+	KIMI_CAPTURE_LOCK_POLL_MS = 250;
+	KIMI_CAPTURE_LOCK_MAX_WAIT_MS = 9e4;
+	KIMI_CAPTURE_LOCK_STALE_AGE_MS = 75e3;
+	KimiCaptureLockTimeoutError = class extends Error {
+		constructor(lockPath, waitedMs) {
+			super(`Timed out after ${waitedMs}ms waiting for the Kimi session-capture lock at ${lockPath} — another process is still holding it.`);
+			this.name = "KimiCaptureLockTimeoutError";
+		}
+	};
+	KimiCodeRuntimeSync = class {
+		name = "kimi-code";
+		overdeckHomeOverride;
+		kimiHomeOverride;
+		execCommand;
+		prepareLaunch;
+		resolveAgentStates;
+		deliverMessage;
+		resolveSupervisorScriptPath;
+		writePtyTokenFor;
+		constructor(options = {}) {
+			this.overdeckHomeOverride = options.overdeckHome;
+			this.kimiHomeOverride = options.kimiHome;
+			this.execCommand = options.execCommand ?? (async (command) => execAsync$4(command));
+			this.prepareLaunch = options.prepareLaunch ?? (() => prepareHarnessLaunch("kimi-code"));
+			this.resolveAgentStates = options.listAgentStates ?? (() => listAgentStates());
+			this.deliverMessage = options.deliverMessage ?? ((agentId, message, preparedKimiContext) => deliverAgentMessage(agentId, message, "runtime:kimi-code", void 0, { preparedKimiContext }));
+			this.resolveSupervisorScriptPath = options.resolveSupervisorScriptPath ?? resolvePtySupervisorScriptPath;
+			this.writePtyTokenFor = options.writePtyTokenFor ?? writePtyToken;
+		}
+		getHarnessBehavior() {
+			return getRuntimeBehavior("kimi-code");
+		}
+		getSessionPath(agentId) {
+			const workspace = this.workspaceFor(agentId);
+			if (!workspace) return null;
+			return findKimiWirePath(this.kimiHome(), workspace, this.readSessionId(agentId));
+		}
+		getLastActivity(agentId) {
+			const path = this.getSessionPath(agentId);
+			if (!path) return null;
+			try {
+				return statSync$1(path).mtime;
+			} catch {
+				return null;
+			}
+		}
+		getHeartbeat(agentId) {
+			const lastActivity = this.getLastActivity(agentId);
+			if (!lastActivity) return null;
+			return {
+				timestamp: lastActivity,
+				agentId,
+				source: "jsonl",
+				confidence: "medium"
+			};
+		}
+		getTokenUsage(agentId) {
+			const path = this.getSessionPath(agentId);
+			if (!path) return null;
+			return parseKimiSessionSync(path)?.usage ?? null;
+		}
+		getSessionCost(agentId) {
+			const path = this.getSessionPath(agentId);
+			if (!path) return null;
+			const parsed = parseKimiSessionSync(path);
+			if (!parsed) return null;
+			return {
+				inputCost: 0,
+				outputCost: 0,
+				cacheReadCost: 0,
+				cacheWriteCost: 0,
+				totalCost: parsed.cost_v2 ?? parsed.cost ?? 0,
+				currency: "USD"
+			};
+		}
+		async sendMessage(agentId, message) {
+			const result = await this.deliverMessage(agentId, message);
+			if (!result.ok) throw new Error(`Kimi Code agent ${agentId}: message delivery failed${result.failure ? ` (${result.failure})` : ""}`);
+		}
+		async killAgent(agentId) {
+			try {
+				await this.execCommand(`tmux -L ${shellQuote$1(getManagedTmuxSocketName())} send-keys -t ${shellQuote$1(agentId)} C-c 2>/dev/null || true`);
+			} catch {}
+			if (await pollUntilSessionGone$1(agentId, 2e3)) return;
+			let panePid = null;
+			try {
+				const { stdout } = await this.execCommand(`tmux -L ${shellQuote$1(getManagedTmuxSocketName())} list-panes -t ${shellQuote$1(agentId)} -F '#{pane_pid}' 2>/dev/null`);
+				panePid = stdout.trim() || null;
+				if (panePid) await this.execCommand(`kill -TERM -- -${panePid} 2>/dev/null || kill -TERM ${panePid} 2>/dev/null || true`);
+			} catch {}
+			if (await pollUntilSessionGone$1(agentId, 5e3)) return;
+			if (panePid) try {
+				await this.execCommand(`kill -KILL -- -${panePid} 2>/dev/null || kill -KILL ${panePid} 2>/dev/null || true`);
+			} catch {}
+			if (await tmuxSessionExists(agentId)) await tmuxKillSession(agentId);
+		}
+		async spawnAgent(config) {
+			const { pathExport } = await this.prepareLaunch();
+			const model = config.model ?? "";
+			const bucketDir = kimiSessionsRoot(this.kimiHome(), config.workspace);
+			let existingBefore = /* @__PURE__ */ new Set();
+			try {
+				existingBefore = new Set(readdirSync$1(bucketDir));
+			} catch {}
+			mkdirSync$1(join(this.home(), "agents", config.agentId), { recursive: true });
+			const supervisorScriptPath = this.resolveSupervisorScriptPath();
+			await this.writePtyTokenFor(config.agentId);
+			const launcherContent = generateLauncherScriptSync({
+				role: "work",
+				workingDir: config.workspace,
+				harness: "kimi-code",
+				kimiCodeModel: model,
+				kimiCodeEffort: config.effort,
+				kimiCodeYolo: true,
+				extraEnvExports: [pathExport],
+				overdeckEnv: { agentId: config.agentId },
+				setTerminalEnv: true,
+				useSupervisor: true,
+				supervisorScriptPath,
+				unsetProviderEnv: true,
+				kimiContextDelivery: "initial-message",
+				appendSystemPromptFiles: await claudeSystemPromptFiles(config.workspace, "kimi-code")
+			});
+			const launcherScript = this.agentPath(config.agentId, "launcher.sh");
+			writeFileSync$1(launcherScript, launcherContent, { mode: 493 });
+			await tmuxCreateSession(config.agentId, config.workspace, `bash ${shellQuote$1(launcherScript)}`, config.env ?? {});
+			try {
+				const sessionId = await this.waitForNewSessionId(config.workspace, existingBefore);
+				if (!sessionId) throw new KimiCodeSpawnTimeout(config.agentId);
+				this.writeSessionId(config.agentId, sessionId);
+				this.markSupervisorEnabled(config.agentId);
+				const initialMessage = await prepareKimiMessage(config.agentId, config.workspace, config.prompt ?? "", {
+					sessionId,
+					overdeckHome: this.home()
+				});
+				const delivery = await this.deliverMessage(config.agentId, initialMessage.message, initialMessage);
+				if (!delivery.ok) throw new Error(`Kimi Code agent ${config.agentId}: initial context delivery failed` + (delivery.failure ? ` (${delivery.failure})` : ""));
+				markKimiContextDelivered(config.agentId, initialMessage);
+				return {
+					id: config.agentId,
+					sessionId,
+					runtime: "kimi-code",
+					model,
+					workspace: config.workspace,
+					startedAt: /* @__PURE__ */ new Date()
+				};
+			} catch (error) {
+				if (await tmuxSessionExists(config.agentId)) await tmuxKillSession(config.agentId);
+				throw error;
+			}
+		}
+		listSessions(workspace) {
+			const sessions = [];
+			for (const state of this.resolveAgentStates()) {
+				if (state.harness !== "kimi-code") continue;
+				if (workspace && state.workspace !== workspace) continue;
+				const sessionId = this.readSessionId(state.id);
+				if (!sessionId) continue;
+				const sessionPath = findKimiWirePath(this.kimiHome(), state.workspace, sessionId);
+				let lastActivity;
+				try {
+					lastActivity = statSync$1(sessionPath ?? "").mtime;
+				} catch {
+					continue;
+				}
+				sessions.push({
+					id: sessionId,
+					agentId: state.id,
+					workspace: state.workspace,
+					model: state.model ?? "",
+					startedAt: new Date(state.startedAt),
+					lastActivity,
+					tokenUsage: {
+						inputTokens: 0,
+						outputTokens: 0
+					}
+				});
+			}
+			return sessions;
+		}
+		async isRunning(agentId) {
+			return tmuxSessionExists(agentId);
+		}
+		home() {
+			return this.overdeckHomeOverride ?? getOverdeckHome();
+		}
+		kimiHome() {
+			return this.kimiHomeOverride ?? kimiHomeDefault();
+		}
+		agentPath(agentId, file) {
+			return join(this.home(), "agents", agentId, file);
+		}
+		workspaceFor(agentId) {
+			return getAgentStateSync(agentId)?.workspace ?? null;
+		}
+		readSessionId(agentId) {
+			try {
+				return readFileSync$1(this.agentPath(agentId, "kimi-session-id"), "utf-8").trim() || null;
+			} catch {
+				return null;
+			}
+		}
+		writeSessionId(agentId, sessionId) {
+			writeKimiSessionId(agentId, sessionId, this.home());
+		}
+		/**
+		* Best-effort: mark the persisted agent state as supervisor-enabled so
+		* prepareSupervisorForRelaunch (supervisor-channels.ts) re-supervises this
+		* agent on relaunch instead of falling back to useSupervisor:false. A
+		* no-op when no state has been saved for this agent yet (some callers of
+		* this adapter's spawnAgent create state afterward).
+		*/
+		markSupervisorEnabled(agentId) {
+			const state = getAgentStateSync(agentId);
+			if (!state) return;
+			state.supervisorEnabled = true;
+			saveAgentStateSync(state);
+		}
+		async waitForNewSessionId(workspace, existingBefore) {
+			return waitForNewKimiSession(this.kimiHome(), workspace, existingBefore);
+		}
+	};
 }));
 //#endregion
+//#region ../../lib/agents/managed-kimi-delivery.ts
+/** Enforce native Kimi's mandatory context contract independently of role bookkeeping. */
+async function requireManagedKimiDelivery(options) {
+	if (options.harness !== "kimi-code" || options.delivery.ok) return;
+	await options.onFailure();
+	throw new Error(`Agent ${options.agentId} (${options.role}) managed Kimi context delivery failed: ` + (options.delivery.failure ?? `delivery returned ok=false via ${options.delivery.path}`));
+}
+var init_managed_kimi_delivery = __esmMin((() => {}));
+//#endregion
 //#region ../../lib/agents/spawn.ts
 async function spawnRun(issueId, role, options) {
 	if (role !== "work") return spawnRunWithoutConsentClaim(issueId, role, options);
@@ -6130,7 +7272,7 @@ async function spawnRunWithoutConsentClaim(issueId, role, options, acceptConsent
 		let reapWarmIdle = false;
 		const advancing = role === "review" || role === "test" || role === "ship";
 		try {
-			const { isPaneDead } = await import("./tmux-CYucGrTl.js");
+			const { isPaneDead } = await import("./tmux-aj9rscol.js");
 			if (await Effect.runPromise(isPaneDead(agentId))) reapWarmIdle = true;
 			else if (advancing) {
 				const { status } = resolveCanonicalReviewStatus(issueId);
@@ -6139,7 +7281,7 @@ async function spawnRunWithoutConsentClaim(issueId, role, options, acceptConsent
 		} 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-CYucGrTl.js");
+		const { killSession } = await import("./tmux-aj9rscol.js");
 		await Effect.runPromise(killSession(agentId)).catch(() => {});
 	}
 	await prepareWorkspaceForAgentSpawn(issueId, role, options.allowHost, workspace);
@@ -6154,7 +7296,7 @@ async function spawnRunWithoutConsentClaim(issueId, role, options, acceptConsent
 	assertCodexNativeAuthForSpawn(resolvedHarness, listAgentStates());
 	await ensureLifecycleHooksBeforeLaunch(agentId, resolvedHarness);
 	if (getProviderForModelSync(selectedModel).name === "openai" && await getProviderAuthMode(selectedModel) === "subscription") {
-		const { isCliproxyRunning } = await import("./cliproxy-DdhFpcXU.js");
+		const { isCliproxyRunning } = await import("./cliproxy-Dz_zq_4H.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 = {
@@ -6185,8 +7327,8 @@ async function spawnRunWithoutConsentClaim(issueId, role, options, acceptConsent
 	const shouldDeliverPromptViaTmux = shouldRegisterConversation && resolvedHarness === "claude-code";
 	const shouldDeliverPromptViaPi = shouldRegisterConversation && resolvedHarness === "ohmypi";
 	const shouldDeliverPromptViaCodexTui = shouldRegisterConversation && resolvedHarness === "codex";
-	const shouldDeliverPromptViaKimiCode = shouldRegisterConversation && resolvedHarness === "kimi-code";
-	const shouldDeliverPromptViaAcp = resolvedHarness === "acp";
+	const shouldDeliverPromptViaKimiCode = resolvedHarness === "muse" || resolvedHarness === "kimi-code";
+	const shouldDeliverPromptViaAcp = resolvedHarness === "acp" || resolvedHarness === "opencode";
 	const prompt = options.prompt ? await withSpawnTimeMemoryContext({
 		prompt: options.prompt,
 		issueId,
@@ -6212,15 +7354,23 @@ async function spawnRunWithoutConsentClaim(issueId, role, options, acceptConsent
 	}
 	const providerExports = isAcp ? void 0 : await getProviderExportsForModel(selectedModel, resolvedHarness);
 	const providerEnv = isAcp ? {} : await getProviderEnvForModel(selectedModel, resolvedHarness);
-	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) : {};
-	const kimiCodeLauncherFields = resolvedHarness === "kimi-code" ? getKimiCodeLauncherFields(selectedModel) : {};
+	const piLauncherFields = resolvedHarness === "ohmypi" ? await getOhmypiLauncherFields(agentId, selectedModel, options.effort) : {};
+	const codexLauncherFields = resolvedHarness === "codex" ? getCodexLauncherFields(agentId, selectedModel, workspace, role, options.effort) : {};
+	const acpLauncherFields = isAcp ? getAcpLauncherFields(agentId, selectedModel, workspace, harnessLaunch.binaryPath, role, options.effort) : {};
+	const museSavedSession = resolvedHarness === "muse" && options.resumeSessionId ? await resolveMuseSessionPath(agentId) : null;
+	const museLauncherFields = resolvedHarness === "muse" ? {
+		harness: "muse",
+		museModel: selectedModel,
+		museEffort: options.effort,
+		museContextFile: await materializeMuseContext(agentId, workspace, roleAgentDefinitionPath(role)),
+		museResumeSessionId: museSavedSession ? museSessionId(museSavedSession) : void 0
+	} : {};
+	const kimiCodeLauncherFields = resolvedHarness === "kimi-code" ? getKimiCodeLauncherFields(selectedModel, options.effort) : {};
 	let sessionId;
 	let rawSessionId;
 	if (shouldRegisterConversation) {
-		rawSessionId = isAcp ? options.resumeSessionId : options.resumeSessionId ?? randomUUID();
-		if (!isAcp && rawSessionId) try {
+		rawSessionId = isAcp || resolvedHarness === "kimi-code" ? options.resumeSessionId : options.resumeSessionId ?? randomUUID();
+		if (!isAcp && resolvedHarness !== "kimi-code" && rawSessionId) try {
 			const agentDir = getAgentDir(agentId);
 			await mkdir$1(agentDir, { recursive: true });
 			await writeFile$1(join$1(agentDir, "session.id"), rawSessionId, "utf-8");
@@ -6274,18 +7424,19 @@ async function spawnRunWithoutConsentClaim(issueId, role, options, acceptConsent
 		...piLauncherFields,
 		...codexLauncherFields,
 		...acpLauncherFields,
-		...kimiCodeLauncherFields
+		...kimiCodeLauncherFields,
+		...museLauncherFields
 	});
 	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-BrbX90Rm.js");
+		const { preTrustDirectory } = await import("./workspace-manager-D0jJ7StJ.js");
 		preTrustDirectory(workspace);
 	} catch {}
 	clearReadySignal(agentId);
-	await Effect.runPromise(createSession(agentId, workspace, claudeCmd, { env: {
+	const launchRoleSession = () => Effect.runPromise(createSession(agentId, workspace, claudeCmd, { env: {
 		...BLANKED_PROVIDER_ENV,
 		TERM: "xterm-256color",
 		OVERDECK_AGENT_ID: agentId,
@@ -6297,6 +7448,20 @@ async function spawnRunWithoutConsentClaim(issueId, role, options, acceptConsent
 		...flywheelEnv,
 		...providerEnv
 	} }));
+	if (resolvedHarness === "kimi-code") try {
+		rawSessionId = await launchAndCaptureManagedKimiSession({
+			agentId,
+			workspace,
+			launch: launchRoleSession,
+			resumeSessionId: options.resumeSessionId
+		});
+		if (shouldRegisterConversation) setConversationClaudeSessionId(agentId, rawSessionId);
+	} catch (error) {
+		const { killSession } = await import("./tmux-aj9rscol.js");
+		await Effect.runPromise(killSession(agentId)).catch(() => {});
+		throw error;
+	}
+	else await launchRoleSession();
 	if (shouldRegisterConversation) await saveAgentRuntimeState(agentId, {
 		claudeSessionId: rawSessionId,
 		...options.resumeSessionId ? {} : {
@@ -6306,7 +7471,7 @@ async function spawnRunWithoutConsentClaim(issueId, role, options, acceptConsent
 	});
 	await Effect.runPromise(setOption(agentId, "destroy-unattached", "off"));
 	await Effect.runPromise(setOption(exactPaneTarget(agentId), "remain-on-exit", "on"));
-	if (prompt) {
+	if (prompt || resolvedHarness === "kimi-code") {
 		if (shouldDeliverPromptViaAcp) try {
 			await waitForPromptReady(agentId, resolvedHarness, 30);
 			const delivery = await deliverAgentMessage(agentId, prompt, "spawnRun:initial-prompt");
@@ -6333,6 +7498,17 @@ async function spawnRunWithoutConsentClaim(issueId, role, options, acceptConsent
 		}
 		else if (shouldDeliverPromptViaTmux || shouldDeliverPromptViaCodexTui || shouldDeliverPromptViaKimiCode) if (tracksKickoffDelivery) {
 			const delivery = await deliverInitialPromptWithRetry(agentId, prompt, "spawnRun:initial-prompt");
+			await requireManagedKimiDelivery({
+				agentId,
+				role,
+				harness: resolvedHarness,
+				delivery,
+				onFailure: async () => {
+					if (delivery.failure === "session-exited-before-kickoff") await recordStartupSessionExit(state, issueId, role);
+					await recordKickoffDeliveryFailure(state, issueId, role);
+					await Effect.runPromise(stopAgent(agentId)).catch(() => {});
+				}
+			});
 			if (delivery.ok) {
 				state.kickoffDelivered = true;
 				await Effect.runPromise(saveAgentState(state));
@@ -6340,14 +7516,26 @@ async function spawnRunWithoutConsentClaim(issueId, role, options, acceptConsent
 				await recordStartupSessionExit(state, issueId, role);
 				return state;
 			}
-		} else if (await waitForPromptReady(agentId, resolvedHarness, 30)) {
-			await new Promise((resolve) => setTimeout(resolve, 500));
-			await deliverAgentMessage(agentId, prompt, "spawnRun:initial-prompt");
-		} else console.error(`[${agentId}] ${getHarnessBehavior(resolvedHarness).displayName} did not become ready within 30s`);
+		} else {
+			const timeout = getHarnessBehavior(resolvedHarness).readyTimeoutSeconds;
+			if (await waitForPromptReady(agentId, resolvedHarness, timeout)) {
+				await new Promise((resolve) => setTimeout(resolve, 500));
+				try {
+					const delivery = await deliverAgentMessage(agentId, prompt, "spawnRun:initial-prompt");
+					if (resolvedHarness === "kimi-code" && !delivery.ok) throw new Error(delivery.failure ?? `delivery returned ok=false via ${delivery.path}`);
+				} catch (error) {
+					if (resolvedHarness === "kimi-code") await Effect.runPromise(stopAgent(agentId)).catch(() => {});
+					throw error;
+				}
+			} else {
+				if (resolvedHarness === "kimi-code") await Effect.runPromise(stopAgent(agentId)).catch(() => {});
+				throw new Error(`[${agentId}] ${getHarnessBehavior(resolvedHarness).displayName} did not become ready within ${timeout}s`);
+			}
+		}
 	}
 	markAgentRunning(state);
 	try {
-		const { snapshotWorkspaceHeadsPromise } = await import("./git-utils-BAMwn9Nf.js");
+		const { snapshotWorkspaceHeadsPromise } = await import("./git-utils-DvcWLgGS.js");
 		const headAnchor = await snapshotWorkspaceHeadsPromise(issueId, workspace);
 		if (headAnchor) state.roleRunHead = headAnchor;
 	} catch {}
@@ -6389,7 +7577,7 @@ async function spawnAgentWithoutConsentClaim(options, acceptConsent) {
 	});
 	console.log(`[DEBUG] Selected model: ${selectedModel}`);
 	if (getProviderForModelSync(selectedModel).name === "openai" && await getProviderAuthMode(selectedModel) === "subscription") {
-		const { isCliproxyRunning } = await import("./cliproxy-DdhFpcXU.js");
+		const { isCliproxyRunning } = await import("./cliproxy-Dz_zq_4H.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({
@@ -6439,7 +7627,7 @@ async function spawnAgentWithoutConsentClaim(options, acceptConsent) {
 		});
 	}
 	if (role === "work") try {
-		const { writeStoryFeatureContext } = await import("./work-agent-prompt-BnhKNAg7.js");
+		const { writeStoryFeatureContext } = await import("./work-agent-prompt-Csr4vMbl.js");
 		await writeStoryFeatureContext(options.workspace, options.issueId);
 	} catch (ctxErr) {
 		console.warn(`[agents] Could not write story feature context for ${options.issueId}: ${ctxErr.message}`);
@@ -6486,7 +7674,7 @@ async function spawnAgentWithoutConsentClaim(options, acceptConsent) {
 	try {
 		const venvPath = join$1(options.workspace, ".venv");
 		if (isTldrEnabledSync() && existsSync(venvPath)) {
-			const { getTldrDaemonServiceSync } = await import("./tldr-daemon-CRSAkhBx.js");
+			const { getTldrDaemonServiceSync } = await import("./tldr-daemon-CW1MhBkM.js");
 			const tldrService = getTldrDaemonServiceSync(options.workspace, venvPath);
 			if (!(await tldrService.getStatus()).running) {
 				await tldrService.start(true);
@@ -6526,13 +7714,13 @@ async function spawnAgentWithoutConsentClaim(options, acceptConsent) {
 	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-BrbX90Rm.js");
+		const { preTrustDirectory } = await import("./workspace-manager-D0jJ7StJ.js");
 		preTrustDirectory(options.workspace);
 	} catch {}
 	try {
-		const { isGitHubAppConfigured, generateInstallationToken, configureWorkspaceForBot } = await import("./github-app-BWziYCf3.js");
+		const { isGitHubAppConfigured, generateInstallationToken, configureWorkspaceForBot } = await import("./github-app-BxM1U38q.js");
 		if (isGitHubAppConfigured()) {
-			const { findProjectByPathSync } = await import("./projects-BMuEf14J.js");
+			const { findProjectByPathSync } = await import("./projects-DXgHD2Xl.js");
 			const ghRepo = findProjectByPathSync(resolve$1(options.workspace, "..", ".."))?.github_repo;
 			if (ghRepo) {
 				const [owner, repo] = ghRepo.split("/");
@@ -6545,42 +7733,29 @@ async function spawnAgentWithoutConsentClaim(options, acceptConsent) {
 		console.warn(`[${agentId}] GitHub App config failed (falling back to SSH): ${err.message}`);
 	}
 	clearReadySignal(agentId);
-	const launchAndCaptureKimiSession = async () => {
-		let kimiExistingSessionsBefore;
-		if (resolvedHarness === "kimi-code") try {
-			const { kimiSessionsRoot } = await import("./kimi-code-BxkDgaj4.js");
-			kimiExistingSessionsBefore = new Set(await readdir$1(kimiSessionsRoot(join$1(homedir(), ".kimi-code"), options.workspace)));
-		} catch {
-			kimiExistingSessionsBefore = /* @__PURE__ */ new Set();
-		}
-		await Effect.runPromise(createSession(agentId, options.workspace, claudeCmd, { env: {
-			...BLANKED_PROVIDER_ENV,
-			TERM: "xterm-256color",
-			OVERDECK_AGENT_ID: agentId,
-			OVERDECK_ISSUE_ID: options.issueId,
-			OVERDECK_SESSION_TYPE: role,
-			OVERDECK_AGENT_STARTED_BY: startedBy,
-			CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION: "false",
-			GIT_SEQUENCE_EDITOR: "false",
-			...flywheelEnv,
-			...providerEnv
-		} }));
-		if (kimiExistingSessionsBefore) {
-			const { waitForNewKimiSessionAsync, writeKimiSessionId } = await import("./kimi-code-BxkDgaj4.js");
-			const sessionId = await waitForNewKimiSessionAsync(join$1(homedir(), ".kimi-code"), options.workspace, kimiExistingSessionsBefore);
-			if (sessionId) writeKimiSessionId(agentId, sessionId);
-			else throw new Error(`kimi-code session capture timed out for ${agentId} — no new session directory appeared under the workspace bucket`);
-		}
-	};
-	if (resolvedHarness === "kimi-code") {
-		const { withKimiSessionCaptureLock } = await import("./kimi-code-BxkDgaj4.js");
-		try {
-			await withKimiSessionCaptureLock(join$1(homedir(), ".kimi-code"), options.workspace, launchAndCaptureKimiSession);
-		} catch (err) {
-			await Effect.runPromise(stopAgent(agentId)).catch(() => void 0);
-			throw err;
-		}
-	} else await launchAndCaptureKimiSession();
+	const launchWorkSession = () => Effect.runPromise(createSession(agentId, options.workspace, claudeCmd, { env: {
+		...BLANKED_PROVIDER_ENV,
+		TERM: "xterm-256color",
+		OVERDECK_AGENT_ID: agentId,
+		OVERDECK_ISSUE_ID: options.issueId,
+		OVERDECK_SESSION_TYPE: role,
+		OVERDECK_AGENT_STARTED_BY: startedBy,
+		CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION: "false",
+		GIT_SEQUENCE_EDITOR: "false",
+		...flywheelEnv,
+		...providerEnv
+	} }));
+	if (resolvedHarness === "kimi-code") try {
+		await launchAndCaptureManagedKimiSession({
+			agentId,
+			workspace: options.workspace,
+			launch: launchWorkSession
+		});
+	} catch (err) {
+		await Effect.runPromise(stopAgent(agentId)).catch(() => void 0);
+		throw err;
+	}
+	else await launchWorkSession();
 	await acceptConsent?.();
 	await saveAgentRuntimeState(agentId, {
 		claudeSessionId: state.sessionId,
@@ -6617,9 +7792,22 @@ async function spawnAgentWithoutConsentClaim(options, acceptConsent) {
 			throw new Error(`Agent ${agentId} kickoff delivery failed: ${err instanceof Error ? err.message : String(err)}`);
 		}
 	}
-	else if (prompt) {
+	else if (prompt || resolvedHarness === "kimi-code") {
 		if (dismissChannelsDialogPromise) await dismissChannelsDialogPromise;
 		const delivery = await deliverInitialPromptWithRetry(agentId, prompt, "spawnAgent:initial-prompt", state.deliveryMethod);
+		await requireManagedKimiDelivery({
+			agentId,
+			role,
+			harness: resolvedHarness,
+			delivery,
+			onFailure: async () => {
+				if (tracksKickoffDelivery) {
+					if (delivery.failure === "session-exited-before-kickoff") await recordStartupSessionExit(state, options.issueId, role);
+					await recordKickoffDeliveryFailure(state, options.issueId, role);
+				}
+				await Effect.runPromise(stopAgent(agentId)).catch(() => {});
+			}
+		});
 		if (delivery.ok) {
 			if (tracksKickoffDelivery) {
 				state.kickoffDelivered = true;
@@ -6633,10 +7821,10 @@ async function spawnAgentWithoutConsentClaim(options, acceptConsent) {
 		}
 	}
 	if (resolvedHarness === "codex" && loadConfigSync().config.codex?.transport === "tui" && getHarnessBehavior(resolvedHarness).readinessKind === "codex-tui-prompt") {
-		const codexHomeForAgent = join$1(homedir(), ".overdeck", "agents", agentId, "codex-home");
+		const codexHomeForAgent = join$1(homedir(), ".overdeck", "agents", agentId, "codex-home-v2");
 		(async () => {
 			try {
-				const { waitForCodexRollout, extractThreadIdFromRollout, writeThreadId } = await import("./codex-BValsmtK.js");
+				const { waitForCodexRollout, extractThreadIdFromRollout, writeThreadId } = await import("./codex-DzLXjzbf.js");
 				const rollout = await waitForCodexRollout(codexHomeForAgent, 12e4);
 				if (rollout) {
 					const threadId = extractThreadIdFromRollout(rollout);
@@ -6688,6 +7876,8 @@ function writeTaskCache(agentId, issueId) {
 }
 var execAsync$3;
 var init_spawn = __esmMin((() => {
+	init_muse_context();
+	init_muse_session();
 	init_activity_logger();
 	init_child_env();
 	init_config_yaml();
@@ -6727,6 +7917,8 @@ var init_spawn = __esmMin((() => {
 	init_auto_spawn_consent();
 	init_provenance();
 	init_registered_slot_spawn();
+	init_kimi_code();
+	init_managed_kimi_delivery();
 	execAsync$3 = promisify$1(exec$1);
 }));
 //#endregion
@@ -7597,7 +8789,7 @@ function queueAgentMail(agentId, message, kind = "queued", dedupKey, source) {
 	return mailPath;
 }
 function resolveAgentDeliveryMethod(state) {
-	if (state?.harness === "acp") return "auto";
+	if (state?.harness === "acp" || state?.harness === "opencode") return "auto";
 	return resilientDeliveryMethod(state?.deliveryMethod);
 }
 function claimCodexIdleTurn(agentId) {
@@ -7638,7 +8830,7 @@ function deliverWithOptionalKey(normalizedId, message, caller, deliveryMethod, d
 * at-most-once across the whole replay window.
 */
 async function resumeThenDeliverKeyed(normalizedId, message, caller, agentState, dedupKey) {
-	const { resumeAgent } = await import("./agents-DixZjXWm.js");
+	const { resumeAgent } = await import("./agents-BVvL4o_4.js");
 	const result = await resumeAgent(normalizedId);
 	if (!result.success) throw new Error(`Failed to auto-resume agent: ${result.error}`);
 	const delivery = await deliverAgentMessage(normalizedId, message, `messageAgent:${caller}`, resolveAgentDeliveryMethod(agentState), { dedupKey });
@@ -7693,7 +8885,7 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 		}
 		console.log(`[agents] Auto-resuming suspended agent ${normalizedId} to deliver message`);
 		if (opts.dedupKey !== void 0) return resumeThenDeliverKeyed(normalizedId, message, caller, agentState, opts.dedupKey);
-		const { resumeAgent } = await import("./agents-DixZjXWm.js");
+		const { resumeAgent } = await import("./agents-BVvL4o_4.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.`);
@@ -7718,7 +8910,7 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 		}
 		console.log(`[agents] Auto-resuming stopped agent ${normalizedId} to deliver feedback (session exists: ${await Effect.runPromise(sessionExists(normalizedId))})`);
 		if (opts.dedupKey !== void 0) return resumeThenDeliverKeyed(normalizedId, message, caller, agentState, opts.dedupKey);
-		const { resumeAgent } = await import("./agents-DixZjXWm.js");
+		const { resumeAgent } = await import("./agents-BVvL4o_4.js");
 		const resumeResult = await resumeAgent(normalizedId, message);
 		queueAgentMail(normalizedId, message);
 		if (resumeResult.success && resumeResult.messageDelivered !== false) {
@@ -7762,7 +8954,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-DixZjXWm.js");
+		const { assertWorkspaceStackHealthyForSpawn } = await import("./agents-BVvL4o_4.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) : {};
@@ -7776,6 +8968,12 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 			extraEnvExports: [harnessLaunch.pathExport],
 			baseCommand: await getRoleRuntimeBaseCommand(resumeModel, normalizedId, resumeRole, fallbackHarness),
 			appendSystemPromptFiles: await claudeSystemPromptFiles(agentState.workspace, fallbackHarness),
+			managedStateKey: normalizedId,
+			overdeckEnv: {
+				agentId: normalizedId,
+				issueId: agentState.issueId,
+				sessionType: resumeRole
+			},
 			useSupervisor: fallbackSupervisorLaunch.useSupervisor,
 			supervisorScriptPath: fallbackSupervisorLaunch.supervisorScriptPath,
 			...fallbackPiFields,
@@ -7845,12 +9043,12 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 			...reason ? { reason } : {}
 		};
 	}
-	const { loadRemoteAgentState, sendToRemoteAgent } = await import("./remote-agents-MuXx2gWm.js");
+	const { loadRemoteAgentState, sendToRemoteAgent } = await import("./remote-agents-CEOvYsvK.js");
 	const remoteState = loadRemoteAgentState(normalizedId);
 	if (remoteState && remoteState.vmName) {
 		console.log(`[agents] Sending message to remote agent ${normalizedId} on ${remoteState.vmName}`);
 		if (opts.dedupKey !== void 0) {
-			const { sendToRemoteAgentKeyed } = await import("./remote-agents-MuXx2gWm.js");
+			const { sendToRemoteAgentKeyed } = await import("./remote-agents-CEOvYsvK.js");
 			const remoteOutcome = await sendToRemoteAgentKeyed(normalizedId, remoteState.vmName, message, opts.dedupKey);
 			queueAgentMail(normalizedId, message, "delivered", opts.dedupKey);
 			await appendTellInterventionForUserSource(normalizedId, caller);
@@ -7914,7 +9112,7 @@ async function messageAgent(agentId, message, caller = "internal", opts = {}) {
 	if (panePids.length > 0 && !await hasAgentRuntimeInSubtree(panePids[0], expectedHarness)) {
 		console.warn(`[agents] ${normalizedId} tmux session is a zombie (no ${expectedHarness} runtime) — attempting resume`);
 		if (opts.dedupKey !== void 0) return resumeThenDeliverKeyed(normalizedId, message, caller, agentState, opts.dedupKey);
-		const { resumeAgent } = await import("./agents-DixZjXWm.js");
+		const { resumeAgent } = await import("./agents-BVvL4o_4.js");
 		const resumeResult = await resumeAgent(normalizedId, message);
 		if (resumeResult.success) {
 			const delivered = resumeResult.messageDelivered !== false;
@@ -8282,6 +9480,51 @@ var init_resume_pane_choice = __esmMin((() => {
 	];
 }));
 //#endregion
+//#region ../../lib/review-lifecycle-guard.ts
+/** Return the issue owned by a review parent or convoy member agent id. */
+function reviewIssueIdForAgent(agentId) {
+	return /^agent-([a-z]+-\d+)-review(?:-|$)/i.exec(agentId)?.[1]?.toUpperCase() ?? null;
+}
+/**
+* Serialize review-family lifecycle mutations for one issue.
+*
+* Dispatch owns this guard across stop, state wipe, and replacement spawn.
+* Direct review-family resumes enter through the same guard. Calls made by a
+* guarded dispatch are re-entrant because dispatch legitimately warm-resumes
+* the parent and convoy members while it owns the replacement sequence.
+*/
+async function withReviewLifecycleGuard(issueId, operation) {
+	const key = issueId.toUpperCase();
+	const held = heldReviewLifecycles.getStore();
+	if (held?.has(key)) return operation();
+	const previous = reviewLifecycleTails.get(key) ?? Promise.resolve();
+	let release = () => {};
+	const current = new Promise((resolve) => {
+		release = resolve;
+	});
+	const tail = previous.catch(() => void 0).then(() => current);
+	reviewLifecycleTails.set(key, tail);
+	await previous.catch(() => void 0);
+	try {
+		const nextHeld = new Set(held);
+		nextHeld.add(key);
+		return await heldReviewLifecycles.run(nextHeld, operation);
+	} finally {
+		release();
+		if (reviewLifecycleTails.get(key) === tail) reviewLifecycleTails.delete(key);
+	}
+}
+/** Run review-family agents under their issue guard; leave other agents alone. */
+async function withReviewLifecycleGuardForAgent(agentId, operation) {
+	const issueId = reviewIssueIdForAgent(agentId);
+	return issueId ? withReviewLifecycleGuard(issueId, operation) : operation();
+}
+var reviewLifecycleTails, heldReviewLifecycles;
+var init_review_lifecycle_guard = __esmMin((() => {
+	reviewLifecycleTails = /* @__PURE__ */ new Map();
+	heldReviewLifecycles = new AsyncLocalStorage();
+}));
+//#endregion
 //#region ../../lib/agents/resume.ts
 /**
 * Resume a suspended agent (PAN-80)
@@ -8314,7 +9557,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-DzMXGRiJ.js"), import("./smart-compaction-CUXn8mfX.js")]);
+			const [{ getConversationCompactionSettings }, { generateSmartSummary }] = await Promise.all([import("./conversation-compaction-D0zgWM1f.js"), import("./smart-compaction-owKHJDbL.js")]);
 			const settings = getConversationCompactionSettings();
 			summary = (await Effect.runPromise(generateSmartSummary({
 				jsonlPath: sessionFile,
@@ -8325,7 +9568,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-CojrFKb6.js");
+				const { generateFallbackSummary } = await import("./summary-fork-PLcckTRE.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`);
@@ -8339,6 +9582,9 @@ async function buildCompactRecoverySeed(agentId) {
 }
 async function resumeAgent(agentId, message, opts) {
 	const normalizedId = normalizeAgentId(agentId);
+	return withReviewLifecycleGuardForAgent(normalizedId, () => resumeAgentWithinLifecycle(normalizedId, message, opts));
+}
+async function resumeAgentWithinLifecycle(normalizedId, message, opts) {
 	const requestedModel = normalizeModelOverrideSync(opts?.model);
 	logAgentLifecycleSync(normalizedId, `resumeAgent called (message=${message ? "yes" : "no"}, harness=${opts?.harness || "unchanged"})`);
 	const runtimeState = getAgentRuntimeStateSync(normalizedId);
@@ -8561,7 +9807,7 @@ 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 === "acp") {
+		else if (effectiveHarness === "acp" || effectiveHarness === "opencode") {
 			const delivery = await deliverInitialPromptWithRetry(normalizedId, effectiveMessage, "resumeAgent:acp-continue");
 			messageDelivered = delivery.ok;
 			if (delivery.ok && resumeMessage.redeliveringKickoff) markKickoffRedelivered(agentState);
@@ -8726,6 +9972,7 @@ var init_resume = __esmMin((() => {
 	init_supervisor_channels();
 	init_spawn_prep();
 	init_resume_contract();
+	init_review_lifecycle_guard();
 }));
 //#endregion
 //#region ../../lib/graceful-restart.ts
@@ -9624,7 +10871,11 @@ var init_pending_decision_gate = __esmMin((() => {
 //#endregion
 //#region ../../lib/agents/recovery.ts
 function resolveRecoveryResumeSessionId(agentId, harness) {
-	if (harness !== "codex" && harness !== "acp" && harness !== "kimi-code") return void 0;
+	if (harness === "muse") {
+		const path = resolveMuseSessionPathSync(agentId);
+		return path ? museSessionId(path) : void 0;
+	}
+	if (harness !== "codex" && harness !== "acp" && harness !== "kimi-code" && harness !== "opencode") return void 0;
 	return getLatestSessionIdSync(agentId) ?? void 0;
 }
 async function restartAgent(agentId, opts = {}, deps = {}) {
@@ -9729,7 +10980,7 @@ async function restartAgent(agentId, opts = {}, deps = {}) {
 					unlinkSync(join$1(getAgentDir(normalizedId), "kimi-session-id"));
 				} catch {}
 				try {
-					const { kimiSessionsRoot } = await import("./kimi-code-BxkDgaj4.js");
+					const { kimiSessionsRoot } = await import("./kimi-code-Cx5YUJpS.js");
 					kimiExistingSessionsBefore = new Set(await readdir$1(kimiSessionsRoot(join$1(homedir(), ".kimi-code"), agentState.workspace)));
 				} catch {
 					kimiExistingSessionsBefore = /* @__PURE__ */ new Set();
@@ -9746,14 +10997,14 @@ async function restartAgent(agentId, opts = {}, deps = {}) {
 				...providerEnv
 			} }));
 			if (kimiExistingSessionsBefore) {
-				const { waitForNewKimiSessionAsync, writeKimiSessionId } = await import("./kimi-code-BxkDgaj4.js");
+				const { waitForNewKimiSessionAsync, writeKimiSessionId } = await import("./kimi-code-Cx5YUJpS.js");
 				const sessionId = await waitForNewKimiSessionAsync(join$1(homedir(), ".kimi-code"), agentState.workspace, kimiExistingSessionsBefore);
 				if (!sessionId) throw new Error(`kimi-code session capture timed out after fresh relaunch for ${normalizedId} — no new session directory appeared under the workspace bucket`);
 				writeKimiSessionId(normalizedId, sessionId);
 			}
 		};
 		if (effectiveHarness === "kimi-code") {
-			const { withKimiSessionCaptureLock } = await import("./kimi-code-BxkDgaj4.js");
+			const { withKimiSessionCaptureLock } = await import("./kimi-code-Cx5YUJpS.js");
 			await withKimiSessionCaptureLock(join$1(homedir(), ".kimi-code"), agentState.workspace, launchAndCaptureKimiSession);
 		} else await launchAndCaptureKimiSession();
 		const prompt = message || buildResumeContinueMessage(agentState);
@@ -9764,9 +11015,10 @@ async function restartAgent(agentId, opts = {}, deps = {}) {
 			console.error(`[restartAgent] ohmypi prompt delivery failed for ${normalizedId}: ${msg}`);
 		}
 		else {
-			if (!await waitForPromptReady(normalizedId, effectiveHarness, 30)) throw new Error(`${getHarnessBehavior(effectiveHarness).displayName} did not become ready within 30s for ${normalizedId}`);
+			const timeout = getHarnessBehavior(effectiveHarness).readyTimeoutSeconds;
+			if (!await waitForPromptReady(normalizedId, effectiveHarness, timeout)) throw new Error(`${getHarnessBehavior(effectiveHarness).displayName} did not become ready within ${timeout}s for ${normalizedId}`);
 			await new Promise((r) => setTimeout(r, 500));
-			if (effectiveHarness === "codex" || effectiveHarness === "acp" || effectiveHarness === "kimi-code") {
+			if (effectiveHarness === "codex" || effectiveHarness === "acp" || effectiveHarness === "kimi-code" || effectiveHarness === "opencode" || effectiveHarness === "muse") {
 				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));
 		}
@@ -9878,13 +11130,13 @@ async function recoverAgent(agentId, opts = {}) {
 	health.recoveryCount = (health.recoveryCount || 0) + 1;
 	writeFileSync(healthFile, JSON.stringify(health, null, 2));
 	const recoveryPrompt = generateRecoveryPrompt(state);
-	const providerEnv = state.model ? await getProviderEnvForModel(state.model) : {};
+	const recoveryHarness = normalizeHarness(state.harness ?? null) ?? "claude-code";
+	const providerEnv = state.model ? await getProviderEnvForModel(state.model, recoveryHarness) : {};
 	if (state.model) {
 		const provider = getProviderForModelSync(state.model);
 		if (provider.authType === "credential-file") setupCredentialFileAuthSync(provider, state.workspace);
 		else clearCredentialFileAuthSync(state.workspace);
 	}
-	const recoveryHarness = normalizeHarness(state.harness ?? null) ?? "claude-code";
 	const harnessLaunch = await prepareHarnessLaunch(recoveryHarness);
 	const recoverySupervisorLaunch = await prepareSupervisorForRelaunch(normalizedId, state, state.model, recoveryHarness);
 	saveAgentStateSync(state);
@@ -9923,7 +11175,7 @@ async function recoverAgent(agentId, opts = {}) {
 			state
 		};
 	}
-	if (recoveryHarness === "acp") {
+	if (recoveryHarness === "acp" || recoveryHarness === "opencode" || recoveryHarness === "muse") {
 		const resumeSessionId = resolveRecoveryResumeSessionId(normalizedId, recoveryHarness);
 		const { launcherContent, providerEnv: acpProviderEnv } = await buildAgentLaunchConfig({
 			agentId: normalizedId,
@@ -9935,7 +11187,9 @@ async function recoverAgent(agentId, opts = {}) {
 				spawnMode: "resume",
 				resumeSessionId
 			} : {},
-			harness: "acp",
+			harness: recoveryHarness,
+			useSupervisor: recoverySupervisorLaunch.useSupervisor,
+			supervisorScriptPath: recoverySupervisorLaunch.supervisorScriptPath,
 			harnessBinaryPath: harnessLaunch.binaryPath,
 			extraEnvExports: [harnessLaunch.pathExport]
 		});
@@ -9949,14 +11203,18 @@ async function recoverAgent(agentId, opts = {}) {
 			CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION: "false",
 			...acpProviderEnv
 		} }));
-		const delivery = await deliverInitialPromptWithRetry(normalizedId, recoveryPrompt, "recoverAgent:acp-recovery-prompt");
+		if (recoveryHarness === "muse" && !await waitForPromptReady(normalizedId, recoveryHarness, getHarnessBehavior(recoveryHarness).readyTimeoutSeconds)) {
+			await Effect.runPromise(stopAgent(normalizedId));
+			throw new Error(`Muse recovery readiness timed out for ${normalizedId}`);
+		}
+		const delivery = await deliverInitialPromptWithRetry(normalizedId, recoveryPrompt, `recoverAgent:${recoveryHarness}-recovery-prompt`);
 		if (!delivery.ok) {
 			await Effect.runPromise(stopAgent(normalizedId));
-			throw new Error(`ACP recovery prompt delivery failed for ${normalizedId}: ${delivery.failure ?? "unknown failure"}`);
+			throw new Error(`${getHarnessBehavior(recoveryHarness).displayName} recovery prompt delivery failed for ${normalizedId}: ${delivery.failure ?? "unknown failure"}`);
 		}
 		markAgentRunning(state);
 		saveAgentStateSync(state);
-		logAgentLifecycleSync(normalizedId, `recoverAgent SUCCESS: recoveryCount=${health.recoveryCount} (acp)`);
+		logAgentLifecycleSync(normalizedId, `recoverAgent SUCCESS: recoveryCount=${health.recoveryCount} (${recoveryHarness})`);
 		return {
 			action: "respawned",
 			state
@@ -9983,7 +11241,7 @@ async function recoverAgent(agentId, opts = {}) {
 		const launchAndCaptureKimiSession = async () => {
 			let kimiExistingSessionsBefore;
 			if (!resumeSessionId) try {
-				const { kimiSessionsRoot } = await import("./kimi-code-BxkDgaj4.js");
+				const { kimiSessionsRoot } = await import("./kimi-code-Cx5YUJpS.js");
 				kimiExistingSessionsBefore = new Set(await readdir$1(kimiSessionsRoot(join$1(homedir(), ".kimi-code"), state.workspace)));
 			} catch {
 				kimiExistingSessionsBefore = /* @__PURE__ */ new Set();
@@ -9997,13 +11255,13 @@ async function recoverAgent(agentId, opts = {}) {
 				...kimiProviderEnv
 			} }));
 			if (kimiExistingSessionsBefore) {
-				const { waitForNewKimiSessionAsync, writeKimiSessionId } = await import("./kimi-code-BxkDgaj4.js");
+				const { waitForNewKimiSessionAsync, writeKimiSessionId } = await import("./kimi-code-Cx5YUJpS.js");
 				const sessionId = await waitForNewKimiSessionAsync(join$1(homedir(), ".kimi-code"), state.workspace, kimiExistingSessionsBefore);
 				if (sessionId) writeKimiSessionId(normalizedId, sessionId);
 				else throw new Error(`kimi-code session capture timed out after fresh relaunch for ${normalizedId} — no new session directory appeared under the workspace bucket`);
 			}
 		};
-		const { withKimiSessionCaptureLock } = await import("./kimi-code-BxkDgaj4.js");
+		const { withKimiSessionCaptureLock } = await import("./kimi-code-Cx5YUJpS.js");
 		try {
 			await withKimiSessionCaptureLock(join$1(homedir(), ".kimi-code"), state.workspace, launchAndCaptureKimiSession);
 		} catch (err) {
@@ -10029,7 +11287,7 @@ async function recoverAgent(agentId, opts = {}) {
 		workingDir: state.workspace,
 		changeDir: false,
 		setTerminalEnv: true,
-		providerExports: (await getProviderExportsForModel(state.model)).trimEnd(),
+		providerExports: (await getProviderExportsForModel(state.model, recoveryHarness)).trimEnd(),
 		extraEnvExports: [harnessLaunch.pathExport],
 		baseCommand: await getRoleRuntimeBaseCommand(state.model, normalizedId, recoveryRole, recoveryHarness),
 		appendSystemPromptFiles: await claudeSystemPromptFiles(state.workspace, recoveryHarness),
@@ -10116,6 +11374,7 @@ async function autoRecoverAgents() {
 	};
 }
 var init_recovery = __esmMin((() => {
+	init_muse_session();
 	init_child_env();
 	init_activity();
 	init_graceful_restart();
@@ -11927,6 +13186,6 @@ var init_agent_state = __esmMin((() => {
 	};
 }));
 //#endregion
-export { deliverCommitForReview as $, isTerminalSwarmSlotAgent as $n, piFifoPaths as $r, init_activity as $t, saveAgentStateSync as A, getAgentRuntimeSnapshot as Ai, init_runtime_census as An, transitionIssueToInReview as Ar, init_agent_input_detection as At, resolveAgentTargetSync as B, markAgentStateServiceInProcess as Bi, countRunningAgents as Bn, getAgentRuntimeBaseCommand as Br, isContextOverflowError as Bt, markAgentTroubled as C, writeChannelsBridgeMcpConfig as Ci, init_state_dir_removal as Cn, paneShowsCodexAuthBurn as Cr, getAgentWorkspace as Ct, recordStartupSessionExit as D, writePtyToken as Di, descendantPidsForSession as Dn, init_spawn_prep as Dr, scanPendingInputsPromise as Dt, recordAgentFailureSync as E, init_pty_token as Ei, removeAgentStateDir as En, defaultRunWorkspace as Er, isInteractiveRoleAgent as Et, writeAgentStateJsonSync as F, init_agents$1 as Fi, init_collector as Fn, init_resolve_tier as Fr, resumeAgent as Ft, init_runtime_state as G, init_concurrency as Gn, getRoleRuntimeBaseCommand as Gr, resolveAgentDeliveryMethod as Gt, waitForReadySignal as H, describeRunningAgents as Hn, getKimiCodeLauncherFields as Hr, init_messaging as Ht, isRole as I, init_agent_record_sync as Ii, LINUX_MEMORY_PRESSURE_DEFAULTS as In, resolveTier as Ir, answerSessionPaneChoice as It, compactAtTierRunBoundary as J, resetPatrolDispatchBudget as Jn, injectPiConversationMemory as Jr, appendActivity as Jt, saveAgentRuntimeState as K, releaseAdvancingSlot as Kn, hasAgentRuntimeInSubtree as Kr, init_operator_interventions as Kt, clearReadySignal as L, readAgentHarnessModelRecordSync as Li, init_linux as Ln, OHMYPI_AGENT_READY_TIMEOUT_SECONDS as Lr, captureSessionPaneChoice as Lt, setAgentPausedSync as M, appendAgentPlaneLifecycle as Mi, refreshRuntimeCensus as Mn, resolveImplicitStaffing as Mr, parseCodexApprovalPrompt as Mt, setAgentYieldedSync as N, appendAgentPlaneSession as Ni, runtimeCensusHasHarnessProcess as Nn, resolveIssueWorkModel as Nr, buildCompactRecoverySeed as Nt, resetAgentFailureCount as O, init_pty_supervisor_locate as Oi, getRuntimeCensus as On, retrieveSpawnTimeMemoryContext as Or, detectAwaitingInputForAgent as Ot, wipeAgentStateDirs as P, flushAgentPlaneWrites as Pi, createHostHealthCollector as Pn, resolveStaffing as Pr, init_resume as Pt, shouldReplayCompactAtTierRunBoundary as Q, init_swarm_slot_lifecycle as Qn, init_pi_fifo as Qr, getSessionId as Qt, isQualifiedAgentId as R, getRuntimeSnapshot as Ri, DARWIN_MEMORY_PRESSURE_DEFAULTS as Rn, describeOhmypiSpawnFailure as Rr, init_session_pane_choice as Rt, markAgentStoppedState as S, init_supervisor_channels as Si, hasRetainedTranscriptsMarker as Sn, isCodexAuthRouted as Sr, getAgentPendingQuestions as St, recordAgentFailure as T, init_resume_contract as Ti, markRetainedTranscripts as Tn, buildAgentLaunchConfig as Tr, isBlockedOnPendingInput as Tt, getAgentRuntimeState as U, emergencyBrake as Un, getOhmypiLauncherFields as Ur, messageAgent as Ut, waitForAgentIdle as V, setAgentRuntimeMirror as Vi, countRunningSwarmSlotsForIssue as Vn, getCodexLauncherFields as Vr, isContextOverflowTail as Vt, getAgentRuntimeStateSync as W, getConcurrencyLimits as Wn, getProviderAuthMode as Wr, messageAgentWithOutcome as Wt, replayCrashedStandingAgent as X, tryReserveSwarmSlot as Xn, waitForAcpHostReady as Xr, getLatestSessionId as Xt, contextWindowForModel as Y, tryReserveAdvancingSlot as Yn, roleAgentDefinitionPath as Yr, getActivity as Yt, replayStandingAgent as Z, workResumeSlotsAvailable as Zn, waitForPromptReady as Zr, getLatestSessionIdSync as Zt, init_agent_state as _, buildResumeContinueMessage as _i, listAgentStates as _n, init_bridge_token as _r, init_pending_decision_gate as _t, clearAgentOperatorGatesForIssuesSync as a, init_claude_auth as ai, init_spawn as an, deliverAgentMessage as ar, broadcastCommit as at, markAgentRunning as b, dismissDevChannelsDialog as bi, warnOnBareNumericIssueIds as bn, checkCodexAuthStatus as br, getAgentJsonlMtime as bt, clearAgentTroubled as c, determineModel as ci, ensureRegisteredSlotWorktree as cn, deliverResumeMessageWithTranscriptConfirmation as cr, init_tier_escalation as ct, decideResumeGate as d, getProviderTmuxFlags as di, init_session_history as dn, resilientDeliveryMethod as dr, reconcileSlotState as dt, init_ohmypi_fifo as ei, resolveLatestSessionIdSync as en, getCachedMemoryVerdict as er, init_tier_supervisor as et, getAgentDir as f, init_provider_health as fi, init_termination as fn, setAgentDeliveryMethod as fr, autoRecoverAgents as ft, getAgentStateSync as g, buildDefaultResumeContinueMessage as gi, init_queries as gn, BRIDGE_TOKEN_HEADER as gr, detectPendingOperatorDecision as gt, getAgentStateFilePath as h, init_openai_auth as hi, dropLegacyAgentStatesMissingRoleAsync as hn, probeTranscriptSince as hr, restartAgent as ht, clearAgentOperatorGatesForIssueSync as i, getClaudeAuthStatus as ii, init_ohmypi as in, SocketPostStatusError as ir, supervisorAgentId as it, setAgentPaused as j, init_agent_runtime as ji, panePidsForSession as jn, init_staffing as jr, normalizeAwaitingInputPrompt as jt, saveAgentState as k, resolvePtySupervisorScriptPath as ki, getRuntimeCensusSnapshot as kn, transitionIssueToInProgress as kr, detectAwaitingInputFromPaneSync as kt, clearAgentTroubledSync as l, getProviderEnvForModel as li, init_registered_slot_spawn as ln, init_delivery as lr, init_slot_reconcile as lt, getAgentState as m, getOpenAIAuthStatus as mi, stopAgentSync as mn, init_transcript_landing as mr, recoverAgent as mt, SESSION_EXITED_BEFORE_KICKOFF as n, init_context as ni, init_event_reads as nn, setCachedMemoryVerdict as nr, shouldSupervise as nt, clearAgentPaused as o, buildCavemanExports as oi, spawnAgent as on, deliverAgentPermissionDecision as or, init_tier_feed as ot, getAgentResumeGateBlockReason as p, validateProviderHealth as pi, stopAgent as pn, captureTranscriptUserRecordSnapshot as pr, detectCrashedAgents as pt, init_agents as q, releaseSwarmSlot as qn, init_runtime_command as qr, operatorInterventionEvent as qt, __testInternals as r, materializeAcpContextFile as ri, createOhmypiRuntimeSync as rn, AmbiguousKeyedDeliveryError as rr, spawnTierSupervisor as rt, clearAgentPausedSync as s, buildSpawnEnvForModel as si, spawnRun as sn, deliverInitialPromptWithRetry as sr, decideEscalation as st, GOVERNOR_SLOT_PAUSE_REASON_PREFIX as t, ohmypiFifoPaths as ti, saveSessionId as tn, init_memory_verdict_cache as tr, loadPrdDraft as tt, clearYieldForResumeSync as u, getProviderExportsForModel as ui, appendSessionIdToHistory as un, keyedSupervisorFailureKind as ur, listSlotAssignments as ut, isAgentPaused as v, decideChannelsForWorkAgent as vi, listRunningAgents as vn, writeBridgeTokenSync as vr, computeAgentEnrichment as vt, recordAgentActivitySync as w, buildResumeContract as wi, listAgentStateFilesForRemoval as wn, assertWorkspaceStackHealthyForSpawn as wr, init_agent_enrichment as wt, markAgentRunningState as x, hasCompletionMarkerForAgent as xi, RETAINED_TRANSCRIPTS_MARKER as xn, init_codex_auth as xr, getAgentJsonlPath as xt, isAgentTroubled as y, decideSupervisorForWorkAgent as yi, listRunningAgentsSync as yn, applyCodexAuthBurnFlag as yr, countPendingAskUserQuestionsForAgent as yt, normalizeAgentId as z, init_agent_runtime_mirror as zi, init_darwin as zn, getAcpLauncherFields as zr, init_context_overflow as zt };
+export { deliverCommitForReview as $, getOpenAIAuthStatus as $i, createHostHealthCollector as $n, resolveStaffing as $r, getLatestSessionIdSync as $t, saveAgentStateSync as A, codexGlobalContextFile as Ai, init_session_history as An, resilientDeliveryMethod as Ar, init_agent_input_detection as At, resolveAgentTargetSync as B, validateTemplate as Bi, RETAINED_TRANSCRIPTS_MARKER as Bn, init_codex_auth as Br, init_session_pane_choice as Bt, markAgentTroubled as C, getRuntimeSnapshot as Ca, ohmypiFifoPaths as Ci, waitForNewKimiSession as Cn, SocketPostStatusError as Cr, getAgentWorkspace as Ct, recordStartupSessionExit as D, init_render as Di, ensureRegisteredSlotWorktree as Dn, deliverResumeMessageWithTranscriptConfirmation as Dr, scanPendingInputsPromise as Dt, recordAgentFailureSync as E, setAgentRuntimeMirror as Ea, configDisabledRuleNames as Ei, writeKimiSessionId as En, deliverInitialPromptWithRetry as Er, isInteractiveRoleAgent as Et, writeAgentStateJsonSync as F, resolveProjectContextFile as Fi, init_queries as Fn, BRIDGE_TOKEN_HEADER as Fr, resumeAgent as Ft, init_runtime_state as G, buildCavemanExports as Gi, removeAgentStateDir as Gn, defaultRunWorkspace as Gr, messageAgent as Gt, waitForReadySignal as H, workspaceContextWithoutProjectLayer as Hi, init_state_dir_removal as Hn, paneShowsCodexAuthBurn as Hr, isContextOverflowError as Ht, isRole as I, resolveWorkspaceContextFile as Ii, listAgentStates as In, init_bridge_token as Ir, init_review_lifecycle_guard as It, compactAtTierRunBoundary as J, getProviderEnvForModel as Ji, getRuntimeCensusSnapshot as Jn, transitionIssueToInProgress as Jr, init_operator_interventions as Jt, saveAgentRuntimeState as K, buildSpawnEnvForModel as Ki, descendantPidsForSession as Kn, init_spawn_prep as Kr, messageAgentWithOutcome as Kt, clearReadySignal as L, workspaceContextFile as Li, listRunningAgents as Ln, writeBridgeTokenSync as Lr, withReviewLifecycleGuard as Lt, setAgentPausedSync as M, globalContextFile as Mi, stopAgent as Mn, captureTranscriptUserRecordSnapshot as Mr, parseCodexApprovalPrompt as Mt, setAgentYieldedSync as N, init_layers as Ni, stopAgentSync as Nn, init_transcript_landing as Nr, buildCompactRecoverySeed as Nt, resetAgentFailureCount as O, init_rules as Oi, init_registered_slot_spawn as On, init_delivery as Or, detectAwaitingInputForAgent as Ot, wipeAgentStateDirs as P, piGlobalContextFile as Pi, dropLegacyAgentStatesMissingRoleAsync as Pn, probeTranscriptSince as Pr, init_resume as Pt, shouldReplayCompactAtTierRunBoundary as Q, validateProviderHealth as Qi, runtimeCensusHasHarnessProcess as Qn, resolveIssueWorkModel as Qr, getLatestSessionId as Qt, isQualifiedAgentId as R, init_harness as Ri, listRunningAgentsSync as Rn, applyCodexAuthBurnFlag as Rr, answerSessionPaneChoice as Rt, markAgentStoppedState as S, readAgentHarnessModelRecordSync as Sa, init_ohmypi_fifo as Si, launchAndCaptureManagedKimiSession as Sn, AmbiguousKeyedDeliveryError as Sr, getAgentPendingQuestions as St, recordAgentFailure as T, markAgentStateServiceInProcess as Ta, materializeAcpContextFile as Ti, withKimiSessionCaptureLock as Tn, deliverAgentPermissionDecision as Tr, isBlockedOnPendingInput as Tt, getAgentRuntimeState as U, getClaudeAuthStatus as Ui, listAgentStateFilesForRemoval as Un, assertWorkspaceStackHealthyForSpawn as Ur, isContextOverflowTail as Ut, waitForAgentIdle as V, init_assemble as Vi, hasRetainedTranscriptsMarker as Vn, isCodexAuthRouted as Vr, init_context_overflow as Vt, getAgentRuntimeStateSync as W, init_claude_auth as Wi, markRetainedTranscripts as Wn, buildAgentLaunchConfig as Wr, init_messaging as Wt, replayCrashedStandingAgent as X, getProviderTmuxFlags as Xi, panePidsForSession as Xn, init_staffing as Xr, appendActivity as Xt, contextWindowForModel as Y, getProviderExportsForModel as Yi, init_runtime_census as Yn, transitionIssueToInReview as Yr, operatorInterventionEvent as Yt, replayStandingAgent as Z, init_provider_health as Zi, refreshRuntimeCensus as Zn, resolveImplicitStaffing as Zr, getActivity as Zt, init_agent_state as _, appendAgentPlaneLifecycle as _a, waitForAcpHostReady as _i, findLatestKimiSessionAsync as _n, init_swarm_slot_lifecycle as _r, init_pending_decision_gate as _t, clearAgentOperatorGatesForIssuesSync as a, dismissDevChannelsDialog as aa, describeOhmypiSpawnFailure as ai, createOhmypiRuntimeSync as an, countRunningAgents as ar, broadcastCommit as at, markAgentRunning as b, init_agents$1 as ba, init_pi_fifo as bi, kimiSessionsRoot as bn, init_memory_verdict_cache as br, getAgentJsonlMtime as bt, clearAgentTroubled as c, writeChannelsBridgeMcpConfig as ca, getCodexLauncherFields as ci, spawnAgent as cn, emergencyBrake as cr, init_tier_escalation as ct, decideResumeGate as d, init_pty_token as da, getProviderAuthMode as di, KimiCodeRuntimeSync as dn, releaseAdvancingSlot as dr, reconcileSlotState as dt, init_openai_auth as ea, init_resolve_tier as ei, getSessionId as en, init_collector as er, init_tier_supervisor as et, getAgentDir as f, writePtyToken as fa, getRoleRuntimeBaseCommand as fi, KimiCodeSpawnTimeout as fn, releaseSwarmSlot as fr, autoRecoverAgents as ft, getAgentStateSync as g, init_agent_runtime as ga, roleAgentDefinitionPath as gi, findLatestKimiSession as gn, workResumeSlotsAvailable as gr, detectPendingOperatorDecision as gt, getAgentStateFilePath as h, getAgentRuntimeSnapshot as ha, injectPiConversationMemory as hi, findKimiWirePathAsync as hn, tryReserveSwarmSlot as hr, restartAgent as ht, clearAgentOperatorGatesForIssueSync as i, decideSupervisorForWorkAgent as ia, OHMYPI_AGENT_READY_TIMEOUT_SECONDS as ii, init_event_reads as in, init_darwin as ir, supervisorAgentId as it, setAgentPaused as j, ensureProjectLayer as ji, init_termination as jn, setAgentDeliveryMethod as jr, normalizeAwaitingInputPrompt as jt, saveAgentState as k, claudeGlobalContextFile as ki, appendSessionIdToHistory as kn, keyedSupervisorFailureKind as kr, detectAwaitingInputFromPaneSync as kt, clearAgentTroubledSync as l, buildResumeContract as la, getKimiCodeLauncherFields as li, spawnRun as ln, getConcurrencyLimits as lr, init_slot_reconcile as lt, getAgentState as m, resolvePtySupervisorScriptPath as ma, init_runtime_command as mi, findKimiWirePath as mn, tryReserveAdvancingSlot as mr, recoverAgent as mt, SESSION_EXITED_BEFORE_KICKOFF as n, buildResumeContinueMessage as na, init_muse_context as ni, resolveLatestSessionIdSync as nn, init_linux as nr, shouldSupervise as nt, clearAgentPaused as o, hasCompletionMarkerForAgent as oa, getAcpLauncherFields as oi, init_ohmypi as on, countRunningSwarmSlotsForIssue as or, init_tier_feed as ot, getAgentResumeGateBlockReason as p, init_pty_supervisor_locate as pa, hasAgentRuntimeInSubtree as pi, createKimiCodeRuntimeSync as pn, resetPatrolDispatchBudget as pr, detectCrashedAgents as pt, init_agents as q, determineModel as qi, getRuntimeCensus as qn, retrieveSpawnTimeMemoryContext as qr, resolveAgentDeliveryMethod as qt, __testInternals as r, decideChannelsForWorkAgent as ra, materializeMuseContext as ri, saveSessionId as rn, DARWIN_MEMORY_PRESSURE_DEFAULTS as rr, spawnTierSupervisor as rt, clearAgentPausedSync as s, init_supervisor_channels as sa, getAgentRuntimeBaseCommand as si, init_spawn as sn, describeRunningAgents as sr, decideEscalation as st, GOVERNOR_SLOT_PAUSE_REASON_PREFIX as t, buildDefaultResumeContinueMessage as ta, resolveTier as ti, init_activity as tn, LINUX_MEMORY_PRESSURE_DEFAULTS as tr, loadPrdDraft as tt, clearYieldForResumeSync as u, init_resume_contract as ua, getOhmypiLauncherFields as ui, KimiCaptureLockTimeoutError as un, init_concurrency as ur, listSlotAssignments as ut, isAgentPaused as v, appendAgentPlaneSession as va, waitForPromptReady as vi, init_kimi_code as vn, isTerminalSwarmSlotAgent as vr, computeAgentEnrichment as vt, recordAgentActivitySync as w, init_agent_runtime_mirror as wa, init_context as wi, waitForNewKimiSessionAsync as wn, deliverAgentMessage as wr, init_agent_enrichment as wt, markAgentRunningState as x, init_agent_record_sync as xa, piFifoPaths as xi, kimiWorkDirKey as xn, setCachedMemoryVerdict as xr, getAgentJsonlPath as xt, isAgentTroubled as y, flushAgentPlaneWrites as ya, claudeSystemPromptFiles as yi, kimiCaptureLockPath as yn, getCachedMemoryVerdict as yr, countPendingAskUserQuestionsForAgent as yt, normalizeAgentId as z, renderForHarness as zi, warnOnBareNumericIssueIds as zn, checkCodexAuthStatus as zr, captureSessionPaneChoice as zt };
 
-//# sourceMappingURL=agent-state-FABw8neJ.js.map
+//# sourceMappingURL=agent-state-Ci6PhjOE.js.map