@schilderlabs/pitown-core 0.2.1 → 0.2.7

package/dist/index.mjs

@@ -1,145 +1,14 @@
+import { A as getLatestAgentSession, C as createAgentState, D as getAgentSessionsDir, E as getAgentSessionPath, F as writeAgentState, I as appendJsonl, L as readJsonl, M as listAgentStates, N as readAgentMessages, O as getAgentStatePath, P as readAgentState, S as createAgentSessionRecord, T as getAgentMailboxPath, _ as assertCommandAvailable, a as resolveAgentSession, b as runCommandSync, c as spawnAgentRun, d as getTaskPath, f as getTasksDir, g as writeTaskRecord, h as updateTaskRecordStatus, i as queueAgentMessage, j as getSessionIdFromPath, k as getAgentsDir, l as updateAgentStatus, m as readTaskRecord, n as delegateTask, o as resumeAgentTurnDetached, p as listTaskRecords, r as notifyTaskDelegator, s as runAgentTurn, t as createRolePrompt, u as createTaskRecord, v as assertSuccess, w as getAgentDir, x as appendAgentMessage, y as runCommandInteractive } from "./orchestration-D6XeSl8s.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
 import { homedir, hostname } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
-import { spawnSync } from "node:child_process";
 
-//#region 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 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) {
 	return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
 }
-function processAlive(pid) {
+function processAlive$1(pid) {
 	if (!Number.isFinite(pid) || pid <= 0) return false;
 	try {
 		process.kill(pid, 0);
@@ -162,7 +31,7 @@ function acquireRepoLease(runId, repoId, branch) {
 	};
 	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}.`);
+		if (processAlive$1(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") {
@@ -244,44 +113,6 @@ 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) {
-	const result = spawnSync(command, args, {
-		cwd: options?.cwd,
-		env: options?.env,
-		encoding: "utf-8"
-	});
-	const errorText = result.error instanceof Error ? `${result.error.message}
-` : "";
-	return {
-		stdout: result.stdout ?? "",
-		stderr: `${errorText}${result.stderr ?? ""}`,
-		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");
-	throw new Error(`${context} failed${details ? `\n${details}` : ""}`);
-}
-
 //#endregion
 //#region src/repo.ts
 function gitResult(cwd, args) {
@@ -336,7 +167,7 @@ function createRepoSlug(repoId, repoRoot) {
 function createRunId() {
 	return `run-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
 }
-function createPiInvocationArgs$1(input) {
+function createPiInvocationArgs(input) {
 	const args = [];
 	if (input.extensionPath) args.push("--extension", input.extensionPath);
 	if (input.appendedSystemPrompt) args.push("--append-system-prompt", input.appendedSystemPrompt);
@@ -346,7 +177,7 @@ function createPiInvocationArgs$1(input) {
 	args.push("-p", input.prompt);
 	return args;
 }
-function writeJson$2(path, value) {
+function writeJson$1(path, value) {
 	writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
 }
 function writeText(path, value) {
@@ -355,7 +186,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:",
@@ -369,7 +200,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}`,
@@ -455,21 +286,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);
@@ -477,11 +308,11 @@ function runController(options) {
 	mkdirSync(latestDir, { recursive: true });
 	writeText(join(runDir, "questions.jsonl"), "");
 	writeText(join(runDir, "interventions.jsonl"), "");
-	writeJson$2(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({
@@ -512,13 +343,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$1({
-			sessionDir: leaderState.session.sessionPath === null ? leaderSessionDir : null,
-			sessionPath: leaderState.session.sessionPath,
+		const piResult = runCommandSync(piCommand, createPiInvocationArgs({
+			sessionDir: mayorState.session.sessionPath === null ? mayorSessionDir : null,
+			sessionPath: mayorState.session.sessionPath,
 			prompt,
 			appendedSystemPrompt: options.appendedSystemPrompt,
 			extensionPath: options.extensionPath
@@ -527,7 +358,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 = {
@@ -536,9 +367,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,
@@ -546,7 +377,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$2(join(runDir, "pi-invocation.json"), piInvocation);
+		writeJson$1(join(runDir, "pi-invocation.json"), piInvocation);
 		appendJsonl(join(runDir, "events.jsonl"), {
 			type: "pi_invocation_finished",
 			runId,
@@ -572,27 +403,27 @@ function runController(options) {
 			stopReason: piInvocation.exitCode === 0 ? "pi invocation completed" : `pi invocation exited with code ${piInvocation.exitCode}`,
 			piExitCode: piInvocation.exitCode
 		};
-		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"), {
+		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$2(join(latestDir, "manifest.json"), finalManifest);
-		writeJson$2(join(latestDir, "metrics.json"), metrics);
-		writeJson$2(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"), {
@@ -638,74 +469,39 @@ function resolveInterrupt(interrupt, options) {
 	};
 }
 
-//#endregion
-//#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;
+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$1(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$1(pollIntervalMs);
+		board = snapshotBoard(input.artifactsDir);
+	}
+	return {
+		timedOut: false,
+		board
+	};
+}
 function snapshotBoard(artifactsDir) {
 	const tasks = listTaskRecords(artifactsDir);
 	const agents = listAgentStates(artifactsDir);
@@ -720,8 +516,8 @@ function snapshotBoard(artifactsDir) {
 			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,
+		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")
 	};
 }
@@ -742,8 +538,13 @@ function evaluateStopCondition(input) {
 		stopReason: "all-tasks-completed",
 		continueReason: null
 	};
-	if (input.board.leaderBlocked) return {
-		stopReason: "leader-blocked",
+	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 {
@@ -757,7 +558,7 @@ function evaluateStopCondition(input) {
 	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");
+	if (reasons.length === 0) reasons.push("mayor idle, no stop condition met");
 	return {
 		stopReason: null,
 		continueReason: reasons.join("; ")
@@ -813,6 +614,7 @@ 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;
@@ -821,6 +623,7 @@ function runLoop(options) {
 	const loopStartedAt = Date.now();
 	const iterations = [];
 	let finalStopReason = "max-iterations-reached";
+	let needsMayorFollowUp = false;
 	appendJsonl(join(loopDir, "events.jsonl"), {
 		type: "loop_started",
 		loopId,
@@ -830,6 +633,26 @@ function runLoop(options) {
 		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 {
@@ -856,6 +679,7 @@ function runLoop(options) {
 			maxWallTimeMs,
 			piExitCode: controllerResult.piInvocation.exitCode,
 			stopOnPiFailure,
+			stopOnMayorIdleNoWork,
 			board,
 			metrics,
 			interruptRateThreshold
@@ -894,9 +718,11 @@ function runLoop(options) {
 			finalStopReason = stopReason;
 			break;
 		}
+		needsMayorFollowUp = hasBackgroundWork(board);
 	}
 	const totalElapsedMs = Date.now() - loopStartedAt;
-	const finalBoard = iterations.length > 0 ? iterations[iterations.length - 1].boardSnapshot : snapshotBoard(artifactsDir);
+	const lastIteration = iterations.at(-1);
+	const finalBoard = lastIteration ? lastIteration.boardSnapshot : snapshotBoard(artifactsDir);
 	const aggregate = aggregateMetrics(iterations);
 	const loopResult = {
 		loopId,
@@ -927,301 +753,172 @@ function runLoop(options) {
 }
 
 //#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;
+//#region src/stop.ts
+const DEFAULT_GRACE_MS = 750;
+function sleepMs(ms) {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function getLocksDir() {
+	return join(homedir(), ".pi-town", "locks");
 }
-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 processAlive(pid) {
+	if (!Number.isFinite(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
 	}
 }
-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.`);
+function terminateProcess(pid, options) {
+	if (!processAlive(pid)) return {
+		signal: null,
+		exited: true
+	};
+	try {
+		process.kill(pid, "SIGTERM");
+	} catch {
+		return {
+			signal: null,
+			exited: !processAlive(pid)
+		};
+	}
+	const graceMs = options.graceMs ?? DEFAULT_GRACE_MS;
+	const deadline = Date.now() + graceMs;
+	while (Date.now() < deadline) {
+		if (!processAlive(pid)) return {
+			signal: "SIGTERM",
+			exited: true
+		};
+		sleepMs(25);
+	}
+	if (!options.force) return {
+		signal: "SIGTERM",
+		exited: !processAlive(pid)
+	};
+	try {
+		process.kill(pid, "SIGKILL");
+	} catch {
+		return {
+			signal: "SIGTERM",
+			exited: !processAlive(pid)
+		};
+	}
 	return {
-		state,
-		session: createAgentSessionRecord({
-			sessionDir,
-			sessionId,
-			sessionPath,
-			lastAttachedAt: (/* @__PURE__ */ new Date()).toISOString()
-		})
+		signal: "SIGKILL",
+		exited: !processAlive(pid)
 	};
 }
-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);
+function readLease(path) {
+	try {
+		return {
+			...JSON.parse(readFileSync(path, "utf-8")),
+			path
+		};
+	} catch {
+		return null;
 	}
-	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
-		})
-	}));
+function createStopMessage(options) {
+	if (options.reason) return options.reason;
+	if (options.actorId) return `Stopped by ${options.actorId}`;
+	return "Stopped by operator";
+}
+function createStopMessageInput(options) {
 	return {
-		piResult,
-		latestSession,
-		completionMessage
+		...options.actorId === void 0 ? {} : { actorId: options.actorId },
+		...options.reason === void 0 ? {} : { reason: options.reason }
 	};
 }
-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
-		})
-	}));
+function createTerminateOptions(options) {
 	return {
-		piResult,
-		latestSession,
-		completionMessage
+		...options.force === void 0 ? {} : { force: options.force },
+		...options.graceMs === void 0 ? {} : { graceMs: options.graceMs }
 	};
 }
-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}`
+function listRepoLeases(repoId) {
+	let entries;
+	try {
+		entries = readdirSync(getLocksDir());
+	} catch {
+		return [];
+	}
+	return entries.filter((entry) => entry.endsWith(".json")).map((entry) => readLease(join(getLocksDir(), entry))).filter((record) => record !== null).filter((record) => repoId === void 0 || repoId === null || record.repoId === repoId);
+}
+function stopRepoLeases(options) {
+	const results = listRepoLeases(options.repoId).map((lease) => {
+		const termination = terminateProcess(lease.pid, options);
+		if (termination.exited) rmSync(lease.path, { force: true });
+		return {
+			path: lease.path,
+			runId: lease.runId,
+			repoId: lease.repoId,
+			branch: lease.branch,
+			processId: lease.pid,
+			signal: termination.signal,
+			exited: termination.exited
+		};
 	});
-	writeTaskRecord(options.artifactsDir, {
-		...task,
-		status: piResult.exitCode === 0 ? "completed" : "blocked",
-		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	return {
+		results,
+		signaledProcesses: results.filter((result) => result.signal !== null).length
+	};
+}
+function stopManagedAgents(options) {
+	const reason = createStopMessage(createStopMessageInput(options));
+	const excluded = new Set(options.excludeAgentIds ?? []);
+	const results = listAgentStates(options.artifactsDir).filter((agent) => {
+		if (excluded.has(agent.agentId)) return false;
+		if (options.agentId && agent.agentId !== options.agentId) return false;
+		return ![
+			"completed",
+			"failed",
+			"stopped"
+		].includes(agent.status);
+	}).map((state) => {
+		const processId = state.session.processId;
+		const termination = processId === null ? {
+			signal: null,
+			exited: true
+		} : terminateProcess(processId, createTerminateOptions(options));
+		if (state.taskId) updateTaskRecordStatus(options.artifactsDir, state.taskId, "aborted");
+		appendAgentMessage({
+			artifactsDir: options.artifactsDir,
+			agentId: state.agentId,
+			box: "outbox",
+			from: options.actorId ?? "system",
+			body: reason
+		});
+		writeAgentState(options.artifactsDir, createAgentState({
+			...state,
+			status: "stopped",
+			lastMessage: reason,
+			waitingOn: "stopped",
+			blocked: true,
+			session: createAgentSessionRecord({
+				sessionDir: state.session.sessionDir,
+				sessionId: state.session.sessionId,
+				sessionPath: state.session.sessionPath,
+				processId: null,
+				lastAttachedAt: state.session.lastAttachedAt
+			})
+		}));
+		return {
+			agentId: state.agentId,
+			previousStatus: state.status,
+			nextStatus: "stopped",
+			processId,
+			signal: termination.signal,
+			exited: termination.exited
+		};
 	});
 	return {
-		task: {
-			...task,
-			status: piResult.exitCode === 0 ? "completed" : "blocked",
-			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-		},
-		agentId,
-		piResult,
-		latestSession
+		results,
+		stoppedAgents: results.length,
+		signaledProcesses: results.filter((result) => result.signal !== null).length
 	};
 }
 
 //#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 };
+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, listRepoLeases, listTaskRecords, notifyTaskDelegator, queueAgentMessage, readAgentMessages, readAgentState, readJsonl, readTaskRecord, resolveAgentSession, resolveInterrupt, resumeAgentTurnDetached, runAgentTurn, runCommandInteractive, runCommandSync, runController, runLoop, snapshotBoard, spawnAgentRun, stopManagedAgents, stopRepoLeases, updateAgentStatus, updateTaskRecordStatus, writeAgentState, writeTaskRecord };
 //# sourceMappingURL=index.mjs.map