@overdeck/desktop 0.45.23 → 0.46.0

package/server/flywheel-CLVB55Be.js

@@ -0,0 +1,478 @@
+import { Cn as resolveStateReadHomeSync, Gn as init_projects, Mn as findProjectByPathSync, Sn as init_state_read_home, f as loadConfigSync, t as init_config_yaml, tt as resolveModel } from "./config-yaml-CmOPzmBb.js";
+import { H as sessionExists, w as init_tmux } from "./tmux-B1Wbxz5o.js";
+import { C as FlywheelStatus, p as FlywheelStats, t as init_src } from "./src-CRmCHlma.js";
+import { b as init_agents } from "./queries-DHJm7bTd.js";
+import { s as init_internal_token } from "./internal-token-DvMTQSOS.js";
+import { d as isFlywheelAutoPickupBacklog, i as getFlywheelActiveRunId, p as isFlywheelRequireUatBeforeMerge, s as init_control_settings } from "./control-settings-C7DUehE1.js";
+import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-CqMqM1Mb.js";
+import { f as init_github_app } from "./github-app-CQ1Lo6LA.js";
+import "./substrate-bug-weights-service-XfLAKnmK.js";
+import { t as init_sequence_io } from "./sequence-io-DF_8iuhV.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-BiT3odRb.js";
+import { r as computeMergeQueueFromCandidates, s as listEligibleCandidatesByProject } from "./flywheel-merge-order-BJv1DZz1.js";
+import { r as validateBookForStart } from "./validate-Cxsx5Uz1.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) {
+	const candidates = listEligibleCandidatesByProject(cwd);
+	return formatFlywheelStateReport(status, await Effect.runPromise(computeMergeQueueFromCandidates(candidates, 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-CLVB55Be.js.map