@overdeck/desktop 0.45.22 → 0.45.24

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

@@ -1,64 +1,11 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { cn as init_auto_commit, jr as init_errors, xr as FsError } from "./config-yaml-ig8Nwtiw.js";
-import { c as PAN_SESSIONS_FILENAME, d as WORKSPACE_RUNTIME_DIRNAME, i as PAN_CONTINUE_FILENAME, n as PAN_CONTEXT_FILENAME, p as init_types, s as PAN_FEEDBACK_DIRNAME, t as LEGACY_WORKSPACE_RUNTIME_DIRNAME, u as PAN_SPEC_FILENAME } from "./types-hraoaQIp.js";
-import { C as init_specs, S as getProjectPanPaths } from "./io-DQR9PMgS.js";
+import { Ht as flushAutoCommits, Ut as init_auto_commit, Wt as queueAutoCommit, ir as FsError, mr as init_errors } from "./config-yaml-DySPNmKN.js";
+import { p as init_types } from "./types-hraoaQIp.js";
+import { C as init_specs, F as getReadableWorkspacePanPaths, I as getWorkspacePanPaths, L as init_continue, N as ensureWorkspacePanDir, P as getLegacyWorkspacePanPaths, S as getProjectPanPaths, b as ensurePanDirs } from "./io-C9kF1wtJ.js";
 import { Effect, FileSystem } from "effect";
 import { join } from "path";
 import { existsSync, readFileSync } from "node:fs";
 import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
-//#region ../../lib/pan-dir/continue.ts
-function workspacePanPaths(workspacePath) {
-	const panDir = join(workspacePath, WORKSPACE_RUNTIME_DIRNAME);
-	return {
-		panDir,
-		specPath: join(panDir, PAN_SPEC_FILENAME),
-		continuePath: join(panDir, PAN_CONTINUE_FILENAME),
-		sessionsPath: join(panDir, PAN_SESSIONS_FILENAME),
-		feedbackDir: join(panDir, PAN_FEEDBACK_DIRNAME),
-		contextPath: join(panDir, PAN_CONTEXT_FILENAME)
-	};
-}
-function getWorkspacePanPaths(workspacePath) {
-	return workspacePanPaths(workspacePath);
-}
-function getLegacyWorkspacePanPaths(workspacePath) {
-	const panDir = join(workspacePath, LEGACY_WORKSPACE_RUNTIME_DIRNAME);
-	return {
-		panDir,
-		specPath: join(panDir, PAN_SPEC_FILENAME),
-		continuePath: join(panDir, PAN_CONTINUE_FILENAME),
-		sessionsPath: join(panDir, PAN_SESSIONS_FILENAME),
-		feedbackDir: join(panDir, PAN_FEEDBACK_DIRNAME),
-		contextPath: join(panDir, PAN_CONTEXT_FILENAME)
-	};
-}
-/** Resolve workspace runtime reads to `.overdeck/`, then legacy `.pan/`. */
-function getReadableWorkspacePanPaths(workspacePath) {
-	const canonical = getWorkspacePanPaths(workspacePath);
-	return existsSync(canonical.panDir) ? canonical : getLegacyWorkspacePanPaths(workspacePath);
-}
-function ensureWorkspacePanDir(workspacePath) {
-	return Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const paths = workspacePanPaths(workspacePath);
-		yield* fs.makeDirectory(paths.panDir, { recursive: true }).pipe(Effect.mapError((cause) => new FsError({
-			path: paths.panDir,
-			operation: "makeDirectory",
-			cause
-		})));
-		yield* fs.makeDirectory(paths.feedbackDir, { recursive: true }).pipe(Effect.mapError((cause) => new FsError({
-			path: paths.feedbackDir,
-			operation: "makeDirectory",
-			cause
-		})));
-		return paths;
-	}).pipe(Effect.provide(NodeFileSystem.layer));
-}
-var init_continue = __esmMin((() => {
-	init_errors();
-	init_types();
-}));
-//#endregion
 //#region ../../lib/pan-dir/sessions.ts
 var init_sessions = __esmMin((() => {
 	init_errors();
@@ -144,6 +91,33 @@ function getDraftsDir(projectRoot) {
 function getDraftPath(projectRoot, filename) {
 	return join(getDraftsDir(projectRoot), filename);
 }
+function getIssueDraftPath(projectRoot, issueId) {
+	return getDraftPath(projectRoot, `${issueId.toUpperCase()}.md`);
+}
+function writeIssueDraft(projectRoot, issueId, content) {
+	return Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		yield* ensurePanDirs(projectRoot);
+		const path = getIssueDraftPath(projectRoot, issueId);
+		yield* fs.writeFileString(path, content).pipe(Effect.mapError((cause) => new FsError({
+			path,
+			operation: "writeFileString",
+			cause
+		})));
+		queueAutoCommit({
+			projectRoot,
+			paths: [path],
+			subject: `chore(state): update PRD draft for ${issueId.toUpperCase()}`
+		});
+		const flushed = yield* flushAutoCommits(projectRoot);
+		if (flushed.errored || flushed.pushed === false) return yield* Effect.fail(new FsError({
+			path,
+			operation: "pushDraft",
+			cause: new Error(flushed.reason ?? "PRD draft commit was not pushed")
+		}));
+		return path;
+	}).pipe(Effect.provide(NodeFileSystem.layer));
+}
 /**
 * Sync PRD-first gate predicate (PAN-2234). The surrounding module uses the
 * Effect FileSystem for read/write/list paths; this predicate is deliberately a
@@ -200,6 +174,52 @@ function checkPrdGateSync(args) {
 		searched
 	};
 }
+/**
+* Promote a workspace-authored PRD draft to the canonical drafts/ location on
+* the state plane. Planning agents author the PRD at
+* `<workspace>/.pan/drafts/<ISSUE>.md`; the PRD-first gate accepts it there,
+* but the workspace is disposable — without this promotion the PRD is lost on
+* workspace teardown and invisible at the canonical location (the PAN-2858
+* defect). Runs at complete-planning, after the PRD gate.
+*
+* No-loss rule: an existing canonical draft is never overwritten — the
+* canonical copy may carry operator edits the workspace copy predates.
+*/
+function promoteWorkspacePrdDraft(args) {
+	return Effect.suspend(() => {
+		const { projectRoot, workspacePath, issueId } = args;
+		const upperFile = `${issueId.toUpperCase()}.md`;
+		const lowerFile = `${issueId.toLowerCase()}.md`;
+		const draftsDir = getDraftsDir(projectRoot);
+		for (const canonical of [join(draftsDir, upperFile), join(draftsDir, lowerFile)]) if (existsSync(canonical)) return Effect.succeed({
+			promoted: false,
+			reason: "canonical-exists",
+			path: canonical
+		});
+		const wsDrafts = join(workspacePath, ".pan", "drafts");
+		const source = [join(wsDrafts, upperFile), join(wsDrafts, lowerFile)].find((p) => existsSync(p));
+		if (!source) return Effect.succeed({
+			promoted: false,
+			reason: "no-workspace-draft"
+		});
+		let content;
+		try {
+			content = readFileSync(source, "utf-8");
+		} catch (cause) {
+			return Effect.fail(new FsError({
+				path: source,
+				operation: "readFileString",
+				cause
+			}));
+		}
+		return writeIssueDraft(projectRoot, issueId, content).pipe(Effect.map((path) => ({
+			promoted: true,
+			reason: "promoted",
+			path,
+			source
+		})));
+	});
+}
 var init_drafts = __esmMin((() => {
 	init_errors();
 	init_auto_commit();
@@ -255,6 +275,6 @@ var init_pan_dir = __esmMin((() => {
 	init_context();
 }));
 //#endregion
-export { clearFeedback as a, ensureWorkspacePanDir as c, checkPrdGateSync as i, getReadableWorkspacePanPaths as l, readWorkspaceContext as n, readFeedback as o, writeWorkspaceContext as r, writeFeedback as s, init_pan_dir as t, getWorkspacePanPaths as u };
+export { getDraftPath as a, clearFeedback as c, checkPrdGateSync as i, readFeedback as l, readWorkspaceContext as n, getIssueDraftPath as o, writeWorkspaceContext as r, promoteWorkspacePrdDraft as s, init_pan_dir as t, writeFeedback as u };
 
-//# sourceMappingURL=pan-dir-DOcf6ug3.js.map
+//# sourceMappingURL=pan-dir-B0c3w0Ya.js.map

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

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

package/server/{pickup-CaskQ7j6.js → pickup-DUCLWrJY.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-CaskQ7j6.js.map
+//# sourceMappingURL=pickup-DUCLWrJY.js.map

package/server/{pipeline-membership-1LGRjo-k.js → pipeline-membership-mY3GprlK.js}

@@ -1,8 +1,11 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Hn as init_projects, Nn as getIssuePrefix } from "./config-yaml-ig8Nwtiw.js";
-import { C as init_specs, w as listSpecs } from "./io-DQR9PMgS.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-CDPtGF7J.js";
-import { n as init_label_reconciler, t as STALE_PIPELINE_LABELS } from "./label-reconciler-Df1ZduPH.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 { Effect } from "effect";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -42,17 +45,26 @@ function listOpenPullRequestsSnapshot(owner, repo) {
 	}))));
 }
 async function runGitHubGraphql(query) {
-	const { stdout } = await execFileAsync("gh", [
-		"api",
-		"graphql",
-		"-f",
-		`query=${query}`
-	], {
-		encoding: "utf-8",
-		timeout: 3e4,
-		maxBuffer: 4 * 1024 * 1024
-	});
-	return stdout;
+	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 [];
@@ -76,9 +88,8 @@ async function listIssueStatesBatched(owner, repo, numbers, runGraphql = runGitH
 	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 response = JSON.parse(await runGraphql(query));
-		const repository = response.data?.repository;
-		if (response.errors?.length || !repository) throw new Error("Incomplete issue-state GraphQL response");
+		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}`);
@@ -95,44 +106,111 @@ async function listIssueStatesBatched(owner, repo, numbers, runGraphql = runGitH
 	}
 	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 Error(`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}`);
+	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
+		}];
+	});
+}
 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\//.test(ref)) return null;
+	if (!/(?:^|\/)(?:feature|strike)\//.test(ref)) return null;
 	const issueId = parseIssueIdFromTextSync(ref);
 	return issueId?.startsWith(`${issuePrefix}-`) ? issueId : null;
 }
-/** Gather all durable pipeline lenses for one GitHub-backed project in batches. */
+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"
+	}));
+}
+/** Gather all durable pipeline lenses for one project in batches. */
 async function gatherProjectLensSignals(project, deps = defaultDeps) {
-	if (!project.github_repo) return [];
-	const [owner, repo] = project.github_repo.split("/");
-	if (!owner || !repo) throw new Error(`Invalid github_repo for ${project.name}: ${project.github_repo}`);
 	const issuePrefix = getIssuePrefix(project)?.toUpperCase();
-	if (!issuePrefix) throw new Error(`Missing issue_prefix for GitHub project ${project.name}`);
-	const [openIssues, phaseLabeledIssues, openPrs, branchRefs, unmergedRefs, specIssueIds] = await Promise.all([
-		deps.listOpenIssues(owner, repo),
-		deps.listPhaseLabeledIssues(owner, repo),
-		deps.listOpenPullRequests(owner, repo),
-		deps.run("git", [
-			"for-each-ref",
-			"--format=%(refname:short)",
-			"refs/heads/feature/*",
-			"refs/remotes/origin/feature/*"
-		], project.path),
-		deps.run("git", [
-			"for-each-ref",
-			"--no-merged=main",
-			"--format=%(refname:short)",
-			"refs/heads/feature/*",
-			"refs/remotes/origin/feature/*"
-		], project.path),
+	if (!issuePrefix) throw new Error(`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 [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([]),
+		Promise.all(branchSnapshots),
 		deps.listSpecIssueIds(project.path)
 	]);
-	const refs = branchRefs.split("\n").map((ref) => ref.trim()).filter(Boolean);
-	const unmerged = new Set(unmergedRefs.split("\n").map((ref) => ref.trim()).filter(Boolean));
 	const candidates = /* @__PURE__ */ new Set();
 	const labelsByIssue = /* @__PURE__ */ new Map();
 	const knownStateByIssue = /* @__PURE__ */ new Map();
@@ -141,7 +219,15 @@ async function gatherProjectLensSignals(project, deps = defaultDeps) {
 	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);
@@ -155,7 +241,7 @@ async function gatherProjectLensSignals(project, deps = defaultDeps) {
 		knownStateByIssue.set(id, issue.state);
 	}
 	for (const pr of openPrs) {
-		if (pr.headRepoFullName.toLowerCase() !== `${owner}/${repo}`.toLowerCase()) continue;
+		if (!owner || !repo || pr.headRepoFullName.toLowerCase() !== `${owner}/${repo}`.toLowerCase()) continue;
 		const id = issueIdFromRef(pr.headRefName, issuePrefix);
 		if (id) {
 			candidates.add(id);
@@ -163,34 +249,61 @@ async function gatherProjectLensSignals(project, deps = defaultDeps) {
 			headRefsByIssue.set(id, new Set([...headRefsByIssue.get(id) ?? [], pr.headRefName]));
 		}
 	}
-	for (const ref of refs) {
-		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);
+	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 spaceIdx = line.indexOf(" ");
+			const tipSha = spaceIdx === -1 ? null : line.slice(0, spaceIdx);
+			const ref = spaceIdx === -1 ? line : line.slice(spaceIdx + 1);
+			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);
+			}
 		}
 	}
 	for (const id of specIssues) candidates.add(id);
-	const candidateHeads = [...new Set([...candidates].flatMap((id) => [...headRefsByIssue.get(id) ?? new Set([`feature/${id.toLowerCase()}`])]))];
-	const mergedHeads = new Set(await deps.listMergedPullRequestHeads(owner, repo, candidateHeads));
-	for (const [id, heads] of headRefsByIssue) if ([...heads].some((head) => mergedHeads.has(head))) mergedPrIssues.add(id);
-	for (const id of candidates) if (!headRefsByIssue.has(id) && mergedHeads.has(`feature/${id.toLowerCase()}`)) mergedPrIssues.add(id);
-	const unknownIssueIds = [...candidates].filter((id) => !knownStateByIssue.has(id));
-	const issueStates = await deps.listIssueStates(owner, repo, unknownIssueIds.map(issueNumber));
-	const stateByNumber = new Map(issueStates.map((entry) => [entry.number, entry.state]));
-	const issueOpen = new Map([...candidates].map((id) => [id, knownStateByIssue.get(id) === "open" || stateByNumber.get(issueNumber(id)) === "open"]));
+	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 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 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: issueOpen.get(id) ?? false,
+		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,
-		hasVbriefSpec: specIssues.has(id),
+		hasXbriefSpec: specIssues.has(id),
 		explicitlyReady: labelsByIssue.get(id)?.includes("ready") ?? false
 	}));
 }
@@ -221,9 +334,11 @@ 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);
@@ -233,6 +348,7 @@ var init_pipeline_membership_gather = __esmMin((() => {
 		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, {
@@ -285,17 +401,20 @@ function resolvePipelineMembership(s) {
 	}
 	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 feature branch but no PR — needs a PR or disposition");
-	if (s.hasConventionBranch) return result("post_merge_limbo", "open issue whose branch is already in main but with no merged PR — landed via a non-PR path; run close-out");
-	if (s.hasVbriefSpec) return result("planned_backlog", PLANNED_BACKLOG_SPEC_ONLY_REASON);
+	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 a vBRIEF spec but no branch/PR — planned work whose plan encodes code paths that age; needs starting or re-planning";
+	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 };
 
-//# sourceMappingURL=pipeline-membership-1LGRjo-k.js.map
+//# sourceMappingURL=pipeline-membership-mY3GprlK.js.map

package/server/{pipeline-notifier-CZsrU_nj.js → pipeline-notifier-BJr8gQX6.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-B6FVsYF9.js";
+import { a as setPipelineHandlerSync, i as setPipelineHandler, n as notifyPipeline, r as notifyPipelineSync, t as init_pipeline_notifier } from "./pipeline-notifier-BXkJzDC4.js";
 init_pipeline_notifier();
 export { notifyPipeline, notifyPipelineSync, setPipelineHandler, setPipelineHandlerSync };

package/server/{pipeline-notifier-B6FVsYF9.js → pipeline-notifier-BXkJzDC4.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-CXsfxslp.js";
+import { o as getInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-s0-oKybJ.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-B6FVsYF9.js.map
+//# sourceMappingURL=pipeline-notifier-BXkJzDC4.js.map