@ferris1225/pi-subagents 1.0.0 → 2.0.0

package/src/fixloop.ts

@@ -86,22 +86,6 @@ export function chainKeyFragments(result: SingleResult): string[] {
 	return extractKeyFragments(getResultOutput(result)).slice(0, CHAIN_SUMMARY_FRAGMENTS_MAX);
 }
 
-/**
- * Compact one-line outcome for a finished chain run, retained so
- * each round reads as what it did: a reviewer reports its verdict plus the
- * key fragments of what it found ("fail · src/index.ts · render()"), a worker
- * the fragments of what it changed. Failed runs and runs with nothing
- * distinctive get no summary.
- */
-export function summarizeChainResult(result: SingleResult): string | undefined {
-	if (isFailedResult(result)) return undefined;
-	const verdict = result.agent === "reviewer" ? reviewVerdict(getResultOutput(result)) : undefined;
-	if (verdict === "pass") return "pass";
-	const fragments = chainKeyFragments(result);
-	if (verdict === "fail") return fragments.length > 0 ? `fail · ${fragments.join(" · ")}` : "fail";
-	return fragments.length > 0 ? fragments.join(" · ") : undefined;
-}
-
 /**
  * Condensed, readable summary of a completed auto-fix chain: one line per step
  * (run id, role, verdict / what changed) plus aggregate usage. Full per-step

package/src/format.ts

@@ -6,6 +6,7 @@
 
 import type { AgentConfig } from "./agents.ts";
 import { formatTaskSummary } from "./monitor.ts";
+import { emptyUsage } from "./rpc-run.ts";
 import {
 	getResultOutput,
 	isFailedResult,
@@ -15,14 +16,9 @@ import {
 	type UsageStats,
 } from "./spawn.ts";
 
-export function emptyUsage(): UsageStats {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 };
-}
-
 export function queuedResult(agent: AgentConfig, task: string, thinking?: string): SingleResult {
 	return {
 		agent: agent.name,
-		agentSource: agent.source,
 		task,
 		exitCode: -1,
 		messages: [],
@@ -36,7 +32,6 @@ export function queuedResult(agent: AgentConfig, task: string, thinking?: string
 export function failedStartResult(agentName: string, task: string, errorMessage: string): SingleResult {
 	return {
 		agent: agentName,
-		agentSource: "unknown",
 		task,
 		exitCode: 1,
 		messages: [],
@@ -61,7 +56,7 @@ export function dispatchFailedResult(agent: AgentConfig, task: string, error: un
 	};
 }
 
-export function formatTokens(count: number): string {
+function formatTokens(count: number): string {
 	if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
 	if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k`;
 	return String(count);
@@ -78,33 +73,40 @@ export function formatUsage(usage: UsageStats): string {
 	return parts.join(" ");
 }
 
-export function formatCompletionBlock(result: SingleResult, maxResultLines: number, cwd?: string): string {
+export interface CompletionFormatOptions {
+	/** Include individual failed-tool errors. Reserved for explicit status lookup. */
+	failedToolDetails?: boolean;
+}
+
+export function formatCompletionBlock(
+	result: SingleResult,
+	maxResultLines: number,
+	cwd?: string,
+	options: CompletionFormatOptions = {},
+): string {
 	const failed = isFailedResult(result);
 	const failedTools = result.failedTools ?? [];
 	const status = failed
 		? "failed"
-		: failedTools.length > 0
+		: options.failedToolDetails && failedTools.length > 0
 			? `completed with ${failedTools.length} failed tool call${failedTools.length === 1 ? "" : "s"}`
 			: "completed";
 	const usage = formatUsage(result.usage);
 	const output = getResultOutput(result);
 	const { text, truncated } = truncateResultOutput(output, maxResultLines);
 	const fallbackNote = result.modelFallbackFrom
-		? ` (model pool fallback: primary ${result.modelFallbackFrom} → final ${result.model ?? "dynamic default"})`
+		? ` (selected model ${result.modelFallbackFrom} failed → main ${result.model ?? "dynamic default"})`
 		: "";
 	const startupRetryNote = result.startupRetries
 		? ` (recovered after ${result.startupRetries} startup retr${result.startupRetries === 1 ? "y" : "ies"} — concurrent pi startup race)`
 		: "";
-	const modelRetryNote = result.modelRetries
-		? ` (recovered after ${result.modelRetries} same-model retr${result.modelRetries === 1 ? "y" : "ies"} on a transient provider error)`
-		: "";
 	const relations = [
 		result.forkedFromRunId !== undefined ? `forked from #${result.forkedFromRunId}` : undefined,
 		(result.forkChildRunIds?.length ?? 0) > 0 ? `fork children ${result.forkChildRunIds!.map((id) => `#${id}`).join(", ")}` : undefined,
 	].filter((value): value is string => Boolean(value));
 	const relationNote = relations.length > 0 ? ` · ${relations.join(" · ")}` : "";
 	const runNote = result.runId !== undefined ? ` · run #${result.runId}` : "";
-	const lines = [`### [${result.agent}] ${status}${usage ? ` (${usage})` : ""}${fallbackNote}${startupRetryNote}${modelRetryNote}${runNote}`, "", `Task: ${formatTaskSummary(result.task, 80, false)}`, ""];
+	const lines = [`### [${result.agent}] ${status}${usage ? ` (${usage})` : ""}${fallbackNote}${startupRetryNote}${runNote}`, "", `Task: ${formatTaskSummary(result.task, 80, false)}`, ""];
 	if (result.isolation === "worktree") {
 		const isolation =
 			result.integrationStatus === "integrated"
@@ -125,23 +127,22 @@ export function formatCompletionBlock(result: SingleResult, maxResultLines: numb
 		lines.push(`Relation: ${relations.join(" · ")}`, "");
 	}
 	lines.push(text);
-	// A run can exit cleanly while its last tools failed (e.g. a build that broke):
-	// the final text alone may claim more than the tools achieved, so surface the
-	// failures explicitly and tell the main agent to verify before relying on it.
-	if (!failed && failedTools.length > 0) {
-		const shown = failedTools.slice(0, 3);
-		const more = failedTools.length - shown.length;
+	// Explicit status always exposes every retained diagnostic, including when
+	// the overall run failed or was aborted. Automatic delivery adds only a
+	// compact pointer for otherwise-clean runs.
+	if (options.failedToolDetails && failedTools.length > 0) {
 		lines.push(
 			"",
-			`⚠ ${failedTools.length} tool call${failedTools.length === 1 ? "" : "s"} failed during this run — the final text above may not reflect a working state:`,
-			...shown.map((tool) => `- ${tool.toolName}: ${tool.error.trim() || "(no output)"}`),
+			`⚠ ${failedTools.length} failed tool call${failedTools.length === 1 ? "" : "s"}:`,
+			...failedTools.map((tool) => `- ${tool.toolName}: ${tool.error.trim() || "(no output)"}`),
 		);
-		if (more > 0) lines.push(`- … and ${more} more`);
-		lines.push("Verify the actual artifacts before relying on this report.");
+	} else if (!failed && failedTools.length > 0) {
+		const lookup = result.runId !== undefined ? ` · details: subagent_status #${result.runId}` : "";
+		lines.push("", `⚠ ${failedTools.length} failed tool call${failedTools.length === 1 ? "" : "s"}${lookup}`);
 	}
 	if (truncated) {
 		// The full text lives on disk so the main agent can read it on demand.
-		lines.push("", `(output truncated to ${maxResultLines} lines; full result: ${writeResultArtifact(output, result.agent, cwd)})`);
+		lines.push("", `(output truncated to ${maxResultLines} lines; full result: ${writeResultArtifact(output, result.agent, result.projectCwd ?? cwd)})`);
 	}
 	return lines.join("\n");
 }
@@ -153,15 +154,12 @@ export function formatCompletionBlock(result: SingleResult, maxResultLines: numb
  * RESUME it in-context once a model is available, instead of re-dispatching
  * fresh (which would re-scan everything). */
 export function modelLevelTakeoverNote(result: SingleResult, opts?: { runId?: number }): string {
-	const sameModel = result.modelRetries
-		? `, after ${result.modelRetries} same-model retr${result.modelRetries === 1 ? "y" : "ies"} on transient errors`
-		: "";
-	const retry = result.modelFallbackFrom ? ", and the configured backup chain also failed" : "";
+	const retry = result.modelFallbackFrom ? ", and the current main model also failed" : "";
 	const sessionPreserved = Boolean(result.sessionDir && result.sessionId) && opts?.runId !== undefined;
 	const recovery = sessionPreserved
 		? ` The sub-agent's earlier work in this run is preserved. Once a model is available again, call subagent_control with { action: "resume", id: ${opts!.runId} } to CONTINUE it in-context (it keeps the same run id and does not re-scan), or execute the task in the main window with your own tools.`
 		: ` Please execute this task in the main window with your own tools; do not re-dispatch it as a sub-agent.`;
-	return `The sub-agent could not complete this task: its model was unavailable or failed (or the run stalled)${sameModel}${retry}.${recovery}`;
+	return `The sub-agent could not complete this task: its model was unavailable or failed (or the run stalled)${retry}.${recovery}`;
 }
 
 /** Resolve a run-id request to actual ids: an exact numeric match always wins

package/src/index.ts

@@ -5,7 +5,8 @@
  * The heavy lifting lives in focused modules:
  *   - dispatch.ts  — the `subagent` tool (spawn, auto-fix chain, vision model)
  *   - tools.ts     — subagent_control / subagent_wait / status / stop
- *   - announcements.ts — session-start recovery and feature notices
+ *   - announcements.ts — session-start recovery, notices, and widget install
+ *   - widget.ts        — active-only TUI run status
  *   - runtime.ts       — shared per-session state
  *
  * Also registers the `/subagents-setup` command and a `before_agent_start` hook
@@ -28,6 +29,7 @@ import { createRuntime } from "./runtime.ts";
 import { runSetup } from "./setup.ts";
 import { currentSubagentDepth } from "./spawn.ts";
 import { registerLookupTools } from "./tools.ts";
+import { clearActiveRunsWidget } from "./widget.ts";
 
 export { matchRunIds };
 
@@ -57,7 +59,8 @@ export default function (pi: ExtensionAPI): void {
 		),
 	);
 
-	pi.on("session_shutdown", async () => {
+	pi.on("session_shutdown", async (_event, ctx) => {
+		clearActiveRunsWidget(ctx);
 		await runtime.shutdown();
 	});
 
@@ -65,7 +68,7 @@ export default function (pi: ExtensionAPI): void {
 	registerLookupTools(pi, runtime);
 
 	pi.registerCommand("subagents-setup", {
-		description: "Configure pi-subagents: enabled agents, primary/backup model pools, and runtime settings",
+		description: "Configure pi-subagents: agents, selected models, capability-aware thinking, vision, and runtime settings",
 		handler: async (_args, ctx) => {
 			await runSetup(ctx, configPath);
 		},

package/src/models.ts

@@ -1,61 +1,55 @@
 /*
- * Model-pool resolution and setup-picker helpers.
+ * Model routing, capability-aware thinking, and setup-picker helpers.
  *
- * Runtime pools deliberately do not filter configured references by current
- * availability: a stale primary/backup is attempted and normal provider/model
- * failure handling advances to the next candidate. Setup uses the same catalog
- * only for honest availability labels; it never rewrites persisted choices.
+ * Runtime has one explicit fallback only: a configured agent/vision model hands
+ * off directly to the current main-window model. Setup lists only currently
+ * available models and derives thinking choices from Pi's model metadata.
  */
 
-import type { Api, Model } from "@earendil-works/pi-ai";
+import {
+	clampThinkingLevel,
+	getSupportedThinkingLevels,
+	type Api,
+	type Model,
+} from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_THINKING_LEVEL, type ThinkingLevel } from "./config.ts";
 
 export type ModelContext = Pick<ExtensionContext, "model" | "modelRegistry"> &
 	Partial<Pick<ExtensionContext, "scopedModels">>;
 
 export const CURRENT_MAIN_MODEL = "__current_main_model__";
 
-export type ModelPoolSlot = "primary" | "backup";
-export type ModelPickerSlot = ModelPoolSlot | "vision";
+export type ModelPickerSlot = "agent" | "vision";
 
 export interface ModelPickerItem {
 	value: string;
 	label: string;
 	description?: string;
-	/** Visible for diagnosis/search, but cannot be selected. */
-	disabled?: boolean;
 }
 
 export type ModelListEntry = Pick<
 	Model<Api>,
-	"provider" | "id" | "name" | "input" | "reasoning"
+	"provider" | "id" | "name" | "input" | "reasoning" | "thinkingLevelMap"
 >;
 
-export interface ResolvedAgentModelPool {
-	/** Effective first candidate. Undefined means let pi use its normal default. */
+export interface ResolvedAgentModelRoute {
+	/** Effective first candidate. Undefined means let Pi use its normal default. */
 	primaryRef?: string;
-	/** Ordered candidates after the primary, already deduplicated. */
-	fallbackModelRefs: string[];
-	/** All known references in runtime order, useful for tests/inspection. */
+	/** Current main-window model when it differs from the selection. */
+	mainFallbackRef?: string;
+	/** Runtime order, useful for status/tests. */
 	candidateRefs: string[];
+	/** Configured ref skipped because Pi does not currently report it available. */
+	unavailableSelectedRef?: string;
 }
 
-export interface AgentModelPoolInput {
-	primaryRef?: string;
-	backupRef?: string;
+export interface AgentModelRouteInput {
+	selectedRef?: string;
 	mainRef?: string;
 	declaredDefaultRef?: string;
-}
-
-export interface AgentModelPoolMaps {
-	agentModels: Record<string, string>;
-	agentBackupModels: Record<string, string>;
-}
-
-export interface AgentModelPoolRow {
-	name: string;
-	primary: string;
-	backup: string;
+	/** When supplied, a configured selection outside this live set is skipped. */
+	availableRefs?: readonly string[];
 }
 
 function cleanModelRef(ref: string | undefined): string | undefined {
@@ -78,70 +72,84 @@ export function currentModelRef(ctx: Pick<ModelContext, "model">): string | unde
  */
 export function availableModelsInScope(ctx: ModelContext): readonly Model<Api>[] {
 	const models = ctx.modelRegistry.getAvailable();
-	// scopedModels was added after the declared Pi 0.80.6 minimum. Treat a
-	// missing field exactly like an empty scope and use the full live registry.
+	// scopedModels was added after the original Pi minimum. Treat a missing field
+	// exactly like an empty scope and use the full live registry.
 	const scopedModels = ctx.scopedModels ?? [];
 	if (scopedModels.length === 0) return models;
 	const scopedRefs = new Set(scopedModels.map((entry) => modelRef(entry.model)));
 	return models.filter((model) => scopedRefs.has(modelRef(model)));
 }
 
-/** Model refs usable by setup, with an available current main model first. */
-export function availableModelRefs(ctx: ModelContext): string[] {
-	const refs = [...new Set(availableModelsInScope(ctx).map(modelRef))];
-	const currentRef = currentModelRef(ctx);
-	if (!currentRef || !refs.includes(currentRef)) return refs;
-	return [currentRef, ...refs.filter((ref) => ref !== currentRef)];
+export function findModelByRef(
+	models: readonly Model<Api>[],
+	ref: string | undefined,
+): Model<Api> | undefined {
+	const normalized = cleanModelRef(ref);
+	return normalized ? models.find((model) => modelRef(model) === normalized) : undefined;
 }
 
 /**
- * Resolve one agent's ordered runtime pool:
+ * Resolve one agent's runtime route:
  *
- * configured primary -> configured backup -> current main-window model
+ * configured selection -> current main-window model
  *
- * Without a primary override, the current main model remains the primary; an
- * agent-declared default is used only when no main model exists. Equal refs are
- * removed without consulting availability, so stale refs stay in the chain and
- * fail normally at runtime instead of being silently repaired.
+ * Without an override, current main is primary; the agent-declared default is
+ * used only when no main model exists. A configured selection that Pi no longer
+ * reports as available is skipped immediately instead of spawning a doomed child.
  */
-export function resolveAgentModelPool(input: AgentModelPoolInput): ResolvedAgentModelPool {
+export function resolveAgentModelRoute(input: AgentModelRouteInput): ResolvedAgentModelRoute {
+	const selectedRef = cleanModelRef(input.selectedRef);
 	const mainRef = cleanModelRef(input.mainRef);
-	const primaryRef = cleanModelRef(input.primaryRef) ?? mainRef ?? cleanModelRef(input.declaredDefaultRef);
-	const ordered = [primaryRef, cleanModelRef(input.backupRef), mainRef];
-	const seen = new Set<string>();
-	const candidateRefs: string[] = [];
-	for (const ref of ordered) {
-		if (!ref || seen.has(ref)) continue;
-		seen.add(ref);
-		candidateRefs.push(ref);
-	}
-	const fallbackModelRefs = candidateRefs.filter((ref) => ref !== primaryRef);
-	return { primaryRef, fallbackModelRefs, candidateRefs };
+	const declaredDefaultRef = cleanModelRef(input.declaredDefaultRef);
+	const available = input.availableRefs
+		? new Set(input.availableRefs.map((ref) => ref.trim()).filter(Boolean))
+		: undefined;
+	const selectedAvailable = !selectedRef || !available || available.has(selectedRef);
+	const usableSelectedRef = selectedAvailable ? selectedRef : undefined;
+	const primaryRef = usableSelectedRef ?? mainRef ?? declaredDefaultRef;
+	const ordered = [primaryRef, usableSelectedRef && usableSelectedRef !== mainRef ? mainRef : undefined];
+	const candidateRefs = [...new Set(ordered.filter((ref): ref is string => Boolean(ref)))];
+	return {
+		primaryRef,
+		...(candidateRefs[1] ? { mainFallbackRef: candidateRefs[1] } : {}),
+		candidateRefs,
+		...(!selectedAvailable && selectedRef ? { unavailableSelectedRef: selectedRef } : {}),
+	};
+}
+
+/** The exact levels Pi exposes for this model, including `off` when supported. */
+export function supportedThinkingLevels(model: Model<Api> | undefined): ThinkingLevel[] {
+	return model ? (getSupportedThinkingLevels(model) as ThinkingLevel[]) : [];
+}
+
+/** Clamp an agent preference to the effective model's actual capability map. */
+export function resolveThinkingLevel(
+	model: Model<Api> | undefined,
+	preferred: ThinkingLevel = DEFAULT_THINKING_LEVEL,
+): ThinkingLevel {
+	return model ? (clampThinkingLevel(model, preferred) as ThinkingLevel) : preferred;
 }
 
 function modelCapabilities(model: ModelListEntry): string {
-	const capabilities = [model.input.includes("image") ? "vision" : "text-only"];
-	if (model.reasoning) capabilities.push("reasoning");
-	return capabilities.join(" + ");
+	const input = model.input.includes("image") ? "vision" : "text-only";
+	const thinking = getSupportedThinkingLevels(model as Model<Api>).join("/");
+	return `${input} · thinking: ${thinking}`;
 }
 
-/** Build the single searchable model list shared by primary/backup/vision picks.
- * Only refs Pi currently reports as available are shown, which means providers
- * without a configured API key/OAuth session never flood the setup picker. */
+/** Build one searchable list for agent or vision selection. Only models Pi
+ * currently reports as available are supplied by setup. */
 export function buildModelPickerItems(options: {
 	models: readonly ModelListEntry[];
-	availableRefs: readonly string[];
 	slot: ModelPickerSlot;
 	configuredRef?: string;
 	mainRef?: string;
 }): ModelPickerItem[] {
 	const configuredRef = cleanModelRef(options.configuredRef);
 	const mainRef = cleanModelRef(options.mainRef);
-	const available = new Set(options.availableRefs.map((ref) => ref.trim()));
 	const byRef = new Map<string, ModelListEntry>();
 	for (const model of options.models) {
 		const ref = modelRef(model);
-		if (available.has(ref) && !byRef.has(ref)) byRef.set(ref, model);
+		if (!byRef.has(ref)) byRef.set(ref, model);
 	}
 
 	const refs = [...byRef.keys()]
@@ -152,26 +160,18 @@ export function buildModelPickerItems(options: {
 			return leftRank - rightRank || left.localeCompare(right);
 		});
 
-	const dynamic = options.slot === "backup"
-		? {
-			value: CURRENT_MAIN_MODEL,
-			label: "Current main model (default)",
-			description: "Clear configured backup; use the main-window model dynamically",
-		}
-		: {
-			value: CURRENT_MAIN_MODEL,
-			label: "Current main model (dynamic)",
-			description: options.slot === "vision"
-				? "Clear vision override; use the main-window model for vision tasks"
-				: "Clear primary override; use the main-window model dynamically",
-		};
-
+	const dynamic: ModelPickerItem = {
+		value: CURRENT_MAIN_MODEL,
+		label: "Current main model (dynamic)",
+		description: options.slot === "vision"
+			? "Clear vision override; use the current main model for image tasks"
+			: "Clear agent override; use the current main model dynamically",
+	};
 	const items: ModelPickerItem[] = [dynamic];
 	for (const ref of refs) {
 		const model = byRef.get(ref)!;
-		const tags = ["available"];
-		if (ref === configuredRef) tags.push("configured");
-		if (ref === mainRef) tags.push("current main");
+		const tags = [ref === configuredRef ? "configured" : "", ref === mainRef ? "current main" : ""]
+			.filter(Boolean);
 		const name = model.name.trim() && model.name !== model.id ? model.name.trim() : undefined;
 		items.push({
 			value: ref,
@@ -182,31 +182,14 @@ export function buildModelPickerItems(options: {
 	return items;
 }
 
-/** Pure pool update: the dynamic/default choice removes the persisted override. */
-export function applyModelPoolChoice(
-	current: AgentModelPoolMaps,
+/** The dynamic choice removes the persisted per-agent override. */
+export function applyAgentModelChoice(
+	current: Record<string, string>,
 	agentName: string,
-	slot: ModelPoolSlot,
 	choice: string,
-): AgentModelPoolMaps {
-	const next: AgentModelPoolMaps = {
-		agentModels: { ...current.agentModels },
-		agentBackupModels: { ...current.agentBackupModels },
-	};
-	const target = slot === "primary" ? next.agentModels : next.agentBackupModels;
-	if (choice === CURRENT_MAIN_MODEL) delete target[agentName];
-	else target[agentName] = choice.trim();
+): Record<string, string> {
+	const next = { ...current };
+	if (choice === CURRENT_MAIN_MODEL) delete next[agentName];
+	else next[agentName] = choice.trim();
 	return next;
 }
-
-/** Pure rows used by the overview component and focused helper tests. */
-export function buildAgentModelPoolRows(
-	agentNames: readonly string[],
-	pools: AgentModelPoolMaps,
-): AgentModelPoolRow[] {
-	return agentNames.map((name) => ({
-		name,
-		primary: pools.agentModels[name] ?? "Main (dynamic)",
-		backup: pools.agentBackupModels[name] ?? "Main (default)",
-	}));
-}