@schilderlabs/pitown-core 0.2.1 → 0.2.6

package/dist/index.mjs

@@ -1,145 +1,17 @@
+import { C as appendJsonl, S as writeAgentState, _ as getLatestAgentSession, a as readTaskRecord, b as readAgentMessages, c as appendAgentMessage, d as getAgentDir, f as getAgentMailboxPath, g as getAgentsDir, h as getAgentStatePath, i as listTaskRecords, l as createAgentSessionRecord, m as getAgentSessionsDir, n as getTaskPath, o as updateTaskRecordStatus, p as getAgentSessionPath, r as getTasksDir, s as writeTaskRecord, t as createTaskRecord, u as createAgentState, v as getSessionIdFromPath, w as readJsonl, x as readAgentState, y as listAgentStates } from "./tasks-BfQm-7-O.mjs";
+import { createRequire } from "node:module";
 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";
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
 
-//#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 +34,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") {
@@ -346,7 +218,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 +227,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 +241,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 +327,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 +349,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 +384,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,
+			sessionDir: mayorState.session.sessionPath === null ? mayorSessionDir : null,
+			sessionPath: mayorState.session.sessionPath,
 			prompt,
 			appendedSystemPrompt: options.appendedSystemPrompt,
 			extensionPath: options.extensionPath
@@ -527,7 +399,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 +408,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 +418,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 +444,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 +510,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 +557,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 +579,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 +599,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 +655,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 +664,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 +674,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 +720,7 @@ function runLoop(options) {
 			maxWallTimeMs,
 			piExitCode: controllerResult.piInvocation.exitCode,
 			stopOnPiFailure,
+			stopOnMayorIdleNoWork,
 			board,
 			metrics,
 			interruptRateThreshold
@@ -894,9 +759,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,
@@ -938,11 +805,29 @@ function createPiInvocationArgs(input) {
 	if (input.prompt) args.push("-p", input.prompt);
 	return args;
 }
+function createDetachedRunnerInvocation(encodedPayload) {
+	if (fileURLToPath(import.meta.url).endsWith(".ts")) {
+		const require = createRequire(import.meta.url);
+		return {
+			command: process.execPath,
+			args: [
+				"--import",
+				require.resolve("tsx"),
+				fileURLToPath(new URL("./agent-runner.ts", import.meta.url)),
+				encodedPayload
+			]
+		};
+	}
+	return {
+		command: process.execPath,
+		args: [fileURLToPath(new URL("./agent-runner.mjs", import.meta.url)), encodedPayload]
+	};
+}
 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.",
+		case "mayor": return [
+			"You are the Pi Town mayor.",
 			"You coordinate work for this repository and act as the primary human-facing agent.",
 			"",
 			`Repository: ${input.repoRoot}`,
@@ -989,6 +874,7 @@ function resolveAgentSession(agentId, artifactsDir) {
 			sessionDir,
 			sessionId,
 			sessionPath,
+			processId: state.session.processId,
 			lastAttachedAt: (/* @__PURE__ */ new Date()).toISOString()
 		})
 	};
@@ -1013,6 +899,7 @@ function queueAgentMessage(input) {
 			sessionDir: state.session.sessionDir ?? getAgentSessionsDir(input.artifactsDir, input.agentId),
 			sessionId: state.session.sessionId,
 			sessionPath: state.session.sessionPath,
+			processId: state.session.processId,
 			lastAttachedAt: state.session.lastAttachedAt
 		})
 	}));
@@ -1021,7 +908,7 @@ 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;
+		const taskStatus = input.status === "completed" ? "completed" : input.status === "blocked" || input.status === "failed" ? "blocked" : input.status === "stopped" ? "aborted" : input.status === "running" || input.status === "queued" ? "running" : null;
 		if (taskStatus) updateTaskRecordStatus(input.artifactsDir, state.taskId, taskStatus);
 	}
 	writeAgentState(input.artifactsDir, createAgentState({
@@ -1069,46 +956,41 @@ function spawnAgentRun(options) {
 		appendedSystemPrompt: options.appendedSystemPrompt,
 		extensionPath: options.extensionPath
 	});
-	const piResult = runCommandSync("pi", piArgs, {
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const runner = createDetachedRunnerInvocation(Buffer.from(JSON.stringify({
+		repoRoot: options.repoRoot,
+		artifactsDir: options.artifactsDir,
+		agentId: options.agentId,
+		role: options.role,
+		task: options.task,
+		taskId: options.taskId ?? null,
+		sessionDir,
+		piArgs
+	}), "utf-8").toString("base64url"));
+	const child = spawn(runner.command, runner.args, {
 		cwd: options.repoRoot,
-		env: process.env
+		detached: true,
+		env: process.env,
+		stdio: "ignore"
 	});
-	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({
+	child.unref();
+	if (!child.pid) throw new Error(`Failed to launch detached ${options.role} run for ${options.agentId}`);
+	writeFileSync(`${getAgentDir(options.artifactsDir, options.agentId)}/latest-invocation.json`, `${JSON.stringify({
 		command: "pi",
 		args: piArgs,
-		exitCode: piResult.exitCode,
+		exitCode: null,
 		sessionDir,
-		sessionPath: latestSession.sessionPath,
-		sessionId: latestSession.sessionId
+		sessionPath: null,
+		sessionId: null,
+		processId: child.pid,
+		startedAt
 	}, 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
+		launch: {
+			processId: child.pid,
+			startedAt
+		},
+		latestSession: createAgentSessionRecord({ sessionDir })
 	};
 }
 function runAgentTurn(options) {
@@ -1160,7 +1042,8 @@ function runAgentTurn(options) {
 		session: createAgentSessionRecord({
 			sessionDir: latestSession.sessionDir,
 			sessionId: latestSession.sessionId,
-			sessionPath: latestSession.sessionPath
+			sessionPath: latestSession.sessionPath,
+			processId: null
 		})
 	}));
 	return {
@@ -1188,7 +1071,7 @@ function delegateTask(options) {
 		from: options.fromAgentId,
 		body: `Delegated ${task.taskId} to ${agentId}: ${options.task}`
 	});
-	const { piResult, latestSession } = spawnAgentRun({
+	const { launch, latestSession } = spawnAgentRun({
 		repoRoot: options.repoRoot,
 		artifactsDir: options.artifactsDir,
 		role: options.role,
@@ -1207,21 +1090,188 @@ function delegateTask(options) {
 	});
 	writeTaskRecord(options.artifactsDir, {
 		...task,
-		status: piResult.exitCode === 0 ? "completed" : "blocked",
+		status: "running",
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	});
 	return {
 		task: {
 			...task,
-			status: piResult.exitCode === 0 ? "completed" : "blocked",
+			status: "running",
 			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 		},
 		agentId,
-		piResult,
+		launch,
 		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 };
+//#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 processAlive(pid) {
+	if (!Number.isFinite(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+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 {
+		signal: "SIGKILL",
+		exited: !processAlive(pid)
+	};
+}
+function readLease(path) {
+	try {
+		return {
+			...JSON.parse(readFileSync(path, "utf-8")),
+			path
+		};
+	} catch {
+		return null;
+	}
+}
+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 {
+		...options.actorId === void 0 ? {} : { actorId: options.actorId },
+		...options.reason === void 0 ? {} : { reason: options.reason }
+	};
+}
+function createTerminateOptions(options) {
+	return {
+		...options.force === void 0 ? {} : { force: options.force },
+		...options.graceMs === void 0 ? {} : { graceMs: options.graceMs }
+	};
+}
+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
+		};
+	});
+	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 {
+		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, listRepoLeases, listTaskRecords, queueAgentMessage, readAgentMessages, readAgentState, readJsonl, readTaskRecord, resolveAgentSession, resolveInterrupt, runAgentTurn, runCommandInteractive, runCommandSync, runController, runLoop, snapshotBoard, spawnAgentRun, stopManagedAgents, stopRepoLeases, updateAgentStatus, updateTaskRecordStatus, writeAgentState, writeTaskRecord };
 //# sourceMappingURL=index.mjs.map