@overdeck/desktop 0.45.23 → 0.46.0

package/server/{pickup-Dd0Znxxy.js → pickup-D8xtG1J2.js}

@@ -28,13 +28,13 @@ function classifyIssue(node, lk) {
 * Routine auto-pickup for WORK: Ready AND Planned AND Released AND not
 * parked/vetoed/objected/in-flight. The DoR `ready` is the entry gate; `released`
 * (PAN-2059) is the operator's explicit "go" after reviewing the plan — a Planned
-* item is NOT pickable until released, UNLESS auto_pickup_backlog is ON, which
-* blanket-releases the whole backlog (vision.mdx). An open `objection` halts pickup
+* item is NOT pickable until released, unless auto_pickup_backlog is ON or active
+* order-book membership supplies the operator release. An open `objection` halts pickup
 * until the operator overrides or parks. An `epic` is a container, never directly
 * workable — its children carry the work, so it is excluded regardless of other gates.
 */
-function isAutoPickable(s, autoPickupBacklog = false) {
-	const released = s.released || autoPickupBacklog;
+function isAutoPickable(s, autoPickupBacklog = false, activeBookMember = false) {
+	const released = s.released || autoPickupBacklog || activeBookMember;
 	return s.ready && s.planned && released && !s.parked && !s.vetoed && !s.objection && !s.inPipeline && !s.epic;
 }
 function effortOf(size) {
@@ -48,13 +48,13 @@ function pickOrder(a, b) {
 	return a.rank - b.rank;
 }
 /** The auto-pickable queue, in pickup order (promoted first, then rank). */
-function pickableQueue(nodes, lk, autoPickupBacklog = false) {
+function pickableQueue(nodes, lk, autoPickupBacklog = false, activeBookMembership = /* @__PURE__ */ new Set()) {
 	return nodes.map((n) => ({
 		issue: n.issue,
 		rank: n.rank,
 		size: n.size,
 		state: classifyIssue(n, lk)
-	})).filter((n) => isAutoPickable(n.state, autoPickupBacklog)).sort((a, b) => pickOrder({
+	})).filter((n) => isAutoPickable(n.state, autoPickupBacklog, activeBookMembership.has(n.issue.toUpperCase()))).sort((a, b) => pickOrder({
 		gate: a.state.gate,
 		rank: a.rank
 	}, {
@@ -63,19 +63,19 @@ function pickableQueue(nodes, lk, autoPickupBacklog = false) {
 	}));
 }
 /** Batch the pickup queue into waves of up to `n`. */
-function computeWaves(nodes, lk, n, autoPickupBacklog = false) {
-	const q = pickableQueue(nodes, lk, autoPickupBacklog);
+function computeWaves(nodes, lk, n, autoPickupBacklog = false, activeBookMembership = /* @__PURE__ */ new Set()) {
+	const q = pickableQueue(nodes, lk, autoPickupBacklog, activeBookMembership);
 	const size = Math.max(1, n);
 	const waves = [];
 	for (let i = 0; i < q.length; i += size) waves.push(q.slice(i, i + size));
 	return waves;
 }
 /** Greedy list-schedule of the pickup queue across `n` lanes (block width = effort). */
-function computeLanes(nodes, lk, n, autoPickupBacklog = false) {
+function computeLanes(nodes, lk, n, autoPickupBacklog = false, activeBookMembership = /* @__PURE__ */ new Set()) {
 	const lanes = Math.max(1, n);
 	const free = new Array(lanes).fill(0);
 	const blocks = [];
-	for (const item of pickableQueue(nodes, lk, autoPickupBacklog)) {
+	for (const item of pickableQueue(nodes, lk, autoPickupBacklog, activeBookMembership)) {
 		let li = 0;
 		for (let i = 1; i < lanes; i++) if (free[i] < free[li]) li = i;
 		const start = free[li];
@@ -98,10 +98,10 @@ function computeLanes(nodes, lk, n, autoPickupBacklog = false) {
 * ∪ the auto-pickable issues in the current + next wave (top `2 × n` by pickup order).
 * Returns the issue ids; the Run completes when all of them reach a terminal state.
 */
-function computeCohort(nodes, lk, n, autoPickupBacklog = false) {
+function computeCohort(nodes, lk, n, autoPickupBacklog = false, activeBookMembership = /* @__PURE__ */ new Set()) {
 	const ids = /* @__PURE__ */ new Set();
 	for (const node of nodes) if (classifyIssue(node, lk).inPipeline) ids.add(node.issue);
-	for (const item of pickableQueue(nodes, lk, autoPickupBacklog).slice(0, Math.max(1, n) * 2)) ids.add(item.issue);
+	for (const item of pickableQueue(nodes, lk, autoPickupBacklog, activeBookMembership).slice(0, Math.max(1, n) * 2)) ids.add(item.issue);
 	return [...ids];
 }
 /**
@@ -122,7 +122,7 @@ function selectNeedsPlanning(nodes, lk, opts = {}) {
 	}).sort((a, b) => a.rank - b.rank).slice(0, cap);
 }
 /** Aggregate counts for the forecast header / filter bar. */
-function computeStats(nodes, lk, autoPickupBacklog = false) {
+function computeStats(nodes, lk, autoPickupBacklog = false, activeBookMembership = /* @__PURE__ */ new Set()) {
 	const stats = {
 		total: nodes.length,
 		inFlight: 0,
@@ -147,9 +147,10 @@ function computeStats(nodes, lk, autoPickupBacklog = false) {
 		if (s.parked) stats.parked++;
 		if (s.vetoed) stats.vetoed++;
 		if (s.blocksMain) stats.blocksMain++;
-		if (isAutoPickable(s, autoPickupBacklog)) stats.pickable++;
+		const activeBookMember = activeBookMembership.has(node.issue.toUpperCase());
+		if (isAutoPickable(s, autoPickupBacklog, activeBookMember)) stats.pickable++;
 		if (s.ready && !s.planned && !s.parked && !s.vetoed && !s.objection && !s.inPipeline) stats.needsPlanning++;
-		if (s.ready && s.planned && !s.released && !s.parked && !s.vetoed && !s.objection && !s.inPipeline) stats.needsRelease++;
+		if (s.ready && s.planned && !s.released && !activeBookMember && !s.parked && !s.vetoed && !s.objection && !s.inPipeline) stats.needsRelease++;
 	}
 	return stats;
 }
@@ -185,4 +186,4 @@ 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 };
 
-//# sourceMappingURL=pickup-Dd0Znxxy.js.map
+//# sourceMappingURL=pickup-D8xtG1J2.js.map

package/server/pipeline-membership-BGSvkT2M.js

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

package/server/pipeline-membership-CrAPLYtf.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-CrAPLYtf.js.map

package/server/{pipeline-membership-0HaEGDlH.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-DvyMuOle.js";
-import { C as init_specs, w as listSpecs } from "./io-B3_AHDfr.js";
-import { f as init_config, m as loadConfigSync } from "./config-CCvjQf27.js";
-import { r as init_factory, t as createTracker } from "./factory-CynerjXO.js";
-import { O as createSettledTtlPromiseCache, _ as listOpenIssuesWithLabelsPromise, f as init_github_app, h as listIssuesWithAnyLabelPromise, j as withConcurrencyLimitPromise, k as init_concurrency } from "./github-app-CMBdIFBQ.js";
-import { n as init_label_reconciler, t as STALE_PIPELINE_LABELS } from "./label-reconciler-DdWbHEBu.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-0HaEGDlH.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-D0ykk59O.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-Bb4XeV2x.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-D0ykk59O.js.map
+//# sourceMappingURL=pipeline-notifier-BuQ0e4hF.js.map

package/server/{pipeline-notifier-6iCJplFZ.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-D0ykk59O.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-2sK1apsO.js → project-pipelines-Bim6bThI.js}

@@ -1,4 +1,4 @@
-import { Tn as init_projects, kn as listProjectsSync } from "./config-yaml-DvyMuOle.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-2sK1apsO.js.map
+//# sourceMappingURL=project-pipelines-Bim6bThI.js.map