@schilderlabs/pitown 0.1.2 → 0.2.6

package/dist/loop-CocC9qO1.mjs

@@ -0,0 +1,678 @@
+import { d as listAgentStates, h as appendJsonl, l as getAgentSessionsDir, m as writeAgentState, n as listTaskRecords, o as createAgentSessionRecord, p as readAgentState, s as createAgentState, u as getLatestAgentSession } from "./tasks-De4IAy3x.mjs";
+import { n as detectPiAuthFailure, t as createPiAuthHelpMessage } from "./pi-C7HRNjBG.mjs";
+import { a as runCommandSync, n as assertCommandAvailable } from "./entrypoint-WBAQmFbT.mjs";
+import { d as createRepoSlug, f as getCurrentBranch, m as getRepoRoot, p as getRepoIdentity } from "./config-BG1v4iIi.mjs";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, hostname } from "node:os";
+
+//#region ../core/src/lease.ts
+function sanitize(value) {
+	return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+function processAlive(pid) {
+	if (!Number.isFinite(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function acquireRepoLease(runId, repoId, branch) {
+	const locksDir = join(homedir(), ".pi-town", "locks");
+	mkdirSync(locksDir, { recursive: true });
+	const leasePath = join(locksDir, `pi-town-${sanitize(repoId)}-${sanitize(branch)}.json`);
+	const nextData = {
+		runId,
+		repoId,
+		branch,
+		pid: process.pid,
+		hostname: hostname(),
+		startedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	try {
+		const current = JSON.parse(readFileSync(leasePath, "utf-8"));
+		if (processAlive(current.pid)) throw new Error(`Pi Town lease already held by pid ${current.pid} on ${current.hostname} for run ${current.runId}.`);
+		rmSync(leasePath, { force: true });
+	} catch (error) {
+		if (error.code !== "ENOENT") {
+			if (error instanceof Error && error.message.startsWith("Pi Town lease already held")) throw error;
+		}
+	}
+	writeFileSync(leasePath, `${JSON.stringify(nextData, null, 2)}\n`, "utf-8");
+	return {
+		path: leasePath,
+		release: () => {
+			try {
+				if (JSON.parse(readFileSync(leasePath, "utf-8")).runId === runId) rmSync(leasePath, { force: true });
+			} catch {}
+		}
+	};
+}
+
+//#endregion
+//#region ../core/src/metrics.ts
+function round(value) {
+	return Math.round(value * 1e3) / 1e3;
+}
+function diffHours(start, end) {
+	return (Date.parse(end) - Date.parse(start)) / 36e5;
+}
+function average(values) {
+	if (values.length === 0) return null;
+	return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function computeInterruptRate(interrupts, taskAttempts) {
+	if (taskAttempts.length === 0) return 0;
+	return round(interrupts.length / taskAttempts.length);
+}
+function computeAutonomousCompletionRate(taskAttempts) {
+	const completed = taskAttempts.filter((task) => task.status === "completed");
+	if (completed.length === 0) return 0;
+	return round(completed.filter((task) => !task.interrupted).length / completed.length);
+}
+function computeContextCoverageScore(interrupts) {
+	const observed = new Set(interrupts.map((interrupt) => interrupt.category));
+	if (observed.size === 0) return 0;
+	return round(new Set(interrupts.filter((interrupt) => interrupt.fixType).map((interrupt) => interrupt.category)).size / observed.size);
+}
+function computeMeanTimeToCorrect(interrupts) {
+	const value = average(interrupts.filter((interrupt) => interrupt.resolvedAt).map((interrupt) => diffHours(interrupt.createdAt, interrupt.resolvedAt)));
+	return value === null ? null : round(value);
+}
+function computeFeedbackToDemoCycleTime(feedbackCycles) {
+	const value = average(feedbackCycles.map((cycle) => diffHours(cycle.feedbackAt, cycle.demoReadyAt)));
+	return value === null ? null : round(value);
+}
+function computeMetrics(input) {
+	const observedCategories = new Set(input.interrupts.map((interrupt) => interrupt.category));
+	const coveredCategories = new Set(input.interrupts.filter((interrupt) => interrupt.fixType).map((interrupt) => interrupt.category));
+	const completedTasks = input.taskAttempts.filter((task) => task.status === "completed").length;
+	return {
+		interruptRate: computeInterruptRate(input.interrupts, input.taskAttempts),
+		autonomousCompletionRate: computeAutonomousCompletionRate(input.taskAttempts),
+		contextCoverageScore: computeContextCoverageScore(input.interrupts),
+		meanTimeToCorrectHours: computeMeanTimeToCorrect(input.interrupts),
+		feedbackToDemoCycleTimeHours: computeFeedbackToDemoCycleTime(input.feedbackCycles ?? []),
+		totals: {
+			taskAttempts: input.taskAttempts.length,
+			completedTasks,
+			interrupts: input.interrupts.length,
+			observedInterruptCategories: observedCategories.size,
+			coveredInterruptCategories: coveredCategories.size
+		}
+	};
+}
+
+//#endregion
+//#region ../core/src/controller.ts
+function createRunId() {
+	return `run-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+}
+function createPiInvocationArgs(input) {
+	const args = [];
+	if (input.extensionPath) args.push("--extension", input.extensionPath);
+	if (input.appendedSystemPrompt) args.push("--append-system-prompt", input.appendedSystemPrompt);
+	if (input.sessionPath) args.push("--session", input.sessionPath);
+	else if (input.sessionDir) args.push("--session-dir", input.sessionDir);
+	else throw new Error("Pi invocation requires a session path or session directory");
+	args.push("-p", input.prompt);
+	return args;
+}
+function writeJson$1(path, value) {
+	writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+}
+function writeText(path, value) {
+	writeFileSync(path, value, "utf-8");
+}
+function createPiPrompt(input) {
+	const goal = input.goal ?? "continue from current scaffold state";
+	if (input.planPath) return [
+		"You are the Pi Town mayor agent for this repository.",
+		"Coordinate the next bounded unit of work, keep updates concise, and leave a durable artifact trail.",
+		"",
+		"Read the private plans in:",
+		`- ${input.planPath}`,
+		"",
+		"and the current code in:",
+		`- ${input.repoRoot}`,
+		"",
+		`Goal: ${goal}`,
+		"Continue from the current scaffold state.",
+		"Keep any persisted run artifacts high-signal and avoid copying private plan contents into them."
+	].join("\n");
+	return [
+		"You are the Pi Town mayor agent for this repository.",
+		"Coordinate the next bounded unit of work, keep updates concise, and leave a durable artifact trail.",
+		"",
+		`Work in the repository at: ${input.repoRoot}`,
+		`Goal: ${goal}`,
+		"No private plan path is configured for this run.",
+		input.recommendedPlanDir ? `If you need private plans, use a user-owned location such as: ${input.recommendedPlanDir}` : "If you need private plans, keep them in a user-owned location outside the repo.",
+		"Continue from the current scaffold state."
+	].join("\n");
+}
+function assertPiRuntimeAvailable(piCommand) {
+	try {
+		assertCommandAvailable(piCommand);
+	} catch (error) {
+		if (piCommand === "pi") throw new Error([
+			"Pi Town requires the `pi` CLI to run `pitown run`.",
+			"Install Pi: npm install -g @mariozechner/pi-coding-agent",
+			"Then authenticate Pi and verify it works: pi -p \"hello\"",
+			`Details: ${error.message}`
+		].join("\n"));
+		throw new Error([
+			`Pi Town could not execute the configured Pi command: ${piCommand}`,
+			"Make sure the command exists on PATH or points to an executable file.",
+			`Details: ${error.message}`
+		].join("\n"));
+	}
+}
+function createManifest(input) {
+	return {
+		runId: input.runId,
+		repoId: input.repoId,
+		repoSlug: input.repoSlug,
+		repoRoot: input.repoRoot,
+		branch: input.branch,
+		goal: input.goal,
+		planPath: input.planPath,
+		recommendedPlanDir: input.recommendedPlanDir,
+		mode: input.mode,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		endedAt: null,
+		stopReason: null,
+		leasePath: input.leasePath,
+		piExitCode: null,
+		completedTaskCount: 0,
+		blockedTaskCount: 0,
+		skippedTaskCount: 0,
+		totalCostUsd: 0
+	};
+}
+function createSummary(input) {
+	const success = input.exitCode === 0;
+	const recommendation = input.recommendedPlanDir === null ? "" : ` No plan path was configured. Recommended private plans location: ${input.recommendedPlanDir}.`;
+	const authHelp = success || !detectPiAuthFailure(input.stderr, input.stdout) ? "" : ` ${createPiAuthHelpMessage()}`;
+	return {
+		runId: input.runId,
+		mode: input.mode,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		success,
+		message: success ? `Pi invocation completed.${recommendation}` : `Pi invocation failed.${authHelp}${recommendation}`,
+		piExitCode: input.exitCode,
+		recommendedPlanDir: input.recommendedPlanDir
+	};
+}
+function runController(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const artifactsDir = options.artifactsDir;
+	const repoRoot = getRepoRoot(cwd);
+	const repoId = getRepoIdentity(repoRoot);
+	const repoSlug = createRepoSlug(repoId, repoRoot);
+	const branch = options.branch ?? getCurrentBranch(repoRoot) ?? "workspace";
+	const goal = options.goal ?? null;
+	const planPath = options.planPath ?? null;
+	const recommendedPlanDir = planPath ? null : options.recommendedPlanDir ?? null;
+	const mode = options.mode ?? "single-pi";
+	const piCommand = options.piCommand ?? "pi";
+	const runId = createRunId();
+	const runDir = join(artifactsDir, "runs", runId);
+	const latestDir = join(artifactsDir, "latest");
+	const stdoutPath = join(runDir, "stdout.txt");
+	const stderrPath = join(runDir, "stderr.txt");
+	const prompt = createPiPrompt({
+		repoRoot,
+		planPath,
+		goal,
+		recommendedPlanDir
+	});
+	const existingMayorState = readAgentState(artifactsDir, "mayor");
+	const existingMayorSession = existingMayorState?.session.sessionPath || existingMayorState?.session.sessionDir ? existingMayorState.session : getLatestAgentSession(artifactsDir, "mayor");
+	const mayorSessionDir = existingMayorSession.sessionDir ?? getAgentSessionsDir(artifactsDir, "mayor");
+	const mayorState = createAgentState({
+		agentId: "mayor",
+		role: "mayor",
+		status: "starting",
+		task: goal,
+		branch,
+		lastMessage: goal ? `Starting mayor run for goal: ${goal}` : "Starting mayor run",
+		runId,
+		session: createAgentSessionRecord({
+			sessionDir: mayorSessionDir,
+			sessionId: existingMayorSession.sessionId,
+			sessionPath: existingMayorSession.sessionPath
+		})
+	});
+	assertPiRuntimeAvailable(piCommand);
+	mkdirSync(runDir, { recursive: true });
+	mkdirSync(latestDir, { recursive: true });
+	writeText(join(runDir, "questions.jsonl"), "");
+	writeText(join(runDir, "interventions.jsonl"), "");
+	writeJson$1(join(runDir, "agent-state.json"), {
+		status: "starting",
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	writeAgentState(artifactsDir, mayorState);
+	const lease = acquireRepoLease(runId, repoId, branch);
+	try {
+		const manifest = createManifest({
+			runId,
+			repoId,
+			repoSlug,
+			repoRoot,
+			branch,
+			goal,
+			planPath,
+			recommendedPlanDir,
+			mode,
+			leasePath: lease.path
+		});
+		appendJsonl(join(runDir, "events.jsonl"), {
+			type: "run_started",
+			runId,
+			repoId,
+			repoSlug,
+			branch,
+			createdAt: manifest.startedAt
+		});
+		const piStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+		appendJsonl(join(runDir, "events.jsonl"), {
+			type: "pi_invocation_started",
+			runId,
+			command: piCommand,
+			createdAt: piStartedAt
+		});
+		writeAgentState(artifactsDir, createAgentState({
+			...mayorState,
+			status: "running",
+			lastMessage: goal ? `Mayor working on: ${goal}` : "Mayor working"
+		}));
+		const piResult = runCommandSync(piCommand, createPiInvocationArgs({
+			sessionDir: mayorState.session.sessionPath === null ? mayorSessionDir : null,
+			sessionPath: mayorState.session.sessionPath,
+			prompt,
+			appendedSystemPrompt: options.appendedSystemPrompt,
+			extensionPath: options.extensionPath
+		}), {
+			cwd: repoRoot,
+			env: process.env
+		});
+		const piEndedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const latestMayorSession = getLatestAgentSession(artifactsDir, "mayor");
+		writeText(stdoutPath, piResult.stdout);
+		writeText(stderrPath, piResult.stderr);
+		const piInvocation = {
+			command: piCommand,
+			cwd: repoRoot,
+			repoRoot,
+			planPath,
+			goal,
+			sessionDir: latestMayorSession.sessionDir,
+			sessionId: latestMayorSession.sessionId,
+			sessionPath: latestMayorSession.sessionPath,
+			startedAt: piStartedAt,
+			endedAt: piEndedAt,
+			exitCode: piResult.exitCode,
+			stdoutPath,
+			stderrPath,
+			promptSummary: planPath ? "Read private plan path and continue from current scaffold state." : "Continue from current scaffold state without a configured private plan path."
+		};
+		writeJson$1(join(runDir, "pi-invocation.json"), piInvocation);
+		appendJsonl(join(runDir, "events.jsonl"), {
+			type: "pi_invocation_finished",
+			runId,
+			command: piCommand,
+			exitCode: piInvocation.exitCode,
+			createdAt: piEndedAt
+		});
+		const metrics = computeMetrics({
+			taskAttempts: [],
+			interrupts: []
+		});
+		const summary = createSummary({
+			runId,
+			mode,
+			exitCode: piInvocation.exitCode,
+			stdout: piResult.stdout,
+			stderr: piResult.stderr,
+			recommendedPlanDir
+		});
+		const finalManifest = {
+			...manifest,
+			endedAt: piEndedAt,
+			stopReason: piInvocation.exitCode === 0 ? "pi invocation completed" : `pi invocation exited with code ${piInvocation.exitCode}`,
+			piExitCode: piInvocation.exitCode
+		};
+		writeJson$1(join(runDir, "manifest.json"), finalManifest);
+		writeJson$1(join(runDir, "metrics.json"), metrics);
+		writeJson$1(join(runDir, "run-summary.json"), summary);
+		writeJson$1(join(runDir, "agent-state.json"), {
+			status: summary.success ? "completed" : "failed",
+			updatedAt: piEndedAt,
+			exitCode: piInvocation.exitCode
+		});
+		writeJson$1(join(latestDir, "manifest.json"), finalManifest);
+		writeJson$1(join(latestDir, "metrics.json"), metrics);
+		writeJson$1(join(latestDir, "run-summary.json"), summary);
+		writeAgentState(artifactsDir, createAgentState({
+			...mayorState,
+			status: piInvocation.exitCode === 0 ? "idle" : "blocked",
+			lastMessage: piInvocation.exitCode === 0 ? "Mayor run completed and is ready for the next instruction" : `Mayor run stopped with exit code ${piInvocation.exitCode}`,
+			blocked: piInvocation.exitCode !== 0,
+			waitingOn: piInvocation.exitCode === 0 ? null : "human-or-follow-up-run",
+			session: createAgentSessionRecord({
+				sessionDir: latestMayorSession.sessionDir,
+				sessionId: latestMayorSession.sessionId,
+				sessionPath: latestMayorSession.sessionPath
+			})
+		}));
+		appendJsonl(join(runDir, "events.jsonl"), {
+			type: "run_finished",
+			runId,
+			createdAt: finalManifest.endedAt,
+			stopReason: finalManifest.stopReason,
+			metrics
+		});
+		return {
+			runId,
+			runDir,
+			latestDir,
+			manifest: finalManifest,
+			metrics,
+			summary,
+			piInvocation
+		};
+	} finally {
+		lease.release();
+	}
+}
+
+//#endregion
+//#region ../core/src/loop.ts
+const DEFAULT_MAX_ITERATIONS = 10;
+const DEFAULT_MAX_WALL_TIME_MS = 36e5;
+const DEFAULT_BACKGROUND_POLL_MS = 250;
+function createLoopId() {
+	return `loop-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+}
+function writeJson(path, value) {
+	writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+}
+function sleepMs(ms) {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function hasBackgroundWork(board) {
+	return board.agents.some((agent) => agent.agentId !== "mayor" && (agent.status === "queued" || agent.status === "running" || agent.status === "starting")) || board.tasks.some((task) => task.status === "queued" || task.status === "running");
+}
+function waitForBackgroundWorkToSettle(input) {
+	const pollIntervalMs = input.pollIntervalMs ?? DEFAULT_BACKGROUND_POLL_MS;
+	let board = snapshotBoard(input.artifactsDir);
+	while (hasBackgroundWork(board)) {
+		if (Date.now() - input.loopStartedAt >= input.maxWallTimeMs) return {
+			timedOut: true,
+			board
+		};
+		sleepMs(pollIntervalMs);
+		board = snapshotBoard(input.artifactsDir);
+	}
+	return {
+		timedOut: false,
+		board
+	};
+}
+function snapshotBoard(artifactsDir) {
+	const tasks = listTaskRecords(artifactsDir);
+	const agents = listAgentStates(artifactsDir);
+	return {
+		tasks: tasks.map((task) => ({
+			taskId: task.taskId,
+			status: task.status
+		})),
+		agents: agents.map((agent) => ({
+			agentId: agent.agentId,
+			status: agent.status,
+			blocked: agent.blocked
+		})),
+		allTasksCompleted: tasks.length > 0 && tasks.every((task) => task.status === "completed"),
+		allRemainingTasksBlocked: tasks.length > 0 && tasks.every((task) => task.status === "completed" || task.status === "blocked" || task.status === "aborted"),
+		mayorBlocked: agents.find((agent) => agent.agentId === "mayor")?.blocked === true,
+		hasQueuedOrRunningWork: agents.some((agent) => agent.status === "queued" || agent.status === "running" || agent.status === "starting") || tasks.some((task) => task.status === "queued" || task.status === "running")
+	};
+}
+function evaluateStopCondition(input) {
+	if (input.iteration >= input.maxIterations) return {
+		stopReason: "max-iterations-reached",
+		continueReason: null
+	};
+	if (input.elapsedMs >= input.maxWallTimeMs) return {
+		stopReason: "max-wall-time-reached",
+		continueReason: null
+	};
+	if (input.stopOnPiFailure && input.piExitCode !== 0) return {
+		stopReason: "pi-exit-nonzero",
+		continueReason: null
+	};
+	if (input.board.allTasksCompleted) return {
+		stopReason: "all-tasks-completed",
+		continueReason: null
+	};
+	if (input.board.mayorBlocked) return {
+		stopReason: "mayor-blocked",
+		continueReason: null
+	};
+	const mayor = input.board.agents.find((agent) => agent.agentId === "mayor");
+	if (input.stopOnMayorIdleNoWork && mayor && !input.board.hasQueuedOrRunningWork && input.board.tasks.length === 0 && mayor.status === "idle") return {
+		stopReason: "mayor-idle-no-work",
+		continueReason: null
+	};
+	if (input.board.allRemainingTasksBlocked) return {
+		stopReason: "all-remaining-tasks-blocked",
+		continueReason: null
+	};
+	if (input.interruptRateThreshold !== null && input.metrics.interruptRate > input.interruptRateThreshold) return {
+		stopReason: "high-interrupt-rate",
+		continueReason: null
+	};
+	const reasons = [];
+	if (input.board.hasQueuedOrRunningWork) reasons.push("queued or running work remains");
+	if (input.board.tasks.length === 0) reasons.push("no tasks tracked yet");
+	if (reasons.length === 0) reasons.push("mayor idle, no stop condition met");
+	return {
+		stopReason: null,
+		continueReason: reasons.join("; ")
+	};
+}
+function aggregateMetrics(iterations) {
+	if (iterations.length === 0) return computeMetrics({
+		taskAttempts: [],
+		interrupts: []
+	});
+	let totalTaskAttempts = 0;
+	let totalCompletedTasks = 0;
+	let totalInterrupts = 0;
+	let totalObservedInterruptCategories = 0;
+	let totalCoveredInterruptCategories = 0;
+	let interruptRateSum = 0;
+	let autonomousCompletionRateSum = 0;
+	let contextCoverageScoreSum = 0;
+	let mttcValues = [];
+	let ftdValues = [];
+	for (const iter of iterations) {
+		const m = iter.metrics;
+		totalTaskAttempts += m.totals.taskAttempts;
+		totalCompletedTasks += m.totals.completedTasks;
+		totalInterrupts += m.totals.interrupts;
+		totalObservedInterruptCategories += m.totals.observedInterruptCategories;
+		totalCoveredInterruptCategories += m.totals.coveredInterruptCategories;
+		interruptRateSum += m.interruptRate;
+		autonomousCompletionRateSum += m.autonomousCompletionRate;
+		contextCoverageScoreSum += m.contextCoverageScore;
+		if (m.meanTimeToCorrectHours !== null) mttcValues.push(m.meanTimeToCorrectHours);
+		if (m.feedbackToDemoCycleTimeHours !== null) ftdValues.push(m.feedbackToDemoCycleTimeHours);
+	}
+	const count = iterations.length;
+	const round = (v) => Math.round(v * 1e3) / 1e3;
+	const avg = (values) => values.length === 0 ? null : round(values.reduce((s, v) => s + v, 0) / values.length);
+	return {
+		interruptRate: round(interruptRateSum / count),
+		autonomousCompletionRate: round(autonomousCompletionRateSum / count),
+		contextCoverageScore: round(contextCoverageScoreSum / count),
+		meanTimeToCorrectHours: avg(mttcValues),
+		feedbackToDemoCycleTimeHours: avg(ftdValues),
+		totals: {
+			taskAttempts: totalTaskAttempts,
+			completedTasks: totalCompletedTasks,
+			interrupts: totalInterrupts,
+			observedInterruptCategories: totalObservedInterruptCategories,
+			coveredInterruptCategories: totalCoveredInterruptCategories
+		}
+	};
+}
+function runLoop(options) {
+	const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+	const maxWallTimeMs = options.maxWallTimeMs ?? DEFAULT_MAX_WALL_TIME_MS;
+	const stopOnPiFailure = options.stopOnPiFailure ?? true;
+	const stopOnMayorIdleNoWork = options.stopOnMayorIdleNoWork ?? false;
+	const interruptRateThreshold = options.interruptRateThreshold ?? null;
+	const loopId = createLoopId();
+	const artifactsDir = options.runOptions.artifactsDir;
+	const loopDir = join(artifactsDir, "loops", loopId);
+	mkdirSync(loopDir, { recursive: true });
+	const loopStartedAt = Date.now();
+	const iterations = [];
+	let finalStopReason = "max-iterations-reached";
+	let needsMayorFollowUp = false;
+	appendJsonl(join(loopDir, "events.jsonl"), {
+		type: "loop_started",
+		loopId,
+		maxIterations,
+		maxWallTimeMs,
+		stopOnPiFailure,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	for (let iteration = 1; iteration <= maxIterations; iteration++) {
+		if (needsMayorFollowUp) {
+			const settled = waitForBackgroundWorkToSettle({
+				artifactsDir,
+				maxWallTimeMs,
+				loopStartedAt
+			});
+			appendJsonl(join(loopDir, "events.jsonl"), {
+				type: "loop_background_work_settled",
+				loopId,
+				iteration,
+				timedOut: settled.timedOut,
+				boardSnapshot: settled.board,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			if (settled.timedOut) {
+				finalStopReason = "max-wall-time-reached";
+				break;
+			}
+			needsMayorFollowUp = false;
+		}
+		const iterationStart = Date.now();
+		let controllerResult;
+		try {
+			controllerResult = runController(options.runOptions);
+		} catch (error) {
+			appendJsonl(join(loopDir, "events.jsonl"), {
+				type: "loop_iteration_error",
+				loopId,
+				iteration,
+				error: error.message,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			finalStopReason = "pi-exit-nonzero";
+			break;
+		}
+		const iterationElapsedMs = Date.now() - iterationStart;
+		const totalElapsedMs = Date.now() - loopStartedAt;
+		const board = snapshotBoard(artifactsDir);
+		const metrics = controllerResult.metrics;
+		const { stopReason, continueReason } = evaluateStopCondition({
+			iteration,
+			maxIterations,
+			elapsedMs: totalElapsedMs,
+			maxWallTimeMs,
+			piExitCode: controllerResult.piInvocation.exitCode,
+			stopOnPiFailure,
+			stopOnMayorIdleNoWork,
+			board,
+			metrics,
+			interruptRateThreshold
+		});
+		const iterationResult = {
+			iteration,
+			controllerResult,
+			boardSnapshot: board,
+			metrics,
+			elapsedMs: iterationElapsedMs,
+			continueReason,
+			stopReason
+		};
+		iterations.push(iterationResult);
+		writeJson(join(loopDir, `iteration-${iteration}.json`), {
+			iteration,
+			runId: controllerResult.runId,
+			boardSnapshot: board,
+			metrics,
+			elapsedMs: iterationElapsedMs,
+			continueReason,
+			stopReason
+		});
+		appendJsonl(join(loopDir, "events.jsonl"), {
+			type: "loop_iteration_completed",
+			loopId,
+			iteration,
+			runId: controllerResult.runId,
+			piExitCode: controllerResult.piInvocation.exitCode,
+			stopReason,
+			continueReason,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		if (options.onIterationComplete) options.onIterationComplete(iterationResult);
+		if (stopReason !== null) {
+			finalStopReason = stopReason;
+			break;
+		}
+		needsMayorFollowUp = hasBackgroundWork(board);
+	}
+	const totalElapsedMs = Date.now() - loopStartedAt;
+	const lastIteration = iterations.at(-1);
+	const finalBoard = lastIteration ? lastIteration.boardSnapshot : snapshotBoard(artifactsDir);
+	const aggregate = aggregateMetrics(iterations);
+	const loopResult = {
+		loopId,
+		iterations,
+		stopReason: finalStopReason,
+		totalIterations: iterations.length,
+		totalElapsedMs,
+		finalBoardSnapshot: finalBoard,
+		aggregateMetrics: aggregate
+	};
+	writeJson(join(loopDir, "loop-summary.json"), {
+		loopId,
+		stopReason: finalStopReason,
+		totalIterations: iterations.length,
+		totalElapsedMs,
+		finalBoardSnapshot: finalBoard,
+		aggregateMetrics: aggregate
+	});
+	appendJsonl(join(loopDir, "events.jsonl"), {
+		type: "loop_finished",
+		loopId,
+		stopReason: finalStopReason,
+		totalIterations: iterations.length,
+		totalElapsedMs,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	return loopResult;
+}
+
+//#endregion
+export { runLoop as t };
+//# sourceMappingURL=loop-CocC9qO1.mjs.map