@overdeck/desktop 0.45.13 → 0.45.16

package/server/{specialists-CL7E8yUg.js → specialists-CFgw_0Q6.js}

@@ -1,46 +1,54 @@
 import { a as __toCommonJS } from "./rolldown-runtime-DNCzzKnI.js";
-import { $n as extractPrefixSync, C as resolveTieredExecutionEnabled, Dn as getProjectSync, E as canUseHarnessSync, Gn as resolveProjectFromIssueSync, Hr as init_paths, Nn as init_projects, O as init_harness_policy, Rr as encodeClaudeProjectDir, S as init_tier_table, Vr as getOverdeckHome, X as resolveModel, er as init_issue_id, f as loadConfigSync, fn as init_state_read_home, lr as FsError, mn as shouldCommitLegacyWorkspaceArtifacts, nr as parseIssueIdSync, t as init_config_yaml, w as resolveTieredExecutionEnabledForIssue, yr as init_errors } from "./config-yaml-C_djSurJ.js";
+import { B as piProviderForModel, Br as encodeClaudeProjectDir, C as init_tier_table, D as canUseHarnessSync, Fn as init_projects, Jr as init_paths, N as UnknownModelError, R as getProviderForModelSync, T as resolveTieredExecutionEnabledForIssue, Z as resolveModel, Zr as resolveOhmypiExtensionPath, c as isClaudeCodeChannelsEnabled, dr as FsError, f as loadConfigSync, gn as shouldCommitLegacyWorkspaceArtifacts, ir as parseIssueIdSync, k as init_harness_policy, kn as getProjectSync, mn as init_state_read_home, nr as init_issue_id, qn as resolveProjectFromIssueSync, qr as getOverdeckHome, t as init_config_yaml, tr as extractPrefixSync, w as resolveTieredExecutionEnabled, xr as init_errors, z as init_providers, zn as listProjectsSync } from "./config-yaml-cNOZcEww.js";
 import { a as init_activity_logger, n as emitActivityEntrySync } from "./activity-logger-pcbf-e30.js";
-import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-Clew3DpF.js";
-import { K as buildChildEnvWithoutTmuxSync, L as sessionExists, R as sessionExistsSync, i as capturePane, k as listSessions, q as init_child_env, w as killSession, x as init_tmux } from "./tmux-BVc-NeKM.js";
-import { a as init_event_store, n as getEventStore } from "./event-store-C71x6h0i.js";
-import { C as normalizeChannelReplyPayload, a as getHarnessBehavior, b as DomainEvent, t as init_src } from "./src-DGAEtABV.js";
-import { D as AGENT_COLUMNS_FOR_DB, M as stateToOverdeckParamsForDb, c as init_review_status, k as init_agent_state_sync, s as getReviewStatusSync, u as loadReviewStatuses, y as setReviewStatusSync } from "./review-status-BcfwcAcO.js";
-import { a as EventStoreService, c as ReadModelService, d as init_read_model, i as init_issue_lifecycle, s as init_domain_services, t as IssueLifecycle, u as getClosedIssueIdsForReadSource } from "./issue-lifecycle-BoJa6qIt.js";
-import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-CaiG63FG.js";
-import { $n as writeAgentStateJsonSync, An as getAgentDir, Bt as resolveStaffing, C as restartAgent, Ct as deliverAgentPermissionDecision, E as resumeAgent, En as clearAgentTroubled, Et as setAgentDeliveryMethod, F as getActivity, I as getLatestSessionId, Jn as saveAgentStateSync, Jt as getProviderAuthMode, K as stopAgent, L as getLatestSessionIdSync, Lt as transitionIssueToInProgress, M as init_operator_interventions, Mn as getAgentState, N as operatorInterventionEvent, Pn as getAgentStateSync, Qn as wipeAgentStateDirs, R as getSessionId, S as recoverAgent, St as deliverAgentMessage, Vn as markAgentStoppedState, X as listAgentStates, Yn as setAgentPaused, Z as listRunningAgents, _t as init_config, cn as determineModel, dr as normalizeAgentId, er as init_persistent_logger, fn as init_provider_health, g as init_tier_escalation, gr as getAgentRuntimeStateSync, h as decideEscalation, hr as getAgentRuntimeState, j as messageAgent, pn as validateProviderHealth, qn as saveAgentState, t as init_agents, tr as logAgentLifecycleSync, vr as saveAgentRuntimeState, wn as clearAgentPaused, yt as loadCloisterConfigSync, z as saveSessionId, zt as init_staffing } from "./agents-DqQa4Dq_.js";
-import { t as init_behavior } from "./behavior-D3d2mVyD.js";
-import { a as performHandoff, i as checkAllTriggers, s as getAgentHealth, t as getCloisterService } from "./service-C8jKYZ0w.js";
-import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-C1Y_2CIo.js";
-import { n as init_issue_service_singleton, r as issue_service_singleton_exports } from "./issue-service-singleton-BS9NENuR.js";
-import { a as PAN_DIRNAME, i as PAN_CONTINUE_FILENAME, p as init_types } from "./types-CE1m_daD.js";
-import { I as generateVBriefFilename, L as init_lifecycle, f as readTierOverrides, g as serializeVBriefDocument, h as recordTierPromotion, m as readWorkspacePlanSync, o as init_io, r as findPlan, u as readPlan } from "./io-CbAFXQge.js";
-import { d as getCliproxyAuthDir, g as getCliproxyLogPath, l as decodeJwtPayload, v as init_cliproxy } from "./cliproxy-BituqWtR.js";
-import { _ as init_codex_conversation_parser, c as parseEntireConversation, d as init_pi_conversation_parser, g as parseOhmypiConversationMessages, m as init_ohmypi_conversation_parser, p as parsePiConversationMessages, t as init_conversation_service, v as parseCodexConversationMessages } from "./conversation-service-CFZIjs-M.js";
-import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-CSH66UO8.js";
-import { c as requireModelOverrideSync, n as init_state_home, o as init_model_validation, r as isStateMigrated, s as normalizeModelOverrideSync } from "./state-home-CoyWsECg.js";
-import { a as init_stack_health, i as getWorkspaceStackHealth } from "./stack-health-C-le5erA.js";
-import { s as getDispatchableItems, u as init_dag } from "./dag-BQFtXOuJ.js";
-import { i as queryBeadById, r as init_beads_query } from "./beads-query-tOsAYP5h.js";
-import { a as init_lifecycle_io, c as updatePlanStatus, s as transitionVBriefOnMain } from "./lifecycle-io-C73m5e6R.js";
-import { Lt as getRuntimeForAgent, Q as createInFlightGuard, Qt as getAgentWorkspace$1, Rt as classifyMemoryPressure, Ut as getResourceConfig, Wt as getSystemHealthSnapshot, Xt as getAgentJsonlPath$1, Zt as getAgentPendingQuestions$1, nn as normalizeAwaitingInputPrompt, qt as computeAgentEnrichment } from "./deacon-2EvA9Ci3.js";
-import { o as stopWorkspaceDocker, r as init_workspace_manager } from "./workspace-manager-D6NgGkiF.js";
-import { at as init_jsonl_parser, ot as normalizeModelName } from "./specialists-BGNZ0_ZW.js";
-import { t as withBdMutex } from "./bd-mutex-BItGvLQ8.js";
-import { a as loadWorkspaceMetadataSync } from "./workspace-metadata-C8yn8kAH.js";
-import { c as syncBeadStatusToVBrief } from "./beads-DRoj6-e1.js";
-import { dirname, join } from "node:path";
+import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-Ba9mS6e6.js";
+import { F as sendKeysAsync, I as sendRawKeystroke, K as buildChildEnvWithoutTmuxSync, L as sessionExists, O as listSessionNames, R as sessionExistsSync, S as isHarnessProcessAlive, W as BLANKED_PROVIDER_ENV, d as exactPaneTarget, i as capturePane, k as listSessions, o as createSession, p as findManagedServerPidSync, q as init_child_env, w as killSession, x as init_tmux, z as setOption } from "./tmux-C3g9VFcg.js";
+import { a as init_event_store, n as getEventStore } from "./event-store-D89fMfXS.js";
+import { C as normalizeChannelReplyPayload, a as getHarnessBehavior, b as DomainEvent, t as init_src } from "./src-B4TTzNSr.js";
+import { D as AGENT_COLUMNS_FOR_DB, M as stateToOverdeckParamsForDb, c as init_review_status, k as init_agent_state_sync, s as getReviewStatusSync, u as loadReviewStatuses, y as setReviewStatusSync } from "./review-status-Dc1l4dVz.js";
+import { a as EventStoreService, c as ReadModelService, d as init_read_model, i as init_issue_lifecycle, s as init_domain_services, t as IssueLifecycle, u as getClosedIssueIdsForReadSource } from "./issue-lifecycle--8MRxrG1.js";
+import { n as ensureSessionContextBriefingFile, r as init_briefing_freshness } from "./briefing-freshness-DESTCWo-.js";
+import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-D9kPIY_5.js";
+import { $n as writeAgentStateJsonSync, An as getAgentDir, At as init_bridge_token, Bt as resolveStaffing, C as restartAgent, Ct as deliverAgentPermissionDecision, E as resumeAgent, En as clearAgentTroubled, Et as setAgentDeliveryMethod, F as getActivity, Gt as getAgentRuntimeBaseCommand, I as getLatestSessionId, Jn as saveAgentStateSync, Jt as getProviderAuthMode, K as stopAgent, L as getLatestSessionIdSync, Lt as transitionIssueToInProgress, M as init_operator_interventions, Mn as getAgentState, N as operatorInterventionEvent, Pn as getAgentStateSync, Qn as wipeAgentStateDirs, R as getSessionId, S as recoverAgent, St as deliverAgentMessage, Vn as markAgentStoppedState, X as listAgentStates, Yn as setAgentPaused, Z as listRunningAgents, _t as init_config, ar as resolvePtySupervisorScriptPath, bn as writeChannelsBridgeMcpConfig, cn as determineModel, cr as normalizeAgentId, dr as waitForReadySignal, en as init_pi_fifo, fn as init_provider_health, fr as getAgentRuntimeState, g as init_tier_escalation, h as decideEscalation, hr as saveAgentRuntimeState, ir as init_pty_supervisor_locate, j as messageAgent, jt as writeBridgeTokenSync, ln as getProviderEnvForModel, nn as init_ohmypi_fifo, nr as init_pty_token, or as clearReadySignal, pn as validateProviderHealth, pr as getAgentRuntimeStateSync, qn as saveAgentState, rn as ohmypiFifoPaths, rr as writePtyToken, t as init_agents, tn as piFifoPaths, un as getProviderExportsForModel, wn as clearAgentPaused, yn as dismissDevChannelsDialog, yt as loadCloisterConfigSync, z as saveSessionId, zt as init_staffing } from "./agents-B9GwfCyp.js";
+import { a as performHandoff, i as checkAllTriggers, s as getAgentHealth, t as getCloisterService } from "./service-DfTVoqJg.js";
+import { o as init_persistent_logger, s as logAgentLifecycleSync } from "./session-history-DanhhiCw.js";
+import { t as init_behavior } from "./behavior-BTpYbAv4.js";
+import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-dQxC15vH.js";
+import { n as init_issue_service_singleton, r as issue_service_singleton_exports } from "./issue-service-singleton-CkTUI-eu.js";
+import { a as PAN_DIRNAME, i as PAN_CONTINUE_FILENAME, p as init_types } from "./types-BLS_Zbmd.js";
+import { F as generateVBriefFilename, I as init_lifecycle, f as readTierOverrides, g as serializeVBriefDocument, h as recordTierPromotion, m as readWorkspacePlanSync, o as init_io, r as findPlan, u as readPlan } from "./io-VEGSAqsd.js";
+import { d as getCliproxyAuthDir, g as getCliproxyLogPath, l as decodeJwtPayload, v as init_cliproxy } from "./cliproxy-B4c1BUvs.js";
+import { B as removeFavorite, E as hasOtherActiveConversationOnTmuxSession, F as markConversationEnded, G as setConversationHarness, K as setConversationModel, M as listConversations, P as markConversationActive, Q as updateConversationDeliveryMethod, S as getConversationByName, W as setConversationEffort, g as backfillConversationModel, h as archiveConversation, k as init_conversations, nt as updateLastAttached, rt as updateSpawnError, x as getConversationById, y as createConversation } from "./conversations-B-lcHv-5.js";
+import { _ as init_codex_conversation_parser, c as parseEntireConversation, d as init_pi_conversation_parser, g as parseOhmypiConversationMessages, m as init_ohmypi_conversation_parser, p as parsePiConversationMessages, t as init_conversation_service, v as parseCodexConversationMessages } from "./conversation-service-B8LFQQm1.js";
+import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-CqZSnqQi.js";
+import { a as init_launcher_generator, c as requireModelOverrideSync, i as generateLauncherScriptSync, n as init_state_home, o as init_model_validation, r as isStateMigrated, s as normalizeModelOverrideSync } from "./state-home-CEvD_v5F.js";
+import { a as init_claude_permissions, o as resolvePermissionModeSync, r as getClaudePermissionFlagsStringSync, t as BYPASS_PERMISSION_MODE } from "./claude-permissions-CThLgf8d.js";
+import { h as workspaceContextFile, l as piGlobalContextFile, o as init_layers } from "./layers-jjL16At6.js";
+import { a as init_stack_health, i as getWorkspaceStackHealth } from "./stack-health-CSgcYcr8.js";
+import { s as getDispatchableItems, u as init_dag } from "./dag-DKI3sOmX.js";
+import { i as queryBeadById, r as init_beads_query } from "./beads-query-Dl4FhT8J.js";
+import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-C6g2R0Cd.js";
+import { a as init_lifecycle_io, c as updatePlanStatus, s as transitionVBriefOnMain } from "./lifecycle-io-IehcRt2v.js";
+import { _ as parseCodexApprovalPrompt, d as getAgentPendingQuestions$1, f as getAgentWorkspace$1, g as normalizeAwaitingInputPrompt, m as detectAwaitingInputForAgent, o as getRuntimeForAgent, p as scanPendingInputsPromise, s as computeAgentEnrichment, u as getAgentJsonlPath$1 } from "./stuck-remediation-CxsyxwFO.js";
+import { Ht as getResourceConfig, Lt as classifyMemoryPressure, Q as createInFlightGuard, Ut as getSystemHealthSnapshot } from "./deacon-DdARMjZq.js";
+import { o as stopWorkspaceDocker, r as init_workspace_manager } from "./workspace-manager-D8AByFIT.js";
+import { a as init_jsonl_parser, o as normalizeModelName } from "./jsonl-parser-BUW5_sSK.js";
+import { a as loadWorkspaceMetadataSync } from "./workspace-metadata-CvC268MN.js";
+import { c as syncBeadStatusToVBrief, l as withBdMutex } from "./beads-BeSMEjGT.js";
+import { basename, delimiter, dirname, join, resolve } from "node:path";
 import { Cause, Data, Effect, Layer, Option, Schema, Stream } from "effect";
 import { join as join$1 } from "path";
 import { homedir } from "node:os";
-import { existsSync } from "node:fs";
+import { createReadStream, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
 import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import { access, appendFile, cp, lstat, mkdir, open, readFile, readdir, rm, stat as stat$1, writeFile } from "node:fs/promises";
+import { access, appendFile, chmod, cp, lstat, mkdir, open, readFile, readdir, realpath, rename, rm, stat as stat$1, writeFile } from "node:fs/promises";
 import { randomUUID } from "crypto";
 import { mkdir as mkdir$1, open as open$1, readFile as readFile$1, stat as stat$2, writeFile as writeFile$1 } from "fs/promises";
 import { exec, execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
-import { timingSafeEqual } from "node:crypto";
+import { randomUUID as randomUUID$1, timingSafeEqual } from "node:crypto";
+import { pathToFileURL } from "node:url";
+import { createInterface } from "node:readline";
 import * as Result$1 from "effect/Result";
 //#region http-helpers.ts
 init_paths();
@@ -65,10 +73,11 @@ function jsonStringResponse(json, options) {
 	});
 }
 //#endregion
-//#region routes/http-handler.ts
+//#region ../../lib/default-cwd.ts
 init_activity_logger();
 init_issue_id();
 init_projects();
+init_providers();
 init_harness_policy();
 init_tier_table();
 init_config_yaml();
@@ -79,12 +88,34 @@ init_event_store();
 init_src();
 init_agent_state_sync();
 init_read_model();
+init_briefing_freshness();
 init_domain_services();
+init_cost();
+init_behavior();
+init_persistent_logger();
+init_tracker_config();
 init_types();
 init_review_status();
 init_lifecycle();
 init_io();
 /**
+* Resolve the default cwd used when no project is selected — the "devroot"
+* fallback. Prefers `~/Projects` if it exists, otherwise the user's home
+* directory.
+*
+* Replaces the deprecated `sync.devroot` config (PAN-1201) for the runtime
+* code paths that still need a sensible default working directory:
+*
+* - New conversations created without a `projectKey` (conversations.ts)
+* - The global editor-launcher in the dashboard top bar (PanOpenInPicker)
+*/
+function getDefaultCwd() {
+	const candidate = join(homedir(), "Projects");
+	return existsSync(candidate) ? candidate : homedir();
+}
+//#endregion
+//#region routes/http-handler.ts
+/**
 * httpHandler — typed error-to-HTTP mapping wrapper (PAN-470)
 *
 * Wraps an Effect route body and catches all typed TaggedErrors,
@@ -153,8 +184,6 @@ function httpHandler(effect) {
 }
 //#endregion
 //#region ../../lib/codex-auth.ts
-init_cost();
-init_tracker_config();
 init_cliproxy();
 /** Wrapper error for Codex auth probing — preserves the underlying cause. */
 var CodexAuthCheckError = class extends Data.TaggedError("CodexAuthCheckError") {};
@@ -408,19 +437,92 @@ function isTrustedOriginForHost(origin, _host) {
 	return getTrustedOrigins().includes(normalized);
 }
 //#endregion
+//#region services/pending-respawn.ts
+/**
+* Tracks tmux sessions that are mid-respawn so that `/ws/terminal`
+* reconnects landing in the kill→spawn gap don't get a fatal 4404.
+*
+* Background: switch-model, resume, and restart-all all do
+*
+*     await killSessionAsync(name)   // old tmux dies, PTY exits,
+*                                    // ws-terminal closes clients with 1000
+*     await spawnConversationSession(...)   // new tmux session with same name
+*     await waitForTmuxSession(name)
+*     await waitForReadySignal(name, 30)        // up to 30s
+*
+* The terminal frontend (`XTerminal.tsx`) reconnects on close 1000 with
+* exponential backoff (1s, 2s, 4s, 8s, 16s). Every reconnect re-enters
+* `ws-terminal.ts`, which checks the tmux session list upfront and
+* `close(4404, 'session-not-found')` if the name isn't there yet.
+* 4404 is treated as fatal on the client (no retry — the session is
+* presumed gone), so the panel sticks on "Could not reconnect" even
+* after the respawn completes a moment later.
+*
+* This registry lets `ws-terminal.ts` distinguish "transient absence
+* during respawn" from "session is actually gone". Respawn sites mark
+* the name with `markRespawnPending()` for the duration of their kill+
+* spawn block; ws-terminal calls `waitForSessionRespawn()` instead of
+* 4404-ing immediately when the session is missing AND
+* `isRespawnPending()` is true.
+*/
+const pendingRespawns = /* @__PURE__ */ new Set();
+/**
+* Mark a tmux session as mid-respawn. The returned `done()` must run in
+* a `finally` so the marker is cleared even if the respawn throws.
+*/
+function markRespawnPending(sessionName) {
+	pendingRespawns.add(sessionName);
+	return { done: () => {
+		pendingRespawns.delete(sessionName);
+	} };
+}
+/** True if a respawn is currently in progress for this session name. */
+function isRespawnPending(sessionName) {
+	return pendingRespawns.has(sessionName);
+}
+const POLL_INTERVAL_MS = 200;
+/**
+* Poll for the session to come back, up to `timeoutMs`. Returns whether
+* it did. Bails early once `pendingRespawns` no longer contains the name
+* (the wrapping respawn block finished, success or failure) and the
+* session still isn't there — at that point the absence is real.
+*
+* `timeoutMs` should comfortably exceed the longest respawn window. The
+* dominant cost is `waitForReadySignal`'s 30s ceiling in the conversation
+* routes, so 35s is the right default for those callers.
+*/
+async function waitForSessionRespawn(sessionName, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (await Effect.runPromise(sessionExists(sessionName))) return true;
+		if (!pendingRespawns.has(sessionName)) return Effect.runPromise(sessionExists(sessionName));
+		await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+	}
+	return Effect.runPromise(sessionExists(sessionName));
+}
+//#endregion
 //#region routes/jsonl-resolver.ts
+init_conversations();
 init_codex_conversation_parser();
 init_ohmypi_conversation_parser();
 init_pi_conversation_parser();
 init_conversation_service();
-init_persistent_logger();
+init_pty_supervisor_locate();
+init_pty_token();
 init_feature_registry_population();
 init_model_validation();
 init_provider_health();
+init_claude_permissions();
+init_layers();
+init_ohmypi_fifo();
+init_pi_fifo();
 init_stack_health();
+init_launcher_generator();
 init_dag();
 init_staffing();
 init_beads_query();
+init_harness_resolve();
+init_bridge_token();
 init_operator_interventions();
 init_lifecycle_io();
 /**
@@ -435,7 +537,8 @@ init_lifecycle_io();
 *
 * For claude-code agents the JSONL filename is the *Claude session ID* (a UUID
 * written by Claude Code itself), NOT the agent/tmux name. Lookup order:
-*   1. session.id     — single UUID written by auto-suspend
+*   1. session.id     — UUID pinned before fresh work-agent launch and updated
+*                       by auto-suspend/resume flows
 *   2. sessions.json  — array of UUIDs the agent has used; the heartbeat hook
 *                       APPENDS new IDs and dedupes, so once a session has been
 *                       seen its array index never moves. After a `pan resume`
@@ -448,7 +551,13 @@ init_lifecycle_io();
 * server's event loop.
 */
 init_agents();
-init_behavior();
+const transcriptResolutionSignatures = /* @__PURE__ */ new Map();
+function logTranscriptResolution(agentId, signature, message, opts) {
+	const signatureKey = `${agentId}:${opts.agentsDirOverride ?? "live"}`;
+	if (transcriptResolutionSignatures.get(signatureKey) === signature) return;
+	transcriptResolutionSignatures.set(signatureKey, signature);
+	(opts.logDiagnostic ?? (opts.agentsDirOverride ? void 0 : logAgentLifecycleSync))?.(agentId, `transcript resolution: ${message}`);
+}
 async function pathExists$1(p) {
 	return access(p).then(() => true, () => false);
 }
@@ -629,7 +738,7 @@ async function resolveCodexRolloutPath(agentId, opts = {}) {
 	const agentDir = join(opts.agentsDirOverride ?? join(getOverdeckHome(), "agents"), agentId);
 	const codexHome = join(agentDir, "codex-home");
 	if (!await pathExists$1(codexHome)) return null;
-	const { findRolloutPath, findLatestRollout } = await import("./codex-Bi1ITSOo.js");
+	const { findRolloutPath, findLatestRollout } = await import("./codex-BYPz6ZdF.js");
 	const threadId = (await readOptional(join(agentDir, "codex-thread-id")))?.trim();
 	if (threadId) {
 		const rollout = findRolloutPath(codexHome, threadId);
@@ -681,18 +790,27 @@ async function resolvePiSessionPath(agentId, opts = {}) {
 * the corresponding JSONL file exists; otherwise null.
 */
 async function resolveJsonlPath(agentId, workspacePath, opts = {}) {
-	const behavior = behaviorForHarness(await resolveAgentHarness(agentId, opts));
+	const harness = await resolveAgentHarness(agentId, opts);
+	const behavior = behaviorForHarness(harness);
 	if (behavior.transcriptKind === "codex-rollout-jsonl") return resolveCodexRolloutPath(agentId, opts);
 	if (behavior.transcriptKind === "ohmypi-jsonl") return resolvePiSessionPath(agentId, opts);
 	const claudeSessionId = await resolveClaudeSessionId(agentId, opts);
-	if (!claudeSessionId) return null;
+	if (!claudeSessionId) {
+		logTranscriptResolution(agentId, `missing-session-id:${harness ?? "unknown"}`, `failed harness=${harness ?? "unknown"} reason=no-session-id checked=session.id,sessions.json,runtime-state`, opts);
+		return null;
+	}
 	const jsonlPath = join(opts.claudeProjectsDirOverride ?? join(homedir(), ".claude", "projects"), encodeClaudeProjectDir(workspacePath), `${claudeSessionId}.jsonl`);
-	if (await pathExists$1(jsonlPath)) return jsonlPath;
+	if (await pathExists$1(jsonlPath)) {
+		logTranscriptResolution(agentId, `resolved:${jsonlPath}`, `resolved harness=${harness ?? "claude-code"} sessionId=${claudeSessionId} path=${jsonlPath}`, opts);
+		return jsonlPath;
+	}
+	logTranscriptResolution(agentId, `missing-jsonl:${jsonlPath}`, `failed harness=${harness ?? "claude-code"} reason=jsonl-missing sessionId=${claudeSessionId} workspace=${workspacePath} expectedPath=${jsonlPath}`, opts);
 	return null;
 }
 //#endregion
 //#region ../../lib/work-agent-lifecycle.ts
 init_agents();
+init_tmux();
 async function pathExists(path) {
 	try {
 		await access(path);
@@ -861,7 +979,7 @@ const getWorkAgentLifecycleState = (agentOrIssueId) => Effect.promise(() => getW
 *
 * All I/O is async (execFile / fs.promises). No execSync, no readFileSync.
 */
-const execFileAsync$2 = promisify(execFile);
+const execFileAsync$3 = promisify(execFile);
 const GIT_INFO_TTL_MS = 3e4;
 const GIT_INFO_TIMEOUT_MS = 2e3;
 const cache = /* @__PURE__ */ new Map();
@@ -902,7 +1020,7 @@ async function readHeadMtimeMs(absPath) {
 	}
 }
 async function readGitInfoFresh(absPath) {
-	const [branchResult, worktreeResult] = await Promise.all([execFileAsync$2("git", [
+	const [branchResult, worktreeResult] = await Promise.all([execFileAsync$3("git", [
 		"-C",
 		absPath,
 		"rev-parse",
@@ -911,7 +1029,7 @@ async function readGitInfoFresh(absPath) {
 	], {
 		encoding: "utf-8",
 		timeout: GIT_INFO_TIMEOUT_MS
-	}).catch(() => null), execFileAsync$2("git", [
+	}).catch(() => null), execFileAsync$3("git", [
 		"-C",
 		absPath,
 		"rev-parse",
@@ -986,8 +1104,8 @@ async function resolveAgentGitInfo(workspacePath, expectedBranch) {
 init_paths();
 init_agents();
 init_tmux();
-const execAsync$1 = promisify(exec);
-const execFileAsync$1 = promisify(execFile);
+const execAsync$2 = promisify(exec);
+const execFileAsync$2 = promisify(execFile);
 function buildPanStartArgs(input) {
 	return [
 		"start",
@@ -1335,9 +1453,9 @@ async function getGitStatusAsync(workspacePath) {
 	try {
 		if (!existsSync(workspacePath)) return null;
 		const [branchResult, uncommittedResult, commitResult] = await Promise.all([
-			execAsync$1("git rev-parse --abbrev-ref HEAD 2>/dev/null || echo \"\"", { cwd: workspacePath }),
-			execAsync$1("git status --porcelain 2>/dev/null | wc -l", { cwd: workspacePath }),
-			execAsync$1("git log -1 --pretty=format:\"%s\" 2>/dev/null || echo \"\"", { cwd: workspacePath })
+			execAsync$2("git rev-parse --abbrev-ref HEAD 2>/dev/null || echo \"\"", { cwd: workspacePath }),
+			execAsync$2("git status --porcelain 2>/dev/null | wc -l", { cwd: workspacePath }),
+			execAsync$2("git log -1 --pretty=format:\"%s\" 2>/dev/null || echo \"\"", { cwd: workspacePath })
 		]);
 		const branch = branchResult.stdout.trim();
 		const uncommitted = uncommittedResult.stdout.trim();
@@ -1720,7 +1838,7 @@ const getAgentOutputRoute = HttpRouter.add("GET", "/api/agents/:id/output", http
 			} catch {}
 			let stdout;
 			if (isRemote && vmName) {
-				const { getRemoteAgentOutput } = await import("./remote-agents-B4eWgwNd.js");
+				const { getRemoteAgentOutput } = await import("./remote-agents-Cv-U-_V8.js");
 				stdout = await getRemoteAgentOutput(id, vmName, parseInt(String(lines), 10) || 100);
 			} else stdout = await Effect.runPromise(capturePane(id, parseInt(String(lines), 10) || 100));
 			if (!stdout || stdout.trim() === "" || stdout.trim() === "Session not found") {
@@ -1821,7 +1939,7 @@ const getAgentFilesRoute = HttpRouter.add("GET", "/api/agents/:id/files", httpHa
 	if (!agentState?.workspace) return jsonResponse({ files: [] });
 	const workspacePath = agentState.workspace;
 	if (!existsSync(workspacePath)) return jsonResponse({ files: [] });
-	const { stdout } = yield* Effect.promise(() => execAsync$1("git diff --name-status HEAD 2>/dev/null || git status --porcelain 2>/dev/null || echo \"\"", {
+	const { stdout } = yield* Effect.promise(() => execAsync$2("git diff --name-status HEAD 2>/dev/null || git status --porcelain 2>/dev/null || echo \"\"", {
 		cwd: workspacePath,
 		encoding: "utf-8"
 	}));
@@ -1908,6 +2026,1403 @@ const postAgentPokeRoute = HttpRouter.add("POST", "/api/agents/:id/poke", httpHa
 	});
 })));
 //#endregion
+//#region ../../lib/runtimes/conversation-control.ts
+function conversationControlPaths(agentId, home) {
+	const { agentDir } = ohmypiFifoPaths(agentId, home);
+	return {
+		agentDir,
+		controlDir: join(agentDir, "control")
+	};
+}
+async function writeConversationControlCommand(agentId, command, home) {
+	const paths = conversationControlPaths(agentId, home);
+	await mkdir(paths.controlDir, {
+		recursive: true,
+		mode: 448
+	});
+	await chmod(paths.controlDir, 448);
+	const finalPath = join(paths.controlDir, `${Date.now()}-${command.id}-${randomUUID$1()}.json`);
+	const tempPath = `${finalPath}.tmp`;
+	await writeFile(tempPath, `${JSON.stringify(command)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+	await chmod(tempPath, 384);
+	await rename(tempPath, finalPath);
+	await chmod(finalPath, 384);
+	return finalPath;
+}
+//#endregion
+//#region ../../lib/ohmypi-codex-auth.ts
+/**
+* oh-my-pi (omp) OAuth helpers for the openai-codex (ChatGPT subscription) provider.
+* Forked from pi-codex-auth.ts (PAN-1520) for the omp migration (PAN-1989).
+*
+* omp stores its general credentials in ~/.omp/agent/agent.db (SQLite). The
+* openai-codex OAuth credential is persisted separately at ~/.omp/agent/auth.json
+* (same JSON format as Pi's ~/.pi/agent/auth.json) so that this helper's
+* read/write logic is unchanged from the Pi side.
+*
+* This module:
+*   - reads/writes the openai-codex credential under ~/.omp/agent/auth.json,
+*   - reports auth status (for `pan doctor` and the conversation spawn gate),
+*   - refreshes an expired-but-recoverable token, and
+*   - drives omp's headless device-code login to re-authenticate.
+*
+* The OAuth module is loaded from the installed `omp` package dynamically.
+* A missing or relocated omp OAuth module degrades to 'unavailable' — never throws.
+*/
+const PI_CODEX_PROVIDER = "openai-codex";
+function getOhmypiAuthPath() {
+	return join(homedir(), ".omp", "agent", "auth.json");
+}
+function readAuthFile() {
+	const path = getOhmypiAuthPath();
+	if (!existsSync(path)) return {};
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8"));
+		return parsed && typeof parsed === "object" ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function readOhmypiCodexCredential() {
+	const cred = readAuthFile()[PI_CODEX_PROVIDER];
+	if (cred && typeof cred === "object" && typeof cred["access"] === "string" && typeof cred["refresh"] === "string") return cred;
+	return null;
+}
+/** Atomically merge a fresh codex credential into auth.json (mode 0600). */
+function writeOhmypiCodexCredential(tokens) {
+	const path = getOhmypiAuthPath();
+	mkdirSync(dirname(path), { recursive: true });
+	const auth = readAuthFile();
+	const stored = {
+		type: "oauth",
+		access: tokens.access,
+		refresh: tokens.refresh,
+		expires: tokens.expires,
+		accountId: tokens.accountId
+	};
+	auth[PI_CODEX_PROVIDER] = stored;
+	const tmp = `${path}.tmp-${process.pid}`;
+	writeFileSync(tmp, JSON.stringify(auth, null, 2), { mode: 384 });
+	renameSync(tmp, path);
+	return stored;
+}
+/** Locate the `omp` executable on PATH (no subprocess — event-loop safe). */
+function findOmpBinary() {
+	for (const dir of (process.env["PATH"] ?? "").split(delimiter)) {
+		if (!dir) continue;
+		const candidate = join(dir, "omp");
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+/** omp is @oh-my-pi/pi-coding-agent; the oauth submodule path mirrors pi-ai's layout. */
+const OMP_AI_OAUTH_SUBPATH = join("@oh-my-pi", "pi-ai", "dist", "utils", "oauth", "openai-codex.js");
+/**
+* Resolve omp's openai-codex OAuth submodule by walking node_modules upward
+* from the real omp binary. Returns null when not found — the caller degrades
+* gracefully to 'unavailable' status.
+*/
+function resolveOmpCodexOAuthFile(ompBin) {
+	let dir = dirname(realpathSync(ompBin));
+	for (let i = 0; i < 10; i++) {
+		const candidate = join(dir, "node_modules", OMP_AI_OAUTH_SUBPATH);
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+let cachedModule = null;
+/**
+* Dynamically load omp's openai-codex OAuth submodule from the installed `omp`
+* package. Returns null on any failure so callers can degrade gracefully.
+*/
+async function loadOhmypiCodexOAuth() {
+	if (cachedModule) return cachedModule;
+	cachedModule = (async () => {
+		try {
+			const ompBin = findOmpBinary();
+			if (!ompBin) return null;
+			const oauthFile = resolveOmpCodexOAuthFile(ompBin);
+			if (!oauthFile) return null;
+			const mod = await import(pathToFileURL(oauthFile).href);
+			if (typeof mod.refreshOpenAICodexToken !== "function" || typeof mod.loginOpenAICodexDeviceCode !== "function") return null;
+			return mod;
+		} catch {
+			return null;
+		}
+	})();
+	return cachedModule;
+}
+const EXPIRY_MARGIN_MS = 6e4;
+async function getOhmypiCodexAuthStatus(opts) {
+	const cred = readOhmypiCodexCredential();
+	if (!cred) return { status: "missing" };
+	if (cred.expires > Date.now() + EXPIRY_MARGIN_MS) return {
+		status: "ok",
+		expiresAt: cred.expires
+	};
+	if (opts?.refreshIfExpired) {
+		const refreshed = await refreshOhmypiCodexAuth();
+		if (refreshed) return {
+			status: "ok",
+			expiresAt: refreshed.expires
+		};
+		return {
+			status: "expired",
+			expiresAt: cred.expires,
+			refreshFailed: true
+		};
+	}
+	return {
+		status: "expired",
+		expiresAt: cred.expires,
+		refreshFailed: false
+	};
+}
+async function refreshOhmypiCodexAuth() {
+	const cred = readOhmypiCodexCredential();
+	if (!cred?.refresh) return null;
+	const mod = await loadOhmypiCodexOAuth();
+	if (!mod) return null;
+	try {
+		return writeOhmypiCodexCredential(await mod.refreshOpenAICodexToken(cred.refresh));
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region services/conversation-attachments.ts
+init_paths();
+const CONVERSATION_ATTACHMENTS_DIR = "conversation-attachments";
+/** Run async tasks in bounded batches to avoid unbounded Promise.all
+*  that can exhaust file descriptors or memory under heavy load. */
+async function runInBatches(items, batchSize, fn) {
+	for (let i = 0; i < items.length; i += batchSize) {
+		const batch = items.slice(i, i + batchSize);
+		await Promise.all(batch.map(fn));
+	}
+}
+/** Max JSONL line length to process. Lines larger than this are skipped to
+*  prevent readline from stalling permanently on oversized input (e.g. a
+*  single-line base64 payload >15 MB). */
+const MAX_JSONL_LINE_LENGTH = 15 * 1024 * 1024;
+/** Bounded LRU cache for readSessionAttachmentBasenames to avoid full JSONL
+*  rescans when the session file has not changed. Key = sessionFile:mtimeMs. */
+const SESSION_ATTACHMENT_CACHE_MAX = 100;
+const sessionAttachmentCache = /* @__PURE__ */ new Map();
+function getAttachmentCacheKey(sessionFile, mtimeMs) {
+	return `${sessionFile}:${mtimeMs}`;
+}
+function setAttachmentCache(sessionFile, mtimeMs, basenames) {
+	const key = getAttachmentCacheKey(sessionFile, mtimeMs);
+	sessionAttachmentCache.set(key, basenames);
+	if (sessionAttachmentCache.size > SESSION_ATTACHMENT_CACHE_MAX) {
+		const firstKey = sessionAttachmentCache.keys().next().value;
+		if (firstKey !== void 0) sessionAttachmentCache.delete(firstKey);
+	}
+}
+function getAttachmentCache(sessionFile, mtimeMs) {
+	const key = getAttachmentCacheKey(sessionFile, mtimeMs);
+	return sessionAttachmentCache.get(key);
+}
+/** Conversation names are sanitized to [a-zA-Z0-9_-]{1,64} on creation.
+*  Re-validate here for defense-in-depth against path traversal. */
+function assertSafeName(name) {
+	if (!/^[a-zA-Z0-9_-]{1,64}$/.test(name)) throw new Error("Invalid conversation name");
+}
+function getConversationAttachmentsRoot() {
+	return join(getOverdeckHome(), CONVERSATION_ATTACHMENTS_DIR);
+}
+function getConversationAttachmentDir(name) {
+	assertSafeName(name);
+	return join(getConversationAttachmentsRoot(), name);
+}
+async function ensureConversationAttachmentDir(name) {
+	const dir = getConversationAttachmentDir(name);
+	await mkdir(dir, { recursive: true });
+	return dir;
+}
+async function cleanupConversationAttachments(name) {
+	assertSafeName(name);
+	await rm(getConversationAttachmentDir(name), {
+		recursive: true,
+		force: true
+	});
+}
+/** Safety-net cleanup: remove attachment directories for conversations that no
+*  longer exist in the database. Catches orphaned files from abandoned/crashed
+*  sessions that the lifecycle poller missed. */
+async function cleanupOrphanedConversationAttachments() {
+	try {
+		const { listConversations } = await import("./conversations-BM7zlXjr.js");
+		const convNames = new Set(listConversations().map((c) => c.name));
+		const root = getConversationAttachmentsRoot();
+		await runInBatches((await readdir(root, { withFileTypes: true })).filter((entry) => entry.isDirectory() && !convNames.has(entry.name)).map((entry) => join(root, entry.name)), 10, (path) => rm(path, {
+			recursive: true,
+			force: true
+		}).catch(() => {}));
+	} catch {}
+}
+async function listConversationAttachmentPaths(name) {
+	const dir = getConversationAttachmentDir(name);
+	try {
+		return (await readdir(dir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => join(dir, entry.name));
+	} catch {
+		return [];
+	}
+}
+/** Synchronous containment check: does the normalized path start with the
+*  pre-resolved attachment directory prefix?  Uses resolve() (not realpath)
+*  so the check is I/O-free — safe because we are only cataloguing references
+*  in the JSONL, not accessing the filesystem. */
+function isUnderAttachmentDir(resolvedAttachmentDir, attachmentPath) {
+	try {
+		return resolve(attachmentPath).startsWith(`${resolvedAttachmentDir}/`);
+	} catch {
+		return false;
+	}
+}
+async function readSessionAttachmentBasenames(sessionFile, name) {
+	try {
+		let mtimeMs;
+		try {
+			mtimeMs = (await stat$1(sessionFile)).mtimeMs;
+		} catch {
+			return /* @__PURE__ */ new Set();
+		}
+		const cached = getAttachmentCache(sessionFile, mtimeMs);
+		if (cached) return cached;
+		let resolvedAttachmentDir;
+		try {
+			resolvedAttachmentDir = await realpath(getConversationAttachmentDir(name));
+		} catch {
+			resolvedAttachmentDir = resolve(getConversationAttachmentDir(name));
+		}
+		const referenced = /* @__PURE__ */ new Set();
+		const stream = createReadStream(sessionFile, { encoding: "utf-8" });
+		const rl = createInterface({
+			input: stream,
+			crlfDelay: Infinity
+		});
+		try {
+			for await (const line of rl) {
+				if (!line.trim()) continue;
+				if (line.length > MAX_JSONL_LINE_LENGTH) continue;
+				let text;
+				let structuredFoundPaths = false;
+				try {
+					const entry = JSON.parse(line);
+					if (typeof entry?.message?.content === "string") text = entry.message.content;
+					else if (Array.isArray(entry?.message?.content)) text = entry.message.content.map((c) => typeof c === "string" ? c : c?.text ?? "").join("");
+					else if (typeof entry?.message?.text === "string") text = entry.message.text;
+					else if (typeof entry?.text === "string") text = entry.text;
+				} catch {
+					text = line;
+				}
+				if (text) {
+					for (const attachmentPath of extractConversationAttachmentPaths(text)) if (isUnderAttachmentDir(resolvedAttachmentDir, attachmentPath)) {
+						referenced.add(basename(attachmentPath));
+						structuredFoundPaths = true;
+					}
+				}
+				if (!structuredFoundPaths) for (const match of line.matchAll(/"@([^"]+)"/g)) {
+					const rawValue = match[1];
+					if (!rawValue.startsWith("/") && !rawValue.startsWith("\\/")) continue;
+					let attachmentPath;
+					try {
+						attachmentPath = JSON.parse(`"${rawValue}"`);
+					} catch {
+						attachmentPath = rawValue;
+					}
+					if (typeof attachmentPath === "string" && attachmentPath.startsWith("/")) {
+						if (isUnderAttachmentDir(resolvedAttachmentDir, attachmentPath)) referenced.add(basename(attachmentPath));
+					}
+				}
+			}
+		} finally {
+			rl.close();
+			stream.destroy();
+		}
+		setAttachmentCache(sessionFile, mtimeMs, referenced);
+		return referenced;
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+async function cleanupUnreferencedConversationAttachments(conversation) {
+	const attachmentPaths = await listConversationAttachmentPaths(conversation.name);
+	if (attachmentPaths.length === 0) return;
+	if (!conversation.sessionFile) {
+		await runInBatches(attachmentPaths, 10, async (attachmentPath) => {
+			await rm(attachmentPath, { force: true });
+		});
+		return;
+	}
+	let sessionMtimeMs;
+	try {
+		sessionMtimeMs = (await stat$1(conversation.sessionFile)).mtimeMs;
+	} catch {
+		return;
+	}
+	const referencedBasenames = await readSessionAttachmentBasenames(conversation.sessionFile, conversation.name);
+	try {
+		const freshStats = await stat$1(conversation.sessionFile);
+		if (freshStats.mtimeMs > sessionMtimeMs) sessionMtimeMs = freshStats.mtimeMs;
+	} catch {}
+	await runInBatches(attachmentPaths, 10, async (attachmentPath) => {
+		if (referencedBasenames.has(basename(attachmentPath))) return;
+		try {
+			if ((await stat$1(attachmentPath)).mtimeMs >= sessionMtimeMs) return;
+		} catch {
+			return;
+		}
+		await rm(attachmentPath, { force: true });
+	});
+}
+function extractConversationAttachmentPaths(message) {
+	return Array.from(message.matchAll(/(?<!\S)@(\/[^\s]+)/g), ([, attachmentPath]) => {
+		let path = attachmentPath;
+		while (path.length > 1 && /[.,;:!?)\]}+"']$/.test(path)) path = path.slice(0, -1);
+		return path;
+	});
+}
+/** Resolve a path for containment checking, walking parent directories with
+*  realpath to preserve symlink detection even when the target file is missing. */
+async function resolveForContainment(attachmentPath) {
+	try {
+		return await realpath(attachmentPath);
+	} catch {
+		let dir = dirname(attachmentPath);
+		const remaining = [basename(attachmentPath)];
+		while (dir !== "/" && dir !== ".") try {
+			return join(await realpath(dir), ...remaining);
+		} catch {
+			remaining.unshift(basename(dir));
+			dir = dirname(dir);
+		}
+		return resolve(attachmentPath);
+	}
+}
+async function isManagedConversationAttachmentPath(attachmentPath) {
+	try {
+		const attachmentsRoot = await realpath(getConversationAttachmentsRoot());
+		return (await resolveForContainment(attachmentPath)).startsWith(`${attachmentsRoot}/`);
+	} catch {
+		return false;
+	}
+}
+async function isConversationAttachmentPath(name, attachmentPath) {
+	try {
+		const attachmentDir = resolve(getConversationAttachmentDir(name));
+		return (await resolveForContainment(attachmentPath)).startsWith(`${attachmentDir}/`);
+	} catch {
+		return false;
+	}
+}
+async function hasConversationAttachment(name, attachmentPath) {
+	try {
+		const attachmentDir = await realpath(getConversationAttachmentDir(name));
+		const candidate = await resolveForContainment(attachmentPath);
+		if (!candidate.startsWith(`${attachmentDir}/`)) return false;
+		return existsSync(candidate);
+	} catch {
+		return false;
+	}
+}
+async function removeConversationAttachment(name, attachmentPath) {
+	if (!await isConversationAttachmentPath(name, attachmentPath)) return false;
+	await rm(attachmentPath, { force: true });
+	return true;
+}
+//#endregion
+//#region ../../lib/overdeck/conversation-runtime.ts
+init_projects();
+init_tmux();
+init_agents();
+init_behavior();
+init_paths();
+const execAsync$1 = promisify(exec);
+const execFileAsync$1 = promisify(execFile);
+const PROCESS_CLEANUP_GRACE_MS = 750;
+const PTY_SUPERVISOR_SOCKET_WAIT_MS = 3e4;
+function parseProcessTable(output) {
+	return output.split("\n").map((line) => {
+		const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.*)$/);
+		if (!match) return null;
+		return {
+			pid: Number(match[1]),
+			ppid: Number(match[2]),
+			args: match[3] ?? ""
+		};
+	}).filter((row) => row !== null && Number.isFinite(row.pid) && Number.isFinite(row.ppid));
+}
+async function readProcessTable() {
+	const { stdout } = await execFileAsync$1("ps", ["-eo", "pid=,ppid=,args="], {
+		encoding: "utf-8",
+		maxBuffer: 10 * 1024 * 1024
+	});
+	return parseProcessTable(stdout);
+}
+function collectProcessTree(rootPids, rows) {
+	const childrenByParent = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const children = childrenByParent.get(row.ppid) ?? [];
+		children.push(row.pid);
+		childrenByParent.set(row.ppid, children);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const ordered = [];
+	const visit = (pid) => {
+		if (seen.has(pid) || pid === process.pid) return;
+		seen.add(pid);
+		for (const child of childrenByParent.get(pid) ?? []) visit(child);
+		ordered.push(pid);
+	};
+	for (const pid of rootPids) visit(pid);
+	return ordered;
+}
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function terminatePids(pids) {
+	if (pids.length === 0) return;
+	for (const pid of pids) try {
+		process.kill(pid, "SIGTERM");
+	} catch {}
+	await new Promise((resolve) => setTimeout(resolve, PROCESS_CLEANUP_GRACE_MS));
+	for (const pid of pids) {
+		if (!isProcessAlive(pid)) continue;
+		try {
+			process.kill(pid, "SIGKILL");
+		} catch {}
+	}
+}
+function conversationRuntimeRootPids(conv, rows) {
+	const launcherScript = join(getOverdeckHome(), "conversations", conv.tmuxSession, "launcher.sh");
+	const sessionId = conv.claudeSessionId?.trim();
+	const sessionNeedles = sessionId ? [`--resume ${sessionId}`, `--session-id ${sessionId}`] : [];
+	const serverPid = findManagedServerPidSync();
+	return rows.filter((row) => {
+		if (row.pid === process.pid) return false;
+		if (serverPid !== void 0 && row.pid === serverPid) return false;
+		if (row.args.includes(launcherScript)) return true;
+		return sessionNeedles.some((needle) => row.args.includes(needle));
+	}).map((row) => row.pid);
+}
+async function killConversationRuntimeProcesses(conv) {
+	const rows = await readProcessTable();
+	await terminatePids(collectProcessTree(conversationRuntimeRootPids(conv, rows), rows));
+}
+async function stopConversationRuntime(conv, name) {
+	if (hasOtherActiveConversationOnTmuxSession(conv.tmuxSession, name)) return;
+	await Effect.runPromise(killSession(conv.tmuxSession).pipe(Effect.catch(() => Effect.succeed(void 0))));
+	try {
+		await killConversationRuntimeProcesses(conv);
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		console.warn(`[conversations] failed to cleanup runtime processes for ${name}: ${msg}`);
+	}
+}
+/** Quote a string for safe use in a bash script using single-quote wrapping. */
+function shellQuote(str) {
+	return "'" + str.replace(/'/g, "'\"'\"'") + "'";
+}
+const SAFE_MODEL_PATTERN = /^[a-zA-Z0-9_.:\/-]+$/;
+const SAFE_EFFORT_PATTERN = /^(low|medium|high)$/;
+const SAFE_ISSUE_ID_PATTERN = /^[A-Z0-9]+-[0-9]+$/;
+const PI_CONVERSATION_SOURCE_CONTRACT = [
+	"Pi conversation source contract:",
+	"A message marked source:'extension' was injected by the Overdeck orchestrator or another agent, not typed by the human operator.",
+	"Treat it as coordination guidance; do not attribute it to the human operator."
+].join(" ");
+async function resolveAllowedHarness(requested, model) {
+	if (!model) return "claude-code";
+	return resolveHarness({
+		model,
+		explicit: requested === "ohmypi" || requested === "claude-code" || requested === "codex" ? requested : void 0
+	});
+}
+async function isInsideGitWorkTree(dir) {
+	try {
+		const { stdout } = await execAsync$1("git rev-parse --is-inside-work-tree", {
+			cwd: dir,
+			encoding: "utf-8"
+		});
+		return stdout.trim() === "true";
+	} catch {
+		return false;
+	}
+}
+async function validateCwdContainment(cwd) {
+	if (!cwd.startsWith("/")) return false;
+	if (cwd.split("/").filter(Boolean).includes("..")) return false;
+	try {
+		const resolved = await realpath(cwd);
+		if (!(await stat$1(resolved)).isDirectory()) return false;
+		const home = homedir();
+		return resolved.startsWith(`${home}/`) || resolved === home;
+	} catch {
+		return false;
+	}
+}
+async function waitForClaudeReady(tmuxSession) {
+	const deadline = Date.now() + 3e4;
+	while (Date.now() < deadline) {
+		if ((await Effect.runPromise(capturePane(tmuxSession, 200))).includes("❯")) {
+			console.log(`[conversations] Claude Code ready in ${tmuxSession}`);
+			return;
+		}
+		await new Promise((r) => setTimeout(r, 500));
+	}
+	console.warn(`[conversations] Timed out waiting for Claude Code prompt in ${tmuxSession}`);
+}
+function isPiTuiInputReady(snapshot) {
+	return /^\s*[❯›>]\s/m.test(snapshot) || /(?:^|\s)0(?:\.\d+)?%\s+context\s+used\b/i.test(snapshot) || /⬢[^\n]*◕/.test(snapshot);
+}
+async function waitForPiTuiReady(tmuxSession, timeoutMs = 6e4) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (isPiTuiInputReady(await Effect.runPromise(capturePane(tmuxSession, 40).pipe(Effect.catch(() => Effect.succeed("")))))) {
+			console.log(`[conversations] Pi TUI ready for ${tmuxSession}`);
+			return true;
+		}
+		await new Promise((r) => setTimeout(r, 250));
+	}
+	console.warn(`[conversations] Timed out waiting for Pi TUI to render in ${tmuxSession}`);
+	return false;
+}
+function shouldReportUnresolvedLiveSession(conv) {
+	if (!conv || conv.status !== "active") return false;
+	return getHarnessBehavior(conv.harness).transcriptKind === "claude-jsonl";
+}
+function conversationSessionAliveFromState(conv, tmuxSessionAlive) {
+	return conv.status === "active" && !conv.forkStatus && tmuxSessionAlive;
+}
+function conversationNeedsRunningRepair(conv, tmuxSessionAlive, harnessProcessAlive) {
+	return conv.status === "ended" && !conv.forkStatus && tmuxSessionAlive && harnessProcessAlive;
+}
+/** Generate a default conversation name, e.g. 20260404-1234 */
+function generateConversationName() {
+	return `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "")}-${Math.floor(Math.random() * 9e3 + 1e3)}`;
+}
+async function tmuxSessionExists(sessionName) {
+	return Effect.runPromise(sessionExists(sessionName));
+}
+async function waitForTmuxSession(sessionName, timeoutMs = 3e4) {
+	const start = Date.now();
+	while (Date.now() - start < timeoutMs) {
+		if (await Effect.runPromise(sessionExists(sessionName))) return;
+		await new Promise((r) => setTimeout(r, 250));
+	}
+	throw new Error(`Timed out waiting for tmux session ${sessionName}`);
+}
+function shouldUseSupervisorForConversation(harness) {
+	return getHarnessBehavior(harness).supportsPtySupervisor && process.env.OVERDECK_DOCKER_WORKSPACE !== "1" && process.env.PAN_DOCKER !== "1";
+}
+async function waitForConversationRuntimeReady(tmuxSession, harness, mode) {
+	const transcriptKind = getHarnessBehavior(harness).transcriptKind;
+	if (transcriptKind === "ohmypi-jsonl") {
+		if (!await waitForPiTuiReady(tmuxSession)) throw new Error(`Pi (ohmypi) did not become interactive in ${tmuxSession} within the startup window — MCP server connections are likely still in progress. Retry once MCP servers finish connecting, or check ~/.claude/mcp.json for a slow/hanging server.`);
+	} else if (transcriptKind !== "codex-rollout-jsonl" && mode === "spawn") {
+		await waitForClaudeReady(tmuxSession);
+		console.log(`[conversations] Claude ready in ${tmuxSession}`);
+	} else if (transcriptKind !== "codex-rollout-jsonl") await waitForReadySignal(tmuxSession, 30);
+}
+async function handleConversationSwitchModel(name, body) {
+	const conv = getConversationByName(name);
+	if (!conv) return jsonResponse({ error: "Conversation not found" }, { status: 404 });
+	const model = typeof body["model"] === "string" && body["model"].trim() ? body["model"].trim() : conv.model ?? void 0;
+	const currentHarness = conv.harness ?? "claude-code";
+	const requestedHarness = body["harness"];
+	let harness = currentHarness;
+	if (requestedHarness === "ohmypi" || requestedHarness === "pi" || requestedHarness === "claude-code" || requestedHarness === "codex") {
+		const requestedRuntime = requestedHarness === "pi" ? "ohmypi" : requestedHarness;
+		if (requestedRuntime !== currentHarness) {
+			const policyModel = model ?? conv.model ?? "";
+			const decision = canUseHarnessSync(requestedRuntime, policyModel, await getProviderAuthMode(policyModel));
+			if (!decision.allowed) return jsonResponse({ error: decision.reason ?? "Harness not allowed for this model" }, { status: 400 });
+		}
+		harness = requestedRuntime;
+	}
+	const harnessChanged = harness !== currentHarness;
+	if (!await validateCwdContainment(conv.cwd)) return jsonResponse({ error: "Invalid cwd" }, { status: 400 });
+	if (model && !SAFE_MODEL_PATTERN.test(model)) return jsonResponse({ error: "Invalid model" }, { status: 400 });
+	const livePiSwitch = isPiControlChannelHarness(currentHarness) && conv.status !== "ended";
+	if (conv.claudeSessionId && harnessChanged) return jsonResponse({ error: "Conversation harness is locked once a conversation has started" }, { status: 409 });
+	if (conv.claudeSessionId && !livePiSwitch) return jsonResponse({ error: "Conversation model is locked once a conversation has started" }, { status: 409 });
+	if (model) {
+		if (livePiSwitch) await sendConversationControlCommand(conv, {
+			type: "set_model",
+			model
+		});
+		setConversationModel(name, model);
+	}
+	if (harnessChanged) setConversationHarness(name, harness);
+	const updated = getConversationByName(name) ?? conv;
+	return jsonResponse({
+		...updated,
+		model: model ?? updated.model,
+		harness,
+		sessionAlive: false
+	});
+}
+function getPtySupervisorSocketPath(agentId) {
+	return join(getOverdeckHome(), "sockets", `pty-${agentId}.sock`);
+}
+async function waitForPtySupervisorSocket(agentId, timeoutMs = PTY_SUPERVISOR_SOCKET_WAIT_MS) {
+	const socketPath = getPtySupervisorSocketPath(agentId);
+	const start = Date.now();
+	while (Date.now() - start < timeoutMs) {
+		try {
+			if (((await stat$1(socketPath)).mode & 511) === 384) return;
+		} catch {}
+		await new Promise((r) => setTimeout(r, 250));
+	}
+	throw new Error(`Timed out waiting for PTY supervisor socket ${socketPath}`);
+}
+async function extractModelFromSessionFile(sessionFile) {
+	try {
+		if (!existsSync(sessionFile)) return null;
+		const stream = createReadStream(sessionFile, { encoding: "utf-8" });
+		const rl = createInterface({
+			input: stream,
+			crlfDelay: Infinity
+		});
+		try {
+			for await (const line of rl) {
+				if (!line.trim()) continue;
+				const entry = JSON.parse(line);
+				if (entry.type === "assistant" && entry.message?.model) return entry.message.model;
+			}
+		} finally {
+			rl.close();
+			stream.destroy();
+		}
+	} catch {}
+	return null;
+}
+let backfillRunning = false;
+async function backfillConversationModels(resolveSessionFile) {
+	if (backfillRunning) return;
+	backfillRunning = true;
+	try {
+		const convs = listConversations();
+		const probe = await Promise.all(convs.map(async (conv) => !conv.model ? await resolveSessionFile(conv) : null));
+		const candidates = convs.filter((_, i) => probe[i] !== null);
+		const BATCH_SIZE = 10;
+		let backfilled = 0;
+		for (let i = 0; i < candidates.length; i += BATCH_SIZE) {
+			const batch = candidates.slice(i, i + BATCH_SIZE);
+			const results = await Promise.all(batch.map(async (conv) => {
+				const sessionFile = await resolveSessionFile(conv);
+				if (!sessionFile) return false;
+				const model = await extractModelFromSessionFile(sessionFile);
+				if (model && SAFE_MODEL_PATTERN.test(model)) {
+					backfillConversationModel(conv.name, model);
+					return true;
+				}
+				return false;
+			}));
+			backfilled += results.filter(Boolean).length;
+		}
+		if (backfilled > 0) console.log(`[conversations] Backfilled model for ${backfilled} conversation(s)`);
+	} finally {
+		backfillRunning = false;
+	}
+}
+function startConversationModelBackfill(resolveSessionFile) {
+	backfillConversationModels(resolveSessionFile).catch((err) => {
+		console.error("[conversations] Model backfill failed:", err);
+	});
+}
+async function claudeConversationSystemPromptFiles(cwd) {
+	const files = [];
+	const contextFile = workspaceContextFile(cwd);
+	try {
+		await stat$1(contextFile);
+		files.push(contextFile);
+	} catch (error) {
+		if (!isNotFound(error)) throw error;
+	}
+	files.push(await ensureSessionContextBriefingFile());
+	return files;
+}
+async function ensurePiConversationSourceContractFile() {
+	const contextDir = join(getOverdeckHome(), "context");
+	await mkdir(contextDir, { recursive: true });
+	const path = join(contextDir, "pi-conversation-source-contract.md");
+	await writeFile(path, `${PI_CONVERSATION_SOURCE_CONTRACT}\n`, "utf-8");
+	return path;
+}
+async function piConversationSystemPromptFiles(cwd) {
+	const files = [];
+	const globalFile = piGlobalContextFile();
+	try {
+		await stat$1(globalFile);
+		files.push(globalFile);
+	} catch (error) {
+		if (!isNotFound(error)) throw error;
+	}
+	files.push(await ensurePiConversationSourceContractFile());
+	const contextFile = workspaceContextFile(cwd);
+	try {
+		await stat$1(contextFile);
+		files.push(contextFile);
+	} catch (error) {
+		if (!isNotFound(error)) throw error;
+	}
+	files.push(await ensureSessionContextBriefingFile());
+	return files;
+}
+function isNotFound(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function spawnConversationSession(tmuxSession, cwd, claudeSessionId, model, effort, issueId, resume = false, harness = "claude-code", plainFork = false) {
+	const behavior = getHarnessBehavior(harness);
+	const stateDir = join(getOverdeckHome(), "conversations", tmuxSession);
+	await mkdir(stateDir, { recursive: true });
+	clearReadySignal(tmuxSession);
+	const launcherScript = join(stateDir, "launcher.sh");
+	let runtimeCommand = `claude ${getClaudePermissionFlagsStringSync()}`;
+	let providerExportsStr = "";
+	let piFields;
+	let codexFields;
+	if (model) {
+		if (!SAFE_MODEL_PATTERN.test(model)) throw new Error("Invalid model name");
+		runtimeCommand = await getAgentRuntimeBaseCommand(model, void 0, void 0, harness);
+		const mode = resolvePermissionModeSync();
+		if (!runtimeCommand.includes("--permission-mode")) runtimeCommand = `${runtimeCommand} --permission-mode ${mode === "auto" ? "auto" : BYPASS_PERMISSION_MODE}`;
+		providerExportsStr = (await getProviderExportsForModel(model)).trim();
+		await getProviderEnvForModel(model);
+		if (behavior.transcriptKind === "ohmypi-jsonl") {
+			if (getProviderForModelSync(model).name === "openai") {
+				const auth = await getOhmypiCodexAuthStatus({ refreshIfExpired: true });
+				if (auth.status === "missing" || auth.status === "expired") throw new Error("ohmypi ChatGPT/Codex login (openai-codex) has expired and could not be refreshed. Re-authenticate with `pan pi-auth login`, then retry.");
+			}
+			const paths = piFifoPaths(tmuxSession);
+			const piSessionDir = join(paths.agentDir, "sessions");
+			await mkdir(paths.agentDir, {
+				recursive: true,
+				mode: 448
+			});
+			await mkdir(piSessionDir, {
+				recursive: true,
+				mode: 448
+			});
+			const storedPiSessionId = resume ? await readFile(join(paths.agentDir, "session.id"), "utf-8").then((s) => s.trim()).catch(() => void 0) : void 0;
+			piFields = {
+				harness: "ohmypi",
+				piMode: "tui",
+				piExtensionPath: resolveOhmypiExtensionPath() ?? resolve(process.cwd(), "packages/ohmypi-extension/dist/index.js"),
+				piSessionDir,
+				resumeSessionId: storedPiSessionId || void 0
+			};
+		} else if (behavior.usesCodexHome) {
+			const codexHome = join(getOverdeckHome(), "agents", tmuxSession, "codex-home");
+			const codexPermMode = loadConfigSync().config.codex?.permissionMode ?? "workspace";
+			const codexApprovalPolicy = codexPermMode === "full-access" ? "never" : "on-request";
+			const codexSandboxMode = codexPermMode === "full-access" ? "danger-full-access" : codexPermMode === "read-only" ? "read-only" : "workspace-write";
+			const codexApprovalsReviewer = codexPermMode === "auto-review" ? "auto_review" : void 0;
+			const { initCodexHome, extractThreadIdFromRollout } = await import("./codex-BYPz6ZdF.js");
+			initCodexHome(codexHome, {
+				trustedDir: cwd,
+				approvalPolicy: codexApprovalPolicy,
+				sandboxMode: codexSandboxMode,
+				approvalsReviewer: codexApprovalsReviewer
+			});
+			const resumeSessionId = resume ? await resolveCodexRolloutPath(tmuxSession, { agentsDirOverride: join(getOverdeckHome(), "agents") }).then((rollout) => rollout ? extractThreadIdFromRollout(rollout) ?? void 0 : void 0) : void 0;
+			codexFields = {
+				harness: "codex",
+				codexMode: "tui",
+				codexHome,
+				codexSessionDir: join(codexHome, "sessions"),
+				resumeSessionId
+			};
+		}
+	}
+	let launcherModel = model;
+	if (behavior.contextLayerKind === "pi" && model) {
+		const piProvider = piProviderForModel(model);
+		if (piProvider) launcherModel = `${piProvider}/${model}`;
+	}
+	if (effort && !SAFE_EFFORT_PATTERN.test(effort)) throw new Error("Invalid effort level");
+	const useSupervisor = shouldUseSupervisorForConversation(harness);
+	let supervisorScriptPath;
+	if (useSupervisor) {
+		supervisorScriptPath = resolvePtySupervisorScriptPath();
+		await writePtyToken(tmuxSession);
+	}
+	let channelsBridgeMcpConfig;
+	if (!piFields && !codexFields && !plainFork && isClaudeCodeChannelsEnabled() && (!model || getProviderForModelSync(model).name === "anthropic") && process.env.CLAUDE_CODE_USE_BEDROCK !== "1" && process.env.CLAUDE_CODE_USE_VERTEX !== "1" && process.env.CLAUDE_CODE_USE_FOUNDRY !== "1" && process.env.OVERDECK_DOCKER_WORKSPACE !== "1" && process.env.PAN_DOCKER !== "1") {
+		channelsBridgeMcpConfig = join(stateDir, "agent-mcp.json");
+		writeBridgeTokenSync(tmuxSession);
+		await writeChannelsBridgeMcpConfig(channelsBridgeMcpConfig, tmuxSession);
+	}
+	const launcherTmp = `${launcherScript}.${randomUUID$1()}.tmp`;
+	await writeFile(launcherTmp, generateLauncherScriptSync({
+		role: "work",
+		spawnMode: "conversation",
+		workingDir: cwd,
+		setTerminalEnv: true,
+		unsetProviderEnv: true,
+		overdeckEnv: {
+			...issueId ? { issueId } : {},
+			...piFields || codexFields || useSupervisor ? { agentId: tmuxSession } : {}
+		},
+		extraEnvExports: [`export OVERDECK_DASHBOARD_URL="http://127.0.0.1:${process.env["API_PORT"] ?? process.env["PORT"] ?? "3011"}"`],
+		providerExports: providerExportsStr || void 0,
+		trapHup: true,
+		baseCommand: runtimeCommand,
+		appendSystemPromptFiles: piFields ? await piConversationSystemPromptFiles(cwd) : codexFields ? [] : await claudeConversationSystemPromptFiles(cwd),
+		model: launcherModel,
+		...piFields ?? codexFields ?? {
+			resumeSessionId: resume ? claudeSessionId : void 0,
+			sessionId: resume ? void 0 : claudeSessionId
+		},
+		extraArgs: !piFields && effort ? `--effort "${effort}"` : void 0,
+		keepAlive: true,
+		fileMode: 448,
+		channelsBridgeMcpConfig,
+		useSupervisor,
+		supervisorScriptPath
+	}), { mode: 448 });
+	await rename(launcherTmp, launcherScript);
+	try {
+		await Effect.runPromise(killSession(tmuxSession));
+	} catch {}
+	console.log(`[claude-invoke] purpose=conversation-session | model=${model || "default"} | source=conversations.ts:spawnConversationSession | session=${tmuxSession} | resume=${resume} | command="${runtimeCommand}"`);
+	try {
+		const { preTrustDirectory } = await import("./workspace-manager-BO-6k3sP.js");
+		preTrustDirectory(cwd);
+	} catch {}
+	try {
+		await Effect.runPromise(createSession(tmuxSession, cwd, `bash ${shellQuote(launcherScript)}`, { env: {
+			...BLANKED_PROVIDER_ENV,
+			TERM: "xterm-256color"
+		} }));
+	} catch (err) {
+		if (err?.code === "ENOENT") throw new Error("tmux is not installed. Install it with: brew install tmux (macOS) or sudo apt-get install tmux (Linux)");
+		throw err;
+	}
+	if (useSupervisor) await waitForPtySupervisorSocket(tmuxSession);
+	if (behavior.usesCodexHome && codexFields?.codexHome) {
+		const codexHomeDir = codexFields.codexHome;
+		(async () => {
+			try {
+				const { waitForCodexRollout, extractThreadIdFromRollout, writeThreadId } = await import("./codex-BYPz6ZdF.js");
+				const rollout = await waitForCodexRollout(codexHomeDir, 12e4);
+				if (rollout) {
+					const threadId = extractThreadIdFromRollout(rollout);
+					if (threadId) writeThreadId(tmuxSession, threadId);
+				}
+			} catch {}
+		})();
+	}
+	if (channelsBridgeMcpConfig) dismissDevChannelsDialog(tmuxSession).catch((err) => {
+		const msg = err instanceof Error ? err.message : String(err);
+		console.error(`[conversations] dismissDevChannelsDialog failed for ${tmuxSession}: ${msg}`);
+	});
+	await Effect.runPromise(setOption(tmuxSession, "destroy-unattached", "off"));
+	await Effect.runPromise(setOption(exactPaneTarget(tmuxSession), "remain-on-exit", "on"));
+}
+/**
+* Resolve a conversation's cwd from a project identifier.
+*
+* The Command Deck identifies projects by display name, not yaml key
+* (PAN-2590) — accept either, like GET /api/session-trees does.
+*/
+function resolveProjectCwd(projectKey) {
+	const projectConfig = getProjectSync(projectKey) ?? listProjectsSync().find((p) => p.config.name === projectKey)?.config ?? null;
+	if (!projectConfig) return { error: `Unknown project: ${projectKey}` };
+	if (!projectConfig.path || !existsSync(projectConfig.path)) return { error: `Project path does not exist: ${projectConfig.path || "(unset)"} (project: ${projectKey})` };
+	return { cwd: projectConfig.path };
+}
+async function handleConversationCreate(body, deps) {
+	try {
+		const message = typeof body["message"] === "string" ? body["message"].trim() : "";
+		const model = typeof body["model"] === "string" ? body["model"].trim() : void 0;
+		const effort = typeof body["effort"] === "string" ? body["effort"].trim() : void 0;
+		const harness = await resolveAllowedHarness(body["harness"], model);
+		const issueId = typeof body["issueId"] === "string" ? body["issueId"] : void 0;
+		const projectKey = typeof body["projectKey"] === "string" ? body["projectKey"].trim() : void 0;
+		if (issueId && !SAFE_ISSUE_ID_PATTERN.test(issueId)) return jsonResponse({ error: "Invalid issueId" }, { status: 400 });
+		if (model && !SAFE_MODEL_PATTERN.test(model)) return jsonResponse({ error: "Invalid model" }, { status: 400 });
+		if (effort && !SAFE_EFFORT_PATTERN.test(effort)) return jsonResponse({ error: "Invalid effort" }, { status: 400 });
+		let cwd = getDefaultCwd();
+		if (projectKey) {
+			const resolved = resolveProjectCwd(projectKey);
+			if ("error" in resolved) return jsonResponse({ error: resolved.error }, { status: 400 });
+			cwd = resolved.cwd;
+		}
+		if (message && message.length > 5e4) return jsonResponse({ error: "message exceeds maximum length of 50000 characters" }, { status: 400 });
+		let name = generateConversationName();
+		for (let i = 0; i < 5 && getConversationByName(name); i++) name = generateConversationName();
+		const tmuxSession = `conv-${name}`;
+		const claudeSessionId = randomUUID$1();
+		console.log(`[conversations] Creating conversation "${name}" with model=${model ?? "default"} effort=${effort ?? "default"} cwd=${cwd}`);
+		const MAX_TITLE_LEN = 60;
+		const title = message ? message.slice(0, MAX_TITLE_LEN) + (message.length > MAX_TITLE_LEN ? "…" : "") : "New conversation";
+		const conv = createConversation({
+			name,
+			tmuxSession,
+			cwd,
+			issueId,
+			claudeSessionId,
+			title,
+			titleSource: message ? "auto" : "default",
+			titleSeed: title,
+			model,
+			effort,
+			harness
+		});
+		getEventStore().emitOnly({
+			type: "conversation.created",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			payload: { conversationName: name }
+		});
+		(async () => {
+			try {
+				await spawnConversationSession(tmuxSession, cwd, claudeSessionId, model, effort, issueId, false, harness);
+				console.log(`[conversations] tmux session ${tmuxSession} spawned, sessionId: ${claudeSessionId}`);
+				await waitForConversationRuntimeReady(tmuxSession, harness, "spawn");
+				if (message) await deliverAgentMessage(tmuxSession, message, "conversation-message", resolveConversationDeliveryMethod(conv));
+			} catch (spawnErr) {
+				const msg = spawnErr instanceof Error ? spawnErr.message : String(spawnErr);
+				console.error(`[conversations] background spawn failed for ${tmuxSession}: ${msg}`);
+				updateSpawnError(name, msg);
+				getEventStore().emitOnly({
+					type: "conversation.created",
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					payload: { conversationName: name }
+				});
+			}
+		})();
+		if (message) deps.generateAiTitle(name, message).catch((err) => {
+			const msg = err instanceof Error ? err.message : String(err);
+			console.error(`[TITLE-GEN-FAILED] AI title generation FAILED for "${name}" — NO RETRY, NO FALLBACK:`, msg);
+		});
+		return jsonResponse({
+			...conv,
+			sessionAlive: false
+		}, { status: 201 });
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		console.error("[conversations] create conversation failed:", msg);
+		return jsonResponse({ error: msg || "Internal server error" }, { status: error instanceof UnknownModelError ? 400 : 500 });
+	}
+}
+async function handleConversationStop(name, deps) {
+	try {
+		const conv = getConversationByName(name);
+		if (!conv) return jsonResponse({ error: "Conversation not found" }, { status: 404 });
+		await stopConversationRuntime(conv, name);
+		markConversationEnded(name);
+		(async () => {
+			await new Promise((r) => setTimeout(r, 500));
+			await cleanupUnreferencedConversationAttachments({
+				name: conv.name,
+				sessionFile: deps.resolveSessionFileForCleanup?.(conv) ?? null
+			});
+		})();
+		return jsonResponse({ success: true });
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		console.error("[conversations] stop conversation failed:", msg);
+		return jsonResponse({ error: "Internal server error" }, { status: 500 });
+	}
+}
+async function handleConversationResume(name, body, deps) {
+	try {
+		const conv = getConversationByName(name);
+		if (!conv) return jsonResponse({ error: "Conversation not found" }, { status: 404 });
+		const model = typeof body["model"] === "string" && body["model"].trim() ? body["model"].trim() : conv.model ?? void 0;
+		const effort = typeof body["effort"] === "string" && body["effort"].trim() ? body["effort"].trim() : conv.effort ?? void 0;
+		if (await isHarnessProcessAlive(conv.tmuxSession)) {
+			updateLastAttached(name);
+			markConversationActive(name);
+			return jsonResponse({
+				...conv,
+				status: "active",
+				reattached: true
+			});
+		}
+		const oldSessionId = conv.claudeSessionId;
+		const harness = conv.harness ?? "claude-code";
+		const modelChanged = !!model && model !== conv.model;
+		if (!await validateCwdContainment(conv.cwd)) return jsonResponse({ error: "Invalid cwd" }, { status: 400 });
+		if (model && modelChanged && !SAFE_MODEL_PATTERN.test(model)) return jsonResponse({ error: "Invalid model" }, { status: 400 });
+		if (model && modelChanged) setConversationModel(name, model);
+		let canResume = !!oldSessionId;
+		if (oldSessionId) {
+			const resumeFile = await deps.resolveSessionFile(conv);
+			if (!resumeFile || !existsSync(resumeFile)) {
+				canResume = false;
+				console.error(`[conversations] SESSION-LOST ${name} harness=${harness} claudeSessionId=${oldSessionId} resolved=${resumeFile ?? "null"} — resuming with a fresh session`);
+			}
+		}
+		const respawn = markRespawnPending(conv.tmuxSession);
+		try {
+			await spawnConversationSession(conv.tmuxSession, conv.cwd, oldSessionId ?? randomUUID$1(), model, effort, conv.issueId ?? void 0, canResume, harness);
+			await waitForTmuxSession(conv.tmuxSession);
+			await waitForConversationRuntimeReady(conv.tmuxSession, harness, "respawn");
+			markConversationActive(name);
+			return jsonResponse({
+				...conv,
+				status: "active",
+				model: model ?? conv.model,
+				harness,
+				reattached: false,
+				sessionAlive: true
+			});
+		} finally {
+			respawn.done();
+		}
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		console.error("[conversations] resume conversation failed:", msg);
+		return jsonResponse({ error: msg || "Internal server error" }, { status: 500 });
+	}
+}
+async function handleConversationDelete(name, deps) {
+	try {
+		const conv = getConversationByName(name);
+		if (!conv) return jsonResponse({ error: "Conversation not found" }, { status: 404 });
+		await stopConversationRuntime(conv, name);
+		markConversationEnded(name);
+		archiveConversation(name);
+		removeFavorite("conversation", name);
+		deps.invalidateFavoritesCache();
+		await cleanupConversationAttachments(name);
+		return jsonResponse({ success: true });
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		console.error("[conversations] delete conversation failed:", msg);
+		return jsonResponse({ error: "Internal server error" }, { status: 500 });
+	}
+}
+async function handleConversationRestartAll(deps) {
+	try {
+		const allConvs = listConversations();
+		const liveSessionNames = new Set(await Effect.runPromise(listSessionNames()));
+		const convs = allConvs.filter((c) => liveSessionNames.has(c.tmuxSession));
+		const results = [];
+		for (const conv of convs) {
+			const respawn = markRespawnPending(conv.tmuxSession);
+			try {
+				await Effect.runPromise(killSession(conv.tmuxSession).pipe(Effect.catch(() => Effect.succeed(void 0))));
+				const oldSessionId = conv.claudeSessionId;
+				const sessionFileForResume = await deps.resolveSessionFile(conv);
+				const canResume = !!oldSessionId && !!sessionFileForResume && existsSync(sessionFileForResume);
+				const harness = await resolveAllowedHarness(conv.harness, conv.model);
+				await spawnConversationSession(conv.tmuxSession, conv.cwd, oldSessionId ?? randomUUID$1(), conv.model ?? void 0, conv.effort ?? void 0, conv.issueId ?? void 0, canResume, harness);
+				setConversationHarness(conv.name, harness);
+				markConversationActive(conv.name);
+				results.push({
+					name: conv.name,
+					model: conv.model,
+					status: "restarted"
+				});
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				console.error(`[conversations] Failed to restart ${conv.name}:`, msg);
+				results.push({
+					name: conv.name,
+					model: conv.model,
+					status: "failed"
+				});
+			} finally {
+				respawn.done();
+			}
+		}
+		console.log(`[conversations] Restarted ${results.filter((r) => r.status === "restarted").length}/${convs.length} conversations`);
+		return jsonResponse({
+			restarted: results.length,
+			results
+		});
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		console.error("[conversations] restart conversations failed:", msg);
+		return jsonResponse({ error: "Internal server error" }, { status: 500 });
+	}
+}
+//#endregion
+//#region ../../lib/overdeck/conversation-delivery.ts
+init_conversations();
+init_behavior();
+init_tmux();
+init_agents();
+const CONTROL_ACK_TIMEOUT_MS = 1e4;
+const pendingConversationControlAcks = /* @__PURE__ */ new Map();
+const PLAN_ACTION_KEYSTROKES = {
+	"approve-auto": "1",
+	"approve-manual": "2",
+	"reject-ultraplan": "3"
+};
+/**
+* PAN-1520 (FR-4) — deliver a native plan-menu action to any tmux session
+* (conversation or agent). The plan menu is answered with raw keystrokes
+* (1/2/3/4), not a text message; `reject-feedback` follows the '4' keystroke
+* with the operator's feedback through the normal message pipeline.
+* Returns null on success, or an error string for an invalid action.
+*/
+async function deliverPlanActionToSession(sessionName, action, feedback, deliveryMethod = "auto") {
+	if (action === "reject-feedback") {
+		await Effect.runPromise(sendRawKeystroke(sessionName, "4", "plan-action-reject"));
+		if (feedback) {
+			await new Promise((r) => setTimeout(r, 300));
+			await deliverAgentMessage(sessionName, feedback, "plan-action-feedback", deliveryMethod);
+		}
+		return null;
+	}
+	const keystroke = PLAN_ACTION_KEYSTROKES[action];
+	if (!keystroke) return `Invalid action: ${action}`;
+	await Effect.runPromise(sendRawKeystroke(sessionName, keystroke, `plan-action-${action}`));
+	return null;
+}
+function registerConversationControlAck(commandId, timeoutMs = CONTROL_ACK_TIMEOUT_MS) {
+	const existing = pendingConversationControlAcks.get(commandId);
+	if (existing) {
+		clearTimeout(existing.timer);
+		existing.reject(/* @__PURE__ */ new Error(`Replaced pending conversation control ack ${commandId}`));
+		pendingConversationControlAcks.delete(commandId);
+	}
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			pendingConversationControlAcks.delete(commandId);
+			reject(/* @__PURE__ */ new Error(`Timed out waiting for conversation control ack ${commandId}`));
+		}, timeoutMs);
+		pendingConversationControlAcks.set(commandId, {
+			resolve: () => {
+				clearTimeout(timer);
+				pendingConversationControlAcks.delete(commandId);
+				resolve();
+			},
+			reject: (error) => {
+				clearTimeout(timer);
+				pendingConversationControlAcks.delete(commandId);
+				reject(error);
+			},
+			timer
+		});
+	});
+}
+function resolveConversationControlAck(ack) {
+	const pending = pendingConversationControlAcks.get(ack.id);
+	if (!pending) return "unknown";
+	if (ack.ok) {
+		pending.resolve();
+		return "resolved";
+	}
+	pending.reject(new Error(ack.error || `Conversation control command ${ack.id} failed`));
+	return "rejected";
+}
+function handleConversationControlAck(body) {
+	const id = typeof body["id"] === "string" ? body["id"].trim() : "";
+	if (!id) return {
+		status: 400,
+		body: { error: "id is required" }
+	};
+	const ok = body["ok"] === true;
+	const error = typeof body["error"] === "string" ? body["error"] : void 0;
+	return {
+		status: 200,
+		body: {
+			ok: true,
+			outcome: resolveConversationControlAck({
+				id,
+				ok,
+				...error !== void 0 ? { error } : {}
+			})
+		}
+	};
+}
+function validateConversationControlAckOrigin(headers, method = "POST") {
+	const origin = getHeaderFromMap(headers, "origin");
+	const referer = getHeaderFromMap(headers, "referer");
+	if (!origin && !referer) return { ok: true };
+	return validateOriginHeaders(headers, method);
+}
+async function handleConversationCodexApproval(rawId, body) {
+	try {
+		const optionNumber = Number(body.optionNumber);
+		if (!Number.isInteger(optionNumber) || optionNumber < 1 || optionNumber > 9) return jsonResponse({ error: "optionNumber must be an integer 1-9" }, { status: 400 });
+		const numericId = Number(rawId);
+		const conv = !Number.isNaN(numericId) && /^\d+$/.test(rawId) ? getConversationById(numericId) : getConversationByName(rawId);
+		if (!conv) return jsonResponse({ error: "Conversation not found" }, { status: 404 });
+		if (getHarnessBehavior(conv.harness).transcriptKind !== "codex-rollout-jsonl") return jsonResponse({ error: "Not a Codex conversation" }, { status: 400 });
+		if (!await tmuxSessionExists(conv.tmuxSession)) return jsonResponse({ error: "Conversation session is not running" }, { status: 409 });
+		const detection = await Effect.runPromise(detectAwaitingInputForAgent(conv.tmuxSession, {
+			isPlanning: false,
+			cache: false
+		}));
+		const parsed = detection ? parseCodexApprovalPrompt(detection.prompt) : null;
+		if (!parsed) return jsonResponse({ error: "No Codex approval prompt is currently pending" }, { status: 409 });
+		if (optionNumber > parsed.options.length) return jsonResponse({ error: `optionNumber out of range (1-${parsed.options.length})` }, { status: 400 });
+		await deliverCodexApprovalChoice(conv.tmuxSession, optionNumber);
+		return jsonResponse({
+			ok: true,
+			optionNumber
+		});
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		console.error("[conversations] codex approval failed:", msg);
+		return jsonResponse({ error: "Internal server error" }, { status: 500 });
+	}
+}
+async function handleConversationPlanAction(name, body) {
+	try {
+		const conv = getConversationByName(name);
+		if (!conv) return jsonResponse({ error: "Conversation not found" }, { status: 404 });
+		const action = typeof body["action"] === "string" ? body["action"] : "";
+		const feedback = typeof body["feedback"] === "string" ? body["feedback"].trim() : "";
+		const error = await deliverPlanActionToSession(conv.tmuxSession, action, feedback, resolveConversationDeliveryMethod(conv));
+		if (error) return jsonResponse({ error }, { status: 400 });
+		return jsonResponse({ ok: true });
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		console.error("[conversations] plan action failed:", msg);
+		return jsonResponse({ error: "Internal server error" }, { status: 500 });
+	}
+}
+const THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const PI_CONVERSATION_ABORT_KEY = "Escape";
+function isPiControlChannelHarness(harness) {
+	return harness === "ohmypi" || harness === "pi";
+}
+function parseThinkingLevel(value) {
+	return typeof value === "string" && THINKING_LEVELS.includes(value) ? value : null;
+}
+function pickDeliverAs(bodyDeliverAs) {
+	if (bodyDeliverAs === "follow_up") return "follow_up";
+	return "steer";
+}
+function resolveConversationDeliveryMethod(conv) {
+	const harness = conv.harness ?? "claude-code";
+	if (isPiControlChannelHarness(harness)) return "auto";
+	return conv.deliveryMethod ?? (getHarnessBehavior(harness).deliveryKind === "rpc-fifo" ? "tmux" : "auto");
+}
+async function sendConversationControlCommand(conv, commandInput) {
+	const id = randomUUID$1();
+	const ackPromise = registerConversationControlAck(id);
+	const command = {
+		id,
+		...commandInput
+	};
+	try {
+		await writeConversationControlCommand(conv.tmuxSession, command);
+	} catch (err) {
+		resolveConversationControlAck({
+			id,
+			ok: false,
+			error: err instanceof Error ? err.message : String(err)
+		});
+	}
+	await ackPromise;
+}
+async function deliverConversationViaControlChannel(conv, message, options) {
+	await sendConversationControlCommand(conv, {
+		type: options.deliverAs,
+		message,
+		source: options.source
+	});
+}
+async function handleConversationThinkingLevel(name, body) {
+	const conv = getConversationByName(name);
+	if (!conv) return jsonResponse({ error: "Conversation not found" }, { status: 404 });
+	if (!isPiControlChannelHarness(conv.harness ?? "claude-code")) return jsonResponse({ error: "Thinking level control is only supported for Pi conversations" }, { status: 400 });
+	if (conv.status === "ended") return jsonResponse({ error: "Session has ended — start a new run to interact" }, { status: 422 });
+	const level = parseThinkingLevel(body["level"]);
+	if (!level) return jsonResponse({ error: "Invalid thinking level" }, { status: 400 });
+	await sendConversationControlCommand(conv, {
+		type: "set_thinking_level",
+		level
+	});
+	setConversationEffort(name, level);
+	return jsonResponse({
+		ok: true,
+		effort: (getConversationByName(name) ?? conv).effort ?? level
+	});
+}
+async function handleConversationCompact(name) {
+	const conv = getConversationByName(name);
+	if (!conv) return jsonResponse({ error: "Conversation not found" }, { status: 404 });
+	if (!isPiControlChannelHarness(conv.harness ?? "claude-code")) return jsonResponse({ error: "Compact control endpoint is only supported for Pi conversations" }, { status: 400 });
+	if (conv.status === "ended") return jsonResponse({ error: "Session has ended — start a new run to interact" }, { status: 422 });
+	await sendConversationControlCommand(conv, { type: "compact" });
+	return jsonResponse({ ok: true });
+}
+async function handleConversationAbort(name) {
+	const conv = getConversationByName(name);
+	if (!conv) return jsonResponse({ error: "Conversation not found" }, { status: 404 });
+	if (!isPiControlChannelHarness(conv.harness ?? "claude-code")) return jsonResponse({ error: "Abort control endpoint is only supported for Pi conversations" }, { status: 400 });
+	if (conv.status === "ended") return jsonResponse({ error: "Session has ended — start a new run to interact" }, { status: 422 });
+	await sendKeysAsync(conv.tmuxSession, PI_CONVERSATION_ABORT_KEY, "conversation-abort");
+	return jsonResponse({
+		ok: true,
+		key: PI_CONVERSATION_ABORT_KEY
+	});
+}
+async function handleConversationDeliveryMethod(name, body) {
+	if (!getConversationByName(name)) return jsonResponse({ error: "Conversation not found" }, { status: 404 });
+	const deliveryMethod = body["deliveryMethod"] ?? body["method"];
+	if (deliveryMethod !== "auto" && deliveryMethod !== "channels" && deliveryMethod !== "tmux" && deliveryMethod !== null) return jsonResponse({ error: "deliveryMethod must be 'auto', 'channels', 'tmux', or null" }, { status: 400 });
+	updateConversationDeliveryMethod(name, deliveryMethod);
+	return jsonResponse({
+		ok: true,
+		deliveryMethod
+	});
+}
+const CODEX_APPROVAL_TOOL_PREFIX = "codex-approval:";
+async function codexConversationPendingInput(conv, sessionAlive, askedAt) {
+	if (!sessionAlive || getHarnessBehavior(conv.harness).transcriptKind !== "codex-rollout-jsonl") return { kinds: [] };
+	try {
+		const detection = await Effect.runPromise(detectAwaitingInputForAgent(conv.tmuxSession, { isPlanning: false }));
+		if (!detection) return { kinds: [] };
+		if (detection.reason === "session_resume") return { kinds: ["sessionResume"] };
+		const parsed = parseCodexApprovalPrompt(detection.prompt);
+		if (parsed) return {
+			kinds: ["permissionRequest"],
+			approval: {
+				toolUseId: `${CODEX_APPROVAL_TOOL_PREFIX}${conv.tmuxSession}`,
+				askedAt,
+				questions: [{
+					question: parsed.detail ? `${parsed.header}\n\n${parsed.detail}` : parsed.header,
+					header: "Codex approval",
+					multiSelect: false,
+					options: parsed.options.map((o) => ({ label: `${o.number}. ${o.label}` }))
+				}]
+			}
+		};
+		return { kinds: ["permissionRequest"] };
+	} catch {
+		return { kinds: [] };
+	}
+}
+async function deliverCodexApprovalChoice(tmuxSession, optionNumber) {
+	for (let i = 1; i < optionNumber; i += 1) {
+		await Effect.runPromise(sendRawKeystroke(tmuxSession, "Down", "codex-approval"));
+		await new Promise((r) => setTimeout(r, 60));
+	}
+	await Effect.runPromise(sendRawKeystroke(tmuxSession, "Enter", "codex-approval"));
+}
+//#endregion
 //#region ../../lib/channels/permission-payload.ts
 const CHANNEL_PERMISSION_LIMITS = {
 	requestIdBytes: 128,
@@ -2127,6 +3642,30 @@ const postAgentAnswerQuestionRoute = HttpRouter.add("POST", "/api/agents/:id/ans
 		delivered: answers.length
 	});
 })));
+const postAgentPlanActionRoute = HttpRouter.add("POST", "/api/agents/:id/plan-action", httpHandler(Effect.gen(function* () {
+	const id = (yield* HttpRouter.params)["id"] ?? "";
+	if (!id.trim()) return jsonResponse({ error: "missing agent id" }, { status: 400 });
+	const body = yield* readJsonBody$1;
+	const action = typeof body["action"] === "string" ? body["action"] : "";
+	const feedback = typeof body["feedback"] === "string" ? body["feedback"].trim() : "";
+	const agentState = yield* getAgentState(id).pipe(Effect.catch(() => Effect.succeed(null)));
+	if (!agentState) return jsonResponse({ error: "Agent not found" }, { status: 404 });
+	const jsonlPath = yield* getAgentJsonlPath$1(id).pipe(Effect.catch(() => Effect.succeed(null)));
+	if (!(jsonlPath ? yield* Effect.promise(() => scanPendingInputsPromise(jsonlPath)) : null)?.exitPlanModePending) return jsonResponse({ error: "No pending plan approval for this agent" }, { status: 409 });
+	const error = yield* Effect.promise(() => deliverPlanActionToSession(id, action, feedback));
+	if (error) return jsonResponse({ error }, { status: 400 });
+	emitActivityEntrySync({
+		source: "dashboard",
+		level: "info",
+		issueId: agentState.issueId,
+		message: `Operator ${action.startsWith("approve") ? "approved" : "requested changes to"} ${id}'s plan from the dashboard`
+	});
+	return jsonResponse({
+		success: true,
+		agentId: id,
+		action
+	});
+})));
 const postInternalAgentPermissionRequestRoute = HttpRouter.add("POST", "/api/internal/agents/:id/permissions/request", httpHandler(Effect.gen(function* () {
 	const id = (yield* HttpRouter.params)["id"] ?? "";
 	if (!id.trim()) return jsonResponse({
@@ -2134,7 +3673,7 @@ const postInternalAgentPermissionRequestRoute = HttpRouter.add("POST", "/api/int
 		error: "missing agent id"
 	}, { status: 400 });
 	const request = yield* HttpServerRequest.HttpServerRequest;
-	const { INTERNAL_TOKEN_HEADER, getInternalTokenSync } = yield* Effect.promise(() => import("./internal-token-C90jBp-y.js"));
+	const { INTERNAL_TOKEN_HEADER, getInternalTokenSync } = yield* Effect.promise(() => import("./internal-token-BPYEaXFh.js"));
 	const expected = getInternalTokenSync();
 	if (!expected) return jsonResponse({
 		ok: false,
@@ -2401,7 +3940,7 @@ const getAgentHealthHistoryRoute = HttpRouter.add("GET", "/api/agents/:id/health
 	const request = yield* HttpServerRequest.HttpServerRequest;
 	const urlOpt = HttpServerRequest.toURL(request);
 	const hours = Option.isSome(urlOpt) ? urlOpt.value.searchParams.get("hours") ?? "24" : "24";
-	const { getHealthHistory } = yield* Effect.promise(() => import("./health-events-DDfkoO5a.js"));
+	const { getHealthHistory } = yield* Effect.promise(() => import("./health-events-Bos3sk5g.js"));
 	const endTime = /* @__PURE__ */ new Date();
 	const startTime = /* @__PURE__ */ new Date(endTime.getTime() - parseInt(hours) * 60 * 60 * 1e3);
 	const events = getHealthHistory(id, startTime.toISOString(), endTime.toISOString());
@@ -2442,7 +3981,7 @@ function emitAgentRuntimeEvent(id, body, timestamp) {
 				detail: String(decoded.failure)
 			}, { status: 400 })
 		};
-		const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-U8feBf8t.js"));
+		const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-CZrayD_G.js"));
 		yield* (yield* AgentStateService).emit(decoded.success);
 		return {
 			ok: true,
@@ -2524,7 +4063,7 @@ const getAgentRuntimeRoute = HttpRouter.add("GET", "/api/agents/:id/runtime", ht
 		success: false,
 		error: "missing agent id"
 	}, { status: 400 });
-	const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-U8feBf8t.js"));
+	const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-CZrayD_G.js"));
 	const snapshot = yield* (yield* AgentStateService).get(id);
 	if (!snapshot) return jsonResponse({
 		success: false,
@@ -2550,7 +4089,9 @@ init_workspace_manager();
 * commit, the persisted event is emitted to the event store's subscribers so
 * the in-memory read model stays current.
 */
+init_event_store();
 init_agents();
+init_persistent_logger();
 function prepareAgentStateForSave(state) {
 	if (state.status === "running" || state.status === "starting") delete state.stoppedAt;
 	else if (state.status === "stopped" && !state.stoppedAt) state.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -2635,8 +4176,8 @@ function createAgentStopHandler(lifecycleEvent) {
 		yield* stopAgent(id);
 		if (stateBeforeStop?.issueId) yield* Effect.promise(async () => {
 			try {
-				const { resolveProjectFromIssueSync } = await import("./projects-BqRMlDOv.js");
-				const { findWorkspacePath } = await import("./archive-planning-DmpT1_14.js");
+				const { resolveProjectFromIssueSync } = await import("./projects-CrBE6IhN.js");
+				const { findWorkspacePath } = await import("./archive-planning-CoyIbgGK.js");
 				const issueLower = stateBeforeStop.issueId.toLowerCase();
 				const workspacePath = findWorkspacePath(resolveProjectFromIssueSync(stateBeforeStop.issueId)?.projectPath ?? process.cwd(), issueLower);
 				if (workspacePath) {
@@ -2806,7 +4347,9 @@ const postAgentUntroubledRoute = HttpRouter.add("POST", "/api/agents/:id/untroub
 })));
 //#endregion
 //#region routes/agents/lifecycle-restart.ts
+init_config_yaml();
 init_agents();
+init_harness_policy();
 init_operator_interventions();
 init_projects();
 init_tmux();
@@ -3711,19 +5254,20 @@ const writeAutoStartVBrief = (projectRoot, workspacePath, issue) => Effect.tryPr
 //#endregion
 //#region routes/agents/spawn-helpers.ts
 init_issue_lifecycle();
+init_child_env();
 init_agents();
 function handleRemoteAgentSpawn(input) {
 	return Effect.gen(function* () {
 		const { issueId, workspacePath, workspaceMetadata, spawnModel, projectPath, spawnGuardrails, lifecycle } = input;
-		const { spawnRemoteAgent, checkRemoteSpendCap } = yield* Effect.promise(() => import("./remote-agents-B4eWgwNd.js"));
-		const { createFlyProviderFromConfig } = yield* Effect.promise(() => import("./remote-B062S1Kc.js"));
-		const { loadConfigSync: loadPanConfig } = yield* Effect.promise(() => import("./config-B4_d7z7z.js"));
+		const { spawnRemoteAgent, checkRemoteSpendCap } = yield* Effect.promise(() => import("./remote-agents-Cv-U-_V8.js"));
+		const { createFlyProviderFromConfig } = yield* Effect.promise(() => import("./remote-DW_TWQnr.js"));
+		const { loadConfigSync: loadPanConfig } = yield* Effect.promise(() => import("./config-Dj6N8EP9.js"));
 		const panConfig = loadPanConfig();
 		const spendCap = checkRemoteSpendCap(panConfig);
 		if (!spendCap.allowed) return jsonResponse({ error: spendCap.message }, { status: 429 });
 		const fly = createFlyProviderFromConfig(panConfig.remote);
 		yield* Effect.promise(() => fly.syncAllCredentials(workspaceMetadata.vmName));
-		const { buildWorkAgentPrompt, getTrackerContext } = yield* Effect.promise(() => import("./work-agent-prompt-B2F3ZwKm.js"));
+		const { buildWorkAgentPrompt, getTrackerContext } = yield* Effect.promise(() => import("./work-agent-prompt-ZTAb2Hyf.js"));
 		const trackerContext = yield* Effect.promise(() => getTrackerContext(issueId, workspacePath));
 		const agentPrompt = yield* Effect.promise(() => buildWorkAgentPrompt({
 			issueId,
@@ -3809,7 +5353,7 @@ function handleContainerOrchestration(input) {
 		if (existsSync(workspacePath) && existsSync(devScript)) {
 			let dockerRunning = false;
 			try {
-				yield* Effect.promise(() => execAsync$1("docker info >/dev/null 2>&1", { encoding: "utf-8" }));
+				yield* Effect.promise(() => execAsync$2("docker info >/dev/null 2>&1", { encoding: "utf-8" }));
 				dockerRunning = true;
 			} catch {}
 			if (dockerRunning) {
@@ -3852,7 +5396,7 @@ function handleContainerOrchestration(input) {
 				}));
 				let containersReady = false;
 				try {
-					const { stdout: existing } = yield* Effect.promise(() => execFileAsync$1("docker", [
+					const { stdout: existing } = yield* Effect.promise(() => execFileAsync$2("docker", [
 						"ps",
 						"--filter",
 						`name=${featureName}`,
@@ -3918,7 +5462,7 @@ function handleContainerOrchestration(input) {
 							let healthy = false;
 							while (Date.now() - startTime < maxWaitMs) {
 								try {
-									const { stdout } = await execFileAsync$1("docker", [
+									const { stdout } = await execFileAsync$2("docker", [
 										"ps",
 										"--filter",
 										`name=${featureName}`,
@@ -4085,7 +5629,7 @@ function spawnGuardrailResourcesHint(hint) {
 * invisible to a JS `try/catch`. Before this helper, that escaped as an
 * unhandled 500 on POST /api/agents instead of the designed 422.
 */
-const countBeadsForIssue = (workspacePath, issueLower) => withBdMutex(() => Effect.promise(() => execFileAsync$1("bd", [
+const countBeadsForIssue = (workspacePath, issueLower) => withBdMutex(() => Effect.promise(() => execFileAsync$2("bd", [
 	"list",
 	"--json",
 	"-l",
@@ -4176,7 +5720,7 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 	const workspacePath = join(projectPath, "workspaces", `feature-${issueLower}`);
 	if (!existsSync(workspacePath)) try {
 		const nodeDir = dirname(process.execPath);
-		yield* Effect.promise(() => execAsync$1(`pan workspace create ${issueId} --local`, {
+		yield* Effect.promise(() => execAsync$2(`pan workspace create ${issueId} --local`, {
 			cwd: projectPath,
 			encoding: "utf-8",
 			timeout: 6e4,
@@ -4252,7 +5796,7 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 	if (!hasBeads) {
 		console.log(`[agents] No beads for ${issueId} — attempting auto-recovery via createBeadsFromVBrief`);
 		try {
-			const { createBeadsFromVBrief } = yield* Effect.promise(() => import("./beads-CivpXztb.js"));
+			const { createBeadsFromVBrief } = yield* Effect.promise(() => import("./beads-B1u04n3o.js"));
 			const recovery = yield* createBeadsFromVBrief(workspacePath);
 			beadCount = recovery.created.length;
 			hasBeads = recovery.created.length > 0 && (planItemCount === null || recovery.created.length === planItemCount);
@@ -4398,24 +5942,24 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 	if (shouldCommitLegacyWorkspaceArtifacts(projectConfig ? yield* Effect.promise(() => isStateMigrated(projectConfig)) : false) && (existsSync(workspacePanContinuePath) || existsSync(workspacePanDir))) yield* Effect.gen(function* () {
 		const gitRoot = workspacePath;
 		if (existsSync(join(gitRoot, ".pan"))) {
-			yield* Effect.promise(() => execAsync$1(`git add .pan/`, {
+			yield* Effect.promise(() => execAsync$2(`git add .pan/`, {
 				cwd: gitRoot,
 				encoding: "utf-8"
 			}));
-			yield* Effect.promise(() => execAsync$1(`git reset HEAD -- .pan/kickoff.md .pan/continue.json .pan/handoff-*.md .pan/spec.vbrief.json`, {
+			yield* Effect.promise(() => execAsync$2(`git reset HEAD -- .pan/kickoff.md .pan/continue.json .pan/handoff-*.md .pan/spec.vbrief.json`, {
 				cwd: gitRoot,
 				encoding: "utf-8"
 			}));
 		}
-		if (existsSync(join(gitRoot, ".beads"))) yield* Effect.promise(() => execAsync$1(`git add .beads/`, {
+		if (existsSync(join(gitRoot, ".beads"))) yield* Effect.promise(() => execAsync$2(`git add .beads/`, {
 			cwd: gitRoot,
 			encoding: "utf-8"
 		}));
-		if (yield* Effect.promise(() => execAsync$1(`git diff --cached --quiet`, {
+		if (yield* Effect.promise(() => execAsync$2(`git diff --cached --quiet`, {
 			cwd: gitRoot,
 			encoding: "utf-8"
 		}).then(() => false).catch(() => true))) {
-			yield* Effect.promise(() => execAsync$1(`git commit -m "chore: planning artifacts for ${issueId} before agent start"`, {
+			yield* Effect.promise(() => execAsync$2(`git commit -m "chore: planning artifacts for ${issueId} before agent start"`, {
 				cwd: gitRoot,
 				encoding: "utf-8"
 			}));
@@ -4442,7 +5986,7 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 		console.warn(`[start-agent] Failed to set plan.status=running (non-fatal): ${planStatusErr?.message ?? planStatusErr}`);
 	}
 	try {
-		const { appendSessionEntry, getProjectConfigFromWorkspacePath, resolveProjectForIssue } = yield* Effect.promise(() => import("./record-CJsjvRO4.js"));
+		const { appendSessionEntry, getProjectConfigFromWorkspacePath, resolveProjectForIssue } = yield* Effect.promise(() => import("./record-lEYK__LD.js"));
 		const recordProject = resolveProjectForIssue(issueId) ?? getProjectConfigFromWorkspacePath(workspacePath);
 		yield* Effect.promise(() => appendSessionEntry(recordProject, issueId, {
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4491,12 +6035,12 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 		console.log(`[start-agent] Killed stale tmux session ${agentSessionName}`);
 	}).pipe(Effect.catch(() => Effect.void));
 	if (!(body.acknowledgeDirtyWorkspace === true)) try {
-		const { stdout: statusOut } = yield* Effect.promise(() => execAsync$1("git status --porcelain", {
+		const { stdout: statusOut } = yield* Effect.promise(() => execAsync$2("git status --porcelain", {
 			cwd: workspacePath,
 			encoding: "utf-8"
 		}));
 		if (statusOut.trim()) {
-			const { stdout: diffOut } = yield* Effect.promise(() => execAsync$1("git diff HEAD --stat", {
+			const { stdout: diffOut } = yield* Effect.promise(() => execAsync$2("git diff HEAD --stat", {
 				cwd: workspacePath,
 				encoding: "utf-8"
 			}).catch(() => ({ stdout: "" })));
@@ -4688,7 +6232,7 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 * Composes all /api/agents/* route layers and preserves the public helper
 * exports that external callers historically imported from routes/agents.js.
 */
-const agentsRouteLayer = Layer.mergeAll(getAgentsRoute, getAgentOutputRoute, getAgentConversationRoute, postAgentMessageRoute, postAgentTellRoute, deleteAgentRoute, postAgentStopRoute, getAgentHealthHistoryRoute, postAgentPokeRoute, getAgentPendingQuestionsRoute, postAgentAnswerQuestionRoute, postAgentHeartbeatRoute, postAgentWorkCompleteRoute, postAgentStuckRoute, postAgentClassifyCompletionRoute, postInternalAgentPermissionRequestRoute, postAgentPermissionResponseRoute, getAgentRuntimeRoute, getAgentGitInfoRoute, getAgentActivityRoute, getAgentFilesRoute, getAgentTimelineRoute, postAgentSuspendRoute, postAgentPauseRoute, postAgentUnpauseRoute, postAgentUntroubledRoute, postAgentResumeRoute, postAgentRecoverRoute, postAgentRestartRoute, getAgentCloisterHealthRoute, getAgentHandoffSuggestionRoute, postAgentHandoffRoute, getAgentCostRoute, postAgentsRoute, postAgentsRestartAllRoute, getAgentTmuxAliveRoute, getAgentHasSessionRoute, postAgentResetSessionRoute, postAgentSwitchModelRoute, postAgentRestartFreshRoute, postAgentDeliveryMethodRoute, getAgentsRestartConfigRoute, postAgentsRestartWithConfigRoute);
+const agentsRouteLayer = Layer.mergeAll(getAgentsRoute, getAgentOutputRoute, getAgentConversationRoute, postAgentMessageRoute, postAgentTellRoute, deleteAgentRoute, postAgentStopRoute, getAgentHealthHistoryRoute, postAgentPokeRoute, getAgentPendingQuestionsRoute, postAgentAnswerQuestionRoute, postAgentPlanActionRoute, postAgentHeartbeatRoute, postAgentWorkCompleteRoute, postAgentStuckRoute, postAgentClassifyCompletionRoute, postInternalAgentPermissionRequestRoute, postAgentPermissionResponseRoute, getAgentRuntimeRoute, getAgentGitInfoRoute, getAgentActivityRoute, getAgentFilesRoute, getAgentTimelineRoute, postAgentSuspendRoute, postAgentPauseRoute, postAgentUnpauseRoute, postAgentUntroubledRoute, postAgentResumeRoute, postAgentRecoverRoute, postAgentRestartRoute, getAgentCloisterHealthRoute, getAgentHandoffSuggestionRoute, postAgentHandoffRoute, getAgentCostRoute, postAgentsRoute, postAgentsRestartAllRoute, getAgentTmuxAliveRoute, getAgentHasSessionRoute, postAgentResetSessionRoute, postAgentSwitchModelRoute, postAgentRestartFreshRoute, postAgentDeliveryMethodRoute, getAgentsRestartConfigRoute, postAgentsRestartWithConfigRoute);
 //#endregion
 //#region ../../lib/cloister/task-readiness.ts
 init_io();
@@ -4860,10 +6404,10 @@ const _serverManagedMerges = /* @__PURE__ */ new Set();
 function firePostMergeLifecycle(issueId, options) {
 	const started = postMergeGuard.run(issueId, async () => {
 		const projectPath = getProjectPathForIssue(extractPrefixSync(issueId) ?? issueId.split("-")[0]);
-		const { postMergeLifecycle } = await import("./merge-agent-Bwm34MZ5.js");
+		const { postMergeLifecycle } = await import("./merge-agent-ejC7Wos8.js");
 		await postMergeLifecycle(issueId, projectPath, options?.sourceBranch, options?.verifiedMergedRef ? { verifiedMergedRef: options.verifiedMergedRef } : void 0);
 		console.log(`[merge] post-merge lifecycle completed for ${issueId}`);
-		const { runMergeTrainReconcile } = await import("./merge-train-BIm7-7cy.js");
+		const { runMergeTrainReconcile } = await import("./merge-train-CH33XJOH.js");
 		const outcomes = await runMergeTrainReconcile(issueId);
 		if (outcomes.length > 0) console.log(`[merge-train] reconciled ${outcomes.length} sibling(s) after ${issueId}: ` + outcomes.map((o) => `${o.issueId}=${o.result}`).join(", "));
 	}, (err) => console.error(`[merge] post-merge lifecycle failed for ${issueId}:`, err));
@@ -4884,15 +6428,15 @@ init_io();
 init_domain_services();
 init_tmux();
 const getSpecialistsRoute = HttpRouter.add("GET", "/api/specialists", httpHandler(Effect.gen(function* () {
-	const { getAllSpecialistStatus, getAllProjectSpecialistStatuses } = yield* Effect.promise(() => import("./specialists-Chvvwf5z.js"));
+	const { getAllSpecialistStatus, getAllProjectSpecialistStatuses } = yield* Effect.promise(() => import("./specialists-k22_Btaq.js"));
 	return jsonResponse({
 		specialists: yield* Effect.promise(() => getAllSpecialistStatus()),
 		projects: yield* Effect.promise(() => getAllProjectSpecialistStatuses())
 	});
 })));
 const postSpecialistsResetAllRoute = HttpRouter.add("POST", "/api/specialists/reset-all", httpHandler(Effect.gen(function* () {
-	const { getAllSpecialists, isRunning, getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-Chvvwf5z.js"));
-	const { clearHookSync } = yield* Effect.promise(() => import("./hooks-DvdnCVv6.js"));
+	const { getAllSpecialists, isRunning, getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-k22_Btaq.js"));
+	const { clearHookSync } = yield* Effect.promise(() => import("./hooks-uEr8WTx_.js"));
 	const specialists = getAllSpecialists();
 	const results = [];
 	for (const specialist of specialists) {
@@ -4942,7 +6486,7 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 	const normalizedIssueId = issueId.toUpperCase();
 	console.log(`[specialists/done] ${specialist} signaling ${status} for ${normalizedIssueId}`);
 	if (specialist === "merge") {
-		const { reportSpecialistCompletion } = yield* Effect.promise(() => import("./specialist-completion-Coz3eTSr.js"));
+		const { reportSpecialistCompletion } = yield* Effect.promise(() => import("./specialist-completion-CJcv-NXH.js"));
 		if (yield* reportSpecialistCompletion(normalizedIssueId, {
 			status,
 			notes
@@ -4989,7 +6533,7 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 	if (specialist === "inspect" && status === "failed") yield* Effect.promise(() => reportTieredInspectFailureEscalation(normalizedIssueId, notes));
 	yield* Effect.promise(async () => {
 		try {
-			const { getTmuxSessionName, updateRunMetadata, makeSpecialistRegistryKey } = await import("./specialists-Chvvwf5z.js");
+			const { getTmuxSessionName, updateRunMetadata, makeSpecialistRegistryKey } = await import("./specialists-k22_Btaq.js");
 			const projectKey = resolveProjectFromIssueSync(normalizedIssueId)?.projectKey;
 			const tmuxSession = projectKey ? getTmuxSessionName(`${specialist}-agent`, projectKey, normalizedIssueId) : getTmuxSessionName(`${specialist}-agent`);
 			saveAgentRuntimeState(tmuxSession, {
@@ -5008,7 +6552,7 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 				});
 				console.log(`[specialists/done] Cleared registry lock for ${registryKey} (${projectKey})`);
 			}
-			const { updateSpecialistHandoffStatus } = await import("./specialist-handoff-logger-B9HK_lRu.js");
+			const { updateSpecialistHandoffStatus } = await import("./specialist-handoff-logger-CQyF1ygu.js");
 			if (await Effect.runPromise(updateSpecialistHandoffStatus(normalizedIssueId, `${specialist}-agent`, status === "passed" ? "completed" : "failed", status === "passed" ? "success" : "failure"))) console.log(`[specialists/done] Updated handoff log: ${specialist}-agent ${normalizedIssueId} → ${status}`);
 		} catch (err) {
 			console.error(`[specialists/done] Error managing specialist state:`, err);
@@ -5020,7 +6564,7 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 			if (project) {
 				const workspacePath = join(project.projectPath, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`);
 				if (existsSync(workspacePath)) {
-					const { getWorkspaceGitInfo } = await import("./git-utils-Ym380hJZ.js");
+					const { getWorkspaceGitInfo } = await import("./git-utils-C0neHvQx.js");
 					const { HEAD } = await Effect.runPromise(getWorkspaceGitInfo(workspacePath));
 					setReviewStatusSync(normalizedIssueId, { reviewedAtCommit: HEAD });
 					console.log(`[specialists/done] Snapshotted reviewedAtCommit=${HEAD.substring(0, 8)} for ${normalizedIssueId}`);
@@ -5032,7 +6576,7 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 	});
 	if (specialist === "inspect" && status === "passed") yield* Effect.promise(async () => {
 		try {
-			const { onInspectComplete } = await import("./inspect-agent-D8UBDgfR.js");
+			const { onInspectComplete } = await import("./inspect-agent-CWkeAB7J.js");
 			const beadId = (notes?.match(/[Bb]ead\s+(\S+)/))?.[1] || "unknown";
 			const project = resolveProjectFromIssueSync(normalizedIssueId);
 			if (project) {
@@ -5077,7 +6621,7 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 			if (project) {
 				if (existsSync(join(project.projectPath, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`))) {
 					setReviewStatusSync(normalizedIssueId, { testStatus: "passed" });
-					const { initEventStore } = await import("./event-store-C02Gprug.js");
+					const { initEventStore } = await import("./event-store-CqDgfbAs.js");
 					await (await initEventStore()).appendAsync({
 						type: "test.passed",
 						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -5130,8 +6674,8 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 		if (notes?.toLowerCase().includes("conflict")) yield* Effect.promise(async () => {
 			try {
 				const workAgentId = `agent-${normalizedIssueId.toLowerCase()}`;
-				const { sessionExists } = await import("./tmux-CbcrkUx5.js");
-				const { messageAgent, spawnAgent, getAgentStateSync } = await import("./agents-CxbuBjID.js");
+				const { sessionExists } = await import("./tmux-By8E_Yv_.js");
+				const { messageAgent, spawnAgent, getAgentStateSync } = await import("./agents-CEcaxSkR.js");
 				if (await Effect.runPromise(sessionExists(workAgentId))) {
 					await messageAgent(workAgentId, `MERGE CONFLICT: The merge-agent could not rebase your branch onto main due to conflicts. Please fix this now:\n\n1. git fetch origin main\n2. git rebase origin/main\n3. Resolve any conflicts (git add <file> && git rebase --continue)\n4. git push --force-with-lease\n5. Resubmit: curl -s -X POST http://localhost:3011/api/review/${normalizedIssueId}/request -H "Content-Type: application/json" -d "{}"\n\nConflict details: ${notes}`);
 					console.log(`[specialists/done] Sent rebase instructions to ${workAgentId}`);
@@ -5145,7 +6689,7 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 		try {
 			const project = resolveProjectFromIssueSync(normalizedIssueId);
 			const workspacePath = project ? join(project.projectPath, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`) : void 0;
-			const { deliverReviewVerdictFeedback } = await import("./review-verdict-feedback-BnGtT0vN.js");
+			const { deliverReviewVerdictFeedback } = await import("./review-verdict-feedback-D2Q960wX.js");
 			const result = await Effect.runPromise(deliverReviewVerdictFeedback({
 				issueId: normalizedIssueId,
 				verdict: status === "failed" ? "failed" : "blocked",
@@ -5186,7 +6730,7 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 	});
 })));
 const postSpecialistsLogsCleanupAllRoute = HttpRouter.add("POST", "/api/specialists/logs/cleanup-all", httpHandler(Effect.gen(function* () {
-	const { cleanupAllLogsSync } = yield* Effect.promise(() => import("./specialist-logs-B24R2B9Y.js"));
+	const { cleanupAllLogsSync } = yield* Effect.promise(() => import("./specialist-logs-CdcUpfjj.js"));
 	const results = cleanupAllLogsSync();
 	return jsonResponse({
 		success: true,
@@ -5196,7 +6740,7 @@ const postSpecialistsLogsCleanupAllRoute = HttpRouter.add("POST", "/api/speciali
 	});
 })));
 const getSpecialistsProjectsRoute = HttpRouter.add("GET", "/api/specialists/projects", httpHandler(Effect.gen(function* () {
-	const { getAllProjectSpecialistStatuses } = yield* Effect.promise(() => import("./specialists-Chvvwf5z.js"));
+	const { getAllProjectSpecialistStatuses } = yield* Effect.promise(() => import("./specialists-k22_Btaq.js"));
 	return jsonResponse(yield* Effect.promise(() => getAllProjectSpecialistStatuses()));
 })));
 const postSpecialistWakeRoute = HttpRouter.add("POST", "/api/specialists/:name/wake", httpHandler(Effect.gen(function* () {
@@ -5240,7 +6784,7 @@ const postSpecialistReportStatusRoute = HttpRouter.add("POST", "/api/specialists
 		"blocked",
 		"failed"
 	].includes(status)) {
-		const { getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-Chvvwf5z.js"));
+		const { getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-k22_Btaq.js"));
 		saveAgentRuntimeState(getTmuxSessionName(name), {
 			state: "idle",
 			lastActivity: (/* @__PURE__ */ new Date()).toISOString()
@@ -5361,7 +6905,7 @@ const postProjectSpecialistKillRoute = HttpRouter.add("POST", "/api/specialists/
 	const issueId = params["issueId"];
 	const type = params["type"];
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { getTmuxSessionName, makeSpecialistRegistryKey, getRunMetadata } = yield* Effect.promise(() => import("./specialists-Chvvwf5z.js"));
+	const { getTmuxSessionName, makeSpecialistRegistryKey, getRunMetadata } = yield* Effect.promise(() => import("./specialists-k22_Btaq.js"));
 	const tmuxSession = getRunMetadata(project, makeSpecialistRegistryKey(type, issueId)).tmuxSession ?? getTmuxSessionName(type, project, issueId);
 	yield* Effect.promise(() => Effect.runPromise(killSession(tmuxSession)).catch(() => {}));
 	saveAgentRuntimeState(tmuxSession, {
@@ -5388,7 +6932,7 @@ const getProjectSpecialistRunsRoute = HttpRouter.add("GET", "/api/specialists/:p
 		if (limitParam) limit = parseInt(limitParam, 10);
 		if (offsetParam) offset = parseInt(offsetParam, 10);
 	}
-	const { listRunLogsSync } = yield* Effect.promise(() => import("./specialist-logs-B24R2B9Y.js"));
+	const { listRunLogsSync } = yield* Effect.promise(() => import("./specialist-logs-CdcUpfjj.js"));
 	return jsonResponse(listRunLogsSync(project, type, {
 		limit,
 		offset
@@ -5399,7 +6943,7 @@ const getProjectSpecialistRunStreamRoute = HttpRouter.add("GET", "/api/specialis
 	const project = params["project"];
 	const type = params["type"];
 	const runId = params["runId"];
-	const { getRunLogPath, isRunLogActive } = yield* Effect.promise(() => import("./specialist-logs-B24R2B9Y.js"));
+	const { getRunLogPath, isRunLogActive } = yield* Effect.promise(() => import("./specialist-logs-CdcUpfjj.js"));
 	const logPath = getRunLogPath(project, type, runId);
 	if (!existsSync(logPath)) return jsonResponse({ error: "Run log not found" }, { status: 404 });
 	const encoder = new TextEncoder();
@@ -5458,7 +7002,7 @@ const getProjectSpecialistRunRoute = HttpRouter.add("GET", "/api/specialists/:pr
 	const project = params["project"];
 	const type = params["type"];
 	const runId = params["runId"];
-	const { getRunLogSync, parseLogMetadata } = yield* Effect.promise(() => import("./specialist-logs-B24R2B9Y.js"));
+	const { getRunLogSync, parseLogMetadata } = yield* Effect.promise(() => import("./specialist-logs-CdcUpfjj.js"));
 	const content = getRunLogSync(project, type, runId);
 	if (!content) return jsonResponse({ error: "Run log not found" }, { status: 404 });
 	return jsonResponse({
@@ -5472,7 +7016,7 @@ const postProjectSpecialistRunTerminateRoute = HttpRouter.add("POST", "/api/spec
 	const project = params["project"];
 	const type = params["type"];
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { terminateSpecialist } = yield* Effect.promise(() => import("./specialists-Chvvwf5z.js"));
+	const { terminateSpecialist } = yield* Effect.promise(() => import("./specialists-k22_Btaq.js"));
 	yield* Effect.promise(() => terminateSpecialist(project, type));
 	return jsonResponse({
 		success: true,
@@ -5484,7 +7028,7 @@ const postProjectSpecialistGracePauseRoute = HttpRouter.add("POST", "/api/specia
 	const project = params["project"];
 	const type = params["type"];
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { pauseGracePeriod } = yield* Effect.promise(() => import("./specialists-Chvvwf5z.js"));
+	const { pauseGracePeriod } = yield* Effect.promise(() => import("./specialists-k22_Btaq.js"));
 	if (pauseGracePeriod(project, type)) return jsonResponse({
 		success: true,
 		message: "Grace period paused"
@@ -5496,7 +7040,7 @@ const postProjectSpecialistGraceResumeRoute = HttpRouter.add("POST", "/api/speci
 	const project = params["project"];
 	const type = params["type"];
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { resumeGracePeriod } = yield* Effect.promise(() => import("./specialists-Chvvwf5z.js"));
+	const { resumeGracePeriod } = yield* Effect.promise(() => import("./specialists-k22_Btaq.js"));
 	if (resumeGracePeriod(project, type)) return jsonResponse({
 		success: true,
 		message: "Grace period resumed"
@@ -5508,7 +7052,7 @@ const postProjectSpecialistGraceExitRoute = HttpRouter.add("POST", "/api/special
 	const project = params["project"];
 	const type = params["type"];
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { exitGracePeriod } = yield* Effect.promise(() => import("./specialists-Chvvwf5z.js"));
+	const { exitGracePeriod } = yield* Effect.promise(() => import("./specialists-k22_Btaq.js"));
 	exitGracePeriod(project, type);
 	return jsonResponse({
 		success: true,
@@ -5520,7 +7064,7 @@ const getProjectSpecialistGraceRoute = HttpRouter.add("GET", "/api/specialists/:
 	const project = params["project"];
 	const type = params["type"];
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { getGracePeriodState } = yield* Effect.promise(() => import("./specialists-Chvvwf5z.js"));
+	const { getGracePeriodState } = yield* Effect.promise(() => import("./specialists-k22_Btaq.js"));
 	const state = getGracePeriodState(project, type);
 	if (state) return jsonResponse(state);
 	else return jsonResponse({ error: "No active grace period" }, { status: 404 });
@@ -5529,7 +7073,7 @@ const getProjectSpecialistContextRoute = HttpRouter.add("GET", "/api/specialists
 	const params = yield* HttpRouter.params;
 	const project = params["project"];
 	const type = params["type"];
-	const { loadContextDigest } = yield* Effect.promise(() => import("./specialist-context-fmb03vXQ.js"));
+	const { loadContextDigest } = yield* Effect.promise(() => import("./specialist-context-B2HlbNxS.js"));
 	const digest = loadContextDigest(project, type);
 	if (digest) return jsonResponse({ digest });
 	else return jsonResponse({ error: "No context digest found" }, { status: 404 });
@@ -5538,7 +7082,7 @@ const postProjectSpecialistContextRegenerateRoute = HttpRouter.add("POST", "/api
 	const params = yield* HttpRouter.params;
 	const project = params["project"];
 	const type = params["type"];
-	const { regenerateContextDigest } = yield* Effect.promise(() => import("./specialist-context-fmb03vXQ.js"));
+	const { regenerateContextDigest } = yield* Effect.promise(() => import("./specialist-context-B2HlbNxS.js"));
 	const digest = yield* Effect.promise(() => regenerateContextDigest(project, type));
 	if (digest) return jsonResponse({
 		digest,
@@ -5557,7 +7101,7 @@ const postProjectSpecialistCompleteRoute = HttpRouter.add("POST", "/api/speciali
 		"blocked"
 	].includes(status)) return jsonResponse({ error: "Valid status (passed/failed/blocked) is required" }, { status: 400 });
 	if (!validateSpecialistAgentName(type)) return jsonResponse({ error: "Invalid specialist type. Must be review-agent, test-agent, or merge-agent" }, { status: 400 });
-	const { signalSpecialistCompletion } = yield* Effect.promise(() => import("./specialists-Chvvwf5z.js"));
+	const { signalSpecialistCompletion } = yield* Effect.promise(() => import("./specialists-k22_Btaq.js"));
 	signalSpecialistCompletion(project, type, {
 		status,
 		notes
@@ -5591,8 +7135,8 @@ const postProjectSpecialistLogsCleanupRoute = HttpRouter.add("POST", "/api/speci
 	const params = yield* HttpRouter.params;
 	const project = params["project"];
 	const type = params["type"];
-	const { cleanupOldLogsSync } = yield* Effect.promise(() => import("./specialist-logs-B24R2B9Y.js"));
-	const { getSpecialistRetention } = yield* Effect.promise(() => import("./projects-BqRMlDOv.js"));
+	const { cleanupOldLogsSync } = yield* Effect.promise(() => import("./specialist-logs-CdcUpfjj.js"));
+	const { getSpecialistRetention } = yield* Effect.promise(() => import("./projects-CrBE6IhN.js"));
 	const retention = getSpecialistRetention(project);
 	const deleted = cleanupOldLogsSync(project, type, {
 		maxDays: retention.max_days,
@@ -5613,7 +7157,7 @@ const postProjectReviewRestartRoute = HttpRouter.add("POST", "/api/specialists/:
 	const project = params["project"];
 	const issueId = params["issueId"];
 	const { model, harness } = yield* readJsonBody;
-	const { killAllReviewerSessions } = yield* Effect.promise(() => import("./review-agent-Bf9XjLnl.js"));
+	const { killAllReviewerSessions } = yield* Effect.promise(() => import("./review-agent-u5q3ip7H.js"));
 	const killResult = yield* killAllReviewerSessions(project, issueId);
 	const projectConfig = resolveProjectFromIssueSync(issueId);
 	if (!projectConfig) return jsonResponse({ error: `Cannot resolve project for ${issueId}` }, { status: 404 });
@@ -5627,7 +7171,7 @@ const postProjectReviewRestartRoute = HttpRouter.add("POST", "/api/specialists/:
 		}));
 		branch = stdout.trim() || "unknown";
 	} catch {}
-	const { spawnReviewRoleForIssue } = yield* Effect.promise(() => import("./review-agent-Bf9XjLnl.js"));
+	const { spawnReviewRoleForIssue } = yield* Effect.promise(() => import("./review-agent-u5q3ip7H.js"));
 	const prUrl = getReviewStatusSync(issueId)?.prUrl;
 	const result = yield* spawnReviewRoleForIssue({
 		issueId,
@@ -5776,6 +7320,6 @@ const specialistsProjectRouteLayer = Layer.mergeAll(getProjectSpecialistStatusRo
 */
 const specialistsRouteLayer = Layer.mergeAll(specialistsLegacyRouteLayer, specialistsProjectRouteLayer);
 //#endregion
-export { validateOrigin as C, jsonResponse as D, httpHandler as E, jsonStringResponse as O, normalizeOrigin as S, checkCodexAuthStatus as T, resolveJsonlPath as _, agentsRouteLayer as a, getTrustedOrigins as b, evaluateSpawnGuardrails as c, resolveConversationGitInfo as d, getWorkAgentLifecycleStateSync as f, resolveCodexRolloutPath as g, resolveClaudeSessionId as h, validateSpecialistAutoCompleteMetadata as i, invalidateAgentsCache as l, resolveAgentHarness as m, _serverManagedMerges as n, saveAgentStateAndEmitEvent as o, readLauncherPinnedSessionId as p, firePostMergeLifecycle as r, saveAgentStateAndEmitEventProgram as s, specialistsRouteLayer as t, resolveAgentGitInfo as u, resolvePiSessionPath as v, validateOriginHeaders as w, isTrustedOriginForHost as x, getHeaderFromMap as y };
+export { readLauncherPinnedSessionId as $, resolveAllowedHarness as A, cleanupUnreferencedConversationAttachments as B, handleConversationCreate as C, handleConversationStop as D, handleConversationResume as E, tmuxSessionExists as F, isManagedConversationAttachmentPath as G, extractConversationAttachmentPaths as H, waitForPiTuiReady as I, evaluateSpawnGuardrails as J, removeConversationAttachment as K, waitForTmuxSession as L, spawnConversationSession as M, startConversationModelBackfill as N, handleConversationSwitchModel as O, stopConversationRuntime as P, getWorkAgentLifecycleStateSync as Q, cleanupConversationAttachments as R, conversationSessionAliveFromState as S, handleConversationRestartAll as T, getConversationAttachmentsRoot as U, ensureConversationAttachmentDir as V, hasConversationAttachment as W, resolveAgentGitInfo as X, invalidateAgentsCache as Y, resolveConversationGitInfo as Z, isPiControlChannelHarness as _, jsonStringResponse as _t, agentsRouteLayer as a, isRespawnPending as at, validateConversationControlAckOrigin as b, codexConversationPendingInput as c, getTrustedOrigins as ct, handleConversationCodexApproval as d, validateOrigin as dt, resolveAgentHarness as et, handleConversationCompact as f, validateOriginHeaders as ft, handleConversationThinkingLevel as g, jsonResponse as gt, handleConversationPlanAction as h, getDefaultCwd as ht, validateSpecialistAutoCompleteMetadata as i, resolvePiSessionPath as it, shouldReportUnresolvedLiveSession as j, isInsideGitWorkTree as k, deliverConversationViaControlChannel as l, isTrustedOriginForHost as lt, handleConversationDeliveryMethod as m, httpHandler as mt, _serverManagedMerges as n, resolveCodexRolloutPath as nt, saveAgentStateAndEmitEvent as o, waitForSessionRespawn as ot, handleConversationControlAck as p, checkCodexAuthStatus as pt, runInBatches as q, firePostMergeLifecycle as r, resolveJsonlPath as rt, saveAgentStateAndEmitEventProgram as s, getHeaderFromMap as st, specialistsRouteLayer as t, resolveClaudeSessionId as tt, handleConversationAbort as u, normalizeOrigin as ut, pickDeliverAs as v, handleConversationDelete as w, conversationNeedsRunningRepair as x, resolveConversationDeliveryMethod as y, cleanupOrphanedConversationAttachments as z };
 
-//# sourceMappingURL=specialists-CL7E8yUg.js.map
+//# sourceMappingURL=specialists-CFgw_0Q6.js.map