@overdeck/desktop 0.45.24 → 0.47.0

package/server/pipeline-membership-gather-CeVGnNJ2.js

@@ -0,0 +1,593 @@
+import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
+import { Gn as init_projects, In as getIssuePrefix, Pt as init_record, Rt as readIssueRecordForWorkspaceSync, Yn as listProjectsSync } from "./config-yaml-CxdwhAIA.js";
+import { n as resolveGitHubIssueSync, t as init_tracker_utils } from "./tracker-utils-CJ6BHjcD.js";
+import { C as listSpecs, S as init_specs } from "./io-B00PBNku.js";
+import { f as init_config, m as loadConfigSync } from "./config-BvLe652W.js";
+import { r as init_factory, t as createTracker } from "./factory-Cmm9Hsho.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-CmNk0zLU.js";
+import { a as PARKED_LABEL, c as VETOED_LABEL, h as init_pickup, i as OBJECTION_LABEL, o as READY_LABEL, s as RELEASED_LABEL, t as BLOCKS_MAIN_LABEL } from "./pickup-DWhqzliO.js";
+import { join, resolve } from "node:path";
+import { Effect } from "effect";
+import { realpath } from "node:fs/promises";
+import { exec, execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region ../../lib/backlog/label-ops.ts
+/**
+* Add or remove a GitHub label on an issue. Non-GitHub issues are silently
+* skipped; the `|| true` keeps a missing-label / already-applied no-op non-fatal.
+*/
+async function editIssueLabel(issueId, op, label) {
+	const resolution = resolveGitHubIssueSync(issueId);
+	if (!resolution.isGitHub) return;
+	const { owner, repo, number } = resolution;
+	await execAsync$1(`gh issue edit ${number} --repo ${owner}/${repo} ${op === "add" ? "--add-label" : "--remove-label"} "${label}" 2>/dev/null || true`);
+}
+var execAsync$1, addIssueLabel, removeIssueLabel, applyIssueParkedLabel, removeIssueParkedLabel, applyIssueVetoedLabel, removeIssueVetoedLabel, applyIssueBlocksMainLabel, removeIssueBlocksMainLabel, applyIssueReadyLabel, removeIssueReadyLabel, applyIssueReleasedLabel, removeIssueReleasedLabel, applyIssueObjectionLabel, removeIssueObjectionLabel;
+var init_label_ops = __esmMin((() => {
+	init_tracker_utils();
+	init_pickup();
+	execAsync$1 = promisify(exec);
+	addIssueLabel = (issueId, label) => editIssueLabel(issueId, "add", label);
+	removeIssueLabel = (issueId, label) => editIssueLabel(issueId, "remove", label);
+	applyIssueParkedLabel = (id) => addIssueLabel(id, PARKED_LABEL);
+	removeIssueParkedLabel = (id) => removeIssueLabel(id, PARKED_LABEL);
+	applyIssueVetoedLabel = (id) => addIssueLabel(id, VETOED_LABEL);
+	removeIssueVetoedLabel = (id) => removeIssueLabel(id, VETOED_LABEL);
+	applyIssueBlocksMainLabel = (id) => addIssueLabel(id, BLOCKS_MAIN_LABEL);
+	removeIssueBlocksMainLabel = (id) => removeIssueLabel(id, BLOCKS_MAIN_LABEL);
+	applyIssueReadyLabel = (id) => addIssueLabel(id, READY_LABEL);
+	removeIssueReadyLabel = (id) => removeIssueLabel(id, READY_LABEL);
+	applyIssueReleasedLabel = (id) => addIssueLabel(id, RELEASED_LABEL);
+	removeIssueReleasedLabel = (id) => removeIssueLabel(id, RELEASED_LABEL);
+	applyIssueObjectionLabel = (id) => addIssueLabel(id, OBJECTION_LABEL);
+	removeIssueObjectionLabel = (id) => removeIssueLabel(id, OBJECTION_LABEL);
+}));
+//#endregion
+//#region ../../lib/cloister/label-reconciler.ts
+function planLabelReconciliation(candidate) {
+	if (!(candidate.recordTerminal || candidate.issueClosed || candidate.mergedWithoutInflight)) return [];
+	const changes = STALE_PIPELINE_LABELS.filter((label) => candidate.labels.includes(label)).map((label) => ({
+		issueId: candidate.issueId,
+		op: "remove",
+		label
+	}));
+	if (!candidate.issueClosed && !candidate.closeOutComplete && !candidate.labels.includes("needs-close-out")) changes.push({
+		issueId: candidate.issueId,
+		op: "add",
+		label: "needs-close-out"
+	});
+	return changes;
+}
+async function reconcilePipelineLabels(candidates, options = {}, edit = (change) => change.op === "add" ? addIssueLabel(change.issueId, change.label) : removeIssueLabel(change.issueId, change.label)) {
+	const changes = candidates.slice(0, options.maxIssues ?? candidates.length).flatMap(planLabelReconciliation);
+	if (!options.dryRun) for (const change of changes) await edit(change);
+	return changes;
+}
+async function collectLabelReconcileCandidates() {
+	const candidates = [];
+	for (const { config } of listProjectsSync()) {
+		const prefix = getIssuePrefix(config);
+		if (!prefix || !config.path) continue;
+		const resolution = resolveGitHubIssueSync(`${prefix}-1`);
+		if (!resolution.isGitHub) continue;
+		const { stdout } = await execAsync(`gh issue list --repo ${resolution.owner}/${resolution.repo} --state all --limit 1000 --json number,state,labels`);
+		const rows = JSON.parse(stdout);
+		for (const row of rows) {
+			const issueId = `${prefix.toUpperCase()}-${row.number}`;
+			const labels = row.labels.map((label) => label.name);
+			const record = readIssueRecordForWorkspaceSync(config.path, issueId);
+			const closeOutComplete = Boolean(record?.closeOut?.closedAt);
+			const recordTerminal = closeOutComplete || record?.pipeline?.mergeStatus === "merged";
+			const mergedWithoutInflight = labels.includes("merged") && !labels.some((label) => [
+				"planning",
+				"in-progress",
+				"in-review",
+				"in-planning"
+			].includes(label));
+			candidates.push({
+				issueId,
+				issueClosed: row.state.toLowerCase() === "closed",
+				labels,
+				recordTerminal,
+				mergedWithoutInflight,
+				closeOutComplete
+			});
+		}
+	}
+	return candidates;
+}
+async function reconcilePipelineLabelsPatrol() {
+	return (await reconcilePipelineLabels(await collectLabelReconcileCandidates(), { maxIssues: 20 })).map((change) => `[labels] ${change.op} ${change.label} on ${change.issueId}`);
+}
+var execAsync, STALE_PIPELINE_LABELS;
+var init_label_reconciler = __esmMin((() => {
+	init_label_ops();
+	init_projects();
+	init_record();
+	init_tracker_utils();
+	execAsync = promisify(exec);
+	STALE_PIPELINE_LABELS = [
+		"verifying-on-main",
+		"planning",
+		"in-progress",
+		"in-review",
+		"in-planning"
+	];
+}));
+//#endregion
+//#region ../../lib/resource-utils.ts
+function parseIssueIdFromTextSync(value) {
+	const match = value.match(/\b([A-Za-z]+-\d+|F\d+|US\d+|DE\d+|TA\d+|TC\d+)\b/i);
+	return match ? match[1].toUpperCase() : null;
+}
+var init_resource_utils = __esmMin((() => {}));
+//#endregion
+//#region ../../lib/pipeline-membership-gather.ts
+function chunksOf(values) {
+	const chunks = [];
+	for (let index = 0; index < values.length; index += GRAPHQL_ALIAS_CHUNK_SIZE) chunks.push(values.slice(index, index + GRAPHQL_ALIAS_CHUNK_SIZE));
+	return chunks;
+}
+/** Share one short-lived repository PR snapshot across dashboard consumers. */
+function listOpenPullRequestsSnapshot(owner, repo) {
+	return cachedOpenPullRequests(`${owner}/${repo}`.toLowerCase(), () => execFileAsync("gh", [
+		"api",
+		"--paginate",
+		"--slurp",
+		`repos/${owner}/${repo}/pulls?state=open&per_page=100`
+	], {
+		encoding: "utf-8",
+		timeout: 3e4,
+		maxBuffer: 16 * 1024 * 1024
+	}).then(({ stdout }) => JSON.parse(stdout).flat().map((pr) => ({
+		number: pr.number,
+		title: pr.title,
+		url: pr.html_url,
+		state: pr.state,
+		isDraft: pr.draft ?? false,
+		headRefName: pr.head.ref,
+		headRepoFullName: pr.head.repo?.full_name ?? "",
+		baseRefName: pr.base.ref
+	}))));
+}
+async function runGitHubGraphql(query) {
+	try {
+		const { stdout } = await execFileAsync("gh", [
+			"api",
+			"graphql",
+			"-f",
+			`query=${query}`
+		], {
+			encoding: "utf-8",
+			timeout: 3e4,
+			maxBuffer: 4 * 1024 * 1024
+		});
+		return stdout;
+	} catch (error) {
+		const stdout = error.stdout;
+		if (typeof stdout === "string" && stdout.length > 0) try {
+			const parsed = JSON.parse(stdout);
+			if (parsed.data !== void 0 && parsed.data !== null) return stdout;
+		} catch {}
+		throw error;
+	}
+}
+async function listMergedPullRequestHeadsBatched(owner, repo, heads, runGraphql = runGitHubGraphql) {
+	if (heads.length === 0) return [];
+	const mergedHeads = [];
+	for (const headChunk of chunksOf(heads)) {
+		const fields = headChunk.map((head, index) => `h${index}: pullRequests(states: MERGED, headRefName: ${JSON.stringify(head)}, first: 10) { nodes { headRepository { name owner { login } } } }`);
+		const query = `query { repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(repo)}) { ${fields.join(" ")} } }`;
+		const response = JSON.parse(await runGraphql(query));
+		const repository = response.data?.repository;
+		if (response.errors?.length || !repository) throw new Error("Incomplete merged-PR GraphQL response");
+		for (let index = 0; index < headChunk.length; index++) if (!Array.isArray(repository[`h${index}`]?.nodes)) throw new Error(`Missing merged-PR alias h${index}`);
+		const normalizedOwner = owner.toLowerCase();
+		const normalizedRepo = repo.toLowerCase();
+		mergedHeads.push(...headChunk.filter((_head, index) => repository[`h${index}`]?.nodes?.some((pr) => pr.headRepository?.name?.toLowerCase() === normalizedRepo && pr.headRepository.owner?.login?.toLowerCase() === normalizedOwner)));
+	}
+	return mergedHeads;
+}
+async function listIssueStatesBatched(owner, repo, numbers, runGraphql = runGitHubGraphql) {
+	if (numbers.length === 0) return [];
+	const states = [];
+	for (const numberChunk of chunksOf(numbers)) {
+		const fields = numberChunk.map((number, index) => `i${index}: issue(number: ${number}) { state }`);
+		const query = `query { repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(repo)}) { ${fields.join(" ")} } }`;
+		const repository = JSON.parse(await runGraphql(query)).data?.repository;
+		if (!repository) throw new Error("Incomplete issue-state GraphQL response");
+		for (let index = 0; index < numberChunk.length; index++) {
+			const alias = `i${index}`;
+			if (!Object.prototype.hasOwnProperty.call(repository, alias)) throw new Error(`Missing issue-state alias ${alias}`);
+			const state = repository[alias]?.state;
+			if (repository[alias] !== null && state !== "OPEN" && state !== "CLOSED") throw new Error(`Invalid issue-state alias ${alias}`);
+		}
+		states.push(...numberChunk.flatMap((number, index) => {
+			const row = repository[`i${index}`];
+			return row === null ? [] : [{
+				number,
+				state: row?.state === "OPEN" ? "open" : "closed"
+			}];
+		}));
+	}
+	return states;
+}
+function resolveProjectTrackerType(project) {
+	if (project.tracker) return project.tracker;
+	if (project.rally_project) return "rally";
+	if (project.github_repo) return "github";
+	if (getIssuePrefix(project)) return "linear";
+	if (project.gitlab_repo) return "gitlab";
+	throw new PipelineMembershipUnavailableError("tracker_unconfigured", `Cannot resolve tracker for ${project.name}`);
+}
+async function listProjectTrackerIssues(project) {
+	const issuePrefix = getIssuePrefix(project)?.toUpperCase();
+	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({
+		type: trackerType,
+		apiKeyEnv: trackerConfig && "api_key_env" in trackerConfig ? trackerConfig.api_key_env : void 0,
+		tokenEnv: trackerConfig && "token_env" in trackerConfig ? trackerConfig.token_env : void 0,
+		team: issuePrefix,
+		owner: project.github_repo?.split("/")[0],
+		repo: project.github_repo?.split("/")[1],
+		projectId: project.gitlab_repo,
+		server: trackerType === "rally" && trackerConfig && "server" in trackerConfig ? trackerConfig.server : void 0,
+		workspace: trackerType === "rally" && trackerConfig && "workspace" in trackerConfig ? trackerConfig.workspace : void 0,
+		project: project.rally_project
+	});
+	return (await Effect.runPromise(tracker.listIssues({
+		team: issuePrefix,
+		includeClosed: true
+	}))).flatMap((issue) => {
+		const issueId = issue.ref.toUpperCase();
+		if (!issueId.startsWith(`${issuePrefix}-`)) return [];
+		return [{
+			issueId,
+			state: issue.state === "closed" ? "closed" : "open",
+			labels: issue.labels
+		}];
+	});
+}
+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}`);
+	return Number(match[1]);
+}
+function issueIdFromRef(ref, issuePrefix) {
+	if (!/(?:^|\/)(?:feature|strike)\//.test(ref)) return null;
+	const issueId = parseIssueIdFromTextSync(ref);
+	return issueId?.startsWith(`${issuePrefix}-`) ? issueId : null;
+}
+function projectRepositories(project) {
+	if (!project.workspace?.repos?.length) return [{
+		path: project.path,
+		defaultBranch: project.workspace?.default_branch ?? "main"
+	}];
+	return project.workspace.repos.map((repo) => ({
+		path: join(project.path, repo.path),
+		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 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 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([]) : 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),
+		withUnavailableReason("gather_failed", () => deps.listSpecIssueIds(project.path))
+	]);
+	const candidates = /* @__PURE__ */ new Set();
+	const labelsByIssue = /* @__PURE__ */ new Map();
+	const knownStateByIssue = /* @__PURE__ */ new Map();
+	const openPrIssues = /* @__PURE__ */ new Set();
+	const mergedPrIssues = /* @__PURE__ */ new Set();
+	const headRefsByIssue = /* @__PURE__ */ new Map();
+	const branchIssues = /* @__PURE__ */ new Set();
+	const unmergedBranchIssues = /* @__PURE__ */ new Set();
+	const mergedBranchWorkIssues = /* @__PURE__ */ new Set();
+	const specIssues = new Set(specIssueIds.map((id) => id.toUpperCase()).filter((id) => id.startsWith(`${issuePrefix}-`)));
+	for (const issue of trackerIssues) {
+		const id = issue.issueId.toUpperCase();
+		if (!id.startsWith(`${issuePrefix}-`)) continue;
+		labelsByIssue.set(id, issue.labels);
+		knownStateByIssue.set(id, issue.state);
+		if (issue.state === "open" || STALE_PIPELINE_LABELS.some((label) => issue.labels.includes(label))) candidates.add(id);
+	}
+	for (const issue of openIssues) {
+		const id = `${issuePrefix}-${issue.number}`;
+		candidates.add(id);
+		labelsByIssue.set(id, issue.labels);
+		knownStateByIssue.set(id, "open");
+	}
+	for (const issue of phaseLabeledIssues) {
+		const id = `${issuePrefix}-${issue.number}`;
+		candidates.add(id);
+		labelsByIssue.set(id, issue.labels);
+		knownStateByIssue.set(id, issue.state);
+	}
+	for (const pr of openPrs) {
+		if (!owner || !repo || pr.headRepoFullName.toLowerCase() !== `${owner}/${repo}`.toLowerCase()) continue;
+		const id = issueIdFromRef(pr.headRefName, issuePrefix);
+		if (id) {
+			candidates.add(id);
+			openPrIssues.add(id);
+			headRefsByIssue.set(id, new Set([...headRefsByIssue.get(id) ?? [], pr.headRefName]));
+		}
+	}
+	for (const snapshot of branches) {
+		const refLines = snapshot.refs.split("\n").map((line) => line.trim()).filter(Boolean);
+		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 { 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]));
+				const classification = classifyBranchRefLine(line, unmerged, firstParentShas);
+				if (classification === "unmerged") unmergedBranchIssues.add(id);
+				else if (classification === "merged-work") mergedBranchWorkIssues.add(id);
+			}
+		}
+	}
+	for (const id of specIssues) candidates.add(id);
+	if (owner && repo) {
+		const unknownIssueIds = [...candidates].filter((id) => !knownStateByIssue.has(id));
+		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 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));
+			if (state) knownStateByIssue.set(id, state);
+			else candidates.delete(id);
+		}
+		const openCandidates = [...candidates].filter((id) => knownStateByIssue.get(id) === "open");
+		const candidateHeads = [...new Set(openCandidates.flatMap((id) => [
+			...headRefsByIssue.get(id) ?? [],
+			`feature/${id.toLowerCase()}`,
+			`strike/${id.toLowerCase()}`
+		]))];
+		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()}`,
+			`strike/${id.toLowerCase()}`
+		].some((head) => mergedHeads.has(head))) mergedPrIssues.add(id);
+	}
+	return [...candidates].sort().map((id) => ({
+		issueId: id,
+		issueOpen: knownStateByIssue.get(id) === "open",
+		hasOpenPr: openPrIssues.has(id),
+		hasMergedPr: mergedPrIssues.has(id),
+		hasConventionBranch: branchIssues.has(id),
+		branchUnmerged: unmergedBranchIssues.has(id),
+		hasMergedBranchWork: mergedBranchWorkIssues.has(id),
+		phaseLabel: STALE_PIPELINE_LABELS.find((label) => labelsByIssue.get(id)?.includes(label)) ?? null,
+		hasXbriefSpec: specIssues.has(id),
+		explicitlyReady: labelsByIssue.get(id)?.includes("ready") ?? false
+	}));
+}
+async function mapPipelineProjects(projects, operation) {
+	return withConcurrencyLimitPromise(projects.map((project) => async () => {
+		try {
+			return {
+				project,
+				value: await operation(project)
+			};
+		} catch (error) {
+			return {
+				project,
+				error
+			};
+		}
+	}), 3);
+}
+async function gatherProjectLensSignalsForProjects(projects, gather = gatherProjectLensSignals) {
+	return (await mapPipelineProjects(projects, gather)).map(({ project, value, error }) => ({
+		project,
+		signals: value,
+		error
+	}));
+}
+var execFileAsync, GRAPHQL_ALIAS_CHUNK_SIZE, cachedOpenPullRequests, PipelineMembershipUnavailableError, defaultDeps, PIPELINE_PROJECT_CONCURRENCY;
+var init_pipeline_membership_gather = __esmMin((() => {
+	init_github_app();
+	init_concurrency();
+	init_label_reconciler();
+	init_config();
+	init_specs();
+	init_projects();
+	init_resource_utils();
+	init_factory();
+	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),
+		listOpenPullRequests: listOpenPullRequestsSnapshot,
+		listMergedPullRequestHeads: listMergedPullRequestHeadsBatched,
+		listIssueStates: listIssueStatesBatched,
+		listTrackerIssues: listProjectTrackerIssues,
+		listSpecIssueIds: async (projectPath) => (await Effect.runPromise(listSpecs(projectPath))).map((entry) => entry.issueId),
+		run: async (command, args, cwd) => {
+			const { stdout } = await execFileAsync(command, args, {
+				cwd,
+				encoding: "utf-8",
+				timeout: 15e3,
+				maxBuffer: 4 * 1024 * 1024
+			});
+			return stdout;
+		}
+	};
+	PIPELINE_PROJECT_CONCURRENCY = 3;
+}));
+//#endregion
+export { removeIssueReleasedLabel as A, applyIssueReleasedLabel as C, removeIssueObjectionLabel as D, removeIssueBlocksMainLabel as E, removeIssueParkedLabel as O, applyIssueReadyLabel as S, init_label_ops as T, init_label_reconciler as _, gatherProjectLensSignals as a, applyIssueObjectionLabel as b, listIssueStatesBatched as c, mapPipelineProjects as d, projectRepositories as f, parseIssueIdFromTextSync as g, init_resource_utils as h, gatherIssueBranchContainment as i, removeIssueVetoedLabel as j, removeIssueReadyLabel as k, 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, reconcilePipelineLabelsPatrol as v, applyIssueVetoedLabel as w, applyIssueParkedLabel as x, applyIssueBlocksMainLabel as y };
+
+//# sourceMappingURL=pipeline-membership-gather-CeVGnNJ2.js.map

package/server/{pipeline-notifier-BXkJzDC4.js → pipeline-notifier-D0ALV6Nw.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-DzK385vD.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-D0ALV6Nw.js.map

package/server/{pipeline-notifier-BJr8gQX6.js → pipeline-notifier-DT6xLFao.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-D0ALV6Nw.js";
 init_pipeline_notifier();
 export { notifyPipeline, notifyPipelineSync, setPipelineHandler, setPipelineHandlerSync };

package/server/post-merge-lifecycle-worker-8HIeS_J6.js

@@ -0,0 +1,50 @@
+import { n as init_review_status_source, s as resolveCanonicalReviewStatus } from "./review-status-source-DIk1JSow.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-DQTXZk8z.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-8HIeS_J6.js.map

package/server/{project-pipelines-C0MWUeCU.js → project-pipelines-9SKt2bEc.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-CxdwhAIA.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-9SKt2bEc.js.map