@overdeck/desktop 0.45.24 → 0.46.0

package/server/{pipeline-membership-mY3GprlK.js → pipeline-membership-gather-CET40frr.js}

@@ -1,12 +1,13 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Tn as init_projects, gn as getIssuePrefix } from "./config-yaml-DySPNmKN.js";
-import { C as init_specs, w as listSpecs } from "./io-C9kF1wtJ.js";
-import { f as init_config, m as loadConfigSync } from "./config-BZ0sHTju.js";
-import { r as init_factory, t as createTracker } from "./factory-CFibJuaw.js";
-import { A as createSettledTtlPromiseCache, N as withConcurrencyLimitPromise, _ as listOpenIssuesWithLabelsPromise, f as init_github_app, h as listIssuesWithAnyLabelPromise, j as init_concurrency } from "./github-app-C3QrAUd0.js";
-import { n as init_label_reconciler, t as STALE_PIPELINE_LABELS } from "./label-reconciler-B4iOAjlC.js";
-import { join } from "node:path";
+import { Gn as init_projects, In as getIssuePrefix } from "./config-yaml-CmOPzmBb.js";
+import { C as listSpecs, S as init_specs } from "./io-VHvc0Ssp.js";
+import { f as init_config, m as loadConfigSync } from "./config-Dr3pW6w6.js";
+import { r as init_factory, t as createTracker } from "./factory-CRoOpGsF.js";
+import { A as createSettledTtlPromiseCache, N as withConcurrencyLimitPromise, _ as listOpenIssuesWithLabelsPromise, f as init_github_app, h as listIssuesWithAnyLabelPromise, j as init_concurrency } from "./github-app-CQ1Lo6LA.js";
+import { n as init_label_reconciler, t as STALE_PIPELINE_LABELS } from "./label-reconciler--F85rufp.js";
+import { join, resolve } from "node:path";
 import { Effect } from "effect";
+import { realpath } from "node:fs/promises";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 //#region ../../lib/resource-utils.ts
@@ -112,11 +113,11 @@ function resolveProjectTrackerType(project) {
 	if (project.github_repo) return "github";
 	if (getIssuePrefix(project)) return "linear";
 	if (project.gitlab_repo) return "gitlab";
-	throw new Error(`Cannot resolve tracker for ${project.name}`);
+	throw new PipelineMembershipUnavailableError("tracker_unconfigured", `Cannot resolve tracker for ${project.name}`);
 }
 async function listProjectTrackerIssues(project) {
 	const issuePrefix = getIssuePrefix(project)?.toUpperCase();
-	if (!issuePrefix) throw new Error(`Missing issue_prefix for project ${project.name}`);
+	if (!issuePrefix) throw new PipelineMembershipUnavailableError("missing_issue_prefix", `Missing issue_prefix for project ${project.name}`);
 	const trackerType = resolveProjectTrackerType(project);
 	const trackerConfig = loadConfigSync().trackers[trackerType];
 	const tracker = createTracker({
@@ -144,6 +145,14 @@ async function listProjectTrackerIssues(project) {
 		}];
 	});
 }
+async function withUnavailableReason(reason, operation) {
+	try {
+		return await operation();
+	} catch (error) {
+		if (error instanceof PipelineMembershipUnavailableError) throw error;
+		throw new PipelineMembershipUnavailableError(reason, error instanceof Error ? error.message : String(error));
+	}
+}
 function issueNumber(issueId) {
 	const match = issueId.match(/-(\d+)$/);
 	if (!match) throw new Error(`Cannot derive GitHub issue number from ${issueId}`);
@@ -164,52 +173,156 @@ function projectRepositories(project) {
 		defaultBranch: repo.default_branch ?? project.workspace?.default_branch ?? "main"
 	}));
 }
+async function normalizeRepoPath(path) {
+	return realpath(path).catch(() => resolve(path));
+}
+async function hasGitRef(repoPath, branch, run) {
+	const ref = branch.startsWith("origin/") ? `refs/remotes/${branch}` : `refs/heads/${branch}`;
+	try {
+		await run("git", [
+			"rev-parse",
+			"--verify",
+			"--quiet",
+			ref
+		], repoPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function resolveRepositoryDefaultBranch(repoPath, configured, run = defaultDeps.run) {
+	if (configured) {
+		if (await hasGitRef(repoPath, configured, run)) return configured;
+		if (await hasGitRef(repoPath, `origin/${configured}`, run)) return `origin/${configured}`;
+	}
+	for (const ref of ["refs/remotes/origin/HEAD", "HEAD"]) try {
+		const branch = (await run("git", [
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			ref
+		], repoPath)).trim();
+		if (branch && await hasGitRef(repoPath, branch, run)) return branch;
+	} catch {}
+	for (const branch of [
+		"main",
+		"master",
+		"origin/main",
+		"origin/master"
+	]) if (await hasGitRef(repoPath, branch, run)) return branch;
+	throw new PipelineMembershipUnavailableError("default_branch_unresolved", `Could not resolve default branch for repository ${repoPath} (configured: ${configured ?? "none"})`);
+}
+async function snapshotBranchRefs(repoPath, defaultBranch, refPatterns, run = defaultDeps.run) {
+	const unavailable = () => new PipelineMembershipUnavailableError("repo_unavailable", `Workspace repo path is not a git repository: ${repoPath}`);
+	let gitTopLevel;
+	try {
+		gitTopLevel = (await run("git", ["rev-parse", "--show-toplevel"], repoPath)).trim();
+	} catch (error) {
+		if (error instanceof PipelineMembershipUnavailableError) throw error;
+		throw unavailable();
+	}
+	const [normalizedRepoPath, normalizedGitTopLevel] = await Promise.all([normalizeRepoPath(repoPath), normalizeRepoPath(gitTopLevel)]);
+	if (normalizedRepoPath !== normalizedGitTopLevel) throw unavailable();
+	const resolvedDefaultBranch = await resolveRepositoryDefaultBranch(repoPath, defaultBranch, run);
+	const [refs, unmergedRefs, firstParentShas] = await Promise.all([
+		run("git", [
+			"for-each-ref",
+			"--format=%(objectname) %(refname:short)",
+			...refPatterns
+		], repoPath),
+		run("git", [
+			"for-each-ref",
+			`--no-merged=${resolvedDefaultBranch}`,
+			"--format=%(refname:short)",
+			...refPatterns
+		], repoPath),
+		run("git", [
+			"rev-list",
+			"--first-parent",
+			resolvedDefaultBranch
+		], repoPath)
+	]);
+	return {
+		refs,
+		unmergedRefs,
+		firstParentShas
+	};
+}
+function parseBranchRefLine(line) {
+	const spaceIdx = line.indexOf(" ");
+	return {
+		tipSha: spaceIdx === -1 ? null : line.slice(0, spaceIdx),
+		ref: spaceIdx === -1 ? line : line.slice(spaceIdx + 1)
+	};
+}
+function classifyBranchRefLine(line, unmergedSet, firstParentShas) {
+	const { tipSha, ref } = parseBranchRefLine(line);
+	if (unmergedSet.has(ref)) return "unmerged";
+	if (tipSha && !firstParentShas.has(tipSha)) return "merged-work";
+	return "pointer";
+}
+async function gatherIssueBranchContainment(project, issueId, run = defaultDeps.run) {
+	const normalizedIssueId = issueId.toLowerCase();
+	const refPatterns = [
+		`refs/heads/feature/${normalizedIssueId}`,
+		`refs/remotes/origin/feature/${normalizedIssueId}`,
+		`refs/heads/strike/${normalizedIssueId}`,
+		`refs/remotes/origin/strike/${normalizedIssueId}`
+	];
+	const snapshots = await Promise.all(projectRepositories(project).map(async (repository) => ({
+		repository,
+		snapshot: await snapshotBranchRefs(repository.path, repository.defaultBranch, refPatterns, run)
+	})));
+	const result = {
+		unmergedRefs: [],
+		mergedWorkRefs: [],
+		pointerRefs: []
+	};
+	for (const { repository, snapshot } of snapshots) {
+		const unmergedSet = new Set(snapshot.unmergedRefs.split("\n").map((ref) => ref.trim()).filter(Boolean));
+		const firstParentShas = new Set(snapshot.firstParentShas.split("\n").map((sha) => sha.trim()).filter(Boolean));
+		const refLines = snapshot.refs.split("\n").map((line) => line.trim()).filter(Boolean);
+		for (const line of refLines) {
+			const { ref } = parseBranchRefLine(line);
+			const qualifiedRef = `${repository.path}:${ref}`;
+			switch (classifyBranchRefLine(line, unmergedSet, firstParentShas)) {
+				case "unmerged":
+					result.unmergedRefs.push(qualifiedRef);
+					break;
+				case "merged-work":
+					result.mergedWorkRefs.push(qualifiedRef);
+					break;
+				case "pointer":
+					result.pointerRefs.push(qualifiedRef);
+					break;
+			}
+		}
+	}
+	return result;
+}
 /** Gather all durable pipeline lenses for one project in batches. */
 async function gatherProjectLensSignals(project, deps = defaultDeps) {
 	const issuePrefix = getIssuePrefix(project)?.toUpperCase();
-	if (!issuePrefix) throw new Error(`Missing issue_prefix for project ${project.name}`);
+	if (!issuePrefix) throw new PipelineMembershipUnavailableError("missing_issue_prefix", `Missing issue_prefix for project ${project.name}`);
 	const githubRepository = project.github_repo?.split("/");
 	const owner = githubRepository?.[0];
 	const repo = githubRepository?.[1];
 	if (project.github_repo && (!owner || !repo)) throw new Error(`Invalid github_repo for ${project.name}: ${project.github_repo}`);
-	const branchSnapshots = projectRepositories(project).map(async (repository) => {
-		const [refs, unmergedRefs, firstParentShas] = await Promise.all([
-			deps.run("git", [
-				"for-each-ref",
-				"--format=%(objectname) %(refname:short)",
-				"refs/heads/feature/*",
-				"refs/remotes/origin/feature/*",
-				"refs/heads/strike/*",
-				"refs/remotes/origin/strike/*"
-			], repository.path),
-			deps.run("git", [
-				"for-each-ref",
-				`--no-merged=${repository.defaultBranch}`,
-				"--format=%(refname:short)",
-				"refs/heads/feature/*",
-				"refs/remotes/origin/feature/*",
-				"refs/heads/strike/*",
-				"refs/remotes/origin/strike/*"
-			], repository.path),
-			deps.run("git", [
-				"rev-list",
-				"--first-parent",
-				repository.defaultBranch
-			], repository.path)
-		]);
-		return {
-			refs,
-			unmergedRefs,
-			firstParentShas
-		};
-	});
+	const repositories = projectRepositories(project);
+	const branchRefPatterns = [
+		"refs/heads/feature/*",
+		"refs/remotes/origin/feature/*",
+		"refs/heads/strike/*",
+		"refs/remotes/origin/strike/*"
+	];
+	const branchSnapshots = repositories.map((repository) => snapshotBranchRefs(repository.path, repository.defaultBranch, branchRefPatterns, deps.run));
 	const [trackerIssues, openIssues, phaseLabeledIssues, openPrs, branches, specIssueIds] = await Promise.all([
-		project.github_repo ? Promise.resolve([]) : deps.listTrackerIssues(project),
-		owner && repo ? deps.listOpenIssues(owner, repo) : Promise.resolve([]),
-		owner && repo ? deps.listPhaseLabeledIssues(owner, repo) : Promise.resolve([]),
-		owner && repo ? deps.listOpenPullRequests(owner, repo) : Promise.resolve([]),
+		project.github_repo ? Promise.resolve([]) : withUnavailableReason("forge_unavailable", () => deps.listTrackerIssues(project)),
+		owner && repo ? withUnavailableReason("forge_unavailable", () => deps.listOpenIssues(owner, repo)) : Promise.resolve([]),
+		owner && repo ? withUnavailableReason("forge_unavailable", () => deps.listPhaseLabeledIssues(owner, repo)) : Promise.resolve([]),
+		owner && repo ? withUnavailableReason("forge_unavailable", () => deps.listOpenPullRequests(owner, repo)) : Promise.resolve([]),
 		Promise.all(branchSnapshots),
-		deps.listSpecIssueIds(project.path)
+		withUnavailableReason("gather_failed", () => deps.listSpecIssueIds(project.path))
 	]);
 	const candidates = /* @__PURE__ */ new Set();
 	const labelsByIssue = /* @__PURE__ */ new Map();
@@ -254,17 +367,16 @@ async function gatherProjectLensSignals(project, deps = defaultDeps) {
 		const unmerged = new Set(snapshot.unmergedRefs.split("\n").map((ref) => ref.trim()).filter(Boolean));
 		const firstParentShas = new Set(snapshot.firstParentShas.split("\n").map((sha) => sha.trim()).filter(Boolean));
 		for (const line of refLines) {
-			const spaceIdx = line.indexOf(" ");
-			const tipSha = spaceIdx === -1 ? null : line.slice(0, spaceIdx);
-			const ref = spaceIdx === -1 ? line : line.slice(spaceIdx + 1);
+			const { ref } = parseBranchRefLine(line);
 			const id = issueIdFromRef(ref, issuePrefix);
 			if (id) {
 				candidates.add(id);
 				branchIssues.add(id);
 				const headRef = ref.replace(/^origin\//, "");
 				headRefsByIssue.set(id, new Set([...headRefsByIssue.get(id) ?? [], headRef]));
-				if (unmerged.has(ref)) unmergedBranchIssues.add(id);
-				else if (tipSha && !firstParentShas.has(tipSha)) mergedBranchWorkIssues.add(id);
+				const classification = classifyBranchRefLine(line, unmerged, firstParentShas);
+				if (classification === "unmerged") unmergedBranchIssues.add(id);
+				else if (classification === "merged-work") mergedBranchWorkIssues.add(id);
 			}
 		}
 	}
@@ -274,7 +386,7 @@ async function gatherProjectLensSignals(project, deps = defaultDeps) {
 		const issueStateCandidates = unknownIssueIds.filter((id) => openPrIssues.has(id) || branchIssues.has(id));
 		const issueStateCandidateSet = new Set(issueStateCandidates);
 		for (const id of unknownIssueIds) if (!issueStateCandidateSet.has(id)) candidates.delete(id);
-		const issueStates = issueStateCandidates.length > 0 ? await deps.listIssueStates(owner, repo, issueStateCandidates.map(issueNumber)) : [];
+		const issueStates = issueStateCandidates.length > 0 ? await withUnavailableReason("forge_unavailable", () => deps.listIssueStates(owner, repo, issueStateCandidates.map(issueNumber))) : [];
 		const stateByNumber = new Map(issueStates.map((entry) => [entry.number, entry.state]));
 		for (const id of issueStateCandidates) {
 			const state = stateByNumber.get(issueNumber(id));
@@ -287,7 +399,7 @@ async function gatherProjectLensSignals(project, deps = defaultDeps) {
 			`feature/${id.toLowerCase()}`,
 			`strike/${id.toLowerCase()}`
 		]))];
-		const mergedHeads = new Set(await deps.listMergedPullRequestHeads(owner, repo, candidateHeads));
+		const mergedHeads = new Set(await withUnavailableReason("forge_unavailable", () => deps.listMergedPullRequestHeads(owner, repo, candidateHeads)));
 		for (const id of openCandidates) if ([
 			...headRefsByIssue.get(id) ?? [],
 			`feature/${id.toLowerCase()}`,
@@ -329,7 +441,7 @@ async function gatherProjectLensSignalsForProjects(projects, gather = gatherProj
 		error
 	}));
 }
-var execFileAsync, GRAPHQL_ALIAS_CHUNK_SIZE, cachedOpenPullRequests, defaultDeps;
+var execFileAsync, GRAPHQL_ALIAS_CHUNK_SIZE, cachedOpenPullRequests, PipelineMembershipUnavailableError, defaultDeps, PIPELINE_PROJECT_CONCURRENCY;
 var init_pipeline_membership_gather = __esmMin((() => {
 	init_github_app();
 	init_concurrency();
@@ -342,6 +454,14 @@ var init_pipeline_membership_gather = __esmMin((() => {
 	execFileAsync = promisify(execFile);
 	GRAPHQL_ALIAS_CHUNK_SIZE = 50;
 	cachedOpenPullRequests = createSettledTtlPromiseCache(3e4);
+	PipelineMembershipUnavailableError = class extends Error {
+		reason;
+		constructor(reason, message) {
+			super(message);
+			this.name = "PipelineMembershipUnavailableError";
+			this.reason = reason;
+		}
+	};
 	defaultDeps = {
 		listOpenIssues: listOpenIssuesWithLabelsPromise,
 		listPhaseLabeledIssues: (owner, repo) => listIssuesWithAnyLabelPromise(owner, repo, STALE_PIPELINE_LABELS),
@@ -360,61 +480,9 @@ var init_pipeline_membership_gather = __esmMin((() => {
 			return stdout;
 		}
 	};
+	PIPELINE_PROJECT_CONCURRENCY = 3;
 }));
 //#endregion
-//#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 { gatherProjectLensSignalsForProjects as a, init_resource_utils as c, gatherProjectLensSignals as i, parseIssueIdFromTextSync as l, init_pipeline_membership as n, init_pipeline_membership_gather as o, resolvePipelineMembership as r, listOpenPullRequestsSnapshot as s, PLANNED_BACKLOG_SPEC_ONLY_REASON as t };
+export { gatherProjectLensSignals as a, listIssueStatesBatched as c, mapPipelineProjects as d, projectRepositories as f, parseIssueIdFromTextSync as g, init_resource_utils as h, gatherIssueBranchContainment as i, listMergedPullRequestHeadsBatched as l, snapshotBranchRefs as m, PipelineMembershipUnavailableError as n, gatherProjectLensSignalsForProjects as o, resolveRepositoryDefaultBranch as p, classifyBranchRefLine as r, init_pipeline_membership_gather as s, PIPELINE_PROJECT_CONCURRENCY as t, listOpenPullRequestsSnapshot as u };
 
-//# sourceMappingURL=pipeline-membership-mY3GprlK.js.map
+//# sourceMappingURL=pipeline-membership-gather-CET40frr.js.map

package/server/pipeline-membership-gather-DTfcgxLl.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-CET40frr.js";
+init_pipeline_membership_gather();
+export { PIPELINE_PROJECT_CONCURRENCY, PipelineMembershipUnavailableError, classifyBranchRefLine, gatherIssueBranchContainment, gatherProjectLensSignals, gatherProjectLensSignalsForProjects, listIssueStatesBatched, listMergedPullRequestHeadsBatched, listOpenPullRequestsSnapshot, mapPipelineProjects, projectRepositories, resolveRepositoryDefaultBranch, snapshotBranchRefs };

package/server/{pipeline-notifier-BXkJzDC4.js → pipeline-notifier-BuQ0e4hF.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { o as getInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-s0-oKybJ.js";
+import { o as getInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-DvMTQSOS.js";
 import { Effect } from "effect";
 //#region ../../lib/pipeline-notifier.ts
 /**
@@ -60,4 +60,4 @@ var init_pipeline_notifier = __esmMin((() => {
 //#endregion
 export { setPipelineHandlerSync as a, setPipelineHandler as i, notifyPipeline as n, notifyPipelineSync as r, init_pipeline_notifier as t };
 
-//# sourceMappingURL=pipeline-notifier-BXkJzDC4.js.map
+//# sourceMappingURL=pipeline-notifier-BuQ0e4hF.js.map

package/server/{pipeline-notifier-BJr8gQX6.js → pipeline-notifier-ImNXknf0.js}

@@ -1,3 +1,3 @@
-import { a as setPipelineHandlerSync, i as setPipelineHandler, n as notifyPipeline, r as notifyPipelineSync, t as init_pipeline_notifier } from "./pipeline-notifier-BXkJzDC4.js";
+import { a as setPipelineHandlerSync, i as setPipelineHandler, n as notifyPipeline, r as notifyPipelineSync, t as init_pipeline_notifier } from "./pipeline-notifier-BuQ0e4hF.js";
 init_pipeline_notifier();
 export { notifyPipeline, notifyPipelineSync, setPipelineHandler, setPipelineHandlerSync };

package/server/post-merge-lifecycle-worker-DbO10pum.js

@@ -0,0 +1,50 @@
+import { n as init_review_status_source, s as resolveCanonicalReviewStatus } from "./review-status-source-CpvJnvnQ.js";
+//#region ../../lib/cloister/post-merge-lifecycle-worker.ts
+init_review_status_source();
+const queue = /* @__PURE__ */ new Map();
+let workerPromise = null;
+function nextEntry() {
+	return [...queue.values()].find((entry) => !entry.running) ?? null;
+}
+async function drainQueue() {
+	for (let entry = nextEntry(); entry; entry = nextEntry()) {
+		entry.running = true;
+		const status = resolveCanonicalReviewStatus(entry.issueId);
+		if (!status.available || status.status?.mergeStatus !== "merged" || status.status.mergeStep !== "post-merge-cleanup") {
+			queue.delete(entry.issueId);
+			continue;
+		}
+		try {
+			const { postMergeLifecycle } = await import("./merge-agent-DrXa1CpW.js");
+			await postMergeLifecycle(entry.issueId, entry.projectPath, entry.sourceBranch, { skipDeploy: true });
+			console.log(`[deacon] Completed pending post-merge lifecycle for ${entry.issueId}`);
+		} catch (error) {
+			console.warn(`[deacon] Pending post-merge lifecycle retry failed for ${entry.issueId}: ${error}`);
+		} finally {
+			queue.delete(entry.issueId);
+		}
+	}
+}
+function startWorker() {
+	if (workerPromise || !nextEntry()) return;
+	workerPromise = drainQueue().finally(() => {
+		workerPromise = null;
+		if (nextEntry()) startWorker();
+	});
+}
+function enqueuePostMergeLifecycle(issueId, projectPath, sourceBranch) {
+	const normalizedIssueId = issueId.trim().toUpperCase();
+	if (!normalizedIssueId || queue.has(normalizedIssueId)) return null;
+	queue.set(normalizedIssueId, {
+		issueId: normalizedIssueId,
+		projectPath,
+		sourceBranch,
+		running: false
+	});
+	startWorker();
+	return `Queued pending post-merge lifecycle for ${normalizedIssueId}`;
+}
+//#endregion
+export { enqueuePostMergeLifecycle };
+
+//# sourceMappingURL=post-merge-lifecycle-worker-DbO10pum.js.map

package/server/{project-pipelines-C0MWUeCU.js → project-pipelines-Bim6bThI.js}

@@ -1,4 +1,4 @@
-import { Tn as init_projects, kn as listProjectsSync } from "./config-yaml-DySPNmKN.js";
+import { Gn as init_projects, Yn as listProjectsSync } from "./config-yaml-CmOPzmBb.js";
 import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { execFile } from "node:child_process";
@@ -159,4 +159,4 @@ async function fetchProjectReleaseStatus(projectKey, deps = {}) {
 //#endregion
 export { fetchProjectReleaseStatus };
 
-//# sourceMappingURL=project-pipelines-C0MWUeCU.js.map
+//# sourceMappingURL=project-pipelines-Bim6bThI.js.map

package/server/{project-repos-B6GycDh9.js → project-repos-C0nuoBGv.js}

@@ -1,5 +1,5 @@
 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 { Gn as init_projects, ar as resolveProjectFromIssueSync, zn as getProjectSync } from "./config-yaml-CmOPzmBb.js";
 import "effect";
 import { existsSync } from "fs";
 import { join } from "path";
@@ -85,10 +85,14 @@ function computeWorkspaceRepoRootsSync(repos, issueId, workspacePath) {
 function resolveWorkspaceRepoRootsSync(issueId, workspacePath) {
 	return computeWorkspaceRepoRootsSync(resolveProjectReposForIssueSync(issueId), issueId, workspacePath);
 }
+/** Resolve the primary git checkout used by single-repo workspace probes. */
+function resolvePrimaryWorkspaceRepoDirSync(issueId, workspacePath) {
+	return resolveWorkspaceRepoRootsSync(issueId, workspacePath)[0].dir;
+}
 var init_project_repos = __esmMin((() => {
 	init_projects();
 }));
 //#endregion
-export { resolveConfiguredReposSync as a, resolveWorkspaceRepoRootsSync as c, normalizeForgeSync as i, inferProjectForgeSync as n, resolveProjectReposForIssueSync as o, init_project_repos as r, resolveProjectReposFromResolvedIssueSync as s, computeWorkspaceRepoRootsSync as t };
+export { resolveConfiguredReposSync as a, resolveProjectReposFromResolvedIssueSync as c, normalizeForgeSync as i, resolveWorkspaceRepoRootsSync as l, inferProjectForgeSync as n, resolvePrimaryWorkspaceRepoDirSync as o, init_project_repos as r, resolveProjectReposForIssueSync as s, computeWorkspaceRepoRootsSync as t };
 
-//# sourceMappingURL=project-repos-B6GycDh9.js.map
+//# sourceMappingURL=project-repos-C0nuoBGv.js.map

package/server/project-repos-CRE6Ykow.js

@@ -0,0 +1,3 @@
+import { l as resolveWorkspaceRepoRootsSync, o as resolvePrimaryWorkspaceRepoDirSync, r as init_project_repos } from "./project-repos-C0nuoBGv.js";
+init_project_repos();
+export { resolvePrimaryWorkspaceRepoDirSync, resolveWorkspaceRepoRootsSync };

package/server/projects-B03Wr-xc.js

@@ -0,0 +1,3 @@
+import { $n as registerProject, An as extractTeamPrefix, Bn as getSpecialistConfig, Dn as PROJECTS_CONFIG_FILE, Fn as findProjectsByRallyProject, Gn as init_projects, Hn as getSpecialistRetention, In as getIssuePrefix, Jn as listProjects, Kn as initializeProjectsConfig, Ln as getProject, Mn as findProjectByPathSync, Nn as findProjectByTeam, On as ProjectRenameError, Pn as findProjectByTeamSync, Rn as getProjectSwarmHotspots, Un as hasProjects, Vn as getSpecialistPromptOverride, Wn as hasProjectsSync, Xn as loadProjectsConfig, Yn as listProjectsSync, Zn as loadProjectsConfigSync, ar as resolveProjectFromIssueSync, cr as saveProjectsConfigSync, dr as setProjectSwarmPolicySync, er as registerProjectSync, fr as unregisterProject, ir as resolveProjectFromIssue, jn as findProjectByPath, kn as createDefaultProjectsConfig, lr as setProjectAutoMergeDefaultSync, nr as renameProjectSync, or as resolveProjectPath, pr as unregisterProjectSync, qn as initializeProjectsConfigSync, rr as resolveInfraRepo, sr as saveProjectsConfig, tr as renameProject, ur as setProjectMergeTrainSync, zn as getProjectSync } from "./config-yaml-CmOPzmBb.js";
+init_projects();
+export { PROJECTS_CONFIG_FILE, ProjectRenameError, createDefaultProjectsConfig, extractTeamPrefix, findProjectByPath, findProjectByPathSync, findProjectByTeam, findProjectByTeamSync, findProjectsByRallyProject, getIssuePrefix, getProject, getProjectSwarmHotspots, getProjectSync, getSpecialistConfig, getSpecialistPromptOverride, getSpecialistRetention, hasProjects, hasProjectsSync, initializeProjectsConfig, initializeProjectsConfigSync, listProjects, listProjectsSync, loadProjectsConfig, loadProjectsConfigSync, registerProject, registerProjectSync, renameProject, renameProjectSync, resolveInfraRepo, resolveProjectFromIssue, resolveProjectFromIssueSync, resolveProjectPath, saveProjectsConfig, saveProjectsConfigSync, setProjectAutoMergeDefaultSync, setProjectMergeTrainSync, setProjectSwarmPolicySync, unregisterProject, unregisterProjectSync };

package/server/{prompts-DxzFXuLl.js → prompts-BEx08AIu.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { h as jsYaml, m as init_js_yaml } from "./config-yaml-DySPNmKN.js";
+import { h as jsYaml, m as init_js_yaml } from "./config-yaml-CmOPzmBb.js";
 import { Data, Effect } from "effect";
 import { existsSync, readFileSync } from "fs";
 import { dirname, join } from "path";
@@ -669,4 +669,4 @@ var init_prompts = __esmMin((() => {
 //#endregion
 export { renderPrompt as n, init_prompts as t };
 
-//# sourceMappingURL=prompts-DxzFXuLl.js.map
+//# sourceMappingURL=prompts-BEx08AIu.js.map

package/server/{providers-u4Ga0jOr.js → providers-D7IluJe0.js}

@@ -1,3 +1,3 @@
-import { B as getProviderEnvSync, H as init_providers, V as getProviderForModelSync } from "./config-yaml-DySPNmKN.js";
+import { B as getProviderEnvSync, H as init_providers, V as getProviderForModelSync } from "./config-yaml-CmOPzmBb.js";
 init_providers();
 export { getProviderEnvSync, getProviderForModelSync };

package/server/{providers-qQAwGQDW.js → providers-evXhiQeg.js}

@@ -1,9 +1,9 @@
 import { n as __esmMin, t as __commonJSMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { i as init_paths, r as ensureParentDir, s as resolveIssueMemoryRoot } from "./paths-D-xWGHdh.js";
-import { o as getPricingSync, s as init_cost } from "./cost-B2ddP6wq.js";
-import { d as init_cost_sync, f as insertCostEventSync, m as queryMemoryExtractionCostUsdSync } from "./cost-sync-BsN6ER0n.js";
-import { n as CLIPROXY_BASE_URL, t as CLIPROXY_AUTH_TOKEN, v as init_cliproxy$1 } from "./cliproxy-C8a1vtTU.js";
-import { i as init_settings, s as loadMemorySettings } from "./settings-BTMvpNFU.js";
+import { i as init_paths, r as ensureParentDir, s as resolveIssueMemoryRoot } from "./paths-cXmOwSbh.js";
+import { o as getPricingSync, s as init_cost } from "./cost-Bgcub5kW.js";
+import { d as init_cost_sync, f as insertCostEventSync, m as queryMemoryExtractionCostUsdSync } from "./cost-sync-Dv3LUaNW.js";
+import { n as CLIPROXY_BASE_URL, t as CLIPROXY_AUTH_TOKEN, v as init_cliproxy$1 } from "./cliproxy-C8mB3KuB.js";
+import { i as init_settings, s as loadMemorySettings } from "./settings-Bse1Pdcj.js";
 import { join } from "path";
 import { randomUUID } from "crypto";
 import { readFile, writeFile } from "fs/promises";
@@ -8125,7 +8125,7 @@ async function readMemoryHealth(path) {
 	};
 }
 async function emitMemoryHealthChanged(payload, timestamp) {
-	const { initEventStore } = await import("./event-store-EV2cMiXj.js");
+	const { initEventStore } = await import("./event-store-ELqkVOn0.js");
 	await (await initEventStore()).appendAsync({
 		type: "memory.health_changed",
 		timestamp,
@@ -8232,4 +8232,4 @@ var init_providers = __esmMin((() => {
 //#endregion
 export { updateMemoryHealth as i, extractWithProviderPolicy as n, init_health as r, init_providers as t };
 
-//# sourceMappingURL=providers-qQAwGQDW.js.map
+//# sourceMappingURL=providers-evXhiQeg.js.map