@overdeck/desktop 0.49.1 → 0.49.2

package/server/project-resource-refresh-queue-x-K9mvpP.js

@@ -0,0 +1,865 @@
+import { On as resolveProjectFromIssueSync, fn as init_projects, vn as listProjectsSync } from "./config-yaml-D9nfpEx1.js";
+import { o as init_resolver, u as listWorkspaces } from "./resolver-gxv97jsQ.js";
+import { r as compareIssueIds, t as init_src } from "./src-CY2Wl8IX.js";
+import { An as init_runtime_census, On as getRuntimeCensus, U as getAgentRuntimeState, q as init_agents } from "./agent-state-BJhGIJZe.js";
+import { A as init_conversations, P as listConversations } from "./conversations-C75EFFjf.js";
+import { a as PAN_DIRNAME, i as PAN_CONTINUE_FILENAME } from "./types-pLpbsNto.js";
+import { C as init_specs, S as findSpecByIssue } from "./io-DKrWd3gX.js";
+import { t as init_pan_dir } from "./pan-dir-BMda7tQj.js";
+import { r as resolveMissingIssueTitles, t as init_issue_title_fallback } from "./issue-title-fallback-DTSCQVu0.js";
+import { m as loadReadyForMergeFlags, p as init_review_status } from "./review-status-yOGD2MuK.js";
+import { A as createSettledTtlPromiseCache, j as init_concurrency, k as createPromiseConcurrencyLimiter } from "./github-app-7ywLhuZO.js";
+import { t as resolveAgentGitInfo } from "./git-info-BSrI9owC.js";
+import { n as findDraftPrd } from "./prd-locations-BbAvqQmT.js";
+import { a as gatherProjectLensSignals, g as parseIssueIdFromTextSync, h as init_resource_utils, n as PipelineMembershipUnavailableError, s as init_pipeline_membership_gather, u as listOpenPullRequestsSnapshot } from "./pipeline-membership-gather-BK4dzh0X.js";
+import { n as init_pipeline_membership, r as resolvePipelineMembership } from "./pipeline-membership-PGX3Pe8V.js";
+import { basename, join } from "node:path";
+import { Effect } from "effect";
+import { readdir, stat } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region services/resource-discovery-shared.ts
+init_projects();
+init_src();
+init_conversations();
+init_runtime_census();
+const execFileAsync$1 = promisify(execFile);
+async function loadTrackerIssues() {
+	const map = /* @__PURE__ */ new Map();
+	try {
+		const { getSharedIssueService } = await import("./issue-service-singleton-CvgNAWqK.js");
+		const issues = (await getSharedIssueService()).getIssues();
+		for (const issue of issues) if (issue.identifier) map.set(issue.identifier.toUpperCase(), issue);
+	} catch {}
+	return map;
+}
+async function loadDockerContainers() {
+	try {
+		const { stdout } = await execFileAsync$1("docker", [
+			"ps",
+			"--format",
+			"{{.Names}}"
+		], {
+			encoding: "utf-8",
+			timeout: 5e3
+		});
+		return stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+async function loadActiveRemoteAgentStates() {
+	try {
+		const { listActiveRemoteAgentStates } = await import("./remote-agents-BVtASiOF.js");
+		return listActiveRemoteAgentStates();
+	} catch {
+		return [];
+	}
+}
+async function captureSharedResourceSignals() {
+	const [trackerIssues, runtimeCensus, dockerContainers, remoteAgentStates] = await Promise.all([
+		loadTrackerIssues(),
+		getRuntimeCensus(),
+		loadDockerContainers(),
+		loadActiveRemoteAgentStates()
+	]);
+	const tmuxSessions = [...runtimeCensus.sessionNames];
+	let conversations = [];
+	try {
+		conversations = listConversations();
+	} catch {}
+	return {
+		trackerIssues,
+		tmuxSessions,
+		dockerContainers,
+		conversations,
+		remoteAgentStates
+	};
+}
+//#endregion
+//#region review-status.ts
+init_resolver();
+init_specs();
+init_pan_dir();
+init_agents();
+init_concurrency();
+init_resource_utils();
+init_pipeline_membership_gather();
+init_pipeline_membership();
+init_review_status();
+//#endregion
+//#region services/pipeline-membership.ts
+init_issue_title_fallback();
+const PIPELINE_MEMBERSHIP_TTL_MS = 3e4;
+function createPipelineMembershipService(deps = {
+	gather: gatherProjectLensSignals,
+	now: () => Date.now()
+}) {
+	const cachedGather = createSettledTtlPromiseCache(PIPELINE_MEMBERSHIP_TTL_MS, deps.now);
+	const service = async (project) => cachedGather(project.path, () => deps.gather(project).then((signals) => signals.map(resolvePipelineMembership)));
+	service.invalidate = (projectPath) => cachedGather.invalidate(projectPath);
+	return service;
+}
+const getProjectPipelineMembership = createPipelineMembershipService();
+const membershipSnapshots = /* @__PURE__ */ new Map();
+const scheduleMembershipRefresh = createPromiseConcurrencyLimiter(3);
+function refreshMembershipSnapshot(project, snapshot, getMembership, now) {
+	if (snapshot.refresh) return snapshot.refresh;
+	snapshot.refresh = scheduleMembershipRefresh(() => getMembership(project)).then((value) => {
+		snapshot.value = value;
+		snapshot.refreshedAt = now();
+		snapshot.lastError = void 0;
+		snapshot.lastErrorReason = void 0;
+		snapshot.lastErrorAt = void 0;
+	}).catch((error) => {
+		snapshot.lastError = error instanceof Error ? error.message : String(error);
+		snapshot.lastErrorReason = error instanceof PipelineMembershipUnavailableError ? error.reason : "gather_failed";
+		snapshot.lastErrorAt = now();
+		console.warn(`[pipeline-membership] refresh failed for ${project.name ?? project.path}; keeping last-good snapshot:`, snapshot.lastError);
+	}).finally(() => {
+		snapshot.refresh = void 0;
+	});
+	return snapshot.refresh;
+}
+/** Read the latest successful snapshots without scheduling tracker or git work. */
+function readPipelineMembershipSnapshotsForProjects(projects) {
+	return projects.map((project) => {
+		const snapshot = membershipSnapshots.get(project.path);
+		if (snapshot?.refreshedAt) return {
+			project,
+			memberships: snapshot.value
+		};
+		return {
+			project,
+			error: /* @__PURE__ */ new Error(snapshot?.lastError ? `Pipeline membership refresh failed: ${snapshot.lastError}` : "Pipeline membership snapshot is loading"),
+			unavailableReason: snapshot?.lastErrorReason
+		};
+	});
+}
+/**
+* PAN-2893 — event-driven refresh. Invalidate the per-project TTL cache and
+* force a snapshot re-gather NOW for the given projects, so agent lifecycle
+* changes reach membership consumers without waiting out the 5-minute TTL.
+* Refresh failures keep the last good snapshot (same policy as TTL refreshes).
+*/
+async function refreshMembershipSnapshotsForProjects(projects, getMembership = getProjectPipelineMembership, now = () => Date.now()) {
+	await Promise.all(projects.map(async (project) => {
+		getMembership.invalidate(project.path);
+		const snapshot = membershipSnapshots.get(project.path) ?? {
+			value: [],
+			refreshedAt: 0
+		};
+		membershipSnapshots.set(project.path, snapshot);
+		const inFlight = snapshot.refresh;
+		if (inFlight) {
+			await inFlight;
+			getMembership.invalidate(project.path);
+		}
+		await refreshMembershipSnapshot(project, snapshot, getMembership, now);
+	}));
+}
+function summarizePipelineMembership(membership) {
+	return {
+		available: true,
+		inPipeline: membership.inPipeline,
+		bucket: membership.bucket,
+		labelDrift: membership.labelDrift
+	};
+}
+function unavailablePipelineMembership() {
+	return {
+		available: false,
+		inPipeline: false,
+		bucket: "clean_terminal",
+		labelDrift: null
+	};
+}
+//#endregion
+//#region services/resource-discovery.ts
+init_pipeline_membership();
+init_pipeline_membership_gather();
+const execFileAsync = promisify(execFile);
+const RECENT_ACTIVITY_WINDOW_MS = 5e3;
+const projectResourceSnapshots = /* @__PURE__ */ new Map();
+let cachedResourceIssues = null;
+let cachedDetailedResourceIssues = null;
+function projectPrefixes(project) {
+	const prefixes = /* @__PURE__ */ new Set();
+	if (project.config.issue_prefix) prefixes.add(project.config.issue_prefix.toUpperCase());
+	for (const prefix of project.config.issue_prefixes ?? []) prefixes.add(prefix.toUpperCase());
+	if (prefixes.size === 0) prefixes.add(project.key.toUpperCase().replace(/-/g, ""));
+	return [...prefixes];
+}
+function deriveStateLabel(issue, hasTmux, hasFreshHeartbeat, membership) {
+	const trackerState = issue.trackerState ?? "";
+	if (membership?.bucket === "post_merge_limbo") return "Merged — Needs Close-Out";
+	if (membership?.lenses.L3_issueOpen === false) return hasTmux ? "Closed" : "Done";
+	if (issue.readyForMerge) return "In Review";
+	if (trackerState === "done" || trackerState === "closed" || trackerState === "canceled") return hasTmux ? "Closed" : "Done";
+	if (trackerState === "in_review") return "In Review";
+	if (trackerState === "in_progress") return "In Progress";
+	if (hasTmux && (issue.agentStatus === "active" || hasFreshHeartbeat)) return "In Progress";
+	if (issue.agentStatus === "suspended") return "Suspended";
+	if (issue.hasPrd && !issue.hasState) return "Planning";
+	if (issue.hasState) return "Has Context";
+	if (issue.resourceSources.has("workspace") || issue.resourceSources.has("branch")) return "Allocated";
+	return "Idle";
+}
+function sortPullRequests(prs) {
+	return [...prs].sort((a, b) => {
+		if (a.isDraft !== b.isDraft) return a.isDraft ? 1 : -1;
+		return a.number - b.number;
+	});
+}
+function summarizeResourceDetails(details) {
+	return {
+		hasWorkspace: details.workspacePath !== null,
+		localBranchCount: details.localBranches.length,
+		remoteBranchCount: details.remoteBranches.length,
+		tmuxSessionCount: details.tmuxSessions.length,
+		prs: sortPullRequests(details.prs).map((pr) => ({
+			number: pr.number,
+			title: pr.title,
+			url: pr.url,
+			state: pr.state,
+			isDraft: pr.isDraft
+		})),
+		hasXbrief: details.xbriefPath !== null,
+		hasTasks: details.tasksPath !== null,
+		hasPrd: details.prdPath !== null,
+		dockerContainerCount: details.dockerContainers.length,
+		actualBranch: details.actualBranch,
+		branchDrifted: details.branchDrifted,
+		branchAheadOfMain: details.branchAheadOfMain,
+		workspaceMissing: details.workspaceMissing,
+		remoteAgent: details.remoteAgent,
+		conversations: details.conversations.map((conv) => ({
+			id: conv.id,
+			name: conv.name,
+			title: conv.title,
+			status: conv.status
+		}))
+	};
+}
+function summarizeResourceDetailIdentifiers(details) {
+	return {
+		workspacePaths: details.workspacePath ? [details.workspacePath] : [],
+		localBranchNames: [...details.localBranches].sort(),
+		remoteBranchNames: [...details.remoteBranches].sort(),
+		tmuxSessionNames: [...details.tmuxSessions].sort(),
+		prs: sortPullRequests(details.prs).map((pr) => ({
+			number: pr.number,
+			title: pr.title,
+			state: pr.state,
+			isDraft: pr.isDraft
+		})),
+		dockerContainerNames: [...details.dockerContainers].sort()
+	};
+}
+function hasRecentActivity(lastActivity) {
+	return lastActivity !== null && Number.isFinite(lastActivity) && Date.now() - lastActivity < RECENT_ACTIVITY_WINDOW_MS;
+}
+function isLiveResource(issue) {
+	return issue.resourceDetails.remoteAgent !== null || issue.resourceDetails.tmuxSessions.length > 0 || issue.resourceDetails.dockerContainers.length > 0 || hasOpenPr(issue);
+}
+function isActiveTrackerState(state) {
+	return state === "in_progress" || state === "in_review" || state === "started";
+}
+function isTerminalTrackerState(state) {
+	return state === "closed" || state === "done" || state === "canceled" || state === "completed";
+}
+function hasOpenPr(issue) {
+	return issue.resourceDetails.prs.some((pr) => pr.state === "OPEN" || pr.state === "open");
+}
+function shouldLoadReviewStatus(issue) {
+	return issue.resourceSources.size > 0 && (!isTerminalTrackerState(issue.trackerState) || hasOpenPr(issue)) && (isLiveResource(issue) || isActiveTrackerState(issue.trackerState) && issue.branch != null);
+}
+/**
+* tmux session-name prefixes that map a session to its issue in the Command Deck
+* tree. `strike-` MUST be included (PAN-1682): strike sessions are named
+* `strike-<issue>` and a strike issue is typically `todo` (not an active tracker
+* state), so without registering the tmux resource the issue is filtered out of
+* the tree entirely. Keep this list in sync with the agent-session prefixes the
+* dashboard recognizes elsewhere (e.g. routes/agents.ts).
+*/
+const DISCOVERABLE_SESSION_PREFIXES = [
+	"agent-",
+	"planning-",
+	"specialist-",
+	"review-",
+	"strike-"
+];
+function isDiscoverableAgentSession(sessionName) {
+	return DISCOVERABLE_SESSION_PREFIXES.some((prefix) => sessionName.startsWith(prefix));
+}
+async function loadOpenPullRequests(projects) {
+	const pullRequests = /* @__PURE__ */ new Map();
+	await Promise.all(projects.map(async (project) => {
+		if (!project.config.github_repo) return;
+		const [owner, repo] = project.config.github_repo.split("/");
+		if (!owner || !repo) return;
+		try {
+			const prs = await listOpenPullRequestsSnapshot(owner, repo);
+			for (const row of prs) {
+				if (row.number === void 0 || row.title === void 0 || row.url === void 0 || row.state === void 0 || row.isDraft === void 0 || row.baseRefName === void 0) continue;
+				const pr = {
+					number: row.number,
+					title: row.title,
+					url: row.url,
+					state: row.state,
+					isDraft: row.isDraft,
+					headRefName: row.headRefName,
+					baseRefName: row.baseRefName
+				};
+				const issueId = parseIssueIdFromTextSync(pr.headRefName);
+				if (!issueId) continue;
+				const existing = pullRequests.get(issueId) ?? [];
+				existing.push(pr);
+				pullRequests.set(issueId, existing);
+			}
+		} catch {}
+	}));
+	for (const [issueId, prs] of pullRequests) pullRequests.set(issueId, sortPullRequests(prs));
+	return pullRequests;
+}
+const PROJECT_BRANCH_PATTERNS = [
+	"refs/heads/feature/*",
+	"refs/remotes/origin/feature/*",
+	"refs/heads/bypass/*",
+	"refs/remotes/origin/bypass/*"
+];
+async function loadProjectBranchSnapshot(projectPath) {
+	const run = (extraArgs = []) => execFileAsync("git", [
+		"for-each-ref",
+		"--format=%(refname:short)",
+		...extraArgs,
+		...PROJECT_BRANCH_PATTERNS
+	], {
+		cwd: projectPath,
+		encoding: "utf-8",
+		timeout: 1e4
+	}).catch(() => ({ stdout: "" }));
+	const [allRefs, unmergedRefs] = await Promise.all([run(), run(["--no-merged=main"])]);
+	const branches = allRefs.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+	const ahead = new Set(unmergedRefs.stdout.split("\n").map((line) => line.trim()).filter(Boolean));
+	return {
+		local: branches.filter((branch) => !branch.startsWith("origin/")),
+		remote: branches.filter((branch) => branch.startsWith("origin/")),
+		ahead
+	};
+}
+async function scanWorkspace(workspacesDir, workspaceName) {
+	const workspacePath = join(workspacesDir, workspaceName);
+	const projectRoot = join(workspacesDir, "..");
+	const workspaceEntries = new Set(await readdir(workspacePath).catch(() => []));
+	const panEntries = workspaceEntries.has(".pan") ? new Set(await readdir(join(workspacePath, PAN_DIRNAME)).catch(() => [])) : /* @__PURE__ */ new Set();
+	const issueMatch = workspaceName.match(/^feature-([a-z]+-\d+)$/i);
+	const issueId = issueMatch ? issueMatch[1].toUpperCase() : null;
+	const specEntry = issueId ? await Effect.runPromise(findSpecByIssue(projectRoot, issueId)).catch(() => null) : null;
+	const xbriefPath = specEntry ? specEntry.path : null;
+	let xbriefMtime = null;
+	if (xbriefPath) try {
+		xbriefMtime = (await stat(xbriefPath)).mtimeMs;
+	} catch {
+		xbriefMtime = null;
+	}
+	return {
+		workspacePath,
+		hasPlanning: workspaceEntries.has(PAN_DIRNAME),
+		hasPrd: panEntries.has("prd.md"),
+		hasState: panEntries.has(PAN_CONTINUE_FILENAME),
+		hasXbrief: xbriefPath !== null,
+		xbriefPath,
+		xbriefMtime,
+		hasTasks: xbriefPath !== null
+	};
+}
+async function computeResourceAllocatedIssues(projectConfigs, sharedSignals) {
+	const registeredProjects = listProjectsSync();
+	const projects = projectConfigs.map((config) => registeredProjects.find((entry) => entry.config.path === config.path) ?? {
+		key: config.name ?? config.path,
+		config
+	});
+	const { trackerIssues, tmuxSessions, dockerContainers, conversations, remoteAgentStates } = sharedSignals ?? await captureSharedResourceSignals();
+	const pullRequests = await loadOpenPullRequests(projects);
+	const issueMap = /* @__PURE__ */ new Map();
+	const projectByPrefix = /* @__PURE__ */ new Map();
+	for (const project of projects) for (const prefix of projectPrefixes(project)) projectByPrefix.set(prefix, project);
+	const projectRefFromResolved = (resolvedProject) => projects.find((project) => project.key === resolvedProject.projectKey || project.config.path === resolvedProject.projectPath) ?? null;
+	const resolveProjectRef = (issueId, preferredProject) => {
+		if (preferredProject) return preferredProject;
+		const resolvedProject = resolveProjectFromIssueSync(issueId);
+		if (resolvedProject) {
+			const project = projectRefFromResolved(resolvedProject);
+			if (project) return project;
+		}
+		const prefix = issueId.toUpperCase().match(/^([A-Z]+)-\d+$/)?.[1] ?? "";
+		return projectByPrefix.get(prefix) ?? null;
+	};
+	const ensureIssue = (issueId, preferredProject) => {
+		const upper = issueId.toUpperCase();
+		const existing = issueMap.get(upper);
+		if (existing) return existing;
+		const resolved = resolveProjectRef(upper, preferredProject);
+		if (!resolved) return null;
+		const tracker = trackerIssues.get(upper);
+		const created = {
+			issueId: upper,
+			title: tracker?.title?.trim() || upper,
+			projectName: resolved.config.name ?? resolved.key,
+			branch: `feature/${upper.toLowerCase()}`,
+			trackerState: typeof tracker?.state === "string" ? tracker.state : null,
+			rawTrackerState: tracker?.rawTrackerState,
+			isRally: tracker?.source === "rally",
+			hasPlanning: false,
+			hasPrd: false,
+			hasState: false,
+			isShadow: false,
+			agentStatus: null,
+			readyForMerge: false,
+			lastActivity: null,
+			resourceSources: /* @__PURE__ */ new Set(),
+			resourceDetails: {
+				tmuxSessions: [],
+				workspacePath: null,
+				localBranches: [],
+				remoteBranches: [],
+				prs: [],
+				xbriefPath: null,
+				xbriefMtime: null,
+				tasksPath: null,
+				prdPath: null,
+				dockerContainers: [],
+				actualBranch: null,
+				branchDrifted: false,
+				branchAheadOfMain: false,
+				workspaceMissing: false,
+				remoteAgent: null,
+				conversations: []
+			},
+			taskTotals: null
+		};
+		issueMap.set(upper, created);
+		return created;
+	};
+	for (const [issueId, tracker] of trackerIssues) {
+		const issue = ensureIssue(issueId);
+		if (!issue) continue;
+		issue.title = tracker.title?.trim() || issue.title;
+		issue.trackerState = typeof tracker.state === "string" ? tracker.state : issue.trackerState;
+		issue.rawTrackerState = tracker.rawTrackerState ?? issue.rawTrackerState;
+		issue.isRally = tracker.source === "rally";
+		issue.resourceSources.add("tracker");
+	}
+	for (const sessionName of tmuxSessions) {
+		if (!isDiscoverableAgentSession(sessionName)) continue;
+		const issueId = parseIssueIdFromTextSync(sessionName);
+		if (!issueId) continue;
+		const issue = ensureIssue(issueId);
+		if (!issue) continue;
+		issue.resourceSources.add("tmux");
+		if (!issue.resourceDetails.tmuxSessions.includes(sessionName)) issue.resourceDetails.tmuxSessions.push(sessionName);
+	}
+	for (const conv of conversations) {
+		if (!conv.issueId || conv.archivedAt) continue;
+		const issue = ensureIssue(conv.issueId);
+		if (!issue) continue;
+		issue.resourceSources.add("conversation");
+		issue.resourceDetails.conversations.push({
+			id: conv.id,
+			name: conv.name,
+			title: conv.title,
+			status: conv.status,
+			tmuxSession: conv.tmuxSession
+		});
+	}
+	for (const remoteState of remoteAgentStates) {
+		const issue = ensureIssue(remoteState.issueId);
+		if (!issue) continue;
+		issue.resourceSources.add("remote-agent");
+		issue.resourceDetails.remoteAgent = {
+			vmName: remoteState.vmName,
+			status: remoteState.status,
+			model: remoteState.model,
+			startedAt: remoteState.startedAt
+		};
+		if (!issue.agentStatus) issue.agentStatus = "active";
+	}
+	for (const containerName of dockerContainers) {
+		const issueId = parseIssueIdFromTextSync(containerName.replace(/feature\//g, "feature-"));
+		if (!issueId) continue;
+		const issue = ensureIssue(issueId);
+		if (!issue) continue;
+		issue.resourceSources.add("docker");
+		issue.resourceDetails.dockerContainers.push(containerName);
+	}
+	await Promise.all(projects.map(async (project) => {
+		const projectPath = project.config.path;
+		const workspacesDir = join(projectPath, "workspaces");
+		const resolverRows = listWorkspaces({
+			projectId: project.key,
+			kind: "issue"
+		});
+		const [workspaceCandidates, branches] = await Promise.all([resolverRows.length > 0 ? Promise.resolve(resolverRows.map((row) => ({
+			name: basename(row.path),
+			issueId: (row.issueId ?? basename(row.path).replace(/^feature-/, "")).toUpperCase()
+		}))) : readdir(workspacesDir, { withFileTypes: true }).then((entries) => entries.filter((entry) => entry.isDirectory() && entry.name.startsWith("feature-")).map((entry) => ({
+			name: entry.name,
+			issueId: entry.name.replace(/^feature-/, "").toUpperCase()
+		}))).catch(() => []), loadProjectBranchSnapshot(projectPath)]);
+		await Promise.all(workspaceCandidates.map(async ({ name, issueId }) => {
+			const issue = ensureIssue(issueId, project);
+			if (!issue) return;
+			const workspace = await scanWorkspace(workspacesDir, name);
+			issue.resourceSources.add("workspace");
+			issue.resourceDetails.workspacePath = workspace.workspacePath;
+			issue.hasPlanning = workspace.hasPlanning;
+			issue.hasPrd = workspace.hasPrd;
+			issue.hasState = workspace.hasState;
+			if (workspace.xbriefPath) {
+				issue.resourceSources.add("vbrief");
+				issue.resourceDetails.xbriefPath = workspace.xbriefPath;
+				issue.resourceDetails.xbriefMtime = workspace.xbriefMtime;
+			}
+			if (workspace.hasTasks) {
+				issue.resourceSources.add("tasks");
+				issue.resourceDetails.tasksPath = join(workspace.workspacePath, ".tasks");
+			}
+			const gitInfo = await resolveAgentGitInfo(workspace.workspacePath, issue.branch);
+			issue.resourceDetails.actualBranch = gitInfo.actualBranch;
+			issue.resourceDetails.branchDrifted = gitInfo.branchDrifted;
+			issue.resourceDetails.workspaceMissing = gitInfo.workspaceMissing;
+		}));
+		for (const [branch, key] of [...branches.local.map((b) => [b, "localBranches"]), ...branches.remote.map((b) => [b, "remoteBranches"])]) {
+			const issueId = parseIssueIdFromTextSync(branch);
+			if (!issueId) continue;
+			const issue = ensureIssue(issueId, project);
+			if (!issue) continue;
+			issue.resourceSources.add("branch");
+			if (!issue.resourceDetails[key].includes(branch)) issue.resourceDetails[key].push(branch);
+			if (branches.ahead.has(branch)) issue.resourceDetails.branchAheadOfMain = true;
+		}
+	}));
+	for (const [issueId, prs] of pullRequests) {
+		const issue = ensureIssue(issueId);
+		if (!issue) continue;
+		issue.resourceSources.add("pr");
+		issue.resourceDetails.prs = prs;
+		const bestTitle = prs.find((pr) => !pr.isDraft)?.title ?? prs[0]?.title;
+		issue.title = issue.title === issue.issueId && bestTitle ? bestTitle : issue.title;
+	}
+	await Promise.all([...issueMap.values()].map(async (issue) => {
+		if (issue.resourceDetails.tmuxSessions.length === 0) return;
+		const states = (await Promise.all(issue.resourceDetails.tmuxSessions.map((sessionName) => Effect.runPromise(getAgentRuntimeState(sessionName)).catch(() => null)))).filter((state) => state !== null);
+		if (states.length === 0) return;
+		issue.agentStatus = (states.find((state) => state.state === "active") ?? states.reduce((a, b) => Date.parse(a.lastActivity) >= Date.parse(b.lastActivity) ? a : b)).state;
+		const lastActivity = Math.max(...states.map((state) => Date.parse(state.lastActivity)).filter(Number.isFinite));
+		issue.lastActivity = Number.isFinite(lastActivity) ? lastActivity : null;
+	}));
+	const reviewStatusIssueIds = [...issueMap.values()].filter(shouldLoadReviewStatus).map((issue) => issue.issueId);
+	if (reviewStatusIssueIds.length > 0) {
+		const readyForMergeFlags = loadReadyForMergeFlags(reviewStatusIssueIds);
+		for (const issue of issueMap.values()) issue.readyForMerge = readyForMergeFlags.get(issue.issueId) ?? false;
+	}
+	const memberships = /* @__PURE__ */ new Map();
+	const unavailableProjects = /* @__PURE__ */ new Set();
+	const projectMemberships = readPipelineMembershipSnapshotsForProjects(projects.map((project) => project.config));
+	for (const result of projectMemberships) {
+		if (result.error) unavailableProjects.add(result.project.name);
+		for (const membership of result.memberships ?? []) {
+			ensureIssue(membership.issueId);
+			memberships.set(membership.issueId, membership);
+		}
+	}
+	await Promise.all([...issueMap.values()].map(async (issue) => {
+		const project = resolveProjectRef(issue.issueId);
+		if (!project) return;
+		const draft = await Effect.runPromise(findDraftPrd(project.config.path, issue.issueId)).catch(() => null);
+		if (!draft) return;
+		issue.resourceSources.add("prd");
+		issue.resourceDetails.prdPath = draft.path;
+		issue.hasPrd = true;
+	}));
+	const untitledIssueIds = [...issueMap.values()].filter((issue) => issue.resourceSources.size > 0 && issue.title === issue.issueId).map((issue) => issue.issueId);
+	if (untitledIssueIds.length > 0) {
+		const fallbackTitles = await resolveMissingIssueTitles(untitledIssueIds).catch(() => /* @__PURE__ */ new Map());
+		for (const issue of issueMap.values()) {
+			const title = fallbackTitles.get(issue.issueId);
+			if (title && issue.title === issue.issueId) issue.title = title;
+		}
+	}
+	return [...issueMap.values()].filter((issue) => issue.resourceSources.size > 0).filter((issue) => {
+		const membership = memberships.get(issue.issueId);
+		return membership?.inPipeline === true || membership?.bucket === "clean_terminal" && isLiveResource(issue) || !membership && unavailableProjects.has(issue.projectName) && isLiveResource(issue);
+	}).map((issue) => {
+		const membership = memberships.get(issue.issueId);
+		const hasTmux = issue.resourceDetails.tmuxSessions.length > 0;
+		const hasRecentHeartbeat = hasRecentActivity(issue.lastActivity);
+		const stateLabel = deriveStateLabel(issue, hasTmux, hasRecentHeartbeat, membership);
+		const isRemoteRunning = issue.resourceDetails.remoteAgent?.status === "running" || issue.resourceDetails.remoteAgent?.status === "starting";
+		const status = hasTmux && (issue.agentStatus === "active" || hasRecentHeartbeat) || isRemoteRunning ? "running" : issue.hasState ? "has_state" : "idle";
+		return {
+			issueId: issue.issueId,
+			title: issue.title,
+			projectName: issue.projectName,
+			branch: issue.branch,
+			status,
+			stateLabel,
+			agentStatus: issue.agentStatus,
+			hasPlanning: issue.hasPlanning,
+			hasPrd: issue.hasPrd,
+			hasState: issue.hasState,
+			isShadow: issue.isShadow,
+			isRally: issue.isRally,
+			childCount: trackerIssues.get(issue.issueId)?.totalChildCount,
+			completedCount: trackerIssues.get(issue.issueId)?.completedChildCount,
+			inProgressCount: trackerIssues.get(issue.issueId)?.inProgressChildCount,
+			readyForMerge: issue.readyForMerge,
+			rawTrackerState: issue.rawTrackerState,
+			resourceSources: new Set([...issue.resourceSources].sort()),
+			resourceDetails: issue.resourceDetails,
+			taskTotals: issue.taskTotals,
+			pipelineBucket: membership?.bucket,
+			specOnlyPlanned: membership ? membership.bucket === "planned_backlog" && membership.reasons.includes("open issue with an xBRIEF spec but no branch/PR — planned work whose plan encodes code paths that age; needs starting or re-planning") : void 0,
+			resourceDrift: membership ? !membership.inPipeline : void 0
+		};
+	}).sort((a, b) => compareIssueIds(a.issueId, b.issueId));
+}
+function toPublicResourceIssue(issue) {
+	return {
+		...issue,
+		resourceSources: [...issue.resourceSources],
+		resourceDetails: summarizeResourceDetails(issue.resourceDetails)
+	};
+}
+function rebuildCombinedResourceSnapshot() {
+	const detailed = [...projectResourceSnapshots.values()].flatMap((snapshot) => snapshot.detailed).sort((a, b) => compareIssueIds(a.issueId, b.issueId));
+	const publicIssues = detailed.map(toPublicResourceIssue);
+	cachedDetailedResourceIssues = detailed;
+	cachedResourceIssues = {
+		value: publicIssues,
+		computedAt: Math.max(0, ...[...projectResourceSnapshots.values()].map((snapshot) => snapshot.computedAt))
+	};
+	return publicIssues;
+}
+function publishProjectResourceSnapshot(project, issues) {
+	projectResourceSnapshots.set(project.path, {
+		detailed: issues,
+		public: issues.map(toPublicResourceIssue),
+		computedAt: Date.now()
+	});
+	rebuildCombinedResourceSnapshot();
+}
+/** Refresh only the requested projects, capturing fleet-wide signals once for the batch. */
+async function refreshResourceAllocatedProjects(projects, options = {}) {
+	if (projects.length === 0) return cachedResourceIssues?.value ?? [];
+	const sharedSignals = await captureSharedResourceSignals();
+	const failures = [];
+	for (const project of projects) try {
+		if (options.refreshMembership !== false) await refreshMembershipSnapshotsForProjects([project]);
+		publishProjectResourceSnapshot(project, await computeResourceAllocatedIssues([project], sharedSignals));
+	} catch (error) {
+		const failure = error instanceof Error ? error : new Error(String(error));
+		failures.push(failure);
+		console.warn(`[resource-discovery] refresh failed for ${project.name ?? project.path}; keeping last-good snapshot:`, failure.message);
+	}
+	if (failures.length > 0) throw new AggregateError(failures, `${failures.length} project resource refresh(es) failed`);
+	return cachedResourceIssues?.value ?? [];
+}
+async function getCachedResourceAllocatedIssues() {
+	return cachedResourceIssues?.value ?? [];
+}
+function sanitizeResourceAllocatedIssues(issues) {
+	return issues.map((issue) => ({
+		...issue,
+		resourceDetails: {
+			hasWorkspace: issue.resourceDetails.hasWorkspace,
+			localBranchCount: issue.resourceDetails.localBranchCount,
+			remoteBranchCount: issue.resourceDetails.remoteBranchCount,
+			tmuxSessionCount: issue.resourceDetails.tmuxSessionCount,
+			prs: issue.resourceDetails.prs.map((pr) => ({
+				number: pr.number,
+				title: pr.title,
+				state: pr.state,
+				isDraft: pr.isDraft
+			})),
+			hasXbrief: issue.resourceDetails.hasXbrief,
+			hasTasks: issue.resourceDetails.hasTasks,
+			hasPrd: issue.resourceDetails.hasPrd,
+			dockerContainerCount: issue.resourceDetails.dockerContainerCount,
+			actualBranch: issue.resourceDetails.actualBranch,
+			branchDrifted: issue.resourceDetails.branchDrifted,
+			branchAheadOfMain: issue.resourceDetails.branchAheadOfMain,
+			workspaceMissing: issue.resourceDetails.workspaceMissing,
+			remoteAgent: issue.resourceDetails.remoteAgent ?? null,
+			conversations: issue.resourceDetails.conversations.map((conv) => ({
+				id: conv.id,
+				name: conv.name,
+				title: conv.title,
+				status: conv.status
+			}))
+		}
+	}));
+}
+function toPublicResourceDetailIdentifiers(details) {
+	return summarizeResourceDetailIdentifiers(details);
+}
+async function getResourceDetailIdentifiers(issueId) {
+	const normalizedIssueId = issueId.toUpperCase();
+	const cachedMatch = cachedDetailedResourceIssues?.find((entry) => entry.issueId === normalizedIssueId);
+	return cachedMatch ? toPublicResourceDetailIdentifiers(cachedMatch.resourceDetails) : null;
+}
+function groupResourceAllocatedIssuesByProject(issues) {
+	const projectTree = /* @__PURE__ */ new Map();
+	for (const issue of issues) {
+		const existing = projectTree.get(issue.projectName);
+		if (existing) {
+			existing.features.push(issue);
+			continue;
+		}
+		projectTree.set(issue.projectName, {
+			name: issue.projectName,
+			path: issue.projectName,
+			features: [issue]
+		});
+	}
+	return [...projectTree.values()].map((project) => ({
+		...project,
+		features: project.features.sort((a, b) => compareIssueIds(a.issueId, b.issueId))
+	})).sort((a, b) => a.name.localeCompare(b.name));
+}
+//#endregion
+//#region services/project-resource-refresh-queue.ts
+init_projects();
+const PROJECT_RESOURCE_REFRESH_DEBOUNCE_MS = 1e3;
+const PROJECT_RESOURCE_CONVERGENCE_INTERVAL_MS = 5 * 6e4;
+function createProjectResourceRefreshQueue(deps) {
+	const debounceMs = deps.debounceMs ?? 1e3;
+	const now = deps.now ?? Date.now;
+	const pending = /* @__PURE__ */ new Map();
+	const reasons = /* @__PURE__ */ new Map();
+	const idleWaiters = /* @__PURE__ */ new Set();
+	let activeProjectPaths = [];
+	let timer = null;
+	let running = false;
+	let stopped = false;
+	let lastStartedAt = null;
+	let lastCompletedAt = null;
+	let lastError = null;
+	const isIdle = () => !running && timer === null && pending.size === 0;
+	const resolveIdleWaiters = () => {
+		if (!isIdle()) return;
+		for (const resolve of idleWaiters) resolve();
+		idleWaiters.clear();
+	};
+	const drain = async () => {
+		timer = null;
+		if (running || stopped) return;
+		running = true;
+		try {
+			while (!stopped && pending.size > 0) {
+				const projects = [...pending.values()];
+				const reasonsByProjectPath = /* @__PURE__ */ new Map();
+				for (const project of projects) {
+					reasonsByProjectPath.set(project.path, new Set(reasons.get(project.path) ?? []));
+					reasons.delete(project.path);
+				}
+				pending.clear();
+				activeProjectPaths = projects.map((project) => project.path);
+				lastStartedAt = now();
+				try {
+					await deps.refreshProjects(projects, { reasonsByProjectPath });
+					lastError = null;
+				} catch (error) {
+					lastError = error instanceof Error ? error.message : String(error);
+					console.warn("[project-resource-refresh] batch failed:", lastError);
+				} finally {
+					activeProjectPaths = [];
+					lastCompletedAt = now();
+				}
+			}
+		} finally {
+			running = false;
+			resolveIdleWaiters();
+		}
+	};
+	const schedule = () => {
+		if (stopped || running || timer) return;
+		timer = setTimeout(() => void drain(), debounceMs);
+		timer.unref?.();
+	};
+	const enqueueProject = (project, reason) => {
+		if (stopped) return;
+		pending.set(project.path, project);
+		const projectReasons = reasons.get(project.path) ?? /* @__PURE__ */ new Set();
+		projectReasons.add(reason);
+		reasons.set(project.path, projectReasons);
+		schedule();
+	};
+	return {
+		enqueueProject,
+		enqueueProjects(projects, reason) {
+			for (const project of projects) enqueueProject(project, reason);
+		},
+		whenIdle() {
+			if (isIdle()) return Promise.resolve();
+			return new Promise((resolve) => idleWaiters.add(resolve));
+		},
+		getState() {
+			return {
+				running,
+				activeProjectPaths: [...activeProjectPaths],
+				pendingProjectPaths: [...pending.keys()],
+				lastStartedAt,
+				lastCompletedAt,
+				lastError
+			};
+		},
+		stop() {
+			stopped = true;
+			if (timer) clearTimeout(timer);
+			timer = null;
+			pending.clear();
+			reasons.clear();
+			resolveIdleWaiters();
+		}
+	};
+}
+const MEMBERSHIP_REFRESH_REASONS = new Set([
+	"boot-warm",
+	"periodic-convergence",
+	"issue.statusChanged:closed-out",
+	"pull_request:opened",
+	"pull_request:closed",
+	"pull_request:reopened"
+]);
+function shouldRefreshMembershipForResourceRefresh(context) {
+	return [...context.reasonsByProjectPath.values()].some((projectReasons) => [...projectReasons].some((reason) => MEMBERSHIP_REFRESH_REASONS.has(reason)));
+}
+const projectResourceRefreshQueue = createProjectResourceRefreshQueue({ refreshProjects: (projects, context) => refreshResourceAllocatedProjects(projects, { refreshMembership: shouldRefreshMembershipForResourceRefresh(context) }) });
+function enqueueProjectResourceRefresh(project, reason) {
+	projectResourceRefreshQueue.enqueueProject(project, reason);
+}
+function enqueueProjectsResourceRefresh(projects, reason) {
+	projectResourceRefreshQueue.enqueueProjects(projects, reason);
+}
+function whenProjectResourceRefreshIdle() {
+	return projectResourceRefreshQueue.whenIdle();
+}
+function getProjectResourceRefreshQueueState() {
+	return projectResourceRefreshQueue.getState();
+}
+function stopProjectResourceRefreshQueue() {
+	projectResourceRefreshQueue.stop();
+}
+function startProjectResourceConvergence() {
+	const timer = setInterval(() => {
+		enqueueProjectsResourceRefresh(listProjectsSync().map((entry) => entry.config), "periodic-convergence");
+	}, PROJECT_RESOURCE_CONVERGENCE_INTERVAL_MS);
+	timer.unref?.();
+	return () => clearInterval(timer);
+}
+//#endregion
+export { refreshMembershipSnapshotsForProjects as _, enqueueProjectsResourceRefresh as a, startProjectResourceConvergence as c, getCachedResourceAllocatedIssues as d, getResourceDetailIdentifiers as f, readPipelineMembershipSnapshotsForProjects as g, sanitizeResourceAllocatedIssues as h, enqueueProjectResourceRefresh as i, stopProjectResourceRefreshQueue as l, isDiscoverableAgentSession as m, PROJECT_RESOURCE_REFRESH_DEBOUNCE_MS as n, getProjectResourceRefreshQueueState as o, groupResourceAllocatedIssuesByProject as p, createProjectResourceRefreshQueue as r, shouldRefreshMembershipForResourceRefresh as s, PROJECT_RESOURCE_CONVERGENCE_INTERVAL_MS as t, whenProjectResourceRefreshIdle as u, summarizePipelineMembership as v, unavailablePipelineMembership as y };
+
+//# sourceMappingURL=project-resource-refresh-queue-x-K9mvpP.js.map