@arhen/pi-core-subagent 1.3.56 → 1.3.58

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@arhen/pi-core-subagent",
-	"version": "1.3.56",
+	"version": "1.3.58",
 	"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

@@ -111,10 +111,17 @@ export function isTalking(task: TaskSnapshot): boolean {
 	return TALK_TOOLS.some((t) => a.startsWith(t));
 }
 let pulsePhase = 0;
+const NOTE_CAP = 240;
+function noteSnippet(note: string): string {
+	return note.length > NOTE_CAP ? `${note.slice(0, NOTE_CAP)}…` : note;
+}
 export function compactLines(run: RunSnapshot): string[] {
 	const lines: string[] = [];
 	for (const task of run.tasks.slice(0, MAX_TASKS)) {
 		lines.push(taskLine(task));
+		// a swapped model or toolset changes what the task did, so it cannot stay out of the status view
+		if (task.modelNote) lines.push(`   ↳ Model: ${noteSnippet(task.modelNote)}`);
+		if (task.toolsNote) lines.push(`   ↳ Tools: ${noteSnippet(task.toolsNote)}`);
 	}
 	if (run.tasks.length > MAX_TASKS) lines.push(`… +${run.tasks.length - MAX_TASKS} more`);
 	return lines;

package/src/index.ts

@@ -299,7 +299,8 @@ export default function (pi: ExtensionAPI) {
 							? `\nApplied IN PLACE (no branch) — ${t.isolationReason ?? "worktree unavailable"}. The changes are already in your working tree.`
 							: "";
 					const wtErr = t.worktreeError ? `\nWorktree: ${t.worktreeError}` : "";
-					return `\n## ${t.agent} ${statusIcon(t.status)}\nGoal: ${truncateText(t.task, 300)}\n${t.error ? `Error: ${t.error}` : t.finalText || "(no output yet)"}${wt}${wtErr}\n${formatUsage(t.usage)}`;
+					const modelNote = t.modelNote ? `\nModel: ${t.modelNote}` : "";
+					return `\n## ${t.agent} ${statusIcon(t.status)}\nGoal: ${truncateText(t.task, 300)}\n${t.error ? `Error: ${t.error}` : t.finalText || "(no output yet)"}${wt}${wtErr}${modelNote}\n${formatUsage(t.usage)}`;
 				}),
 			].join("\n");
 			return { content: [{ type: "text", text: truncateText(text) }], details: { run: cloneRun(run) } };

package/src/manager.ts

@@ -2,7 +2,13 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync
 import { rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, 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";
+import {
+	type Api,
+	type AssistantMessage,
+	clampThinkingLevel,
+	getSupportedThinkingLevels,
+	type Model,
+} from "@earendil-works/pi-ai";
 import {
 	type AgentSessionEvent,
 	createAgentSession,
@@ -157,16 +163,36 @@ export function resolveChildModel(ctx: ExtensionContext, explicit: string | unde
 	throw new Error(`Model not found: ${ref}`);
 }
 
+const PROBE_THINKING_LEVELS: ThinkingLevel[] = ["low", "minimal", "medium", "high", "xhigh", "max"];
+
+/**
+ * Thinking level for the usability probe: exactly what the child session will send — the clamped
+ * requested level, or the cheapest the model accepts when none was requested. Probing without a
+ * level makes adaptive-thinking providers reject the request (9router claude models answer
+ * "thinking.type.disabled is not supported"), which used to make every preflight fail and fall
+ * back to the session model.
+ */
+function probeThinking(model: Model<Api>, thinking?: string): ThinkingLevel | undefined {
+	if (!model.reasoning) return undefined;
+	const supported = getSupportedThinkingLevels(model);
+	if (thinking && thinking !== "off") return clampThinkingLevel(model, thinking as ThinkingLevel);
+	// the child clamps an unsupported "off" up to its cheapest level, so probe that instead
+	if (thinking === "off") return supported.includes("off") ? undefined : supported[0];
+	return PROBE_THINKING_LEVELS.find((level) => supported.includes(level));
+}
+
 async function probeModel(
 	ctx: ExtensionContext,
 	model: Model<Api>,
 	signal: AbortSignal | undefined,
+	thinking?: string,
 ): Promise<string | undefined> {
 	try {
+		const reasoningEffort = probeThinking(model, thinking);
 		const reply = await ctx.modelRegistry.complete(
 			model,
 			{ messages: [{ role: "user", content: "ping", timestamp: Date.now() }] },
-			{ maxTokens: 16, signal },
+			{ maxTokens: 16, signal, ...(reasoningEffort ? { reasoningEffort } : {}) },
 		);
 		return reply.stopReason === "error" ? (reply.errorMessage ?? "provider returned an error") : undefined;
 	} catch (err) {
@@ -178,11 +204,12 @@ export async function ensureUsableModel(
 	ctx: ExtensionContext,
 	model: Model<Api> | undefined,
 	signal: AbortSignal | undefined,
+	thinking?: string,
 ): 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);
+	const error = await probeModel(ctx, model, signal, thinking);
 	if (!error) return { model };
 	if (model.provider === "opencode-go" && /MissingSessionID|x-opencode-session/i.test(error)) {
 		// ponytail: opencode-go rejects stateless probes but accepts AgentSession requests, which add the session header.
@@ -302,10 +329,10 @@ export class SubagentManager {
 		return false;
 	}
 
-	clearWidget(ctx: ExtensionContext): void {
+	clearWidget(ctx?: ExtensionContext): void {
 		this.widgetRuns = [];
 		this.widgetTui = null;
-		if (ctx.hasUI) {
+		if (ctx?.hasUI) {
 			try {
 				ctx.ui.setWidget("subagents", undefined);
 			} catch {}
@@ -483,8 +510,14 @@ export class SubagentManager {
 	}
 
 	private widgetTui: TUI | null = null;
+
+	/** Settled runs are history (subagent_status/result still reach them) — the widget shows live work only. */
+	private pruneSettledWidget(): void {
+		this.widgetRuns = this.widgetRuns.filter((r) => !TERMINAL.includes(r.status));
+	}
 	private upsertWidgetRun(run: RunSnapshot | undefined): void {
-		if (!run) return;
+		this.pruneSettledWidget();
+		if (!run || TERMINAL.includes(run.status)) return;
 		const idx = this.widgetRuns.findIndex((r) => r.id === run.id);
 		if (idx >= 0) this.widgetRuns[idx] = run;
 		else this.widgetRuns.push(run);
@@ -524,12 +557,17 @@ export class SubagentManager {
 				this.widgetTimers.delete(run.id);
 			}
 		}
-		if (!run || this.widgetRuns.length === 0) return;
-		if (ctx?.hasUI) {
-			this.ensureWidget(ctx);
-			this.widgetTui?.requestRender();
+		this.pruneSettledWidget();
+		if (this.widgetRuns.length === 0) {
+			if (this.widgetTui) this.clearWidget(ctx);
+		} else {
+			if (ctx?.hasUI) {
+				this.ensureWidget(ctx);
+				this.widgetTui?.requestRender();
+			}
+			this.maybePulse(ctx);
 		}
-		this.maybePulse(ctx);
+		if (!run) return;
 
 		onUpdate?.({
 			content: [
@@ -747,7 +785,7 @@ export class SubagentManager {
 			model = resolveChildModel(ctx, file?.model ?? input.model);
 			validateThinking(model, thinking);
 
-			const checked = await ensureUsableModel(ctx, model, signal);
+			const checked = await ensureUsableModel(ctx, model, signal, thinking);
 			model = checked.model;
 			if (checked.note) {
 				task.modelNote = checked.note;