@schilderlabs/pitown-core 0.1.0 → 0.2.1

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { homedir, hostname } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
@@ -20,6 +20,120 @@ function readJsonl(filePath) {
 	}
 }
 
+//#endregion
+//#region src/agents.ts
+function writeJson$3(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$3(getAgentStatePath(artifactsDir, state.agentId), state);
+	writeJson$3(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 src/lease.ts
 function sanitize$1(value) {
@@ -120,6 +234,16 @@ function computeMetrics(input) {
 	};
 }
 
+//#endregion
+//#region src/pi.ts
+function detectPiAuthFailure(stderr, stdout) {
+	const output = `${stdout}\n${stderr}`.toLowerCase();
+	return output.includes("no models available") || output.includes("not authenticated") || output.includes("authentication") || output.includes("/login") || output.includes("api key");
+}
+function createPiAuthHelpMessage() {
+	return "Pi appears to be installed but not authenticated or configured. Verify Pi works first: pi -p \"hello\". Either set an API key or run `pi` and use `/login`.";
+}
+
 //#endregion
 //#region src/shell.ts
 function runCommandSync(command, args, options) {
@@ -136,6 +260,22 @@ function runCommandSync(command, args, options) {
 		exitCode: result.status ?? 1
 	};
 }
+function assertCommandAvailable(command) {
+	const result = spawnSync(command, ["--help"], {
+		encoding: "utf-8",
+		stdio: "ignore"
+	});
+	if (result.error instanceof Error) throw new Error(result.error.message);
+}
+function runCommandInteractive(command, args, options) {
+	const result = spawnSync(command, args, {
+		cwd: options?.cwd,
+		env: options?.env,
+		stdio: "inherit"
+	});
+	if (result.error instanceof Error) throw new Error(result.error.message);
+	return result.status ?? 1;
+}
 function assertSuccess(result, context) {
 	if (result.exitCode === 0) return;
 	const details = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
@@ -196,7 +336,17 @@ function createRepoSlug(repoId, repoRoot) {
 function createRunId() {
 	return `run-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
 }
-function writeJson(path, value) {
+function createPiInvocationArgs$1(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$2(path, value) {
 	writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
 }
 function writeText(path, value) {
@@ -205,6 +355,9 @@ 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.",
+		"Coordinate the next bounded unit of work, keep updates concise, and leave a durable artifact trail.",
+		"",
 		"Read the private plans in:",
 		`- ${input.planPath}`,
 		"",
@@ -216,6 +369,9 @@ 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.",
+		"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.",
@@ -223,6 +379,23 @@ function createPiPrompt(input) {
 		"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,
@@ -248,12 +421,13 @@ function createManifest(input) {
 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.${recommendation}`,
+		message: success ? `Pi invocation completed.${recommendation}` : `Pi invocation failed.${authHelp}${recommendation}`,
 		piExitCode: input.exitCode,
 		recommendedPlanDir: input.recommendedPlanDir
 	};
@@ -281,14 +455,33 @@ 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",
+		status: "starting",
+		task: goal,
+		branch,
+		lastMessage: goal ? `Starting leader run for goal: ${goal}` : "Starting leader run",
+		runId,
+		session: createAgentSessionRecord({
+			sessionDir: leaderSessionDir,
+			sessionId: existingLeaderSession.sessionId,
+			sessionPath: existingLeaderSession.sessionPath
+		})
+	});
+	assertPiRuntimeAvailable(piCommand);
 	mkdirSync(runDir, { recursive: true });
 	mkdirSync(latestDir, { recursive: true });
 	writeText(join(runDir, "questions.jsonl"), "");
 	writeText(join(runDir, "interventions.jsonl"), "");
-	writeJson(join(runDir, "agent-state.json"), {
+	writeJson$2(join(runDir, "agent-state.json"), {
 		status: "starting",
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	});
+	writeAgentState(artifactsDir, leaderState);
 	const lease = acquireRepoLease(runId, repoId, branch);
 	try {
 		const manifest = createManifest({
@@ -318,15 +511,23 @@ function runController(options) {
 			command: piCommand,
 			createdAt: piStartedAt
 		});
-		const piResult = runCommandSync(piCommand, [
-			"--no-session",
-			"-p",
-			prompt
-		], {
+		writeAgentState(artifactsDir, createAgentState({
+			...leaderState,
+			status: "running",
+			lastMessage: goal ? `Leader working on: ${goal}` : "Leader working"
+		}));
+		const piResult = runCommandSync(piCommand, createPiInvocationArgs$1({
+			sessionDir: leaderState.session.sessionPath === null ? leaderSessionDir : null,
+			sessionPath: leaderState.session.sessionPath,
+			prompt,
+			appendedSystemPrompt: options.appendedSystemPrompt,
+			extensionPath: options.extensionPath
+		}), {
 			cwd: repoRoot,
 			env: process.env
 		});
 		const piEndedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const latestLeaderSession = getLatestAgentSession(artifactsDir, "leader");
 		writeText(stdoutPath, piResult.stdout);
 		writeText(stderrPath, piResult.stderr);
 		const piInvocation = {
@@ -335,6 +536,9 @@ function runController(options) {
 			repoRoot,
 			planPath,
 			goal,
+			sessionDir: latestLeaderSession.sessionDir,
+			sessionId: latestLeaderSession.sessionId,
+			sessionPath: latestLeaderSession.sessionPath,
 			startedAt: piStartedAt,
 			endedAt: piEndedAt,
 			exitCode: piResult.exitCode,
@@ -342,7 +546,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$2(join(runDir, "pi-invocation.json"), piInvocation);
 		appendJsonl(join(runDir, "events.jsonl"), {
 			type: "pi_invocation_finished",
 			runId,
@@ -358,6 +562,8 @@ function runController(options) {
 			runId,
 			mode,
 			exitCode: piInvocation.exitCode,
+			stdout: piResult.stdout,
+			stderr: piResult.stderr,
 			recommendedPlanDir
 		});
 		const finalManifest = {
@@ -366,17 +572,29 @@ 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$2(join(runDir, "manifest.json"), finalManifest);
+		writeJson$2(join(runDir, "metrics.json"), metrics);
+		writeJson$2(join(runDir, "run-summary.json"), summary);
+		writeJson$2(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$2(join(latestDir, "manifest.json"), finalManifest);
+		writeJson$2(join(latestDir, "metrics.json"), metrics);
+		writeJson$2(join(latestDir, "run-summary.json"), summary);
+		writeAgentState(artifactsDir, createAgentState({
+			...leaderState,
+			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}`,
+			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
+			})
+		}));
 		appendJsonl(join(runDir, "events.jsonl"), {
 			type: "run_finished",
 			runId,
@@ -421,5 +639,589 @@ function resolveInterrupt(interrupt, options) {
 }
 
 //#endregion
-export { acquireRepoLease, appendJsonl, assertSuccess, computeAutonomousCompletionRate, computeContextCoverageScore, computeFeedbackToDemoCycleTime, computeInterruptRate, computeMeanTimeToCorrect, computeMetrics, createInterruptRecord, createRepoSlug, getCurrentBranch, getRepoIdentity, getRepoRoot, isGitRepo, readJsonl, resolveInterrupt, runCommandSync, runController };
+//#region src/tasks.ts
+function writeJson$1(path, value) {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+}
+function getTasksDir(artifactsDir) {
+	return join(artifactsDir, "tasks");
+}
+function getTaskPath(artifactsDir, taskId) {
+	return join(getTasksDir(artifactsDir), `${taskId}.json`);
+}
+function createTaskRecord(input) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		taskId: input.taskId,
+		title: input.title,
+		status: input.status,
+		role: input.role,
+		assignedAgentId: input.assignedAgentId,
+		createdBy: input.createdBy,
+		createdAt: now,
+		updatedAt: now
+	};
+}
+function writeTaskRecord(artifactsDir, task) {
+	writeJson$1(getTaskPath(artifactsDir, task.taskId), task);
+}
+function updateTaskRecordStatus(artifactsDir, taskId, status) {
+	const task = readTaskRecord(artifactsDir, taskId);
+	if (task === null) return null;
+	const updatedTask = {
+		...task,
+		status,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	writeTaskRecord(artifactsDir, updatedTask);
+	return updatedTask;
+}
+function readTaskRecord(artifactsDir, taskId) {
+	const path = getTaskPath(artifactsDir, taskId);
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function listTaskRecords(artifactsDir) {
+	const tasksDir = getTasksDir(artifactsDir);
+	let entries;
+	try {
+		entries = readdirSync(tasksDir);
+	} catch {
+		return [];
+	}
+	return entries.filter((entry) => entry.endsWith(".json")).map((entry) => readTaskRecord(artifactsDir, entry.replace(/\.json$/, ""))).filter((task) => task !== null).sort((left, right) => left.taskId.localeCompare(right.taskId));
+}
+
+//#endregion
+//#region src/loop.ts
+const DEFAULT_MAX_ITERATIONS = 10;
+const DEFAULT_MAX_WALL_TIME_MS = 36e5;
+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 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"),
+		leaderBlocked: agents.find((agent) => agent.agentId === "leader")?.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.leaderBlocked) return {
+		stopReason: "leader-blocked",
+		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("leader 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 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";
+	appendJsonl(join(loopDir, "events.jsonl"), {
+		type: "loop_started",
+		loopId,
+		maxIterations,
+		maxWallTimeMs,
+		stopOnPiFailure,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	for (let iteration = 1; iteration <= maxIterations; iteration++) {
+		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,
+			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;
+		}
+	}
+	const totalElapsedMs = Date.now() - loopStartedAt;
+	const finalBoard = iterations.length > 0 ? iterations[iterations.length - 1].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
+//#region src/orchestration.ts
+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");
+	if (input.prompt) args.push("-p", input.prompt);
+	return args;
+}
+function createRolePrompt(input) {
+	const task = input.task ?? "pick the next bounded task from the current repo context";
+	switch (input.role) {
+		case "leader": return [
+			"You are the Pi Town leader.",
+			"You coordinate work for this repository and act as the primary human-facing agent.",
+			"",
+			`Repository: ${input.repoRoot}`,
+			`Task: ${task}`,
+			"Keep updates concise, choose bounded next steps, and leave a durable artifact trail."
+		].join("\n");
+		case "reviewer": return [
+			"You are the Pi Town reviewer.",
+			"You review work for correctness, safety, and completeness.",
+			"",
+			`Repository: ${input.repoRoot}`,
+			`Task: ${task}`,
+			"Focus on validation confidence, regressions, and whether the output is ready for a human handoff."
+		].join("\n");
+		case "docs-keeper": return [
+			"You are the Pi Town docs keeper.",
+			"You summarize outcomes, blockers, and continuity in compact factual language.",
+			"",
+			`Repository: ${input.repoRoot}`,
+			`Task: ${task}`,
+			"Keep the output concise and useful for the next run or human review."
+		].join("\n");
+		default: return [
+			"You are the Pi Town worker.",
+			"You implement one bounded task at a time.",
+			"",
+			`Repository: ${input.repoRoot}`,
+			`Task: ${task}`,
+			"Keep scope tight, prefer explicit validations, and summarize what changed and what still needs follow-up."
+		].join("\n");
+	}
+}
+function resolveAgentSession(agentId, artifactsDir) {
+	const state = readAgentState(artifactsDir, agentId);
+	if (state === null) throw new Error(`Unknown agent: ${agentId}`);
+	const latestSession = getLatestAgentSession(artifactsDir, agentId);
+	const sessionPath = state.session.sessionPath ?? latestSession.sessionPath;
+	const sessionId = state.session.sessionId ?? latestSession.sessionId;
+	const sessionDir = state.session.sessionDir ?? latestSession.sessionDir ?? getAgentSessionsDir(artifactsDir, agentId);
+	if (sessionPath === null) throw new Error(`Agent ${agentId} does not have a persisted Pi session yet.`);
+	return {
+		state,
+		session: createAgentSessionRecord({
+			sessionDir,
+			sessionId,
+			sessionPath,
+			lastAttachedAt: (/* @__PURE__ */ new Date()).toISOString()
+		})
+	};
+}
+function queueAgentMessage(input) {
+	const state = readAgentState(input.artifactsDir, input.agentId);
+	if (state === null) throw new Error(`Unknown agent: ${input.agentId}`);
+	appendAgentMessage({
+		artifactsDir: input.artifactsDir,
+		agentId: input.agentId,
+		box: "inbox",
+		from: input.from,
+		body: input.body
+	});
+	writeAgentState(input.artifactsDir, createAgentState({
+		...state,
+		status: state.status === "idle" ? "queued" : state.status,
+		lastMessage: input.body,
+		waitingOn: null,
+		blocked: false,
+		session: createAgentSessionRecord({
+			sessionDir: state.session.sessionDir ?? getAgentSessionsDir(input.artifactsDir, input.agentId),
+			sessionId: state.session.sessionId,
+			sessionPath: state.session.sessionPath,
+			lastAttachedAt: state.session.lastAttachedAt
+		})
+	}));
+}
+function updateAgentStatus(input) {
+	const state = readAgentState(input.artifactsDir, input.agentId);
+	if (state === null) throw new Error(`Unknown agent: ${input.agentId}`);
+	if (state.taskId) {
+		const taskStatus = input.status === "completed" ? "completed" : input.status === "blocked" || input.status === "failed" ? "blocked" : input.status === "running" || input.status === "queued" ? "running" : null;
+		if (taskStatus) updateTaskRecordStatus(input.artifactsDir, state.taskId, taskStatus);
+	}
+	writeAgentState(input.artifactsDir, createAgentState({
+		...state,
+		status: input.status,
+		lastMessage: input.lastMessage ?? state.lastMessage,
+		waitingOn: input.waitingOn ?? state.waitingOn,
+		blocked: input.blocked ?? state.blocked,
+		session: state.session
+	}));
+}
+function spawnAgentRun(options) {
+	const sessionDir = getAgentSessionsDir(options.artifactsDir, options.agentId);
+	if (readAgentState(options.artifactsDir, options.agentId) !== null) throw new Error(`Agent already exists: ${options.agentId}`);
+	assertCommandAvailable("pi");
+	const state = createAgentState({
+		agentId: options.agentId,
+		role: options.role,
+		status: "queued",
+		taskId: options.taskId ?? null,
+		task: options.task,
+		lastMessage: options.task ? `Spawned with task: ${options.task}` : `Spawned ${options.role} agent`,
+		session: createAgentSessionRecord({ sessionDir })
+	});
+	writeAgentState(options.artifactsDir, state);
+	if (options.task) appendAgentMessage({
+		artifactsDir: options.artifactsDir,
+		agentId: options.agentId,
+		box: "inbox",
+		from: "system",
+		body: options.task
+	});
+	writeAgentState(options.artifactsDir, createAgentState({
+		...state,
+		status: "running",
+		lastMessage: options.task ? `Running ${options.role} task: ${options.task}` : `Running ${options.role} agent`
+	}));
+	const piArgs = createPiInvocationArgs({
+		sessionDir,
+		prompt: createRolePrompt({
+			role: options.role,
+			task: options.task,
+			repoRoot: options.repoRoot
+		}),
+		appendedSystemPrompt: options.appendedSystemPrompt,
+		extensionPath: options.extensionPath
+	});
+	const piResult = runCommandSync("pi", piArgs, {
+		cwd: options.repoRoot,
+		env: process.env
+	});
+	const latestSession = getLatestAgentSession(options.artifactsDir, options.agentId);
+	const agentArtifactsDir = getAgentDir(options.artifactsDir, options.agentId);
+	writeFileSync(`${agentArtifactsDir}/latest-stdout.txt`, piResult.stdout, "utf-8");
+	writeFileSync(`${agentArtifactsDir}/latest-stderr.txt`, piResult.stderr, "utf-8");
+	writeFileSync(`${agentArtifactsDir}/latest-invocation.json`, `${JSON.stringify({
+		command: "pi",
+		args: piArgs,
+		exitCode: piResult.exitCode,
+		sessionDir,
+		sessionPath: latestSession.sessionPath,
+		sessionId: latestSession.sessionId
+	}, null, 2)}\n`, "utf-8");
+	const completionMessage = piResult.stdout.trim() || (piResult.exitCode === 0 ? `${options.role} run completed` : `${options.role} run exited with code ${piResult.exitCode}`);
+	appendAgentMessage({
+		artifactsDir: options.artifactsDir,
+		agentId: options.agentId,
+		box: "outbox",
+		from: options.agentId,
+		body: completionMessage
+	});
+	writeAgentState(options.artifactsDir, createAgentState({
+		...state,
+		status: piResult.exitCode === 0 ? "idle" : "blocked",
+		lastMessage: completionMessage,
+		blocked: piResult.exitCode !== 0,
+		waitingOn: piResult.exitCode === 0 ? null : "human-or-follow-up-run",
+		session: createAgentSessionRecord({
+			sessionDir: latestSession.sessionDir,
+			sessionId: latestSession.sessionId,
+			sessionPath: latestSession.sessionPath
+		})
+	}));
+	return {
+		piResult,
+		latestSession,
+		completionMessage
+	};
+}
+function runAgentTurn(options) {
+	assertCommandAvailable("pi");
+	const resolved = resolveAgentSession(options.agentId, options.artifactsDir);
+	const messageSource = options.from ?? "human";
+	writeAgentState(options.artifactsDir, createAgentState({
+		...resolved.state,
+		status: "running",
+		lastMessage: `Responding to ${messageSource}: ${options.message}`,
+		waitingOn: null,
+		blocked: false,
+		session: resolved.session
+	}));
+	const piArgs = options.runtimeArgs && options.runtimeArgs.length > 0 ? options.runtimeArgs : createPiInvocationArgs({
+		sessionPath: resolved.session.sessionPath,
+		prompt: options.message
+	});
+	const piResult = runCommandSync("pi", piArgs, {
+		cwd: options.repoRoot,
+		env: process.env
+	});
+	const latestSession = getLatestAgentSession(options.artifactsDir, options.agentId);
+	const agentArtifactsDir = getAgentDir(options.artifactsDir, options.agentId);
+	writeFileSync(`${agentArtifactsDir}/latest-stdout.txt`, piResult.stdout, "utf-8");
+	writeFileSync(`${agentArtifactsDir}/latest-stderr.txt`, piResult.stderr, "utf-8");
+	writeFileSync(`${agentArtifactsDir}/latest-invocation.json`, `${JSON.stringify({
+		command: "pi",
+		args: piArgs,
+		exitCode: piResult.exitCode,
+		sessionDir: latestSession.sessionDir,
+		sessionPath: latestSession.sessionPath,
+		sessionId: latestSession.sessionId
+	}, null, 2)}\n`, "utf-8");
+	const completionMessage = piResult.stdout.trim() || (piResult.exitCode === 0 ? `${resolved.state.role} turn completed` : `${resolved.state.role} turn exited with code ${piResult.exitCode}`);
+	appendAgentMessage({
+		artifactsDir: options.artifactsDir,
+		agentId: options.agentId,
+		box: "outbox",
+		from: options.agentId,
+		body: completionMessage
+	});
+	writeAgentState(options.artifactsDir, createAgentState({
+		...resolved.state,
+		status: piResult.exitCode === 0 ? "idle" : "blocked",
+		lastMessage: completionMessage,
+		waitingOn: piResult.exitCode === 0 ? null : "human-or-follow-up-run",
+		blocked: piResult.exitCode !== 0,
+		session: createAgentSessionRecord({
+			sessionDir: latestSession.sessionDir,
+			sessionId: latestSession.sessionId,
+			sessionPath: latestSession.sessionPath
+		})
+	}));
+	return {
+		piResult,
+		latestSession,
+		completionMessage
+	};
+}
+function delegateTask(options) {
+	if (readAgentState(options.artifactsDir, options.fromAgentId) === null) throw new Error(`Unknown delegating agent: ${options.fromAgentId}`);
+	const agentId = options.agentId ?? `${options.role}-${Date.now()}`;
+	const task = createTaskRecord({
+		taskId: `task-${Date.now()}`,
+		title: options.task,
+		status: "queued",
+		role: options.role,
+		assignedAgentId: agentId,
+		createdBy: options.fromAgentId
+	});
+	writeTaskRecord(options.artifactsDir, task);
+	appendAgentMessage({
+		artifactsDir: options.artifactsDir,
+		agentId: options.fromAgentId,
+		box: "outbox",
+		from: options.fromAgentId,
+		body: `Delegated ${task.taskId} to ${agentId}: ${options.task}`
+	});
+	const { piResult, latestSession } = spawnAgentRun({
+		repoRoot: options.repoRoot,
+		artifactsDir: options.artifactsDir,
+		role: options.role,
+		agentId,
+		appendedSystemPrompt: options.appendedSystemPrompt,
+		extensionPath: options.extensionPath,
+		task: options.task,
+		taskId: task.taskId
+	});
+	appendAgentMessage({
+		artifactsDir: options.artifactsDir,
+		agentId,
+		box: "inbox",
+		from: options.fromAgentId,
+		body: `Delegated by ${options.fromAgentId} as ${task.taskId}: ${options.task}`
+	});
+	writeTaskRecord(options.artifactsDir, {
+		...task,
+		status: piResult.exitCode === 0 ? "completed" : "blocked",
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	return {
+		task: {
+			...task,
+			status: piResult.exitCode === 0 ? "completed" : "blocked",
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		},
+		agentId,
+		piResult,
+		latestSession
+	};
+}
+
+//#endregion
+export { acquireRepoLease, appendAgentMessage, appendJsonl, assertCommandAvailable, assertSuccess, computeAutonomousCompletionRate, computeContextCoverageScore, computeFeedbackToDemoCycleTime, computeInterruptRate, computeMeanTimeToCorrect, computeMetrics, createAgentSessionRecord, createAgentState, createInterruptRecord, createPiAuthHelpMessage, createRepoSlug, createRolePrompt, createTaskRecord, delegateTask, detectPiAuthFailure, evaluateStopCondition, getAgentDir, getAgentMailboxPath, getAgentSessionPath, getAgentSessionsDir, getAgentStatePath, getAgentsDir, getCurrentBranch, getLatestAgentSession, getRepoIdentity, getRepoRoot, getSessionIdFromPath, getTaskPath, getTasksDir, isGitRepo, listAgentStates, listTaskRecords, queueAgentMessage, readAgentMessages, readAgentState, readJsonl, readTaskRecord, resolveAgentSession, resolveInterrupt, runAgentTurn, runCommandInteractive, runCommandSync, runController, runLoop, snapshotBoard, spawnAgentRun, updateAgentStatus, updateTaskRecordStatus, writeAgentState, writeTaskRecord };
 //# sourceMappingURL=index.mjs.map