@overdeck/desktop 0.45.23 → 0.46.0

package/server/flywheel-BiT3odRb.js

@@ -0,0 +1,1092 @@
+import { a as __toCommonJS } from "./rolldown-runtime-DNCzzKnI.js";
+import { Cn as resolveStateReadHomeSync, Gn as init_projects, Mn as findProjectByPathSync, Rn as getProjectSwarmHotspots, Sn as init_state_read_home, cn as flushAutoCommits, ln as init_auto_commit, un as queueAutoCommit } from "./config-yaml-CmOPzmBb.js";
+import { C as FlywheelStatus, S as FlywheelRunId, d as OrderBook, f as OrderBookIndexEntry, t as init_src } from "./src-CRmCHlma.js";
+import { f as init_review_status, u as getReviewStatusSync } from "./review-status-yljtTd-q.js";
+import { a as countAgentsByStatusRole, o as init_agents } from "./agents-C5rWYhb6.js";
+import { $n as getAgentDir, b as init_agents$1, dt as spawnRun, pt as stopAgent } from "./queries-DHJm7bTd.js";
+import { n as init_issue_service_singleton, r as issue_service_singleton_exports } from "./issue-service-singleton-DmCh7EHj.js";
+import { o as getInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-DvMTQSOS.js";
+import { S as setFlywheelGloballyPaused, b as setFlywheelActiveRunId, d as isFlywheelAutoPickupBacklog, f as isFlywheelGloballyPaused, i as getFlywheelActiveRunId, p as isFlywheelRequireUatBeforeMerge, s as init_control_settings } from "./control-settings-C7DUehE1.js";
+import { n as parseSequenceMd, t as init_sequence_io } from "./sequence-io-DF_8iuhV.js";
+import { l as computeCohort, m as init_pickup, n as LEGACY_PARKED_LABELS } from "./pickup-D8xtG1J2.js";
+import { a as computePredictedConflictSignals, l as pickFromSequence, o as declaredIssueFootprint } from "./flywheel-merge-order-BJv1DZz1.js";
+import { a as gatherProjectLensSignals, s as init_pipeline_membership_gather } from "./pipeline-membership-gather-CET40frr.js";
+import { n as init_pipeline_membership, r as resolvePipelineMembership } from "./pipeline-membership-CrAPLYtf.js";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { Effect, Schema } from "effect";
+import { homedir } from "node:os";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { mkdir, readFile, readdir, realpath, rename, stat as stat$1, writeFile } from "node:fs/promises";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+//#region ../../lib/orders/types.ts
+init_projects();
+init_state_read_home();
+init_auto_commit();
+init_internal_token();
+init_review_status();
+init_agents$1();
+init_sequence_io();
+init_pickup();
+init_src();
+const decodeOrderBook = Schema.decodeUnknownSync(OrderBook);
+function parseOrderBookJson(value) {
+	try {
+		return {
+			ok: true,
+			book: decodeOrderBook(value)
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: `Invalid order book: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+}
+//#endregion
+//#region ../../lib/orders/io.ts
+init_src();
+const BOOK_ID_PATTERN = /^\d{4}-\d{2}-\d{2}-[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const decodeIndex = Schema.decodeUnknownSync(Schema.Array(OrderBookIndexEntry));
+function ordersDirectory(stateRoot) {
+	return join(stateRoot, "orders");
+}
+function orderBookPath(stateRoot, bookId) {
+	if (!BOOK_ID_PATTERN.test(bookId)) throw new Error(`Invalid order book id: ${bookId}`);
+	return join(ordersDirectory(stateRoot), `${bookId}.json`);
+}
+function orderBookIndexPath(stateRoot) {
+	return join(ordersDirectory(stateRoot), "index.json");
+}
+function backlogSequencePath(stateRoot) {
+	return join(stateRoot, "backlog", "sequence.md");
+}
+function readOrderBook(stateRoot, bookId) {
+	const path = orderBookPath(stateRoot, bookId);
+	if (!existsSync(path)) return null;
+	let value;
+	try {
+		value = JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		throw new Error(`Could not parse order book ${bookId}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const parsed = parseOrderBookJson(value);
+	if (!parsed.ok) throw new Error(`Could not parse order book ${bookId}: ${parsed.error}`);
+	if (parsed.book.id !== bookId) throw new Error(`Order book ${bookId} contains mismatched id ${parsed.book.id}`);
+	return parsed.book;
+}
+function readOrderBookIndex(stateRoot) {
+	const path = orderBookIndexPath(stateRoot);
+	if (!existsSync(path)) return [];
+	try {
+		return decodeIndex(JSON.parse(readFileSync(path, "utf8")));
+	} catch (error) {
+		throw new Error(`Could not parse order book index: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function listOrderBookIds(stateRoot) {
+	const indexed = readOrderBookIndex(stateRoot).map((entry) => entry.id);
+	if (indexed.length > 0 || !existsSync(ordersDirectory(stateRoot))) return [...indexed];
+	return readdirSync(ordersDirectory(stateRoot)).filter((name) => name !== "index.json" && name.endsWith(".json")).map((name) => name.slice(0, -5)).filter((id) => BOOK_ID_PATTERN.test(id)).sort();
+}
+function preserveOperatorOwnedState(prior, next) {
+	if (!prior) return next;
+	if (prior.id !== next.id) throw new Error(`Order book id is immutable: ${prior.id} cannot become ${next.id}`);
+	const priorItems = new Map(prior.items.map((item) => [item.issue.toUpperCase(), item]));
+	const items = next.items.map((item) => {
+		const existing = priorItems.get(item.issue.toUpperCase());
+		if (!existing) return item;
+		return {
+			...item,
+			addedAt: existing.addedAt,
+			addedBy: existing.addedBy
+		};
+	});
+	return {
+		...next,
+		createdAt: prior.createdAt,
+		items
+	};
+}
+function indexEntry(book) {
+	return {
+		id: book.id,
+		name: book.name,
+		status: book.status,
+		runId: book.runId,
+		updatedAt: book.updatedAt
+	};
+}
+/**
+* Physical state-store primitive used only by the orders writer. Domain callers
+* must mutate order books through writer.ts so the book and queue stay aligned.
+*/
+async function writeOrderBookState(stateRoot, nextBook, queueOrder) {
+	const book = preserveOperatorOwnedState(readOrderBook(stateRoot, nextBook.id), nextBook);
+	const bookPath = orderBookPath(stateRoot, book.id);
+	const indexPath = orderBookIndexPath(stateRoot);
+	const existingIndex = [...readOrderBookIndex(stateRoot)];
+	const byId = new Map(existingIndex.map((entry) => [entry.id, entry]));
+	byId.set(book.id, indexEntry(book));
+	const ids = [...queueOrder ?? existingIndex.map((entry) => entry.id)];
+	if (!ids.includes(book.id)) ids.push(book.id);
+	for (const entry of existingIndex) if (!ids.includes(entry.id)) ids.push(entry.id);
+	const index = ids.map((id) => byId.get(id)).filter((entry) => Boolean(entry));
+	mkdirSync(dirname(bookPath), { recursive: true });
+	writeFileSync(bookPath, `${JSON.stringify(book, null, 2)}\n`, "utf8");
+	writeFileSync(indexPath, `${JSON.stringify(index, null, 2)}\n`, "utf8");
+	queueAutoCommit({
+		projectRoot: stateRoot,
+		repoRoot: stateRoot,
+		paths: [bookPath, indexPath],
+		subject: `chore(state): update order book ${book.id}`
+	});
+	const flushed = await Effect.runPromise(flushAutoCommits(stateRoot));
+	if (flushed.errored || flushed.pushed === false) throw new Error(`Failed to persist order book ${book.id}: ${flushed.reason ?? "state commit failed"}`);
+	return book;
+}
+//#endregion
+//#region ../../lib/orders/resolver.ts
+const COMPLETE_STATUS = "complete";
+function labelNames(issue) {
+	return (Array.isArray(issue.labels) ? issue.labels : []).map((label) => typeof label === "string" ? label : typeof label === "object" && label !== null && typeof label.name === "string" ? label.name : "").filter(Boolean).map((label) => label.toLowerCase());
+}
+function issueIdentifier(issue) {
+	for (const key of [
+		"identifier",
+		"issueId",
+		"id"
+	]) {
+		const value = issue[key];
+		if (typeof value === "string" && value) return value.toUpperCase();
+	}
+	return "";
+}
+function issueIsClosed(issue) {
+	return [
+		issue.canonicalStatus,
+		issue.status,
+		issue.state
+	].map((value) => typeof value === "string" ? value.toLowerCase().replace(/[ -]/g, "_") : "").some((value) => [
+		"done",
+		"completed",
+		"closed",
+		"canceled",
+		"cancelled"
+	].includes(value));
+}
+const liveOrderIssueLookup = (issueIds) => {
+	const wanted = new Set(issueIds.map((id) => id.toUpperCase()));
+	const result = /* @__PURE__ */ new Map();
+	try {
+		const { getSharedIssueService } = (init_issue_service_singleton(), __toCommonJS(issue_service_singleton_exports));
+		const issues = getSharedIssueService().getIssues({
+			cycle: "all",
+			includeCompleted: true
+		});
+		for (const issue of issues) {
+			const id = issueIdentifier(issue);
+			if (!wanted.has(id)) continue;
+			const labels = labelNames(issue);
+			const closed = issueIsClosed(issue);
+			result.set(id, {
+				issue: id,
+				open: !closed,
+				parked: labels.includes("parked") || LEGACY_PARKED_LABELS.some((label) => labels.includes(label))
+			});
+		}
+	} catch {}
+	return result;
+};
+/** The sole order-book read door. */
+function listBooks(stateRoot) {
+	return listOrderBookIds(stateRoot).map((id) => {
+		const book = readOrderBook(stateRoot, id);
+		if (!book) throw new Error(`Order book index references missing book ${id}`);
+		return book;
+	});
+}
+function getBook(stateRoot, bookId) {
+	return readOrderBook(stateRoot, bookId);
+}
+function membership(stateRoot) {
+	const result = /* @__PURE__ */ new Map();
+	for (const book of listBooks(stateRoot)) {
+		if (book.status === COMPLETE_STATUS) continue;
+		for (const item of book.items) {
+			const issue = item.issue.toUpperCase();
+			const existing = result.get(issue);
+			if (existing && existing !== book.id) throw new Error(`Issue ${issue} belongs to multiple non-complete order books: ${existing}, ${book.id}`);
+			result.set(issue, book.id);
+		}
+	}
+	return result;
+}
+function backlogCandidates(stateRoot, limit) {
+	if (limit <= 0) return [];
+	const path = backlogSequencePath(stateRoot);
+	if (!existsSync(path)) return [];
+	const parsed = parseSequenceMd(readFileSync(path, "utf8"));
+	if (!parsed.ok) throw new Error(`Could not parse backlog sequence: ${parsed.error}`);
+	const assigned = membership(stateRoot);
+	return [...parsed.doc.nodes].sort((a, b) => a.rank - b.rank).filter((node) => !assigned.has(node.issue.toUpperCase())).slice(0, limit);
+}
+function computeBookProgress(book, issueLookup = liveOrderIssueLookup) {
+	const state = issueLookup(book.items.map((item) => item.issue));
+	const items = book.items.map((item) => {
+		const issue = state.get(item.issue.toUpperCase());
+		const closed = issue ? !issue.open : false;
+		const parked = issue?.parked ?? false;
+		return {
+			issue: item.issue,
+			lane: item.lane,
+			order: item.order,
+			closed,
+			parked,
+			terminal: closed || parked
+		};
+	});
+	return {
+		bookId: book.id,
+		total: items.length,
+		landed: items.filter((item) => item.closed).length,
+		items,
+		drained: items.every((item) => item.terminal)
+	};
+}
+//#endregion
+//#region ../../lib/orders/writer.ts
+init_agents();
+init_control_settings();
+function timestamp(value) {
+	return value ?? (/* @__PURE__ */ new Date()).toISOString();
+}
+function requireBook(stateRoot, bookId) {
+	const book = getBook(stateRoot, bookId);
+	if (!book) throw new Error(`Order book not found: ${bookId}`);
+	return book;
+}
+function normalizeLaneOrder(items) {
+	const laneA = items.filter((item) => item.lane === "A").sort((a, b) => a.order - b.order);
+	const laneB = items.filter((item) => item.lane === "B").sort((a, b) => a.order - b.order);
+	return [...laneA.map((item, index) => ({
+		...item,
+		order: index + 1
+	})), ...laneB.map((item, index) => ({
+		...item,
+		order: index + 1
+	}))];
+}
+function updated(book, changes, at) {
+	return {
+		...book,
+		...changes,
+		id: book.id,
+		createdAt: book.createdAt,
+		updatedAt: timestamp(at)
+	};
+}
+/** The sole order-book write door. */
+async function createBook(stateRoot, input) {
+	if (getBook(stateRoot, input.id)) throw new Error(`Order book already exists: ${input.id}`);
+	const at = timestamp(input.createdAt);
+	const settings = {
+		laneAConcurrency: input.settings?.laneAConcurrency ?? 1,
+		briefOverlay: input.settings?.briefOverlay,
+		posture: input.settings?.posture ?? "open",
+		postureSetAt: input.settings?.postureSetAt,
+		postureSetBy: input.settings?.postureSetBy,
+		postureReason: input.settings?.postureReason
+	};
+	if (!Number.isInteger(settings.laneAConcurrency) || settings.laneAConcurrency < 1) throw new Error("laneAConcurrency must be a positive integer");
+	return writeOrderBookState(stateRoot, {
+		id: input.id,
+		name: input.name,
+		status: "draft",
+		settings,
+		items: [],
+		createdAt: at,
+		updatedAt: at
+	});
+}
+async function renameBook(stateRoot, bookId, name, at) {
+	if (!name.trim()) throw new Error("Order book name cannot be empty");
+	return writeOrderBookState(stateRoot, updated(requireBook(stateRoot, bookId), { name: name.trim() }, at));
+}
+async function addItems(stateRoot, bookId, items, actor, at) {
+	const book = requireBook(stateRoot, bookId);
+	const existing = new Set(book.items.map((item) => item.issue.toUpperCase()));
+	const assigned = membership(stateRoot);
+	const addedAt = timestamp(at);
+	const additions = [];
+	for (const item of items) {
+		const issue = item.issue.toUpperCase();
+		if (existing.has(issue) || additions.some((candidate) => candidate.issue.toUpperCase() === issue)) throw new Error(`Issue ${issue} is already in order book ${bookId}`);
+		const otherBook = assigned.get(issue);
+		if (otherBook && otherBook !== bookId) throw new Error(`Issue ${issue} already belongs to non-complete order book ${otherBook}`);
+		additions.push({
+			...item,
+			issue,
+			prereqs: item.prereqs.map((prereq) => prereq.toUpperCase()),
+			addedAt: item.addedAt ?? addedAt,
+			addedBy: item.addedBy ?? actor
+		});
+	}
+	return writeOrderBookState(stateRoot, updated(book, { items: normalizeLaneOrder([...book.items, ...additions]) }, at));
+}
+async function removeItem(stateRoot, bookId, issueId, at) {
+	const book = requireBook(stateRoot, bookId);
+	const issue = issueId.toUpperCase();
+	if (!book.items.some((item) => item.issue.toUpperCase() === issue)) throw new Error(`Issue ${issue} is not in order book ${bookId}`);
+	return writeOrderBookState(stateRoot, updated(book, { items: normalizeLaneOrder(book.items.filter((item) => item.issue.toUpperCase() !== issue)) }, at));
+}
+async function moveItem(stateRoot, bookId, issueId, lane, order, at) {
+	const book = requireBook(stateRoot, bookId);
+	const issue = issueId.toUpperCase();
+	const moving = book.items.find((item) => item.issue.toUpperCase() === issue);
+	if (!moving) throw new Error(`Issue ${issue} is not in order book ${bookId}`);
+	if (!Number.isInteger(order) || order < 1) throw new Error("Order must be a positive integer");
+	const remaining = book.items.filter((item) => item !== moving);
+	const targetLane = remaining.filter((item) => item.lane === lane).sort((a, b) => a.order - b.order);
+	targetLane.splice(Math.min(order - 1, targetLane.length), 0, {
+		...moving,
+		lane,
+		order
+	});
+	const otherLane = remaining.filter((item) => item.lane !== lane).sort((a, b) => a.order - b.order);
+	return writeOrderBookState(stateRoot, updated(book, { items: normalizeLaneOrder([...targetLane, ...otherLane]) }, at));
+}
+async function setItemRequirements(stateRoot, bookId, issueId, requirements, at) {
+	const book = requireBook(stateRoot, bookId);
+	const issue = issueId.toUpperCase();
+	let found = false;
+	const items = book.items.map((item) => {
+		if (item.issue.toUpperCase() !== issue) return item;
+		found = true;
+		return {
+			...item,
+			prereqs: requirements.prereqs === void 0 ? item.prereqs : [...new Set(requirements.prereqs.map((prereq) => prereq.toUpperCase()))],
+			reVerify: requirements.reVerify ?? item.reVerify,
+			planAtPickup: requirements.planAtPickup ?? item.planAtPickup
+		};
+	});
+	if (!found) throw new Error(`Issue ${issue} is not in order book ${bookId}`);
+	return writeOrderBookState(stateRoot, updated(book, { items }, at));
+}
+async function setSettings(stateRoot, bookId, settings, at) {
+	const book = requireBook(stateRoot, bookId);
+	const next = {
+		...book.settings,
+		...settings
+	};
+	if (!Number.isInteger(next.laneAConcurrency) || next.laneAConcurrency < 1) throw new Error("laneAConcurrency must be a positive integer");
+	return writeOrderBookState(stateRoot, updated(book, { settings: next }, at));
+}
+async function setStatus(stateRoot, bookId, status, options = {}) {
+	const book = requireBook(stateRoot, bookId);
+	if (status === "running") {
+		const running = listBooks(stateRoot).find((candidate) => candidate.status === "running" && candidate.id !== bookId);
+		if (running) throw new Error(`Order book ${running.id} is already running`);
+	}
+	return writeOrderBookState(stateRoot, updated(book, {
+		status,
+		runId: options.runId === void 0 ? book.runId : options.runId ?? void 0
+	}, options.at));
+}
+async function advanceQueue(stateRoot, completedBookId, at) {
+	if (requireBook(stateRoot, completedBookId).status !== "complete") await setStatus(stateRoot, completedBookId, "complete", { at });
+	const order = readOrderBookIndex(stateRoot).map((entry) => entry.id);
+	for (const id of order) {
+		const book = getBook(stateRoot, id);
+		if (book?.status === "ready") return book;
+	}
+	return null;
+}
+//#endregion
+//#region services/flywheel-run-state.ts
+init_src();
+const decodeFlywheelStatus = Schema.decodeUnknownSync(FlywheelStatus);
+const decodeFlywheelRunId$1 = Schema.decodeUnknownSync(FlywheelRunId);
+const RUN_ID_PATTERN = /^RUN-(\d+)$/;
+const DEFAULT_RUNS_LIMIT = 20;
+const MAX_RUNS_LIMIT = 100;
+const RUN_SUMMARY_CONCURRENCY = 4;
+const flywheelStatusListeners = /* @__PURE__ */ new Set();
+function subscribeLatestFlywheelStatus(listener) {
+	flywheelStatusListeners.add(listener);
+	return () => {
+		flywheelStatusListeners.delete(listener);
+	};
+}
+function publishLatestFlywheelStatus(status) {
+	for (const listener of flywheelStatusListeners) listener(status);
+}
+function publishFlywheelStatusCleared() {
+	publishLatestFlywheelStatus(null);
+}
+function parseFlywheelRunId(runId) {
+	return decodeFlywheelRunId$1(runId);
+}
+function isFlywheelRunId(runId) {
+	return RUN_ID_PATTERN.test(runId);
+}
+function runNumber(runId) {
+	const match = RUN_ID_PATTERN.exec(runId);
+	return match ? Number(match[1]) : 0;
+}
+function normalizeLimit(limit) {
+	if (limit === void 0) return DEFAULT_RUNS_LIMIT;
+	if (!Number.isFinite(limit) || limit <= 0) return DEFAULT_RUNS_LIMIT;
+	return Math.min(Math.floor(limit), MAX_RUNS_LIMIT);
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+	const results = new Array(items.length);
+	let index = 0;
+	await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+		while (index < items.length) {
+			const current = index;
+			index += 1;
+			results[current] = await mapper(items[current]);
+		}
+	}));
+	return results;
+}
+function getFlywheelHome(options = {}) {
+	return join(options.overdeckHome ?? process.env["OVERDECK_HOME"] ?? join(homedir(), ".overdeck"), "flywheel");
+}
+function getFlywheelRunsDir(options = {}) {
+	return join(getFlywheelHome(options), "runs");
+}
+function getFlywheelRunDir(runId, options = {}) {
+	return join(getFlywheelRunsDir(options), parseFlywheelRunId(runId));
+}
+/** Persist the run's cohort (issue ids) at run start. */
+function saveRunCohort(runId, issueIds, options = {}) {
+	const dir = getFlywheelRunDir(runId, options);
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(join(dir, "cohort.json"), JSON.stringify({
+		issueIds: [...issueIds],
+		snapshotAt: (/* @__PURE__ */ new Date()).toISOString()
+	}, null, 2), "utf-8");
+}
+async function nextFlywheelRunId(options = {}) {
+	const runsDir = getFlywheelRunsDir(options);
+	await mkdir(runsDir, { recursive: true });
+	return parseFlywheelRunId(`RUN-${(await readdir(runsDir, { withFileTypes: true })).reduce((max, entry) => {
+		if (!entry.isDirectory()) return max;
+		const match = RUN_ID_PATTERN.exec(entry.name);
+		if (!match) return max;
+		return Math.max(max, Number(match[1]));
+	}, 0) + 1}`);
+}
+async function writeJsonAtomic(path, payload) {
+	const tmpPath = join(dirname(path), `.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`);
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(tmpPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+	await rename(tmpPath, path);
+	return path;
+}
+function enrichFlywheelStatusWithOrders(status, book, progress) {
+	const terminalPipelineStatuses = new Set([
+		"failed",
+		"merged",
+		"parked"
+	]);
+	const inFlight = new Set(status.activePipeline.filter((item) => !terminalPipelineStatuses.has(item.status)).map((item) => item.issueId.toUpperCase()));
+	const laneAInFlight = book.items.filter((item) => item.lane === "A" && inFlight.has(item.issue.toUpperCase())).sort((left, right) => left.order - right.order).map((item) => item.issue);
+	const laneBInFlight = book.items.filter((item) => item.lane === "B" && inFlight.has(item.issue.toUpperCase())).sort((left, right) => left.order - right.order)[0]?.issue;
+	return {
+		...status,
+		orders: {
+			bookId: book.id,
+			bookName: book.name,
+			landed: progress.landed,
+			total: progress.total,
+			laneAInFlight,
+			...laneBInFlight ? { laneBInFlight } : {},
+			drained: progress.drained
+		}
+	};
+}
+async function mechanicallyEnrichOrdersStatus(status, options) {
+	const launch = await readFlywheelLaunchMetadata(status.runId, options);
+	const { scope: _claimedScope, ...unscoped } = status;
+	const scoped = launch?.scope ? {
+		...unscoped,
+		scope: launch.scope
+	} : unscoped;
+	if (!launch?.orders) {
+		const { orders: _untrustedOrders, ...booklessStatus } = scoped;
+		return booklessStatus;
+	}
+	const stateRoot = options.orderStateRoot?.(launch.workspace) ?? (() => {
+		const project = findProjectByPathSync(launch.workspace);
+		if (!project) throw new Error(`No configured project contains orders-bound Flywheel workspace ${launch.workspace}`);
+		return resolveStateReadHomeSync(project).root;
+	})();
+	const book = (options.getOrderBook ?? getBook)(stateRoot, launch.orders.bookId);
+	if (!book) throw new Error(`Flywheel run ${status.runId} references missing order book ${launch.orders.bookId}`);
+	const progress = (options.computeOrderProgress ?? computeBookProgress)(book);
+	if (progress.drained && book.status === "running") await (options.setOrderStatus ?? setStatus)(stateRoot, book.id, "drained", { runId: book.runId });
+	return enrichFlywheelStatusWithOrders(scoped, book, progress);
+}
+async function writeLatestFlywheelStatus(status, options = {}) {
+	const enriched = await mechanicallyEnrichOrdersStatus(status, options);
+	const latestPath = join(getFlywheelRunDir(status.runId, options), "latest.json");
+	await writeJsonAtomic(latestPath, enriched);
+	publishLatestFlywheelStatus(enriched);
+	return latestPath;
+}
+function decodeLaunchMetadata(payload) {
+	if (typeof payload !== "object" || payload === null) throw new Error("Invalid Flywheel launch metadata");
+	const record = payload;
+	if (record.version !== 1) throw new Error("Invalid Flywheel launch metadata version");
+	for (const key of [
+		"runId",
+		"workspace",
+		"briefPath",
+		"briefDisplayPath"
+	]) if (typeof record[key] !== "string" || !record[key]) throw new Error(`Invalid Flywheel launch metadata: ${key}`);
+	if (record.briefOverlayPath !== void 0 && (typeof record.briefOverlayPath !== "string" || !record.briefOverlayPath)) throw new Error("Invalid Flywheel launch metadata: briefOverlayPath");
+	if (record.orders !== void 0) {
+		const orders = record.orders;
+		if (!orders || typeof orders !== "object" || typeof orders.bookId !== "string" || !orders.bookId) throw new Error("Invalid Flywheel launch metadata: orders.bookId");
+	}
+	if (record.scope !== void 0 && record.scope !== "pan-only" && record.scope !== "all-tracked-projects") throw new Error("Invalid Flywheel launch metadata: scope");
+	return record;
+}
+async function writeFlywheelLaunchMetadata(metadata, options = {}) {
+	const runId = parseFlywheelRunId(metadata.runId);
+	return writeJsonAtomic(join(getFlywheelRunDir(runId, options), "launch.json"), {
+		...metadata,
+		runId
+	});
+}
+async function readFlywheelLaunchMetadata(runId, options = {}) {
+	const launchPath = join(getFlywheelRunDir(runId, options), "launch.json");
+	try {
+		return decodeLaunchMetadata(JSON.parse(await readFile(launchPath, "utf8")));
+	} catch (error) {
+		if ((typeof error === "object" && error !== null && "code" in error ? error.code : void 0) === "ENOENT") return null;
+		throw error;
+	}
+}
+async function readLatestFlywheelStatus(runId, options = {}) {
+	const latestPath = join(getFlywheelRunDir(runId, options), "latest.json");
+	try {
+		return decodeFlywheelStatus(JSON.parse(await readFile(latestPath, "utf8")));
+	} catch (error) {
+		if ((typeof error === "object" && error !== null && "code" in error ? error.code : void 0) === "ENOENT") return null;
+		throw error;
+	}
+}
+async function fileExists(path) {
+	try {
+		return (await stat$1(path)).isFile();
+	} catch (error) {
+		if ((typeof error === "object" && error !== null && "code" in error ? error.code : void 0) === "ENOENT") return false;
+		throw error;
+	}
+}
+async function deriveRunStatus(runDir, runId, activeRunId) {
+	if (await fileExists(join(runDir, "aborted.json"))) return "aborted";
+	if (await fileExists(join(runDir, "report.md"))) return "complete";
+	if (activeRunId !== runId) return "aborted";
+	return isFlywheelGloballyPaused() ? "paused" : "running";
+}
+async function summarizeRun(runId, options, activeRunId) {
+	const runDir = getFlywheelRunDir(runId, options);
+	const latest = await readLatestFlywheelStatus(runId, options);
+	const status = await deriveRunStatus(runDir, runId, activeRunId);
+	return {
+		id: runId,
+		startedAt: latest?.startedAt ?? "",
+		status
+	};
+}
+async function readCurrentLatestFlywheelStatus(options = {}) {
+	const activeRunId = options.activeRunId === void 0 ? getFlywheelActiveRunId() : options.activeRunId;
+	if (!activeRunId || !isFlywheelRunId(activeRunId)) return null;
+	const activeRun = await getFlywheelRunDetail(activeRunId, options);
+	return activeRun?.status === "running" || activeRun?.status === "paused" ? activeRun.latest : null;
+}
+function selectLatestRunIds(entries, limit) {
+	const selected = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory() || !isFlywheelRunId(entry.name)) continue;
+		selected.push(entry.name);
+		selected.sort((a, b) => runNumber(b) - runNumber(a));
+		if (selected.length > limit) selected.length = limit;
+	}
+	return selected;
+}
+async function listFlywheelRuns(options = {}) {
+	const runsDir = getFlywheelRunsDir(options);
+	let entries;
+	try {
+		entries = await readdir(runsDir, { withFileTypes: true });
+	} catch (error) {
+		if ((typeof error === "object" && error !== null && "code" in error ? error.code : void 0) === "ENOENT") return [];
+		throw error;
+	}
+	const runIds = selectLatestRunIds(entries, normalizeLimit(options.limit));
+	const activeRunId = getFlywheelActiveRunId();
+	return (await mapWithConcurrency(runIds, RUN_SUMMARY_CONCURRENCY, (runId) => summarizeRun(runId, options, activeRunId))).sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+/**
+* PAN-1528/PAN-1908: overlay the flywheel capacity gauge from the indexed
+* agents table. This status path must not enumerate state.json files.
+*/
+async function countLiveWorkAgents(_options = {}) {
+	return countAgentsByStatusRole("running", "work");
+}
+function withLiveAgentsActive(latest, liveCount) {
+	if (latest.system.agentsActive === liveCount) return latest;
+	return {
+		...latest,
+		system: {
+			...latest.system,
+			agentsActive: liveCount
+		}
+	};
+}
+async function getFlywheelRunDetail(runId, options = {}) {
+	const runDir = getFlywheelRunDir(runId, options);
+	const latest = await readLatestFlywheelStatus(runId, options);
+	if (!latest) return null;
+	const status = await deriveRunStatus(runDir, runId, options.activeRunId !== void 0 ? options.activeRunId : getFlywheelActiveRunId());
+	const reportPath = join(runDir, "report.md");
+	const openedPrPath = join(runDir, "opened-pr.json");
+	const liveCount = await countLiveWorkAgents(options);
+	return {
+		id: runId,
+		startedAt: latest.startedAt,
+		status,
+		latest: withLiveAgentsActive(latest, liveCount),
+		...latest.orders ? { orders: latest.orders } : {},
+		...latest.scope ? { scope: latest.scope } : {},
+		paths: {
+			latest: join(runDir, "latest.json"),
+			...await fileExists(reportPath) ? { report: reportPath } : {},
+			...await fileExists(openedPrPath) ? { openedPr: openedPrPath } : {}
+		}
+	};
+}
+function clearFlywheelGate() {
+	setFlywheelActiveRunId(null);
+	setFlywheelGloballyPaused(false);
+	publishFlywheelStatusCleared();
+}
+async function resolveLiveFlywheelRunId(options = {}) {
+	const candidate = getFlywheelActiveRunId();
+	if (!candidate) return null;
+	if (!isFlywheelRunId(candidate)) {
+		clearFlywheelGate();
+		return null;
+	}
+	if (!await readLatestFlywheelStatus(candidate, options)) {
+		clearFlywheelGate();
+		return null;
+	}
+	const status = await deriveRunStatus(getFlywheelRunDir(candidate, options), candidate, candidate);
+	if (status === "complete" || status === "aborted") {
+		clearFlywheelGate();
+		return null;
+	}
+	return candidate;
+}
+async function abortFlywheelRun(runId, options = {}) {
+	const parsed = parseFlywheelRunId(runId);
+	await writeJsonAtomic(join(getFlywheelRunDir(parsed, options), "aborted.json"), {
+		runId: parsed,
+		abortedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	if (getFlywheelActiveRunId() === parsed) clearFlywheelGate();
+}
+//#endregion
+//#region ../../lib/flywheel-start.ts
+const execAsync = promisify(exec);
+function isInsideRoot(projectRoot, candidate) {
+	const relativePath = relative(projectRoot, candidate);
+	return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+function resolveFlywheelStartBriefPath(cwd, requestedPath) {
+	const rawPath = requestedPath?.trim() || "docs/flywheel-brief.md";
+	if (rawPath.includes("\0")) throw new Error("Brief path is invalid");
+	const root = resolve(cwd);
+	const absolutePath = isAbsolute(rawPath) ? resolve(rawPath) : resolve(root, rawPath);
+	if (!isInsideRoot(root, absolutePath)) throw new Error("Brief path must stay inside the project root");
+	const normalizedRoot = root.endsWith(sep) ? root : `${root}${sep}`;
+	const displayPath = absolutePath === root ? "." : relative(root, absolutePath);
+	return {
+		absolutePath,
+		displayPath: absolutePath.startsWith(normalizedRoot) ? displayPath : absolutePath
+	};
+}
+async function assertExistingPathInsideRoot(projectRoot, candidate) {
+	const [realRoot, realCandidate] = await Promise.all([realpath(projectRoot), realpath(candidate)]);
+	if (!isInsideRoot(realRoot, realCandidate)) throw new Error("Brief path must stay inside the project root");
+}
+async function requireFlywheelBrief(cwd, requestedPath) {
+	const resolved = resolveFlywheelStartBriefPath(cwd, requestedPath);
+	try {
+		await assertExistingPathInsideRoot(cwd, resolved.absolutePath);
+		await readFile(resolved.absolutePath, "utf8");
+		return resolved;
+	} catch (error) {
+		if ((typeof error === "object" && error !== null && "code" in error ? error.code : void 0) === "ENOENT") throw new Error(`Flywheel brief not found: ${resolved.displayPath}`);
+		throw error;
+	}
+}
+/**
+* The flywheel is a project-scoped singleton: it must run from the PRIMARY
+* worktree root, never a linked feature worktree. Every worktree contains
+* docs/flywheel-brief.md, so the brief check alone cannot catch a caller whose
+* shell happens to sit inside a workspaces/feature-* checkout, and an
+* orchestrator spawned there operates inside a live work agent's worktree.
+* A linked worktree is
+* detected by `git rev-parse --git-common-dir` resolving to the primary's
+* .git directory; outside a repo (or on failure) the cwd is kept and the
+* brief check reports its own error.
+*/
+async function resolvePrimaryWorktreeRoot(cwd) {
+	try {
+		const { stdout } = await execAsync("git rev-parse --path-format=absolute --git-common-dir", {
+			cwd,
+			timeout: 5e3
+		});
+		const commonDir = stdout.trim();
+		if (commonDir.endsWith(`${sep}.git`)) return dirname(commonDir);
+		return cwd;
+	} catch {
+		return cwd;
+	}
+}
+//#endregion
+//#region ../../lib/backlog/lookups.ts
+/**
+* Build the {@link ClassifyLookups} the shared pickup module needs from live project
+* state: labels (in-memory issue service), planned (readable xBRIEF spec), and
+* in-pipeline (review status / live workspace). Shared by the dashboard forecast
+* route and the Flywheel run-cohort snapshot so both classify issues identically
+* (PAN-2006 single source of truth). The issue service is lazy-required to avoid a
+* static lib → dashboard layering edge.
+*/
+function buildClassifyLookups(projectRoot, opts = {}) {
+	const labelsByIssue = /* @__PURE__ */ new Map();
+	if (!opts?.labels) try {
+		const { getSharedIssueService } = (init_issue_service_singleton(), __toCommonJS(issue_service_singleton_exports));
+		for (const issue of getSharedIssueService().getIssues()) {
+			const id = typeof issue["identifier"] === "string" ? issue["identifier"].toUpperCase() : "";
+			if (!id) continue;
+			const names = (Array.isArray(issue["labels"]) ? issue["labels"] : []).map((l) => typeof l === "string" ? l : l?.name ?? "").filter((s) => Boolean(s));
+			labelsByIssue.set(id, names);
+		}
+	} catch {}
+	const specsDir = join(projectRoot, ".pan", "specs");
+	const specIssues = /* @__PURE__ */ new Set();
+	if (existsSync(specsDir)) for (const f of readdirSync(specsDir)) {
+		const m = /^[\d-]+-([A-Z]+-\d+)-/i.exec(f);
+		if (m) specIssues.add(m[1].toUpperCase());
+	}
+	const workspacesDir = join(projectRoot, "workspaces");
+	return {
+		labels: opts?.labels ?? ((id) => labelsByIssue.get(id.toUpperCase()) ?? []),
+		isPlanned: (id) => {
+			const u = id.toUpperCase();
+			return specIssues.has(u);
+		},
+		isInPipeline: (id) => {
+			const rs = getReviewStatusSync(id.toUpperCase());
+			return rs !== null && rs.reviewStatus !== "pending" || existsSync(join(workspacesDir, `feature-${id.toLowerCase()}`));
+		}
+	};
+}
+//#endregion
+//#region ../../lib/cloister/flywheel.ts
+init_sequence_io();
+init_projects();
+init_state_read_home();
+init_control_settings();
+init_pickup();
+init_pipeline_membership_gather();
+init_pipeline_membership();
+const FLYWHEEL_ORCHESTRATOR_AGENT_ID = "flywheel-orchestrator";
+function isIssueInResolvedPipeline(issueId, memberships) {
+	return memberships.some((membership) => membership.issueId.toUpperCase() === issueId.toUpperCase() && membership.inPipeline);
+}
+async function activeOrderBookIssues(projectRoot, runId, deps = {}) {
+	const activeRunId = runId ?? (deps.activeRunId ?? getFlywheelActiveRunId)();
+	if (!activeRunId) return /* @__PURE__ */ new Set();
+	const bookId = (await (deps.readLaunch ?? readFlywheelLaunchMetadata)(activeRunId))?.orders?.bookId;
+	if (!bookId) return /* @__PURE__ */ new Set();
+	const stateRoot = deps.stateRoot?.(projectRoot) ?? (() => {
+		const project = findProjectByPathSync(projectRoot);
+		return project ? resolveStateReadHomeSync(project).root : null;
+	})();
+	if (!stateRoot) return /* @__PURE__ */ new Set();
+	const book = (deps.getBook ?? getBook)(stateRoot, bookId);
+	return new Set(book?.items.map((item) => item.issue.toUpperCase()) ?? []);
+}
+const FlywheelRunIdSchema = Schema.String.check(Schema.isPattern(/^RUN-\d+$/));
+const decodeFlywheelRunId = Schema.decodeUnknownSync(FlywheelRunIdSchema);
+function parseRunId(runId) {
+	return decodeFlywheelRunId(runId);
+}
+function defaultFlywheelRunId() {
+	return parseRunId(`RUN-${Date.now()}`);
+}
+function internalDashboardOrigin() {
+	const port = Number.parseInt(process.env["API_PORT"] ?? process.env["PORT"] ?? "3011", 10);
+	return process.env["OVERDECK_INTERNAL_DASHBOARD_URL"] ?? `http://127.0.0.1:${port}`;
+}
+async function fetchIssueRowsFromDashboard() {
+	const dashboardOrigin = internalDashboardOrigin();
+	const token = getInternalTokenSync();
+	if (!token) {
+		console.error("[flywheel] Cannot load issue metadata: internal dashboard token is unavailable");
+		return [];
+	}
+	try {
+		const response = await fetch(new URL("/api/issues?cycle=all&includeCompleted=true", dashboardOrigin), { headers: {
+			[INTERNAL_TOKEN_HEADER]: token,
+			origin: dashboardOrigin
+		} });
+		if (!response.ok) {
+			console.error(`[flywheel] Cannot load issue metadata from dashboard: HTTP ${response.status}`);
+			return [];
+		}
+		const body = await response.json();
+		if (!Array.isArray(body)) {
+			console.error("[flywheel] Cannot load issue metadata from dashboard: response was not an array");
+			return [];
+		}
+		return body;
+	} catch (error) {
+		console.error("[flywheel] Cannot load issue metadata from dashboard:", error);
+		return [];
+	}
+}
+async function flywheelRunConfigurationSection(options, runId) {
+	const configLines = [
+		options.harness ? `Harness: ${options.harness}` : void 0,
+		options.effort ? `Effort: ${options.effort}` : void 0,
+		options.minAgents ? `Min concurrent agents (target): ${options.minAgents}` : void 0,
+		options.maxAgents ? `Max concurrent agents (ceiling): ${options.maxAgents}` : void 0,
+		options.scope ? `Scope: ${options.scope}` : void 0,
+		typeof options.autoPickupBacklog === "boolean" ? `Auto-pickup backlog: ${options.autoPickupBacklog}` : void 0,
+		typeof options.requireUatBeforeMerge === "boolean" ? `Require UAT before merge: ${options.requireUatBeforeMerge}` : void 0
+	].filter(Boolean).join("\n");
+	let sequenceSection = "";
+	const projectRoot = process.cwd();
+	const orderBookIssues = await activeOrderBookIssues(projectRoot, runId);
+	if (options.autoPickupBacklog || orderBookIssues.size > 0) {
+		const seqPath = join(projectRoot, ".pan", "backlog", "sequence.md");
+		if (existsSync(seqPath)) try {
+			const parsed = parseSequenceMd(readFileSync(seqPath, "utf-8"));
+			if (parsed.ok) {
+				const getIssueRows = async () => fetchIssueRowsFromDashboard();
+				const issueRowMap = new Map((await getIssueRows()).map((i) => [i.ref ?? i.identifier ?? "", i]));
+				const issueLabelsLookup = (issueId) => issueRowMap.get(issueId)?.labels ?? [];
+				const AUTHORIZED_AUTHORS = new Set(["eltmon", "panopticon-agent[bot]"]);
+				const isAuthorizedIssue = (issueId) => {
+					const row = issueRowMap.get(issueId);
+					if (!row) return false;
+					if (row.author && AUTHORIZED_AUTHORS.has(row.author)) return true;
+					return (typeof row.assignee === "string" ? row.assignee : row.assignee?.name) === "eltmon";
+				};
+				const specsDir = join(projectRoot, ".pan", "specs");
+				const issuesWithSpecs = /* @__PURE__ */ new Set();
+				const declaredFootprints = [];
+				if (existsSync(specsDir)) for (const f of readdirSync(specsDir)) {
+					const match = /^[\d-]+-([A-Z]+-\d+)-/i.exec(f);
+					if (!match) continue;
+					const issueId = match[1].toUpperCase();
+					issuesWithSpecs.add(issueId);
+					try {
+						const doc = JSON.parse(readFileSync(join(specsDir, f), "utf-8"));
+						declaredFootprints.push(declaredIssueFootprint(issueId, doc));
+					} catch {}
+				}
+				const projectConfig = findProjectByPathSync(projectRoot);
+				const predictedConflictSignals = computePredictedConflictSignals(declaredFootprints, { hotspots: getProjectSwarmHotspots(projectConfig) });
+				const isReadyOrHasPrd = (issueId) => {
+					const id = issueId.toUpperCase();
+					if (issuesWithSpecs.has(id)) return true;
+					return existsSync(join(projectRoot, ".pan", "drafts", `${id}.md`));
+				};
+				const membershipAvailable = Boolean(projectConfig?.github_repo);
+				const memberships = projectConfig?.github_repo ? (await gatherProjectLensSignals(projectConfig)).map(resolvePipelineMembership) : [];
+				const isInPipeline = (issueId) => membershipAvailable ? isIssueInResolvedPipeline(issueId, memberships) : true;
+				const top10 = parsed.doc.nodes.slice(0, 10).map((n) => `  #${n.rank} ${n.issue}: ${n.why.slice(0, 100)} [gate:${n.gate}]`);
+				const nextPick = pickFromSequence(parsed.doc.nodes, {
+					issueLabels: issueLabelsLookup,
+					isAuthorizedIssue,
+					isReadyOrHasPrd,
+					isInPipeline,
+					requireReady: true,
+					autoPickupBacklog: options.autoPickupBacklog,
+					activeBookMembership: orderBookIssues,
+					predictedConflictSignals
+				});
+				let nextLine;
+				let pickInstruction;
+				if (!membershipAvailable) {
+					nextLine = "MEMBERSHIP UNAVAILABLE: project has no GitHub repository; auto-pickup is disabled";
+					pickInstruction = "\n\nIMPORTANT: Canonical pipeline membership is unavailable for this project. Do NOT auto-start backlog work; surface the missing github_repo configuration to the operator.";
+				} else if (!nextPick) {
+					nextLine = "No eligible issue found in sequence — fall back to normal priority";
+					pickInstruction = "";
+				} else if (nextPick.planning === "interactive") {
+					nextLine = `NEEDS OPERATOR ACTION: ${nextPick.issueId} (rank ${nextPick.rank}) has planning=interactive — do NOT auto-start; operator must run 'pan plan ${nextPick.issueId}'`;
+					pickInstruction = `\n\nIMPORTANT: auto_pickup_backlog=true. The top-ranked issue requires interactive planning and MUST NOT be auto-started. Surface it to the operator for manual 'pan plan' invocation instead of auto-picking it.`;
+				} else {
+					const conflictSuffix = typeof nextPick.predictedConflictCount === "number" ? `, predictedConflicts=${nextPick.predictedConflictCount}${nextPick.predictedConflictsWith?.length ? ` with ${nextPick.predictedConflictsWith.join(", ")}` : ""}` : "";
+					nextLine = `MUST start next: ${nextPick.issueId} (rank ${nextPick.rank}, planning=${nextPick.planning}${conflictSuffix})`;
+					pickInstruction = `\n\nIMPORTANT: auto_pickup_backlog=true. You MUST pick the "MUST start next" issue above as your next startup target. Do NOT apply your own P0-P3/oldest-first ranking while a sequence is available.`;
+				}
+				sequenceSection = `\n\nBacklog sequence (${parsed.doc.nodes.length} issues ranked):\n${top10.join("\n")}\n${nextLine}${pickInstruction}`;
+			}
+		} catch {}
+	}
+	return (configLines ? `\n\nRun configuration:\n${configLines}` : "") + sequenceSection;
+}
+async function defaultFlywheelPrompt(runId, options, briefContent) {
+	return `FLYWHEEL ORCHESTRATOR TASK for ${runId}:
+
+Run the Fix-All Flywheel loop. Keep status snapshots current, coordinate Overdeck roles through the normal pipeline surfaces, respect the configured run scope and agent cap, and wait for explicit lifecycle instructions when the run is paused or complete.${await flywheelRunConfigurationSection(options, runId)}${options.briefPath ? `\n\nBrief path: ${options.briefPath}\n\n${briefContent ?? ""}` : ""}`;
+}
+function getLocalFlywheelRunDir(runId) {
+	return join(process.env.OVERDECK_HOME ?? join(homedir(), ".overdeck"), "flywheel", "runs", runId);
+}
+async function saveResumeSessionId(runId, sessionId) {
+	const runDir = getLocalFlywheelRunDir(runId);
+	await mkdir(runDir, { recursive: true });
+	await writeFile(join(runDir, "resume-session.json"), JSON.stringify({
+		sessionId,
+		pausedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}), "utf-8");
+}
+async function loadResumeSessionId(runId) {
+	try {
+		const raw = await readFile(join(getLocalFlywheelRunDir(runId), "resume-session.json"), "utf-8");
+		const parsed = JSON.parse(raw);
+		return typeof parsed.sessionId === "string" ? parsed.sessionId : null;
+	} catch {
+		return null;
+	}
+}
+function isFlywheelDevcontainerRuntime(env = process.env) {
+	const disabledDeacon = env.OVERDECK_DISABLE_DEACON?.toLowerCase();
+	if (disabledDeacon === "1" || disabledDeacon === "true") return true;
+	const hostname = env.HOSTNAME?.toLowerCase() ?? "";
+	return hostname.includes("devcontainer") || hostname.startsWith("api-feature-") || hostname.startsWith("workspace-");
+}
+/**
+* Resume prompt. PAN-2006 FR-8: re-attach the standing brief on resume so its
+* directives (pipeline-unblock override, never-block, red-main-first) survive a
+* resume + context compaction — the pre-PAN-2006 resume prompt only pointed at
+* FLYWHEEL-STATE.md and a long-running orchestrator could drift off-brief.
+*/
+function buildFlywheelResumePrompt(configSection, briefContent) {
+	return `FLYWHEEL RESUME: You were paused by the operator. Resume the tick loop from your prior state. Check \`docs/FLYWHEEL-STATE.md\` and the latest status snapshot for context.${configSection}${briefContent ? `\n\n--- Standing brief (re-read it — it governs pickup, unblocking, and never-block) ---\n\n${briefContent}` : ""}`;
+}
+function withOrderBookBriefOverlay(briefContent, overlayPath, overlayContent) {
+	if (!overlayContent) return briefContent;
+	const standard = briefContent?.trimEnd() ?? "";
+	const overlay = `--- Order-book brief overlay${overlayPath ? `: ${overlayPath}` : ""} ---\n\n${overlayContent.trim()}`;
+	return standard ? `${standard}\n\n${overlay}` : overlay;
+}
+async function spawnFlywheelAgent(runId, options = {}) {
+	const workspace = options.workspace ?? process.cwd();
+	const briefPath = options.briefPath ?? join(workspace, "docs", "flywheel-brief.md");
+	let briefOverlayPath = options.briefOverlayPath;
+	let briefOverlayContent = options.briefOverlayContent;
+	if (briefOverlayPath && briefOverlayContent === void 0) {
+		const resolvedOverlay = await requireFlywheelBrief(workspace, briefOverlayPath);
+		briefOverlayPath = resolvedOverlay.displayPath;
+		briefOverlayContent = await readFile(resolvedOverlay.absolutePath, "utf8");
+	}
+	const briefContent = withOrderBookBriefOverlay(await readFile(briefPath, "utf8").catch(() => void 0), briefOverlayPath, briefOverlayContent);
+	return spawnRun(runId, "flywheel", {
+		agentId: FLYWHEEL_ORCHESTRATOR_AGENT_ID,
+		workspace,
+		prompt: options.resumeSessionId ? buildFlywheelResumePrompt(await flywheelRunConfigurationSection(options, runId), briefContent) : options.prompt ?? await defaultFlywheelPrompt(runId, {
+			...options,
+			briefPath
+		}, briefContent),
+		model: options.model,
+		harness: options.harness,
+		effort: options.effort,
+		allowHost: true,
+		registerConversation: true,
+		resumeSessionId: options.resumeSessionId,
+		flywheelRunId: runId
+	});
+}
+function withFlywheelAutonomyOptions(options) {
+	return {
+		...options,
+		autoPickupBacklog: options.autoPickupBacklog ?? isFlywheelAutoPickupBacklog(),
+		requireUatBeforeMerge: options.requireUatBeforeMerge ?? isFlywheelRequireUatBeforeMerge()
+	};
+}
+async function spawnFlywheel(options = {}) {
+	if (isFlywheelDevcontainerRuntime(options.env)) throw new Error("Refusing to spawn flywheel-orchestrator inside a workspace devcontainer");
+	const activeRunId = await resolveLiveFlywheelRunId();
+	if (activeRunId) throw new Error(`Flywheel run ${activeRunId} is already active; pause, resume, or report it before starting another run`);
+	const runId = options.runId ? parseRunId(options.runId) : defaultFlywheelRunId();
+	const agent = await spawnFlywheelAgent(runId, withFlywheelAutonomyOptions(options));
+	setFlywheelActiveRunId(runId);
+	setFlywheelGloballyPaused(false);
+	try {
+		const workspace = options.workspace ?? process.cwd();
+		const seqPath = join(workspace, ".pan", "backlog", "sequence.md");
+		if (existsSync(seqPath)) {
+			const parsed = parseSequenceMd(readFileSync(seqPath, "utf-8"));
+			if (parsed.ok) saveRunCohort(runId, computeCohort(parsed.doc.nodes, buildClassifyLookups(workspace), options.maxAgents ?? 5, options.autoPickupBacklog ?? isFlywheelAutoPickupBacklog(), await activeOrderBookIssues(workspace, runId)));
+		}
+	} catch {}
+	return agent;
+}
+async function abortSpawnedFlywheel(runId) {
+	try {
+		await Effect.runPromise(stopAgent(FLYWHEEL_ORCHESTRATOR_AGENT_ID));
+	} finally {
+		await abortFlywheelRun(runId);
+	}
+}
+async function pauseFlywheel() {
+	const activeRunId = getFlywheelActiveRunId();
+	if (activeRunId) try {
+		const sessionId = (await readFile(join(getAgentDir(FLYWHEEL_ORCHESTRATOR_AGENT_ID), "session.id"), "utf-8")).trim();
+		if (sessionId) await saveResumeSessionId(activeRunId, sessionId);
+	} catch {}
+	setFlywheelGloballyPaused(true);
+	await Effect.runPromise(stopAgent(FLYWHEEL_ORCHESTRATOR_AGENT_ID));
+	return { activeRunId };
+}
+async function resumeFlywheel(options = {}) {
+	if (isFlywheelDevcontainerRuntime(options.env)) throw new Error("Refusing to resume flywheel-orchestrator inside a workspace devcontainer");
+	const activeRunId = getFlywheelActiveRunId();
+	if (!activeRunId) throw new Error("No active flywheel run to resume");
+	const runId = parseRunId(activeRunId);
+	const resumeSessionId = options.resumeSessionId ?? await loadResumeSessionId(runId) ?? void 0;
+	const launch = await readFlywheelLaunchMetadata(runId);
+	const agent = await spawnFlywheelAgent(runId, withFlywheelAutonomyOptions({
+		...options,
+		workspace: options.workspace ?? launch?.workspace,
+		briefPath: options.briefPath ?? launch?.briefPath,
+		briefOverlayPath: options.briefOverlayPath ?? launch?.briefOverlayPath,
+		resumeSessionId
+	}));
+	setFlywheelGloballyPaused(false);
+	return {
+		activeRunId,
+		agent
+	};
+}
+//#endregion
+export { advanceQueue as A, getBook as B, readCurrentLatestFlywheelStatus as C, writeFlywheelLaunchMetadata as D, subscribeLatestFlywheelStatus as E, setItemRequirements as F, liveOrderIssueLookup as H, setSettings as I, setStatus as L, moveItem as M, removeItem as N, writeLatestFlywheelStatus as O, renameBook as P, backlogCandidates as R, nextFlywheelRunId as S, resolveLiveFlywheelRunId as T, listBooks as V, clearFlywheelGate as _, isFlywheelDevcontainerRuntime as a, isFlywheelRunId as b, pauseFlywheel as c, spawnFlywheel as d, spawnFlywheelAgent as f, abortFlywheelRun as g, resolvePrimaryWorktreeRoot as h, buildFlywheelResumePrompt as i, createBook as j, addItems as k, resumeFlywheel as l, requireFlywheelBrief as m, abortSpawnedFlywheel as n, isIssueInResolvedPipeline as o, buildClassifyLookups as p, activeOrderBookIssues as r, loadResumeSessionId as s, FLYWHEEL_ORCHESTRATOR_AGENT_ID as t, saveResumeSessionId as u, getFlywheelRunDetail as v, readFlywheelLaunchMetadata as w, listFlywheelRuns as x, getFlywheelRunDir as y, computeBookProgress as z };
+
+//# sourceMappingURL=flywheel-BiT3odRb.js.map