@overdeck/desktop 0.45.13 → 0.45.16

package/server/stuck-remediation-CxsyxwFO.js

@@ -0,0 +1,1513 @@
+import { Br as encodeClaudeProjectDir, Fn as init_projects, Jr as init_paths, dr as FsError, nr as init_issue_id, qn as resolveProjectFromIssueSync, qr as getOverdeckHome, tr as extractPrefixSync, vr as TmuxError, xr as init_errors } from "./config-yaml-cNOZcEww.js";
+import { D as listPaneValuesSync, P as sendKeys, R as sessionExistsSync, T as killSessionSync, i as capturePane, x as init_tmux } from "./tmux-C3g9VFcg.js";
+import { n as CLAUDE_CODE_BEHAVIOR } from "./src-B4TTzNSr.js";
+import { c as init_review_status, s as getReviewStatusSync } from "./review-status-Dc1l4dVz.js";
+import { An as getAgentDir, B as createOhmypiRuntimeSync, E as resumeAgent, Hn as markAgentTroubled, Jn as saveAgentStateSync, Pn as getAgentStateSync, Q as listRunningAgentsSync, U as spawnAgent, V as init_ohmypi, _t as init_config, cn as determineModel, en as init_pi_fifo, fr as getAgentRuntimeState, hr as saveAgentRuntimeState, ht as DEFAULT_CLOISTER_CONFIG, j as messageAgent, pr as getAgentRuntimeStateSync, t as init_agents, yt as loadCloisterConfigSync } from "./agents-B9GwfCyp.js";
+import { c as logDeaconEventSync, o as init_persistent_logger } from "./session-history-DanhhiCw.js";
+import { t as init_behavior } from "./behavior-BTpYbAv4.js";
+import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-dQxC15vH.js";
+import { a as init_launcher_generator } from "./state-home-CEvD_v5F.js";
+import { i as createCodexRuntimeSync, l as init_codex } from "./codex-BbqIRZjd.js";
+import { f as isFlywheelGloballyPaused, i as getFlywheelActiveRunId, s as init_control_settings } from "./control-settings-D4EFsRBd.js";
+import { o as queryReadyBeadsByIssueLabels, r as init_beads_query, s as resolveBeadsQueryRoot } from "./beads-query-Dl4FhT8J.js";
+import { a as init_jsonl_parser, i as getSessionFilesSync, r as getProjectDirsSync, s as parseClaudeSessionSync } from "./jsonl-parser-BUW5_sSK.js";
+import { t as recordRecoveryFailure } from "./recovery-trip-BT7nb9OV.js";
+import "node:path";
+import { Effect } from "effect";
+import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { join as join$1 } from "path";
+import { homedir } from "os";
+import "node:os";
+import "node:fs";
+import { readFile, readdir, stat as stat$1 } from "fs/promises";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { exec as exec$1 } from "child_process";
+import { promisify as promisify$1 } from "util";
+import "node:crypto";
+//#region ../../lib/agent-input-detection.ts
+init_paths();
+init_issue_id();
+init_projects();
+init_behavior();
+init_persistent_logger();
+init_review_status();
+init_codex();
+init_launcher_generator();
+init_beads_query();
+init_agents();
+init_tmux();
+init_errors();
+const ANSI_PATTERN = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+const MAX_PROMPT_CHARS = 2e3;
+const PANE_DETECTION_CACHE_TTL_MS = 1e4;
+const MAX_PANE_DETECTION_CACHE_ENTRIES = 256;
+const MAX_CONCURRENT_PANE_DETECTIONS = 4;
+const paneDetectionCache = /* @__PURE__ */ new Map();
+const paneDetectionInFlight = /* @__PURE__ */ new Map();
+const paneDetectionWaiters = [];
+let activePaneDetections = 0;
+function getPaneDetectionCacheKey(agentId, options) {
+	return `${agentId}:${options.isPlanning === true ? "planning" : "agent"}:${options.lines ?? 90}`;
+}
+function sweepPaneDetectionCache(now = Date.now()) {
+	for (const [key, entry] of paneDetectionCache) if (entry.expiresAt <= now) paneDetectionCache.delete(key);
+	while (paneDetectionCache.size > MAX_PANE_DETECTION_CACHE_ENTRIES) {
+		const oldestKey = paneDetectionCache.keys().next().value;
+		if (!oldestKey) break;
+		paneDetectionCache.delete(oldestKey);
+	}
+}
+async function withPaneDetectionSlot(fn) {
+	if (activePaneDetections >= MAX_CONCURRENT_PANE_DETECTIONS) await new Promise((resolve) => paneDetectionWaiters.push(resolve));
+	activePaneDetections += 1;
+	try {
+		return await fn();
+	} finally {
+		activePaneDetections = Math.max(0, activePaneDetections - 1);
+		paneDetectionWaiters.shift()?.();
+	}
+}
+function cleanPaneLine(line) {
+	return line.replace(ANSI_PATTERN, "").replace(/[\x00-\x1f\x7f]/g, "").replace(/\s+$/g, "");
+}
+function compactPrompt(prompt) {
+	const compact = prompt.split("\n").map((line) => line.trim()).filter(Boolean).join("\n").trim();
+	if (compact.length <= MAX_PROMPT_CHARS) return compact;
+	return `${compact.slice(0, MAX_PROMPT_CHARS - 1)}…`;
+}
+function normalizeAwaitingInputPrompt(prompt) {
+	return compactPrompt(prompt);
+}
+function snippetAround(lines, index, before = 8, after = 4) {
+	const start = Math.max(0, index - before);
+	const end = Math.min(lines.length, index + after + 1);
+	return compactPrompt(lines.slice(start, end).join("\n"));
+}
+function lastIndexMatching(lines, predicate) {
+	for (let i = lines.length - 1; i >= 0; i -= 1) if (predicate(lines[i], i)) return i;
+	return -1;
+}
+function isRecentPromptIndex(lines, index) {
+	if (index < 0) return false;
+	return lines.length - index <= 25;
+}
+function isCurrentPromptIndex(lines, index, maxTrailingLines = 0) {
+	if (index < 0) return false;
+	return lines.length - index <= maxTrailingLines + 1;
+}
+function findPermissionMenuEndIndex(lines, menuStartIndex) {
+	if (menuStartIndex < 0) return -1;
+	const end = Math.min(lines.length, menuStartIndex + 8);
+	for (let i = menuStartIndex; i < end; i += 1) if (/\s*3\.\s*No\b/i.test(lines[i])) return i;
+	return menuStartIndex;
+}
+function looksLikeClaudePermissionMenu(text) {
+	return /(?:^|\n)\s*❯?\s*1\.\s*Yes\b/i.test(text) && /(?:^|\n)\s*2\.\s*Yes,?\s*(?:and\s*)?(?:allow|don't ask|always)/i.test(text) && /(?:^|\n)\s*3\.\s*No\b/i.test(text);
+}
+function looksLikePermissionText(text) {
+	return /permission|allow(?:\s+this)?|tool use|bash command|mcp tool|do you want to proceed|do you want to continue/i.test(text);
+}
+function looksLikeGenericConfirmation(line) {
+	return /(?:\?|:)\s*(?:\[[Yy]\/[Nn]\]|\[[Nn]\/[Yy]\]|\([Yy]\/[Nn]\)|\([Nn]\/[Yy]\)|\[y\/N\]|\[Y\/n\])\s*$/i.test(line) || /\b(?:continue|proceed|confirm|approve|allow|run|execute|overwrite|delete|remove)\b.*(?:\[[Yy]\/[Nn]\]|\([Yy]\/[Nn]\)|\[y\/N\]|\[Y\/n\])/i.test(line);
+}
+function looksLikePiPermission(text) {
+	return /(?:permission|approval|approve|allow).{0,80}(?:required|request|prompt|action|command)/i.test(text) || /(?:allow|approve|run|execute)\s+(?:this\s+)?(?:command|tool|action)/i.test(text);
+}
+function looksLikePlanningDone(text) {
+	return /planning finalized\s*[—-]\s*click done/i.test(text) || /click Done in the dashboard/i.test(text) || /planning (?:is )?complete.{0,120}(?:click|press|select) Done/i.test(text);
+}
+/**
+* PAN-1520 (covers #1197) — Claude Code session-resume dialog. Fires when an
+* agent is resumed via `claude --resume <session>` and a prior session is
+* still considered active or interrupted. The dialog blocks tool execution
+* until acknowledged. Conservative patterns — we want false-negatives over
+* false-positives, so we only match strings that clearly indicate a resume
+* choice point.
+*/
+function looksLikeSessionResumeDialog(text) {
+	return /this session (?:is|was)\s+(?:still\s+)?(?:active|interrupted|running)/i.test(text) || /resume (?:the\s+)?previous session/i.test(text) || /(?:continue|resume) (?:this\s+)?session\??.{0,40}(?:\[[Yy]\/[Nn]\]|\([Yy]\/[Nn]\)|press\s+enter)/i.test(text) || /press enter to (?:continue|resume)/i.test(text);
+}
+/**
+* PAN-1834 — Codex/gpt-5.5 rate-limit / model-switch modal. The harness shows a
+* choice between keeping the current model and switching to an alternative.
+* To avoid matching prose that merely mentions rate limits, require BOTH option
+* lines to be present near the bottom of the pane.
+*/
+function looksLikeRateLimitModelSwitchModal(text) {
+	return /keep current model/i.test(text) && /switch to\s+\S+/i.test(text);
+}
+/**
+* PAN-1690 — Codex TUI approval prompt header. Codex asks for approval with a
+* distinctive "Would you like to …?" prompt box (command run, edits, network/
+* host grants) followed by a numbered Yes/…/No menu. Unlike Claude's menu,
+* Codex renders option descriptions and a footer hint *below* "3. No", so the
+* trailing-line heuristics the Claude path relies on never fire — we key on the
+* header instead. Verb list pulled from the codex binary; see PAN-1690.
+*/
+function looksLikeCodexApprovalHeader(line) {
+	return /Would you like to (?:run the following command|grant these permissions?|make the following edits|allow|apply)\b/i.test(line);
+}
+function detectAwaitingInputFromPaneSync(pane, options = {}) {
+	const lines = pane.split("\n").map(cleanPaneLine).filter((line) => line.trim().length > 0);
+	if (lines.length === 0) return null;
+	const recentText = lines.slice(-45).join("\n");
+	if (looksLikeClaudePermissionMenu(recentText) && looksLikePermissionText(recentText)) {
+		const menuIndex = lastIndexMatching(lines, (line) => /❯?\s*1\.\s*Yes\b/i.test(line));
+		const menuEndIndex = findPermissionMenuEndIndex(lines, menuIndex);
+		if (isRecentPromptIndex(lines, menuIndex) && isCurrentPromptIndex(lines, menuEndIndex)) return {
+			reason: "tool_permission",
+			prompt: snippetAround(lines, menuIndex, 10, 3)
+		};
+	}
+	const codexHeaderIndex = lastIndexMatching(lines, looksLikeCodexApprovalHeader);
+	if (codexHeaderIndex >= 0 && isRecentPromptIndex(lines, codexHeaderIndex)) {
+		const optionIndex = lastIndexMatching(lines, (line) => /^[^\w]*1\.\s*Yes\b/i.test(line));
+		if (optionIndex > codexHeaderIndex && lines.length - optionIndex <= 12) return {
+			reason: "tool_permission",
+			prompt: snippetAround(lines, codexHeaderIndex, 1, 14)
+		};
+	}
+	const piIndex = lastIndexMatching(lines, (line) => looksLikePiPermission(line) || looksLikeGenericConfirmation(line));
+	if (isRecentPromptIndex(lines, piIndex) && isCurrentPromptIndex(lines, piIndex)) {
+		const snippet = snippetAround(lines, piIndex, 6, 2);
+		return {
+			reason: looksLikeGenericConfirmation(lines[piIndex]) ? "confirmation" : "tool_permission",
+			prompt: snippet
+		};
+	}
+	if (options.isPlanning && looksLikePlanningDone(recentText)) {
+		const doneIndex = lastIndexMatching(lines, (line) => /done|planning/i.test(line));
+		return {
+			reason: "planning_done",
+			prompt: snippetAround(lines, doneIndex >= 0 ? doneIndex : lines.length - 1, 8, 2)
+		};
+	}
+	if (looksLikeSessionResumeDialog(recentText)) {
+		const resumeIndex = lastIndexMatching(lines, (line) => looksLikeSessionResumeDialog(line));
+		return {
+			reason: "session_resume",
+			prompt: snippetAround(lines, resumeIndex >= 0 ? resumeIndex : lines.length - 1, 8, 2)
+		};
+	}
+	if (looksLikeRateLimitModelSwitchModal(recentText)) {
+		const rateLimitIndex = lastIndexMatching(lines, (line) => /keep current model|switch to\s+\S+/i.test(line));
+		if (isRecentPromptIndex(lines, rateLimitIndex)) return {
+			reason: "rate_limit",
+			prompt: snippetAround(lines, rateLimitIndex >= 0 ? rateLimitIndex : lines.length - 1, 8, 2)
+		};
+	}
+	return null;
+}
+async function detectAwaitingInputForAgentPromise(agentId, options = {}) {
+	const cacheEnabled = options.cache !== false;
+	const cacheKey = getPaneDetectionCacheKey(agentId, options);
+	const now = Date.now();
+	if (cacheEnabled) {
+		sweepPaneDetectionCache(now);
+		const cached = paneDetectionCache.get(cacheKey);
+		if (cached && cached.expiresAt > now) {
+			paneDetectionCache.delete(cacheKey);
+			paneDetectionCache.set(cacheKey, cached);
+			return cached.detection;
+		}
+		const inFlight = paneDetectionInFlight.get(cacheKey);
+		if (inFlight) return inFlight;
+	}
+	const detectionPromise = withPaneDetectionSlot(async () => {
+		const detection = detectAwaitingInputFromPaneSync(await Effect.runPromise(capturePane(agentId, options.lines ?? 90)), options);
+		if (cacheEnabled) {
+			paneDetectionCache.set(cacheKey, {
+				expiresAt: Date.now() + PANE_DETECTION_CACHE_TTL_MS,
+				detection
+			});
+			sweepPaneDetectionCache();
+		}
+		return detection;
+	});
+	if (!cacheEnabled) return detectionPromise;
+	paneDetectionInFlight.set(cacheKey, detectionPromise);
+	try {
+		return await detectionPromise;
+	} finally {
+		paneDetectionInFlight.delete(cacheKey);
+	}
+}
+/**
+* Effect-native variant of detectAwaitingInputForAgent. Fails with TmuxError if
+* the pane capture fails outside the in-cache fast path.
+*/
+const detectAwaitingInputForAgent = (agentId, options = {}) => Effect.tryPromise({
+	try: () => detectAwaitingInputForAgentPromise(agentId, options),
+	catch: (cause) => new TmuxError({
+		command: "capture-pane",
+		message: `failed to detect awaiting input for ${agentId}`,
+		cause
+	})
+});
+/**
+* PAN-1690 — parse a Codex approval prompt (as captured by the codex-aware
+* branch of detectAwaitingInputFromPaneSync) into its header, detail, and
+* numbered options, so the dashboard can render the menu and answer it without
+* the terminal. Returns null when the text doesn't contain a usable menu
+* (fewer than two numbered options). Option lines tolerate a leading selection
+* cursor (❯ › > etc.); the footer hint and other non-numbered lines are
+* naturally excluded.
+*/
+function parseCodexApprovalPrompt(text) {
+	const lines = text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+	if (lines.length === 0) return null;
+	const headerIndex = lines.findIndex((l) => looksLikeCodexApprovalHeader(l));
+	if (headerIndex < 0) return null;
+	const optionRe = /^[^\w]*(\d+)\.\s*(.+?)\s*$/;
+	const options = [];
+	const detailLines = [];
+	let firstOptionSeen = false;
+	for (let i = headerIndex + 1; i < lines.length; i += 1) {
+		const m = optionRe.exec(lines[i]);
+		if (m) {
+			firstOptionSeen = true;
+			options.push({
+				number: Number(m[1]),
+				label: m[2].trim()
+			});
+		} else if (!firstOptionSeen) detailLines.push(lines[i]);
+	}
+	if (options.length < 2) return null;
+	return {
+		header: lines[headerIndex],
+		detail: detailLines.join("\n"),
+		options
+	};
+}
+//#endregion
+//#region ../../lib/agent-enrichment.ts
+/**
+* Agent enrichment utilities (PAN-440 / PAN-1048)
+*
+* Shared functions for computing enrichment fields:
+*   role, hasPendingQuestion, pendingQuestionCount, resolution, resolutionCount
+*
+* Used by both the legacy REST /api/agents endpoint and the new
+* AgentEnrichmentService background poller.
+*
+* PAN-1048: replaced the legacy `agentPhase` string with the role primitive —
+* the dashboard derives label/status from `role` + lifecycle state.
+*/
+init_errors();
+init_tracker_config();
+const execAsync$1 = promisify$1(exec$1);
+function appendPaneDetectionKind(detection, kinds) {
+	if (detection?.reason === "session_resume" && !kinds.includes("sessionResume")) kinds.push("sessionResume");
+	if (detection?.reason === "rate_limit" && !kinds.includes("rateLimit")) kinds.push("rateLimit");
+}
+function isOwnActiveSpecialist(role) {
+	return role === "review" || role === "test" || role === "ship";
+}
+function getClaudeProjectDir(workspacePath) {
+	return join$1(homedir(), ".claude", "projects", encodeClaudeProjectDir(workspacePath));
+}
+async function getActiveSessionPath(projectDir) {
+	if (!existsSync(projectDir)) return null;
+	try {
+		const jsonlFiles = (await readdir(projectDir)).filter((f) => f.endsWith(".jsonl"));
+		if (jsonlFiles.length === 0) return null;
+		const withMtime = (await Promise.all(jsonlFiles.map(async (f) => {
+			try {
+				return {
+					name: f,
+					path: join$1(projectDir, f),
+					mtime: (await stat$1(join$1(projectDir, f))).mtime.getTime()
+				};
+			} catch {
+				return null;
+			}
+		}))).filter((x) => x !== null);
+		if (withMtime.length === 0) return null;
+		withMtime.sort((a, b) => b.mtime - a.mtime);
+		return withMtime[0].path;
+	} catch {
+		return null;
+	}
+}
+function getProjectPathByPrefix(issuePrefix) {
+	const resolved = resolveProjectFromIssueSync(`${issuePrefix}-1`);
+	if (resolved) return resolved.projectPath;
+	const config = getGitHubConfig();
+	if (config) {
+		for (const { owner, repo, prefix } of config.repos) if ((prefix || repo.toUpperCase().replace(/-CLI$/, "").replace(/-/g, "")).toUpperCase() === issuePrefix.toUpperCase()) {
+			const possiblePaths = [
+				join$1(homedir(), "Projects", repo),
+				join$1(homedir(), "Projects", repo.replace(/-cli$/, "")),
+				join$1(homedir(), "Projects", owner, repo)
+			];
+			for (const path of possiblePaths) if (existsSync(path)) return path;
+		}
+	}
+	return join$1(homedir(), "Projects");
+}
+async function getAgentWorkspacePromise(agentId) {
+	const workspace = getAgentStateSync(agentId)?.workspace;
+	if (workspace) return workspace;
+	try {
+		const { stdout: paneCwd } = await execAsync$1(`tmux display-message -t ${agentId} -p '#{pane_current_path}' 2>/dev/null`, { encoding: "utf-8" });
+		const trimmed = paneCwd.trim();
+		if (trimmed && existsSync(trimmed)) return trimmed;
+	} catch {}
+	const issueId = agentId.replace(/^(agent-|planning-)/, "").toUpperCase();
+	const prefix = extractPrefixSync(issueId);
+	if (!prefix) return null;
+	try {
+		const projectPath = getProjectPathByPrefix(prefix);
+		const workspacePath = join$1(projectPath, "workspaces", `feature-${issueId.toLowerCase()}`);
+		if (existsSync(workspacePath)) return workspacePath;
+		return projectPath;
+	} catch {
+		return null;
+	}
+}
+async function getAgentJsonlPathPromise(agentId) {
+	const workspace = await Effect.runPromise(getAgentWorkspace(agentId));
+	if (!workspace) return null;
+	return await getActiveSessionPath(getClaudeProjectDir(workspace));
+}
+/**
+* Count outstanding AskUserQuestions across ALL of an agent's workspace JSONL
+* session files — not just the newest one. Claude Code rotates session files,
+* so an open AskUserQuestion can sit in a file that is not the most-recently-
+* modified. The complete-planning guard MUST be robust to that: scanning only
+* the active file let TIN-1 complete planning while the operator's question was
+* still open. Returns 0 only when no file has an unanswered AUQ.
+*/
+async function countPendingAskUserQuestionsForAgentPromise(agentId) {
+	const workspace = await Effect.runPromise(getAgentWorkspace(agentId));
+	if (!workspace) return 0;
+	const projectDir = getClaudeProjectDir(workspace);
+	if (!existsSync(projectDir)) return 0;
+	let files;
+	try {
+		files = (await readdir(projectDir)).filter((f) => f.endsWith(".jsonl"));
+	} catch {
+		return 0;
+	}
+	let total = 0;
+	for (const f of files) try {
+		const scan = await scanPendingInputsPromise(join$1(projectDir, f));
+		total += scan.askUserQuestions.length;
+	} catch {}
+	return total;
+}
+/** Effect-native: count pending AskUserQuestions across all of an agent's JSONL files. */
+const countPendingAskUserQuestionsForAgent = (agentId) => Effect.promise(() => countPendingAskUserQuestionsForAgentPromise(agentId));
+/**
+* Read the last `maxBytes` from a file. Efficient for large JSONL files where
+* only recent entries (at the end) are relevant.
+*/
+async function readFileTail(filePath, maxBytes) {
+	try {
+		const fileStat = await stat$1(filePath);
+		const start = Math.max(0, fileStat.size - maxBytes);
+		if (start === 0) return readFile(filePath, "utf-8");
+		const { createReadStream } = await import("node:fs");
+		return new Promise((resolve, reject) => {
+			const stream = createReadStream(filePath, {
+				start,
+				encoding: "utf-8"
+			});
+			let data = "";
+			stream.on("data", (chunk) => {
+				data += chunk;
+			});
+			stream.on("end", () => resolve(data));
+			stream.on("error", reject);
+		});
+	} catch {
+		return "";
+	}
+}
+const ASK_USER_QUESTION_HOOK_DENY_MARKER = "PAN-1520";
+const ASK_USER_QUESTION_HOOK_DENY_PHRASE = "surfaced to the operator in the Overdeck dashboard";
+function isHookDenyText(text) {
+	return text.includes(ASK_USER_QUESTION_HOOK_DENY_MARKER) || text.includes(ASK_USER_QUESTION_HOOK_DENY_PHRASE);
+}
+function isAskUserQuestionHookDenyToolResult(item) {
+	if (item.is_error !== true) return false;
+	const content = item.content;
+	if (typeof content === "string") return isHookDenyText(content);
+	if (Array.isArray(content)) return content.some((part) => {
+		if (typeof part === "string") return isHookDenyText(part);
+		if (part && typeof part === "object" && "text" in part) {
+			const text = part.text;
+			return typeof text === "string" && isHookDenyText(text);
+		}
+		return false;
+	});
+	return false;
+}
+async function getPendingQuestionsPromise(jsonlPath) {
+	return (await scanPendingInputsPromise(jsonlPath)).askUserQuestions;
+}
+/**
+* PAN-1520 — does this user-message entry carry operator text (i.e. an answer)
+* rather than just being a wrapper for a tool_result? When the hook denies an
+* AskUserQuestion the agent restates the question as plain text; the operator's
+* next user message — whether typed in the terminal, sent from the conversation
+* composer, or delivered by the answer-question route — is the actual answer.
+* The presence of that user-text turn after the deny is what resolves the AUQ.
+*/
+function isUserTextEntry(entry) {
+	if (!entry || typeof entry !== "object") return false;
+	const e = entry;
+	if (e.type !== "user") return false;
+	const content = e.message?.content;
+	if (typeof content === "string") return content.trim().length > 0;
+	if (Array.isArray(content)) return content.some((item) => {
+		if (!item || typeof item !== "object") return false;
+		return item.type !== "tool_result";
+	});
+	return false;
+}
+async function scanPendingInputsPromise(jsonlPath) {
+	if (!existsSync(jsonlPath)) return {
+		askUserQuestions: [],
+		enterPlanModeOpen: false,
+		exitPlanModePending: false
+	};
+	try {
+		const lines = (await readFileTail(jsonlPath, 512e3)).split("\n").filter((line) => line.trim());
+		const askToolCalls = /* @__PURE__ */ new Map();
+		const askAnswered = /* @__PURE__ */ new Set();
+		const askDeniedAwaitingUser = /* @__PURE__ */ new Set();
+		const exitPlanModeIds = /* @__PURE__ */ new Set();
+		const exitPlanModeCalls = /* @__PURE__ */ new Map();
+		const exitPlanModeAnswered = /* @__PURE__ */ new Set();
+		const enterPlanModeIds = /* @__PURE__ */ new Set();
+		const exitPlanModeFiredAfterEnter = /* @__PURE__ */ new Set();
+		for (const line of lines) try {
+			const entry = JSON.parse(line);
+			if (isUserTextEntry(entry)) {
+				for (const id of askDeniedAwaitingUser) askAnswered.add(id);
+				askDeniedAwaitingUser.clear();
+			}
+			const messageContent = entry.message?.content;
+			if (!Array.isArray(messageContent)) continue;
+			for (const item of messageContent) {
+				if (item.type === "tool_use") {
+					if (item.name === "AskUserQuestion" && typeof item.id === "string") askToolCalls.set(item.id, {
+						toolId: item.id,
+						timestamp: entry.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+						questions: item.input?.questions || []
+					});
+					else if (item.name === "ExitPlanMode" && typeof item.id === "string") {
+						exitPlanModeIds.add(item.id);
+						exitPlanModeFiredAfterEnter.add(item.id);
+						if (typeof item.input?.plan === "string" && item.input.plan.trim()) exitPlanModeCalls.set(item.id, {
+							plan: item.input.plan,
+							timestamp: entry.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+						});
+					} else if (item.name === "EnterPlanMode" && typeof item.id === "string") enterPlanModeIds.add(item.id);
+				}
+				if (item.type === "tool_result" && typeof item.tool_use_id === "string") {
+					if (askToolCalls.has(item.tool_use_id)) if (isAskUserQuestionHookDenyToolResult(item)) askDeniedAwaitingUser.add(item.tool_use_id);
+					else {
+						askAnswered.add(item.tool_use_id);
+						askDeniedAwaitingUser.delete(item.tool_use_id);
+					}
+					if (exitPlanModeIds.has(item.tool_use_id)) exitPlanModeAnswered.add(item.tool_use_id);
+				}
+			}
+		} catch {}
+		const askUserQuestions = Array.from(askToolCalls.entries()).filter(([id]) => !askAnswered.has(id)).map(([, question]) => question);
+		const pendingExitPlanId = Array.from(exitPlanModeIds).find((id) => !exitPlanModeAnswered.has(id));
+		const exitPlanModePending = pendingExitPlanId !== void 0;
+		const pendingCall = pendingExitPlanId ? exitPlanModeCalls.get(pendingExitPlanId) : void 0;
+		const pendingProposedPlan = pendingExitPlanId && pendingCall ? {
+			toolUseId: pendingExitPlanId,
+			askedAt: pendingCall.timestamp,
+			plan: pendingCall.plan
+		} : void 0;
+		return {
+			askUserQuestions,
+			enterPlanModeOpen: enterPlanModeIds.size > 0 && exitPlanModeFiredAfterEnter.size === 0,
+			exitPlanModePending,
+			...pendingProposedPlan ? { pendingProposedPlan } : {}
+		};
+	} catch {
+		return {
+			askUserQuestions: [],
+			enterPlanModeOpen: false,
+			exitPlanModePending: false
+		};
+	}
+}
+async function getAgentPendingQuestionsPromise(agentId) {
+	const jsonlPath = await Effect.runPromise(getAgentJsonlPath(agentId));
+	if (!jsonlPath) return [];
+	return [...await Effect.runPromise(getPendingQuestions(jsonlPath))];
+}
+async function getAgentJsonlMtimePromise(agentId) {
+	const jsonlPath = await Effect.runPromise(getAgentJsonlPath(agentId));
+	if (!jsonlPath || !existsSync(jsonlPath)) return null;
+	try {
+		return (await stat$1(jsonlPath)).mtime.getTime();
+	} catch {
+		return null;
+	}
+}
+async function computeAgentEnrichmentPromise(agentId, startedAt, hasActiveSpecialist, skipJsonlScan) {
+	const isPlanning = agentId.startsWith("planning-");
+	const stateRole = getAgentStateSync(agentId)?.role;
+	const role = stateRole === "plan" || stateRole === "work" || stateRole === "review" || stateRole === "test" || stateRole === "ship" || stateRole === "flywheel" ? stateRole : isPlanning ? "plan" : void 0;
+	const runtimeState = await Effect.runPromise(getAgentRuntimeState(agentId));
+	let pendingQuestions = [];
+	let enterPlanModeOpen = false;
+	let exitPlanModePending = false;
+	let scannedProposedPlan;
+	if (!skipJsonlScan) {
+		const jsonlPath = await Effect.runPromise(getAgentJsonlPath(agentId));
+		if (jsonlPath) {
+			const scan = await scanPendingInputsPromise(jsonlPath);
+			pendingQuestions = [...scan.askUserQuestions];
+			enterPlanModeOpen = scan.enterPlanModeOpen;
+			exitPlanModePending = scan.exitPlanModePending;
+			scannedProposedPlan = scan.pendingProposedPlan;
+		}
+		if (pendingQuestions.length > 0 && startedAt) {
+			const agentStartTime = new Date(startedAt).getTime();
+			pendingQuestions = pendingQuestions.filter((q) => {
+				const qTime = new Date(q.timestamp).getTime();
+				return !isNaN(qTime) && qTime >= agentStartTime;
+			});
+		}
+	}
+	const questionDetection = pendingQuestions.length > 0 ? {
+		reason: "user_question",
+		prompt: normalizeAwaitingInputPrompt(pendingQuestions[0]?.questions.map((q) => q.question).filter(Boolean).join("\n") || "Agent is waiting for a user answer")
+	} : null;
+	const runtimeDetection = runtimeState?.state === "waiting-on-human" ? {
+		reason: runtimeState.waitingReason || "other",
+		prompt: normalizeAwaitingInputPrompt(runtimeState.waitingNotification || "Agent is waiting for human input")
+	} : null;
+	const paneDetection = !questionDetection && !runtimeDetection ? await Effect.runPromise(detectAwaitingInputForAgent(agentId, { isPlanning })) : null;
+	const fallbackDetection = runtimeState?.resolution === "needs_input" ? {
+		reason: "other",
+		prompt: normalizeAwaitingInputPrompt("Agent stopped because it needs human input or hit a blocker")
+	} : null;
+	const detection = questionDetection ?? runtimeDetection ?? paneDetection ?? fallbackDetection;
+	const shouldSuppressPendingInput = hasActiveSpecialist === true && !isOwnActiveSpecialist(role);
+	const hasPendingQuestion = !shouldSuppressPendingInput && detection !== null;
+	const pendingInputKinds = [];
+	let pendingAskUserQuestion;
+	if (!shouldSuppressPendingInput) {
+		if (pendingQuestions.length > 0) {
+			pendingInputKinds.push("askUserQuestion");
+			const first = pendingQuestions[0];
+			pendingAskUserQuestion = {
+				toolUseId: first.toolId,
+				askedAt: first.timestamp,
+				questions: first.questions.map((q) => ({
+					question: q.question,
+					header: q.header,
+					multiSelect: q.multiSelect,
+					options: q.options.map((o) => ({
+						label: o.label,
+						description: o.description
+					}))
+				}))
+			};
+		}
+		if (exitPlanModePending) pendingInputKinds.push("exitPlanMode");
+		if (enterPlanModeOpen && !exitPlanModePending) pendingInputKinds.push("enterPlanMode");
+		appendPaneDetectionKind(detection, pendingInputKinds);
+	}
+	const pendingProposedPlan = !shouldSuppressPendingInput && exitPlanModePending ? scannedProposedPlan : void 0;
+	return {
+		role,
+		hasPendingQuestion,
+		pendingQuestionCount: pendingQuestions.length,
+		pendingQuestionPrompt: detection?.prompt,
+		pendingQuestionReason: detection?.reason,
+		pendingInputCount: pendingInputKinds.length,
+		pendingInputKinds,
+		pendingAskUserQuestion,
+		pendingProposedPlan,
+		resolution: runtimeState?.resolution || "working",
+		resolutionCount: runtimeState?.resolutionCount || 0
+	};
+}
+/**
+* Effect-native variant of computeAgentEnrichment. Fails with FsError if any
+* underlying filesystem read fails outside the swallowed branches.
+*/
+const computeAgentEnrichment = (agentId, startedAt, hasActiveSpecialist, skipJsonlScan) => Effect.tryPromise({
+	try: () => computeAgentEnrichmentPromise(agentId, startedAt, hasActiveSpecialist, skipJsonlScan),
+	catch: (cause) => new FsError({
+		path: getAgentDir(agentId),
+		operation: "computeAgentEnrichment",
+		cause
+	})
+});
+/** Effect-native: resolve the workspace path for an agent (null on failure). */
+const getAgentWorkspace = (agentId) => Effect.promise(() => getAgentWorkspacePromise(agentId));
+/** Effect-native: resolve the active JSONL session path for an agent (null on failure). */
+const getAgentJsonlPath = (agentId) => Effect.promise(() => getAgentJsonlPathPromise(agentId));
+/** Effect-native: get the mtime of the agent's active JSONL session file. */
+const getAgentJsonlMtime = (agentId) => Effect.promise(() => getAgentJsonlMtimePromise(agentId));
+/** Effect-native: parse pending questions from a JSONL file. */
+const getPendingQuestions = (jsonlPath) => Effect.promise(() => getPendingQuestionsPromise(jsonlPath));
+/** Effect-native: get pending questions for an agent by id. */
+const getAgentPendingQuestions = (agentId) => Effect.promise(() => getAgentPendingQuestionsPromise(agentId));
+//#endregion
+//#region ../../lib/runtimes/claude-code.ts
+init_config();
+/**
+* Claude Code Runtime Implementation
+*
+* Implements AgentRuntime for Claude Code CLI.
+*
+* Session storage: ~/.claude/projects/<workspace-hash>/<session-id>.jsonl
+* Session index: ~/.claude/projects/<workspace-hash>/sessions-index.json
+*/
+init_agents();
+init_tmux();
+init_jsonl_parser();
+init_errors();
+const CLAUDE_PROJECTS_DIR = join$1(homedir(), ".claude", "projects");
+/**
+* Claude Code Runtime implementation
+*/
+var ClaudeCodeRuntimeSync = class {
+	name = "claude-code";
+	getHarnessBehavior() {
+		return CLAUDE_CODE_BEHAVIOR;
+	}
+	/**
+	* Get the project directory for a workspace
+	*
+	* Claude Code hashes the workspace path to create project directories.
+	* We need to find the project directory that contains sessions for this workspace.
+	*/
+	getProjectDirForWorkspace(workspace) {
+		if (!existsSync(CLAUDE_PROJECTS_DIR)) return null;
+		const projectDirs = getProjectDirsSync();
+		for (const projectDir of projectDirs) {
+			const indexPath = join$1(projectDir, "sessions-index.json");
+			if (existsSync(indexPath)) try {
+				if (readFileSync(indexPath, "utf-8").includes(workspace)) return projectDir;
+			} catch {}
+		}
+		return null;
+	}
+	/**
+	* Get the active session ID for an agent from the sessions index
+	*/
+	getActiveSessionId(projectDir) {
+		const indexPath = join$1(projectDir, "sessions-index.json");
+		if (!existsSync(indexPath)) return null;
+		try {
+			const indexContent = readFileSync(indexPath, "utf-8");
+			const index = JSON.parse(indexContent);
+			if (index.sessions && Array.isArray(index.sessions)) {
+				const sessions = index.sessions;
+				if (sessions.length === 0) return null;
+				return sessions.sort((a, b) => {
+					return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+				})[0].sessionId;
+			}
+		} catch {}
+		return null;
+	}
+	/**
+	* Get the most recent JSONL file for a project
+	*/
+	getMostRecentJSONL(projectDir) {
+		const files = getSessionFilesSync(projectDir);
+		return files.length > 0 ? files[0] : null;
+	}
+	/**
+	* Get the session path for an agent
+	*/
+	getSessionPath(agentId) {
+		const state = getAgentStateSync(agentId);
+		if (!state) return null;
+		const projectDir = this.getProjectDirForWorkspace(state.workspace);
+		if (!projectDir) return null;
+		const sessionId = this.getActiveSessionId(projectDir);
+		if (sessionId) {
+			const sessionPath = join$1(projectDir, `${sessionId}.jsonl`);
+			if (existsSync(sessionPath)) return sessionPath;
+		}
+		return this.getMostRecentJSONL(projectDir);
+	}
+	/**
+	* Get last activity timestamp for an agent
+	*
+	* Uses passive detection via JSONL file modification time.
+	*/
+	getLastActivity(agentId) {
+		const sessionPath = this.getSessionPath(agentId);
+		if (!sessionPath || !existsSync(sessionPath)) return null;
+		try {
+			return statSync(sessionPath).mtime;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Read active heartbeat file if it exists
+	*/
+	getActiveHeartbeat(agentId) {
+		const heartbeatPath = join$1(homedir(), ".overdeck", "heartbeats", `${agentId}.json`);
+		if (!existsSync(heartbeatPath)) return null;
+		try {
+			const content = readFileSync(heartbeatPath, "utf-8");
+			const data = JSON.parse(content);
+			const timestamp = new Date(data.timestamp);
+			if ((/* @__PURE__ */ new Date()).getTime() - timestamp.getTime() > 300 * 1e3) return null;
+			return {
+				timestamp,
+				agentId: data.agent_id || agentId,
+				source: "active-heartbeat",
+				confidence: "high",
+				toolName: data.tool_name,
+				lastAction: data.last_action,
+				currentTask: data.current_task,
+				gitBranch: data.git_branch,
+				workspace: data.workspace,
+				pid: data.pid,
+				sessionId: data.session_id
+			};
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Get passive heartbeat from file timestamps
+	*/
+	getPassiveHeartbeat(agentId) {
+		const lastActivity = this.getLastActivity(agentId);
+		if (!lastActivity) return null;
+		return {
+			timestamp: lastActivity,
+			agentId,
+			source: "jsonl",
+			confidence: "medium"
+		};
+	}
+	/**
+	* Get heartbeat for an agent
+	*
+	* Tries active heartbeat first (if hooks configured), falls back to passive.
+	*/
+	getHeartbeat(agentId) {
+		const activeHeartbeat = this.getActiveHeartbeat(agentId);
+		if (activeHeartbeat) return activeHeartbeat;
+		return this.getPassiveHeartbeat(agentId);
+	}
+	/**
+	* Get token usage for an agent's current session
+	*/
+	getTokenUsage(agentId) {
+		const sessionPath = this.getSessionPath(agentId);
+		if (!sessionPath) return null;
+		const sessionUsage = parseClaudeSessionSync(sessionPath);
+		if (!sessionUsage) return null;
+		return sessionUsage.usage;
+	}
+	/**
+	* Get cost breakdown for an agent's current session
+	*/
+	getSessionCost(agentId) {
+		const sessionPath = this.getSessionPath(agentId);
+		if (!sessionPath) return null;
+		const sessionUsage = parseClaudeSessionSync(sessionPath);
+		if (!sessionUsage) return null;
+		const inputPrice = 3 / 1e6;
+		const outputPrice = 15 / 1e6;
+		const cacheReadPrice = .3 / 1e6;
+		const cacheWritePrice = 3.75 / 1e6;
+		const usage = sessionUsage.usage;
+		const inputCost = usage.inputTokens * inputPrice;
+		const outputCost = usage.outputTokens * outputPrice;
+		const cacheReadCost = (usage.cacheReadTokens || 0) * cacheReadPrice;
+		const cacheWriteCost = (usage.cacheWriteTokens || 0) * cacheWritePrice;
+		return {
+			inputCost,
+			outputCost,
+			cacheReadCost,
+			cacheWriteCost,
+			totalCost: inputCost + outputCost + cacheReadCost + cacheWriteCost,
+			currency: "USD"
+		};
+	}
+	/**
+	* Send a message to a running agent
+	*/
+	async sendMessage(agentId, message) {
+		if (!sessionExistsSync(agentId)) throw new Error(`Agent ${agentId} is not running`);
+		await Effect.runPromise(sendKeys(agentId, message));
+		const mailDir = join$1(getAgentDir(agentId), "mail");
+		mkdirSync(mailDir, { recursive: true });
+		writeFileSync(join$1(mailDir, `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.md`), `# Message\n\n${message}\n`);
+	}
+	/**
+	* Kill an agent
+	*/
+	killAgent(agentId) {
+		if (!sessionExistsSync(agentId)) throw new Error(`Agent ${agentId} is not running`);
+		killSessionSync(agentId);
+		saveAgentRuntimeState(agentId, {
+			state: "idle",
+			lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		const state = getAgentStateSync(agentId);
+		if (state) {
+			state.status = "stopped";
+			saveAgentStateSync(state);
+		}
+	}
+	/**
+	* Spawn a new agent
+	*/
+	async spawnAgent(config) {
+		const state = await spawnAgent({
+			issueId: config.agentId.replace(/^agent-/, ""),
+			workspace: config.workspace,
+			harness: "claude-code",
+			model: determineModel({
+				model: config.model,
+				role: "work",
+				spawnKey: `work:${config.agentId.replace(/^agent-/, "")}`
+			}),
+			role: "work",
+			prompt: config.prompt
+		});
+		const projectDir = this.getProjectDirForWorkspace(config.workspace);
+		const sessionId = projectDir ? this.getActiveSessionId(projectDir) : void 0;
+		return {
+			id: state.id,
+			sessionId: sessionId || "unknown",
+			runtime: "claude-code",
+			model: state.model,
+			workspace: state.workspace,
+			startedAt: new Date(state.startedAt)
+		};
+	}
+	/**
+	* List all sessions for this runtime
+	*/
+	listSessions(workspace) {
+		const sessions = [];
+		if (workspace) {
+			const projectDir = this.getProjectDirForWorkspace(workspace);
+			if (projectDir) {
+				const files = getSessionFilesSync(projectDir);
+				for (const file of files) {
+					const session = this.parseSessionFile(file, workspace);
+					if (session) sessions.push(session);
+				}
+			}
+		} else {
+			const projectDirs = getProjectDirsSync();
+			for (const projectDir of projectDirs) {
+				const files = getSessionFilesSync(projectDir);
+				for (const file of files) {
+					const session = this.parseSessionFile(file);
+					if (session) sessions.push(session);
+				}
+			}
+		}
+		return sessions;
+	}
+	/**
+	* Parse a session file into a Session object
+	*/
+	parseSessionFile(file, workspace) {
+		const sessionUsage = parseClaudeSessionSync(file);
+		if (!sessionUsage) return null;
+		const stat = statSync(file);
+		return {
+			id: sessionUsage.sessionId,
+			agentId: "unknown",
+			workspace: workspace || "unknown",
+			model: sessionUsage.model,
+			startedAt: new Date(sessionUsage.startTime),
+			lastActivity: stat.mtime,
+			tokenUsage: sessionUsage.usage
+		};
+	}
+	/**
+	* Check if an agent is running
+	*/
+	isRunning(agentId) {
+		return sessionExistsSync(agentId);
+	}
+};
+/**
+* Create a Claude Code runtime instance
+*/
+function createClaudeCodeRuntimeSync() {
+	return new ClaudeCodeRuntimeSync();
+}
+//#endregion
+//#region ../../lib/cost-parsers/pi-parser.ts
+init_errors();
+//#endregion
+//#region ../../lib/runtimes/pi.ts
+init_behavior();
+init_tmux();
+init_pi_fifo();
+init_errors();
+init_paths();
+promisify(exec);
+//#endregion
+//#region ../../lib/runtimes/index.ts
+init_behavior();
+init_ohmypi();
+init_agents();
+/**
+* Runtime registry implementation
+*
+* Manages multiple runtime adapters and provides lookup by agent ID.
+*/
+var RuntimeRegistry = class {
+	runtimes = /* @__PURE__ */ new Map();
+	/**
+	* Register a runtime adapter
+	*/
+	register(runtime) {
+		this.runtimes.set(runtime.name, runtime);
+	}
+	/**
+	* Get a runtime by name
+	*/
+	get(name) {
+		return this.runtimes.get(name);
+	}
+	/**
+	* Get all registered runtimes
+	*/
+	getAll() {
+		return Array.from(this.runtimes.values());
+	}
+	/**
+	* Get the runtime for a specific agent.
+	*
+	* Reads the agent's state file and dispatches by `state.harness`. When
+	* the harness field is missing or carries a legacy value (e.g. 'claude'
+	* from pre-PAN-636 wire format), we fall back to the claude-code runtime
+	* to preserve back-compat (PAN-636 ac2).
+	*/
+	getRuntimeForAgent(agentId) {
+		const state = getAgentStateSync(agentId);
+		if (!state) return null;
+		const harness = state.harness;
+		if (harness === "ohmypi" || harness === "pi") return this.get("ohmypi") ?? null;
+		if (harness === "codex") return this.get("codex") ?? null;
+		return this.get("claude-code") ?? null;
+	}
+};
+/**
+* Global runtime registry instance
+*/
+let globalRegistry = null;
+/**
+* Get the global runtime registry
+*
+* Creates a new registry if one doesn't exist.
+* Registers Claude Code runtime by default.
+*/
+function getGlobalRegistry() {
+	if (!globalRegistry) {
+		globalRegistry = new RuntimeRegistry();
+		globalRegistry.register(createClaudeCodeRuntimeSync());
+		globalRegistry.register(createOhmypiRuntimeSync());
+		globalRegistry.register(createCodexRuntimeSync());
+	}
+	return globalRegistry;
+}
+/**
+* Helper to get the runtime for an agent from the global registry
+*/
+function getRuntimeForAgent(agentId) {
+	return getGlobalRegistry().getRuntimeForAgent(agentId);
+}
+//#endregion
+//#region ../../lib/cloister/agent-idle.ts
+init_agents();
+init_tmux();
+function getAgentEffectiveLastActivityMs(agentId) {
+	const candidates = [];
+	const runtimeState = getAgentRuntimeStateSync(agentId);
+	const runtimeMs = runtimeState?.lastActivity ? new Date(runtimeState.lastActivity).getTime() : NaN;
+	if (Number.isFinite(runtimeMs)) candidates.push(runtimeMs);
+	try {
+		const tmuxActivity = listPaneValuesSync(agentId, "#{window_activity}").map((value) => Number.parseInt(value.trim(), 10) * 1e3).filter(Number.isFinite);
+		candidates.push(...tmuxActivity);
+	} catch {}
+	try {
+		const heartbeat = getRuntimeForAgent(agentId)?.getHeartbeat(agentId);
+		if (heartbeat?.timestamp) {
+			const heartbeatMs = heartbeat.timestamp.getTime();
+			if (Number.isFinite(heartbeatMs)) candidates.push(heartbeatMs);
+		}
+	} catch {}
+	return candidates.length > 0 ? Math.max(...candidates) : null;
+}
+function isAgentIdleForNudge(agentId, staleActiveThresholdMs = 300 * 1e3, now = Date.now()) {
+	const runtimeState = getAgentRuntimeStateSync(agentId);
+	const effectiveLastActivityMs = getAgentEffectiveLastActivityMs(agentId);
+	if (!runtimeState) {
+		if (effectiveLastActivityMs === null) {
+			console.log(`[deacon] ${agentId}: no runtime.json — skipping (hook not yet fired)`);
+			return false;
+		}
+		return now - effectiveLastActivityMs > staleActiveThresholdMs;
+	}
+	if (runtimeState.state === "suspended" || runtimeState.state === "stopped") return false;
+	if (runtimeState.state === "waiting-on-human") return false;
+	if (runtimeState.state === "idle") return true;
+	return now - (effectiveLastActivityMs ?? new Date(runtimeState.lastActivity).getTime()) > staleActiveThresholdMs;
+}
+//#endregion
+//#region ../../lib/cloister/agent-death.ts
+/**
+* Agent death diagnostics (PAN-2108).
+*
+* When an ohmypi/pi agent process dies, the launcher records its exit code +
+* timestamp to `<agentDir>/exit-status` (see buildOhmypiCommand in
+* launcher-generator.ts), and omp's stdout/stderr is captured to
+* `<agentDir>/output.log`. This module turns those into a one-line death reason
+* the deacon can log, replacing the opaque "session is dead" with an actual
+* cause — the gap that made the flywheel orchestrator's silent death
+* undiagnosable in RUN-30.
+*/
+init_paths();
+init_tmux();
+function agentDir(agentId) {
+	return join$1(getOverdeckHome(), "agents", agentId);
+}
+/** Read the launcher-recorded exit code + UTC timestamp, or null if absent. */
+function readAgentExitStatus(agentId) {
+	try {
+		const p = join$1(agentDir(agentId), "exit-status");
+		if (!existsSync(p)) return null;
+		const raw = readFileSync(p, "utf-8").trim();
+		if (!raw) return null;
+		const [code, at = ""] = raw.split(/\s+/);
+		return {
+			code: code ?? "?",
+			at
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Best-effort one-line description of why an agent process died: the
+* launcher-recorded exit status (preferred), the tmux pane exit status (fallback
+* when the dead pane corpse still exists), and the tail of output.log.
+*/
+function describeAgentDeath(agentId) {
+	const parts = [];
+	const exit = readAgentExitStatus(agentId);
+	if (exit) parts.push(`exit=${exit.code}${exit.at ? ` at ${exit.at}` : ""}`);
+	else if (sessionExistsSync(agentId)) {
+		const paneExit = listPaneValuesSync(agentId, "#{pane_exit_status}").find((v) => v !== "");
+		if (paneExit) parts.push(`pane_exit=${paneExit}`);
+	}
+	try {
+		const logPath = join$1(agentDir(agentId), "output.log");
+		if (existsSync(logPath)) {
+			const tail = readFileSync(logPath, "utf-8").slice(-1500).trim().split("\n").slice(-6).join(" | ").trim();
+			if (tail) parts.push(`output.log tail: ${tail}`);
+		}
+	} catch {}
+	return parts.length ? parts.join("; ") : "no exit trace (exit-status + output.log empty)";
+}
+//#endregion
+//#region ../../lib/cloister/stuck-remediation-state.ts
+init_control_settings();
+init_paths();
+function agentStateDir(agentId) {
+	return join$1(getOverdeckHome(), "agents", agentId);
+}
+function statePath(agentId) {
+	return join$1(agentStateDir(agentId), "stuck-remediation.json");
+}
+function readStuckRemediationState(agentId) {
+	const filePath = statePath(agentId);
+	if (!existsSync(filePath)) return null;
+	try {
+		return JSON.parse(readFileSync(filePath, "utf-8"));
+	} catch (error) {
+		console.warn(`Failed to read stuck-remediation state for ${agentId}:`, error);
+		return null;
+	}
+}
+function writeStuckRemediationState(agentId, state) {
+	mkdirSync(agentStateDir(agentId), { recursive: true });
+	writeFileSync(statePath(agentId), `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+}
+function clearStuckRemediationState(agentId) {
+	const filePath = statePath(agentId);
+	if (!existsSync(filePath)) return;
+	unlinkSync(filePath);
+}
+//#endregion
+//#region ../../lib/cloister/stuck-remediation.ts
+init_agents();
+init_tmux();
+function issueIdForAgent(agent) {
+	return agent.issueId || agent.id.replace(/^agent-/, "").toUpperCase();
+}
+function shouldSkipReviewStatus(status) {
+	if (!status) return false;
+	if (status.stuck || status.deaconIgnored || status.mergeStatus === "merged" || status.readyForMerge) return true;
+	if (status.reviewStatus === "blocked" || status.reviewStatus === "failed") return true;
+	if (status.verificationStatus === "failed" || status.testStatus === "failed") return true;
+	if (status.reviewStatus === "reviewing" || status.reviewStatus === "passed") return true;
+	return status.reviewStatus === "pending" && !!status.reviewRequestedAt;
+}
+/**
+* PAN-2581 (FR-2, residual): phase gate for the health-check poke loop
+* (service.ts pokeAgent → pokeAgentWithEscalation → idle-alive pause), the
+* SECOND independent idleness consumer besides stuck-remediation. A warm-idle
+* work agent on a pipeline-owned issue — and a warm-idle review/test agent
+* after its verdict — must never be poked ("are you stuck?") or idle-alive
+* paused: the poke spends tokens re-explaining the wait, and the pause
+* manufactures the paused-delivery-target deadlock PAN-2461 exists to undo.
+* A genuinely stalled mid-review parent is covered by the PAN-2584 liveness
+* deadline, not pokes. Owed-rework agents (review blocked/failed, tests
+* failed) are ALSO skipped here by design: shouldSkipReviewStatus returns
+* true for those because the PAN-2519 wedged-rework path owns their
+* escalation — the health-check poke loop must not double-drive them.
+* Roles outside work/review/test (plan, strike, flywheel, sequencer) keep
+* their existing idleness semantics.
+*/
+function shouldSkipIdlePokeForAgent(agent, readStatus = getReviewStatusSync) {
+	if (!agent) return false;
+	if (agent.role !== "work" && agent.role !== "review" && agent.role !== "test") return false;
+	return shouldSkipReviewStatus(readStatus((agent.issueId || agent.id.replace(/^agent-/, "").replace(/-(review|test|ship)(-.*)?$/, "").replace(/-slot-\d+$/, "")).toUpperCase()));
+}
+function hasPendingRework(status) {
+	if (!status) return false;
+	if (status.stuck || status.deaconIgnored || status.mergeStatus === "merged" || status.readyForMerge) return false;
+	return status.reviewStatus === "blocked" || status.reviewStatus === "failed" || status.verificationStatus === "failed" || status.testStatus === "failed";
+}
+const STUCK_KILL_REQUEUE_CEILING = 25;
+async function evaluateWedgedReworkAgent(agent, config, now, actions) {
+	const agentId = agent.id;
+	if (agent.role !== "work" || !agent.workspace) return false;
+	const issueId = issueIdForAgent(agent);
+	const status = getReviewStatusSync(issueId);
+	if (!hasPendingRework(status)) return false;
+	const lastActivityMs = getAgentEffectiveLastActivityMs(agentId);
+	if (lastActivityMs === null || !Number.isFinite(lastActivityMs)) return false;
+	const stuckState = readStuckRemediationState(agentId);
+	if (stuckState) {
+		const firstStuckMs = new Date(stuckState.firstStuckAt).getTime();
+		if (Number.isFinite(firstStuckMs) && lastActivityMs > firstStuckMs) {
+			clearStuckRemediationState(agentId);
+			return false;
+		}
+	}
+	const idleMinutes = Math.floor((now - lastActivityMs) / 6e4);
+	const lastStage = stuckState?.lastStage ?? 0;
+	if (idleMinutes < config.stage3_minutes || lastStage >= 3) return false;
+	const firstStuck = firstStuckAt(new Date(lastActivityMs).toISOString(), stuckState);
+	if ((status?.autoRequeueCount ?? 0) >= STUCK_KILL_REQUEUE_CEILING) {
+		markAgentTroubled(agentId);
+		writeStuckRemediationState(agentId, stageState(3, now, firstStuck));
+		logAction(actions, transitionAction(3, issueId, idleMinutes, "rework-wedge-troubled"));
+		surfaceStuckNeedsYou(agent, issueId, firstStuck, actions);
+		return true;
+	}
+	killSessionSync(agentId);
+	writeStuckRemediationState(agentId, stageState(3, now, firstStuck));
+	logAction(actions, transitionAction(3, issueId, idleMinutes, "killed-for-respawn"));
+	return true;
+}
+function hasReadyBeads(readyByQueryRoot, agent, issueLabel) {
+	return (readyByQueryRoot.get(resolveBeadsQueryRoot(agent.workspace))?.[issueLabel] ?? []).length > 0;
+}
+function shouldCheckReadyBeadsForAgent(agent, now) {
+	const agentId = agent.id;
+	if (!agentId) return false;
+	if (agent.status !== "running") return false;
+	if (agent.role !== "work") return false;
+	if (!agent.workspace) return false;
+	const completedAt = agent.completedAt;
+	if (agent.paused || agent.troubled || completedAt) return false;
+	if (!sessionExistsSync(agentId)) return false;
+	if (shouldSkipReviewStatus(getReviewStatusSync(issueIdForAgent(agent)))) return false;
+	return isAgentIdleForNudge(agentId, 300 * 1e3, now);
+}
+function firstStuckAt(runtimeLastActivity, stuckState) {
+	return stuckState?.firstStuckAt ?? runtimeLastActivity;
+}
+function stageState(stage, now, firstStuck, prev) {
+	return {
+		lastStage: stage,
+		lastStageAt: new Date(now).toISOString(),
+		firstStuckAt: firstStuck,
+		...prev?.respawnCount !== void 0 ? { respawnCount: prev.respawnCount } : {},
+		...prev?.lastRespawnAt !== void 0 ? { lastRespawnAt: prev.lastRespawnAt } : {}
+	};
+}
+function transitionAction(stage, issueId, idleMinutes, action) {
+	return `[deacon] stuck-remediation stage=${stage} issue=${issueId} idleMin=${idleMinutes} action=${action}`;
+}
+function logAction(actions, action) {
+	actions.push(action);
+	console.log(action);
+	logDeaconEventSync(action);
+}
+function surfaceStuckNeedsYou(agent, issueId, generation, actions) {
+	if (!agent.workspace) return;
+	if (recordRecoveryFailure(agent.workspace, issueId, "stuck-remediation", generation, 1).emitNeedsYou) logAction(actions, `[deacon] needs-you ${issueId}: stuck remediation exhausted`);
+}
+async function evaluateAgent(agent, config, now, actions, readyByQueryRoot) {
+	const agentId = agent.id;
+	if (!agentId) return;
+	if (agent.status !== "running") return;
+	const completedAt = agent.completedAt;
+	if (agent.paused || agent.troubled || completedAt) return;
+	if (agent.role === "flywheel") {
+		await evaluateFlywheelOrchestrator(agent, config, now, actions);
+		return;
+	}
+	if (!sessionExistsSync(agentId)) return;
+	if (agent.role === "plan" && agent.auto === true) {
+		await evaluateAutoPlanningAgent(agent, config, now, actions);
+		return;
+	}
+	if (await evaluateWedgedReworkAgent(agent, config, now, actions)) return;
+	if (!shouldCheckReadyBeadsForAgent(agent, now)) return;
+	if (!agent.workspace) return;
+	const issueId = issueIdForAgent(agent);
+	if (hasReadyBeads(readyByQueryRoot, agent, issueId.toLowerCase())) return;
+	const lastActivityMs = getAgentEffectiveLastActivityMs(agentId);
+	if (lastActivityMs === null) return;
+	if (!Number.isFinite(lastActivityMs)) return;
+	const lastActivity = new Date(lastActivityMs).toISOString();
+	const stuckState = readStuckRemediationState(agentId);
+	if (stuckState) {
+		const firstStuckMs = new Date(stuckState.firstStuckAt).getTime();
+		if (Number.isFinite(firstStuckMs) && lastActivityMs > firstStuckMs) {
+			clearStuckRemediationState(agentId);
+			return;
+		}
+	}
+	const idleMinutes = Math.floor((now - lastActivityMs) / 6e4);
+	const lastStage = stuckState?.lastStage ?? 0;
+	const firstStuck = firstStuckAt(lastActivity, stuckState);
+	if (idleMinutes >= config.stage3_minutes && lastStage < 3) {
+		markAgentTroubled(agentId);
+		writeStuckRemediationState(agentId, stageState(3, now, firstStuck));
+		logAction(actions, transitionAction(3, issueId, idleMinutes, "marked-troubled"));
+		surfaceStuckNeedsYou(agent, issueId, firstStuck, actions);
+		return;
+	}
+	if (idleMinutes >= config.stage2_minutes && lastStage < 2) {
+		if ((await resumeAgent(agentId, `Resuming after auto-detected stall (${idleMinutes} min idle). Review your last work and decide whether to continue or signal done with \`pan done ${issueId}\`.`)).success) {
+			writeStuckRemediationState(agentId, stageState(2, now, firstStuck));
+			logAction(actions, transitionAction(2, issueId, idleMinutes, "resumed"));
+		} else {
+			const action = `${transitionAction(2, issueId, idleMinutes, "resume-failed")} — death: ${describeAgentDeath(agentId)}`;
+			console.warn(action);
+			logDeaconEventSync(action);
+		}
+		return;
+	}
+	if (idleMinutes >= config.stage1_minutes && lastStage < 1) {
+		await messageAgent(agentId, `You appear stuck — no tool calls for ${idleMinutes} min. If your implementation is complete, run \`pan done ${issueId}\`. Otherwise reply with a one-line summary of what you're waiting on, then continue.`);
+		writeStuckRemediationState(agentId, stageState(1, now, firstStuck));
+		logAction(actions, transitionAction(1, issueId, idleMinutes, "poked"));
+	}
+}
+async function evaluateAutoPlanningAgent(agent, config, now, actions) {
+	const agentId = agent.id;
+	if (!isAgentIdleForNudge(agentId, 300 * 1e3, now)) return;
+	if (await Effect.runPromise(countPendingAskUserQuestionsForAgent(agentId)) === 0) return;
+	const lastActivityMs = getAgentEffectiveLastActivityMs(agentId);
+	if (lastActivityMs === null || !Number.isFinite(lastActivityMs)) return;
+	const lastActivity = new Date(lastActivityMs).toISOString();
+	const stuckState = readStuckRemediationState(agentId);
+	if (stuckState) {
+		const firstStuckMs = new Date(stuckState.firstStuckAt).getTime();
+		if (Number.isFinite(firstStuckMs) && lastActivityMs > firstStuckMs) {
+			clearStuckRemediationState(agentId);
+			return;
+		}
+	}
+	const idleMinutes = Math.floor((now - lastActivityMs) / 6e4);
+	const lastStage = stuckState?.lastStage ?? 0;
+	if (idleMinutes < config.stage1_minutes || lastStage >= 1) return;
+	const issueId = issueIdForAgent(agent);
+	await messageAgent(agentId, `This planning session was launched with \`pan plan ${issueId} --auto\`, so do not wait for operator input. Proceed with the most defensible default from the issue/PRD/comments, record the choice in \`plan.autoDecisions[]\` with rationale, and continue to \`pan plan finalize\`. Only halt for a genuine contradiction between authoritative inputs.`);
+	writeStuckRemediationState(agentId, stageState(1, now, firstStuckAt(lastActivity, stuckState)));
+	logAction(actions, transitionAction(1, issueId, idleMinutes, "auto-planning-default"));
+}
+const FLYWHEEL_RESPAWN_WINDOW_MS = 1800 * 1e3;
+const FLYWHEEL_MAX_RESPAWNS = 3;
+const FLYWHEEL_ORCHESTRATOR_AGENT_ID = "flywheel-orchestrator";
+/**
+* Pure decision for recovering a dead or wedged flywheel orchestrator (no I/O —
+* side effects live in remediateFlywheelOrchestrator). The respawn cap
+* (FLYWHEEL_MAX_RESPAWNS within FLYWHEEL_RESPAWN_WINDOW_MS) stops an infinite
+* relaunch loop: past the cap, escalate to paused+troubled. `hasActiveRun` false
+* ⇒ the operator stopped the flywheel deliberately ⇒ do not resurrect.
+*/
+function decideFlywheelRemediation(opts) {
+	if (!opts.hasActiveRun) return { kind: "noop" };
+	const lastRespawnMs = opts.prev?.lastRespawnAt ? new Date(opts.prev.lastRespawnAt).getTime() : 0;
+	const respawnCount = Number.isFinite(lastRespawnMs) && opts.now - lastRespawnMs < FLYWHEEL_RESPAWN_WINDOW_MS ? opts.prev?.respawnCount ?? 0 : 0;
+	if (respawnCount >= FLYWHEEL_MAX_RESPAWNS) return {
+		kind: "escalate",
+		respawnCount
+	};
+	return {
+		kind: "relaunch",
+		respawnCount: respawnCount + 1
+	};
+}
+/** True when the orchestrator's process is actually gone (session missing or dead pane). */
+function isFlywheelOrchestratorDead(agentId) {
+	if (!sessionExistsSync(agentId)) return true;
+	return listPaneValuesSync(agentId, "#{pane_dead}").some((v) => v === "1");
+}
+/**
+* Recover a dead or wedged flywheel orchestrator: relaunch (capped) or, past the
+* cap, pause+trouble. `reason` describes why recovery fired (death vs wedge) for
+* the deacon log. NO_RESUME is intentionally NOT consulted (see header comment) —
+* the operator gate is the active run (`pan flywheel stop`) / patrol freeze.
+*/
+async function remediateFlywheelOrchestrator(agentId, now, actions, reason) {
+	const decision = decideFlywheelRemediation({
+		hasActiveRun: Boolean(getFlywheelActiveRunId()),
+		prev: readStuckRemediationState(agentId),
+		now
+	});
+	if (decision.kind === "noop") return;
+	const { resumeFlywheel, pauseFlywheel } = await import("./flywheel-RCnHAgc4.js");
+	const prev = readStuckRemediationState(agentId);
+	const nowIso = new Date(now).toISOString();
+	if (decision.kind === "escalate") {
+		await pauseFlywheel();
+		markAgentTroubled(agentId);
+		writeStuckRemediationState(agentId, {
+			lastStage: 3,
+			lastStageAt: nowIso,
+			firstStuckAt: prev?.firstStuckAt ?? nowIso,
+			respawnCount: decision.respawnCount,
+			lastRespawnAt: prev?.lastRespawnAt
+		});
+		logAction(actions, `[deacon] FLYWHEEL orchestrator ${reason} and exceeded ${FLYWHEEL_MAX_RESPAWNS} relaunches in ${FLYWHEEL_RESPAWN_WINDOW_MS / 6e4}min — paused + troubled; operator needed`);
+		return;
+	}
+	try {
+		killSessionSync(agentId);
+	} catch {}
+	try {
+		await resumeFlywheel();
+		writeStuckRemediationState(agentId, {
+			lastStage: 0,
+			lastStageAt: nowIso,
+			firstStuckAt: nowIso,
+			respawnCount: decision.respawnCount,
+			lastRespawnAt: nowIso
+		});
+		logAction(actions, `[deacon] FLYWHEEL orchestrator ${reason} — fresh-launched (relaunch ${decision.respawnCount}/${FLYWHEEL_MAX_RESPAWNS})`);
+	} catch (error) {
+		logAction(actions, `[deacon] FLYWHEEL orchestrator ${reason} — relaunch FAILED: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+async function evaluateFlywheelOrchestrator(agent, config, now, actions) {
+	const agentId = agent.id;
+	if (isFlywheelOrchestratorDead(agentId)) {
+		await remediateFlywheelOrchestrator(agentId, now, actions, `DIED (${describeAgentDeath(agentId)})`);
+		return;
+	}
+	if (!isAgentIdleForNudge(agentId, 300 * 1e3, now)) return;
+	const runtime = getAgentRuntimeStateSync(agentId);
+	if (!runtime?.lastActivity) return;
+	const lastActivityMs = new Date(runtime.lastActivity).getTime();
+	if (!Number.isFinite(lastActivityMs)) return;
+	const stuckState = readStuckRemediationState(agentId);
+	if (stuckState) {
+		const firstStuckMs = new Date(stuckState.firstStuckAt).getTime();
+		if (Number.isFinite(firstStuckMs) && lastActivityMs > firstStuckMs) {
+			clearStuckRemediationState(agentId);
+			return;
+		}
+	}
+	const idleMinutes = Math.floor((now - lastActivityMs) / 6e4);
+	const lastStage = stuckState?.lastStage ?? 0;
+	const firstStuck = firstStuckAt(runtime.lastActivity, stuckState);
+	if (idleMinutes >= config.flywheel_stage3_minutes && lastStage < 3) {
+		await remediateFlywheelOrchestrator(agentId, now, actions, `wedged (idle ${idleMinutes}min)`);
+		return;
+	}
+	if (idleMinutes >= config.flywheel_stage2_minutes && lastStage < 2) {
+		await messageAgent(agentId, `Stage 2: idle ${idleMinutes} min — run a FULL flywheel tick NOW: inventory -> diagnose -> suggest -> launch ready work -> \`pan flywheel emit-status\`. Then call ScheduleWakeup(delaySeconds:1000) to arm the next tick. Do NOT ask the operator a question, do NOT wait, and do NOT just emit a stale status or pause.`);
+		writeStuckRemediationState(agentId, stageState(2, now, firstStuck, stuckState));
+		logAction(actions, transitionAction(2, "FLYWHEEL", idleMinutes, "escalated-nudge"));
+		return;
+	}
+	if (idleMinutes >= config.flywheel_stage1_minutes && lastStage < 1) {
+		await messageAgent(agentId, `You appear stuck — ${idleMinutes} min since your last tick. Run a FULL flywheel tick NOW: inventory -> diagnose -> suggest -> launch ready work -> \`pan flywheel emit-status\`. Then call ScheduleWakeup(delaySeconds:1000) to arm the next tick. Do NOT ask the operator a question, do NOT wait, and do NOT just emit a stale status or pause.`);
+		writeStuckRemediationState(agentId, stageState(1, now, firstStuck, stuckState));
+		logAction(actions, transitionAction(1, "FLYWHEEL", idleMinutes, "poked"));
+	}
+}
+async function reconcileActiveFlywheelWithoutRunningAgent(now, actions) {
+	if (!getFlywheelActiveRunId()) return;
+	if (isFlywheelGloballyPaused()) return;
+	if (sessionExistsSync(FLYWHEEL_ORCHESTRATOR_AGENT_ID)) return;
+	await remediateFlywheelOrchestrator(FLYWHEEL_ORCHESTRATOR_AGENT_ID, now, actions, `DIED (${describeAgentDeath(FLYWHEEL_ORCHESTRATOR_AGENT_ID)})`);
+}
+async function checkStuckAgentRemediation(opts = {}) {
+	const config = loadCloisterConfigSync().stuck_remediation ?? DEFAULT_CLOISTER_CONFIG.stuck_remediation;
+	if (!config.enabled) return [];
+	const actions = [];
+	const now = opts.now ?? Date.now();
+	const runningAgents = listRunningAgentsSync();
+	const readyByQueryRoot = /* @__PURE__ */ new Map();
+	const workAgentsByQueryRoot = /* @__PURE__ */ new Map();
+	let sawFlywheelOrchestrator = false;
+	for (const agent of runningAgents) {
+		if (!shouldCheckReadyBeadsForAgent(agent, now)) continue;
+		const queryRoot = resolveBeadsQueryRoot(agent.workspace);
+		const workspaceAgents = workAgentsByQueryRoot.get(queryRoot) ?? [];
+		workspaceAgents.push(agent);
+		workAgentsByQueryRoot.set(queryRoot, workspaceAgents);
+	}
+	for (const [queryRoot, workspaceAgents] of workAgentsByQueryRoot) {
+		const issueIds = workspaceAgents.map(issueIdForAgent);
+		const ready = await Effect.runPromise(queryReadyBeadsByIssueLabels(queryRoot, issueIds, { acquisitionTimeoutMs: 500 }));
+		readyByQueryRoot.set(queryRoot, ready.byIssue);
+	}
+	for (const agent of runningAgents) {
+		if (agent.id === FLYWHEEL_ORCHESTRATOR_AGENT_ID || agent.role === "flywheel") sawFlywheelOrchestrator = true;
+		try {
+			await evaluateAgent(agent, config, now, actions, readyByQueryRoot);
+		} catch (error) {
+			const message = `[deacon] stuck-remediation agent=${agent.id || "(unknown)"} error=${error instanceof Error ? error.message : String(error)}`;
+			console.error(message, error);
+			logDeaconEventSync(message);
+		}
+	}
+	if (!sawFlywheelOrchestrator) try {
+		await reconcileActiveFlywheelWithoutRunningAgent(now, actions);
+	} catch (error) {
+		const message = `[deacon] stuck-remediation agent=${FLYWHEEL_ORCHESTRATOR_AGENT_ID} error=${error instanceof Error ? error.message : String(error)}`;
+		console.error(message, error);
+		logDeaconEventSync(message);
+	}
+	return actions;
+}
+//#endregion
+export { parseCodexApprovalPrompt as _, isAgentIdleForNudge as a, countPendingAskUserQuestionsForAgent as c, getAgentPendingQuestions as d, getAgentWorkspace as f, normalizeAwaitingInputPrompt as g, detectAwaitingInputFromPaneSync as h, shouldSkipReviewStatus as i, getAgentJsonlMtime as l, detectAwaitingInputForAgent as m, decideFlywheelRemediation as n, getRuntimeForAgent as o, scanPendingInputsPromise as p, shouldSkipIdlePokeForAgent as r, computeAgentEnrichment as s, checkStuckAgentRemediation as t, getAgentJsonlPath as u };
+
+//# sourceMappingURL=stuck-remediation-CxsyxwFO.js.map