@arhen/pi-core-subagent 1.3.42 → 1.3.44

package/package.json

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

@@ -242,8 +242,9 @@ export function makeSummary(run: RunSnapshot): string {
 		// 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}]` : "";
+		const swap = task.modelNote ? `\nModel: ${task.modelNote}` : "";
 		lines.push(
-			`\n## ${task.agent}${edge}${fileNote} ${statusIcon(task.status)}${task.error ? `\nError: ${task.error}` : `\n${truncateText(task.finalText || "(no output)")}`}${worktreeLine(task, run.tasks)}`,
+			`\n## ${task.agent}${edge}${fileNote} ${statusIcon(task.status)}${swap}${task.error ? `\nError: ${task.error}` : `\n${truncateText(task.finalText || "(no output)")}`}${worktreeLine(task, run.tasks)}`,
 		);
 	}
 	// Ceiling on the WHOLE summary — 16 tasks × 24KB would otherwise flood the parent context.
@@ -265,9 +266,10 @@ export function makeTaskNotice(run: RunSnapshot, task: TaskSnapshot, kind: strin
 	// 403, wrong persona) that override is the likeliest cause, so it has to be
 	// in the notice, not only in the run summary the leader may never read.
 	const src = task.agentFile ? `\nAgent file: ${task.agentFile}${task.model ? ` (model ${task.model})` : ""}` : "";
+	const swap = task.modelNote ? `\nModel: ${task.modelNote}` : "";
 	return [
 		`Task ${task.agent} (${task.id}) ${kind} in run ${run.id}: ${detail}${wt}`,
-		`Goal: ${goal}${src}`,
+		`Goal: ${goal}${src}${swap}`,
 		isStartupFailure(task, kind)
 			? "Never started — stop and diagnose before spawning anything else: a config-level error (model, plan, auth, agent file) fails identically on every respawn."
 			: `Use subagent_result(runId: "${run.id}", taskId: "${task.id}") for full output.`,

package/src/manager.ts

@@ -22,10 +22,10 @@ import {
 	activitySnippet,
 	describeCall,
 	getFirstText,
+	isStartupFailure,
 	isTalking,
 	makeNotice,
 	makeTaskNotice,
-	isStartupFailure,
 	SubagentsWidget,
 	truncateText,
 } from "./format.ts";
@@ -160,14 +160,26 @@ export function cloneRun(run: RunSnapshot): RunSnapshot {
 	return JSON.parse(JSON.stringify(run)) as RunSnapshot;
 }
 /** Resolve a child model from the pi model registry.
- *  Order: explicit "provider/model-id" or bare id (searched across available
- *  models) → agent file model → parent's current model (ctx.model) → undefined
- *  (createAgentSession falls back to settings). */
+ *  Order: explicit "provider/model-id" or bare id → agent file model → parent's
+ *  current model (ctx.model) → undefined (createAgentSession falls back to settings).
+ *
+ *  A BARE id is ambiguous: `claude-sonnet-5` exists on anthropic, commandcode,
+ *  github-copilot and openrouter at once, and an agent file's `model:` is written
+ *  without a provider. Taking the registry's first match routed children to a
+ *  provider the session never chose (403 MODEL_NOT_IN_PLAN on every spawn), so the
+ *  ACTIVE SESSION's provider is searched first — exact id, then its own prefixed
+ *  form (9router carries `cc/claude-opus-5`, not `claude-opus-5`). */
 export function resolveChildModel(ctx: ExtensionContext, explicit: string | undefined) {
 	if (!explicit?.trim()) return ctx.model; // inherit the parent's active model
 	const ref = explicit.trim();
 	if (!ctx.modelRegistry) return ctx.model; // no registry to check against (tests, headless)
 	const available = ctx.modelRegistry.getAvailable();
+	const sessionProvider = ctx.model?.provider;
+	if (sessionProvider && !ref.includes("/")) {
+		const own = available.filter((m) => m.provider === sessionProvider);
+		const hit = own.find((m) => m.id === ref) ?? own.find((m) => m.id.endsWith(`/${ref}`));
+		if (hit) return hit;
+	}
 	// Model ids can contain slashes (e.g. 9router/cc/claude-opus-5), so a bare id
 	// match and every provider/id split point must be tried, not just the first.
 	const byId = available.find((m) => m.id === ref);
@@ -179,6 +191,48 @@ export function resolveChildModel(ctx: ExtensionContext, explicit: string | unde
 	throw new Error(`Model not found: ${ref}`);
 }
 
+/** One throwaway request against the resolved model. A child that cannot reach its
+ *  model dies on its FIRST turn with no output, after a worktree and a session have
+ *  already been built — and an agent file's `model:` is chosen by a file the leader
+ *  never wrote, so "it resolved" is not evidence it is usable (plan gates, ZDR,
+ *  dead keys all pass resolution). Returns the error text, or undefined when OK. */
+async function probeModel(
+	ctx: ExtensionContext,
+	model: Model<Api>,
+	signal: AbortSignal | undefined,
+): Promise<string | undefined> {
+	try {
+		const reply = await ctx.modelRegistry.complete(
+			model,
+			{ messages: [{ role: "user", content: "ping", timestamp: Date.now() }] },
+			{ maxTokens: 16, signal },
+		);
+		return reply.stopReason === "error" ? (reply.errorMessage ?? "provider returned an error") : undefined;
+	} catch (err) {
+		return err instanceof Error ? err.message : String(err);
+	}
+}
+
+/** Preflight for the model a child is about to run on. Probes only what is not
+ *  already proven: the session's own model answered this very turn. On failure the
+ *  session model is the fallback — the one model known to work right now. */
+export async function ensureUsableModel(
+	ctx: ExtensionContext,
+	model: Model<Api> | undefined,
+	signal: AbortSignal | undefined,
+): Promise<{ model: Model<Api> | undefined; note?: string }> {
+	const session = ctx.model;
+	if (!model || !ctx.modelRegistry) return { model };
+	if (session && model.provider === session.provider && model.id === session.id) return { model };
+	const error = await probeModel(ctx, model, signal);
+	if (!error) return { model };
+	if (!session) throw new Error(`Model ${model.provider}/${model.id} is unusable: ${error}`);
+	return {
+		model: session,
+		note: `${model.provider}/${model.id} failed preflight (${error}); using session model ${session.provider}/${session.id}`,
+	};
+}
+
 /** Extension-registered providers (e.g. 9router) live only in the parent's
  *  in-memory runtime. A child builds its runtime from disk and would lose them,
  *  so replay the parent's registrations before the child resolves auth. */
@@ -810,10 +864,18 @@ export class SubagentManager {
 		try {
 			model = resolveChildModel(ctx, file?.model ?? input.model);
 			validateThinking(model, thinking);
+			// Resolution only proves the id exists. Probe it before anything is built,
+			// and fall back to the session's own model when the probe fails.
+			const checked = await ensureUsableModel(ctx, model, signal);
+			model = checked.model;
+			if (checked.note) {
+				task.modelNote = checked.note;
+				validateThinking(model, thinking);
+			}
 			// Record the model ACTUALLY used — an agent file's `model:` overrides the
 			// requested one, and showing the request in the widget hides that entirely
 			// (a 403 then names a model the leader never asked for).
-			if (model) this.updateTask(run, task, { model: model.id }, ctx, onUpdate);
+			if (model) this.updateTask(run, task, { model: model.id, modelNote: checked.note }, ctx, onUpdate);
 		} catch (err) {
 			this.updateTask(
 				run,

package/src/peek.ts

@@ -38,51 +38,119 @@ function readTail(path: string): string {
 	}
 }
 
+/** Reasoning markup is the model talking to itself, and empty `<think></think>`
+ *  pairs are the commonest single line in a transcript — they filled the pane with
+ *  rows carrying no information at all. */
+function stripThinking(text: string): string {
+	return text
+		.replace(/<think>[\s\S]*?<\/think>/g, " ")
+		.replace(/<\/?(?:think|thinking|reasoning)>/g, " ")
+		.trim();
+}
+
+// biome-ignore lint/suspicious/noControlCharactersInRegex: stripping real terminal escapes is the point
+const ANSI = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+// biome-ignore lint/suspicious/noControlCharactersInRegex: same
+const CONTROL = /[\x00-\x08\x0b-\x1f\x7f]/g;
+
+/** Tool output is terminal output: it carries colour escapes and carriage returns
+ *  that corrupt the pane's own styling (stray `[0m` mid-row, cursor jumps). */
 function clip(text: string, max: number): string {
-	const flat = text.replace(/\s+/g, " ").trim();
+	const flat = text.replace(ANSI, "").replace(CONTROL, " ").replace(/\s+/g, " ").trim();
 	return flat.length > max ? `${flat.slice(0, max)}…` : flat;
 }
 
-/** One session-file line → one display line: [gutter, text]. Irrelevant → null. */
-function eventLine(raw: string): [string, string] | null {
+/** Long absolute paths are almost entirely prefix. The tail is what identifies
+ *  the file, so shorten from the left and keep the last segments. */
+function shortenPath(text: string): string {
+	return text.replace(/(?:\/[\w.@+-]+){3,}/g, (path) => {
+		const parts = path.split("/").filter(Boolean);
+		return parts.length <= 3 ? path : `…/${parts.slice(-3).join("/")}`;
+	});
+}
+
+const PATH_ARGS = ["path", "file", "filePath", "command", "pattern", "query", "url", "task", "subject"];
+
+/** The argument that says WHAT a call does. Object.values() order is insertion
+ *  order, so the old "first string wins" picked `oldText` blobs over `path`. */
+function callSummary(args: Record<string, unknown> | undefined): string {
+	for (const key of PATH_ARGS) {
+		const value = args?.[key];
+		if (typeof value === "string" && value.trim()) return value;
+	}
+	const first = Object.values(args ?? {}).find((v) => typeof v === "string" && v.trim() !== "");
+	return typeof first === "string" ? first : "";
+}
+
+export type PeekLine = { gutter: string; text: string; kind: "call" | "result" | "error" | "say" };
+
+/** One session-file entry → display lines. A turn with 4 tool calls is 4 lines:
+ *  keeping only the first hid the parallel calls that explain what the child did. */
+function eventLines(raw: string): PeekLine[] {
 	let entry: any;
 	try {
 		entry = JSON.parse(raw);
 	} catch {
-		return null;
+		return [];
 	}
 	const msg = entry?.message;
-	if (!msg) return null;
-	const out: [string, string][] = [];
-	for (const block of msg.content ?? []) {
+	if (!msg) return [];
+	const out: PeekLine[] = [];
+	const isResult = msg.role === "toolResult";
+	for (const block of Array.isArray(msg.content) ? msg.content : []) {
 		if (block.type === "toolCall") {
-			const arg = Object.values(block.arguments ?? {}).find((v) => typeof v === "string" && v.trim() !== "") as
-				| string
-				| undefined;
-			out.push(["→", `${block.name}${arg ? ` ${clip(arg, 120)}` : ""}`]);
-		} else if (block.type === "text" && block.text?.trim()) {
-			out.push([msg.role === "toolResult" ? "←" : "·", clip(block.text, 160)]);
+			const arg = callSummary(block.arguments);
+			out.push({ gutter: "→", kind: "call", text: `${block.name}${arg ? ` ${shortenPath(clip(arg, 110))}` : ""}` });
+		} else if (block.type === "text") {
+			const text = stripThinking(block.text ?? "");
+			if (!text) continue; // a turn that was pure reasoning has nothing to show
+			if (isResult) {
+				const kind = msg.isError ? "error" : "result";
+				const name = msg.toolName ? `${msg.toolName}: ` : "";
+				out.push({ gutter: msg.isError ? "✗" : "←", kind, text: `${name}${shortenPath(clip(text, 150))}` });
+			} else {
+				out.push({ gutter: "·", kind: "say", text: clip(text, 150) });
+			}
 		}
 	}
-	return out[0] ?? null;
+	return out;
 }
 
-function tailLines(path: string, max: number): [string, string][] {
+function tailLines(path: string, max: number): PeekLine[] {
 	let text: string;
 	try {
 		text = readTail(path);
 	} catch {
-		return [["·", "(session file not readable yet)"]];
+		return [{ gutter: "·", kind: "say", text: "(session file not readable yet)" }];
 	}
-	const lines: [string, string][] = [];
+	const lines: PeekLine[] = [];
 	// First line of a mid-file read is usually a fragment — drop it.
-	for (const raw of text.split("\n").slice(1)) {
-		const line = eventLine(raw);
-		if (line) lines.push(line);
-	}
+	for (const raw of text.split("\n").slice(1)) lines.push(...eventLines(raw));
 	return lines.slice(-max);
 }
 
+/** Gutter colour carries the line's role, so the eye can skip to failures without
+ *  reading: → call, ← result, ✗ error, · the child speaking. */
+function renderLine(line: PeekLine, theme: Theme): string {
+	if (line.kind === "error") return `${theme.fg("error", line.gutter)} ${theme.fg("error", line.text)}`;
+	if (line.kind === "call") {
+		const space = line.text.indexOf(" ");
+		const name = space === -1 ? line.text : line.text.slice(0, space);
+		const arg = space === -1 ? "" : line.text.slice(space + 1);
+		return `${theme.fg("accent", line.gutter)} ${theme.fg("toolTitle", name)}${arg ? ` ${theme.fg("muted", arg)}` : ""}`;
+	}
+	if (line.kind === "result") return `${theme.fg("dim", line.gutter)} ${theme.fg("dim", line.text)}`;
+	return `${theme.fg("dim", line.gutter)} ${line.text}`;
+}
+
+/** Status as a coloured word, the way pi marks tool state. */
+function statusTag(status: string, theme: Theme): string {
+	if (status === "failed") return theme.fg("error", status);
+	if (status === "completed") return theme.fg("success", status);
+	if (status === "aborted") return theme.fg("warning", status);
+	return theme.fg("muted", status);
+}
+
 export interface PeekPane {
 	render(width: number): string[];
 	handleInput(data: string): void;
@@ -128,8 +196,14 @@ export function createPeekPane(
 			const hint = confirming
 				? theme.fg("error", `abort ${task.agent}?  y / n`)
 				: theme.fg("dim", tailing ? "esc back · x abort" : "shift+↑↓ / jk move · enter tail · x abort · esc close");
-			const title = `${theme.fg("accent", theme.bold(tailing ? task.agent : "Subagents"))} ${theme.fg("muted", `${selected + 1}/${tasks.length}`)}`;
-			const lines = [row("", width), row(title, width), row(hint, width), row("", width)];
+			// Breadcrumb, not a bare name: while tailing, WHERE you are is the thing you
+			// lose track of first, and the child's status belongs next to its name.
+			const crumb = tailing
+				? `${theme.fg("muted", "Subagents")}${theme.fg("dim", " › ")}${theme.fg("accent", theme.bold(task.agent))} ${statusTag(task.status, theme)}`
+				: theme.fg("accent", theme.bold("Subagents"));
+			const title = `${crumb} ${theme.fg("muted", `${selected + 1}/${tasks.length}`)}`;
+			const rule = theme.fg("borderMuted", "─".repeat(Math.max(0, width - 4)));
+			const lines = [row("", width), row(title, width), row(hint, width), row(rule, width)];
 
 			if (!tailing) {
 				for (const [i, t] of tasks.entries()) {
@@ -140,9 +214,9 @@ export function createPeekPane(
 				lines.push(row(theme.fg("dim", "(no session file — agent has not started yet)"), width));
 			} else {
 				// ponytail: re-reads the tail each render (700ms poll). A watcher only pays off for files far bigger than a child session.
-				for (const [gutter, text] of tailLines(task.sessionFile, TAIL_ROWS)) {
-					lines.push(row(`${theme.fg("dim", gutter)} ${gutter === "←" ? theme.fg("dim", text) : text}`, width));
-				}
+				const tail = tailLines(task.sessionFile, TAIL_ROWS);
+				if (tail.length === 0) lines.push(row(theme.fg("dim", "(no activity yet)"), width));
+				for (const line of tail) lines.push(row(renderLine(line, theme), width));
 			}
 			lines.push(row("", width));
 			return lines;

package/src/types.ts

@@ -36,6 +36,9 @@ export interface TaskSnapshot {
 	finalText?: string;
 	error?: string;
 	model?: string;
+	/** Why `model` is not what was requested: preflight failed and the session's
+	 *  model took over. Silent substitution is worse than a slow spawn. */
+	modelNote?: string;
 	thinking?: string;
 	tools?: string[];
 	usage: UsageStats;