@overdeck/desktop 0.45.24 → 0.47.0

package/server/{rally-CyWT_lNO.js → rally-CPysR4T_.js}

@@ -1,6 +1,6 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { fr as TrackerError, mr as init_errors } from "./config-yaml-DySPNmKN.js";
-import { a as TrackerAuthError, n as init_rally_api, o as init_interface, r as IssueNotFoundError, t as RallyRestApi } from "./rally-api-C8e_1JRi.js";
+import { Fr as init_errors, Nr as TrackerError } from "./config-yaml-CxdwhAIA.js";
+import { a as TrackerAuthError, n as init_rally_api, o as init_interface, r as IssueNotFoundError, t as RallyRestApi } from "./rally-api-8Ptlp2os.js";
 import { Effect } from "effect";
 //#region ../../lib/tracker/rally.ts
 /**
@@ -504,4 +504,4 @@ var init_rally = __esmMin((() => {
 //#endregion
 export { init_rally as n, RallyTracker as t };
 
-//# sourceMappingURL=rally-CyWT_lNO.js.map
+//# sourceMappingURL=rally-CPysR4T_.js.map

package/server/rally-D_VW4bJv.js

@@ -0,0 +1,3 @@
+import { n as init_rally, t as RallyTracker } from "./rally-CPysR4T_.js";
+init_rally();
+export { RallyTracker };

package/server/{rally-api-C8e_1JRi.js → rally-api-8Ptlp2os.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { fr as TrackerError, mr as init_errors } from "./config-yaml-DySPNmKN.js";
+import { Fr as init_errors, Nr as TrackerError } from "./config-yaml-CxdwhAIA.js";
 import { Data, Effect } from "effect";
 //#region ../../lib/tracker/interface.ts
 /**
@@ -162,4 +162,4 @@ var init_rally_api = __esmMin((() => {
 //#endregion
 export { TrackerAuthError as a, NotImplementedError as i, init_rally_api as n, init_interface as o, IssueNotFoundError as r, RallyRestApi as t };
 
-//# sourceMappingURL=rally-api-C8e_1JRi.js.map
+//# sourceMappingURL=rally-api-8Ptlp2os.js.map

package/server/{rally-api-ClOSd-Tt.js → rally-api-CgosKdKL.js}

@@ -1,3 +1,3 @@
-import { n as init_rally_api, t as RallyRestApi } from "./rally-api-C8e_1JRi.js";
+import { n as init_rally_api, t as RallyRestApi } from "./rally-api-8Ptlp2os.js";
 init_rally_api();
 export { RallyRestApi };

package/server/{rally-client-sgtVqzNU.js → rally-client-CCX0hADj.js}

@@ -1,3 +1,3 @@
-import { i as init_rally_client, n as RallyClientLive, r as RallyClientOptionalLive, t as RallyClient } from "./rally-client-lc-nokqr.js";
+import { i as init_rally_client, n as RallyClientLive, r as RallyClientOptionalLive, t as RallyClient } from "./rally-client-iYMHWQD7.js";
 init_rally_client();
 export { RallyClient, RallyClientLive, RallyClientOptionalLive };

package/server/{rally-client-lc-nokqr.js → rally-client-iYMHWQD7.js}

@@ -1,6 +1,6 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { a as init_tracker_config, r as getRallyConfig } from "./tracker-config-G6latr8C.js";
-import { a as RateLimited, c as TrackerNotConfigured, d as init_typed_errors, r as IssueNotFound, s as TrackerApiError } from "./typed-errors-2BTMxkZq.js";
+import { a as init_tracker_config, r as getRallyConfig } from "./tracker-config-BcPMElRB.js";
+import { a as RateLimited, c as TrackerNotConfigured, d as init_typed_errors, r as IssueNotFound, s as TrackerApiError } from "./typed-errors-DyjseiB6.js";
 import { Context, Effect, Layer } from "effect";
 //#region services/rally-client.ts
 /**
@@ -46,7 +46,7 @@ function makeRallyClientImpl(config) {
 	let tracker = null;
 	async function getTracker() {
 		if (!tracker) {
-			const { RallyTracker } = await import("./rally-zhhtXuDP.js");
+			const { RallyTracker } = await import("./rally-D_VW4bJv.js");
 			tracker = new RallyTracker({
 				apiKey: config.apiKey,
 				server: config.server,
@@ -106,7 +106,7 @@ var init_rally_client = __esmMin((() => {
 	RallyClientLive = Layer.effect(RallyClient, Effect.gen(function* () {
 		const config = getRallyConfig();
 		if (!config) return yield* Effect.fail(new TrackerNotConfigured({ tracker: "rally" }));
-		const { RallyTracker } = yield* Effect.promise(() => import("./rally-zhhtXuDP.js"));
+		const { RallyTracker } = yield* Effect.promise(() => import("./rally-D_VW4bJv.js"));
 		const tracker = new RallyTracker({
 			apiKey: config.apiKey,
 			server: config.server,
@@ -158,4 +158,4 @@ var init_rally_client = __esmMin((() => {
 //#endregion
 export { init_rally_client as i, RallyClientLive as n, RallyClientOptionalLive as r, RallyClient as t };
 
-//# sourceMappingURL=rally-client-lc-nokqr.js.map
+//# sourceMappingURL=rally-client-iYMHWQD7.js.map

package/server/{reap-terminal-sessions-7KeHv1R1.js → reap-terminal-sessions-4Xg9NGA8.js}

@@ -1,4 +1,4 @@
-import { r as isRoleTerminal } from "./review-status-source-CxuEjLGg.js";
-import { i as selectAwaitingTestWorkSessions, o as selectMergedWorkSessions, s as selectNonMergedTerminalAdvancingSessions, t as init_reap_terminal_sessions } from "./reap-terminal-sessions-BtHPo6Xc.js";
+import { r as isRoleTerminal } from "./review-status-source-DIk1JSow.js";
+import { i as selectAwaitingTestWorkSessions, o as selectMergedWorkSessions, s as selectNonMergedTerminalAdvancingSessions, t as init_reap_terminal_sessions } from "./reap-terminal-sessions-Qf-9LVQc.js";
 init_reap_terminal_sessions();
 export { isRoleTerminal, selectAwaitingTestWorkSessions, selectMergedWorkSessions, selectNonMergedTerminalAdvancingSessions };

package/server/{reap-terminal-sessions-BtHPo6Xc.js → reap-terminal-sessions-Qf-9LVQc.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { n as init_review_status_source, r as isRoleTerminal, t as classifyAdvancingSessionLifecycle } from "./review-status-source-CxuEjLGg.js";
+import { n as init_review_status_source, r as isRoleTerminal, t as classifyAdvancingSessionLifecycle } from "./review-status-source-DIk1JSow.js";
 //#region ../../lib/cloister/reap-terminal-sessions.ts
 /**
 * Of the alive sessions, the ones belonging to `issueId`'s advancing `role`.
@@ -128,4 +128,4 @@ var init_reap_terminal_sessions = __esmMin((() => {
 //#endregion
 export { selectMergedAdvancingSessions as a, sessionsToReapForRole as c, selectAwaitingTestWorkSessions as i, isAwaitingTestReapable as n, selectMergedWorkSessions as o, isWorkReapable as r, selectNonMergedTerminalAdvancingSessions as s, init_reap_terminal_sessions as t };
 
-//# sourceMappingURL=reap-terminal-sessions-BtHPo6Xc.js.map
+//# sourceMappingURL=reap-terminal-sessions-Qf-9LVQc.js.map

package/server/{rebuild-stack-lwtsW0GO.js → rebuild-stack-CMdgaylx.js}

@@ -1,9 +1,9 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Tn as init_projects, yn as getProjectSync, zn as resolveProjectFromIssueSync } from "./config-yaml-DySPNmKN.js";
-import { d as init_docker_stats, f as recordDockerContainerLifecycleSnapshot, n as collectDockerContainerLifecycleSnapshot, o as hasIssueToken, r as composeProjectNameForWorkspace, s as init_stack_health } from "./stack-health-DxSdG9cW.js";
-import { n as init_issue_closed, r as isIssueClosed } from "./issue-closed-CDJk4pIp.js";
-import { n as reconcileTraefikNetworks, t as init_traefik_connect } from "./traefik-connect-Df2uXPsQ.js";
-import { n as ensureDevcontainerSync, r as init_ensure_devcontainer } from "./ensure-devcontainer-DNi-ono3.js";
+import { Gn as init_projects, ar as resolveProjectFromIssueSync, zn as getProjectSync } from "./config-yaml-CxdwhAIA.js";
+import { d as init_docker_stats, f as recordDockerContainerLifecycleSnapshot, n as collectDockerContainerLifecycleSnapshot, o as hasIssueToken, r as composeProjectNameForWorkspace, s as init_stack_health } from "./stack-health-DqLTiEu4.js";
+import { n as init_issue_closed, r as isIssueClosed } from "./issue-closed-BehTG1be.js";
+import { n as reconcileTraefikNetworks, t as init_traefik_connect } from "./traefik-connect-DZ6nMYMj.js";
+import { n as ensureDevcontainerSync, r as init_ensure_devcontainer } from "./ensure-devcontainer-BAofzBPv.js";
 import { dirname, join } from "node:path";
 import { Effect } from "effect";
 import { existsSync, rmSync } from "node:fs";
@@ -100,10 +100,19 @@ var init_rebuild_stack = __esmMin((() => {
 			error: `Workspace not found: ${workspacePath}`
 		});
 		return Effect.gen(function* () {
-			if (yield* Effect.promise(() => isIssueClosed(issueId))) return {
+			const closed = yield* Effect.promise(() => isIssueClosed(issueId));
+			const reviewStatus = closed ? null : yield* Effect.promise(async () => {
+				const { resolveCanonicalReviewStatus } = await import("./review-status-source-BLx_1siH.js");
+				return resolveCanonicalReviewStatus(issueId);
+			});
+			if (closed || reviewStatus?.status?.mergeStatus === "merged") return {
 				success: false,
 				error: "Issue is terminal (closed/merged) — skipping stack rebuild"
 			};
+			if (!reviewStatus?.available) return {
+				success: false,
+				error: "Issue terminal status is unavailable — skipping stack rebuild"
+			};
 			const composeProjectName = composeProjectNameForWorkspace(workspacePath, normalizedIssueId);
 			const existingComposeFile = findDevcontainerComposeFile(workspacePath);
 			if (existingComposeFile) {
@@ -175,4 +184,4 @@ var init_rebuild_stack = __esmMin((() => {
 //#endregion
 export { rebuildWorkspaceStack as n, removeStaleIssueContainers as r, init_rebuild_stack as t };
 
-//# sourceMappingURL=rebuild-stack-lwtsW0GO.js.map
+//# sourceMappingURL=rebuild-stack-CMdgaylx.js.map

package/server/{rebuild-stack-CFvcBHsS.js → rebuild-stack-DqcOVmJO.js}

@@ -1,4 +1,4 @@
-import "./stack-health-DxSdG9cW.js";
-import { n as rebuildWorkspaceStack, t as init_rebuild_stack } from "./rebuild-stack-lwtsW0GO.js";
+import "./stack-health-DqLTiEu4.js";
+import { n as rebuildWorkspaceStack, t as init_rebuild_stack } from "./rebuild-stack-CMdgaylx.js";
 init_rebuild_stack();
 export { rebuildWorkspaceStack };

package/server/{reconstruct-cache-C3Ui7ojV.js → reconstruct-cache-CMZJ_Vjq.js}

@@ -1,8 +1,9 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Ft as resolveProjectForIssue, Ot as init_record, Tn as init_projects, jt as readIssueRecord, kn as listProjectsSync } from "./config-yaml-DySPNmKN.js";
-import { c as listAllAgentsSync, o as init_agents, r as backfillAgentsSync } from "./agents-EbI0zCJl.js";
-import { b as init_agents$1, i as listRunningAgents } from "./queries-CjNIf-Ub.js";
-import { a as gatherProjectLensSignalsForProjects, i as gatherProjectLensSignals, n as init_pipeline_membership, o as init_pipeline_membership_gather, r as resolvePipelineMembership } from "./pipeline-membership-mY3GprlK.js";
+import { Gn as init_projects, Lt as readIssueRecord, Pt as init_record, Vt as resolveProjectForIssue, Yn as listProjectsSync } from "./config-yaml-CxdwhAIA.js";
+import { c as listAllAgentsSync, o as init_agents, r as backfillAgentsSync } from "./agents-J5mEnekq.js";
+import { b as init_agents$1, i as listRunningAgents } from "./queries-C-MUZaIy.js";
+import { a as gatherProjectLensSignals, o as gatherProjectLensSignalsForProjects, s as init_pipeline_membership_gather } from "./pipeline-membership-gather-CeVGnNJ2.js";
+import { n as init_pipeline_membership, r as resolvePipelineMembership } from "./pipeline-membership-D9SBvItj.js";
 import { Effect } from "effect";
 //#region ../../lib/reconstruct/enumerate-in-flight.ts
 async function enumerateInFlightIssuesFromSources(projects, gather = gatherProjectLensSignals) {
@@ -138,7 +139,7 @@ async function loadInFlightIssueIds(projects) {
 	return enumerateInFlightIssuesFromSources(projects);
 }
 async function fetchPrState(issueId) {
-	const { fetchIssuePullRequest } = await import("./pull-requests-7N8WKseP.js");
+	const { fetchIssuePullRequest } = await import("./pull-requests-Dq0y6IxE.js");
 	const result = await fetchIssuePullRequest(issueId);
 	if (!result.pr) return {
 		hasPr: false,
@@ -157,7 +158,7 @@ async function fetchPrState(issueId) {
 */
 async function reconstructCache(_db, opts) {
 	const verbose = opts?.verbose ?? false;
-	const { processed: agentsRebuilt } = backfillAgentsSync({
+	const { processed: agentsRebuilt, markedStoppedIds = [] } = backfillAgentsSync({
 		verbose,
 		listLiveSessions: opts?.listLiveSessions
 	});
@@ -248,6 +249,7 @@ async function reconstructCache(_db, opts) {
 	return {
 		issuesEnumerated: inFlight.size,
 		agentsRebuilt,
+		markedStoppedIds,
 		phaseCounts,
 		agentRuntimeById,
 		agentsById,
@@ -269,4 +271,4 @@ __esmMin((() => {
 }))();
 export { reconstructCache, reconstructCacheAuto };
 
-//# sourceMappingURL=reconstruct-cache-C3Ui7ojV.js.map
+//# sourceMappingURL=reconstruct-cache-CMZJ_Vjq.js.map

package/server/record-BTwWhtBb.js

@@ -0,0 +1,3 @@
+import { $t as writeRecordResumePointSync, At as getIssueRecordPath, Bt as readRecordContinueViewSync, Ct as buildOwnUri, Dt as ensureIssueRecord, Et as clearRecordFeedbackSync, Ft as markRecordPipelineClosedOutSync, Gt as writeCloseOutDodGateSync, Ht as writeAgentHarnessModel, It as queueIssueRecordCommit, Jt as writeRecordDecisions, Kt as writeIssueRecordForWorkspaceSync, Lt as readIssueRecord, Mt as getIssueWorkspacePath, Nt as getProjectConfigFromWorkspacePath, Ot as ensureIssueRecordSync, Pt as init_record, Qt as writeRecordResumePoint, Rt as readIssueRecordForWorkspaceSync, St as appendSessionEntrySync, Tt as clearIssueOwner, Ut as writeAgentHarnessModelSync, Vt as resolveProjectForIssue, Wt as writeCloseOutDodGate, Xt as writeRecordHazards, Yt as writeRecordDecisionsSync, Zt as writeRecordHazardsSync, _t as RECORD_DIRNAME, an as writeStatusOverridesSync, bt as appendFeedbackEntrySync, en as writeRecordScopeDriftSync, in as writeStatusOverrideSync, jt as getIssueRecordPathForWorkspace, kt as getIssueRecordBasePath, nn as writeRecordTieredExecutionOverrideSync, qt as writeIssueRecordSync, rn as writeStatusOverride, tn as writeRecordTieredExecutionOverride, vt as RECORD_SCHEMA_VERSION, wt as claimIssueOwner, xt as appendSessionEntry, yt as appendFeedbackEntry, zt as readIssueRecordSync } from "./config-yaml-CxdwhAIA.js";
+init_record();
+export { RECORD_DIRNAME, RECORD_SCHEMA_VERSION, appendFeedbackEntry, appendFeedbackEntrySync, appendSessionEntry, appendSessionEntrySync, buildOwnUri, claimIssueOwner, clearIssueOwner, clearRecordFeedbackSync, ensureIssueRecord, ensureIssueRecordSync, getIssueRecordBasePath, getIssueRecordPath, getIssueRecordPathForWorkspace, getIssueWorkspacePath, getProjectConfigFromWorkspacePath, markRecordPipelineClosedOutSync, queueIssueRecordCommit, readIssueRecord, readIssueRecordForWorkspaceSync, readIssueRecordSync, readRecordContinueViewSync, resolveProjectForIssue, writeAgentHarnessModel, writeAgentHarnessModelSync, writeCloseOutDodGate, writeCloseOutDodGateSync, writeIssueRecordForWorkspaceSync, writeIssueRecordSync, writeRecordDecisions, writeRecordDecisionsSync, writeRecordHazards, writeRecordHazardsSync, writeRecordResumePoint, writeRecordResumePointSync, writeRecordScopeDriftSync, writeRecordTieredExecutionOverride, writeRecordTieredExecutionOverrideSync, writeStatusOverride, writeStatusOverrideSync, writeStatusOverridesSync };

package/server/{record-update-dE1Aw83j.js → record-update-DaOKS7Wb.js}

@@ -1,151 +1,80 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { At as queueIssueRecordCommit, Br as getOverdeckHome, Dt as getProjectConfigFromWorkspacePath, Ft as resolveProjectForIssue, Ht as flushAutoCommits, Nt as readIssueRecordSync, Ot as init_record, Rt as writeIssueRecordSync, St as ensureIssueRecordSync, Tn as init_projects, Ut as init_auto_commit, Vr as init_paths, kn as listProjectsSync, nn as init_state_read_home, rn as resolveStateReadHomeSync, tn as STATE_BRANCH, wt as getIssueRecordPath } from "./config-yaml-DySPNmKN.js";
-import { dirname, join, relative } from "node:path";
+import { At as getIssueRecordPath, Cn as resolveStateReadHomeSync, It as queueIssueRecordCommit, Nt as getProjectConfigFromWorkspacePath, Ot as ensureIssueRecordSync, Pt as init_record, Sn as init_state_read_home, Vt as resolveProjectForIssue, cn as flushAutoCommits, ln as init_auto_commit, qt as writeIssueRecordSync, xn as STATE_BRANCH, zt as readIssueRecordSync } from "./config-yaml-CxdwhAIA.js";
+import { a as withRecordFsLock, n as init_fs_lock } from "./fs-lock-Bre3sGoz.js";
+import { relative } from "node:path";
 import { Effect } from "effect";
 import { hostname } from "node:os";
-import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-//#region ../../lib/pan-dir/fs-lock.ts
-/** Cross-process per-issue record locking (PAN-2648 CD-2). */
-function safeSegment(value) {
-	return value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
-}
-function recordLockPath(project, issueId) {
-	const configuredKey = listProjectsSync().find(({ config }) => config.path === project.path)?.key;
-	const projectKey = safeSegment(configuredKey ?? project.name ?? project.path) || "unknown-project";
-	return join(getOverdeckHome(), "locks", "records", projectKey, `${issueId.toUpperCase()}.lock`);
-}
-function isPidDead(pid) {
-	if (!pid || pid <= 0 || pid === process.pid) return false;
-	try {
-		process.kill(pid, 0);
-		return false;
-	} catch (error) {
-		return error.code === "ESRCH";
-	}
-}
-async function sweepRecordTmpFiles(recordPath) {
-	try {
-		const dir = dirname(recordPath);
-		const base = recordPath.slice(dir.length + 1);
-		const entries = await readdir(dir);
-		await Promise.all(entries.filter((entry) => entry.startsWith(`${base}.`) && entry.endsWith(".tmp")).map((entry) => rm(join(dir, entry), { force: true })));
-	} catch {}
-}
-async function readOwner(lockPath) {
-	try {
-		const owner = JSON.parse(await readFile(join(lockPath, "owner.json"), "utf8"));
-		return {
-			description: `${owner.writerId ?? "unknown writer"} pid=${owner.pid ?? "unknown"} acquiredAt=${owner.acquiredAt ?? "unknown"}`,
-			pid: owner.pid
-		};
-	} catch {
-		return { description: "unknown writer" };
-	}
+//#region ../../lib/pan-dir/record-update.ts
+/** The single locked read-modify-write door for per-issue records. */
+function recordDurabilityBudgetMs() {
+	const parsed = Number(process.env.OVERDECK_RECORD_DURABILITY_BUDGET_MS);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_RECORD_DURABILITY_BUDGET_MS;
 }
-async function acquireRecordLock(lockPath, options) {
-	await mkdir(dirname(lockPath), {
-		recursive: true,
-		mode: 448
-	});
-	const delays = options.retryDelaysMs ?? RECORD_LOCK_RETRY_DELAYS_MS;
-	let lastOwner = "unknown writer";
-	for (let attempt = 0; attempt <= delays.length; attempt += 1) {
-		try {
-			await mkdir(lockPath, { mode: 448 });
-			const owner = {
-				writerId: options.writerId,
-				pid: process.pid,
-				acquiredAt: (/* @__PURE__ */ new Date()).toISOString()
-			};
-			try {
-				await writeFile(join(lockPath, "owner.json"), JSON.stringify(owner, null, 2), "utf8");
-			} catch (error) {
-				try {
-					await rm(lockPath, {
-						recursive: true,
-						force: true
-					});
-				} catch {}
-				throw error;
-			}
-			await sweepRecordTmpFiles(options.recordPath);
-			return owner;
-		} catch (error) {
-			if (error.code !== "EEXIST") throw error;
-			const owner = await readOwner(lockPath);
-			lastOwner = owner.description;
-			if (isPidDead(owner.pid)) {
-				await rm(lockPath, {
-					recursive: true,
-					force: true
-				});
-				continue;
-			}
-		}
-		const delay = delays[attempt];
-		if (delay === void 0) break;
-		await new Promise((resolve) => setTimeout(resolve, delay));
+async function withRecordDurabilityDeadline(issueId, promise, deadlineMs, budgetMs, onTimeout) {
+	const remaining = deadlineMs - Date.now();
+	if (remaining <= 0) {
+		await onTimeout?.().catch(() => void 0);
+		throw new RecordDurabilityTimeoutError(issueId, budgetMs);
 	}
-	throw new RecordLockError(lockPath, lastOwner);
-}
-async function releaseRecordLock(lockPath) {
-	await rm(lockPath, {
-		recursive: true,
-		force: true
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		let timingOut = false;
+		const timer = setTimeout(() => {
+			timingOut = true;
+			(onTimeout?.() ?? Promise.resolve()).catch(() => void 0).finally(() => {
+				settled = true;
+				reject(new RecordDurabilityTimeoutError(issueId, budgetMs));
+			});
+		}, remaining);
+		timer.unref?.();
+		promise.then((value) => {
+			if (settled || timingOut) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve(value);
+		}, (error) => {
+			if (settled || timingOut) return;
+			settled = true;
+			clearTimeout(timer);
+			reject(error);
+		});
 	});
 }
-async function withRecordFsLock(project, issueId, options, operation) {
-	const lockPath = recordLockPath(project, issueId);
-	await acquireRecordLock(lockPath, options);
-	try {
-		return await operation();
-	} finally {
-		await releaseRecordLock(lockPath);
-	}
-}
-var RECORD_LOCK_RETRY_DELAYS_MS, RecordLockError;
-var init_fs_lock = __esmMin((() => {
-	init_paths();
-	init_projects();
-	RECORD_LOCK_RETRY_DELAYS_MS = [
-		5,
-		10,
-		20,
-		40,
-		80,
-		160,
-		320,
-		360
-	];
-	RecordLockError = class extends Error {
-		constructor(lockPath, owner) {
-			super(`The per-issue record lock at ${lockPath} is held by ${owner}. Retry the command after that writer finishes.`);
-			this.lockPath = lockPath;
-			this.owner = owner;
-			this.name = "RecordLockError";
-		}
-	};
-}));
-//#endregion
-//#region ../../lib/pan-dir/record-update.ts
-/** The single locked read-modify-write door for per-issue records. */
 function updateIssueRecordForWorkspace(workspacePath, issueId, mutator, options = {}) {
 	return updateIssueRecord(resolveProjectForIssue(issueId) ?? getProjectConfigFromWorkspacePath(workspacePath), issueId, mutator, options);
 }
-async function git(gitRoot, args) {
+/**
+* Clear the terminal close-out marker so a reopened issue re-enters the pipeline (sync).
+* Ordinary status writes deliberately preserve closedOut (projectPipeline in records.ts),
+* so reopen needs this explicit inverse of markRecordPipelineClosedOutSync in record.ts
+* (MIN-850, 2026-07-24).
+*/
+function clearRecordPipelineClosedOutSync(project, issueId) {
+	const record = ensureIssueRecordSync(project, issueId);
+	if (!record.pipeline.closedOut && !record.pipeline.closedOutAt) return;
+	record.pipeline.closedOut = void 0;
+	record.pipeline.closedOutAt = void 0;
+	record.pipeline.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	queueIssueRecordCommit(project, issueId, writeIssueRecordSync(project, issueId, record));
+}
+async function git(gitRoot, args, options = {}) {
 	return (await execFileAsync("git", args, {
 		cwd: gitRoot,
 		encoding: "utf8",
-		timeout: 3e4,
+		timeout: options.timeoutMs ?? 3e4,
 		maxBuffer: 16 * 1024 * 1024,
 		env: {
 			...process.env,
 			HUSKY: "0"
-		}
+		},
+		...options.signal ? { signal: options.signal } : {}
 	})).stdout.trim();
 }
+function throwIfDurabilityAborted(signal) {
+	if (signal?.aborted) throw new Error("Record durability operation aborted at the deadline");
+}
 function gitFailureMessage(error) {
 	if (error && typeof error === "object") {
 		const failure = error;
@@ -156,18 +85,21 @@ function gitFailureMessage(error) {
 function isRemoteRefRaceError(message) {
 	return /non-fast-forward|fetch first|stale info|cannot lock ref.*expected|failed to update ref/i.test(message);
 }
-async function abortRebase(gitRoot) {
+async function abortRebase(gitRoot, options = {}) {
 	try {
-		await git(gitRoot, ["rebase", "--abort"]);
+		await git(gitRoot, ["rebase", "--abort"], {
+			timeoutMs: 5e3,
+			...options
+		});
 	} catch {}
 }
-async function replayConflictedRecord(project, issueId, mutator, gitRoot, recordPath) {
+async function replayConflictedRecord(project, issueId, mutator, gitRoot, recordPath, signal) {
 	const relativeRecordPath = relative(gitRoot, recordPath).replace(/\\/g, "/");
 	const conflicts = (await git(gitRoot, [
 		"diff",
 		"--name-only",
 		"--diff-filter=U"
-	])).split("\n").map((path) => path.trim()).filter(Boolean);
+	], { signal })).split("\n").map((path) => path.trim()).filter(Boolean);
 	if (conflicts.length !== 1 || conflicts[0] !== relativeRecordPath) throw new Error(`state rebase conflicted outside ${relativeRecordPath}: ${conflicts.join(", ") || "unknown conflict"}`);
 	await git(gitRoot, [
 		"restore",
@@ -175,43 +107,49 @@ async function replayConflictedRecord(project, issueId, mutator, gitRoot, record
 		"--worktree",
 		"--",
 		relativeRecordPath
-	]);
+	], { signal });
 	const remoteRecord = readIssueRecordSync(project, issueId);
 	if (!remoteRecord) throw new Error(`Remote ${issueId} state record is unreadable`);
-	writeIssueRecordSync(project, issueId, await mutator(remoteRecord) ?? remoteRecord);
+	const result = await mutator(remoteRecord);
+	throwIfDurabilityAborted(signal);
+	writeIssueRecordSync(project, issueId, result ?? remoteRecord);
 	await git(gitRoot, [
 		"add",
 		"--",
 		relativeRecordPath
-	]);
+	], { signal });
+	throwIfDurabilityAborted(signal);
 	await git(gitRoot, [
 		"-c",
 		"core.editor=true",
 		"rebase",
 		"--continue"
-	]);
+	], { signal });
 }
-async function restoreRetryableRecord(project, issueId, original, recordPath) {
+async function restoreRetryableRecord(project, issueId, original, recordPath, signal) {
 	const stateHome = resolveStateReadHomeSync(project);
 	const gitRoot = stateHome.root;
 	const relativeRecordPath = relative(gitRoot, recordPath).replace(/\\/g, "/");
-	await abortRebase(gitRoot);
+	await abortRebase(gitRoot, { signal });
 	let restored = structuredClone(original);
-	const branch = stateHome.migrated ? STATE_BRANCH : await git(gitRoot, ["branch", "--show-current"]);
+	const branch = stateHome.migrated ? STATE_BRANCH : await git(gitRoot, ["branch", "--show-current"], { signal });
 	try {
 		await git(gitRoot, [
 			"fetch",
 			"origin",
 			branch
-		]);
-		restored = JSON.parse(await git(gitRoot, ["show", `origin/${branch}:${relativeRecordPath}`]));
-	} catch {}
+		], { signal });
+		restored = JSON.parse(await git(gitRoot, ["show", `origin/${branch}:${relativeRecordPath}`], { signal }));
+	} catch (fetchError) {
+		throwIfDurabilityAborted(signal);
+	}
+	throwIfDurabilityAborted(signal);
 	writeIssueRecordSync(project, issueId, restored);
 	await git(gitRoot, [
 		"add",
 		"--",
 		relativeRecordPath
-	]);
+	], { signal });
 	try {
 		await git(gitRoot, [
 			"diff",
@@ -219,32 +157,36 @@ async function restoreRetryableRecord(project, issueId, original, recordPath) {
 			"--quiet",
 			"--",
 			relativeRecordPath
-		]);
+		], { signal });
 		return;
-	} catch {}
+	} catch (diffError) {
+		throwIfDurabilityAborted(signal);
+	}
 	await git(gitRoot, [
 		"commit",
 		"-m",
 		`chore(records): restore ${issueId} after failed state push`,
 		"--",
 		relativeRecordPath
-	]);
+	], { signal });
 }
-async function reconcileStatePush(project, issueId, mutator, recordPath) {
+async function reconcileStatePush(project, issueId, mutator, recordPath, signal) {
 	const gitRoot = resolveStateReadHomeSync(project).root;
 	for (let attempt = 0; attempt < MAX_STATE_PUSH_RECONCILIATIONS; attempt += 1) {
+		throwIfDurabilityAborted(signal);
 		await git(gitRoot, [
 			"fetch",
 			"origin",
 			STATE_BRANCH
-		]);
+		], { signal });
 		try {
-			await git(gitRoot, ["rebase", `origin/${STATE_BRANCH}`]);
+			await git(gitRoot, ["rebase", `origin/${STATE_BRANCH}`], { signal });
 		} catch (error) {
+			throwIfDurabilityAborted(signal);
 			try {
-				await replayConflictedRecord(project, issueId, mutator, gitRoot, recordPath);
+				await replayConflictedRecord(project, issueId, mutator, gitRoot, recordPath, signal);
 			} catch (replayError) {
-				await abortRebase(gitRoot);
+				await abortRebase(gitRoot, { signal });
 				throw new Error(`Failed to reconcile ${issueId} state after push race: ${gitFailureMessage(replayError)}`, { cause: error });
 			}
 		}
@@ -253,11 +195,12 @@ async function reconcileStatePush(project, issueId, mutator, recordPath) {
 				"push",
 				"origin",
 				STATE_BRANCH
-			]);
+			], { signal });
 			const record = readIssueRecordSync(project, issueId);
 			if (!record) throw new Error(`Reconciled ${issueId} state record is unreadable`);
 			return record;
 		} catch (error) {
+			throwIfDurabilityAborted(signal);
 			const message = gitFailureMessage(error);
 			if (!isRemoteRefRaceError(message)) throw new Error(`Failed to push reconciled ${issueId} state: ${message}`, { cause: error });
 		}
@@ -276,26 +219,43 @@ async function updateIssueRecord(project, issueId, mutator, options = {}) {
 		const next = await mutator(current) ?? current;
 		const path = writeIssueRecordSync(project, normalizedIssueId, next);
 		if (options.autoCommit === false) return readIssueRecordSync(project, normalizedIssueId) ?? next;
+		const budgetMs = recordDurabilityBudgetMs();
+		const deadlineMs = Date.now() + budgetMs;
 		try {
 			const commitRoot = queueIssueRecordCommit(project, normalizedIssueId, path);
-			const flushed = await Effect.runPromise(flushAutoCommits(commitRoot));
+			const flushed = await withRecordDurabilityDeadline(normalizedIssueId, Effect.runPromise(flushAutoCommits(commitRoot)), deadlineMs, budgetMs);
 			if (flushed.pushed === false) {
-				if (resolveStateReadHomeSync(project).migrated && isRemoteRefRaceError(flushed.reason ?? "")) return await reconcileStatePush(project, normalizedIssueId, mutator, path);
+				if (resolveStateReadHomeSync(project).migrated && isRemoteRefRaceError(flushed.reason ?? "")) {
+					const reconcileAbort = new AbortController();
+					const reconcilePromise = reconcileStatePush(project, normalizedIssueId, mutator, path, reconcileAbort.signal);
+					return await withRecordDurabilityDeadline(normalizedIssueId, reconcilePromise, deadlineMs, budgetMs, async () => {
+						reconcileAbort.abort();
+						await reconcilePromise.catch(() => void 0);
+						await abortRebase(resolveStateReadHomeSync(project).root);
+					});
+				}
 				throw new Error(`Failed to push ${normalizedIssueId} state: ${flushed.reason ?? "unknown push failure"}`);
 			}
 			if (!flushed.committed && !["no diff", "no pending"].includes(flushed.reason ?? "")) throw new Error(`Failed to commit ${normalizedIssueId} state: ${flushed.reason ?? "unknown commit failure"}`);
 			return readIssueRecordSync(project, normalizedIssueId) ?? next;
 		} catch (error) {
+			if (error instanceof RecordDurabilityTimeoutError) throw error;
 			try {
-				await restoreRetryableRecord(project, normalizedIssueId, original, path);
+				const restoreAbort = new AbortController();
+				const restorePromise = restoreRetryableRecord(project, normalizedIssueId, original, path, restoreAbort.signal);
+				await withRecordDurabilityDeadline(normalizedIssueId, restorePromise, deadlineMs, budgetMs, async () => {
+					restoreAbort.abort();
+					await restorePromise.catch(() => void 0);
+				});
 			} catch (restoreError) {
+				if (restoreError instanceof RecordDurabilityTimeoutError) throw restoreError;
 				throw new Error(`Failed to persist ${normalizedIssueId} state and restore retryability: ${gitFailureMessage(restoreError)}`, { cause: error });
 			}
 			throw error;
 		}
 	});
 }
-var execFileAsync, MAX_STATE_PUSH_RECONCILIATIONS;
+var execFileAsync, MAX_STATE_PUSH_RECONCILIATIONS, DEFAULT_RECORD_DURABILITY_BUDGET_MS, RecordDurabilityTimeoutError;
 var init_record_update = __esmMin((() => {
 	init_state_read_home();
 	init_auto_commit();
@@ -303,8 +263,15 @@ var init_record_update = __esmMin((() => {
 	init_record();
 	execFileAsync = promisify(execFile);
 	MAX_STATE_PUSH_RECONCILIATIONS = 3;
+	DEFAULT_RECORD_DURABILITY_BUDGET_MS = 3e4;
+	RecordDurabilityTimeoutError = class extends Error {
+		constructor(issueId, budgetMs) {
+			super(`Durability wait for ${issueId} state exceeded ${budgetMs}ms; releasing the record lock. The mutation remains in the local record and the flush continues in the background; callers with a fallback (e.g. the review-verdict fallback and drain) reconcile through it, other writers must retry the write.`);
+			this.name = "RecordDurabilityTimeoutError";
+		}
+	};
 }));
 //#endregion
-export { isPidDead as a, init_fs_lock as i, updateIssueRecord as n, updateIssueRecordForWorkspace as r, init_record_update as t };
+export { updateIssueRecordForWorkspace as a, updateIssueRecord as i, clearRecordPipelineClosedOutSync as n, init_record_update as r, RecordDurabilityTimeoutError as t };
 
-//# sourceMappingURL=record-update-dE1Aw83j.js.map
+//# sourceMappingURL=record-update-DaOKS7Wb.js.map

package/server/record-update-DhI7eySG.js

@@ -0,0 +1,3 @@
+import { i as updateIssueRecord, r as init_record_update } from "./record-update-DaOKS7Wb.js";
+init_record_update();
+export { updateIssueRecord };

package/server/{recovery-trip-BvRWfUXM.js → recovery-trip-DDH-02ng.js}

@@ -1,4 +1,4 @@
-import { r as updateIssueRecordForWorkspace, t as init_record_update } from "./record-update-dE1Aw83j.js";
+import { a as updateIssueRecordForWorkspace, r as init_record_update } from "./record-update-DaOKS7Wb.js";
 //#region ../../lib/cloister/recovery-trip.ts
 init_record_update();
 async function recordRecoveryFailure(workspacePath, issue, recoveryPath, obligationGeneration, threshold = 25, now = /* @__PURE__ */ new Date()) {
@@ -41,4 +41,4 @@ async function recordRecoveryFailure(workspacePath, issue, recoveryPath, obligat
 //#endregion
 export { recordRecoveryFailure as t };
 
-//# sourceMappingURL=recovery-trip-BvRWfUXM.js.map
+//# sourceMappingURL=recovery-trip-DDH-02ng.js.map