@overdeck/desktop 0.45.24 → 0.47.0

package/server/{pan-dir-B0c3w0Ya.js → pan-dir-DMzF5wne.js}

@@ -1,10 +1,10 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Ht as flushAutoCommits, Ut as init_auto_commit, Wt as queueAutoCommit, ir as FsError, mr as init_errors } from "./config-yaml-DySPNmKN.js";
-import { p as init_types } from "./types-hraoaQIp.js";
-import { C as init_specs, F as getReadableWorkspacePanPaths, I as getWorkspacePanPaths, L as init_continue, N as ensureWorkspacePanDir, P as getLegacyWorkspacePanPaths, S as getProjectPanPaths, b as ensurePanDirs } from "./io-C9kF1wtJ.js";
+import { Fr as init_errors, Tr as FsError, cn as flushAutoCommits, ln as init_auto_commit, un as queueAutoCommit } from "./config-yaml-CxdwhAIA.js";
+import { p as init_types } from "./types-Cm5ASJbq.js";
+import { F as getReadableWorkspacePanPaths, I as getWorkspacePanPaths, L as init_continue, M as getProjectPanPaths, N as ensureWorkspacePanDir, P as getLegacyWorkspacePanPaths, S as init_specs, b as ensurePanDirs } from "./io-B00PBNku.js";
 import { Effect, FileSystem } from "effect";
 import { join } from "path";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, rmSync } from "node:fs";
 import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
 //#region ../../lib/pan-dir/sessions.ts
 var init_sessions = __esmMin((() => {
@@ -184,6 +184,12 @@ function checkPrdGateSync(args) {
 *
 * No-loss rule: an existing canonical draft is never overwritten — the
 * canonical copy may carry operator edits the workspace copy predates.
+*
+* A successful promotion also removes the workspace copy: the identical content
+* is committed and pushed on the state plane, and the leftover untracked file
+* tripped the spawn-time dirty-workspace gate, stranding the planning→work
+* auto-handoff with `planning_auto_handoff_failed` (PAN-3042). Removal is
+* best-effort — the spawn gate exempts Overdeck-owned `.pan/` paths anyway.
 */
 function promoteWorkspacePrdDraft(args) {
 	return Effect.suspend(() => {
@@ -212,12 +218,20 @@ function promoteWorkspacePrdDraft(args) {
 				cause
 			}));
 		}
-		return writeIssueDraft(projectRoot, issueId, content).pipe(Effect.map((path) => ({
-			promoted: true,
-			reason: "promoted",
-			path,
-			source
-		})));
+		return writeIssueDraft(projectRoot, issueId, content).pipe(Effect.map((path) => {
+			let sourceRemoved = false;
+			try {
+				rmSync(source);
+				sourceRemoved = true;
+			} catch {}
+			return {
+				promoted: true,
+				reason: "promoted",
+				path,
+				source,
+				sourceRemoved
+			};
+		}));
 	});
 }
 var init_drafts = __esmMin((() => {
@@ -277,4 +291,4 @@ var init_pan_dir = __esmMin((() => {
 //#endregion
 export { getDraftPath as a, clearFeedback as c, checkPrdGateSync as i, readFeedback as l, readWorkspaceContext as n, getIssueDraftPath as o, writeWorkspaceContext as r, promoteWorkspacePrdDraft as s, init_pan_dir as t, writeFeedback as u };
 
-//# sourceMappingURL=pan-dir-B0c3w0Ya.js.map
+//# sourceMappingURL=pan-dir-DMzF5wne.js.map

package/server/{paths-D-xWGHdh.js → paths-sJBSb7Ul.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Br as getOverdeckHome, Vr as init_paths$1 } from "./config-yaml-DySPNmKN.js";
+import { ci as getOverdeckHome, li as init_paths$1 } from "./config-yaml-CxdwhAIA.js";
 import { dirname, isAbsolute, join, relative, resolve } from "path";
 import { mkdir } from "fs/promises";
 //#region ../../lib/memory/paths.ts
@@ -62,4 +62,4 @@ var init_paths = __esmMin((() => {
 //#endregion
 export { resolveArchiveDir as a, resolveMemoryRoot as c, resolveRagRunsFile as d, resolveStatusFile as f, init_paths as i, resolveObservationsFile as l, ensureDir as n, resolveFtsDbPath as o, resolveSummariesDir as p, ensureParentDir as r, resolveIssueMemoryRoot as s, assertMemorySafeSegment as t, resolvePendingDir as u };
 
-//# sourceMappingURL=paths-D-xWGHdh.js.map
+//# sourceMappingURL=paths-sJBSb7Ul.js.map

package/server/pending-lifecycle-claim-DilzGfgk.js

@@ -0,0 +1,110 @@
+import { n as init_review_status_source, s as resolveCanonicalReviewStatus } from "./review-status-source-DIk1JSow.js";
+import { basename, dirname, join } from "node:path";
+import { readFile, readdir, rename, unlink } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+//#region ../../lib/cloister/pending-lifecycle-claim.ts
+init_review_status_source();
+function isMissing(error) {
+	return error?.code === "ENOENT";
+}
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function findRecoverableLifecycleFiles(pendingFile) {
+	const directory = dirname(pendingFile);
+	const name = basename(pendingFile);
+	let entries;
+	try {
+		entries = await readdir(directory);
+	} catch (error) {
+		if (isMissing(error)) return [];
+		throw error;
+	}
+	const queuedPrefix = `${name}.queued-`;
+	const claimedPrefix = `${name}.claimed-`;
+	const queued = [];
+	const abandoned = [];
+	for (const entry of entries.sort()) {
+		if (entry.startsWith(queuedPrefix)) {
+			queued.push(join(directory, entry));
+			continue;
+		}
+		if (!entry.startsWith(claimedPrefix)) continue;
+		const ownerPid = Number.parseInt(entry.slice(claimedPrefix.length).split("-")[0], 10);
+		if (Number.isInteger(ownerPid) && ownerPid > 0 && !isProcessAlive(ownerPid)) abandoned.push(join(directory, entry));
+	}
+	return [...queued, ...abandoned];
+}
+async function acquireClaimPath(pendingFile, claimPath) {
+	try {
+		await rename(pendingFile, claimPath);
+		return true;
+	} catch (error) {
+		if (!isMissing(error)) throw error;
+	}
+	for (const recoverablePath of await findRecoverableLifecycleFiles(pendingFile)) try {
+		await rename(recoverablePath, claimPath);
+		return true;
+	} catch (error) {
+		if (!isMissing(error)) throw error;
+	}
+	return false;
+}
+async function claimPendingLifecycleFile(pendingFile) {
+	const claimPath = `${pendingFile}.claimed-${process.pid}-${randomUUID()}`;
+	if (!await acquireClaimPath(pendingFile, claimPath)) return null;
+	let settled = false;
+	const removeClaim = async () => {
+		try {
+			await unlink(claimPath);
+		} catch (error) {
+			if (!isMissing(error)) throw error;
+		}
+		settled = true;
+	};
+	const queueClaim = async () => {
+		await rename(claimPath, `${pendingFile}.queued-${randomUUID()}`);
+		settled = true;
+	};
+	try {
+		return {
+			path: claimPath,
+			raw: await readFile(claimPath, "utf-8"),
+			discard: async () => {
+				if (settled) return;
+				await removeClaim();
+			},
+			restore: async () => {
+				if (settled) return;
+				await queueClaim();
+			}
+		};
+	} catch (error) {
+		try {
+			await queueClaim();
+		} catch {}
+		throw error;
+	}
+}
+async function settlePendingLifecycleClaim(claim, issueId, succeeded) {
+	if (succeeded) {
+		await claim.discard();
+		return "discarded";
+	}
+	const canonical = resolveCanonicalReviewStatus(issueId);
+	if (canonical.available && canonical.status?.mergeStatus === "merged" && (canonical.status.mergeStep === "post-merge-cleanup" || canonical.status.mergeStep === "merged")) {
+		await claim.discard();
+		return "discarded";
+	}
+	await claim.restore();
+	return "queued";
+}
+//#endregion
+export { settlePendingLifecycleClaim as n, claimPendingLifecycleFile as t };
+
+//# sourceMappingURL=pending-lifecycle-claim-DilzGfgk.js.map

package/server/persistent-logger-H_VjuOu7.js

@@ -0,0 +1,57 @@
+import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
+import { ci as getOverdeckHome, li as init_paths } from "./config-yaml-CxdwhAIA.js";
+import "effect";
+import { appendFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import "fs/promises";
+//#region ../../lib/persistent-logger.ts
+/**
+* Append-only persistent logger for forensic audit trails.
+*
+* Complements the SQLite event store (activity-logger.ts) with flat-file logs
+* that survive event-store resets and are greppable from the shell.
+*
+* Files:
+*   ~/.overdeck/logs/deacon.log        — deacon startup recovery actions
+*   ~/.overdeck/agents/<id>/lifecycle.log — per-agent state transitions
+*/
+function logsDir() {
+	return join(getOverdeckHome(), "logs");
+}
+function agentDir(agentId) {
+	return join(getOverdeckHome(), "agents", agentId);
+}
+function ensureLogsDir() {
+	try {
+		mkdirSync(logsDir(), { recursive: true });
+	} catch {}
+}
+function ensureAgentDir(agentId) {
+	try {
+		mkdirSync(agentDir(agentId), { recursive: true });
+	} catch {}
+}
+function timestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+/** Append a line to ~/.overdeck/logs/deacon.log */
+function logDeaconEventSync(message) {
+	ensureLogsDir();
+	try {
+		appendFileSync(join(logsDir(), "deacon.log"), `[${timestamp()}] ${message}\n`);
+	} catch {}
+}
+/** Append a line to ~/.overdeck/agents/<agentId>/lifecycle.log */
+function logAgentLifecycleSync(agentId, message) {
+	ensureAgentDir(agentId);
+	try {
+		appendFileSync(join(agentDir(agentId), "lifecycle.log"), `[${timestamp()}] ${message}\n`);
+	} catch {}
+}
+var init_persistent_logger = __esmMin((() => {
+	init_paths();
+}));
+//#endregion
+export { logAgentLifecycleSync as n, logDeaconEventSync as r, init_persistent_logger as t };
+
+//# sourceMappingURL=persistent-logger-H_VjuOu7.js.map

package/server/{pickup-DUCLWrJY.js → pickup-DWhqzliO.js}

@@ -166,10 +166,11 @@ function computeEpicGroups(nodes, edges, lk) {
 		}))
 	};
 }
-var READY_LABEL, PARKED_LABEL, VETOED_LABEL, BLOCKS_MAIN_LABEL, RELEASED_LABEL, OBJECTION_LABEL, LEGACY_PARKED_LABELS, EFFORT_UNITS;
+var READY_LABEL, PARKED_LABEL, EPIC_LABEL, VETOED_LABEL, BLOCKS_MAIN_LABEL, RELEASED_LABEL, OBJECTION_LABEL, LEGACY_PARKED_LABELS, EFFORT_UNITS;
 var init_pickup = __esmMin((() => {
 	READY_LABEL = "ready";
 	PARKED_LABEL = "parked";
+	EPIC_LABEL = "epic";
 	VETOED_LABEL = "vetoed";
 	BLOCKS_MAIN_LABEL = "blocks-main";
 	RELEASED_LABEL = "released";
@@ -184,6 +185,6 @@ var init_pickup = __esmMin((() => {
 	};
 }));
 //#endregion
-export { selectNeedsPlanning as _, READY_LABEL as a, classifyIssue as c, computeLanes as d, computeStats as f, normalizeGate as g, isAutoPickable as h, PARKED_LABEL as i, computeCohort as l, init_pickup as m, LEGACY_PARKED_LABELS as n, RELEASED_LABEL as o, computeWaves as p, OBJECTION_LABEL as r, VETOED_LABEL as s, BLOCKS_MAIN_LABEL as t, computeEpicGroups as u };
+export { normalizeGate as _, PARKED_LABEL as a, VETOED_LABEL as c, computeEpicGroups as d, computeLanes as f, isAutoPickable as g, init_pickup as h, OBJECTION_LABEL as i, classifyIssue as l, computeWaves as m, EPIC_LABEL as n, READY_LABEL as o, computeStats as p, LEGACY_PARKED_LABELS as r, RELEASED_LABEL as s, BLOCKS_MAIN_LABEL as t, computeCohort as u, selectNeedsPlanning as v };
 
-//# sourceMappingURL=pickup-DUCLWrJY.js.map
+//# sourceMappingURL=pickup-DWhqzliO.js.map

package/server/pipeline-membership-C88VBnhJ.js

@@ -0,0 +1,3 @@
+import { n as init_pipeline_membership, r as resolvePipelineMembership, t as PLANNED_BACKLOG_SPEC_ONLY_REASON } from "./pipeline-membership-D9SBvItj.js";
+init_pipeline_membership();
+export { PLANNED_BACKLOG_SPEC_ONLY_REASON, resolvePipelineMembership };

package/server/pipeline-membership-D9SBvItj.js

@@ -0,0 +1,57 @@
+import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
+//#region ../../lib/pipeline-membership.ts
+/**
+* Classify a single issue's pipeline membership from its durable lens signals.
+*
+* Decisions (see PAN-1980):
+*  - A closed issue is subtracted from the pipeline regardless of lingering
+*    branch/label/agent/workspace state (§2d), EXCEPT a still-open PR — a live,
+*    mergeable artifact that must be closed (`zombie_pr`).
+*  - L1-merged is the merge oracle; a squash-merged branch that L2 still calls
+*    "unmerged" is treated as merged.
+*  - An open issue with a branch but no PR is `planned_backlog` (in the pipeline,
+*    needs a PR or disposition) — distinct from `in_flight` so it does not
+*    inflate throughput.
+*/
+function resolvePipelineMembership(s) {
+	const branchLive = s.hasConventionBranch && s.branchUnmerged && !s.hasMergedPr;
+	const lenses = {
+		L1_openPr: s.hasOpenPr,
+		L2_unmergedBranch: branchLive,
+		L3_issueOpen: s.issueOpen,
+		L4_phaseLabel: s.phaseLabel
+	};
+	const result = (bucket, reason) => {
+		const labelDrift = s.phaseLabel !== null && (bucket === "clean_terminal" || !s.issueOpen) ? "stale_present" : s.issueOpen && s.hasOpenPr && s.phaseLabel === null ? "stale_absent" : null;
+		return {
+			issueId: s.issueId,
+			inPipeline: bucket !== "clean_terminal",
+			bucket,
+			reasons: [reason],
+			labelDrift,
+			lenses
+		};
+	};
+	if (!s.issueOpen) {
+		if (s.hasOpenPr) return result("zombie_pr", "issue is closed but a PR is still open — close/reconcile the PR");
+		return result("clean_terminal", "issue closed; no open PR — terminal (any leftover branch/label/agent is cleanup, not pipeline)");
+	}
+	if (s.hasOpenPr) return result("in_flight", "open issue with an open PR — active work");
+	if (s.hasMergedPr) return result("post_merge_limbo", "open issue with a merged PR — merged but never closed out; run close-out");
+	if (branchLive) return result("planned_backlog", "open issue with an unmerged convention branch (feature/ or strike/) but no PR — needs a PR or disposition");
+	if (s.hasConventionBranch) {
+		if (s.hasMergedBranchWork) return result("post_merge_limbo", "open issue whose branch work is contained in main but with no merged PR — landed via a non-PR path; run close-out");
+		return result("planned_backlog", "open issue with a convention branch but no unique commits — created, work not yet landed; needs work or disposition");
+	}
+	if (s.hasXbriefSpec) return result("planned_backlog", PLANNED_BACKLOG_SPEC_ONLY_REASON);
+	if (s.explicitlyReady) return result("planned_backlog", "open issue carries the explicit ready label — ready to start");
+	return result("clean_terminal", "open issue with no branch and no PR — backlog, never started");
+}
+var PLANNED_BACKLOG_SPEC_ONLY_REASON;
+var init_pipeline_membership = __esmMin((() => {
+	PLANNED_BACKLOG_SPEC_ONLY_REASON = "open issue with an xBRIEF spec but no branch/PR — planned work whose plan encodes code paths that age; needs starting or re-planning";
+}));
+//#endregion
+export { init_pipeline_membership as n, resolvePipelineMembership as r, PLANNED_BACKLOG_SPEC_ONLY_REASON as t };
+
+//# sourceMappingURL=pipeline-membership-D9SBvItj.js.map

package/server/pipeline-membership-gather-4eR-7Tqy.js

@@ -0,0 +1,3 @@
+import { a as gatherProjectLensSignals, c as listIssueStatesBatched, d as mapPipelineProjects, f as projectRepositories, i as gatherIssueBranchContainment, l as listMergedPullRequestHeadsBatched, m as snapshotBranchRefs, n as PipelineMembershipUnavailableError, o as gatherProjectLensSignalsForProjects, p as resolveRepositoryDefaultBranch, r as classifyBranchRefLine, s as init_pipeline_membership_gather, t as PIPELINE_PROJECT_CONCURRENCY, u as listOpenPullRequestsSnapshot } from "./pipeline-membership-gather-CeVGnNJ2.js";
+init_pipeline_membership_gather();
+export { PIPELINE_PROJECT_CONCURRENCY, PipelineMembershipUnavailableError, classifyBranchRefLine, gatherIssueBranchContainment, gatherProjectLensSignals, gatherProjectLensSignalsForProjects, listIssueStatesBatched, listMergedPullRequestHeadsBatched, listOpenPullRequestsSnapshot, mapPipelineProjects, projectRepositories, resolveRepositoryDefaultBranch, snapshotBranchRefs };