@schilderlabs/pitown 0.2.1 → 0.2.7

package/dist/{controller-9ihAZj3V.mjs → loop-CocC9qO1.mjs}

@@ -1,141 +1,11 @@
-import { n as detectPiAuthFailure, t as createPiAuthHelpMessage } from "./pi-C0fURZj7.mjs";
-import { a as runCommandSync, n as assertCommandAvailable } from "./entrypoint-CyJDLudQ.mjs";
-import { d as createRepoSlug, f as getCurrentBranch, m as getRepoRoot, p as getRepoIdentity } from "./config-CUpe9o0x.mjs";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+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/events.ts
-function appendJsonl(filePath, value) {
-	mkdirSync(dirname(filePath), { recursive: true });
-	writeFileSync(filePath, `${JSON.stringify(value)}\n`, {
-		encoding: "utf-8",
-		flag: "a"
-	});
-}
-function readJsonl(filePath) {
-	try {
-		return readFileSync(filePath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
-	} catch {
-		return [];
-	}
-}
-
-//#endregion
-//#region ../core/src/agents.ts
-function writeJson$1(path, value) {
-	mkdirSync(dirname(path), { recursive: true });
-	writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
-}
-function ensureMailbox(path) {
-	mkdirSync(dirname(path), { recursive: true });
-	if (!existsSync(path)) writeFileSync(path, "", "utf-8");
-}
-function getAgentsDir(artifactsDir) {
-	return join(artifactsDir, "agents");
-}
-function getAgentDir(artifactsDir, agentId) {
-	return join(getAgentsDir(artifactsDir), agentId);
-}
-function getAgentStatePath(artifactsDir, agentId) {
-	return join(getAgentDir(artifactsDir, agentId), "state.json");
-}
-function getAgentSessionPath(artifactsDir, agentId) {
-	return join(getAgentDir(artifactsDir, agentId), "session.json");
-}
-function getAgentMailboxPath(artifactsDir, agentId, box) {
-	return join(getAgentDir(artifactsDir, agentId), `${box}.jsonl`);
-}
-function getAgentSessionsDir(artifactsDir, agentId) {
-	return join(getAgentDir(artifactsDir, agentId), "sessions");
-}
-function getSessionIdFromPath(sessionPath) {
-	if (!sessionPath) return null;
-	return /_([0-9a-f-]+)\.jsonl$/i.exec(sessionPath)?.[1] ?? null;
-}
-function createAgentSessionRecord(input) {
-	return {
-		runtime: "pi",
-		persisted: true,
-		sessionDir: input?.sessionDir ?? null,
-		sessionId: input?.sessionId ?? null,
-		sessionPath: input?.sessionPath ?? null,
-		lastAttachedAt: input?.lastAttachedAt ?? null
-	};
-}
-function createAgentState(input) {
-	return {
-		agentId: input.agentId,
-		role: input.role,
-		status: input.status,
-		taskId: input.taskId ?? null,
-		task: input.task ?? null,
-		branch: input.branch ?? null,
-		updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		lastMessage: input.lastMessage ?? null,
-		waitingOn: input.waitingOn ?? null,
-		blocked: input.blocked ?? false,
-		runId: input.runId ?? null,
-		session: input.session ?? createAgentSessionRecord()
-	};
-}
-function writeAgentState(artifactsDir, state) {
-	mkdirSync(getAgentDir(artifactsDir, state.agentId), { recursive: true });
-	ensureMailbox(getAgentMailboxPath(artifactsDir, state.agentId, "inbox"));
-	ensureMailbox(getAgentMailboxPath(artifactsDir, state.agentId, "outbox"));
-	writeJson$1(getAgentStatePath(artifactsDir, state.agentId), state);
-	writeJson$1(getAgentSessionPath(artifactsDir, state.agentId), state.session);
-}
-function readAgentState(artifactsDir, agentId) {
-	const statePath = getAgentStatePath(artifactsDir, agentId);
-	try {
-		return JSON.parse(readFileSync(statePath, "utf-8"));
-	} catch {
-		return null;
-	}
-}
-function listAgentStates(artifactsDir) {
-	const agentsDir = getAgentsDir(artifactsDir);
-	let entries;
-	try {
-		entries = readdirSync(agentsDir);
-	} catch {
-		return [];
-	}
-	return entries.map((entry) => readAgentState(artifactsDir, entry)).filter((state) => state !== null).sort((left, right) => left.agentId.localeCompare(right.agentId));
-}
-function appendAgentMessage(input) {
-	const record = {
-		box: input.box,
-		from: input.from,
-		body: input.body,
-		createdAt: (/* @__PURE__ */ new Date()).toISOString()
-	};
-	appendJsonl(getAgentMailboxPath(input.artifactsDir, input.agentId, input.box), record);
-	return record;
-}
-function readAgentMessages(artifactsDir, agentId, box) {
-	return readJsonl(getAgentMailboxPath(artifactsDir, agentId, box));
-}
-function getLatestAgentSession(artifactsDir, agentId) {
-	const sessionDir = getAgentSessionsDir(artifactsDir, agentId);
-	let entries;
-	try {
-		entries = readdirSync(sessionDir);
-	} catch {
-		return createAgentSessionRecord({ sessionDir });
-	}
-	const latestSessionPath = entries.filter((entry) => entry.endsWith(".jsonl")).sort().at(-1) ?? null;
-	if (latestSessionPath === null) return createAgentSessionRecord({ sessionDir });
-	const sessionPath = join(sessionDir, latestSessionPath);
-	return createAgentSessionRecord({
-		sessionDir,
-		sessionPath,
-		sessionId: getSessionIdFromPath(sessionPath)
-	});
-}
-
-//#endregion
 //#region ../core/src/lease.ts
 function sanitize(value) {
 	return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
@@ -250,7 +120,7 @@ function createPiInvocationArgs(input) {
 	args.push("-p", input.prompt);
 	return args;
 }
-function writeJson(path, value) {
+function writeJson$1(path, value) {
 	writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
 }
 function writeText(path, value) {
@@ -259,7 +129,7 @@ function writeText(path, value) {
 function createPiPrompt(input) {
 	const goal = input.goal ?? "continue from current scaffold state";
 	if (input.planPath) return [
-		"You are the Pi Town leader agent for this repository.",
+		"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:",
@@ -273,7 +143,7 @@ function createPiPrompt(input) {
 		"Keep any persisted run artifacts high-signal and avoid copying private plan contents into them."
 	].join("\n");
 	return [
-		"You are the Pi Town leader agent for this repository.",
+		"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}`,
@@ -359,21 +229,21 @@ function runController(options) {
 		goal,
 		recommendedPlanDir
 	});
-	const existingLeaderState = readAgentState(artifactsDir, "leader");
-	const existingLeaderSession = existingLeaderState?.session.sessionPath || existingLeaderState?.session.sessionDir ? existingLeaderState.session : getLatestAgentSession(artifactsDir, "leader");
-	const leaderSessionDir = existingLeaderSession.sessionDir ?? getAgentSessionsDir(artifactsDir, "leader");
-	const leaderState = createAgentState({
-		agentId: "leader",
-		role: "leader",
+	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 leader run for goal: ${goal}` : "Starting leader run",
+		lastMessage: goal ? `Starting mayor run for goal: ${goal}` : "Starting mayor run",
 		runId,
 		session: createAgentSessionRecord({
-			sessionDir: leaderSessionDir,
-			sessionId: existingLeaderSession.sessionId,
-			sessionPath: existingLeaderSession.sessionPath
+			sessionDir: mayorSessionDir,
+			sessionId: existingMayorSession.sessionId,
+			sessionPath: existingMayorSession.sessionPath
 		})
 	});
 	assertPiRuntimeAvailable(piCommand);
@@ -381,11 +251,11 @@ function runController(options) {
 	mkdirSync(latestDir, { recursive: true });
 	writeText(join(runDir, "questions.jsonl"), "");
 	writeText(join(runDir, "interventions.jsonl"), "");
-	writeJson(join(runDir, "agent-state.json"), {
+	writeJson$1(join(runDir, "agent-state.json"), {
 		status: "starting",
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	});
-	writeAgentState(artifactsDir, leaderState);
+	writeAgentState(artifactsDir, mayorState);
 	const lease = acquireRepoLease(runId, repoId, branch);
 	try {
 		const manifest = createManifest({
@@ -416,13 +286,13 @@ function runController(options) {
 			createdAt: piStartedAt
 		});
 		writeAgentState(artifactsDir, createAgentState({
-			...leaderState,
+			...mayorState,
 			status: "running",
-			lastMessage: goal ? `Leader working on: ${goal}` : "Leader working"
+			lastMessage: goal ? `Mayor working on: ${goal}` : "Mayor working"
 		}));
 		const piResult = runCommandSync(piCommand, createPiInvocationArgs({
-			sessionDir: leaderState.session.sessionPath === null ? leaderSessionDir : null,
-			sessionPath: leaderState.session.sessionPath,
+			sessionDir: mayorState.session.sessionPath === null ? mayorSessionDir : null,
+			sessionPath: mayorState.session.sessionPath,
 			prompt,
 			appendedSystemPrompt: options.appendedSystemPrompt,
 			extensionPath: options.extensionPath
@@ -431,7 +301,7 @@ function runController(options) {
 			env: process.env
 		});
 		const piEndedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const latestLeaderSession = getLatestAgentSession(artifactsDir, "leader");
+		const latestMayorSession = getLatestAgentSession(artifactsDir, "mayor");
 		writeText(stdoutPath, piResult.stdout);
 		writeText(stderrPath, piResult.stderr);
 		const piInvocation = {
@@ -440,9 +310,9 @@ function runController(options) {
 			repoRoot,
 			planPath,
 			goal,
-			sessionDir: latestLeaderSession.sessionDir,
-			sessionId: latestLeaderSession.sessionId,
-			sessionPath: latestLeaderSession.sessionPath,
+			sessionDir: latestMayorSession.sessionDir,
+			sessionId: latestMayorSession.sessionId,
+			sessionPath: latestMayorSession.sessionPath,
 			startedAt: piStartedAt,
 			endedAt: piEndedAt,
 			exitCode: piResult.exitCode,
@@ -450,7 +320,7 @@ function runController(options) {
 			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(join(runDir, "pi-invocation.json"), piInvocation);
+		writeJson$1(join(runDir, "pi-invocation.json"), piInvocation);
 		appendJsonl(join(runDir, "events.jsonl"), {
 			type: "pi_invocation_finished",
 			runId,
@@ -476,27 +346,27 @@ function runController(options) {
 			stopReason: piInvocation.exitCode === 0 ? "pi invocation completed" : `pi invocation exited with code ${piInvocation.exitCode}`,
 			piExitCode: piInvocation.exitCode
 		};
-		writeJson(join(runDir, "manifest.json"), finalManifest);
-		writeJson(join(runDir, "metrics.json"), metrics);
-		writeJson(join(runDir, "run-summary.json"), summary);
-		writeJson(join(runDir, "agent-state.json"), {
+		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(join(latestDir, "manifest.json"), finalManifest);
-		writeJson(join(latestDir, "metrics.json"), metrics);
-		writeJson(join(latestDir, "run-summary.json"), summary);
+		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({
-			...leaderState,
+			...mayorState,
 			status: piInvocation.exitCode === 0 ? "idle" : "blocked",
-			lastMessage: piInvocation.exitCode === 0 ? "Leader run completed and is ready for the next instruction" : `Leader run stopped with exit code ${piInvocation.exitCode}`,
+			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: latestLeaderSession.sessionDir,
-				sessionId: latestLeaderSession.sessionId,
-				sessionPath: latestLeaderSession.sessionPath
+				sessionDir: latestMayorSession.sessionDir,
+				sessionId: latestMayorSession.sessionId,
+				sessionPath: latestMayorSession.sessionPath
 			})
 		}));
 		appendJsonl(join(runDir, "events.jsonl"), {
@@ -521,5 +391,288 @@ function runController(options) {
 }
 
 //#endregion
-export { createAgentState as a, getLatestAgentSession as c, readAgentState as d, writeAgentState as f, createAgentSessionRecord as i, listAgentStates as l, computeMetrics as n, getAgentDir as o, appendJsonl as p, appendAgentMessage as r, getAgentSessionsDir as s, runController as t, readAgentMessages as u };
-//# sourceMappingURL=controller-9ihAZj3V.mjs.map
+//#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