@arhen/pi-core-subagent 1.3.29 → 1.3.30

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@arhen/pi-core-subagent",
-	"version": "1.3.29",
+	"version": "1.3.30",
 	"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/index.ts

@@ -18,7 +18,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { Text, truncateToWidth } from "@earendil-works/pi-tui";
 import { compactLines, formatUsage, makeSummary, statusIcon, taskLine, truncateText } from "./format.ts";
 import { waveNotation } from "./graph.ts";
-import { cloneRun, SubagentManager } from "./manager.ts";
+import { cloneRun, type ParkedMsg, SubagentManager } from "./manager.ts";
 import { createPeekPane, type PeekTask } from "./peek.ts";
 import {
 	AwaitParam,
@@ -30,7 +30,7 @@ import {
 	type SubagentParamsShape,
 } from "./schemas.ts";
 import { type RunDetails, type RunSnapshot, TERMINAL } from "./types.ts";
-import { repoRoot, sweepStale } from "./worktree.ts";
+import { cleanupMerged, repoRoot, sweepStale } from "./worktree.ts";
 
 export default function (pi: ExtensionAPI) {
 	const manager = new SubagentManager(pi);
@@ -111,15 +111,23 @@ export default function (pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		await manager.restoreFromSidecar(ctx);
 		// Crash leftovers: remove stale worktree dirs (branches survive for merging).
-		sweepStale(ctx.cwd);
+		// Also reap branches the leader merged in a previous session (H1: cleanup can't
+		// fire at run end — the leader merges after).
+		const roots = new Set<string>();
+		const cwdRoot = repoRoot(ctx.cwd);
+		if (cwdRoot) roots.add(cwdRoot);
 		for (const run of manager.listRuns()) {
 			for (const task of run.tasks) {
 				if (task.branch) {
 					const root = repoRoot(task.cwd);
-					if (root) sweepStale(root);
+					if (root) roots.add(root);
 				}
 			}
 		}
+		for (const root of roots) {
+			sweepStale(root);
+			cleanupMerged(root);
+		}
 	});
 	pi.on("session_shutdown", async (_event, ctx) => {
 		if (ctx?.hasUI) {
@@ -158,13 +166,23 @@ export default function (pi: ExtensionAPI) {
 			const typed = params as SubagentParamsShape;
 			const details = manager.startInBackground(typed, ctx);
 			if (typed.autoAwait) {
-				// awaitRun wakes on every child→leader message (ask/notify/done) — that's the
-				// slice-loop feature. autoAwait wants the final result: re-park until terminal.
+				// awaitRun wakes on every child→leader message (ask/notify/done). Re-park
+				// until terminal — but surface an ask_parent: the child is waiting on the
+				// leader, so break out, reply via reply_subagent, then await again.
 				let run = details.run;
+				let intercom: ParkedMsg[] = [];
 				while (!TERMINAL.includes(run.status)) {
-					run = (await manager.awaitRun(details.run.id))?.run ?? run;
+					const awaited = await manager.awaitRun(details.run.id);
+					if (!awaited) break; // run gone (session shutdown) — stop, no busy-spin
+					if (awaited.run) run = awaited.run;
+					intercom = awaited.intercom;
+					if (intercom.some((m) => m.kind === "ask")) break;
 				}
-				return { content: [{ type: "text", text: makeSummary(run) }], details: { run } };
+				const asked = intercom.find((m) => m.kind === "ask");
+				const text = asked
+					? `${makeSummary(run)}\n\nA child is waiting for your answer (${asked.agent}, ${asked.taskId}): ${asked.text}\nReply with reply_subagent(runId: "${run.id}", taskId: "${asked.taskId}", message: ...), then await_subagent again for the result.`
+					: makeSummary(run);
+				return { content: [{ type: "text", text }], details: { run } };
 			}
 			return {
 				content: [

package/src/manager.ts

@@ -1,7 +1,7 @@
 /** SubagentManager: run lifecycle, child sessions, intercom, persistence, widget plumbing. */
 import { existsSync, readFileSync } from "node:fs";
 import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { Api, AssistantMessage, Model } from "@earendil-works/pi-ai";
 import {
@@ -62,6 +62,8 @@ const DEFAULT_RUNTIME_MS = 0;
 const DEFAULT_STALL_MS = 180_000; // 3 min: long model thinking streams emit no events, but they're not stalled.
 const READONLY_TOOLS = ["read", "grep", "find", "ls"];
 const WRITE_TOOLS = ["read", "grep", "find", "ls", "bash", "edit", "write"];
+/** Task ids become git refs + filesystem paths. */
+const SAFE_TASK_ID = /^[A-Za-z0-9_-]{1,64}$/;
 const WIDGET_THROTTLE_MS = 150;
 
 // ── helpers ──────────────────────────────────────────────────────────────
@@ -649,21 +651,33 @@ export class SubagentManager {
 		const file = resolveAgentFile(input.agent, input.task, task.cwd, getAgentDir());
 		const prompt = file?.body ?? input.prompt?.trim();
 		const thinking = input.thinking;
-		const baseTools = file?.tools ?? input.tools ?? (input.write ? WRITE_TOOLS : READONLY_TOOLS);
+		// Trust boundary: a file can NARROW the toolset (intersect with the leader's
+		// intent) but never widen it — a repo-planted agent file can't grant write.
+		const allowedTools = input.write ? WRITE_TOOLS : READONLY_TOOLS;
+		const fileTools = file?.tools?.filter((t) => allowedTools.includes(t));
+		const baseTools = fileTools?.length ? fileTools : (input.tools ?? allowedTools);
 		const tools = [...baseTools, ...(run.allowIntercom ? CHILD_TALK_TOOLS : [])];
+		// Worktree whenever the child can write — whether the leader said write:true
+		// or a file granted write-capable tools.
+		const canWrite = input.write || (file?.tools?.some((t) => WRITE_TOOLS.includes(t)) ?? false);
 
 		// Write agents run in an isolated git worktree (branch subagents/<run>/<task>);
 		// non-git repos fall back to in-place. The worktree is created BEFORE session
 		// start so the child's cwd + AGENTS.md context chain are the worktree's.
 		let wt: Worktree | undefined;
-		if (input.write) {
+		if (canWrite) {
 			try {
 				wt = createWorktree(task.cwd, run.id, task.id);
 			} catch {
 				wt = undefined; // git failure → in-place
 			}
 		}
-		const childCwd = wt?.path ?? task.cwd;
+		// Map a per-task cwd subpath into the worktree so relative paths stay correct.
+		let childCwd = wt?.path ?? task.cwd;
+		if (wt) {
+			const rel = relative(wt.root, task.cwd);
+			if (rel && !rel.startsWith("..") && rel !== ".") childCwd = join(wt.path, rel);
+		}
 
 		// Model + thinking resolve against the pi model registry; a bad request
 		// fails the TASK with a helpful message, not the whole run.
@@ -818,15 +832,30 @@ export class SubagentManager {
 					// Commit the child's changes, then report the branch + diff so the
 					// leader can review and merge (PR-style). The worktree dir stays
 					// until the branch is merged — cleanupMerged removes both then.
-					commitWorktree(wt, `subagent ${task.agent}: ${truncateText(input.task, 60)}`);
-					const { stat, files } = branchDiff(wt);
-					this.updateTask(
-						run,
-						task,
-						{ branch: wt.branch, diffStat: stat || undefined, changedFiles: files.length ? files : undefined },
-						ctx,
-						onUpdate,
-					);
+					// Commit/diff failures must NOT downgrade a completed task or destroy
+					// its work: the error is reported, the status stays completed.
+					try {
+						commitWorktree(wt, `subagent ${task.agent}: ${truncateText(input.task, 60)}`);
+						const { stat, files } = branchDiff(wt);
+						this.updateTask(
+							run,
+							task,
+							{ branch: wt.branch, diffStat: stat || undefined, changedFiles: files.length ? files : undefined },
+							ctx,
+							onUpdate,
+						);
+					} catch (commitErr) {
+						this.updateTask(
+							run,
+							task,
+							{
+								branch: wt.branch,
+								error: `Worktree commit failed (changes remain in ${wt.path}): ${commitErr instanceof Error ? commitErr.message : String(commitErr)}`,
+							},
+							ctx,
+							onUpdate,
+						);
+					}
 				}
 			}
 		} catch (err) {
@@ -861,9 +890,14 @@ export class SubagentManager {
 			watchdog.dispose();
 			if (timeout) clearTimeout(timeout);
 			child?.dispose();
-			// Failed/aborted: the branch keeps any partial work for manual merging, the
-			// checkout dir is removed so it can't linger on disk.
+			// Failed/aborted: commit whatever partial work exists FIRST (so the branch
+			// really keeps it), then drop the checkout dir.
 			if (wt && task.status !== "completed") {
+				try {
+					commitWorktree(wt, `subagent ${task.agent} (partial, ${task.status})`);
+				} catch {
+					/* nothing to commit */
+				}
 				this.updateTask(run, task, { branch: wt.branch }, ctx, onUpdate);
 				removeWorktree(wt);
 			}
@@ -898,13 +932,25 @@ export class SubagentManager {
 				? params.tasks!
 				: params.chain!;
 		if (inputs.length > MAX_TASKS) throw new Error(`Too many subagent tasks (${inputs.length}). Max is ${MAX_TASKS}.`);
+		// Task ids become git refs + filesystem paths — refuse anything unsafe.
+		// Explicit ids are checked against each other; generated ones are checked
+		// against explicit ones so a collision can't silently fall back to in-place.
 		const ids = new Set<string>();
 		for (const input of inputs) {
 			if (input.id !== undefined) {
+				if (!SAFE_TASK_ID.test(input.id)) {
+					throw new Error(`Unsafe task id: "${input.id}" (allowed: letters, digits, _ and - only).`);
+				}
 				if (ids.has(input.id)) throw new Error(`Duplicate task id: ${input.id}`);
 				ids.add(input.id);
 			}
 		}
+		for (let i = 0; i < inputs.length; i++) {
+			const generated = `task_${i + 1}`;
+			if (inputs[i]?.id === undefined && ids.has(generated)) {
+				throw new Error(`Generated task id ${generated} collides with an explicit id — rename the explicit id.`);
+			}
+		}
 		const edges = resolveNeeds(inputs, mode);
 
 		const run: RunSnapshot = {
@@ -968,14 +1014,19 @@ export class SubagentManager {
 		for (const task of run.tasks) {
 			if (TERMINAL.includes(task.status)) settled.add(task.id); // canceled before start
 		}
+		// id → input, immune to filtered-array index drift (C4).
+		const inputById = new Map(run.tasks.map((t, i) => [t.id, inputs[i]]));
 
 		const { skipped } = await runWaveScheduler(
 			run.tasks.filter((t) => !TERMINAL.includes(t.status)),
 			run.mode === "single" ? 1 : run.concurrency,
 			outputs,
 			settled,
-			async (task, index) => {
-				const input = inputs[index]!;
+			async (task) => {
+				// The scheduler passes the index into the FILTERED list — never use it
+				// against the unfiltered inputs. Look the input up by task id instead.
+				const input = inputById.get(task.id);
+				if (!input) return;
 				await this.runChild(
 					run,
 					task,

package/src/worktree.ts

@@ -7,14 +7,14 @@
  *  start (dir removed, branch kept — the work survives). */
 
 import { execFileSync } from "node:child_process";
-import { existsSync, readdirSync, rmSync, symlinkSync } from "node:fs";
+import { existsSync, readdirSync, realpathSync, rmSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 
 export interface Worktree {
 	root: string; // repo root (main tree)
 	path: string; // worktree checkout dir
 	branch: string; // subagents/<runId>/<taskId>
-	base: string; // branch HEAD was created from
+	base: string; // SHA the branch was created from
 }
 
 function git(root: string, args: string[]): string {
@@ -53,9 +53,9 @@ export function createWorktree(cwd: string, runId: string, taskId: string): Work
 	const branch = `subagents/${runId}/${taskId}`;
 	let base: string;
 	try {
-		base = git(root, ["rev-parse", "--abbrev-ref", "HEAD"]);
+		base = git(root, ["rev-parse", "HEAD"]); // SHA — detached HEAD stays correct
 	} catch {
-		return undefined; // detached or broken repo — fall back to in-place
+		return undefined; // broken repo — fall back to in-place
 	}
 	git(root, ["worktree", "add", "-b", branch, path, "HEAD"]);
 	// Deps follow the child into the worktree; anything else the task needs is
@@ -74,11 +74,11 @@ export function createWorktree(cwd: string, runId: string, taskId: string): Work
 /** Commit all child changes. No-op when the worktree is already clean. */
 export function commitWorktree(wt: Worktree, message: string): void {
 	if (gitIn(wt.path, ["status", "--porcelain"]).length === 0) return;
-	gitIn(wt.path, ["add", "-A"]);
+	gitIn(wt.path, ["add", "-A", "--", ".", ":(exclude)node_modules"]); // never stage the dep symlink
 	gitIn(wt.path, ["commit", "-m", message, "--no-verify"]);
 }
 
-/** Diffstat + changed files of the branch vs its base. */
+/** Diffstat + changed files of the branch vs its base SHA. */
 export function branchDiff(wt: Worktree): { stat: string; files: string[] } {
 	const files = git(wt.root, ["diff", "--name-only", `${wt.base}...${wt.branch}`])
 		.split("\n")
@@ -94,6 +94,7 @@ export function removeWorktree(wt: Worktree): void {
 	} catch {
 		/* already gone */
 	}
+	prune(wt.root);
 }
 
 /** Remove a worktree dir by branch name (cancel paths that didn't keep a Worktree). */
@@ -106,16 +107,32 @@ export function removeByBranch(cwd: string, branch: string): void {
 	} catch {
 		/* already gone */
 	}
+	prune(root);
 }
 
-/** Delete branch + worktree for branches already merged into `target`. */
+/** Drop git's stale worktree admin entries (they pile up under .git/worktrees). */
+function prune(root: string): void {
+	try {
+		git(root, ["worktree", "prune"]);
+	} catch {
+		/* ignore */
+	}
+}
+
+/**
+ * Delete branch + worktree for branches already merged into `target`.
+ * SAFETY: branches checked out in a LIVE worktree (concurrent run) are skipped —
+ * their tip equals the base until the child commits, so they look "merged".
+ */
 export function cleanupMerged(root: string, target = "HEAD"): number {
+	root = realpathSync(root);
 	const merged = git(root, ["branch", "--merged", target])
 		.split("\n")
 		.map((b) => b.trim().replace(/^[+*]\s*/, ""));
+	const live = new Set(worktreeBranches(root));
 	let cleaned = 0;
 	for (const branch of merged) {
-		if (!branch.startsWith("subagents/")) continue;
+		if (!branch.startsWith("subagents/") || live.has(branch)) continue;
 		const path = join(root, ".git", "subagents", branch.slice("subagents/".length));
 		if (existsSync(path)) {
 			try {
@@ -126,30 +143,56 @@ export function cleanupMerged(root: string, target = "HEAD"): number {
 		}
 		if (gitOk(root, ["branch", "-d", branch])) cleaned += 1;
 	}
+	prune(root);
 	return cleaned;
 }
 
-/** Remove worktree dirs of branches that no longer exist (crash leftovers). */
+/** Branch names currently checked out in any worktree (incl. the main one). */
+function worktreeBranches(root: string): string[] {
+	try {
+		return git(root, ["worktree", "list", "--porcelain"])
+			.split("\n")
+			.filter((l) => l.startsWith("branch "))
+			.map((l) => l.slice("branch refs/heads/".length).trim());
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Remove worktree dirs that are NOT registered worktrees (crash leftovers).
+ * A crash leaves the dir AND the branch, so branch-existence can't identify
+ * leftovers — worktree registration can. Branches always survive.
+ */
 export function sweepStale(root: string): void {
+	root = realpathSync(root);
 	const sub = join(root, ".git", "subagents");
 	if (!existsSync(sub)) return;
-	const branches = new Set(
-		git(root, ["branch", "--list", "subagents/*"])
-			.split("\n")
-			.map((b) => b.trim().replace(/^[+*]\s*/, "")),
-	);
+	const registered = new Set(worktreePaths(root));
 	for (const runDir of readDirs(sub)) {
 		for (const taskDir of readDirs(join(sub, runDir))) {
-			const branch = `subagents/${runDir}/${taskDir}`;
-			if (branches.has(branch)) continue; // live branch, dir may be an active worktree
+			const dir = join(sub, runDir, taskDir);
+			if (registered.has(dir)) continue; // live worktree
 			try {
-				git(root, ["worktree", "remove", "--force", join(sub, runDir, taskDir)]);
+				git(root, ["worktree", "remove", "--force", dir]);
 			} catch {
 				// dir not a registered worktree (partial crash) — plain rm
-				rmSync(join(sub, runDir, taskDir), { recursive: true, force: true });
+				rmSync(dir, { recursive: true, force: true });
 			}
 		}
 	}
+	prune(root);
+}
+
+function worktreePaths(root: string): string[] {
+	try {
+		return git(root, ["worktree", "list", "--porcelain"])
+			.split("\n")
+			.filter((l) => l.startsWith("worktree "))
+			.map((l) => l.slice("worktree ".length).trim());
+	} catch {
+		return [];
+	}
 }
 
 function readDirs(dir: string): string[] {