@overdeck/desktop 0.45.24 → 0.47.0

package/server/uat-train-DDSrSoV1.js

@@ -1,2152 +0,0 @@
-import { Tn as init_projects, d as loadConfigNoMigration, fn as findProjectByPathSync, t as init_config_yaml, tt as resolveModel } from "./config-yaml-DySPNmKN.js";
-import { n as getDashboardIdentity, t as recordDeaconNudge } from "./deacon-nudge-log-6wVqAaqz.js";
-import { D as killSession, E as isPaneDead, H as sessionExists, w as init_tmux } from "./tmux-R7N7y-Mh.js";
-import { X as messageAgent, b as init_agents } from "./queries-CjNIf-Ub.js";
-import { S as setUatGenerationStackStartedAtSync, a as getUatGenerationSync, h as listUatGenerationsWithStacksSync, l as isMergeTrainEnabled, m as listUatGenerationsSync, o as init_merge_sync, p as listUatGenerationNamesSync, s as insertUatGenerationSync, w as updateUatGenerationSync } from "./merge-sync-VPV28g0g.js";
-import { A as init_xbrief_index, M as readXBriefDocument, k as findXBriefByIssue } from "./io-C9kF1wtJ.js";
-import { S as getConversationByName, _t as getDiscoveredStats, at as aggregateDiscoveredSessionCost, ct as countDiscoveredSessions, ft as findDiscoveredSessions, k as init_conversations, mt as getDiscoveredSessionById, ot as aggregateDiscoveredSessionCostBy, yt as init_discovered_sessions } from "./conversations-6AfUfbwc.js";
-import { f as isFlywheelGloballyPaused, i as getFlywheelActiveRunId, n as FLYWHEEL_GLOBAL_PAUSE_KEY, o as getSetting, s as init_control_settings, t as FLYWHEEL_ACTIVE_RUN_ID_KEY, w as setSetting } from "./control-settings-BQp7_4uD.js";
-import { n as resolveHarness, t as init_harness_resolve } from "./harness-resolve-3lNZkyT4.js";
-import { a as enrichSessions, c as searchSessions, i as CostThresholdError, n as getSessionsFeedFacets, o as embedSessions, r as listSessionsFeed, t as scan } from "./scanner-CnqEZeDy.js";
-import { t as listSubstrateBugWeights } from "./substrate-bug-weights-service-B-FwCs5V.js";
-import { D as writeFlywheelLaunchMetadata, O as writeLatestFlywheelStatus, S as nextFlywheelRunId, T as resolveLiveFlywheelRunId, a as isFlywheelDevcontainerRuntime, f as spawnFlywheelAgent, g as abortFlywheelRun, s as loadResumeSessionId, t as FLYWHEEL_ORCHESTRATOR_AGENT_ID, u as saveResumeSessionId, v as getFlywheelRunDetail, w as readFlywheelLaunchMetadata, x as listFlywheelRuns } from "./flywheel-DHrgCphM.js";
-import { t as extractACFromDocument } from "./acceptance-criteria-DDCnXF58.js";
-import { n as ensureDevcontainerSync, r as init_ensure_devcontainer } from "./ensure-devcontainer-DNi-ono3.js";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-import { Effect } from "effect";
-import { existsSync } from "fs";
-import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
-import { tmpdir } from "os";
-import { freemem as freemem$1, totalmem as totalmem$1 } from "node:os";
-import { readFile, realpath, stat } from "node:fs/promises";
-import { exec, execFile, spawn } from "node:child_process";
-import { promisify } from "node:util";
-import { execFile as execFile$1 } from "child_process";
-import { promisify as promisify$1 } from "util";
-import { randomUUID } from "node:crypto";
-import { layer } from "@effect/platform-node/NodeServices";
-import { Worker } from "node:worker_threads";
-//#region services/dashboard-db-task.ts
-init_projects();
-init_config_yaml();
-init_tmux();
-init_merge_sync();
-init_xbrief_index();
-init_harness_resolve();
-init_agents();
-init_discovered_sessions();
-init_conversations();
-init_control_settings();
-const MAX_PENDING_JOBS = 32;
-const SEMANTIC_SEARCH_TIMEOUT_MS = Number.parseInt(process.env["OVERDECK_SEMANTIC_SEARCH_TIMEOUT_MS"] ?? "15000", 10);
-const COALESCED_OPERATIONS = new Set([
-	"scanConversations",
-	"enrichSessions",
-	"embedSessions",
-	"searchSessionsSemantic",
-	"listSubstrateBugWeights"
-]);
-const workers = {
-	read: null,
-	long: null,
-	semantic: null
-};
-const pending = /* @__PURE__ */ new Map();
-const sharedJobs = /* @__PURE__ */ new Map();
-let latestSemanticJobId = null;
-function workerScriptUrl() {
-	return import.meta.url.endsWith(".ts") ? new URL("./dashboard-db-worker.ts", import.meta.url) : new URL("./dashboard-db-worker.js", import.meta.url);
-}
-function failPendingForLane(lane, err) {
-	for (const [id, job] of pending.entries()) {
-		if (job.lane !== lane) continue;
-		if (job.timeout) clearTimeout(job.timeout);
-		job.reject(err);
-		pending.delete(id);
-	}
-	for (const [key, job] of sharedJobs.entries()) if (job.lane === lane) sharedJobs.delete(key);
-	if (lane === "semantic") latestSemanticJobId = null;
-}
-function stableStringify(value) {
-	if (value == null || typeof value !== "object") return JSON.stringify(value);
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	return `{${Object.entries(value).filter(([, v]) => typeof v !== "function" && v !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
-}
-function coalescingKey(operation, payload) {
-	if (!COALESCED_OPERATIONS.has(operation)) return null;
-	return `${operation}:${stableStringify(payload)}`;
-}
-function workerLane(operation) {
-	if (operation === "searchSessionsSemantic") return "semantic";
-	return COALESCED_OPERATIONS.has(operation) ? "long" : "read";
-}
-function cancelOlderSemanticSearches() {
-	if (!latestSemanticJobId && !workers.semantic) return;
-	failPendingForLane("semantic", /* @__PURE__ */ new Error("Superseded by a newer semantic search"));
-	workers.semantic?.terminate();
-	workers.semantic = null;
-}
-function aggregateDiscoveredSessionCostByPayload(payload) {
-	if (typeof payload === "string") return aggregateDiscoveredSessionCostBy(payload);
-	const input = payload;
-	return aggregateDiscoveredSessionCostBy(input?.groupBy ?? "workspace", input?.filter ?? {});
-}
-function getWorker(lane) {
-	const existing = workers[lane];
-	if (existing) return existing;
-	const worker = new Worker(workerScriptUrl(), { execArgv: process.execArgv.filter((arg) => !arg.startsWith("--inspect")) });
-	workers[lane] = worker;
-	worker.on("message", (message) => {
-		const job = pending.get(message.id);
-		if (!job) return;
-		if (message.progress !== void 0) {
-			job.progressChain = job.progressChain.then(async () => {
-				for (const listener of job.progressListeners) await listener(message.progress);
-			});
-			return;
-		}
-		pending.delete(message.id);
-		if (job.timeout) clearTimeout(job.timeout);
-		if (job.lane === "semantic" && latestSemanticJobId === message.id) latestSemanticJobId = null;
-		if (message.ok) {
-			job.progressChain.then(() => job.resolve(message.result), job.reject);
-			return;
-		}
-		const err = message.error?.name === "CostThresholdError" ? new CostThresholdError(message.error.estimatedCost ?? 0, message.error.threshold ?? 0, message.error.sessionCount ?? 0) : new Error(message.error?.message ?? "Dashboard database worker failed");
-		err.name = message.error?.name ?? "DashboardDatabaseWorkerError";
-		err.stack = message.error?.stack;
-		job.progressChain.then(() => job.reject(err), job.reject);
-	});
-	worker.on("error", (err) => {
-		failPendingForLane(lane, err);
-		if (workers[lane] === worker) workers[lane] = null;
-	});
-	worker.on("exit", (code) => {
-		if (code !== 0) failPendingForLane(lane, /* @__PURE__ */ new Error(`Dashboard database ${lane} worker exited with code ${code}`));
-		if (workers[lane] === worker) workers[lane] = null;
-	});
-	return worker;
-}
-async function runInline(operation, payload, onProgress) {
-	switch (operation) {
-		case "getDiscoveredStats": return getDiscoveredStats();
-		case "listDiscoveredSessions": {
-			const filter = payload;
-			return {
-				sessions: findDiscoveredSessions(filter),
-				total: countDiscoveredSessions({
-					...filter,
-					limit: void 0,
-					offset: void 0
-				})
-			};
-		}
-		case "listSessionsFeed": return listSessionsFeed(payload);
-		case "getSessionsFeedFacets": return getSessionsFeedFacets(payload);
-		case "getDiscoveredSessionById": return getDiscoveredSessionById(payload);
-		case "aggregateDiscoveredSessionCost": return aggregateDiscoveredSessionCost(payload);
-		case "aggregateDiscoveredSessionCostBy": return aggregateDiscoveredSessionCostByPayload(payload);
-		case "searchSessions":
-		case "searchSessionsSemantic": return searchSessions(payload);
-		case "scanConversations": return scan({
-			...payload,
-			onProgress
-		});
-		case "enrichSessions": return enrichSessions({
-			...payload,
-			onProgress
-		});
-		case "embedSessions": return embedSessions({
-			...payload,
-			autoInstall: true,
-			onProgress
-		});
-		case "getConversationByName": return getConversationByName(payload);
-		case "getSetting": return getSetting(payload);
-		case "setSetting": {
-			const input = payload;
-			setSetting(input.key, input.value);
-			return null;
-		}
-		case "listSubstrateBugWeights": {
-			const input = payload;
-			return listSubstrateBugWeights(input.window, {
-				limit: input.limit,
-				offset: input.offset
-			});
-		}
-		case "getArtifactBySlug": {
-			const { getArtifactBySlugJob } = await import("./artifact-index-jobs-CbEDfCDu.js");
-			return getArtifactBySlugJob(payload);
-		}
-		case "listArtifactsForWorkspaceOrIssue": {
-			const { listArtifactsForWorkspaceOrIssueJob } = await import("./artifact-index-jobs-CbEDfCDu.js");
-			return listArtifactsForWorkspaceOrIssueJob(payload);
-		}
-		case "unshareArtifactBySlug": {
-			const { unshareArtifactBySlugJob } = await import("./artifact-index-jobs-CbEDfCDu.js");
-			return unshareArtifactBySlugJob(payload);
-		}
-	}
-}
-function runDashboardDbJob(operation, payload, onProgress) {
-	if (import.meta.url.endsWith(".ts") && process.env["VITEST"]) return runInline(operation, payload, onProgress);
-	const key = coalescingKey(operation, payload);
-	const existing = key ? sharedJobs.get(key) : void 0;
-	if (existing) {
-		if (onProgress) existing.progressListeners.add(onProgress);
-		return existing.promise;
-	}
-	if (pending.size >= MAX_PENDING_JOBS) return Promise.reject(/* @__PURE__ */ new Error("Dashboard database worker queue is full"));
-	const id = randomUUID();
-	const lane = workerLane(operation);
-	if (operation === "searchSessionsSemantic") {
-		cancelOlderSemanticSearches();
-		latestSemanticJobId = id;
-	}
-	const progressListeners = /* @__PURE__ */ new Set();
-	if (onProgress) progressListeners.add(onProgress);
-	const promise = new Promise((resolve, reject) => {
-		const timeout = operation === "searchSessionsSemantic" ? setTimeout(() => {
-			if (!pending.get(id)) return;
-			pending.delete(id);
-			for (const [sharedKey, sharedJob] of sharedJobs.entries()) if (sharedJob.promise === promise) sharedJobs.delete(sharedKey);
-			if (latestSemanticJobId === id) latestSemanticJobId = null;
-			reject(/* @__PURE__ */ new Error("Semantic search timed out"));
-			workers.semantic?.terminate();
-			workers.semantic = null;
-		}, Number.isFinite(SEMANTIC_SEARCH_TIMEOUT_MS) ? SEMANTIC_SEARCH_TIMEOUT_MS : 15e3) : null;
-		pending.set(id, {
-			lane,
-			operation,
-			resolve,
-			reject,
-			progressListeners,
-			progressChain: Promise.resolve(),
-			timeout
-		});
-		getWorker(lane).postMessage({
-			id,
-			operation,
-			payload
-		});
-	});
-	if (key) {
-		sharedJobs.set(key, {
-			lane,
-			promise,
-			progressListeners
-		});
-		promise.then(() => sharedJobs.delete(key), () => sharedJobs.delete(key));
-	}
-	return promise;
-}
-//#endregion
-//#region services/flywheel-actions.ts
-init_ensure_devcontainer();
-init_control_settings();
-const DEFAULT_BRIEF_PATH = "docs/flywheel-brief.md";
-const execAsync = promisify(exec);
-function mb(bytes) {
-	return Math.round(bytes / 1024 / 1024);
-}
-function isInsideRoot(projectRoot, candidate) {
-	const relativePath = relative(projectRoot, candidate);
-	return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
-}
-function resolveFlywheelStartBriefPath(cwd, requestedPath) {
-	const rawPath = requestedPath?.trim() || DEFAULT_BRIEF_PATH;
-	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;
-	}
-}
-async function dashboardSetting(key) {
-	return runDashboardDbJob("getSetting", key);
-}
-async function setDashboardSetting(key, value) {
-	await runDashboardDbJob("setSetting", {
-		key,
-		value
-	});
-}
-async function getActiveRunId() {
-	const value = await dashboardSetting(FLYWHEEL_ACTIVE_RUN_ID_KEY);
-	return value && value.trim() ? value : null;
-}
-async function setActiveRunId(runId) {
-	await setDashboardSetting(FLYWHEEL_ACTIVE_RUN_ID_KEY, runId ?? "");
-}
-async function isPaused() {
-	return await dashboardSetting(FLYWHEEL_GLOBAL_PAUSE_KEY) === "true";
-}
-async function setPaused(paused) {
-	await setDashboardSetting(FLYWHEEL_GLOBAL_PAUSE_KEY, paused ? "true" : "false");
-}
-async function readGateSnapshot() {
-	const [paused, activeRunId] = await Promise.all([isPaused(), getActiveRunId()]);
-	return {
-		paused,
-		activeRunId
-	};
-}
-async function resolveFlywheelRoleConfig() {
-	const { config } = await Effect.runPromise(loadConfigNoMigration());
-	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"
-	};
-}
-async function gitOutput(command, cwd) {
-	const { stdout } = await execAsync(command, {
-		cwd,
-		encoding: "utf8"
-	});
-	return stdout.trim();
-}
-async function createInitialFlywheelStatus(runId, startedAt, cwd, agentModel, agentHarness, roleConfig) {
-	const ramTotalMb = mb(totalmem$1());
-	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$1())),
-			ramTotalMb,
-			swapUsedMb: 0,
-			swapTotalMb: 0,
-			agentsActive: 1,
-			agentsCap: roleConfig.maxAgents
-		},
-		openQuestions: [],
-		ticks: 0,
-		lastTickAt: startedAt
-	};
-}
-async function startFlywheelRunForDashboard(options = {}) {
-	const cwd = options.cwd ?? process.cwd();
-	if (isFlywheelDevcontainerRuntime()) throw new Error("Refusing to spawn flywheel-orchestrator inside a workspace devcontainer");
-	const activeRunId = await resolveLiveFlywheelRunId();
-	if (activeRunId) if (!await Effect.runPromise(sessionExists("flywheel-orchestrator")) || await Effect.runPromise(isPaneDead("flywheel-orchestrator"))) {
-		console.log(`[flywheel] ${activeRunId} gate stuck — orchestrator pane is dead; auto-aborting`);
-		await Effect.runPromise(killSession(FLYWHEEL_ORCHESTRATOR_AGENT_ID)).catch(() => {});
-		await abortFlywheelRun(activeRunId);
-	} else throw new Error(`Flywheel run ${activeRunId} is already active; pause, resume, or report it before starting another run`);
-	const brief = await requireFlywheelBrief(cwd, options.brief ?? DEFAULT_BRIEF_PATH);
-	const runId = await nextFlywheelRunId();
-	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-	await writeFlywheelLaunchMetadata({
-		version: 1,
-		runId,
-		workspace: cwd,
-		briefPath: brief.absolutePath,
-		briefDisplayPath: brief.displayPath
-	});
-	const roleConfig = await resolveFlywheelRoleConfig();
-	const agent = await spawnFlywheelAgent(runId, {
-		briefPath: brief.absolutePath,
-		workspace: cwd,
-		model: roleConfig.model,
-		harness: roleConfig.harness,
-		effort: roleConfig.effort,
-		minAgents: roleConfig.minAgents,
-		maxAgents: roleConfig.maxAgents,
-		scope: roleConfig.scope
-	});
-	await setActiveRunId(runId);
-	await setPaused(false);
-	await writeLatestFlywheelStatus(await createInitialFlywheelStatus(runId, startedAt, cwd, agent.model, agent.harness, roleConfig));
-	return {
-		runId,
-		briefDisplayPath: resolveFlywheelStartBriefPath(cwd, options.brief ?? DEFAULT_BRIEF_PATH).displayPath,
-		agentModel: agent.model
-	};
-}
-async function pauseFlywheelRunForDashboard() {
-	const before = await readGateSnapshot();
-	if (before.paused) return {
-		before,
-		after: before,
-		changed: false
-	};
-	if (before.activeRunId) try {
-		const { readFile } = await import("node:fs/promises");
-		const { join } = await import("node:path");
-		const { getAgentDir } = await import("./agents-wi9NWzs2.js");
-		const sessionId = (await readFile(join(getAgentDir(FLYWHEEL_ORCHESTRATOR_AGENT_ID), "session.id"), "utf-8")).trim();
-		if (sessionId) await saveResumeSessionId(before.activeRunId, sessionId);
-	} catch {}
-	await setPaused(true);
-	await import("./agents-wi9NWzs2.js").then(({ stopAgent }) => Effect.runPromise(stopAgent(FLYWHEEL_ORCHESTRATOR_AGENT_ID)));
-	return {
-		before,
-		after: await readGateSnapshot(),
-		changed: true
-	};
-}
-async function abortFlywheelRunForDashboard() {
-	const candidate = await getActiveRunId();
-	if (!candidate) return { aborted: await resolveLiveFlywheelRunId() ?? null };
-	const { stopAgent } = await import("./agents-wi9NWzs2.js");
-	await Effect.runPromise(stopAgent(FLYWHEEL_ORCHESTRATOR_AGENT_ID));
-	await abortFlywheelRun(candidate);
-	return { aborted: candidate };
-}
-async function resumeFlywheelRunForDashboard() {
-	const before = await readGateSnapshot();
-	if (!before.paused && await Effect.runPromise(sessionExists("flywheel-orchestrator"))) return {
-		before,
-		after: before,
-		changed: false
-	};
-	if (!before.activeRunId) throw new Error("No active flywheel run to resume");
-	const launch = await readFlywheelLaunchMetadata(before.activeRunId);
-	if (!launch) throw new Error(`Flywheel run ${before.activeRunId} is missing launch metadata; cannot resume safely`);
-	const brief = await requireFlywheelBrief(launch.workspace, launch.briefPath);
-	const roleConfig = await resolveFlywheelRoleConfig();
-	const resumeSessionId = await loadResumeSessionId(before.activeRunId) ?? void 0;
-	await spawnFlywheelAgent(before.activeRunId, {
-		workspace: launch.workspace,
-		briefPath: brief.absolutePath,
-		model: roleConfig.model,
-		harness: roleConfig.harness,
-		effort: roleConfig.effort,
-		minAgents: roleConfig.minAgents,
-		maxAgents: roleConfig.maxAgents,
-		scope: roleConfig.scope,
-		resumeSessionId
-	});
-	await setPaused(false);
-	return {
-		before,
-		after: await readGateSnapshot(),
-		changed: true
-	};
-}
-function getPlatformOpenCommand() {
-	switch (process.platform) {
-		case "linux": return "xdg-open";
-		case "darwin": return "open";
-		case "win32": return "explorer";
-		default: throw new Error(`Opening files is not supported on ${process.platform}`);
-	}
-}
-function openPathDetached(path) {
-	spawn(getPlatformOpenCommand(), [path], {
-		detached: true,
-		stdio: "ignore"
-	}).unref();
-}
-async function resolveReportOpenRunId(runId) {
-	if (runId) return runId;
-	const runs = await listFlywheelRuns();
-	const run = runs.find((candidate) => candidate.status === "complete") ?? runs[0];
-	if (!run) throw new Error("no flywheel run report to open");
-	return run.id;
-}
-async function openFlywheelRunReportForDashboard(options = {}) {
-	const runId = await resolveReportOpenRunId(options.runId);
-	const detail = await getFlywheelRunDetail(runId);
-	if (!detail) throw new Error(`Flywheel run not found: ${runId}`);
-	if (!detail.paths.report) throw new Error(`No report exists for ${runId}`);
-	await (options.opener ?? openPathDetached)(detail.paths.report);
-	return {
-		runId,
-		path: detail.paths.report
-	};
-}
-async function readCurrentFlywheelStatusForDashboard() {
-	const activeRunId = await resolveLiveFlywheelRunId();
-	if (!activeRunId) return null;
-	const activeRun = await getFlywheelRunDetail(activeRunId);
-	return activeRun?.status === "running" ? activeRun.latest : null;
-}
-//#endregion
-//#region ../../lib/cloister/uat-candidate-name.ts
-/**
-* UAT candidate branch naming (PAN-1691) — codename + short date.
-*
-* One candidate branch is assembled per label/day and force-reset on rebuild.
-* Format: `uat/<label>-<codename>-<MMDD>`, e.g. `uat/pan-otter-0609`. Codenames
-* are short, memorable words you can say out loud ("ship the otter candidate").
-*
-* The core is pure and fully injectable (wordlist / index pick / collision
-* date) so it's deterministically testable. The default codename index is a
-* stable hash of label + day so rebuilds for the same day reuse the same branch.
-*/
-const UAT_CODENAMES = [
-	"otter",
-	"falcon",
-	"cedar",
-	"quartz",
-	"ember",
-	"marlin",
-	"willow",
-	"cobalt",
-	"sable",
-	"heron",
-	"onyx",
-	"larch",
-	"perch",
-	"flint",
-	"dune",
-	"reef",
-	"vale",
-	"crow",
-	"moss",
-	"thorn",
-	"birch",
-	"koi",
-	"slate",
-	"wren"
-];
-function mmdd(dateIso) {
-	const [, month, day] = dateIso.slice(0, 10).split("-");
-	return `${month ?? "00"}${day ?? "00"}`;
-}
-/**
-* Build the deterministic `uat/<label>-<codename>-<MMDD>` branch name. Pure.
-*/
-function makeUatCandidateName(deps) {
-	const day = mmdd(deps.dateIso);
-	const words = deps.codenames ?? UAT_CODENAMES;
-	const pick = deps.pick ?? ((n) => stableIndex(`${deps.label}-${day}`, n));
-	const word = words[words.length > 0 ? pick(words.length) % words.length : 0] ?? "candidate";
-	return `uat/${deps.label}-${word}-${day}`;
-}
-function stableIndex(seed, modulo) {
-	if (modulo <= 0) return 0;
-	let hash = 2166136261;
-	for (let i = 0; i < seed.length; i++) {
-		hash ^= seed.charCodeAt(i);
-		hash = Math.imul(hash, 16777619);
-	}
-	return (hash >>> 0) % modulo;
-}
-//#endregion
-//#region ../../lib/cloister/uat-generation-engine.ts
-/**
-* UAT generation assembly engine (PAN-1737: UAT batch trains).
-*
-* Builds one *generation* — a deterministic-per-day `uat/<label>-<codename>-<MMDD>` branch
-* off current main containing as many ready features as possible, merged in
-* queue order, with cross-feature conflicts resolved on the branch by the
-* injected `resolveConflict` hook (the assembly agent). A feature whose
-* conflict cannot be resolved is *held out* with a human-readable reason and
-* assembly continues — a single bad merge never blocks the batch.
-*
-* Each rebuild for the same label/day force-resets the same branch + persistent
-* worktree under `<projectRoot>/workspaces/`, keeping one authoritative current
-* UAT candidate instead of proliferating stale branches.
-*
-* Pure orchestrator: all git and store I/O is injected (see
-* uat-generation-deps.ts for the real wiring), so every path — happy,
-* conflict-resolved, held-out, failed — is unit-testable with fake deps.
-*/
-/** Branch name → worktree folder name (slashes collapse to dashes). */
-function generationFolderName(branchName) {
-	return branchName.replace(/[^a-zA-Z0-9._-]+/g, "-");
-}
-/**
-* Assemble the next generation from the given ready set. Always returns the
-* generation row (status 'ready' or 'failed'); throws only on store failures.
-* On success, older 'ready' generations for the project flip to 'superseded'.
-*/
-async function assembleUatGeneration(input, deps) {
-	const log = deps.log ?? (() => {});
-	const baseSha = await deps.git.fetchMain();
-	const name = makeUatCandidateName({
-		label: input.label,
-		dateIso: input.dateIso
-	});
-	const worktreePath = `${input.projectRoot}/workspaces/${generationFolderName(name)}`;
-	deps.store.insert({
-		name,
-		worktreePath,
-		projectRoot: input.projectRoot,
-		baseSha,
-		status: "assembling",
-		members: [],
-		heldOut: [],
-		resolutions: [],
-		stackStartedAt: null,
-		cleanedAt: null
-	});
-	const members = [];
-	const heldOut = [];
-	const resolutions = [];
-	const finish = (status) => {
-		deps.store.update(name, {
-			status,
-			members,
-			heldOut,
-			resolutions
-		});
-		return {
-			name,
-			worktreePath,
-			projectRoot: input.projectRoot,
-			baseSha,
-			status,
-			members,
-			heldOut,
-			resolutions,
-			stackStartedAt: null,
-			cleanedAt: null,
-			createdAt: "",
-			updatedAt: ""
-		};
-	};
-	try {
-		await deps.git.createWorktree(name, worktreePath);
-	} catch (err) {
-		log(`[uat-generation] ${name}: worktree creation failed: ${err instanceof Error ? err.message : String(err)}`);
-		return finish("failed");
-	}
-	for (const feature of input.features) {
-		const mergedIssueIds = members.map((m) => m.issueId);
-		const attemptedHeadSha = async () => deps.git.branchHeadSha(feature.branch).catch(() => "unknown");
-		const recordMember = async () => ({
-			issueId: feature.issueId,
-			title: feature.title,
-			branch: feature.branch,
-			headSha: await attemptedHeadSha(),
-			mergeOrder: members.length + 1,
-			...feature.pr !== void 0 ? { pr: feature.pr } : {},
-			...feature.prUrl !== void 0 ? { prUrl: feature.prUrl } : {}
-		});
-		const holdOut = async (reason) => {
-			heldOut.push({
-				issueId: feature.issueId,
-				branch: feature.branch,
-				headSha: await attemptedHeadSha(),
-				reason
-			});
-		};
-		let result;
-		try {
-			result = await deps.git.mergeBranch(feature.branch);
-		} catch (err) {
-			await deps.git.abortMerge().catch(() => {});
-			await holdOut(`merge failed: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`);
-			deps.store.update(name, {
-				members,
-				heldOut,
-				resolutions
-			});
-			continue;
-		}
-		if (result.ok) {
-			members.push(await recordMember());
-			deps.store.update(name, {
-				members,
-				heldOut,
-				resolutions
-			});
-			continue;
-		}
-		if (!result.conflict || !deps.resolveConflict) {
-			await deps.git.abortMerge().catch(() => {});
-			await holdOut(result.conflict ? `conflicts with ${conflictingWith(feature, mergedIssueIds).join(", ") || "an earlier member"} — no assembly agent available` : result.reason);
-			deps.store.update(name, {
-				members,
-				heldOut,
-				resolutions
-			});
-			continue;
-		}
-		const conflictingIssueIds = conflictingWith(feature, mergedIssueIds);
-		log(`[uat-generation] ${name}: resolving conflict ${feature.issueId} <-> ${conflictingIssueIds.join(", ") || "(unknown member)"}`);
-		let resolution = null;
-		try {
-			resolution = await deps.resolveConflict({
-				feature,
-				mergedIssueIds,
-				conflictingIssueIds,
-				branchName: name,
-				worktreePath
-			});
-		} catch (err) {
-			log(`[uat-generation] ${name}: conflict agent threw: ${err instanceof Error ? err.message : String(err)}`);
-			resolution = null;
-		}
-		if (resolution) {
-			members.push(await recordMember());
-			resolutions.push({
-				issueIds: [feature.issueId, ...conflictingIssueIds],
-				files: resolution.files,
-				commitSha: resolution.commitSha
-			});
-		} else {
-			await deps.git.abortMerge().catch(() => {});
-			await holdOut(`conflict with ${conflictingIssueIds.join(", ") || "an earlier member"} could not be auto-resolved — waits for the next generation`);
-		}
-		deps.store.update(name, {
-			members,
-			heldOut,
-			resolutions
-		});
-	}
-	if (members.length === 0) {
-		log(`[uat-generation] ${name}: nothing merged (${heldOut.length} held out) — marking failed`);
-		return finish("failed");
-	}
-	try {
-		await deps.git.push(name);
-	} catch (err) {
-		log(`[uat-generation] ${name}: push failed: ${err instanceof Error ? err.message : String(err)}`);
-		return finish("failed");
-	}
-	for (const older of deps.store.listChain(input.projectRoot, ["ready"])) if (older.name !== name) deps.store.update(older.name, { status: "superseded" });
-	log(`[uat-generation] ${name}: ready — ${members.length} member(s), ${resolutions.length} resolution(s), ${heldOut.length} held out`);
-	return finish("ready");
-}
-function conflictingWith(feature, mergedIssueIds) {
-	const merged = new Set(mergedIssueIds.map((id) => id.toUpperCase()));
-	return (feature.conflictsWith ?? []).filter((id) => merged.has(id.toUpperCase()));
-}
-/**
-* Reap dead generations' branches/worktrees, and trim the live chain to the
-* newest `keep` (default 3). Trimmed superseded generations flip to
-* 'invalidated' (their branch is gone — no longer testable). Rows are never
-* deleted: the chain is the audit trail. Promoted generations keep their row
-* but lose branch/worktree/stack — their content lives on main now.
-*/
-async function cleanupUatGenerations(projectRoot, deps, options = {}) {
-	const log = deps.log ?? (() => {});
-	const keep = options.keep ?? 3;
-	const trimmed = deps.store.listChain(projectRoot, ["ready", "superseded"]).slice(keep);
-	const dead = deps.store.listChain(projectRoot, [
-		"invalidated",
-		"promoted",
-		"failed"
-	]).filter((gen) => !gen.cleanedAt);
-	for (const gen of [...trimmed, ...dead]) {
-		let cleaned = true;
-		if (gen.stackStartedAt && deps.teardownStack) await deps.teardownStack(gen).catch((err) => {
-			cleaned = false;
-			log(`[uat-generation] cleanup ${gen.name}: stack teardown failed: ${err instanceof Error ? err.message : String(err)}`);
-		});
-		await deps.removeWorktree(gen.worktreePath).catch((err) => {
-			cleaned = false;
-			log(`[uat-generation] cleanup ${gen.name}: worktree removal failed: ${err instanceof Error ? err.message : String(err)}`);
-		});
-		await deps.deleteBranch(gen.name).catch((err) => {
-			cleaned = false;
-			log(`[uat-generation] cleanup ${gen.name}: branch deletion failed: ${err instanceof Error ? err.message : String(err)}`);
-		});
-		if (!cleaned) continue;
-		const cleanedAt = (/* @__PURE__ */ new Date()).toISOString();
-		if (gen.status === "ready" || gen.status === "superseded") {
-			deps.store.update(gen.name, {
-				status: "invalidated",
-				cleanedAt
-			});
-			log(`[uat-generation] cleanup: trimmed ${gen.name} (beyond newest ${keep})`);
-		} else deps.store.update(gen.name, { cleanedAt });
-	}
-}
-//#endregion
-//#region ../../lib/cloister/uat-generation-deps.ts
-/**
-* Real git + store wiring for the UAT generation engine (PAN-1737).
-*
-* Generation worktrees are PERSISTENT under `<projectRoot>/workspaces/` — the
-* live UAT stack serves from them, and the deterministic daily folder name yields the Traefik
-* host (`uat-<label>-<codename>-<mmdd>.overdeck.localhost`) via the standard
-* FEATURE_FOLDER devcontainer template.
-*
-* Pure I/O — exercised live; the orchestrator (uat-generation-engine.ts) holds
-* the tested logic.
-*/
-const execFileAsync$4 = promisify$1(execFile$1);
-const runGit = (args, cwd) => execFileAsync$4("git", args, {
-	cwd,
-	maxBuffer: 16 * 1024 * 1024
-});
-function safeBranchName(branchName, prefix) {
-	if (!(prefix === "feature" ? /^feature\/[A-Za-z0-9][A-Za-z0-9._-]*$/ : /^uat\/[A-Za-z0-9][A-Za-z0-9._-]*$/).test(branchName)) throw new Error(`unsafe ${prefix} branch name: ${branchName}`);
-	return branchName;
-}
-function safeGenerationWorktreePath(projectRoot, worktreePath) {
-	const workspacesRoot = resolve$1(projectRoot, "workspaces");
-	const target = resolve$1(worktreePath);
-	const rel = relative$1(workspacesRoot, target);
-	if (rel === "" || rel.startsWith("..") || isAbsolute$1(rel)) throw new Error(`unsafe UAT worktree path outside project workspaces: ${worktreePath}`);
-	return target;
-}
-/** Store port backed by uat-generations-db. */
-function buildUatGenerationStore() {
-	return {
-		insert: (gen) => {
-			insertUatGenerationSync(gen);
-		},
-		update: (name, patch) => {
-			updateUatGenerationSync(name, patch);
-		},
-		listNames: () => listUatGenerationNamesSync(),
-		listChain: (projectRoot, statuses) => listUatGenerationsSync({
-			projectRoot,
-			...statuses ? { statuses } : {}
-		})
-	};
-}
-/**
-* Git deps for one assembly run. The worktree path is bound on createWorktree
-* and reused by the merge/push operations that follow.
-*/
-function buildUatGenerationGitDeps(projectRoot) {
-	let worktreePath = "";
-	return {
-		fetchMain: async () => {
-			await runGit([
-				"fetch",
-				"origin",
-				"main"
-			], projectRoot);
-			const { stdout } = await runGit(["rev-parse", "origin/main"], projectRoot);
-			return stdout.trim();
-		},
-		createWorktree: async (branchName, path) => {
-			const safeBranch = safeBranchName(branchName, "uat");
-			worktreePath = safeGenerationWorktreePath(projectRoot, path);
-			await runGit([
-				"worktree",
-				"remove",
-				"--force",
-				worktreePath
-			], projectRoot).catch(() => {});
-			await runGit(["worktree", "prune"], projectRoot).catch(() => {});
-			await runGit([
-				"worktree",
-				"add",
-				"-B",
-				safeBranch,
-				worktreePath,
-				"origin/main"
-			], projectRoot);
-		},
-		branchHeadSha: async (branch) => {
-			const safeBranch = safeBranchName(branch, "feature");
-			const tryRef = async (ref) => (await runGit(["rev-parse", ref], projectRoot)).stdout.trim();
-			return tryRef(`origin/${safeBranch}`).catch(() => tryRef(safeBranch));
-		},
-		mergeBranch: async (featureBranch) => {
-			const safeFeatureBranch = safeBranchName(featureBranch, "feature");
-			const originRef = `origin/${safeFeatureBranch}`;
-			const ref = await runGit([
-				"rev-parse",
-				"--verify",
-				originRef
-			], worktreePath).then(() => originRef).catch(() => safeFeatureBranch);
-			try {
-				await runGit([
-					"merge",
-					"--no-edit",
-					ref
-				], worktreePath);
-				return { ok: true };
-			} catch (err) {
-				const { stdout } = await runGit(["ls-files", "-u"], worktreePath).catch(() => ({ stdout: "" }));
-				return {
-					ok: false,
-					conflict: stdout.trim().length > 0,
-					reason: err instanceof Error ? err.message.split("\n")[0] ?? "merge failed" : String(err)
-				};
-			}
-		},
-		abortMerge: async () => {
-			await runGit(["merge", "--abort"], worktreePath).catch(() => {});
-		},
-		push: async (branchName) => {
-			await runGit([
-				"push",
-				"-u",
-				"--force-with-lease",
-				"origin",
-				safeBranchName(branchName, "uat")
-			], worktreePath);
-		}
-	};
-}
-/** Branch names currently present on origin under uat/* — naming collision input. */
-async function listRemoteUatBranches(projectRoot) {
-	const { stdout } = await runGit([
-		"ls-remote",
-		"--heads",
-		"origin",
-		"uat/*"
-	], projectRoot).catch(() => ({ stdout: "" }));
-	return stdout.split("\n").map((line) => line.split("	")[1] ?? "").filter((ref) => ref.startsWith("refs/heads/")).map((ref) => ref.slice(11));
-}
-/** Cleanup deps: remove a generation worktree and delete its branch everywhere. */
-function buildUatGenerationCleanupGit(projectRoot) {
-	return {
-		removeWorktree: async (path) => {
-			await runGit([
-				"worktree",
-				"remove",
-				"--force",
-				safeGenerationWorktreePath(projectRoot, path)
-			], projectRoot).catch(() => {});
-			await runGit(["worktree", "prune"], projectRoot).catch(() => {});
-		},
-		deleteBranch: async (branchName) => {
-			const safeBranch = safeBranchName(branchName, "uat");
-			await runGit([
-				"branch",
-				"-D",
-				safeBranch
-			], projectRoot).catch(() => {});
-			await runGit([
-				"push",
-				"origin",
-				"--delete",
-				safeBranch
-			], projectRoot).catch(() => {});
-		}
-	};
-}
-//#endregion
-//#region ../../lib/cloister/uat-conflict-agent.ts
-/**
-* Assembly-agent conflict resolution (PAN-1737: UAT batch trains).
-*
-* Implements the engine's `resolveConflict` hook: when merging a feature onto
-* a UAT generation branch conflicts, a TIMEBOXED headless agent run is given
-* the mid-conflict worktree with one mission — resolve THIS merge's conflict
-* markers, changing nothing beyond the resolution.
-*
-* Division of labor, deliberately strict:
-*   - The agent only EDITS FILES (headless `claude -p` with acceptEdits; no
-*     shell access). It cannot stage, commit, push, or wander.
-*   - This module verifies the result in code (no leftover conflict markers,
-*     no unmerged index entries), stages, and concludes the merge commit.
-*   - Any failure — agent missing, timeout, markers left, commit rejected —
-*     returns null; the engine then aborts the merge and holds the feature
-*     out. The assembly NEVER wedges on a conflict.
-*
-* The merge commit subject keeps git's standard `Merge branch ...` form (it
-* survives commitlint's default-ignores when this history is later promoted
-* to main); the auditable `uat-assembly:` marker lives in the body.
-*/
-const execFileAsync$3 = promisify$1(execFile$1);
-function splitNul(stdout) {
-	return stdout.split("\0").filter((p) => p.length > 0);
-}
-function allowlist(files) {
-	return new Set(files.map((f) => f.replace(/\\/g, "/")));
-}
-function buildConflictResolutionPrompt(ctx, conflictedFiles) {
-	const counterparts = ctx.conflictingIssueIds.length > 0 ? ctx.conflictingIssueIds.join(", ") : "an earlier batch member";
-	return [
-		`You are resolving a git merge conflict inside a UAT batch assembly worktree.`,
-		``,
-		`The branch ${ctx.branchName} bundles already-reviewed features for human testing.`,
-		`Merging ${ctx.feature.branch} (${ctx.feature.issueId}: ${ctx.feature.title}) conflicted with ${counterparts}.`,
-		``,
-		`Conflicted files:`,
-		...conflictedFiles.map((f) => `  - ${f}`),
-		``,
-		`Your ONLY job: edit these files to resolve every conflict marker (<<<<<<<, =======, >>>>>>>)`,
-		`so that BOTH features' intended behavior is preserved. Both sides passed review —`,
-		`combine them; do not pick one side wholesale unless the changes are genuinely identical in intent.`,
-		``,
-		`Rules:`,
-		`- Change NOTHING beyond what resolving the conflict requires.`,
-		`- Do not refactor, reformat, or "improve" surrounding code.`,
-		`- Do not run git commands; the caller stages and commits.`,
-		`- If the conflict cannot be safely resolved, leave the markers in place and say so.`
-	].join("\n");
-}
-function buildMergeCommitMessage(ctx, files) {
-	const pair = [ctx.feature.issueId, ...ctx.conflictingIssueIds].join(" <-> ");
-	return [
-		`Merge branch '${ctx.feature.branch}' into ${ctx.branchName}`,
-		``,
-		`uat-assembly: resolve ${pair}`,
-		`files: ${files.join(", ")}`
-	].join("\n");
-}
-function defaultDeps$1() {
-	const run = (cmd, args, cwd, timeoutMs) => execFileAsync$3(cmd, args, {
-		cwd,
-		maxBuffer: 16 * 1024 * 1024,
-		...timeoutMs ? { timeout: timeoutMs } : {}
-	});
-	return {
-		listConflictedFiles: async (cwd) => {
-			const { stdout } = await run("git", [
-				"diff",
-				"--name-only",
-				"--diff-filter=U"
-			], cwd);
-			return stdout.split("\n").map((l) => l.trim()).filter(Boolean);
-		},
-		stagedFiles: async (cwd) => {
-			const { stdout } = await run("git", [
-				"diff",
-				"--cached",
-				"--name-only",
-				"-z"
-			], cwd);
-			return splitNul(stdout);
-		},
-		runAgent: async ({ prompt, cwd, timeoutMs }) => {
-			await run("claude", [
-				"-p",
-				prompt,
-				"--permission-mode",
-				"acceptEdits"
-			], cwd, timeoutMs);
-		},
-		filesWithConflictMarkers: async (cwd, files) => {
-			if (files.length === 0) return [];
-			const { stdout } = await execFileAsync$3("grep", [
-				"-lE",
-				"^(<<<<<<<|=======$|>>>>>>>)",
-				"--",
-				...files
-			], {
-				cwd,
-				maxBuffer: 16 * 1024 * 1024
-			}).catch((err) => {
-				if (err && err.code === 1) return { stdout: "" };
-				throw err;
-			});
-			return stdout.split("\n").map((l) => l.trim()).filter(Boolean);
-		},
-		unsafeChangedFiles: async (cwd, files) => {
-			const allowed = allowlist(files);
-			const [{ stdout: unstaged }, { stdout: untracked }] = await Promise.all([run("git", [
-				"diff",
-				"--name-only",
-				"-z"
-			], cwd), run("git", [
-				"ls-files",
-				"--others",
-				"--exclude-standard",
-				"-z"
-			], cwd)]);
-			return [...new Set([...splitNul(unstaged), ...splitNul(untracked)])].filter((file) => !allowed.has(file.replace(/\\/g, "/")));
-		},
-		discardFiles: async (cwd, files) => {
-			if (files.length === 0) return;
-			await run("git", [
-				"restore",
-				"--staged",
-				"--worktree",
-				"--",
-				...files
-			], cwd).catch(() => {});
-			await run("git", [
-				"clean",
-				"-fd",
-				"--",
-				...files
-			], cwd).catch(() => {});
-		},
-		stageFiles: async (cwd, files) => {
-			if (files.length === 0) return;
-			await run("git", [
-				"add",
-				"--",
-				...files
-			], cwd);
-		},
-		hasUnmergedEntries: async (cwd) => {
-			const { stdout } = await run("git", ["ls-files", "-u"], cwd);
-			return stdout.trim().length > 0;
-		},
-		commitMerge: async (cwd, message) => {
-			await run("git", [
-				"commit",
-				"-m",
-				message
-			], cwd);
-		},
-		headSha: async (cwd) => (await run("git", ["rev-parse", "HEAD"], cwd)).stdout.trim()
-	};
-}
-/**
-* Build the engine's `resolveConflict` hook. Returns the resolution on
-* success; null on ANY failure (the engine aborts the merge and holds the
-* feature out — never throws into the assembly loop).
-*/
-function buildConflictAgentHook(options = {}) {
-	const deps = {
-		...defaultDeps$1(),
-		...options.deps ?? {}
-	};
-	const timeoutMs = options.timeoutMs ?? 3e5;
-	const log = deps.log ?? (() => {});
-	return async (ctx) => {
-		const tag = `[uat-conflict-agent] ${ctx.branchName} ${ctx.feature.issueId}`;
-		let files;
-		let stagedBefore;
-		try {
-			files = await deps.listConflictedFiles(ctx.worktreePath);
-			stagedBefore = await deps.stagedFiles(ctx.worktreePath);
-		} catch (err) {
-			log(`${tag}: could not inspect conflicted state: ${err instanceof Error ? err.message : String(err)}`);
-			return null;
-		}
-		if (files.length === 0) {
-			log(`${tag}: merge failed without unmerged paths — not a content conflict, giving up`);
-			return null;
-		}
-		try {
-			await deps.runAgent({
-				prompt: buildConflictResolutionPrompt(ctx, files),
-				cwd: ctx.worktreePath,
-				timeoutMs
-			});
-		} catch (err) {
-			log(`${tag}: agent run failed (${err instanceof Error ? err.message.split("\n")[0] : String(err)})`);
-			return null;
-		}
-		try {
-			const unsafe = await deps.unsafeChangedFiles(ctx.worktreePath, files);
-			if (unsafe.length > 0) {
-				log(`${tag}: agent touched non-conflicted path(s): ${unsafe.join(", ")}`);
-				await deps.discardFiles(ctx.worktreePath, unsafe).catch((err) => {
-					log(`${tag}: cleanup of non-conflicted path(s) failed: ${err instanceof Error ? err.message : String(err)}`);
-				});
-				return null;
-			}
-			const unresolved = await deps.filesWithConflictMarkers(ctx.worktreePath, files);
-			if (unresolved.length > 0) {
-				log(`${tag}: conflict markers remain in ${unresolved.join(", ")}`);
-				return null;
-			}
-			await deps.stageFiles(ctx.worktreePath, files);
-			if (await deps.hasUnmergedEntries(ctx.worktreePath)) {
-				log(`${tag}: unmerged index entries remain after staging`);
-				return null;
-			}
-			const stagedBeforeSet = new Set(stagedBefore);
-			const allowed = allowlist(files);
-			const newlyStagedOutsideAllowlist = (await deps.stagedFiles(ctx.worktreePath)).filter((file) => !stagedBeforeSet.has(file) && !allowed.has(file.replace(/\\/g, "/")));
-			if (newlyStagedOutsideAllowlist.length > 0) {
-				log(`${tag}: cached diff includes non-conflicted path(s): ${newlyStagedOutsideAllowlist.join(", ")}`);
-				return null;
-			}
-			await deps.commitMerge(ctx.worktreePath, buildMergeCommitMessage(ctx, files));
-			const commitSha = await deps.headSha(ctx.worktreePath);
-			log(`${tag}: resolved ${files.length} file(s) at ${commitSha.slice(0, 9)}`);
-			return {
-				files,
-				commitSha
-			};
-		} catch (err) {
-			log(`${tag}: verification/commit failed: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`);
-			return null;
-		}
-	};
-}
-/**
-* Single-flight per project: a tick that arrives while one is running gets
-* 'in-flight' immediately instead of queuing (assemblies are minutes-long;
-* the interval would pile up).
-*/
-const inFlightReconciles = /* @__PURE__ */ new Map();
-/** Stable signature of "what we want assembled" — backoff bookkeeping. */
-function desiredSignature(features, headShas, mainSha) {
-	return `${mainSha}|${[...features].map((f) => `${f.issueId.toUpperCase()}@${headShas.get(f.branch) ?? "unknown"}`).sort().join(",")}`;
-}
-function generationSignature(gen) {
-	const parts = [...gen.members.map((m) => `${m.issueId.toUpperCase()}@${m.headSha}`), ...gen.heldOut.map((h) => `${h.issueId.toUpperCase()}@${h.headSha ?? "held"}`)].sort();
-	return `${gen.baseSha}|${parts.join(",")}`;
-}
-function liveSignatureMatches(gen, features, headShas, mainSha) {
-	if (gen.baseSha !== mainSha) return false;
-	const desiredIds = new Set(features.map((f) => f.issueId.toUpperCase()));
-	const genIds = new Set([...gen.members.map((m) => m.issueId.toUpperCase()), ...gen.heldOut.map((h) => h.issueId.toUpperCase())]);
-	if (desiredIds.size !== genIds.size) return false;
-	for (const id of desiredIds) if (!genIds.has(id)) return false;
-	for (const member of gen.members) if (headShas.get(member.branch) !== member.headSha) return false;
-	for (const held of gen.heldOut) {
-		if (!held.branch || !held.headSha) return false;
-		if (headShas.get(held.branch) !== held.headSha) return false;
-	}
-	return true;
-}
-/**
-* A live generation is INVALIDATED only when its own CONTENT can no longer be
-* trusted for promotion: a bundled member left the ready queue (its work must
-* not merge) or a member's branch gained commits (the tested tree is outdated).
-*
-* Deliberately NOT invalidation triggers (the first live run, 2026-06-10,
-* churned every ready batch to death within minutes):
-*  - main advancing past baseSha — an active flywheel run lands strike commits
-*    on main continuously; the batch tree is still perfectly testable. Base
-*    movement makes liveSignatureMatches() fail, so a FRESH superset assembles
-*    and supersedes this one when ready; promotion safety against a moved base
-*    is enforced at promote time (member-file overlap check + clean merge).
-*  - held-out drift (departed / branch moved / metadata missing) — held-out
-*    features are not in the tree; their changes also flow through
-*    liveSignatureMatches() into a fresh assembly, never destruction of a
-*    testable batch.
-*/
-function isStale(gen, desiredIds, headShas) {
-	for (const member of gen.members) {
-		if (!desiredIds.has(member.issueId.toUpperCase())) return `${member.issueId} left the ready queue`;
-		if (headShas.get(member.branch) !== member.headSha) return `${member.issueId} branch gained commits`;
-	}
-	return null;
-}
-async function reconcileUatGenerations(projectRoot, deps, options = {}) {
-	const log = deps.log ?? (() => {});
-	const now = deps.now ?? Date.now;
-	const invalidated = [];
-	if (!deps.isEnabled()) return {
-		action: "disabled",
-		invalidated
-	};
-	if (inFlightReconciles.has(projectRoot)) return {
-		action: "in-flight",
-		invalidated
-	};
-	const tick = async () => {
-		const readySet = await deps.getReadySet();
-		if (readySet === null) return {
-			action: "no-queue",
-			invalidated
-		};
-		const mainSha = await deps.getMainHeadSha();
-		const headShas = /* @__PURE__ */ new Map();
-		for (const f of readySet) headShas.set(f.branch, await deps.getBranchHeadSha(f.branch).catch(() => "unknown"));
-		const desiredIds = new Set(readySet.map((f) => f.issueId.toUpperCase()));
-		for (const gen of deps.store.listChain(projectRoot, ["ready", "superseded"])) {
-			const staleReason = isStale(gen, desiredIds, headShas);
-			if (!staleReason) continue;
-			log(`[uat-reconciler] invalidating ${gen.name}: ${staleReason}`);
-			deps.store.update(gen.name, { status: "invalidated" });
-			invalidated.push(gen.name);
-			await deps.teardownStack(gen).catch((err) => {
-				log(`[uat-reconciler] stack teardown for ${gen.name} failed: ${err instanceof Error ? err.message : String(err)}`);
-			});
-		}
-		const assembling = deps.store.listChain(projectRoot, ["assembling"]);
-		for (const gen of assembling) {
-			const lastProgress = Date.parse(gen.updatedAt || gen.createdAt || "");
-			const sinceProgress = Number.isFinite(lastProgress) ? now() - lastProgress : Number.POSITIVE_INFINITY;
-			if (sinceProgress > 36e5) {
-				log(`[uat-reconciler] marking stuck assembling generation ${gen.name} failed (no progress for ${Math.round(sinceProgress / 6e4)}m)`);
-				deps.store.update(gen.name, { status: "failed" });
-			}
-		}
-		if (!options.force && deps.store.listChain(projectRoot, ["assembling"]).length > 0) return {
-			action: "in-flight",
-			invalidated
-		};
-		if (readySet.length === 0) {
-			await deps.cleanup().catch(() => {});
-			return {
-				action: "idle",
-				invalidated
-			};
-		}
-		const desired = desiredSignature(readySet, headShas, mainSha);
-		if (!options.force) {
-			if (deps.store.listChain(projectRoot, ["ready", "superseded"]).some((gen) => liveSignatureMatches(gen, readySet, headShas, mainSha))) {
-				await deps.cleanup().catch(() => {});
-				return {
-					action: "idle",
-					invalidated
-				};
-			}
-			const recentFailure = deps.store.listChain(projectRoot, ["failed"]).find((gen) => generationSignature(gen) === desired && now() - Date.parse(gen.updatedAt || gen.createdAt || "") < 6e5);
-			if (recentFailure) {
-				log(`[uat-reconciler] backing off — ${recentFailure.name} failed recently for the same input`);
-				return {
-					action: "backoff",
-					invalidated
-				};
-			}
-		}
-		log(`[uat-reconciler] assembling next generation for ${readySet.length} ready feature(s)`);
-		const generation = await deps.assemble(readySet);
-		await deps.cleanup().catch(() => {});
-		return {
-			action: generation.status === "ready" ? "assembled" : "assembly-failed",
-			invalidated,
-			generation
-		};
-	};
-	const pending = tick().finally(() => inFlightReconciles.delete(projectRoot));
-	inFlightReconciles.set(projectRoot, pending);
-	return pending;
-}
-//#endregion
-//#region ../../lib/cloister/uat-stack.ts
-/**
-* Live UAT stack lifecycle for batch generations (PAN-1737, absorbs PAN-1738).
-*
-* Each ready generation can serve a real dashboard stack from its persistent
-* worktree: the devcontainer renders via the standard FEATURE_FOLDER template,
-* so the folder name (`uat-<label>-<codename>-<mmdd>`) yields the Traefik host
-* `uat-<label>-<codename>-<mmdd>.overdeck.localhost` with zero new infra.
-*
-* HARD INVARIANT — max 2 UAT stacks run concurrently. Docker's default
-* address pool fits ~31 bridge networks; accumulating UAT stacks would
-* eventually block ALL workspace creation ("all predefined address pools
-* have been fully subnetted"). Starting a third stack tears down the oldest
-* first, and invalidation/promotion always tear the generation's stack down.
-*
-* All process exec is async (server-reachable code — never execSync).
-*/
-init_merge_sync();
-const execFileAsync$2 = promisify$1(execFile$1);
-const COMPOSE_FILES = [
-	"docker-compose.devcontainer.yml",
-	"docker-compose.yml",
-	"docker-compose.yaml",
-	"compose.yml",
-	"compose.yaml"
-];
-const stackMutationLocks = /* @__PURE__ */ new Map();
-async function withStackMutationLock(projectRoot, fn) {
-	const previous = stackMutationLocks.get(projectRoot) ?? Promise.resolve();
-	let release;
-	const current = new Promise((resolve) => {
-		release = resolve;
-	});
-	const tail = previous.catch(() => {}).then(() => current);
-	stackMutationLocks.set(projectRoot, tail);
-	await previous.catch(() => {});
-	try {
-		return await fn();
-	} finally {
-		release();
-		if (stackMutationLocks.get(projectRoot) === tail) stackMutationLocks.delete(projectRoot);
-	}
-}
-function defaultDeps() {
-	const compose = (args, cwd) => execFileAsync$2("docker", ["compose", ...args], {
-		cwd,
-		encoding: "utf-8",
-		timeout: 3e5,
-		maxBuffer: 10 * 1024 * 1024
-	});
-	return {
-		ensureDevcontainer: (workspacePath, issueId) => {
-			const result = ensureDevcontainerSync({
-				workspacePath,
-				issueId
-			});
-			return result.step.success ? { ok: true } : {
-				ok: false,
-				error: result.step.error ?? "devcontainer render failed"
-			};
-		},
-		composeUp: async (composeFile, projectName) => {
-			await compose([
-				"-f",
-				composeFile,
-				"-p",
-				projectName,
-				"up",
-				"-d",
-				"--build"
-			], dirname$1(composeFile));
-		},
-		composeDown: async (composeFile, projectName) => {
-			await compose([
-				"-f",
-				composeFile,
-				"-p",
-				projectName,
-				"down",
-				"-v",
-				"--remove-orphans"
-			], dirname$1(composeFile));
-		},
-		composePsCount: async (composeFile, projectName) => {
-			const { stdout } = await compose([
-				"-f",
-				composeFile,
-				"-p",
-				projectName,
-				"ps",
-				"-q"
-			], dirname$1(composeFile));
-			return stdout.split("\n").filter((l) => l.trim().length > 0).length;
-		},
-		findComposeFile: (workspacePath) => {
-			const devcontainerDir = join$1(workspacePath, ".devcontainer");
-			for (const file of COMPOSE_FILES) {
-				const fullPath = join$1(devcontainerDir, file);
-				if (existsSync(fullPath)) return fullPath;
-			}
-			return null;
-		},
-		readComposeFile: (composeFile) => readFile(composeFile, "utf-8"),
-		store: {
-			setStack: (name, startedAt) => setUatGenerationStackStartedAtSync(name, startedAt),
-			listWithStacks: () => listUatGenerationsWithStacksSync()
-		}
-	};
-}
-function uatStackFolderName(gen) {
-	return basename$1(gen.worktreePath);
-}
-function composeProjectName(gen) {
-	return `overdeck-${uatStackFolderName(gen)}`;
-}
-/**
-* The frontend URL the generation's stack serves (or will serve). Prefers the
-* Host(`…`) Traefik label in the rendered compose file; falls back to the
-* FEATURE_FOLDER convention.
-*/
-async function uatFrontendUrl(gen, deps = {}) {
-	const d = {
-		...defaultDeps(),
-		...deps
-	};
-	const folder = uatStackFolderName(gen);
-	const composeFile = d.findComposeFile(gen.worktreePath);
-	if (composeFile) try {
-		const hostMatch = (await d.readComposeFile(composeFile)).match(new RegExp("Host\\(`(" + folder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "\\.[^`]+)`\\)"));
-		if (hostMatch?.[1]) return `https://${hostMatch[1]}`;
-	} catch {}
-	return `https://${folder}.overdeck.localhost`;
-}
-/** Probe a generation's stack. Self-corrects stale stackStartedAt records. */
-async function probeUatStack(gen, deps = {}) {
-	const d = {
-		...defaultDeps(),
-		...deps
-	};
-	const frontendUrl = await uatFrontendUrl(gen, d);
-	const composeFile = d.findComposeFile(gen.worktreePath);
-	if (!composeFile || !gen.stackStartedAt) return {
-		status: "absent",
-		frontendUrl
-	};
-	if (await d.composePsCount(composeFile, composeProjectName(gen)).catch(() => 0) === 0) {
-		try {
-			d.store.setStack(gen.name, null);
-		} catch {}
-		return {
-			status: "absent",
-			frontendUrl
-		};
-	}
-	return {
-		status: "running",
-		frontendUrl
-	};
-}
-/**
-* Bring up the live stack for a generation (idempotent — compose up on a
-* running project is a no-op). Enforces MAX_UAT_STACKS by tearing down the
-* oldest running UAT stack(s) first.
-*/
-async function ensureUatStack(gen, deps = {}) {
-	return withStackMutationLock(gen.projectRoot, async () => {
-		const d = {
-			...defaultDeps(),
-			...deps
-		};
-		const log = d.log ?? (() => {});
-		const evicted = [];
-		const member = gen.members[0];
-		if (!member) return {
-			success: false,
-			error: "generation has no members",
-			evicted
-		};
-		const others = d.store.listWithStacks().filter((g) => g.name !== gen.name);
-		while (others.length > 0 && others.length >= 2) {
-			const oldest = others.shift();
-			log(`[uat-stack] cap 2 reached — tearing down oldest stack ${oldest.name}`);
-			try {
-				await teardownUatStackUnlocked(oldest, d);
-			} catch (err) {
-				return {
-					success: false,
-					error: err instanceof Error ? err.message.split("\n")[0] ?? "stack teardown failed" : String(err),
-					evicted
-				};
-			}
-			evicted.push(oldest.name);
-		}
-		const rendered = d.ensureDevcontainer(gen.worktreePath, member.issueId);
-		if (!rendered.ok) return {
-			success: false,
-			error: rendered.error ?? "devcontainer render failed",
-			evicted
-		};
-		const composeFile = d.findComposeFile(gen.worktreePath);
-		if (!composeFile) return {
-			success: false,
-			error: `no compose file under ${gen.worktreePath}/.devcontainer`,
-			evicted
-		};
-		try {
-			await d.composeUp(composeFile, composeProjectName(gen));
-		} catch (err) {
-			return {
-				success: false,
-				error: err instanceof Error ? err.message.split("\n")[0] ?? "compose up failed" : String(err),
-				evicted
-			};
-		}
-		d.store.setStack(gen.name, (/* @__PURE__ */ new Date()).toISOString());
-		const frontendUrl = await uatFrontendUrl(gen, d);
-		log(`[uat-stack] ${gen.name}: stack up at ${frontendUrl}`);
-		return {
-			success: true,
-			frontendUrl,
-			evicted
-		};
-	});
-}
-async function teardownUatStackUnlocked(gen, d) {
-	const composeFile = d.findComposeFile(gen.worktreePath);
-	if (composeFile) try {
-		await d.composeDown(composeFile, composeProjectName(gen));
-	} catch (err) {
-		d.log?.(`[uat-stack] ${gen.name}: compose down failed: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`);
-		throw err;
-	}
-	try {
-		d.store.setStack(gen.name, null);
-	} catch {}
-}
-/**
-* Tear the generation's stack down (idempotent) and clear its stack record.
-* MUST be called on invalidation, promotion, and generation cleanup —
-* orphaned uat networks eventually block all workspace creation.
-*/
-async function teardownUatStack(gen, deps = {}) {
-	await withStackMutationLock(gen.projectRoot, async () => {
-		await teardownUatStackUnlocked(gen, {
-			...defaultDeps(),
-			...deps
-		});
-	});
-}
-//#endregion
-//#region ../../lib/cloister/file-size-reconcile.ts
-const execFileAsync$1 = promisify(execFile);
-async function reconcileFileSizeBaseline(worktreePath, runGit) {
-	await execFileAsync$1("bash", ["scripts/lint-file-size.sh", "--update"], {
-		cwd: worktreePath,
-		maxBuffer: 16 * 1024 * 1024
-	});
-	const { stdout } = await runGit([
-		"status",
-		"--porcelain",
-		"--",
-		"scripts/file-size-baseline.txt"
-	], worktreePath);
-	if (stdout.trim() === "") return { changed: false };
-	await runGit(["add", "scripts/file-size-baseline.txt"], worktreePath);
-	return { changed: true };
-}
-//#endregion
-//#region ../../lib/cloister/uat-promote.ts
-/**
-* Batch promotion (PAN-1737: UAT batch trains) — "merge what you tested".
-*
-* Promoting a generation merges the uat/* branch itself into main (one no-ff
-* merge), so main receives EXACTLY the tree the operator exercised — including
-* the assembly agent's conflict resolutions. The deliberate exception is
-* file-size baseline reconciliation: scripts/file-size-baseline.txt is CI
-* metadata, so stale-high entries may be lowered or dropped before push.
-* Per-feature PRs are marked merged by GitHub automatically (their head commits
-* become reachable from main), and each member issue then flows through the
-* standard per-issue post-merge lifecycle exactly once, behind the PAN-328
-* in-flight guard.
-*
-* Hard precondition: the generation's baseSha must still equal origin/main —
-* promoting a stale tree would silently drop commits that landed since
-* assembly. Stale promotes are rejected with reassemble guidance (the
-* reconciler rebuilds automatically anyway).
-*
-* Pure orchestration with injected deps; real git in buildUatPromoteGitDeps.
-*/
-const execFileAsync = promisify$1(execFile$1);
-function safeUatBranchName(branchName) {
-	if (!/^uat\/[A-Za-z0-9][A-Za-z0-9._-]*$/.test(branchName)) throw new Error(`unsafe UAT branch name: ${branchName}`);
-	return branchName;
-}
-const PROMOTABLE = ["ready", "superseded"];
-function buildPromoteMergeMessage(gen) {
-	const ids = gen.members.map((m) => m.issueId).join(", ");
-	const resolutionNote = gen.resolutions.length > 0 ? `\n\nIncludes ${gen.resolutions.length} uat-assembly conflict resolution(s): ` + gen.resolutions.map((r) => r.issueIds.join(" <-> ")).join("; ") : "";
-	return `Merge UAT batch ${gen.name} (${ids})${resolutionNote}`;
-}
-async function promoteUatGeneration(name, projectRoot, deps) {
-	const log = deps.log ?? (() => {});
-	const gen = deps.store.get(name);
-	if (!gen || gen.projectRoot !== projectRoot) return {
-		success: false,
-		reason: "not-found",
-		message: `No UAT generation named ${name}`
-	};
-	if (!PROMOTABLE.includes(gen.status)) return {
-		success: false,
-		reason: "wrong-status",
-		message: `${name} is ${gen.status} — only a ready or superseded batch can be merged to main`
-	};
-	const notReady = gen.members.map((m) => ({
-		issueId: m.issueId,
-		gate: deps.memberEligibility(m.issueId)
-	})).filter(({ gate }) => !gate.eligible);
-	if (notReady.length > 0) return {
-		success: false,
-		reason: "member-not-ready",
-		message: `${name} contains member(s) the pipeline has not cleared to merge: ${notReady.map(({ issueId, gate }) => `${issueId} (${gate.reason ?? "not eligible"})`).join(", ")} — wait for them to pass review+test, or for the reconciler to rebuild the batch without them.`
-	};
-	const mainSha = await deps.git.fetchMain();
-	if (gen.baseSha !== mainSha) {
-		const [mainChanged, batchChanged] = await Promise.all([deps.git.changedFilesSince(gen.baseSha), deps.git.batchChangedFiles(gen.name)]);
-		const batchSet = new Set(batchChanged);
-		const overlap = mainChanged.filter((f) => batchSet.has(f));
-		if (overlap.length > 0) return {
-			success: false,
-			reason: "stale-base",
-			message: `${name} was assembled off ${gen.baseSha.slice(0, 9)} but main is now at ${mainSha.slice(0, 9)}, and the new commits touch ${overlap.length} file(s) this batch also changes (${overlap.slice(0, 3).join(", ")}${overlap.length > 3 ? ", …" : ""}) — the tree you tested may not match what would land. A fresh batch reassembles automatically; re-test before merging.`
-		};
-		log(`[uat-promote] ${name}: base moved ${gen.baseSha.slice(0, 9)} → ${mainSha.slice(0, 9)} with no member-file overlap — proceeding`);
-	}
-	let mergeSha;
-	try {
-		mergeSha = await deps.git.mergeIntoMain(gen.name, buildPromoteMergeMessage(gen));
-	} catch (err) {
-		return {
-			success: false,
-			reason: "merge-failed",
-			message: err instanceof Error ? err.message.split("\n")[0] ?? "merge failed" : String(err)
-		};
-	}
-	log(`[uat-promote] ${name}: merged to main at ${mergeSha.slice(0, 9)} (${gen.members.length} member(s))`);
-	deps.store.update(gen.name, { status: "promoted" });
-	await deps.teardownStack(gen).catch((err) => {
-		log(`[uat-promote] ${name}: stack teardown failed: ${err instanceof Error ? err.message : String(err)}`);
-	});
-	const invalidated = [];
-	for (const other of deps.store.listChain(projectRoot, ["ready", "superseded"])) {
-		if (other.name === gen.name) continue;
-		deps.store.update(other.name, { status: "invalidated" });
-		invalidated.push(other.name);
-		await deps.teardownStack(other).catch(() => {});
-	}
-	const postMergeStarted = [];
-	for (const member of gen.members) if (deps.firePostMerge(member.issueId, {
-		sourceBranch: member.branch,
-		verifiedMergedRef: member.headSha || member.branch
-	})) postMergeStarted.push(member.issueId);
-	else log(`[uat-promote] ${name}: post-merge for ${member.issueId} already in flight — skipped`);
-	return {
-		success: true,
-		generation: gen.name,
-		mergeSha,
-		members: gen.members.map((m) => m.issueId),
-		postMergeStarted,
-		invalidated
-	};
-}
-/** Real git wiring: throwaway detached worktree off origin/main, no-ff merge, baseline reconcile, push. */
-function buildUatPromoteGitDeps(projectRoot) {
-	const runGit = (args, cwd) => execFileAsync("git", args, {
-		cwd,
-		maxBuffer: 16 * 1024 * 1024
-	});
-	return {
-		fetchMain: async () => {
-			await runGit([
-				"fetch",
-				"origin",
-				"main"
-			], projectRoot);
-			return (await runGit(["rev-parse", "origin/main"], projectRoot)).stdout.trim();
-		},
-		mergeIntoMain: async (branchName, message) => {
-			const safeBranch = safeUatBranchName(branchName);
-			const worktreePath = join$1(tmpdir(), `uat-promote-${safeBranch.replace(/[^a-z0-9]/gi, "-")}`);
-			await runGit([
-				"worktree",
-				"remove",
-				"--force",
-				worktreePath
-			], projectRoot).catch(() => {});
-			await runGit(["worktree", "prune"], projectRoot).catch(() => {});
-			await runGit([
-				"worktree",
-				"add",
-				"--detach",
-				worktreePath,
-				"origin/main"
-			], projectRoot);
-			try {
-				const originRef = `origin/${safeBranch}`;
-				await runGit([
-					"merge",
-					"--no-ff",
-					await runGit([
-						"rev-parse",
-						"--verify",
-						originRef
-					], worktreePath).then(() => originRef).catch(() => safeBranch),
-					"-m",
-					message
-				], worktreePath);
-				const { changed } = await reconcileFileSizeBaseline(worktreePath, runGit);
-				if (changed) await runGit([
-					"commit",
-					"--amend",
-					"--no-edit"
-				], worktreePath);
-				await runGit([
-					"push",
-					"origin",
-					"HEAD:main"
-				], worktreePath);
-				return (await runGit(["rev-parse", "HEAD"], worktreePath)).stdout.trim();
-			} finally {
-				await runGit([
-					"worktree",
-					"remove",
-					"--force",
-					worktreePath
-				], projectRoot).catch(() => {});
-				await runGit(["worktree", "prune"], projectRoot).catch(() => {});
-			}
-		},
-		changedFilesSince: async (baseSha) => {
-			if (!/^[0-9a-f]{7,40}$/i.test(baseSha)) throw new Error(`unsafe base sha: ${baseSha}`);
-			const { stdout } = await runGit([
-				"diff",
-				"--name-only",
-				`${baseSha}..origin/main`
-			], projectRoot);
-			return stdout.split("\n").map((l) => l.trim()).filter(Boolean);
-		},
-		batchChangedFiles: async (branchName) => {
-			const safeBranch = safeUatBranchName(branchName);
-			const ref = await runGit([
-				"rev-parse",
-				"--verify",
-				`origin/${safeBranch}`
-			], projectRoot).then(() => `origin/${safeBranch}`).catch(() => safeBranch);
-			const { stdout } = await runGit([
-				"diff",
-				"--name-only",
-				`${(await runGit([
-					"merge-base",
-					"origin/main",
-					ref
-				], projectRoot)).stdout.trim()}..${ref}`
-			], projectRoot);
-			return stdout.split("\n").map((l) => l.trim()).filter(Boolean);
-		}
-	};
-}
-//#endregion
-//#region ../../lib/cloister/uat-promote-notify.ts
-init_control_settings();
-init_tmux();
-function buildPromoteNudge(result) {
-	const members = result.members.length > 0 ? result.members.join(", ") : "(no members recorded)";
-	return `The operator just promoted UAT generation ${result.generation} to main at ${result.mergeSha}. Run a fresh Observe->Act loop NOW. Fetch GET /api/registered-projects, then for every returned project key call GET /api/pipeline/membership?project=<URL-encoded-project-key>. Combine the responses and re-derive activePipeline from only rows where inPipeline === true; clean_terminal rows are audit-only and excluded. EXCLUDE the merged member(s): ${members}. Re-assemble a clean UAT batch with only members that are currently review+test passed, close out the promoted issue(s), emit a fresh status snapshot, and re-arm the next tick. Do NOT ask the operator a question, do NOT pause, and do NOT reuse the stale pre-promote ready set.`;
-}
-async function notifyFlywheelOfUatPromote(result, deps = {}) {
-	try {
-		if (result.success !== true) return;
-		const getActiveRunId = deps.getActiveRunId ?? getFlywheelActiveRunId;
-		const isPaused = deps.isPaused ?? isFlywheelGloballyPaused;
-		const sessionExistsDep = deps.sessionExists ?? ((name) => Effect.runPromise(sessionExists(name)));
-		const message = deps.message ?? messageAgent;
-		const recordNudge = deps.recordNudge ?? recordDeaconNudge;
-		if (!getActiveRunId()) return;
-		if (isPaused()) return;
-		const delivered = await sessionExistsDep(FLYWHEEL_ORCHESTRATOR_AGENT_ID);
-		if (delivered) try {
-			await message(FLYWHEEL_ORCHESTRATOR_AGENT_ID, buildPromoteNudge(result), "uat-promote-notify");
-		} catch {}
-		recordNudge({
-			patrol: "uat-promote-notify",
-			issueId: result.members[0] ?? result.generation,
-			action: "notified flywheel-orchestrator to re-derive ready set after UAT promote",
-			reason: "operator promoted a UAT batch; flywheel must immediately rebuild to drop merged + regressed members before its next tick",
-			state: {
-				generation: result.generation,
-				members: result.members,
-				mergeSha: result.mergeSha,
-				delivered
-			}
-		});
-	} catch {}
-}
-//#endregion
-//#region services/uat-train.ts
-/**
-* UAT batch train service (PAN-1737) — real wiring for the reconciler,
-* assembly engine, stacks, and promote path, plus the payload builders the
-* flywheel routes expose.
-*
-* The reconciler interval is the heartbeat of "always one batch ready":
-* every 60s (gated per-tick on flywheel.merge_train_enabled, no-op without an
-* active flywheel run) it compares the ready set against the generation chain
-* and assembles/invalidates as needed. Assemblies run minutes — the reconciler
-* is single-flight per project, so ticks never pile up.
-*/
-init_merge_sync();
-const RECONCILE_INTERVAL_MS = 6e4;
-const CHAIN_PAYLOAD_LIMIT = 10;
-const ACCEPTANCE_CRITERIA_READ_CONCURRENCY = 4;
-const acceptanceCriteriaByIssue = /* @__PURE__ */ new Map();
-function resolveUatProjectRoot(cwdPath = process.cwd()) {
-	const registeredProject = findProjectByPathSync(cwdPath);
-	if (registeredProject) return resolve(registeredProject.path);
-	const normalized = resolve(cwdPath);
-	const workspaceMatch = normalized.match(/^(.*)\/workspaces\/feature-[^/]+(?:\/.*)?$/i);
-	return workspaceMatch?.[1] ? resolve(workspaceMatch[1]) : normalized;
-}
-function projectRoot() {
-	return resolveUatProjectRoot();
-}
-function canStartUatTrainReconciler() {
-	const identity = getDashboardIdentity();
-	return identity.mode === "primary" && resolve(identity.repoRoot) === projectRoot();
-}
-/** Ready set in merge order, or null when no flywheel run is active. */
-async function getReadySet() {
-	const status = await readCurrentFlywheelStatusForDashboard();
-	if (!status) return null;
-	const { computeMergeQueue, resolveMergeQueuePrUrl } = await import("./flywheel-merge-order-UUcsCDb6.js");
-	const fromVerbs = (await Effect.runPromise(computeMergeQueue(status.activePipeline, projectRoot(), {
-		getPrUrl: resolveMergeQueuePrUrl,
-		onIneligible: (issueId, reason) => console.log(`[uat-train] ${issueId} has a merge verb but is not merge-eligible (${reason}) — excluded from the ready set`)
-	}).pipe(Effect.provide(layer)))).map((item) => ({
-		issueId: item.issueId,
-		title: item.title,
-		branch: item.branchName,
-		...item.pr !== void 0 ? { pr: item.pr } : {},
-		...item.prUrl !== void 0 ? { prUrl: item.prUrl } : {},
-		conflictsWith: item.conflictsWith
-	}));
-	const swept = await sweepEligibleFeatures(new Set(fromVerbs.map((f) => f.issueId)));
-	return [...fromVerbs, ...swept];
-}
-/**
-* PAN-2484: the verb-based ready set misses merge-eligible issues that entered
-* the pipeline outside the active flywheel run (operator revivals, strikes,
-* externally-requested reviews) — those sat at readyForMerge with no train ever
-* assembling around them. Sweep review status for THIS project's merge-eligible
-* issues whose feature branch exists and append any the verb set missed. The
-* flywheel's ordering still leads; swept extras ride at the tail (the assembly
-* engine's conflict hook owns any cross-feature conflicts).
-*/
-async function sweepEligibleFeatures(alreadyIncluded) {
-	try {
-		const { loadReviewStatuses, mergeGateEligibility } = await import("./review-status-btEYlaxA.js");
-		const { resolveProjectFromIssueSync } = await import("./projects-vjjcmiN8.js");
-		const { execFile } = await import("node:child_process");
-		const { promisify } = await import("node:util");
-		const execFileAsync = promisify(execFile);
-		const root = projectRoot();
-		const extras = [];
-		for (const [issueId, rs] of Object.entries(loadReviewStatuses())) {
-			if (alreadyIncluded.has(issueId)) continue;
-			if (rs.readyForMerge !== true) continue;
-			if (!mergeGateEligibility(rs).eligible) continue;
-			const project = resolveProjectFromIssueSync(issueId);
-			if (!project || resolve(project.projectPath) !== root) continue;
-			const branch = `feature/${issueId.toLowerCase()}`;
-			try {
-				await execFileAsync("git", [
-					"show-ref",
-					"--verify",
-					"--quiet",
-					`refs/heads/${branch}`
-				], {
-					cwd: root,
-					timeout: 1e4
-				});
-			} catch {
-				continue;
-			}
-			console.log(`[uat-train] ${issueId} is merge-eligible without a flywheel merge verb — swept into the ready set (PAN-2484)`);
-			extras.push({
-				issueId,
-				title: issueId,
-				branch,
-				conflictsWith: []
-			});
-		}
-		return extras;
-	} catch (err) {
-		console.warn(`[uat-train] eligibility sweep failed: ${err instanceof Error ? err.message : String(err)}`);
-		return [];
-	}
-}
-function codenameLabel(features) {
-	return (features[0]?.issueId.split("-")[0] ?? "uat").toLowerCase();
-}
-async function assembleFromReadySet(features) {
-	const root = projectRoot();
-	const store = buildUatGenerationStore();
-	return assembleUatGeneration({
-		projectRoot: root,
-		label: codenameLabel(features),
-		dateIso: (/* @__PURE__ */ new Date()).toISOString(),
-		features,
-		takenBranchNames: await listRemoteUatBranches(root)
-	}, {
-		git: buildUatGenerationGitDeps(root),
-		store,
-		resolveConflict: buildConflictAgentHook(),
-		log: (msg) => console.log(msg)
-	});
-}
-async function runCleanup() {
-	const root = projectRoot();
-	await cleanupUatGenerations(root, {
-		store: buildUatGenerationStore(),
-		...buildUatGenerationCleanupGit(root),
-		teardownStack: (gen) => teardownUatStack(gen),
-		log: (msg) => console.log(msg)
-	});
-}
-/** One reconciler pass. `force` rebuilds even when a live generation matches. */
-async function runUatTrainReconcile(options = {}) {
-	const root = projectRoot();
-	const gitDeps = buildUatGenerationGitDeps(root);
-	return reconcileUatGenerations(root, {
-		isEnabled: () => isMergeTrainEnabled(),
-		getReadySet,
-		getMainHeadSha: () => gitDeps.fetchMain(),
-		getBranchHeadSha: (branch) => gitDeps.branchHeadSha(branch),
-		store: buildUatGenerationStore(),
-		assemble: assembleFromReadySet,
-		teardownStack: (gen) => teardownUatStack(gen),
-		cleanup: runCleanup,
-		log: (msg) => console.log(msg)
-	}, options);
-}
-let reconcilerTimer = null;
-function startUatTrainReconciler() {
-	if (!canStartUatTrainReconciler()) return false;
-	if (reconcilerTimer) return true;
-	reconcilerTimer = setInterval(() => {
-		runUatTrainReconcile().catch((err) => {
-			console.warn("[uat-train] reconcile tick failed:", err instanceof Error ? err.message : err);
-		});
-	}, RECONCILE_INTERVAL_MS);
-	reconcilerTimer.unref?.();
-	runUatTrainReconcile().catch((err) => {
-		console.warn("[uat-train] initial reconcile failed:", err instanceof Error ? err.message : err);
-	});
-	return true;
-}
-function stopUatTrainReconciler() {
-	if (reconcilerTimer) {
-		clearInterval(reconcilerTimer);
-		reconcilerTimer = null;
-	}
-}
-async function mapBounded(items, concurrency, worker) {
-	let next = 0;
-	const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
-		while (next < items.length) {
-			const item = items[next++];
-			await worker(item);
-		}
-	});
-	await Promise.all(workers);
-}
-async function loadAcceptanceCriteriaCache(issueIds) {
-	const cache = /* @__PURE__ */ new Map();
-	if (issueIds.size === 0) return cache;
-	const root = projectRoot();
-	await mapBounded([...issueIds], ACCEPTANCE_CRITERIA_READ_CONCURRENCY, async (issueId) => {
-		const upperIssueId = issueId.toUpperCase();
-		const existing = acceptanceCriteriaByIssue.get(upperIssueId);
-		if (existing) try {
-			const { mtimeMs } = await stat(existing.path);
-			if (existing.mtimeMs === mtimeMs) {
-				cache.set(upperIssueId, existing.criteria);
-				return;
-			}
-		} catch {
-			acceptanceCriteriaByIssue.delete(upperIssueId);
-		}
-		try {
-			const found = await Effect.runPromise(findXBriefByIssue(root, upperIssueId));
-			if (!found) {
-				acceptanceCriteriaByIssue.delete(upperIssueId);
-				cache.set(upperIssueId, []);
-				return;
-			}
-			const { mtimeMs } = await stat(found.path);
-			const criteria = extractACFromDocument(await Effect.runPromise(readXBriefDocument(found.path))).map((ac) => ({
-				title: ac.title,
-				status: ac.status
-			}));
-			acceptanceCriteriaByIssue.set(upperIssueId, {
-				path: found.path,
-				mtimeMs,
-				criteria
-			});
-			cache.set(upperIssueId, criteria);
-		} catch {
-			cache.set(upperIssueId, []);
-		}
-	});
-	return cache;
-}
-/** The generation chain, newest first, enriched for the UAT batches card. */
-async function getUatGenerationsPayload() {
-	if (!await readCurrentFlywheelStatusForDashboard()) return [];
-	const chain = listUatGenerationsSync({
-		projectRoot: projectRoot(),
-		limit: CHAIN_PAYLOAD_LIMIT
-	});
-	if (chain.length === 0) return [];
-	const acCache = await loadAcceptanceCriteriaCache(new Set(chain.flatMap((gen) => gen.members.map((member) => member.issueId.toUpperCase()))));
-	const payload = [];
-	for (const gen of chain) {
-		const probe = await probeUatStack(gen);
-		const members = [];
-		for (const member of gen.members) members.push({
-			issueId: member.issueId,
-			title: member.title,
-			branch: member.branch,
-			...member.pr !== void 0 ? { pr: member.pr } : {},
-			...member.prUrl !== void 0 ? { prUrl: member.prUrl } : {},
-			mergeOrder: member.mergeOrder,
-			acceptanceCriteria: acCache.get(member.issueId.toUpperCase()) ?? []
-		});
-		payload.push({
-			name: gen.name,
-			status: gen.status,
-			baseSha: gen.baseSha,
-			createdAt: gen.createdAt,
-			updatedAt: gen.updatedAt,
-			members,
-			heldOut: gen.heldOut,
-			resolutions: gen.resolutions,
-			stack: {
-				status: probe.status,
-				frontendUrl: probe.frontendUrl
-			}
-		});
-	}
-	return payload;
-}
-/** The authoritative active UAT candidate, if one is ready to test/ship. */
-async function getUatCandidatePayload() {
-	const [candidate] = listUatGenerationsSync({
-		projectRoot: projectRoot(),
-		statuses: ["ready"],
-		limit: 1
-	});
-	if (!candidate) return null;
-	return {
-		branchName: candidate.name,
-		bundled: candidate.members.map((member) => member.issueId),
-		status: "ready"
-	};
-}
-async function postUatGenerationStackPayload(name) {
-	const gen = getUatGenerationSync(name);
-	if (!gen) return {
-		ok: false,
-		error: `No UAT generation named ${name}`,
-		status: 404
-	};
-	if (gen.status !== "ready" && gen.status !== "superseded") return {
-		ok: false,
-		error: `${name} is ${gen.status} — only live batches can serve a stack`,
-		status: 409
-	};
-	const result = await ensureUatStack(gen);
-	if (!result.success) return {
-		ok: false,
-		error: result.error ?? "stack start failed",
-		status: 500
-	};
-	return {
-		ok: true,
-		frontendUrl: result.frontendUrl,
-		evicted: result.evicted
-	};
-}
-async function postUatGenerationPromotePayload(name, firePostMerge) {
-	const root = projectRoot();
-	const { reviewRecordEligibility } = await import("./flywheel-merge-order-UUcsCDb6.js");
-	const result = await promoteUatGeneration(name, root, {
-		git: buildUatPromoteGitDeps(root),
-		store: {
-			...buildUatGenerationStore(),
-			get: (n) => getUatGenerationSync(n)
-		},
-		teardownStack: (gen) => teardownUatStack(gen),
-		firePostMerge,
-		memberEligibility: reviewRecordEligibility,
-		log: (msg) => console.log(msg)
-	});
-	await notifyFlywheelOfUatPromote(result).catch(() => {});
-	return result;
-}
-//#endregion
-export { postUatGenerationStackPayload as a, startUatTrainReconciler as c, openFlywheelRunReportForDashboard as d, pauseFlywheelRunForDashboard as f, runDashboardDbJob as g, startFlywheelRunForDashboard as h, postUatGenerationPromotePayload as i, stopUatTrainReconciler as l, resumeFlywheelRunForDashboard as m, getUatCandidatePayload as n, resolveUatProjectRoot as o, readCurrentFlywheelStatusForDashboard as p, getUatGenerationsPayload as r, runUatTrainReconcile as s, canStartUatTrainReconciler as t, abortFlywheelRunForDashboard as u };
-
-//# sourceMappingURL=uat-train-DDSrSoV1.js.map