@overdeck/desktop 0.45.23 → 0.45.24

package/server/flywheel-DzGtWnJ1.js

@@ -0,0 +1,477 @@
+import { Tn as init_projects, f as loadConfigSync, fn as findProjectByPathSync, nn as init_state_read_home, rn as resolveStateReadHomeSync, t as init_config_yaml, tt as resolveModel } from "./config-yaml-DySPNmKN.js";
+import { H as sessionExists, w as init_tmux } from "./tmux-R7N7y-Mh.js";
+import { S as FlywheelStatus, f as FlywheelStats, t as init_src } from "./src-DtcUOZCq.js";
+import { b as init_agents } from "./queries-CjNIf-Ub.js";
+import { s as init_internal_token } from "./internal-token-s0-oKybJ.js";
+import { d as isFlywheelAutoPickupBacklog, i as getFlywheelActiveRunId, p as isFlywheelRequireUatBeforeMerge, s as init_control_settings } from "./control-settings-BQp7_4uD.js";
+import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-3lNZkyT4.js";
+import { f as init_github_app } from "./github-app-C3QrAUd0.js";
+import "./substrate-bug-weights-service-B-FwCs5V.js";
+import { t as init_sequence_io } from "./sequence-io-D909zgeH.js";
+import { A as advanceQueue, B as getBook, D as writeFlywheelLaunchMetadata, L as setStatus, O as writeLatestFlywheelStatus, S as nextFlywheelRunId, _ as clearFlywheelGate, d as spawnFlywheel, h as resolvePrimaryWorktreeRoot, m as requireFlywheelBrief, n as abortSpawnedFlywheel, t as FLYWHEEL_ORCHESTRATOR_AGENT_ID, v as getFlywheelRunDetail, w as readFlywheelLaunchMetadata, x as listFlywheelRuns, y as getFlywheelRunDir, z as computeBookProgress } from "./flywheel-DHrgCphM.js";
+import { r as computeMergeQueue } from "./flywheel-merge-order-UU0tiUld.js";
+import { r as validateBookForStart } from "./validate-IfDGkaVR.js";
+import { join } from "node:path";
+import { Effect, Schema } from "effect";
+import { freemem, totalmem } from "node:os";
+import "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { exec, execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { layer } from "@effect/platform-node/NodeServices";
+//#region ../../cli/commands/flywheel-merge-backend.ts
+init_projects();
+init_config_yaml();
+init_tmux();
+init_src();
+init_internal_token();
+init_control_settings();
+init_harness_resolve();
+init_agents();
+init_github_app();
+//#endregion
+//#region ../../cli/commands/flywheel-orders.ts
+init_state_read_home();
+function orderStateRootFor(cwd) {
+	const project = findProjectByPathSync(cwd);
+	if (!project) throw new Error(`No configured project contains ${cwd}`);
+	return resolveStateReadHomeSync(project).root;
+}
+function validationError(bookId, findings) {
+	return new Error([`Order book ${bookId} cannot start:`, ...findings.map((finding) => `- [${finding.code}] ${finding.issue}: ${finding.message}`)].join("\n"));
+}
+function resolveFlywheelOrderStart(cwd, bookId, deps = {}) {
+	const stateRoot = (deps.orderStateRoot ?? orderStateRootFor)(cwd);
+	const book = (deps.getOrderBook ?? getBook)(stateRoot, bookId);
+	if (!book) throw new Error(`Order book not found: ${bookId}`);
+	if (book.status !== "ready") throw new Error(`Order book ${book.id} must be ready before start (current status: ${book.status})`);
+	const validation = (deps.validateOrderBook ?? validateBookForStart)(stateRoot, book);
+	if (validation.blocks.length > 0) throw validationError(book.id, validation.blocks);
+	return {
+		stateRoot,
+		book
+	};
+}
+async function resolveFlywheelOrderBriefOverlay(cwd, book, deps = {}) {
+	const path = book?.settings.briefOverlay?.trim();
+	if (!path) return {};
+	const brief = await (deps.requireBrief ?? requireFlywheelBrief)(cwd, path);
+	return {
+		briefOverlayPath: brief.displayPath,
+		briefOverlayContent: await (deps.readBrief ?? ((absolutePath) => readFile(absolutePath, "utf8")))(brief.absolutePath)
+	};
+}
+async function compensateFailedFlywheelStart(context, runId, cause, deps = {}) {
+	const failures = [cause];
+	try {
+		await (deps.cleanupSpawnedRun ?? abortSpawnedFlywheel)(runId);
+	} catch (error) {
+		failures.push(error);
+	}
+	if (context) try {
+		await setFlywheelOrderStatus(context, "ready", null, deps);
+	} catch (error) {
+		failures.push(error);
+	}
+	if (failures.length > 1) throw new AggregateError(failures, `Flywheel run ${runId} failed to start and compensation was incomplete`);
+	throw cause;
+}
+async function setFlywheelOrderStatus(context, status, runId, deps = {}) {
+	await (deps.setOrderStatus ?? setStatus)(context.stateRoot, context.book.id, status, runId === void 0 ? {} : { runId });
+}
+//#endregion
+//#region ../../cli/commands/flywheel-complete.ts
+init_projects();
+init_state_read_home();
+function stateRootFor(workspace) {
+	const project = findProjectByPathSync(workspace);
+	if (!project) throw new Error(`No configured project contains ${workspace}`);
+	return resolveStateReadHomeSync(project).root;
+}
+async function readOptionalFile(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch (error) {
+		if ((typeof error === "object" && error !== null && "code" in error ? error.code : void 0) === "ENOENT") return null;
+		throw error;
+	}
+}
+function appendFlywheelRetrospective(report, retro) {
+	const finding = retro?.trim();
+	if (!finding) return {
+		report: `${report.trimEnd()}\n\nRetrospective: no findings recognized.\n`,
+		retrospectiveIncluded: false
+	};
+	return {
+		report: `${report.trimEnd()}\n\n---\n\n## Retrospective\n\n${finding}\n`,
+		retrospectiveIncluded: true
+	};
+}
+function nonTerminalIssues(progress) {
+	return progress.items.filter((item) => !item.terminal).map((item) => item.issue);
+}
+async function completeFlywheelRun(options, deps) {
+	const cwd = options.cwd ?? process.cwd();
+	const status = await deps.loadStatus();
+	if (!status) throw new Error("no flywheel run to complete");
+	const launch = await (deps.readLaunch ?? readFlywheelLaunchMetadata)(status.runId);
+	if (!launch) throw new Error(`Flywheel run ${status.runId} is missing launch metadata`);
+	const bookId = launch.orders?.bookId;
+	if (!bookId) throw new Error(`Flywheel run ${status.runId} is not bound to an order book; use pan flywheel report`);
+	const stateRoot = (deps.stateRoot ?? stateRootFor)(launch.workspace);
+	const book = (deps.getOrderBook ?? getBook)(stateRoot, bookId);
+	if (!book) throw new Error(`Flywheel run ${status.runId} references missing order book ${bookId}`);
+	const progress = (deps.computeProgress ?? computeBookProgress)(book);
+	const remaining = nonTerminalIssues(progress);
+	if (!progress.drained && !options.force) throw new Error(`Order book ${book.id} is not drained; non-terminal items: ${remaining.join(", ")}. Pass --force to complete anyway.`);
+	const runDir = getFlywheelRunDir(status.runId);
+	const retro = await (deps.readRetro ?? readOptionalFile)(join(runDir, "retro.md"));
+	const report = appendFlywheelRetrospective(await deps.buildReport(status, cwd), retro);
+	try {
+		await deps.persistReport(status, cwd, report.report);
+	} finally {
+		deps.clearGate(status.runId);
+	}
+	const nextBook = await (deps.advance ?? advanceQueue)(stateRoot, book.id);
+	const startOptions = {
+		cwd: launch.workspace,
+		brief: launch.briefPath
+	};
+	if (nextBook) {
+		const next = await deps.start({
+			...startOptions,
+			orders: nextBook.id
+		});
+		return {
+			runId: status.runId,
+			reportPath: join(runDir, "report.md"),
+			retrospectiveIncluded: report.retrospectiveIncluded,
+			continuation: "next-book",
+			nextRunId: next.runId,
+			nextBookId: nextBook.id
+		};
+	}
+	if ((deps.autoPickupBacklog ?? isFlywheelAutoPickupBacklog)()) {
+		const next = await deps.start(startOptions);
+		return {
+			runId: status.runId,
+			reportPath: join(runDir, "report.md"),
+			retrospectiveIncluded: report.retrospectiveIncluded,
+			continuation: "backlog",
+			nextRunId: next.runId
+		};
+	}
+	return {
+		runId: status.runId,
+		reportPath: join(runDir, "report.md"),
+		retrospectiveIncluded: report.retrospectiveIncluded,
+		continuation: "needs-you"
+	};
+}
+function createFlywheelCompleteCommand(deps) {
+	return async (options = {}) => {
+		try {
+			const result = await completeFlywheelRun(options, deps);
+			if (result.continuation === "next-book") console.log(`Completed ${result.runId}; started ${result.nextRunId} with order book ${result.nextBookId}.`);
+			else if (result.continuation === "backlog") console.log(`Completed ${result.runId}; started ${result.nextRunId} in backlog mode.`);
+			else console.log("needs-you: pipeline idle — no order book queued and auto-pickup is off");
+		} catch (error) {
+			console.error(error instanceof Error ? error.message : String(error));
+			process.exitCode = 1;
+		}
+	};
+}
+//#endregion
+//#region ../../cli/commands/flywheel-surfaces.ts
+init_sequence_io();
+init_control_settings();
+init_github_app();
+promisify(exec);
+promisify(execFile);
+//#endregion
+//#region ../../cli/commands/flywheel.ts
+init_control_settings();
+Schema.decodeUnknownSync(FlywheelStatus);
+Schema.decodeUnknownSync(FlywheelStats);
+const execAsync = promisify(exec);
+function mb(bytes) {
+	return Math.round(bytes / 1024 / 1024);
+}
+async function resolveFlywheelRoleConfig() {
+	const { config } = loadConfigSync();
+	const flywheel = config.roles?.flywheel;
+	const model = resolveModel("flywheel", void 0, config);
+	return {
+		harness: await resolveHarness({ model }),
+		model,
+		effort: flywheel?.effort ?? "high",
+		minAgents: flywheel?.minAgents ?? 20,
+		maxAgents: flywheel?.maxAgents ?? 30,
+		scope: flywheel?.scope ?? "pan-only",
+		autoPickupBacklog: isFlywheelAutoPickupBacklog(),
+		requireUatBeforeMerge: isFlywheelRequireUatBeforeMerge()
+	};
+}
+async function createInitialFlywheelStatus(runId, startedAt, cwd, agentModel, agentHarness, roleConfig) {
+	const ramTotalMb = mb(totalmem());
+	return {
+		runId,
+		startedAt,
+		elapsedMs: 0,
+		orchestrator: {
+			harness: agentHarness ?? roleConfig.harness,
+			model: agentModel ?? roleConfig.model,
+			effort: roleConfig.effort,
+			ctxPercent: 0
+		},
+		headline: {
+			bugsFixed: 0,
+			swarmItemsMerged: 0,
+			swarmItemsTotal: 0,
+			prsMerged: 0,
+			awaitingUat: 0
+		},
+		activePipeline: [],
+		substrateBugs: [],
+		agents: [{
+			id: FLYWHEEL_ORCHESTRATOR_AGENT_ID,
+			label: "flywheel-orchestrator",
+			status: "running",
+			role: "flywheel",
+			model: agentModel
+		}],
+		parked: [],
+		suggestions: [],
+		system: {
+			mainHead: await gitOutput("git rev-parse --short HEAD", cwd).catch(() => "unknown"),
+			ramUsedMb: Math.max(0, ramTotalMb - mb(freemem())),
+			ramTotalMb,
+			swapUsedMb: 0,
+			swapTotalMb: 0,
+			agentsActive: 1,
+			agentsCap: roleConfig.maxAgents
+		},
+		openQuestions: [],
+		ticks: 0,
+		lastTickAt: startedAt
+	};
+}
+async function startFlywheelRun(options = {}, deps = {}) {
+	const cwd = options.cwd ?? await (deps.resolvePrimaryRoot ?? resolvePrimaryWorktreeRoot)(process.cwd());
+	const brief = await (deps.requireBrief ?? requireFlywheelBrief)(cwd, options.brief);
+	const orderContext = options.orders ? resolveFlywheelOrderStart(cwd, options.orders, deps) : null;
+	const book = orderContext?.book ?? null;
+	const overlay = await resolveFlywheelOrderBriefOverlay(cwd, book, deps);
+	const runId = await (deps.nextRunId ?? nextFlywheelRunId)();
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const launchMetadata = {
+		version: 1,
+		runId,
+		workspace: cwd,
+		briefPath: brief.absolutePath,
+		briefDisplayPath: brief.displayPath,
+		...overlay.briefOverlayPath ? { briefOverlayPath: overlay.briefOverlayPath } : {},
+		...book ? { orders: { bookId: book.id } } : {}
+	};
+	await (deps.writeLaunchMetadata ?? writeFlywheelLaunchMetadata)(launchMetadata);
+	const roleConfig = await (deps.resolveRoleConfig ?? resolveFlywheelRoleConfig)();
+	const agent = await (deps.spawn ?? spawnFlywheel)({
+		runId,
+		briefPath: brief.absolutePath,
+		...overlay,
+		workspace: cwd,
+		model: roleConfig.model,
+		harness: roleConfig.harness,
+		effort: roleConfig.effort,
+		minAgents: roleConfig.minAgents,
+		maxAgents: roleConfig.maxAgents,
+		scope: roleConfig.scope,
+		autoPickupBacklog: roleConfig.autoPickupBacklog,
+		requireUatBeforeMerge: roleConfig.requireUatBeforeMerge
+	});
+	try {
+		if (orderContext) await setFlywheelOrderStatus(orderContext, "running", runId, deps);
+		await (deps.writeStatus ?? writeLatestFlywheelStatus)(await createInitialFlywheelStatus(runId, startedAt, cwd, agent.model, agent.harness, roleConfig));
+		return {
+			runId,
+			briefDisplayPath: brief.displayPath,
+			agentModel: agent.model
+		};
+	} catch (error) {
+		return compensateFailedFlywheelStart(orderContext, runId, error, deps);
+	}
+}
+function runNumberFromRunId(runId) {
+	const match = /^RUN-(\d+)$/.exec(runId);
+	if (!match) throw new Error(`Invalid Flywheel run id for report: ${runId}`);
+	return Number(match[1]);
+}
+function reportDate(status) {
+	return status.lastTickAt.slice(0, 10);
+}
+function tableCell(value) {
+	return String(value ?? "").replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+function formatFlywheelStateReport(status, mergeQueue = []) {
+	const runNumber = runNumberFromRunId(status.runId);
+	const suggestionRows = status.suggestions.length > 0 ? status.suggestions.map((suggestion) => `| ${tableCell(suggestion.priority)} | ${tableCell(suggestion.action)} | ${tableCell(suggestion.issueId)} | ${tableCell(suggestion.rationale)} |`).join("\n") : "No suggestions emitted this run.";
+	const activePipelineRows = status.activePipeline.length > 0 ? status.activePipeline.map((item) => `| ${tableCell(item.issueId)} | ${tableCell(item.verb)} | ${tableCell(item.status)} | ${tableCell(item.title)} | ${tableCell(item.progressPercent)} | ${tableCell(item.pr)} |`).join("\n") : "| _None_ |  |  |  |  |  |";
+	const substrateRows = status.substrateBugs.length > 0 ? status.substrateBugs.map((bug) => `| ${tableCell(bug.issueId)} | ${tableCell(bug.status)} | ${tableCell(bug.title)} | ${tableCell(bug.commitSha?.slice(0, 10))} |`).join("\n") : "| _None_ |  |  |  |";
+	const patternLines = status.parked.length > 0 ? status.parked.map((item) => `- **${item.issueId}** (${item.reason}) — ${item.title}`).join("\n") : "- None recorded this run.";
+	const questionLines = status.openQuestions.length > 0 ? status.openQuestions.map((question) => `- ${question}`).join("\n") : "- None.";
+	const mergeQueueSection = mergeQueue.length > 0 ? `## Merge Queue
+
+Merge ship-ready PRs in this order to avoid rebase conflicts. Branches with overlapping file changes must be merged in sequence; non-overlapping branches can be merged in any order.
+
+| # | Issue | PR | Conflicts With |
+|---|---|---|---|
+${mergeQueue.map((item) => {
+		const prCell = item.pr != null ? `#${item.pr}` : "—";
+		const conflictsCell = item.conflictsWith.length > 0 ? item.conflictsWith.join(", ") : "—";
+		return `| ${item.mergeOrder} | ${item.issueId} | ${prCell} | ${conflictsCell} |`;
+	}).join("\n")}
+
+---
+
+` : "";
+	return `# Flywheel Run ${runNumber} Report — ${reportDate(status)}
+
+Per-run report derived from the last \`FlywheelStatus\` snapshot. Durable cumulative memory across runs lives in \`docs/FLYWHEEL-STATE.md\`.
+
+**Run window:** ${status.startedAt} → ${status.lastTickAt} (${status.orchestrator.harness}, ${status.orchestrator.model}, ${status.orchestrator.effort})
+
+**Headline result:** ${status.headline.bugsFixed} substrate bugs fixed; ${status.headline.swarmItemsMerged}/${status.headline.swarmItemsTotal} SWARM items merged; ${status.headline.prsMerged} PRs merged; ${status.headline.awaitingUat} awaiting UAT.
+
+**Run counters:** ticks ${status.ticks}; last tick ${status.lastTickAt}; orchestrator context ${status.orchestrator.ctxPercent}%.
+
+---
+
+${mergeQueueSection}## Suggestions
+
+${status.suggestions.length > 0 ? `| Priority | Action | Issue | Rationale |
+|---|---|---|---|
+${suggestionRows}` : suggestionRows}
+
+---
+
+## Active Pipeline
+
+| Issue | Verb | Status | Title | Progress | PR |
+|---|---|---|---|---:|---:|
+${activePipelineRows}
+
+---
+
+## Cycling Alerts
+
+${questionLines}
+
+---
+
+## Infrastructure Gaps
+
+| Issue | Status | Notes | Commit |
+|---|---|---|---|
+${substrateRows}
+
+---
+
+## Pattern Ledger
+
+${patternLines}
+
+---
+
+## Skill Gaps
+
+- Keep \`pan flywheel report\` in the closeout path so run summaries stay archived under the run directory.
+`;
+}
+async function isFlywheelStateDirty(cwd) {
+	try {
+		const { stdout } = await execAsync("git status --porcelain docs/FLYWHEEL-STATE.md", {
+			cwd,
+			encoding: "utf8"
+		});
+		return stdout.trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+async function loadReportFlywheelStatus() {
+	const activeRunId = getFlywheelActiveRunId();
+	if (activeRunId) {
+		const activeDetail = await getFlywheelRunDetail(activeRunId);
+		if (activeDetail?.latest) return activeDetail.latest;
+	}
+	const runs = await listFlywheelRuns();
+	const run = runs.find((candidate) => candidate.status === "running") ?? runs[0];
+	if (!run) return null;
+	return (await getFlywheelRunDetail(run.id))?.latest ?? null;
+}
+async function gitOutput(command, cwd) {
+	const { stdout } = await execAsync(command, {
+		cwd,
+		encoding: "utf8"
+	});
+	return stdout.trim();
+}
+async function commitFlywheelStateChanges(cwd, runNumber) {
+	const subject = `docs(flywheel): run ${runNumber}`;
+	await execAsync("git add docs/FLYWHEEL-STATE.md", { cwd });
+	await execAsync(await gitOutput("git log -1 --format=%s", cwd).catch(() => "") === subject ? `git commit --amend -m ${JSON.stringify(subject)}` : `git commit -m ${JSON.stringify(subject)}`, {
+		cwd,
+		encoding: "utf8"
+	});
+}
+function clearFlywheelRunGate(runId) {
+	if (getFlywheelActiveRunId() === runId) clearFlywheelGate();
+}
+async function buildFlywheelStateReport(status, cwd) {
+	return formatFlywheelStateReport(status, await Effect.runPromise(computeMergeQueue(status.activePipeline, cwd).pipe(Effect.provide(layer))));
+}
+async function persistFlywheelStateReport(status, cwd, report) {
+	const runNumber = runNumberFromRunId(status.runId);
+	await writeFile(join(getFlywheelRunDir(status.runId), "report.md"), report, "utf8");
+	if (await isFlywheelStateDirty(cwd)) {
+		await commitFlywheelStateChanges(cwd, runNumber);
+		console.log(`Wrote per-run report and committed FLYWHEEL-STATE.md changes for run ${runNumber}.`);
+	} else console.log(`Wrote per-run report for run ${runNumber}. No FLYWHEEL-STATE.md changes to commit.`);
+}
+async function flywheelReportCommand(options = {}) {
+	try {
+		const cwd = options.cwd ?? process.cwd();
+		if (!options.force && await Effect.runPromise(sessionExists("flywheel-orchestrator"))) {
+			console.error("Refusing to write report — flywheel orchestrator session is still alive.");
+			console.error("This command finalizes the run (writes report.md and clears the active-run gate).");
+			console.error("Run `pan flywheel pause` (or `pan flywheel abort`) first, or pass --force to override.");
+			process.exitCode = 1;
+			return;
+		}
+		const status = await loadReportFlywheelStatus();
+		if (!status) {
+			console.error("no flywheel run to report");
+			process.exitCode = 1;
+			return;
+		}
+		try {
+			await persistFlywheelStateReport(status, cwd, await buildFlywheelStateReport(status, cwd));
+		} finally {
+			clearFlywheelRunGate(status.runId);
+		}
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : String(error));
+		process.exitCode = 1;
+	}
+}
+createFlywheelCompleteCommand({
+	loadStatus: loadReportFlywheelStatus,
+	buildReport: buildFlywheelStateReport,
+	persistReport: persistFlywheelStateReport,
+	clearGate: clearFlywheelRunGate,
+	start: startFlywheelRun
+});
+//#endregion
+export { flywheelReportCommand, startFlywheelRun };
+
+//# sourceMappingURL=flywheel-DzGtWnJ1.js.map

package/server/flywheel-SVF02Jpq.js

@@ -0,0 +1,2 @@
+import { c as pauseFlywheel, l as resumeFlywheel } from "./flywheel-DHrgCphM.js";
+export { pauseFlywheel, resumeFlywheel };

package/server/{flywheel-merge-order-DxbQKE1d.js → flywheel-merge-order-UU0tiUld.js}

@@ -1,9 +1,9 @@
-import { Tn as init_projects, fn as findProjectByPathSync, vn as getProjectSwarmHotspots } from "./config-yaml-DvyMuOle.js";
-import { c as getReviewStatusSync, l as init_review_status, m as mergeGateEligibility } from "./review-status-A7quS5KJ.js";
-import { i as resolveGitHubIssueSync, n as init_tracker_utils } from "./tracker-utils-tnxxqROg.js";
-import { l as init_dag, r as compileGlob } from "./dag-CdOjJVDT.js";
-import { n as computeIssueFootprint, r as init_swarm_readiness } from "./swarm-readiness-CQ_fwUWF.js";
-import { c as classifyIssue, h as isAutoPickable, m as init_pickup } from "./pickup-Dd0Znxxy.js";
+import { Tn as init_projects, fn as findProjectByPathSync, vn as getProjectSwarmHotspots } from "./config-yaml-DySPNmKN.js";
+import { c as getReviewStatusSync, l as init_review_status, m as mergeGateEligibility } from "./review-status-kZj_KyCk.js";
+import { i as resolveGitHubIssueSync, n as init_tracker_utils } from "./tracker-utils-DHv5pSDT.js";
+import { l as init_dag, r as compileGlob } from "./dag-B1ucnjDU.js";
+import { n as computeIssueFootprint, r as init_swarm_readiness } from "./swarm-readiness-DlP_UjHq.js";
+import { c as classifyIssue, h as isAutoPickable, m as init_pickup } from "./pickup-DUCLWrJY.js";
 import { Effect } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 //#region ../../lib/flywheel-merge-order.ts
@@ -208,10 +208,11 @@ function pickFromSequence(nodes, opts) {
 	const signalByIssue = new Map((opts?.predictedConflictSignals ?? []).map((signal) => [signal.issueId.toUpperCase(), signal]));
 	const eligible = [...nodes].sort((a, b) => a.rank - b.rank).filter((node) => {
 		const state = classifyIssue(node, lookups);
+		const activeBookMember = opts?.activeBookMembership?.has(node.issue.toUpperCase()) ?? false;
 		if (!isAutoPickable(opts?.requireReady ? state : {
 			...state,
 			ready: true
-		}, opts?.autoPickupBacklog ?? false)) return false;
+		}, opts?.autoPickupBacklog ?? false, activeBookMember)) return false;
 		if (opts?.excludeIssueIds?.has(node.issue)) return false;
 		if (opts?.isAuthorizedIssue && !opts.isAuthorizedIssue(node.issue)) return false;
 		return true;
@@ -241,4 +242,4 @@ function pickFromSequence(nodes, opts) {
 //#endregion
 export { declaredIssueFootprint as a, resolveMergeQueuePrUrl as c, computePredictedConflictSignals as i, reviewRecordEligibility as l, changedFilesVsMain as n, orderMergeCandidates as o, computeMergeQueue as r, pickFromSequence as s, MERGE_GATE_VERBS as t };
 
-//# sourceMappingURL=flywheel-merge-order-DxbQKE1d.js.map
+//# sourceMappingURL=flywheel-merge-order-UU0tiUld.js.map

package/server/{flywheel-merge-order-C-6zRLvM.js → flywheel-merge-order-UUcsCDb6.js}

@@ -1,2 +1,2 @@
-import { c as resolveMergeQueuePrUrl, l as reviewRecordEligibility, r as computeMergeQueue } from "./flywheel-merge-order-DxbQKE1d.js";
+import { c as resolveMergeQueuePrUrl, l as reviewRecordEligibility, r as computeMergeQueue } from "./flywheel-merge-order-UU0tiUld.js";
 export { computeMergeQueue, resolveMergeQueuePrUrl, reviewRecordEligibility };

package/server/{forge-Ch9gCFod.js → forge-CNFnyqps.js}

@@ -1,4 +1,4 @@
-import { S as parsePullRequestRef, d as getPullRequestState, f as init_github_app, p as isGitHubAppConfigured, v as listPullRequestsForHead, x as mergePullRequestWithApp } from "./github-app-CMBdIFBQ.js";
+import { S as parsePullRequestRef, d as getPullRequestState, f as init_github_app, p as isGitHubAppConfigured, v as listPullRequestsForHead, x as mergePullRequestWithApp } from "./github-app-C3QrAUd0.js";
 import { join } from "node:path";
 import { Data, Effect } from "effect";
 import { tmpdir } from "node:os";
@@ -267,4 +267,4 @@ function getForgeAdapter(forge) {
 //#endregion
 export { getForgeAdapter as n, parseArtifactRef as r, GITHUB_MERGE_TIMEOUT_MS as t };
 
-//# sourceMappingURL=forge-Ch9gCFod.js.map
+//# sourceMappingURL=forge-CNFnyqps.js.map

package/server/forge-DXnS_YFH.js

@@ -0,0 +1,2 @@
+import { n as getForgeAdapter } from "./forge-CNFnyqps.js";
+export { getForgeAdapter };

package/server/{from-CJ_aH5jD.js → from-kNxT0bZC.js}

@@ -3841,4 +3841,4 @@ var init_from = __esmMin((() => {
 //#endregion
 export { File as a, init_esm_min as i, FormData as n, Blob as o, formDataToBlob as r, init_fetch_blob as s, init_from as t };
 
-//# sourceMappingURL=from-CJ_aH5jD.js.map
+//# sourceMappingURL=from-kNxT0bZC.js.map

package/server/{fts-db-CKgg0VKg.js → fts-db-CE46vDkZ.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { a as runMemoryFtsTransactionSync, i as runMemoryFtsStatementSync, n as getMemoryFtsDatabaseSync, r as init_fts_operations, t as closeMemoryFtsDatabasesInProcess } from "./fts-operations-BrL_VTRr.js";
+import { a as runMemoryFtsTransactionSync, i as runMemoryFtsStatementSync, n as getMemoryFtsDatabaseSync, r as init_fts_operations, t as closeMemoryFtsDatabasesInProcess } from "./fts-operations-CqY6zl-i.js";
 import { Worker } from "node:worker_threads";
 //#region ../../lib/memory/fts-db.ts
 async function getMemoryFtsDatabase(projectId) {
@@ -143,4 +143,4 @@ var init_fts_db = __esmMin((() => {
 //#endregion
 export { withMemoryFtsDatabase as a, runMemoryFtsTransaction as i, init_fts_db as n, runMemoryFtsStatement as r, closeMemoryFtsDatabases as t };
 
-//# sourceMappingURL=fts-db-CKgg0VKg.js.map
+//# sourceMappingURL=fts-db-CE46vDkZ.js.map

package/server/{fts-operations-BrL_VTRr.js → fts-operations-CqY6zl-i.js}

@@ -1,6 +1,6 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
 import { n as openDatabase, t as init_driver } from "./driver-CKVGi51s.js";
-import { i as init_paths, o as resolveFtsDbPath } from "./paths-_zEts6wc.js";
+import { i as init_paths, o as resolveFtsDbPath } from "./paths-D-xWGHdh.js";
 import { dirname } from "node:path";
 import { mkdirSync } from "node:fs";
 //#region ../../lib/memory/fts-operations.ts
@@ -131,4 +131,4 @@ var init_fts_operations = __esmMin((() => {
 //#endregion
 export { runMemoryFtsTransactionSync as a, runMemoryFtsStatementSync as i, getMemoryFtsDatabaseSync as n, init_fts_operations as r, closeMemoryFtsDatabasesInProcess as t };
 
-//# sourceMappingURL=fts-operations-BrL_VTRr.js.map
+//# sourceMappingURL=fts-operations-CqY6zl-i.js.map

package/server/{git-utils-BVa07a4a.js → git-utils-CRw2zLPC.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { ar as GitError, ir as FsError, mr as init_errors } from "./config-yaml-DvyMuOle.js";
+import { ar as GitError, ir as FsError, mr as init_errors } from "./config-yaml-DySPNmKN.js";
 import { Effect } from "effect";
 import { existsSync, readdirSync, unlinkSync } from "fs";
 import { join } from "path";
@@ -142,6 +142,43 @@ async function cleanupStaleLocksPromise(repoPath, options) {
 	}
 	return result;
 }
+/**
+* Parse a polyrepo head anchor such as `fe@<sha> api@<sha>`.
+* Plain single-repo refs return null. Malformed composite anchors fail before
+* any caller can accidentally pass the whitespace-containing value to git.
+*/
+function parseWorkspaceHeadAnchor(anchor) {
+	const normalized = anchor.trim();
+	if (!normalized.includes("@")) {
+		if (/\s/.test(normalized)) throw new Error(`Invalid workspace head anchor: ${anchor}`);
+		return null;
+	}
+	return normalized.split(/\s+/).map((token) => {
+		const match = /^([^@\s]+)@([0-9a-fA-F]{40,64})$/.exec(token);
+		if (!match) throw new Error(`Invalid workspace head anchor token '${token}' in '${anchor}'`);
+		return {
+			repoKey: match[1],
+			sha: match[2]
+		};
+	});
+}
+/**
+* Render `git show` for a single-repo ref or every entry in a polyrepo anchor.
+* Composite entries are resolved to their nested worktree and labeled using
+* the same repo-section convention as review and inspect diff summaries.
+*/
+async function renderWorkspaceGitShowPromise(issueId, workspacePath, anchor, args, gitShow) {
+	const entries = parseWorkspaceHeadAnchor(anchor);
+	if (!entries) return gitShow(workspacePath, anchor.trim(), args);
+	if (!issueId) throw new Error(`Cannot resolve composite workspace head anchor '${anchor}' without an issue id`);
+	const { resolveWorkspaceRepoRootsSync } = await import("./project-repos-DXKQsc_m.js");
+	const rootsByKey = new Map(resolveWorkspaceRepoRootsSync(issueId, workspacePath).map((root) => [root.repoKey, root]));
+	return (await Promise.all(entries.map(async ({ repoKey, sha }) => {
+		const root = rootsByKey.get(repoKey);
+		if (!root) throw new Error(`Composite workspace head anchor repo '${repoKey}' was not found in ${workspacePath}`);
+		return `── ${repoKey} ──\n${(await gitShow(root.dir, sha, args)).trimEnd()}`;
+	}))).join("\n");
+}
 async function getWorkspaceGitInfoPromise(workspacePath) {
 	try {
 		const [headResult, branchResult] = await Promise.all([execAsync("git rev-parse HEAD", { cwd: workspacePath }), execAsync("git rev-parse --abbrev-ref HEAD", { cwd: workspacePath })]);
@@ -154,6 +191,34 @@ async function getWorkspaceGitInfoPromise(workspacePath) {
 		throw new Error(`getWorkspaceGitInfo failed for ${workspacePath}: ${msg}`);
 	}
 }
+/**
+* Snapshot the code HEAD(s) of a workspace for drift comparison (PAN-2948).
+*
+* Monorepo: returns the workspace HEAD SHA (unchanged behavior). Polyrepo:
+* returns a composite `fe@<sha> api@<sha>` over the sub-repo worktrees —
+* the wrapper repo at the workspace root is a one-commit artifacts repo whose
+* SHA never changes, so snapshotting it makes every drift comparison
+* (reviewedAtCommit vs lastVerifiedCommit, reviewer verdict anchors) report
+* "no drift" forever. Composite snapshots compare equal iff every sub-repo
+* head is unchanged; consumers that try to use the anchor as a git ref fail
+* the ref lookup and fall back to their conservative full-rerun path.
+*/
+async function snapshotWorkspaceHeadsPromise(issueId, workspacePath) {
+	const { resolveWorkspaceRepoRootsSync } = await import("./project-repos-DXKQsc_m.js");
+	const roots = resolveWorkspaceRepoRootsSync(issueId, workspacePath);
+	const isPolyrepo = roots.some((root) => root.isPolyrepo);
+	const heads = [];
+	for (const root of roots) try {
+		const { stdout } = await execAsync("git rev-parse HEAD", {
+			cwd: root.dir,
+			encoding: "utf-8",
+			timeout: 1e4
+		});
+		const sha = stdout.trim();
+		if (sha) heads.push(isPolyrepo ? `${root.repoKey}@${sha}` : sha);
+	} catch {}
+	return heads.length > 0 ? heads.join(" ") : void 0;
+}
 async function hasStaleLocksPromise(repoPath) {
 	if (findGitLockFiles(repoPath).length === 0) return false;
 	return (await hasRunningGitProcesses(repoPath, {})).status === "idle";
@@ -193,6 +258,6 @@ var init_git_utils = __esmMin((() => {
 	hasStaleLocks = (repoPath) => Effect.promise(() => hasStaleLocksPromise(repoPath));
 }));
 //#endregion
-export { init_git_utils as i, getWorkspaceGitInfo as n, hasStaleLocks as r, cleanupStaleLocks as t };
+export { parseWorkspaceHeadAnchor as a, init_git_utils as i, getWorkspaceGitInfo as n, renderWorkspaceGitShowPromise as o, hasStaleLocks as r, snapshotWorkspaceHeadsPromise as s, cleanupStaleLocks as t };
 
-//# sourceMappingURL=git-utils-BVa07a4a.js.map
+//# sourceMappingURL=git-utils-CRw2zLPC.js.map

package/server/git-utils-D0_yhCgF.js

@@ -0,0 +1,3 @@
+import { a as parseWorkspaceHeadAnchor, i as init_git_utils, n as getWorkspaceGitInfo, o as renderWorkspaceGitShowPromise, r as hasStaleLocks, s as snapshotWorkspaceHeadsPromise, t as cleanupStaleLocks } from "./git-utils-CRw2zLPC.js";
+init_git_utils();
+export { cleanupStaleLocks, getWorkspaceGitInfo, hasStaleLocks, parseWorkspaceHeadAnchor, renderWorkspaceGitShowPromise, snapshotWorkspaceHeadsPromise };