@arhen/pi-core-subagent 1.3.33 → 1.3.34

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@arhen/pi-core-subagent",
-	"version": "1.3.33",
+	"version": "1.3.34",
 	"type": "module",
 	"description": "pi extension: fast in-process subagents with a dependency-graph scheduler (needs edges gate tasks and carry upstream output into dependent prompts), plus background runs, intercom and agent-to-agent mailbox. Leader defines agents inline.",
 	"license": "MIT",

package/src/agentfile.ts

@@ -13,6 +13,8 @@ export interface AgentFileInfo {
 	model?: string;
 	tools?: string[];
 	description?: string;
+	/** The matched file path — surfaced so the leader can audit which file won. */
+	path?: string;
 }
 
 const AGENT_DIRS = [".agents/agents", ".claude/agents", ".pi/agents"] as const;
@@ -41,10 +43,23 @@ const STOP = new Set([
 	"as",
 	"how",
 	"what",
-	"when",
 	"who",
 ]);
 
+/** A body becomes the child's ENTIRE system prompt — an oversized reference file
+ *  would blow the context window and kill the session with a cryptic error. */
+const MAX_BODY_CHARS = 64_000;
+
+/** Per-cwd memo of the ancestor walk (project dirs then home), since the files
+ *  can't meaningfully change within one run and the walk costs 3 sync stats per
+ *  ancestor dir per task otherwise. Keyed per (agentDir + cwd). */
+const walkCache = new Map<string, AgentFileInfo[]>();
+
+/** Test/diagnostic hook: flush the walk cache (files changed mid-session). */
+export function clearAgentFileCache(): void {
+	walkCache.clear();
+}
+
 /** Lowercase, split, drop stopwords, strip plural -s/-es. */
 function tokens(text: string): string[] {
 	return (text.toLowerCase().match(/[a-z0-9]+/g) ?? [])
@@ -68,65 +83,67 @@ function readAgentFile(dir: string): AgentFileInfo[] {
 	const out: AgentFileInfo[] = [];
 	for (const entry of readdirSync(dir)) {
 		if (!entry.endsWith(".md")) continue;
-		const { frontmatter, body } = parseFrontmatter(readFileSync(join(dir, entry), "utf8"));
+		const path = join(dir, entry);
+		const { frontmatter, body } = parseFrontmatter(readFileSync(path, "utf8"));
+		let trimmed = body;
+		if (trimmed.length > MAX_BODY_CHARS) {
+			trimmed = `${trimmed.slice(0, MAX_BODY_CHARS)}\n\n[truncated: agent file exceeded ${MAX_BODY_CHARS} chars — slim it down]`;
+		}
+		const toolsF = frontmatter.tools;
 		const tools =
-			typeof frontmatter.tools === "string"
-				? frontmatter.tools
+			typeof toolsF === "string"
+				? toolsF
 						.split(",")
 						.map((t) => t.trim())
 						.filter(Boolean)
-				: Array.isArray(frontmatter.tools)
-					? frontmatter.tools.map(String)
+				: Array.isArray(toolsF)
+					? toolsF.map(String)
 					: undefined;
 		out.push({
-			body,
+			body: trimmed,
 			model: typeof frontmatter.model === "string" ? frontmatter.model : undefined,
 			tools: tools?.length ? tools : undefined,
 			description: typeof frontmatter.description === "string" ? frontmatter.description : undefined,
+			path,
 		});
 	}
 	return out;
 }
 
-/**
- * Best agent-file match for a spawn goal. Order: `.agents/agents` (single
- * source) → `.claude/agents` → `.pi/agents` per cwd ancestor (nearest first),
- * then home (`~/.agents` → `~/.claude` → `~/.pi`). Within a dir, highest
- * description-overlap score wins; the first dir with a match is returned.
- * `agentDir` is the pi agent dir (`~/.pi/agent`); home is derived from it.
- */
-export function resolveAgentFile(name: string, task: string, cwd: string, agentDir: string): AgentFileInfo | undefined {
-	const query = tokens(`${name} ${task}`);
+/** Walk cwd's ancestors, then home, returning files in priority order (nearest
+ *  first, each dir's 3 subdirs in AGENT_DIRS order). */
+function allAgentFiles(cwd: string, agentDir: string): AgentFileInfo[] {
+	const out: AgentFileInfo[] = [];
 	let dir = cwd;
 	while (true) {
-		for (const sub of AGENT_DIRS) {
-			let best: AgentFileInfo | undefined;
-			let bestScore = 0;
-			for (const file of readAgentFile(join(dir, sub))) {
-				const s = score(query, tokens(file.description ?? ""));
-				if (s > bestScore) {
-					best = file;
-					bestScore = s;
-				}
-			}
-			if (best) return best; // first dir with any match wins (priority over score)
-		}
+		for (const sub of AGENT_DIRS) out.push(...readAgentFile(join(dir, sub)));
 		const parent = dirname(dir);
 		if (parent === dir) break;
 		dir = parent;
 	}
 	const home = dirname(dirname(agentDir)); // ~/.pi/agent → ~
-	for (const sub of AGENT_DIRS) {
-		let best: AgentFileInfo | undefined;
-		let bestScore = 0;
-		for (const file of readAgentFile(join(home, sub))) {
-			const s = score(query, tokens(file.description ?? ""));
-			if (s > bestScore) {
-				best = file;
-				bestScore = s;
-			}
+	for (const sub of AGENT_DIRS) out.push(...readAgentFile(join(home, sub)));
+	return out;
+}
+
+/** Best agent-file match for a spawn goal. Caches per (agentDir, cwd). */
+export function resolveAgentFile(name: string, task: string, cwd: string, agentDir: string): AgentFileInfo | undefined {
+	const query = tokens(`${name} ${task}`);
+	const cacheKey = `${agentDir}${cwd}`;
+	let files = walkCache.get(cacheKey);
+	if (!files) {
+		files = allAgentFiles(cwd, agentDir);
+		if (walkCache.size >= 512) walkCache.clear();
+		walkCache.set(cacheKey, files);
+	}
+	let best: AgentFileInfo | undefined;
+	let bestScore = 0;
+	for (const file of files) {
+		const s = score(query, tokens(file.description ?? ""));
+		if (s > 0 && s > bestScore) {
+			best = file;
+			bestScore = s;
 		}
-		if (best) return best;
 	}
-	return undefined;
+	return best;
 }

package/src/format.ts

@@ -226,8 +226,9 @@ export function makeSummary(run: RunSnapshot): string {
 	for (const task of run.tasks) {
 		// Edges are named so the leader can compare what it delegated against what came back.
 		const edge = task.needs?.length ? ` (${task.id}, needs ${task.needs.join(", ")})` : ` (${task.id})`;
+		const fileNote = task.agentFile ? ` [${task.agentFile}]` : "";
 		lines.push(
-			`\n## ${task.agent}${edge} ${statusIcon(task.status)}${task.error ? `\nError: ${task.error}` : `\n${truncateText(task.finalText || "(no output)")}`}${worktreeLine(task)}`,
+			`\n## ${task.agent}${edge}${fileNote} ${statusIcon(task.status)}${task.error ? `\nError: ${task.error}` : `\n${truncateText(task.finalText || "(no output)")}`}${worktreeLine(task)}`,
 		);
 	}
 	// Ceiling on the WHOLE summary — 16 tasks × 24KB would otherwise flood the parent context.

package/src/manager.ts

@@ -1,6 +1,6 @@
 /** SubagentManager: run lifecycle, child sessions, intercom, persistence, widget plumbing. */
 import { existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
+import { rename, writeFile } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { Api, AssistantMessage, Model } from "@earendil-works/pi-ai";
@@ -304,6 +304,18 @@ export class SubagentManager {
 			child.dispose();
 		}
 		this.liveChildren.clear();
+		// Mark every non-terminal task aborted BEFORE resolving pendingReplies: the
+		// resumed onAskParent closure re-checks status, and a still-awaiting task
+		// would flip back to "running" and re-insert the run after the maps clear —
+		// a ghost run that widgets re-arm on and persist forever.
+		for (const run of this.runs.values()) {
+			for (const task of run.tasks) {
+				if (!TERMINAL.includes(task.status)) {
+					task.status = "aborted";
+					task.error = task.error ?? "(session ended)";
+				}
+			}
+		}
 		// Release anyone parked on a run before the maps go — dropping waiters would
 		// leave their promises pending forever (autoAwait / await_subagent hang).
 		for (const [runId, waiters] of this.settleWaiters) {
@@ -383,7 +395,13 @@ export class SubagentManager {
 			const parentFile = getParentSessionFile(ctx);
 			if (!parentFile) return;
 			const sidecar = parentFile.replace(/\.jsonl$/, ".subagents.json");
-			void writeFile(sidecar, JSON.stringify(this.listRuns().slice(0, 50).map(cloneRun), null, 2)).catch(() => {}); // never surface as an unhandled rejection
+			// Write-then-rename: a plain writeFile can tear on crash and silently drop
+			// ALL run history for the session on the next read.
+			const tmp = `${sidecar}.tmp`;
+			const payload = JSON.stringify(this.listRuns().slice(0, 50).map(cloneRun), null, 2);
+			void writeFile(tmp, payload)
+				.then(() => rename(tmp, sidecar))
+				.catch(() => {}); // never surface as an unhandled rejection
 		} catch {
 			/* ignore */
 		}
@@ -715,6 +733,7 @@ export class SubagentManager {
 		// is authoritative — body = system prompt, frontmatter model/tools win over
 		// inline. No match → inline on-demand definition as usual.
 		const file = resolveAgentFile(input.agent, input.task, task.cwd, getAgentDir());
+		if (file?.path) task.agentFile = file.path; // recorded for audit — which file won
 		const prompt = file?.body ?? input.prompt?.trim();
 		const thinking = input.thinking;
 		// Trust boundary: a file can NARROW the toolset (intersect with the leader's
@@ -1387,8 +1406,15 @@ export class SubagentManager {
 				delivered = true;
 			} else if (msg.kind === "ask") {
 				// An unanswered ask blocks a child for 10 minutes — it must never be the
-				// message that gets dropped by the cap.
-				p.msgs[p.msgs.length - 1] = msg;
+				// message that gets dropped by the cap. Evict the oldest NON-ask first
+				// (asks already block children; displacing one hangs the earlier asker).
+				const drop = p.msgs.findIndex((m) => m.kind !== "ask");
+				if (drop !== -1) {
+					p.msgs.splice(drop, 1);
+					p.msgs.push(msg);
+				} else {
+					p.msgs[p.msgs.length - 1] = msg; // all asks — overwrite the oldest ask
+				}
 				delivered = true;
 			}
 			p.wake(); // resolve the parked await early — the leader breathes on every message

package/src/types.ts

@@ -41,6 +41,10 @@ export interface TaskSnapshot {
 	usage: UsageStats;
 	/** Sibling addresses for intercom tools (send_agent_message targets). */
 	roster?: string;
+	/** Path of the agent file that drove this child (inline definition otherwise).
+	 *  Surfaced so the leader can audit which file took over — a description-only
+	 *  match must never be invisible. */
+	agentFile?: string;
 	/** Git worktree isolation (write agents): branch + diff of the child's changes. */
 	branch?: string;
 	diffStat?: string;

package/src/worktree.ts

@@ -278,7 +278,21 @@ export function reapDeadWorktrees(root: string, isLive: (path: string) => boolea
 		try {
 			commitIn(path, "subagent (recovered after interrupted session)");
 		} catch {
-			continue; // git failed — never drop a dir whose work isn't on the branch
+			// A dir git refuses to read (half-created by a timed-out worktree add,
+			// or corrupted) holds no recoverable work — drop it instead of retrying
+			// forever. The "never drop uncommitted work" rule protects readable dirs.
+			try {
+				execFileSync("git", ["-C", path, "rev-parse", "--git-dir"], {
+					encoding: "utf8",
+					timeout: GIT_TIMEOUT_MS,
+					maxBuffer: GIT_MAX_BUFFER,
+				});
+				continue; // git still reads it — legitimate work, keep
+			} catch {
+				dropDir(root, path);
+				reaped += 1;
+			}
+			continue;
 		}
 		dropDir(root, path);
 		reaped += 1;
@@ -326,9 +340,12 @@ export function ownerAlive(path: string): boolean {
 	}
 }
 
-/** Stable per-boot id, so a recycled pid from before a reboot can't look alive. */
+/** Stable per-boot id, so a recycled pid from before a reboot can't look alive.
+ *  Compute ONE floor on the expressed seconds, not two — separate floors of
+ *  walltime and uptime flip by ±1 around integer boundaries and would read a
+ *  live marker as dead on a cross-second read. */
 function bootId(): string {
-	return String(Math.floor(Date.now() / 1000 - Math.floor(uptime())));
+	return String(Math.floor((Date.now() - uptime() * 1000) / 1000));
 }
 
 /**
@@ -344,6 +361,16 @@ export function sweepStale(root: string): void {
 	// Unknown registration = every dir might be live. Deleting here would be the
 	// single most destructive thing this module can do; bail instead.
 	if (!registered) return;
+	// Empty run dirs are litter — a run dir holds nothing but its task dirs.
+	for (const runDir of readdirSync(sub, { withFileTypes: true })) {
+		if (!runDir.isDirectory()) continue;
+		const runPath = join(sub, runDir.name);
+		try {
+			if (readdirSync(runPath).length === 0) rmSync(runPath, { recursive: true, force: true });
+		} catch {
+			/* skip */
+		}
+	}
 	for (const runDir of readDirs(sub)) {
 		for (const taskDir of readDirs(join(sub, runDir))) {
 			const dir = join(sub, runDir, taskDir);