@overdeck/desktop 0.45.15 → 0.45.18

package/server/{specialists-BudKrjOu.js → specialists-Dax7tqXC.js}

@@ -1,46 +1,53 @@
 import { a as __toCommonJS } from "./rolldown-runtime-DNCzzKnI.js";
-import { C as init_tier_table, D as canUseHarnessSync, Kn as resolveProjectFromIssueSync, Kr as getOverdeckHome, On as getProjectSync, Pn as init_projects, T as resolveTieredExecutionEnabledForIssue, Z as resolveModel, br as init_errors, er as extractPrefixSync, f as loadConfigSync, hn as shouldCommitLegacyWorkspaceArtifacts, k as init_harness_policy, pn as init_state_read_home, qr as init_paths, rr as parseIssueIdSync, t as init_config_yaml, tr as init_issue_id, ur as FsError, w as resolveTieredExecutionEnabled, zr as encodeClaudeProjectDir } from "./config-yaml-Dcz-8uit.js";
+import { B as piProviderForModel, C as init_tier_table, D as canUseHarnessSync, Fn as init_projects, Jr as getOverdeckHome, N as UnknownModelError, Qr as resolveOhmypiExtensionPath, R as getProviderForModelSync, Sr as init_errors, T as resolveTieredExecutionEnabledForIssue, Vr as encodeClaudeProjectDir, Yr as init_paths, Z as resolveModel, ar as parseIssueIdSync, c as isClaudeCodeChannelsEnabled, f as loadConfigSync, fr as FsError, hn as shouldCommitLegacyWorkspaceArtifacts, k as init_harness_policy, kn as getProjectSync, nr as extractPrefixSync, pn as init_state_read_home, qn as resolveProjectFromIssueSync, rr as init_issue_id, t as init_config_yaml, w as resolveTieredExecutionEnabled, z as init_providers, zn as listProjectsSync } from "./config-yaml-CqaAyn8y.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-bpq1MHKU.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-C_d-lSIq.js";
-import { a as init_event_store, n as getEventStore } from "./event-store-DRte2Rwt.js";
-import { C as normalizeChannelReplyPayload, a as getHarnessBehavior, b as DomainEvent, t as init_src } from "./src-DHn4Rd2F.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-4qqLkRMu.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-C-K53ASY.js";
-import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-DQ2ajr_m.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-CsOzAmRg.js";
-import { t as init_behavior } from "./behavior-Cpj03N4v.js";
-import { a as performHandoff, i as checkAllTriggers, s as getAgentHealth, t as getCloisterService } from "./service-D0_gh2tl.js";
-import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-CNODpd11.js";
-import { n as init_issue_service_singleton, r as issue_service_singleton_exports } from "./issue-service-singleton-CuHGpJJP.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-BiQ2Cs3k.js";
-import { d as getCliproxyAuthDir, g as getCliproxyLogPath, l as decodeJwtPayload, v as init_cliproxy } from "./cliproxy-BsoNNDAj.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-BR1OgvxO.js";
-import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-ie-yBcQC.js";
-import { c as requireModelOverrideSync, n as init_state_home, o as init_model_validation, r as isStateMigrated, s as normalizeModelOverrideSync } from "./state-home-CRowbXqU.js";
-import { a as init_stack_health, i as getWorkspaceStackHealth } from "./stack-health-DxsTx7II.js";
-import { s as getDispatchableItems, u as init_dag } from "./dag-CqTehWpY.js";
-import { i as queryBeadById, r as init_beads_query } from "./beads-query-B1DlJVp9.js";
-import { a as init_lifecycle_io, c as updatePlanStatus, s as transitionVBriefOnMain } from "./lifecycle-io-CeYxP3cE.js";
-import { d as getAgentPendingQuestions$1, f as getAgentWorkspace$1, g as normalizeAwaitingInputPrompt, o as getRuntimeForAgent, s as computeAgentEnrichment, u as getAgentJsonlPath$1 } from "./stuck-remediation-CFWUP8_I.js";
-import { Ht as getResourceConfig, Lt as classifyMemoryPressure, Q as createInFlightGuard, Ut as getSystemHealthSnapshot } from "./deacon-DrKDBeJL.js";
-import { o as stopWorkspaceDocker, r as init_workspace_manager } from "./workspace-manager-CB-R07R3.js";
-import { a as init_jsonl_parser, o as normalizeModelName } from "./jsonl-parser-dNIjHgym.js";
-import { a as loadWorkspaceMetadataSync } from "./workspace-metadata-9Nn5kgRl.js";
-import { c as syncBeadStatusToVBrief, l as withBdMutex } from "./beads-BGGxrkZ5.js";
-import { dirname, join } from "node:path";
+import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-_Kx1m9pm.js";
+import { A as listSessions, B as setOption, C as isHarnessProcessAlive, G as BLANKED_PROVIDER_ENV, I as sendKeysAsync, J as init_child_env, L as sendRawKeystroke, R as sessionExists, S as init_tmux, T as killSession, f as exactPaneTarget, i as capturePane, k as listSessionNames, m as findManagedServerPidSync, o as createSession, q as buildChildEnvWithoutTmuxSync, z as sessionExistsSync } from "./tmux-U55cNGFG.js";
+import { a as init_event_store, n as getEventStore } from "./event-store-KZnWUKWh.js";
+import { C as normalizeChannelReplyPayload, a as getHarnessBehavior, b as DomainEvent, t as init_src } from "./src-By3D85Ry.js";
+import { A as stateToOverdeckParamsForDb, D as init_agent_state_sync, T as AGENT_COLUMNS_FOR_DB, c as init_review_status, s as getReviewStatusSync, u as loadReviewStatuses, y as setReviewStatusSync } from "./review-status-DANr0t-v.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-CFR8TJ22.js";
+import { d as isTerminalIssueStage, o as init_agents, u as getIssueStageSync } from "./agents-BHBxr8c9.js";
+import { n as ensureSessionContextBriefingFile, r as init_briefing_freshness } from "./briefing-freshness-DuxIE1yr.js";
+import { o as getPricingSync, s as init_cost, t as calculateCostSync } from "./cost-BoqD1Pxz.js";
+import { $n as wipeAgentStateDirs, At as init_bridge_token, Ct as deliverAgentPermissionDecision, Dn as clearAgentTroubled, Et as setAgentDeliveryMethod, Fn as getAgentStateSync, G as saveSessionId, H as getLatestSessionId, Hn as markAgentStoppedState, Jn as saveAgentState, Kt as getAgentRuntimeBaseCommand, L as messageAgent, Lt as transitionIssueToInProgress, M as resumeAgent, Nn as getAgentState, O as recoverAgent, Q as stopAgent, R as init_operator_interventions, S as init_tier_escalation, St as deliverAgentMessage, Tn as clearAgentPaused, U as getLatestSessionIdSync, V as getActivity, Vt as resolveStaffing, W as getSessionId, Xn as setAgentPaused, Yn as saveAgentStateSync, Yt as getProviderAuthMode, _t as init_config, ar as init_pty_supervisor_locate, bn as dismissDevChannelsDialog, br as checkCodexAuthStatus, dn as getProviderExportsForModel, er as writeAgentStateJsonSync, fr as waitForReadySignal, gr as saveAgentRuntimeState, i as listRunningAgents, in as ohmypiFifoPaths, ir as writePtyToken, jn as getAgentDir, jt as writeBridgeTokenSync, k as restartAgent, ln as determineModel, lr as normalizeAgentId, mn as validateProviderHealth, mr as getAgentRuntimeStateSync, n as init_queries, nn as piFifoPaths, or as resolvePtySupervisorScriptPath, pn as init_provider_health, pr as getAgentRuntimeState, r as listAgentStates, rn as init_ohmypi_fifo, rr as init_pty_token, s as init_agents$1, sr as clearReadySignal, tn as init_pi_fifo, un as getProviderEnvForModel, x as decideEscalation, xn as writeChannelsBridgeMcpConfig, xr as init_codex_auth, yt as loadCloisterConfigSync, z as operatorInterventionEvent, zt as init_staffing } from "./queries-C0LCGG21.js";
+import { a as performHandoff, i as checkAllTriggers, s as getAgentHealth, t as getCloisterService } from "./service-CLVBC_1Y.js";
+import { o as init_persistent_logger, s as logAgentLifecycleSync } from "./session-history-bnOFKMwf.js";
+import { t as init_behavior } from "./behavior-CWqNMqE5.js";
+import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-OkdbaUCm.js";
+import { n as init_issue_service_singleton, r as issue_service_singleton_exports } from "./issue-service-singleton-ldvUUXi3.js";
+import { a as PAN_DIRNAME, i as PAN_CONTINUE_FILENAME, p as init_types } from "./types-DOjWNv3Z.js";
+import { F as init_lifecycle, P as generateVBriefFilename, f as readTierOverrides, g as serializeVBriefDocument, h as recordTierPromotion, m as readWorkspacePlanSync, o as init_io, r as findPlan, u as readPlan } from "./io-DkC4sFSy.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-BX5aD-6F.js";
+import { n as recordFeatureRegistryLifecycle, t as init_feature_registry_population } from "./feature-registry-population-Ca2UaV0U.js";
+import { a as requireModelOverrideSync, i as normalizeModelOverrideSync, n as init_launcher_generator, r as init_model_validation, t as generateLauncherScriptSync } from "./launcher-generator-BXLM9f4b.js";
+import { a as init_claude_permissions, o as resolvePermissionModeSync, r as getClaudePermissionFlagsStringSync, t as BYPASS_PERMISSION_MODE } from "./claude-permissions-BB6agcOZ.js";
+import { h as workspaceContextFile, l as piGlobalContextFile, o as init_layers } from "./layers-gCJlK62m.js";
+import { a as init_stack_health, i as getWorkspaceStackHealth } from "./stack-health-C-SnpRHh.js";
+import { l as init_dag, o as getDispatchableItems } from "./dag-C6kYyF17.js";
+import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-Dx8hUsvC.js";
+import { c as isStateMigrated, o as init_state_home } from "./state-home-Bur1y4oH.js";
+import { a as init_lifecycle_io, c as updatePlanStatus, s as transitionVBriefOnMain } from "./lifecycle-io-FfPUtz-y.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-mFVFdDQK.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-B699-p8v.js";
+import { Q as createInFlightGuard, Rt as classifyMemoryPressure, Ut as getResourceConfig, Wt as getSystemHealthSnapshot } from "./deacon-Dru5onpk.js";
+import { o as stopWorkspaceDocker, r as init_workspace_manager } from "./workspace-manager-Beeo2aKF.js";
+import { a as init_jsonl_parser, o as normalizeModelName } from "./jsonl-parser-Cd5jIqh7.js";
+import { a as loadWorkspaceMetadataSync } from "./workspace-metadata-BZC5BmoP.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, 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 { mkdir as mkdir$1, writeFile as writeFile$1 } from "fs/promises";
 import { exec, execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
-import { 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 +72,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();
@@ -78,13 +86,36 @@ init_infra();
 init_event_store();
 init_src();
 init_agent_state_sync();
+init_agents();
 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,
@@ -110,7 +141,7 @@ let opaqueLastSummaryAt = 0;
 *   TrackerNotConfigured                  → 503 Service Unavailable
 *   RateLimited                           → 429 Too Many Requests
 *   AgentAlreadyRunning                   → 409 Conflict
-*   BeadsNotInitialized, PlanEmpty        → 422 Unprocessable Entity
+*   PlanEmpty                             → 422 Unprocessable Entity
 *   TrackerApiError                       → 502 Bad Gateway
 *   WorkspaceCreateError, AgentStartError → 500 Internal Server Error
 *   Unknown errors                        → 500 Internal Server Error
@@ -120,7 +151,7 @@ function httpHandler(effect) {
 	return effect.pipe(Effect.catchTag("IssueNotFound", (err) => Effect.succeed(jsonResponse({ error: `Issue not found: ${err.id}` }, { status: 404 }))), Effect.catchTag("WorkspaceNotFound", (err) => Effect.succeed(jsonResponse({ error: `Workspace not found: ${err.id}` }, { status: 404 }))), Effect.catchTag("TrackerNotConfigured", (err) => Effect.succeed(jsonResponse({ error: `Tracker not configured: ${err.tracker}` }, { status: 503 }))), Effect.catchTag("RateLimited", (err) => Effect.succeed(jsonResponse({
 		error: "Rate limited",
 		retryAfter: err.retryAfter
-	}, { status: 429 }))), Effect.catchTag("AgentAlreadyRunning", (err) => Effect.succeed(jsonResponse({ error: `Agent already running for issue: ${err.id}` }, { status: 409 }))), Effect.catchTag("BeadsNotInitialized", (err) => Effect.succeed(jsonResponse({ error: `Beads not initialized for workspace: ${err.workspace}` }, { status: 422 }))), Effect.catchTag("PlanEmpty", (err) => Effect.succeed(jsonResponse({ error: `Plan is empty for issue: ${err.id}` }, { status: 422 }))), Effect.catchTag("TrackerApiError", (err) => Effect.succeed(jsonResponse({ error: `Tracker API error (${err.tracker}): ${err.message}` }, { status: 502 }))), Effect.catchTag("WorkspaceCreateError", (err) => Effect.succeed(jsonResponse({ error: `Workspace creation failed for ${err.id}: ${err.message}` }, { status: 500 }))), Effect.catchTag("AgentStartError", (err) => Effect.succeed(jsonResponse({ error: `Agent start failed for ${err.id}: ${err.message}` }, { status: 500 }))), Effect.catchCause((cause) => Effect.gen(function* () {
+	}, { status: 429 }))), Effect.catchTag("AgentAlreadyRunning", (err) => Effect.succeed(jsonResponse({ error: `Agent already running for issue: ${err.id}` }, { status: 409 }))), Effect.catchTag("PlanEmpty", (err) => Effect.succeed(jsonResponse({ error: `Plan is empty for issue: ${err.id}` }, { status: 422 }))), Effect.catchTag("TrackerApiError", (err) => Effect.succeed(jsonResponse({ error: `Tracker API error (${err.tracker}): ${err.message}` }, { status: 502 }))), Effect.catchTag("WorkspaceCreateError", (err) => Effect.succeed(jsonResponse({ error: `Workspace creation failed for ${err.id}: ${err.message}` }, { status: 500 }))), Effect.catchTag("AgentStartError", (err) => Effect.succeed(jsonResponse({ error: `Agent start failed for ${err.id}: ${err.message}` }, { status: 500 }))), Effect.catchCause((cause) => Effect.gen(function* () {
 		if (Cause.hasInterruptsOnly(cause)) return jsonResponse({ error: "Request cancelled" }, { status: 499 });
 		const error = Cause.squash(cause);
 		const message = error instanceof Error ? error.message : "Internal server error";
@@ -152,171 +183,27 @@ 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") {};
-async function checkCodexAuthStatusPromise(options = {}) {
-	const credPath = join$1(getCliproxyAuthDir(), "codex-primary.json");
-	let raw;
-	let credMtimeMs = null;
-	try {
-		raw = await readFile$1(credPath, "utf8");
-		credMtimeMs = (await stat$2(credPath)).mtimeMs;
-	} catch {
-		return { status: "missing" };
-	}
-	let creds;
-	try {
-		creds = JSON.parse(raw);
-	} catch {
-		return {
-			status: "unknown",
-			message: "Malformed credential file"
-		};
-	}
-	const accessToken = typeof creds.access_token === "string" ? creds.access_token : null;
-	if (!accessToken) return {
-		status: "unknown",
-		message: "Missing access_token in credential file"
-	};
-	const claims = decodeJwtPayload(accessToken);
-	if (!claims) return {
-		status: "unknown",
-		message: "Unable to decode access_token"
-	};
-	const expSec = typeof claims.exp === "number" ? claims.exp : null;
-	if (expSec === null) return {
-		status: "unknown",
-		message: "Missing exp claim in access_token"
-	};
-	const email = typeof creds.email === "string" ? creds.email : "";
-	const expiresAt = (/* @__PURE__ */ new Date(expSec * 1e3)).toISOString();
-	if (expSec * 1e3 <= Date.now()) return {
-		status: "expired",
-		email,
-		expiresAt
-	};
-	return await applyBurnedTokenOverride({
-		status: "valid",
-		email,
-		expiresAt
-	}, email, expiresAt, { ignoreBurnBefore: options.ignoreBurnBefore ?? credMtimeMs ?? void 0 });
-}
-/** Read the trailing window of the cliproxy log for burn/failure analysis. */
-async function readLogTail(path) {
-	const TAIL_BYTES = 128 * 1024;
-	const file = await open$1(path, "r");
-	try {
-		const stat = await file.stat();
-		const length = Math.min(stat.size, TAIL_BYTES);
-		const buffer = Buffer.alloc(length);
-		await file.read(buffer, 0, length, stat.size - length);
-		return buffer.toString("utf8");
-	} finally {
-		await file.close();
-	}
-}
-async function applyBurnedTokenOverride(baseStatus, email, expiresAt, options) {
-	let logRaw;
-	try {
-		logRaw = await readLogTail(getCliproxyLogPath());
-	} catch {
-		return baseStatus;
-	}
-	return evaluateBurnedFromLog(logRaw, baseStatus, email, expiresAt, options);
-}
-const BURN_STALENESS_MS = 3600 * 1e3;
-/**
-* Pure decision: given the cliproxy log tail, decide whether a JWT-valid token
-* is actually burned. Exported for regression testing (PAN-1584).
-*
-* "Auth failure" evidence = either a refresh-token burn line
-* (`refresh token has already been used`) OR a `503` on `/v1/messages` /
-* `/v1/chat/completions` (the live symptom the agent hits once cliproxy disables
-* the provider — and which keeps appearing after the burn line stops, since a
-* disabled provider no longer attempts refreshes). "Success" = a `200` on those
-* same paths (proves the auth path works right now).
-*
-* Decision:
-*   - No failure evidence              → trust base status.
-*   - Success AFTER the last failure   → trust base status (recovered).
-*   - Failure AFTER the credential's last write (ignoreBurnBefore) → BURNED,
-*     regardless of age. The credential write time is when you last logged in;
-*     a failure after it means the current token is dead. This is authoritative
-*     and is the fix for the bug where a >1h-stale burn line was dismissed as
-*     "valid" during a quiet period even though the token was dead (PAN-1584).
-*   - Failure BEFORE that cutoff       → trust base status (re-authed since).
-*   - No cutoff available              → fall back to the staleness backstop:
-*     burned only if the last failure is within BURN_STALENESS_MS.
-*
-* We intentionally don't probe cliproxy with HTTP — `GET /v1/models` always
-* 401s (it needs real OAuth, not the local key) and would generate spurious log
-* lines on every dashboard load.
-*/
-function evaluateBurnedFromLog(logRaw, baseStatus, email, expiresAt, options = {}) {
-	const now = options.now ?? Date.now();
-	const lines = logRaw.split("\n").slice(-500);
-	const isBurnLine = (l) => l.includes("refresh token has already been used") || l.includes("refresh_token_reused");
-	const isAuthFailure503 = (l) => /\b503 \|/.test(l) && /POST\s+"\/v1\/(messages|chat\/completions)/.test(l);
-	const isSuccess = (l) => /\b200 \|/.test(l) && /POST\s+"\/v1\/(messages|chat\/completions)/.test(l);
-	const timestampAt = (idx) => {
-		for (let j = idx; j >= Math.max(0, idx - 10); j--) {
-			const m = lines[j]?.match(/^\[(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})\]/);
-			if (m) {
-				const t = Date.parse(`${m[1]}T${m[2]}Z`);
-				if (Number.isFinite(t)) return t;
-			}
-		}
-		return null;
-	};
-	let lastFailureIdx = -1;
-	let lastFailureTimestamp = null;
-	let lastSuccessIdx = -1;
-	for (let i = lines.length - 1; i >= 0; i--) {
-		const line = lines[i] ?? "";
-		if (lastFailureIdx < 0 && (isBurnLine(line) || isAuthFailure503(line))) {
-			lastFailureIdx = i;
-			lastFailureTimestamp = timestampAt(i);
-		}
-		if (lastSuccessIdx < 0 && isSuccess(line)) lastSuccessIdx = i;
-		if (lastFailureIdx >= 0 && lastSuccessIdx >= 0) break;
-	}
-	if (lastFailureIdx < 0) return baseStatus;
-	if (lastSuccessIdx > lastFailureIdx) return baseStatus;
-	if (options.ignoreBurnBefore !== void 0) {
-		if (lastFailureTimestamp !== null && lastFailureTimestamp + 1e3 <= options.ignoreBurnBefore) return baseStatus;
-		return {
-			status: "burned",
-			email,
-			expiresAt
-		};
-	}
-	if (lastFailureTimestamp !== null && now - lastFailureTimestamp > BURN_STALENESS_MS) return baseStatus;
-	return {
-		status: "burned",
-		email,
-		expiresAt
-	};
-}
-/**
-* Effect-native checkCodexAuthStatus. The Promise version is designed to
-* swallow all I/O errors and report the auth state through the typed status
-* union. The Effect variant wraps that to make it composable; it only fails
-* with CodexAuthCheckError if the underlying call itself throws unexpectedly
-* (i.e., not from the documented "missing/unknown" branches).
-*/
-const checkCodexAuthStatus = (options = {}) => Effect.tryPromise({
-	try: () => checkCodexAuthStatusPromise(options),
-	catch: (cause) => new CodexAuthCheckError({
-		message: cause instanceof Error ? cause.message : String(cause),
-		cause
-	})
-});
-//#endregion
 //#region routes/origin-validation.ts
+init_conversations();
+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_harness_resolve();
+init_bridge_token();
+init_operator_interventions();
+init_lifecycle_io();
+init_agents$1();
+init_queries();
 let cachedTrustedOrigins;
 function addTrustedOrigin(origins, raw) {
 	if (!raw) return;
@@ -408,21 +295,75 @@ 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_codex_conversation_parser();
 init_ohmypi_conversation_parser();
 init_pi_conversation_parser();
 init_conversation_service();
-init_persistent_logger();
-init_feature_registry_population();
-init_model_validation();
-init_provider_health();
-init_stack_health();
-init_dag();
-init_staffing();
-init_beads_query();
-init_operator_interventions();
-init_lifecycle_io();
 /**
 * JSONL transcript resolver for the Command Deck (PAN-830).
 *
@@ -435,7 +376,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`
@@ -447,8 +389,13 @@ init_lifecycle_io();
 * Async-only (fs/promises) because this code path runs inside the dashboard
 * 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 +576,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-B7DTpwEw.js");
+	const { findRolloutPath, findLatestRollout } = await import("./codex-DxLivxri.js");
 	const threadId = (await readOptional(join(agentDir, "codex-thread-id")))?.trim();
 	if (threadId) {
 		const rollout = findRolloutPath(codexHome, threadId);
@@ -681,18 +628,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_agents$1();
+init_tmux();
 async function pathExists(path) {
 	try {
 		await access(path);
@@ -861,7 +817,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 +858,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 +867,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",
@@ -984,10 +940,10 @@ async function resolveAgentGitInfo(workspacePath, expectedBranch) {
 //#endregion
 //#region routes/agents/shared.ts
 init_paths();
-init_agents();
+init_agents$1();
 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",
@@ -1228,7 +1184,7 @@ function buildStoppedAgentLifecycle(agentOrIssueId, state, runtimeData) {
 	const agentId = normalizeAgentId(agentOrIssueId);
 	const hasAgentState = true;
 	const hasLiveTmuxSession = false;
-	const hasSavedSession = !!runtimeData.claudeSessionId;
+	const hasSavedSession = !!runtimeData.claudeSessionId || !!getLatestSessionIdSync(agentId);
 	const hasWorkspace = typeof state.workspace === "string" && state.workspace.length > 0;
 	const agentStatus = state.status || "unknown";
 	const runtime = runtimeData.state || "uninitialized";
@@ -1335,9 +1291,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();
@@ -1467,7 +1423,7 @@ const getAgentJsonlPath = getAgentJsonlPath$1;
 const getAgentPendingQuestions = getAgentPendingQuestions$1;
 //#endregion
 //#region routes/agents/listing.ts
-init_agents();
+init_agents$1();
 init_tmux();
 const getAgentsRoute = HttpRouter.add("GET", "/api/agents", httpHandler(Effect.gen(function* () {
 	const now = Date.now();
@@ -1698,7 +1654,7 @@ const getAgentHasSessionRoute = HttpRouter.add("GET", "/api/agents/:id/has-sessi
 //#endregion
 //#region routes/agents/conversation.ts
 init_paths();
-init_agents();
+init_agents$1();
 init_tmux();
 const getAgentOutputRoute = HttpRouter.add("GET", "/api/agents/:id/output", httpHandler(Effect.gen(function* () {
 	const id = (yield* HttpRouter.params)["id"] ?? "";
@@ -1720,7 +1676,7 @@ const getAgentOutputRoute = HttpRouter.add("GET", "/api/agents/:id/output", http
 			} catch {}
 			let stdout;
 			if (isRemote && vmName) {
-				const { getRemoteAgentOutput } = await import("./remote-agents-DlvbzO7m.js");
+				const { getRemoteAgentOutput } = await import("./remote-agents-DYY5fFpd.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") {
@@ -1794,119 +1750,1516 @@ async function buildConversationResponse(id) {
 				if (existsSync(candidate)) jsonlPath = candidate;
 			}
 		}
-		if (!jsonlPath) jsonlPath = await Effect.runPromise(getAgentJsonlPath(id));
-		if (!jsonlPath || !existsSync(jsonlPath)) return EMPTY_CONVERSATION;
-		return {
-			...await parseEntireConversation(jsonlPath),
-			streaming: false
-		};
-	} catch (err) {
-		console.error("[conversation] failed for", id, err);
-		return EMPTY_CONVERSATION;
+		if (!jsonlPath) jsonlPath = await Effect.runPromise(getAgentJsonlPath(id));
+		if (!jsonlPath || !existsSync(jsonlPath)) return EMPTY_CONVERSATION;
+		return {
+			...await parseEntireConversation(jsonlPath),
+			streaming: false
+		};
+	} catch (err) {
+		console.error("[conversation] failed for", id, err);
+		return EMPTY_CONVERSATION;
+	}
+}
+const getAgentConversationRoute = HttpRouter.add("GET", "/api/agents/:id/conversation", httpHandler(Effect.gen(function* () {
+	const id = (yield* HttpRouter.params)["id"] ?? "";
+	return yield* Effect.promise(async () => jsonResponse(await buildConversationResponse(id)));
+})));
+const getAgentActivityRoute = HttpRouter.add("GET", "/api/agents/:id/activity", httpHandler(Effect.gen(function* () {
+	const id = (yield* HttpRouter.params)["id"] ?? "";
+	const request = yield* HttpServerRequest.HttpServerRequest;
+	const urlOpt = HttpServerRequest.toURL(request);
+	const limitStr = Option.isSome(urlOpt) ? urlOpt.value.searchParams.get("limit") ?? "100" : "100";
+	return jsonResponse({ activity: getActivity(id, parseInt(limitStr) || 100) });
+})));
+const getAgentFilesRoute = HttpRouter.add("GET", "/api/agents/:id/files", httpHandler(Effect.gen(function* () {
+	const agentState = yield* getAgentState((yield* HttpRouter.params)["id"] ?? "");
+	if (!agentState?.workspace) return jsonResponse({ files: [] });
+	const workspacePath = agentState.workspace;
+	if (!existsSync(workspacePath)) return jsonResponse({ files: [] });
+	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"
+	}));
+	return jsonResponse({ files: stdout.split("\n").filter((l) => l.trim()).map((l) => {
+		const parts = l.trim().split(/\s+/);
+		if (parts.length >= 2) return {
+			status: parts[0],
+			path: parts[parts.length - 1]
+		};
+		return {
+			status: "?",
+			path: l.trim()
+		};
+	}).filter((f) => f.path) });
+})));
+const getAgentTimelineRoute = HttpRouter.add("GET", "/api/agents/:id/timeline", httpHandler(Effect.gen(function* () {
+	const id = (yield* HttpRouter.params)["id"] ?? "";
+	const request = yield* HttpServerRequest.HttpServerRequest;
+	const urlOpt = HttpServerRequest.toURL(request);
+	const limitStr = Option.isSome(urlOpt) ? urlOpt.value.searchParams.get("limit") ?? "50" : "50";
+	const limit = parseInt(limitStr) || 50;
+	const activity = getActivity(id, limit);
+	const agentState = yield* getAgentState(id);
+	const events = activity.map((a) => ({
+		timestamp: a.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+		type: a.type || "activity",
+		message: a.message || a.content || ""
+	}));
+	if (agentState?.startedAt) events.unshift({
+		timestamp: agentState.startedAt,
+		type: "started",
+		message: "Agent started"
+	});
+	events.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+	return jsonResponse({ timeline: events.slice(0, limit) });
+})));
+//#endregion
+//#region routes/agents/messaging.ts
+init_agents$1();
+async function sendAgentMessage(id, message) {
+	const remoteStateFile = join(join(homedir(), ".overdeck", "agents", id), "remote-state.json");
+	let isRemote = false;
+	if (existsSync(remoteStateFile)) try {
+		const state = JSON.parse(await readFile(remoteStateFile, "utf-8"));
+		isRemote = state.location === "remote" && Boolean(state.vmName);
+	} catch {}
+	await messageAgent(id, message, "dashboard:user-message");
+	return isRemote ? {
+		success: true,
+		remote: true
+	} : { success: true };
+}
+function validateAgentMessageOrigin(request) {
+	const originCheck = validateOrigin(request);
+	if (!originCheck.ok) return {
+		ok: false,
+		response: jsonResponse({
+			ok: false,
+			error: originCheck.error
+		}, { status: 403 })
+	};
+	return { ok: true };
+}
+function postAgentMessageLikeRoute(path) {
+	return HttpRouter.add("POST", path, httpHandler(Effect.gen(function* () {
+		const originCheck = validateAgentMessageOrigin(yield* HttpServerRequest.HttpServerRequest);
+		if (!originCheck.ok) return originCheck.response;
+		const id = (yield* HttpRouter.params)["id"] ?? "";
+		const { message } = yield* readJsonBody$1;
+		if (!message) return jsonResponse({ error: "Message required" }, { status: 400 });
+		return yield* Effect.promise(() => sendAgentMessage(id, message)).pipe(Effect.map((result) => jsonResponse(result)));
+	})));
+}
+const postAgentMessageRoute = postAgentMessageLikeRoute("/api/agents/:id/message");
+const postAgentTellRoute = postAgentMessageLikeRoute("/api/agents/:id/tell");
+const postAgentPokeRoute = HttpRouter.add("POST", "/api/agents/:id/poke", httpHandler(Effect.gen(function* () {
+	const id = (yield* HttpRouter.params)["id"] ?? "";
+	const { message } = yield* readJsonBody$1;
+	const pokeMsg = message || "You seem to have been inactive for a while. If you're stuck:\n1. Check your current task in continue.vbrief.json\n2. Try an alternative approach if blocked\n3. Ask for help if needed\n\nWhat's your current status?";
+	yield* Effect.promise(() => messageAgent(id, pokeMsg));
+	return jsonResponse({
+		success: true,
+		message: "Agent poked successfully"
+	});
+})));
+//#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-BajHQ60c.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$1();
+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-DxLivxri.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-B1mYn0lN.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-DxLivxri.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 });
 	}
 }
-const getAgentConversationRoute = HttpRouter.add("GET", "/api/agents/:id/conversation", httpHandler(Effect.gen(function* () {
-	const id = (yield* HttpRouter.params)["id"] ?? "";
-	return yield* Effect.promise(async () => jsonResponse(await buildConversationResponse(id)));
-})));
-const getAgentActivityRoute = HttpRouter.add("GET", "/api/agents/:id/activity", httpHandler(Effect.gen(function* () {
-	const id = (yield* HttpRouter.params)["id"] ?? "";
-	const request = yield* HttpServerRequest.HttpServerRequest;
-	const urlOpt = HttpServerRequest.toURL(request);
-	const limitStr = Option.isSome(urlOpt) ? urlOpt.value.searchParams.get("limit") ?? "100" : "100";
-	return jsonResponse({ activity: getActivity(id, parseInt(limitStr) || 100) });
-})));
-const getAgentFilesRoute = HttpRouter.add("GET", "/api/agents/:id/files", httpHandler(Effect.gen(function* () {
-	const agentState = yield* getAgentState((yield* HttpRouter.params)["id"] ?? "");
-	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 \"\"", {
-		cwd: workspacePath,
-		encoding: "utf-8"
-	}));
-	return jsonResponse({ files: stdout.split("\n").filter((l) => l.trim()).map((l) => {
-		const parts = l.trim().split(/\s+/);
-		if (parts.length >= 2) return {
-			status: parts[0],
-			path: parts[parts.length - 1]
-		};
-		return {
-			status: "?",
-			path: l.trim()
-		};
-	}).filter((f) => f.path) });
-})));
-const getAgentTimelineRoute = HttpRouter.add("GET", "/api/agents/:id/timeline", httpHandler(Effect.gen(function* () {
-	const id = (yield* HttpRouter.params)["id"] ?? "";
-	const request = yield* HttpServerRequest.HttpServerRequest;
-	const urlOpt = HttpServerRequest.toURL(request);
-	const limitStr = Option.isSome(urlOpt) ? urlOpt.value.searchParams.get("limit") ?? "50" : "50";
-	const limit = parseInt(limitStr) || 50;
-	const activity = getActivity(id, limit);
-	const agentState = yield* getAgentState(id);
-	const events = activity.map((a) => ({
-		timestamp: a.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-		type: a.type || "activity",
-		message: a.message || a.content || ""
-	}));
-	if (agentState?.startedAt) events.unshift({
-		timestamp: agentState.startedAt,
-		type: "started",
-		message: "Agent started"
-	});
-	events.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
-	return jsonResponse({ timeline: events.slice(0, limit) });
-})));
 //#endregion
-//#region routes/agents/messaging.ts
-init_agents();
-async function sendAgentMessage(id, message) {
-	const remoteStateFile = join(join(homedir(), ".overdeck", "agents", id), "remote-state.json");
-	let isRemote = false;
-	if (existsSync(remoteStateFile)) try {
-		const state = JSON.parse(await readFile(remoteStateFile, "utf-8"));
-		isRemote = state.location === "remote" && Boolean(state.vmName);
-	} catch {}
-	await messageAgent(id, message, "dashboard:user-message");
-	return isRemote ? {
-		success: true,
-		remote: true
-	} : { success: true };
+//#region ../../lib/overdeck/conversation-delivery.ts
+init_conversations();
+init_behavior();
+init_tmux();
+init_agents$1();
+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 validateAgentMessageOrigin(request) {
-	const originCheck = validateOrigin(request);
-	if (!originCheck.ok) return {
-		ok: false,
-		response: jsonResponse({
-			ok: false,
-			error: originCheck.error
-		}, { status: 403 })
+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 } : {}
+			})
+		}
 	};
-	return { ok: true };
 }
-function postAgentMessageLikeRoute(path) {
-	return HttpRouter.add("POST", path, httpHandler(Effect.gen(function* () {
-		const originCheck = validateAgentMessageOrigin(yield* HttpServerRequest.HttpServerRequest);
-		if (!originCheck.ok) return originCheck.response;
-		const id = (yield* HttpRouter.params)["id"] ?? "";
-		const { message } = yield* readJsonBody$1;
-		if (!message) return jsonResponse({ error: "Message required" }, { status: 400 });
-		return yield* Effect.promise(() => sendAgentMessage(id, message)).pipe(Effect.map((result) => jsonResponse(result)));
-	})));
+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);
 }
-const postAgentMessageRoute = postAgentMessageLikeRoute("/api/agents/:id/message");
-const postAgentTellRoute = postAgentMessageLikeRoute("/api/agents/:id/tell");
-const postAgentPokeRoute = HttpRouter.add("POST", "/api/agents/:id/poke", httpHandler(Effect.gen(function* () {
-	const id = (yield* HttpRouter.params)["id"] ?? "";
-	const { message } = yield* readJsonBody$1;
-	const pokeMsg = message || "You seem to have been inactive for a while. If you're stuck:\n1. Check your current task in continue.vbrief.json\n2. Try an alternative approach if blocked\n3. Ask for help if needed\n\nWhat's your current status?";
-	yield* Effect.promise(() => messageAgent(id, pokeMsg));
+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({
-		success: true,
-		message: "Agent poked successfully"
+		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 = {
@@ -2095,7 +3448,7 @@ async function processPermissionResponse(deps, args) {
 }
 //#endregion
 //#region routes/agents/permissions.ts
-init_agents();
+init_agents$1();
 init_activity_logger();
 init_read_model();
 const getAgentPendingQuestionsRoute = HttpRouter.add("GET", "/api/agents/:id/pending-questions", httpHandler(Effect.gen(function* () {
@@ -2127,6 +3480,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 +3511,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-CCaWaTwE.js"));
+	const { INTERNAL_TOKEN_HEADER, getInternalTokenSync } = yield* Effect.promise(() => import("./internal-token-D-t28de5.js"));
 	const expected = getInternalTokenSync();
 	if (!expected) return jsonResponse({
 		ok: false,
@@ -2401,7 +3778,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-B_WsQyYm.js"));
+	const { getHealthHistory } = yield* Effect.promise(() => import("./health-events-B0mj6Iae.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 +3819,7 @@ function emitAgentRuntimeEvent(id, body, timestamp) {
 				detail: String(decoded.failure)
 			}, { status: 400 })
 		};
-		const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-C_2ZAQRP.js"));
+		const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-BUfovFfB.js"));
 		yield* (yield* AgentStateService).emit(decoded.success);
 		return {
 			ok: true,
@@ -2508,14 +3885,14 @@ const postAgentStuckRoute = HttpRouter.add("POST", "/api/agents/:id/stuck", http
 	});
 })));
 function hasNegatedCompletionOutput(output) {
-	return /\b(not|never|no|cannot|can't|blocked|waiting|needs input|not yet|isn't|aren't)\b.{0,48}\b(implementation complete|all beads closed|ready for review|work complete)\b/i.test(output);
+	return /\b(not|never|no|cannot|can't|blocked|waiting|needs input|not yet|isn't|aren't)\b.{0,48}\b(implementation complete|all tasks closed|ready for review|work complete)\b/i.test(output);
 }
 const postAgentClassifyCompletionRoute = HttpRouter.add("POST", "/api/agents/:id/classify-completion", httpHandler(Effect.gen(function* () {
 	const body = yield* readJsonBody$1;
 	const output = typeof body["output"] === "string" ? body["output"] : "";
 	return jsonResponse({
 		success: true,
-		verdict: /blocked|needs input|waiting for|not ready for review/i.test(output) || hasNegatedCompletionOutput(output) ? "STOPPED_FOR_INPUT" : /Implementation complete|all beads closed|ready for review|work complete/i.test(output) ? "FORGOT_COMPLETION" : "UNCLEAR"
+		verdict: /blocked|needs input|waiting for|not ready for review/i.test(output) || hasNegatedCompletionOutput(output) ? "STOPPED_FOR_INPUT" : /Implementation complete|all tasks closed|ready for review|work complete/i.test(output) ? "FORGOT_COMPLETION" : "UNCLEAR"
 	});
 })));
 const getAgentRuntimeRoute = HttpRouter.add("GET", "/api/agents/:id/runtime", httpHandler(Effect.gen(function* () {
@@ -2524,7 +3901,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-C_2ZAQRP.js"));
+	const { AgentStateService } = yield* Effect.promise(() => import("./agent-state-service-BUfovFfB.js"));
 	const snapshot = yield* (yield* AgentStateService).get(id);
 	if (!snapshot) return jsonResponse({
 		success: false,
@@ -2550,7 +3927,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_agents();
+init_event_store();
+init_agents$1();
+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();
@@ -2617,7 +3996,7 @@ function saveAgentStateAndEmitEventWithDeps(db, eventStore, state, event) {
 }
 //#endregion
 //#region routes/agents/lifecycle-stop.ts
-init_agents();
+init_agents$1();
 init_activity_logger();
 init_tmux();
 init_domain_services();
@@ -2635,8 +4014,8 @@ function createAgentStopHandler(lifecycleEvent) {
 		yield* stopAgent(id);
 		if (stateBeforeStop?.issueId) yield* Effect.promise(async () => {
 			try {
-				const { resolveProjectFromIssueSync } = await import("./projects-KJ94e50I.js");
-				const { findWorkspacePath } = await import("./archive-planning-CTILQRnV.js");
+				const { resolveProjectFromIssueSync } = await import("./projects-Dc9aoVoG.js");
+				const { findWorkspacePath } = await import("./archive-planning-D-QsBufn.js");
 				const issueLower = stateBeforeStop.issueId.toLowerCase();
 				const workspacePath = findWorkspacePath(resolveProjectFromIssueSync(stateBeforeStop.issueId)?.projectPath ?? process.cwd(), issueLower);
 				if (workspacePath) {
@@ -2806,7 +4185,9 @@ const postAgentUntroubledRoute = HttpRouter.add("POST", "/api/agents/:id/untroub
 })));
 //#endregion
 //#region routes/agents/lifecycle-restart.ts
-init_agents();
+init_config_yaml();
+init_agents$1();
+init_harness_policy();
 init_operator_interventions();
 init_projects();
 init_tmux();
@@ -3092,9 +4473,14 @@ const postAgentRestartFreshRoute = HttpRouter.add("POST", "/api/agents/:id/resta
 	const agentState = yield* getAgentState(id);
 	if (!agentState) return jsonResponse({ error: `Agent ${id} not found` }, { status: 404 });
 	const issueId = agentState.issueId ?? id.replace(/^agent-/, "").toUpperCase();
+	const issueStage = getIssueStageSync(issueId);
+	if (wantsSpawn && isTerminalIssueStage(issueStage)) return jsonResponse({
+		error: `${issueId} is already ${issueStage?.replaceAll("_", " ")}. Reopen the issue before starting fresh work.`,
+		issueStage
+	}, { status: 409 });
 	const lifecycle = yield* getWorkAgentLifecycleState(id);
 	if (lifecycle.hasLiveTmuxSession) return jsonResponse({
-		error: `Agent ${id} has a live tmux session. Run 'pan kill ${issueId}' first, then retry.`,
+		error: `Agent ${id} has a live tmux session. Run 'pan kill ${id}' to stop only this work agent, then retry.`,
 		lifecycle
 	}, { status: 409 });
 	yield* Effect.promise(() => appendAgentLifecycleLog(id, "agent.restart_fresh_requested", {
@@ -3157,9 +4543,21 @@ const postAgentRestartFreshRoute = HttpRouter.add("POST", "/api/agents/:id/resta
 			cwd: workspacePath
 		}));
 	} catch (err) {
+		saveAgentStateSync({
+			id: agentSessionName,
+			issueId,
+			workspace: workspacePath,
+			harness: effectiveHarness ?? agentState.harness ?? "claude-code",
+			role: "work",
+			model: spawnModel,
+			status: "stopped",
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			stoppedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
 		return jsonResponse({
 			success: false,
-			error: `Agent dir wiped but spawn failed: ${err?.message ?? String(err)}`,
+			error: "The old agent state was cleared, but the fresh agent could not start. Resolve the startup blocker, then try again.",
+			details: err?.message ?? String(err),
 			wiped: wipeResult.removed
 		}, { status: 500 });
 	}
@@ -3345,6 +4743,7 @@ async function resolveCurrentStaffing(agentId, agentState, issueId) {
 		const staffing = resolveStaffing(workItem, {
 			planMetadata: plan.plan.metadata,
 			spawnKey: `work:${issueId.toLowerCase()}`,
+			issueId,
 			config: {
 				...config,
 				tieredExecution: {
@@ -3441,7 +4840,7 @@ init_config();
 init_jsonl_parser();
 init_model_validation();
 init_paths();
-init_agents();
+init_agents$1();
 const getAgentCloisterHealthRoute = HttpRouter.add("GET", "/api/agents/:id/cloister-health", httpHandler(Effect.gen(function* () {
 	const id = (yield* HttpRouter.params)["id"] ?? "";
 	const health = getCloisterService().getAgentHealth(id);
@@ -3593,6 +4992,7 @@ const postAgentSwitchModelRoute = HttpRouter.add("POST", "/api/agents/:id/switch
 //#endregion
 //#region ../../lib/vbrief/auto-synthesize.ts
 init_state_read_home();
+init_codex_auth();
 init_state_home();
 init_io();
 function cleanMarkdownLine(line) {
@@ -3711,19 +5111,20 @@ const writeAutoStartVBrief = (projectRoot, workspacePath, issue) => Effect.tryPr
 //#endregion
 //#region routes/agents/spawn-helpers.ts
 init_issue_lifecycle();
-init_agents();
+init_child_env();
+init_agents$1();
 function handleRemoteAgentSpawn(input) {
 	return Effect.gen(function* () {
 		const { issueId, workspacePath, workspaceMetadata, spawnModel, projectPath, spawnGuardrails, lifecycle } = input;
-		const { spawnRemoteAgent, checkRemoteSpendCap } = yield* Effect.promise(() => import("./remote-agents-DlvbzO7m.js"));
-		const { createFlyProviderFromConfig } = yield* Effect.promise(() => import("./remote-DmeL21dF.js"));
-		const { loadConfigSync: loadPanConfig } = yield* Effect.promise(() => import("./config-BRNQJXhA.js"));
+		const { spawnRemoteAgent, checkRemoteSpendCap } = yield* Effect.promise(() => import("./remote-agents-DYY5fFpd.js"));
+		const { createFlyProviderFromConfig } = yield* Effect.promise(() => import("./remote-Cvu4CSDk.js"));
+		const { loadConfigSync: loadPanConfig } = yield* Effect.promise(() => import("./config-6MCHOZ2N.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-fZljjA1_.js"));
+		const { buildWorkAgentPrompt, getTrackerContext } = yield* Effect.promise(() => import("./work-agent-prompt-BiJ43Der.js"));
 		const trackerContext = yield* Effect.promise(() => getTrackerContext(issueId, workspacePath));
 		const agentPrompt = yield* Effect.promise(() => buildWorkAgentPrompt({
 			issueId,
@@ -3809,7 +5210,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 +5253,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 +5319,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}`,
@@ -4038,7 +5439,7 @@ function handleContainerOrchestration(input) {
 }
 //#endregion
 //#region routes/agents/spawn.ts
-init_agents();
+init_agents$1();
 init_child_env();
 init_harness_policy();
 init_activity_logger();
@@ -4070,45 +5471,6 @@ function spawnGuardrailResourcesHint(hint) {
 	const resourcesHint = "Open /resources to inspect Machine Room pressure before retrying.";
 	return hint ? `${hint} ${resourcesHint}` : resourcesHint;
 }
-/**
-* Count materialized beads for an issue by shelling out to `bd list`.
-*
-* Returns 0 on ANY bd failure — non-zero exit (e.g. bd refusing with "Linear
-* data has never been pulled"), an unparseable JSON body, or the 10s timeout.
-* The caller treats 0 as "no beads yet" and falls through to auto-recovery
-* (createBeadsFromVBrief) and, failing that, a clean 422 `beads_required`.
-*
-* The failure is folded into the success channel with `Effect.matchCause`. A
-* bare `try/catch` around `yield* withBdMutex(...)` does NOT work: withBdMutex
-* converts the child-process rejection into an Effect error-channel failure
-* (via its internal `Effect.tryPromise`), which short-circuits the fiber and is
-* 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", [
-	"list",
-	"--json",
-	"-l",
-	issueLower,
-	"--status",
-	"all",
-	"--limit",
-	"0"
-], {
-	cwd: workspacePath,
-	encoding: "utf-8",
-	timeout: 1e4
-}))).pipe(Effect.matchCause({
-	onFailure: () => 0,
-	onSuccess: ({ stdout }) => {
-		try {
-			const bdTasks = JSON.parse(stdout.trim() || "[]");
-			return Array.isArray(bdTasks) ? bdTasks.length : 0;
-		} catch {
-			return 0;
-		}
-	}
-}));
 const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect.gen(function* () {
 	const originCheck = validateOrigin(yield* HttpServerRequest.HttpServerRequest);
 	if (!originCheck.ok) return jsonResponse({
@@ -4176,7 +5538,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,
@@ -4190,13 +5552,6 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 	}
 	const workspacePanDir = join(workspacePath, PAN_DIRNAME);
 	const workspacePanContinuePath = join(workspacePanDir, PAN_CONTINUE_FILENAME);
-	const workspaceBeadsDir = join(workspacePath, ".beads");
-	if (!existsSync(workspaceBeadsDir)) {
-		const projectRootBeadsDir = join(projectPath, ".beads");
-		if (existsSync(projectRootBeadsDir)) try {
-			yield* Effect.promise(() => cp(projectRootBeadsDir, workspaceBeadsDir, { recursive: true }));
-		} catch {}
-	}
 	let planPath = yield* findPlan(workspacePath);
 	if (autoStart && !planPath) {
 		yield* writeAutoStartVBrief(projectPath, workspacePath, {
@@ -4208,7 +5563,7 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 		planPath = yield* findPlan(workspacePath);
 	}
 	if (!planPath) return jsonResponse({
-		error: `No workspace vBRIEF found for ${issueId}. Work agents require a finalized plan with matching beads.`,
+		error: `No workspace vBRIEF found for ${issueId}. Work agents require a finalized plan.`,
 		hint: "Run planning first, or use auto-start to synthesize a plan before starting the work agent.",
 		issueId
 	}, { status: 422 });
@@ -4239,44 +5594,11 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 		expectedIssue: issueId,
 		actualIssue: planIssueId.toUpperCase()
 	}, { status: 422 });
-	const planItemCount = planDoc?.plan?.items?.length ?? 0;
-	if (planItemCount === 0) return jsonResponse({
+	if ((planDoc?.plan?.items?.length ?? 0) === 0) return jsonResponse({
 		error: "Plan exists but contains no items. Planning may have failed or produced an empty plan.",
 		hint: "Re-run planning to produce a plan with tasks and acceptance criteria.",
 		issueId
 	}, { status: 422 });
-	let beadCount = yield* countBeadsForIssue(workspacePath, issueLower);
-	let hasBeads = beadCount > 0;
-	if (planItemCount !== null && planItemCount > 0 && beadCount !== planItemCount) hasBeads = false;
-	let recoveryError = null;
-	if (!hasBeads) {
-		console.log(`[agents] No beads for ${issueId} — attempting auto-recovery via createBeadsFromVBrief`);
-		try {
-			const { createBeadsFromVBrief } = yield* Effect.promise(() => import("./beads-CYsLiyIM.js"));
-			const recovery = yield* createBeadsFromVBrief(workspacePath);
-			beadCount = recovery.created.length;
-			hasBeads = recovery.created.length > 0 && (planItemCount === null || recovery.created.length === planItemCount);
-			if (hasBeads) console.log(`[agents] Auto-recovery created ${recovery.created.length} beads for ${issueId}`);
-			else if (recovery.created.length > 0 && planItemCount !== null) recoveryError = `created ${recovery.created.length} beads, but vBRIEF has ${planItemCount} plan items`;
-			else if (recovery.errors.length > 0) {
-				recoveryError = recovery.errors[0] ?? "Unknown error during beads creation";
-				console.warn(`[agents] Auto-recovery errors: ${recovery.errors.join(", ")}`);
-			} else recoveryError = "createBeadsFromVBrief returned no beads and no errors";
-		} catch (recoveryErr) {
-			recoveryError = recoveryErr.message;
-			console.warn(`[agents] Auto-recovery failed: ${recoveryErr.message}`);
-		}
-	}
-	if (!hasBeads) {
-		const detail = recoveryError ? ` Beads recovery failed: ${recoveryError}.` : " No beads exist for this issue.";
-		console.warn(`[agents] Refusing to start work agent for ${issueId} without beads.${detail}`);
-		return jsonResponse({
-			success: false,
-			error: "beads_required",
-			message: `Cannot start work agent for ${issueId} without beads.${detail} Re-run planning so beads can be materialized from the vBRIEF plan, then retry.`,
-			...recoveryError ? { recoveryError } : {}
-		}, { status: 422 });
-	}
 	const health = yield* readModel.getSnapshot.pipe(Effect.flatMap((snapshot) => Effect.promise(() => getSystemHealthSnapshot(snapshot))));
 	emitStartAgentPhase(issueId, "guardrails", "start", "evaluating spawn guardrails");
 	const spawnGuardrails = evaluateSpawnGuardrails(health);
@@ -4320,7 +5642,7 @@ const postAgentsRoute = HttpRouter.add("POST", "/api/agents", httpHandler(Effect
 		return jsonResponse({ error: err instanceof Error ? err.message : String(err) }, { status: 400 });
 	}
 	if ((yield* Effect.promise(() => getProviderAuthMode(spawnModel))) === "subscription") {
-		const codexAuth = yield* checkCodexAuthStatus();
+		const codexAuth = yield* checkCodexAuthStatus({ agentStates: listAgentStates() });
 		if (codexAuth.status === "expired" || codexAuth.status === "burned") return jsonResponse({
 			success: false,
 			blocked: true,
@@ -4398,24 +5720,20 @@ 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/`, {
-			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 +5760,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-pyB6VA32.js"));
+		const { appendSessionEntry, getProjectConfigFromWorkspacePath, resolveProjectForIssue } = yield* Effect.promise(() => import("./record-DLOqfbkI.js"));
 		const recordProject = resolveProjectForIssue(issueId) ?? getProjectConfigFromWorkspacePath(workspacePath);
 		yield* Effect.promise(() => appendSessionEntry(recordProject, issueId, {
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4491,12 +5809,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,39 +6006,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);
-//#endregion
-//#region ../../lib/cloister/task-readiness.ts
-init_io();
-const TERMINAL_STATUSES = ["completed", "cancelled"];
-/**
-* Returns the list of item IDs that are newly unblocked after `justCompletedId`
-* reaches a terminal status.
-*
-* "Newly unblocked" means: the item was not ready before (had at least one
-* non-terminal blocker) and is now ready after this completion.
-*
-* Returns [] when no plan exists.
-*/
-function getUnblockedItemsSync(workspacePath, justCompletedId) {
-	const doc = readWorkspacePlanSync(workspacePath);
-	if (!doc) return [];
-	const itemById = new Map(doc.plan.items.map((i) => [i.id, i]));
-	const directlyUnblocking = doc.plan.edges.filter((e) => e.type === "blocks" && e.from === justCompletedId).map((e) => e.to);
-	const unblocked = [];
-	for (const candidateId of directlyUnblocking) {
-		const candidate = itemById.get(candidateId);
-		if (!candidate) continue;
-		if (TERMINAL_STATUSES.includes(candidate.status)) continue;
-		if (doc.plan.edges.filter((e) => e.type === "blocks" && e.to === candidateId).map((e) => e.from).every((blockerId) => {
-			const blocker = itemById.get(blockerId);
-			if (!blocker) return true;
-			if (blockerId === justCompletedId) return true;
-			return TERMINAL_STATUSES.includes(blocker.status);
-		})) unblocked.push(candidateId);
-	}
-	return unblocked;
-}
+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 routes/tiered-inspect-escalation.ts
 init_tier_escalation();
@@ -4745,18 +6031,18 @@ function handleTieredInspectFailureEscalation(issueId, notes, deps = {}) {
 	if (!exists(workspacePath)) return null;
 	const doc = readPlan(workspacePath);
 	if (!resolveTieredExecutionEnabled(tiered, doc?.plan.metadata)) return null;
-	const beadId = notes?.match(/[Bb]ead\s+(\S+)/)?.[1];
-	if (!doc || !beadId) return null;
-	const item = doc.plan.items.find((candidate) => candidate.id === beadId);
+	const taskId = notes?.match(/[Bb]ead\s+(\S+)/)?.[1];
+	if (!doc || !taskId) return null;
+	const item = doc.plan.items.find((candidate) => candidate.id === taskId);
 	if (!item) return null;
 	const overrides = readOverrides(workspacePath);
 	const decision = decide({
 		kind: "supervisor-blocked",
-		beadId,
+		taskId,
 		sha: getReviewStatusSync(issueId)?.reviewedAtCommit ?? "unknown",
 		attemptsAtCurrentTier: tiered.escalation.retries_at_tier
 	}, item, tiered.escalation, overrides);
-	if (decision.action === "promote") recordPromotion(workspacePath, beadId, decision.from, decision.to, decision.reason);
+	if (decision.action === "promote") recordPromotion(workspacePath, taskId, decision.from, decision.to, decision.reason);
 	return decision;
 }
 async function reportTieredInspectFailureEscalation(issueId, notes, deps = {}) {
@@ -4860,10 +6146,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-36wfYm2u.js");
+		const { postMergeLifecycle } = await import("./merge-agent-DMQTJMP0.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-DGqVuNZV.js");
+		const { runMergeTrainReconcile } = await import("./merge-train-DJgr81tF.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));
@@ -4877,22 +6163,21 @@ function getProjectPathForIssue(issuePrefix) {
 }
 //#endregion
 //#region routes/specialists/legacy-routes.ts
-init_agents();
+init_agents$1();
 init_projects();
 init_review_status();
-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-8ZAguXef.js"));
+	const { getAllSpecialistStatus, getAllProjectSpecialistStatuses } = yield* Effect.promise(() => import("./specialists-D9-dMUtI.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-8ZAguXef.js"));
-	const { clearHookSync } = yield* Effect.promise(() => import("./hooks-C1ScyVxP.js"));
+	const { getAllSpecialists, isRunning, getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-D9-dMUtI.js"));
+	const { clearHookSync } = yield* Effect.promise(() => import("./hooks-BDcQJDUe.js"));
 	const specialists = getAllSpecialists();
 	const results = [];
 	for (const specialist of specialists) {
@@ -4942,7 +6227,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-BZ8M-WZ0.js"));
+		const { reportSpecialistCompletion } = yield* Effect.promise(() => import("./specialist-completion-pJtESo7m.js"));
 		if (yield* reportSpecialistCompletion(normalizedIssueId, {
 			status,
 			notes
@@ -4989,7 +6274,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-8ZAguXef.js");
+			const { getTmuxSessionName, updateRunMetadata, makeSpecialistRegistryKey } = await import("./specialists-D9-dMUtI.js");
 			const projectKey = resolveProjectFromIssueSync(normalizedIssueId)?.projectKey;
 			const tmuxSession = projectKey ? getTmuxSessionName(`${specialist}-agent`, projectKey, normalizedIssueId) : getTmuxSessionName(`${specialist}-agent`);
 			saveAgentRuntimeState(tmuxSession, {
@@ -5008,7 +6293,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-BxX1YefH.js");
+			const { updateSpecialistHandoffStatus } = await import("./specialist-handoff-logger-Duz9RGvk.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 +6305,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-BCLRWQ-y.js");
+					const { getWorkspaceGitInfo } = await import("./git-utils-q8jNoBts.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,40 +6317,12 @@ const postSpecialistsDoneRoute = HttpRouter.add("POST", "/api/specialists/done",
 	});
 	if (specialist === "inspect" && status === "passed") yield* Effect.promise(async () => {
 		try {
-			const { onInspectComplete } = await import("./inspect-agent-477VxQim.js");
-			const beadId = (notes?.match(/[Bb]ead\s+(\S+)/))?.[1] || "unknown";
+			const { onInspectComplete } = await import("./inspect-agent-DCJQm9Wu.js");
+			const taskId = (notes?.match(/[Bb]ead\s+(\S+)/))?.[1] || "unknown";
 			const project = resolveProjectFromIssueSync(normalizedIssueId);
 			if (project) {
 				const workspacePath = join(project.projectPath, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`);
-				if (existsSync(workspacePath)) {
-					await Effect.runPromise(onInspectComplete(project.projectKey, normalizedIssueId, beadId, "passed", workspacePath));
-					try {
-						const beadData = await Effect.runPromise(queryBeadById(workspacePath, beadId));
-						const updatedItemId = await Effect.runPromise(syncBeadStatusToVBrief(beadId, workspacePath, "completed", beadData?.title));
-						if (updatedItemId) try {
-							const unblockedItems = getUnblockedItemsSync(workspacePath, updatedItemId);
-							if (unblockedItems.length > 0) {
-								console.log(`[auto-wake] ${normalizedIssueId}: items unblocked after "${updatedItemId}": ${unblockedItems.join(", ")}`);
-								const workAgentId = `agent-${normalizedIssueId.toLowerCase()}`;
-								const doc = readWorkspacePlanSync(workspacePath);
-								const unblockedTitles = unblockedItems.map((id) => {
-									const it = doc?.plan.items.find((i) => i.id === id);
-									return it ? `"${it.title}"` : `"${id}"`;
-								}).join(", ");
-								await messageAgent(workAgentId, `DAG SCHEDULER: Task${unblockedItems.length > 1 ? "s" : ""} now unblocked after completing "${updatedItemId}": ${unblockedTitles}. Pick up the next available task.`).catch((err) => {
-									const errMsg = err instanceof Error ? err.message : String(err);
-									console.log(`[auto-wake] Could not wake ${workAgentId} (may not be running): ${errMsg}`);
-								});
-							}
-						} catch (wakeErr) {
-							const errMsg = wakeErr instanceof Error ? wakeErr.message : String(wakeErr);
-							console.warn(`[auto-wake] Failed to check unblocked items: ${errMsg}`);
-						}
-					} catch (syncErr) {
-						const errMsg = syncErr instanceof Error ? syncErr.message : String(syncErr);
-						console.warn(`[specialists/done] vBRIEF sync failed: ${errMsg}`);
-					}
-				}
+				if (existsSync(workspacePath)) await Effect.runPromise(onInspectComplete(project.projectKey, normalizedIssueId, taskId, "passed", workspacePath));
 			}
 		} catch (err) {
 			console.error(`[specialists/done] Error saving inspect checkpoint:`, err);
@@ -5077,7 +6334,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-CcJAhKCl.js");
+					const { initEventStore } = await import("./event-store-D9UhQyMS.js");
 					await (await initEventStore()).appendAsync({
 						type: "test.passed",
 						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -5130,8 +6387,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-x291Gjjb.js");
-				const { messageAgent, spawnAgent, getAgentStateSync } = await import("./agents-DCvyTXNU.js");
+				const { sessionExists } = await import("./tmux-C-rgxRDA.js");
+				const { messageAgent, spawnAgent, getAgentStateSync } = await import("./agents-BA15AQqo.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 +6402,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-YOzmsq9G.js");
+			const { deliverReviewVerdictFeedback } = await import("./review-verdict-feedback-BsFLjN_6.js");
 			const result = await Effect.runPromise(deliverReviewVerdictFeedback({
 				issueId: normalizedIssueId,
 				verdict: status === "failed" ? "failed" : "blocked",
@@ -5186,7 +6443,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-BWZYcJ6P.js"));
+	const { cleanupAllLogsSync } = yield* Effect.promise(() => import("./specialist-logs-DtSkPJZK.js"));
 	const results = cleanupAllLogsSync();
 	return jsonResponse({
 		success: true,
@@ -5196,7 +6453,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-8ZAguXef.js"));
+	const { getAllProjectSpecialistStatuses } = yield* Effect.promise(() => import("./specialists-D9-dMUtI.js"));
 	return jsonResponse(yield* Effect.promise(() => getAllProjectSpecialistStatuses()));
 })));
 const postSpecialistWakeRoute = HttpRouter.add("POST", "/api/specialists/:name/wake", httpHandler(Effect.gen(function* () {
@@ -5240,7 +6497,7 @@ const postSpecialistReportStatusRoute = HttpRouter.add("POST", "/api/specialists
 		"blocked",
 		"failed"
 	].includes(status)) {
-		const { getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-8ZAguXef.js"));
+		const { getTmuxSessionName } = yield* Effect.promise(() => import("./specialists-D9-dMUtI.js"));
 		saveAgentRuntimeState(getTmuxSessionName(name), {
 			state: "idle",
 			lastActivity: (/* @__PURE__ */ new Date()).toISOString()
@@ -5342,7 +6599,7 @@ init_config_yaml();
 init_projects();
 init_review_status();
 init_tmux();
-init_agents();
+init_agents$1();
 const getProjectSpecialistStatusRoute = HttpRouter.add("GET", "/api/specialists/:project/:issueId/:type/status", httpHandler(Effect.gen(function* () {
 	const params = yield* HttpRouter.params;
 	return jsonResponse({
@@ -5361,7 +6618,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-8ZAguXef.js"));
+	const { getTmuxSessionName, makeSpecialistRegistryKey, getRunMetadata } = yield* Effect.promise(() => import("./specialists-D9-dMUtI.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 +6645,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-BWZYcJ6P.js"));
+	const { listRunLogsSync } = yield* Effect.promise(() => import("./specialist-logs-DtSkPJZK.js"));
 	return jsonResponse(listRunLogsSync(project, type, {
 		limit,
 		offset
@@ -5399,7 +6656,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-BWZYcJ6P.js"));
+	const { getRunLogPath, isRunLogActive } = yield* Effect.promise(() => import("./specialist-logs-DtSkPJZK.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 +6715,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-BWZYcJ6P.js"));
+	const { getRunLogSync, parseLogMetadata } = yield* Effect.promise(() => import("./specialist-logs-DtSkPJZK.js"));
 	const content = getRunLogSync(project, type, runId);
 	if (!content) return jsonResponse({ error: "Run log not found" }, { status: 404 });
 	return jsonResponse({
@@ -5472,7 +6729,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-8ZAguXef.js"));
+	const { terminateSpecialist } = yield* Effect.promise(() => import("./specialists-D9-dMUtI.js"));
 	yield* Effect.promise(() => terminateSpecialist(project, type));
 	return jsonResponse({
 		success: true,
@@ -5484,7 +6741,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-8ZAguXef.js"));
+	const { pauseGracePeriod } = yield* Effect.promise(() => import("./specialists-D9-dMUtI.js"));
 	if (pauseGracePeriod(project, type)) return jsonResponse({
 		success: true,
 		message: "Grace period paused"
@@ -5496,7 +6753,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-8ZAguXef.js"));
+	const { resumeGracePeriod } = yield* Effect.promise(() => import("./specialists-D9-dMUtI.js"));
 	if (resumeGracePeriod(project, type)) return jsonResponse({
 		success: true,
 		message: "Grace period resumed"
@@ -5508,7 +6765,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-8ZAguXef.js"));
+	const { exitGracePeriod } = yield* Effect.promise(() => import("./specialists-D9-dMUtI.js"));
 	exitGracePeriod(project, type);
 	return jsonResponse({
 		success: true,
@@ -5520,7 +6777,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-8ZAguXef.js"));
+	const { getGracePeriodState } = yield* Effect.promise(() => import("./specialists-D9-dMUtI.js"));
 	const state = getGracePeriodState(project, type);
 	if (state) return jsonResponse(state);
 	else return jsonResponse({ error: "No active grace period" }, { status: 404 });
@@ -5529,7 +6786,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-BMq83C58.js"));
+	const { loadContextDigest } = yield* Effect.promise(() => import("./specialist-context-CspI4Eog.js"));
 	const digest = loadContextDigest(project, type);
 	if (digest) return jsonResponse({ digest });
 	else return jsonResponse({ error: "No context digest found" }, { status: 404 });
@@ -5538,7 +6795,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-BMq83C58.js"));
+	const { regenerateContextDigest } = yield* Effect.promise(() => import("./specialist-context-CspI4Eog.js"));
 	const digest = yield* Effect.promise(() => regenerateContextDigest(project, type));
 	if (digest) return jsonResponse({
 		digest,
@@ -5557,7 +6814,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-8ZAguXef.js"));
+	const { signalSpecialistCompletion } = yield* Effect.promise(() => import("./specialists-D9-dMUtI.js"));
 	signalSpecialistCompletion(project, type, {
 		status,
 		notes
@@ -5591,8 +6848,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-BWZYcJ6P.js"));
-	const { getSpecialistRetention } = yield* Effect.promise(() => import("./projects-KJ94e50I.js"));
+	const { cleanupOldLogsSync } = yield* Effect.promise(() => import("./specialist-logs-DtSkPJZK.js"));
+	const { getSpecialistRetention } = yield* Effect.promise(() => import("./projects-Dc9aoVoG.js"));
 	const retention = getSpecialistRetention(project);
 	const deleted = cleanupOldLogsSync(project, type, {
 		maxDays: retention.max_days,
@@ -5613,7 +6870,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-Rub0OpZc.js"));
+	const { killAllReviewerSessions } = yield* Effect.promise(() => import("./review-agent-CpSHLzed.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 +6884,7 @@ const postProjectReviewRestartRoute = HttpRouter.add("POST", "/api/specialists/:
 		}));
 		branch = stdout.trim() || "unknown";
 	} catch {}
-	const { spawnReviewRoleForIssue } = yield* Effect.promise(() => import("./review-agent-Rub0OpZc.js"));
+	const { spawnReviewRoleForIssue } = yield* Effect.promise(() => import("./review-agent-CpSHLzed.js"));
 	const prUrl = getReviewStatusSync(issueId)?.prUrl;
 	const result = yield* spawnReviewRoleForIssue({
 		issueId,
@@ -5776,6 +7033,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 _, 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, jsonStringResponse as gt, handleConversationPlanAction as h, jsonResponse as ht, validateSpecialistAutoCompleteMetadata as i, resolvePiSessionPath as it, shouldReportUnresolvedLiveSession as j, isInsideGitWorkTree as k, deliverConversationViaControlChannel as l, isTrustedOriginForHost as lt, handleConversationDeliveryMethod as m, getDefaultCwd as mt, _serverManagedMerges as n, resolveCodexRolloutPath as nt, saveAgentStateAndEmitEvent as o, waitForSessionRespawn as ot, handleConversationControlAck as p, httpHandler 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-BudKrjOu.js.map
+//# sourceMappingURL=specialists-Dax7tqXC.js.map