@overdeck/desktop 0.45.15 → 0.45.18

package/server/state-migrate-D3VveYfO.js

@@ -0,0 +1,362 @@
+import { Fn as init_projects, Gn as resolveInfraRepo, an as STATE_BRANCH_PATHS, cn as init_state_plane, dn as acquireStateMigrationLock, fn as init_state_migration_lock, kn as getProjectSync, nn as init_auto_commit, tn as flushAutoCommits } from "./config-yaml-CqaAyn8y.js";
+import { l as stateWorktreePath, n as STATE_BRANCH, o as init_state_home, r as clearStateMigrationCache, t as MIGRATION_COMPLETE_MARKER } from "./state-home-Bur1y4oH.js";
+import { dirname, join } from "node:path";
+import { Effect } from "effect";
+import { tmpdir } from "node:os";
+import { copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createHash } from "node:crypto";
+//#region ../../lib/state-migration-manifest.ts
+init_projects();
+init_state_migration_lock();
+init_state_plane();
+init_auto_commit();
+init_state_home();
+function manifestEntry(source, destination) {
+	const stat = lstatSync(source);
+	const bytes = readFileSync(source);
+	return {
+		source,
+		destination,
+		mode: stat.mode & 511,
+		size: stat.size,
+		sha256: createHash("sha256").update(bytes).digest("hex")
+	};
+}
+function verifyStateMigrationManifest(entries) {
+	for (const expected of entries) {
+		const actual = manifestEntry(expected.destination, expected.destination);
+		if ((actual.mode & 64) !== (expected.mode & 64) || actual.size !== expected.size || actual.sha256 !== expected.sha256) throw new Error(`State migration no-loss mismatch: ${expected.source} -> ${expected.destination}`);
+	}
+}
+//#endregion
+//#region ../../cli/commands/admin/state-migrate.ts
+const execFileAsync = promisify(execFile);
+async function git(cwd, args, env) {
+	const { stdout } = await execFileAsync("git", args, {
+		cwd,
+		env: {
+			...process.env,
+			...env
+		},
+		encoding: "utf8",
+		maxBuffer: 32 * 1024 * 1024
+	});
+	return stdout.trim();
+}
+function destinationForTracked(path) {
+	if (!path.startsWith(".pan/")) return null;
+	const flat = path.slice(5);
+	return STATE_BRANCH_PATHS.some((prefix) => flat.startsWith(prefix)) ? flat : null;
+}
+async function trackedManifest(repo, sourceSha, stateRoot) {
+	return (await git(repo, [
+		"ls-tree",
+		"-r",
+		"--name-only",
+		sourceSha,
+		"--",
+		".pan"
+	])).split("\n").filter(Boolean).flatMap((path) => {
+		const destination = destinationForTracked(path);
+		if (!destination) return [];
+		const source = join(repo, path);
+		const target = join(stateRoot, destination);
+		if (!existsSync(target)) {
+			mkdirSync(dirname(target), { recursive: true });
+			copyFileSync(source, target);
+		}
+		return [manifestEntry(source, target)];
+	});
+}
+async function createOrphanStateCommit(repo, sourceSha) {
+	const index = join(tmpdir(), `overdeck-state-index-${process.pid}-${Date.now()}`);
+	const env = { GIT_INDEX_FILE: index };
+	try {
+		await git(repo, ["read-tree", "--empty"], env);
+		const rows = (await git(repo, [
+			"ls-tree",
+			"-r",
+			sourceSha,
+			"--",
+			".pan"
+		])).split("\n").filter(Boolean);
+		for (const row of rows) {
+			const match = row.match(/^(\d+)\s+\w+\s+([0-9a-f]+)\t(.+)$/);
+			if (!match) continue;
+			const destination = destinationForTracked(match[3]);
+			if (destination) await git(repo, [
+				"update-index",
+				"--add",
+				"--cacheinfo",
+				`${match[1]},${match[2]},${destination}`
+			], env);
+		}
+		return await git(repo, [
+			"commit-tree",
+			await git(repo, ["write-tree"], env),
+			"-m",
+			"chore(state): seed overdeck-state"
+		]);
+	} finally {
+		rmSync(index, { force: true });
+	}
+}
+function copyLegacyState(sourceRoot, stateRoot) {
+	const manifest = [];
+	for (const sourcePath of STATE_BRANCH_PATHS) {
+		const source = join(sourceRoot, ".pan", sourcePath);
+		if (!existsSync(source)) continue;
+		const destination = join(stateRoot, sourcePath);
+		cpSync(source, destination, {
+			recursive: true,
+			preserveTimestamps: true
+		});
+		const visit = (sourceDir, destinationDir) => {
+			for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+				const sourceEntry = join(sourceDir, entry.name);
+				const destinationEntry = join(destinationDir, entry.name);
+				if (entry.isDirectory()) visit(sourceEntry, destinationEntry);
+				else if (entry.isFile()) manifest.push(manifestEntry(sourceEntry, destinationEntry));
+			}
+		};
+		visit(source, destination);
+	}
+	return manifest;
+}
+function hasNonStateDirtyState(porcelain) {
+	return porcelain.split("\n").filter(Boolean).some((line) => {
+		const path = line.slice(3).split(" -> ").at(-1) ?? "";
+		if (path === ".pan" || path.startsWith(".pan/")) return false;
+		return true;
+	});
+}
+function dedupeManifest(entries) {
+	return [...new Map(entries.map((entry) => [entry.destination, entry])).values()];
+}
+const GITIGNORE_MANAGED_LINES = [
+	"# PAN-2541: permanent state is on overdeck-state; workspace runtime stays local.",
+	".pan/",
+	".overdeck/continue.json",
+	".overdeck/spec.vbrief.json",
+	".overdeck/sessions.jsonl",
+	".overdeck/feedback/",
+	".overdeck/review/",
+	".overdeck/test/",
+	".overdeck/kickoff.md",
+	".overdeck/agent-mcp.json"
+];
+function rewriteGitignore(repo) {
+	const path = join(repo, ".gitignore");
+	const prior = existsSync(path) ? readFileSync(path, "utf8") : "";
+	const managed = new Set([...GITIGNORE_MANAGED_LINES, ".overdeck/"]);
+	const kept = prior.split("\n").filter((line) => !managed.has(line.trim()));
+	while (kept.length > 0 && kept[kept.length - 1]?.trim() === "") kept.pop();
+	writeFileSync(path, [
+		...kept,
+		"",
+		...GITIGNORE_MANAGED_LINES,
+		""
+	].join("\n"));
+}
+async function migrateProjectState(projectKey, options = {}, projectOverride) {
+	const project = projectOverride ?? getProjectSync(projectKey);
+	if (!project) throw new Error(`Unknown project: ${projectKey}`);
+	const { repoPath: repo } = resolveInfraRepo(project);
+	const legacyStateSource = project.path;
+	const sourceIsHostRepo = legacyStateSource === repo;
+	const stateRoot = stateWorktreePath(project, { projectKey });
+	console.log(`PAN-2541 state migration plan for ${projectKey}:`);
+	console.log(`  ${legacyStateSource}/.pan/{${STATE_BRANCH_PATHS.map((p) => p.slice(0, -1)).join(",")}} -> ${stateRoot}/`);
+	console.log(`  ${legacyStateSource}/.pan/context -> ${legacyStateSource}/.overdeck/context`);
+	if (options.dryRun) return;
+	const release = acquireStateMigrationLock(projectKey);
+	try {
+		await Effect.runPromise(flushAutoCommits(repo));
+		if (hasNonStateDirtyState(await git(repo, ["status", "--porcelain"]))) throw new Error("Primary checkout is dirty outside legacy state paths; migration refused before mutation");
+		await git(repo, [
+			"fetch",
+			"--prune",
+			"origin"
+		]);
+		const sourceMainSha = await git(repo, ["rev-parse", "main"]);
+		if (sourceMainSha !== await git(repo, ["rev-parse", "origin/main"])) throw new Error("main is not exactly at origin/main; migration refused");
+		if (await git(repo, ["show", `origin/overdeck-state:migration-complete.json`]).catch(() => "")) {
+			console.log("State migration already complete on origin; nothing to do.");
+			return;
+		}
+		let stateSha = await git(repo, ["rev-parse", STATE_BRANCH]).catch(() => "");
+		const remoteStateSha = await git(repo, ["rev-parse", `origin/${STATE_BRANCH}`]).catch(() => "");
+		if (stateSha && remoteStateSha && stateSha !== remoteStateSha) throw new Error("Local and remote overdeck-state diverged; refusing non-fast-forward migration");
+		if (!stateSha) {
+			stateSha = remoteStateSha || await createOrphanStateCommit(repo, sourceMainSha);
+			await git(repo, [
+				"update-ref",
+				`refs/heads/${STATE_BRANCH}`,
+				stateSha
+			]);
+		}
+		if (!remoteStateSha) await git(repo, [
+			"push",
+			"origin",
+			STATE_BRANCH
+		]);
+		if (!existsSync(stateRoot)) {
+			mkdirSync(dirname(stateRoot), { recursive: true });
+			await git(repo, [
+				"worktree",
+				"add",
+				stateRoot,
+				STATE_BRANCH
+			]);
+		}
+		const manifest = sourceIsHostRepo ? dedupeManifest([...await trackedManifest(repo, sourceMainSha, stateRoot), ...copyLegacyState(legacyStateSource, stateRoot)]) : copyLegacyState(legacyStateSource, stateRoot);
+		if (manifest.length > 0) {
+			await git(stateRoot, ["add", "--all"]);
+			if (await git(stateRoot, [
+				"diff",
+				"--cached",
+				"--name-only"
+			])) await git(stateRoot, [
+				"commit",
+				"-m",
+				"chore(state): seed legacy project state"
+			]);
+			await git(stateRoot, [
+				"push",
+				"origin",
+				STATE_BRANCH
+			]);
+		}
+		const untracked = sourceIsHostRepo ? (await git(repo, [
+			"ls-files",
+			"--others",
+			"--",
+			".pan"
+		])).split("\n").filter((path) => path.split("/").length === 2 && existsSync(join(repo, path)) && lstatSync(join(repo, path)).isFile()) : existsSync(join(legacyStateSource, ".pan")) ? readdirSync(join(legacyStateSource, ".pan"), { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => `.pan/${entry.name}`) : [];
+		for (const path of untracked) {
+			if (!existsSync(join(legacyStateSource, path))) continue;
+			const destination = join(stateRoot, "notes", path.slice(5));
+			if (existsSync(destination)) {
+				if (!readFileSync(join(legacyStateSource, path)).equals(readFileSync(destination))) throw new Error(`Untracked-note destination collision: ${destination}`);
+				manifest.push(manifestEntry(join(legacyStateSource, path), destination));
+				continue;
+			}
+			mkdirSync(dirname(destination), { recursive: true });
+			copyFileSync(join(legacyStateSource, path), destination);
+			manifest.push(manifestEntry(join(legacyStateSource, path), destination));
+		}
+		if (untracked.length > 0) {
+			await git(stateRoot, ["add", "notes"]);
+			if (await git(stateRoot, [
+				"diff",
+				"--cached",
+				"--name-only"
+			])) await git(stateRoot, [
+				"commit",
+				"-m",
+				"chore(state): preserve untracked operator notes"
+			]);
+			await git(stateRoot, [
+				"push",
+				"origin",
+				STATE_BRANCH
+			]);
+		}
+		if (await git(repo, ["rev-parse", "main"]) !== sourceMainSha) throw new Error("main advanced during migration; refusing cleanup");
+		if (sourceIsHostRepo) await git(repo, [
+			"rm",
+			"-r",
+			"--cached",
+			"--ignore-unmatch",
+			".pan/records",
+			".pan/continues",
+			".pan/specs",
+			".pan/drafts",
+			".pan/review",
+			".pan/test",
+			".pan/feedback",
+			".pan/backlog",
+			".pan/notes"
+		]);
+		const oldContext = join(legacyStateSource, ".pan", "context");
+		const newContext = join(legacyStateSource, ".overdeck", "context");
+		let movedContext = false;
+		if (existsSync(oldContext) && !existsSync(newContext)) {
+			mkdirSync(dirname(newContext), { recursive: true });
+			renameSync(oldContext, newContext);
+			movedContext = true;
+		}
+		rewriteGitignore(legacyStateSource);
+		if (sourceIsHostRepo) {
+			if (await git(repo, [
+				"ls-files",
+				"--",
+				".pan/context"
+			])) await git(repo, [
+				"add",
+				"-u",
+				"--",
+				".pan/context"
+			]);
+			const addPaths = [".gitignore"];
+			if (movedContext || existsSync(newContext)) addPaths.push(".overdeck/context");
+			await git(repo, [
+				"add",
+				"--",
+				...addPaths
+			]);
+			if (await git(repo, [
+				"diff",
+				"--cached",
+				"--name-only"
+			])) await git(repo, [
+				"commit",
+				"-m",
+				"chore(state): move permanent state to overdeck-state"
+			]);
+		}
+		verifyStateMigrationManifest(manifest);
+		for (const entry of manifest) rmSync(entry.source, { force: true });
+		if (!sourceIsHostRepo) rmSync(join(legacyStateSource, ".pan"), {
+			recursive: true,
+			force: true
+		});
+		stateSha = await git(stateRoot, ["rev-parse", "HEAD"]);
+		writeFileSync(join(stateRoot, MIGRATION_COMPLETE_MARKER), `${JSON.stringify({
+			sourceMainSha,
+			stateBranchSha: stateSha,
+			completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			version: 1
+		}, null, 2)}\n`);
+		await git(stateRoot, ["add", MIGRATION_COMPLETE_MARKER]);
+		await git(stateRoot, [
+			"commit",
+			"-m",
+			"chore(state): complete state migration"
+		]);
+		await git(repo, [
+			"push",
+			"--atomic",
+			"--dry-run",
+			"origin",
+			"main",
+			STATE_BRANCH
+		]);
+		await git(repo, [
+			"push",
+			"--atomic",
+			"origin",
+			"main",
+			STATE_BRANCH
+		]);
+		clearStateMigrationCache();
+	} finally {
+		release();
+	}
+}
+//#endregion
+export { migrateProjectState };
+
+//# sourceMappingURL=state-migrate-D3VveYfO.js.map

package/server/{stuck-remediation-CFWUP8_I.js → stuck-remediation-B699-p8v.js}

@@ -1,16 +1,18 @@
-import { Kn as resolveProjectFromIssueSync, Kr as getOverdeckHome, Pn as init_projects, _r as TmuxError, br as init_errors, er as extractPrefixSync, qr as init_paths, tr as init_issue_id, ur as FsError, zr as encodeClaudeProjectDir } from "./config-yaml-Dcz-8uit.js";
-import { D as listPaneValuesSync, P as sendKeys, R as sessionExistsSync, T as killSessionSync, i as capturePane, x as init_tmux } from "./tmux-C_d-lSIq.js";
-import { n as CLAUDE_CODE_BEHAVIOR } from "./src-DHn4Rd2F.js";
-import { c as init_review_status, s as getReviewStatusSync } from "./review-status-4qqLkRMu.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, er as init_persistent_logger, gr as getAgentRuntimeStateSync, hr as getAgentRuntimeState, ht as DEFAULT_CLOISTER_CONFIG, j as messageAgent, nr as logDeaconEventSync, t as init_agents, vr as saveAgentRuntimeState, yt as loadCloisterConfigSync } from "./agents-CsOzAmRg.js";
-import { t as init_behavior } from "./behavior-Cpj03N4v.js";
-import { a as init_tracker_config, t as getGitHubConfig } from "./tracker-config-CNODpd11.js";
-import { a as init_launcher_generator } from "./state-home-CRowbXqU.js";
-import { i as createCodexRuntimeSync, l as init_codex } from "./codex-DW60_5j2.js";
-import { f as isFlywheelGloballyPaused, i as getFlywheelActiveRunId, s as init_control_settings } from "./control-settings-DwkAeooY.js";
-import { o as queryReadyBeadsByIssueLabels, r as init_beads_query, s as resolveBeadsQueryRoot } from "./beads-query-B1DlJVp9.js";
-import { a as init_jsonl_parser, i as getSessionFilesSync, r as getProjectDirsSync, s as parseClaudeSessionSync } from "./jsonl-parser-dNIjHgym.js";
-import { t as recordRecoveryFailure } from "./recovery-trip-Dfh1tNHn.js";
+import { Fn as init_projects, Jr as getOverdeckHome, Sr as init_errors, Vr as encodeClaudeProjectDir, Yr as init_paths, fr as FsError, nr as extractPrefixSync, qn as resolveProjectFromIssueSync, rr as init_issue_id, yr as TmuxError } from "./config-yaml-CqaAyn8y.js";
+import { E as killSessionSync, F as sendKeys, O as listPaneValuesSync, S as init_tmux, a as capturePaneSync, c as detectTerminalApiErrorSync, i as capturePane, z as sessionExistsSync } from "./tmux-U55cNGFG.js";
+import { n as CLAUDE_CODE_BEHAVIOR } from "./src-By3D85Ry.js";
+import { c as init_review_status, s as getReviewStatusSync } from "./review-status-DANr0t-v.js";
+import { Fn as getAgentStateSync, K as createOhmypiRuntimeSync, L as messageAgent, M as resumeAgent, Un as markAgentTroubled, Y as spawnAgent, Yn as saveAgentStateSync, _t as init_config, a as listRunningAgentsSync, gr as saveAgentRuntimeState, ht as DEFAULT_CLOISTER_CONFIG, jn as getAgentDir, ln as determineModel, mr as getAgentRuntimeStateSync, pr as getAgentRuntimeState, q as init_ohmypi, s as init_agents, tn as init_pi_fifo, yt as loadCloisterConfigSync } from "./queries-C0LCGG21.js";
+import { c as logDeaconEventSync, o as init_persistent_logger } 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 { m as readWorkspacePlanSync, o as init_io } from "./io-DkC4sFSy.js";
+import { n as init_launcher_generator } from "./launcher-generator-BXLM9f4b.js";
+import { i as createCodexRuntimeSync, l as init_codex } from "./codex-sgWVCGUd.js";
+import { f as isFlywheelGloballyPaused, i as getFlywheelActiveRunId, s as init_control_settings } from "./control-settings-BguNQ1F_.js";
+import { l as init_dag, o as getDispatchableItems } from "./dag-C6kYyF17.js";
+import { a as init_jsonl_parser, i as getSessionFilesSync, r as getProjectDirsSync, s as parseClaudeSessionSync } from "./jsonl-parser-Cd5jIqh7.js";
+import { t as recordRecoveryFailure } from "./recovery-trip-Cn7KJVkS.js";
 import "node:path";
 import { Effect } from "effect";
 import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "fs";
@@ -28,12 +30,13 @@ import "node:crypto";
 init_paths();
 init_issue_id();
 init_projects();
-init_review_status();
 init_behavior();
 init_persistent_logger();
+init_review_status();
+init_io();
 init_codex();
 init_launcher_generator();
-init_beads_query();
+init_dag();
 init_agents();
 init_tmux();
 init_errors();
@@ -425,15 +428,19 @@ async function readFileTail(filePath, maxBytes) {
 	}
 }
 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 content.includes(ASK_USER_QUESTION_HOOK_DENY_MARKER);
+	if (typeof content === "string") return isHookDenyText(content);
 	if (Array.isArray(content)) return content.some((part) => {
-		if (typeof part === "string") return part.includes(ASK_USER_QUESTION_HOOK_DENY_MARKER);
+		if (typeof part === "string") return isHookDenyText(part);
 		if (part && typeof part === "object" && "text" in part) {
 			const text = part.text;
-			return typeof text === "string" && text.includes(ASK_USER_QUESTION_HOOK_DENY_MARKER);
+			return typeof text === "string" && isHookDenyText(text);
 		}
 		return false;
 	});
@@ -474,6 +481,7 @@ async function scanPendingInputsPromise(jsonlPath) {
 		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();
@@ -495,6 +503,10 @@ async function scanPendingInputsPromise(jsonlPath) {
 					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") {
@@ -508,11 +520,19 @@ async function scanPendingInputsPromise(jsonlPath) {
 			}
 		} catch {}
 		const askUserQuestions = Array.from(askToolCalls.entries()).filter(([id]) => !askAnswered.has(id)).map(([, question]) => question);
-		const exitPlanModePending = Array.from(exitPlanModeIds).some((id) => !exitPlanModeAnswered.has(id));
+		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
+			exitPlanModePending,
+			...pendingProposedPlan ? { pendingProposedPlan } : {}
 		};
 	} catch {
 		return {
@@ -544,6 +564,7 @@ async function computeAgentEnrichmentPromise(agentId, startedAt, hasActiveSpecia
 	let pendingQuestions = [];
 	let enterPlanModeOpen = false;
 	let exitPlanModePending = false;
+	let scannedProposedPlan;
 	if (!skipJsonlScan) {
 		const jsonlPath = await Effect.runPromise(getAgentJsonlPath(agentId));
 		if (jsonlPath) {
@@ -551,6 +572,7 @@ async function computeAgentEnrichmentPromise(agentId, startedAt, hasActiveSpecia
 			pendingQuestions = [...scan.askUserQuestions];
 			enterPlanModeOpen = scan.enterPlanModeOpen;
 			exitPlanModePending = scan.exitPlanModePending;
+			scannedProposedPlan = scan.pendingProposedPlan;
 		}
 		if (pendingQuestions.length > 0 && startedAt) {
 			const agentStartTime = new Date(startedAt).getTime();
@@ -600,6 +622,7 @@ async function computeAgentEnrichmentPromise(agentId, startedAt, hasActiveSpecia
 		if (enterPlanModeOpen && !exitPlanModePending) pendingInputKinds.push("enterPlanMode");
 		appendPaneDetectionKind(detection, pendingInputKinds);
 	}
+	const pendingProposedPlan = !shouldSuppressPendingInput && exitPlanModePending ? scannedProposedPlan : void 0;
 	return {
 		role,
 		hasPendingQuestion,
@@ -609,6 +632,7 @@ async function computeAgentEnrichmentPromise(agentId, startedAt, hasActiveSpecia
 		pendingInputCount: pendingInputKinds.length,
 		pendingInputKinds,
 		pendingAskUserQuestion,
+		pendingProposedPlan,
 		resolution: runtimeState?.resolution || "working",
 		resolutionCount: runtimeState?.resolutionCount || 0
 	};
@@ -1198,7 +1222,7 @@ async function evaluateWedgedReworkAgent(agent, config, now, actions) {
 		markAgentTroubled(agentId);
 		writeStuckRemediationState(agentId, stageState(3, now, firstStuck));
 		logAction(actions, transitionAction(3, issueId, idleMinutes, "rework-wedge-troubled"));
-		surfaceStuckNeedsYou(agent, issueId, firstStuck, actions);
+		await surfaceStuckNeedsYou(agent, issueId, firstStuck, actions);
 		return true;
 	}
 	killSessionSync(agentId);
@@ -1206,9 +1230,6 @@ async function evaluateWedgedReworkAgent(agent, config, now, actions) {
 	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;
@@ -1241,11 +1262,11 @@ function logAction(actions, action) {
 	console.log(action);
 	logDeaconEventSync(action);
 }
-function surfaceStuckNeedsYou(agent, issueId, generation, actions) {
+async 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`);
+	if ((await 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) {
+async function evaluateAgent(agent, config, now, actions) {
 	const agentId = agent.id;
 	if (!agentId) return;
 	if (agent.status !== "running") return;
@@ -1264,7 +1285,9 @@ async function evaluateAgent(agent, config, now, actions, readyByQueryRoot) {
 	if (!shouldCheckReadyBeadsForAgent(agent, now)) return;
 	if (!agent.workspace) return;
 	const issueId = issueIdForAgent(agent);
-	if (hasReadyBeads(readyByQueryRoot, agent, issueId.toLowerCase())) return;
+	const plan = readWorkspacePlanSync(agent.workspace);
+	if (!plan) return;
+	if (getDispatchableItems(plan, /* @__PURE__ */ new Set()).length > 0) return;
 	const lastActivityMs = getAgentEffectiveLastActivityMs(agentId);
 	if (lastActivityMs === null) return;
 	if (!Number.isFinite(lastActivityMs)) return;
@@ -1280,11 +1303,19 @@ async function evaluateAgent(agent, config, now, actions, readyByQueryRoot) {
 	const idleMinutes = Math.floor((now - lastActivityMs) / 6e4);
 	const lastStage = stuckState?.lastStage ?? 0;
 	const firstStuck = firstStuckAt(lastActivity, stuckState);
+	const terminalProviderError = detectTerminalApiErrorSync(capturePaneSync(agentId, 80));
+	if (terminalProviderError) {
+		markAgentTroubled(agentId);
+		writeStuckRemediationState(agentId, stageState(3, now, firstStuck));
+		logAction(actions, `${agentId} provider-terminal: ${terminalProviderError.summary}`);
+		await surfaceStuckNeedsYou(agent, issueId, firstStuck, actions);
+		return;
+	}
 	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);
+		await surfaceStuckNeedsYou(agent, issueId, firstStuck, actions);
 		return;
 	}
 	if (idleMinutes >= config.stage2_minutes && lastStage < 2) {
@@ -1368,7 +1399,7 @@ async function remediateFlywheelOrchestrator(agentId, now, actions, reason) {
 		now
 	});
 	if (decision.kind === "noop") return;
-	const { resumeFlywheel, pauseFlywheel } = await import("./flywheel-Bi82iiNl.js");
+	const { resumeFlywheel, pauseFlywheel } = await import("./flywheel-BUWdcfhq.js");
 	const prev = readStuckRemediationState(agentId);
 	const nowIso = new Date(now).toISOString();
 	if (decision.kind === "escalate") {
@@ -1451,25 +1482,11 @@ async function checkStuckAgentRemediation(opts = {}) {
 	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);
+			await evaluateAgent(agent, config, now, actions);
 		} catch (error) {
 			const message = `[deacon] stuck-remediation agent=${agent.id || "(unknown)"} error=${error instanceof Error ? error.message : String(error)}`;
 			console.error(message, error);
@@ -1488,4 +1505,4 @@ async function checkStuckAgentRemediation(opts = {}) {
 //#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-CFWUP8_I.js.map
+//# sourceMappingURL=stuck-remediation-B699-p8v.js.map

package/server/{stuck-remediation-CLHd-lrF.js → stuck-remediation-CaFYYTQW.js}

@@ -1,2 +1,2 @@
-import { r as shouldSkipIdlePokeForAgent } from "./stuck-remediation-CFWUP8_I.js";
+import { r as shouldSkipIdlePokeForAgent } from "./stuck-remediation-B699-p8v.js";
 export { shouldSkipIdlePokeForAgent };

package/server/{summary-fork-CKc01Our.js → summary-fork-BxnF8Xh0.js}

@@ -1,4 +1,4 @@
-import "./smart-compaction-D5Zen3AA.js";
-import { a as generateFallbackSummary, l as init_summary_fork } from "./summary-fork-CtCwBJ2Z.js";
+import "./smart-compaction-CmoXpjeU.js";
+import { a as generateFallbackSummary, l as init_summary_fork } from "./summary-fork-COqYpVa3.js";
 init_summary_fork();
 export { generateFallbackSummary };

package/server/{summary-fork-CtCwBJ2Z.js → summary-fork-COqYpVa3.js}

@@ -1,9 +1,9 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Wr as getHandoffsDir, Yr as packageRoot, Zr as sessionFilePath, br as init_errors, f as loadConfigSync, qr as init_paths, t as init_config_yaml, ur as FsError } from "./config-yaml-Dcz-8uit.js";
-import { St as deliverAgentMessage, t as init_agents } from "./agents-CsOzAmRg.js";
-import { k as init_conversations } from "./conversations-DG2M8WnT.js";
-import { a as init_stack_health, i as getWorkspaceStackHealth } from "./stack-health-DxsTx7II.js";
-import { a as runModelSummary, i as parseEntries, o as serializeConversation, r as init_smart_compaction, s as summarizeSerializedText, t as generateSmartSummary } from "./smart-compaction-D5Zen3AA.js";
+import { $r as sessionFilePath, Kr as getHandoffsDir, Sr as init_errors, Yr as init_paths, Zr as packageRoot, f as loadConfigSync, fr as FsError, t as init_config_yaml } from "./config-yaml-CqaAyn8y.js";
+import { St as deliverAgentMessage, s as init_agents } from "./queries-C0LCGG21.js";
+import { k as init_conversations } from "./conversations-BX5aD-6F.js";
+import { a as init_stack_health, i as getWorkspaceStackHealth } from "./stack-health-C-SnpRHh.js";
+import { a as runModelSummary, i as parseEntries, o as serializeConversation, r as init_smart_compaction, s as summarizeSerializedText, t as generateSmartSummary } from "./smart-compaction-CmoXpjeU.js";
 import { join } from "node:path";
 import { Effect } from "effect";
 import { join as join$1 } from "path";
@@ -442,11 +442,11 @@ async function generateSummaryForFork(jsonlPath, summaryModel, includeThinkingIn
 	}
 }
 async function reserveSummaryForkSessionPromise(cwd) {
-	const { reserveForkSession } = await import("./session-fork-DZ12vipL.js");
+	const { reserveForkSession } = await import("./session-fork-DlEIAhRy.js");
 	return reserveForkSession(cwd);
 }
 async function copySessionFromCompactBoundaryPromise(sourcePath, destPath) {
-	const { copySessionForFork } = await import("./session-fork-DZ12vipL.js");
+	const { copySessionForFork } = await import("./session-fork-DlEIAhRy.js");
 	return copySessionForFork(sourcePath, destPath, { fullHistory: false });
 }
 /** Effect variant of generateFallbackSummary. */
@@ -521,4 +521,4 @@ var init_summary_fork = __esmMin((() => {
 //#endregion
 export { init_transcript_adapter as _, generateFallbackSummary as a, handoffPreconditionFallbackReason as c, prependFallbackFocus as d, requestHandoffFromAgent as f, getTranscriptAdapter as g, validateHandoffDoc as h, copySessionFromCompactBoundary as i, init_summary_fork as l, sanitizeHandoffDoc as m, HandoffValidationError as n, generateSummaryForFork as o, reserveSummaryForkSession as p, authorHandoffExternal as r, handoffFailureReason as s, HandoffStallError as t, logHandoffFallback as u };
 
-//# sourceMappingURL=summary-fork-CtCwBJ2Z.js.map
+//# sourceMappingURL=summary-fork-COqYpVa3.js.map