@xynogen/pix-subagent 0.1.3 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-subagent",
-	"version": "0.1.3",
+	"version": "0.2.0",
 	"description": "Pi tool — planner-driven sub-agents: spawn, fetch, steer scoped child agents",
 	"type": "module",
 	"main": "src/index.ts",
@@ -36,7 +36,8 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@sinclair/typebox": "^0.34.0"
+		"@sinclair/typebox": "^0.34.0",
+		"@xynogen/pix-data": "*"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-coding-agent": "*",

package/src/agent-manager.ts

@@ -180,6 +180,8 @@ export class AgentManager {
 			abortController,
 			lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
 			compactionCount: 0,
+			turnCount: 0,
+			maxTurns: options.maxTurns,
 			invocation: options.invocation,
 		};
 		this.agents.set(id, record);
@@ -258,7 +260,10 @@ export class AgentManager {
 				if (activity.type === "end") record.toolUses++;
 				options.onToolActivity?.(activity);
 			},
-			onTurnEnd: options.onTurnEnd,
+			onTurnEnd: (turnCount) => {
+				record.turnCount = turnCount;
+				options.onTurnEnd?.(turnCount);
+			},
 			onTextDelta: options.onTextDelta,
 			onAssistantUsage: (usage) => {
 				addUsage(record.lifetimeUsage, usage);

package/src/index.ts

@@ -135,8 +135,11 @@ export default function registerPixSubagent(pi: ExtensionAPI): void {
 			widget.update();
 		},
 		4, // maxConcurrent
-		// onStart
+		// onStart — re-arm the 80ms spinner loop. update() clears the timer when
+		// the last agent finishes; a fresh spawn mid-turn (no new turn_start) must
+		// restart it or the spinner freezes on one frame.
 		(_record) => {
+			widget.ensureTimer();
 			widget.update();
 		},
 	);

package/src/model-resolver.ts

@@ -2,6 +2,8 @@
  * Model resolution: exact match ("provider/modelId") with fuzzy fallback.
  */
 
+import { lookupBenchmark, lookupModelsDev } from "@xynogen/pix-data";
+
 export interface ModelEntry {
 	id: string;
 	name: string;
@@ -91,8 +93,71 @@ export function resolveModel(
 	return `Model not found: "${input}".\n\nAvailable models:\n${modelList}`;
 }
 
-/** List available models as "provider/id" strings (for tool-description injection). */
+// ── Enrichment for orchestrator model choice ────────────────────────────────
+// The orchestrator picks a worker model from the `agent` tool description. Bare
+// ids carry no signal, so each line is annotated with bench score, context,
+// price, and a coarse tier — sourced from pix-data (the shared data layer).
+
+const SCORE_FRONTIER = 88;
+const SCORE_STRONG = 75;
+const CHEAP_OUTPUT_PRICE = 3; // $/M output tokens — below this counts as cheap
+
+/** Context window → compact "200k" / "1M". */
+function fmtCtx(n: number | undefined): string {
+	if (!n || n < 1_000) return n ? `${n}` : "";
+	if (n >= 1_000_000) {
+		const m = n / 1_000_000;
+		return `${Number.isInteger(m) ? m : m.toFixed(1).replace(/\.0$/, "")}M ctx`;
+	}
+	return `${Math.round(n / 1_000)}k ctx`;
+}
+
+/** Cost → "$3/$15" (input/output per Mtok), "free", or "" when unknown. */
+function fmtCost(input?: number, output?: number): string {
+	if (input == null && output == null) return "";
+	const i = input ?? 0;
+	const o = output ?? 0;
+	if (i === 0 && o === 0) return "free";
+	return `$${i}/$${o}`;
+}
+
+/** Coarse decision tier from score + output price. */
+function tier(score: number | null | undefined, output?: number): string {
+	if (typeof score !== "number") return "";
+	if (score >= SCORE_FRONTIER) return "frontier";
+	if (score >= SCORE_STRONG) return "strong";
+	if (output != null && output <= CHEAP_OUTPUT_PRICE) return "fast-cheap";
+	return "basic";
+}
+
+/** One enriched line: "provider/id  — ⚡95 · 200k ctx · $3/$15 · frontier". */
+function annotate(m: ModelEntry): { line: string; score: number } {
+	const dev = lookupModelsDev(m.provider, m.id);
+	const bench = lookupBenchmark(m.name ?? m.id);
+	const score = bench?.overallScore ?? null;
+	const out = bench?.outputPrice ?? dev?.cost?.output;
+	const segs = [
+		typeof score === "number" ? `⚡${score}` : "",
+		fmtCtx(dev?.limit?.context),
+		fmtCost(bench?.inputPrice ?? dev?.cost?.input, out),
+		tier(score, out),
+	].filter(Boolean);
+	const id = `${m.provider}/${m.id}`;
+	return {
+		line: segs.length ? `${id}  — ${segs.join(" · ")}` : id,
+		score: score ?? -1,
+	};
+}
+
+/**
+ * List available models, enriched + ranked for orchestrator decisions.
+ * Sorted by bench score desc (best first); unscored fall to the bottom
+ * alphabetically (preserved by the stable id tiebreak).
+ */
 export function listAvailable(registry: ModelRegistry): string[] {
 	const all = (registry.getAvailable?.() ?? registry.getAll()) as ModelEntry[];
-	return all.map((m) => `${m.provider}/${m.id}`).sort();
+	return all
+		.map((m) => ({ ...annotate(m), id: `${m.provider}/${m.id}` }))
+		.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id))
+		.map((r) => r.line);
 }

package/src/tools.ts

@@ -29,7 +29,11 @@ import {
 import { resolveAgentInvocationConfig } from "./invocation-config.ts";
 import { resolveModel } from "./model-resolver.ts";
 import type { AgentInvocation, LifetimeUsage } from "./types.ts";
-import { getLifetimeTotal } from "./usage.ts";
+import {
+	getLifetimeTotal,
+	getSessionContextPercent,
+	type SessionLike,
+} from "./usage.ts";
 
 // ── Types shared with ui/widget.ts (widget imports from here to avoid circular) ─
 
@@ -54,6 +58,10 @@ export interface AgentDetails {
 	subagentType: string;
 	toolUses: number;
 	tokens: string;
+	/** Context-window utilization 0–100, or null/undefined when unavailable. */
+	contextPercent?: number | null;
+	/** Raw output tokens — for t/s = outputTokens / durationMs. */
+	outputTokens?: number;
 	durationMs: number;
 	status:
 		| "queued"
@@ -106,6 +114,15 @@ export function formatMs(ms: number): string {
 	return `${(ms / 1000).toFixed(1)}s`;
 }
 
+/**
+ * Output tokens per second over a duration. "" when either input is
+ * non-positive (no work / zero elapsed) so callers can skip the segment.
+ */
+export function formatSpeed(outputTokens: number, durationMs: number): string {
+	if (outputTokens <= 0 || durationMs <= 0) return "";
+	return `${Math.round(outputTokens / (durationMs / 1000))} t/s`;
+}
+
 // ── helpers ──────────────────────────────────────────────────────────────────
 
 function textResult(msg: string, details?: AgentDetails) {
@@ -137,7 +154,13 @@ function buildStats(d: AgentDetails, theme: Theme): string {
 		parts.push(
 			theme.fg("dim", `${d.toolUses} tool use${d.toolUses === 1 ? "" : "s"}`),
 		);
-	if (d.tokens) parts.push(theme.fg("dim", d.tokens));
+	if (d.tokens) {
+		const pct =
+			d.contextPercent != null
+				? ` ${theme.fg("dim", `(${Math.round(d.contextPercent)}%)`)}`
+				: "";
+		parts.push(theme.fg("dim", d.tokens) + pct);
+	}
 	return parts.join(` ${theme.fg("dim", "·")} `);
 }
 
@@ -314,21 +337,34 @@ export function createAgentTool(
 				);
 			}
 
-			// Completed / steered
+			// Completed / steered. Collapsed view stays empty — the ● Agents widget
+			// carries the full finished line, so the inline transcript doesn't echo
+			// it (caller shouldn't output the result). Expanded view still shows the
+			// summary + full output on demand.
 			if (details.status === "completed" || details.status === "steered") {
+				if (!expanded) return new Text("", 0, 0);
 				const duration = formatMs(details.durationMs);
 				const isSteered = details.status === "steered";
 				const icon = isSteered
 					? theme.fg("warning", "✓")
 					: theme.fg("success", "✓");
+				const speed = formatSpeed(
+					details.outputTokens ?? 0,
+					details.durationMs,
+				);
 				let line =
 					icon +
 					(stats ? ` ${stats}` : "") +
 					" " +
 					theme.fg("dim", "·") +
 					" " +
-					theme.fg("dim", duration);
+					theme.fg("dim", duration) +
+					(speed ? ` ${theme.fg("dim", "·")} ${theme.fg("dim", speed)}` : "") +
+					// Steered = stopped at turn limit; keep that note inline since the
+					// stats alone don't say why it ended.
+					(isSteered ? ` ${theme.fg("warning", "(turn limit)")}` : "");
 
+				// Expanded view appends the full result below the one-line summary.
 				if (expanded) {
 					const resultText =
 						result.content[0]?.type === "text" ? result.content[0].text : "";
@@ -343,13 +379,6 @@ export function createAgentTool(
 									"  … (use agent_result with verbose for full output)",
 								);
 					}
-				} else {
-					line +=
-						"\n" +
-						theme.fg(
-							"dim",
-							`  ⎿  ${isSteered ? "Wrapped up (turn limit)" : "Done"}`,
-						);
 				}
 				return new Text(line, 0, 0);
 			}
@@ -804,10 +833,15 @@ function buildDetails(
 	activity?: AgentActivity & { durationMs?: number },
 ): AgentDetails {
 	const totalTokens = getLifetimeTotal(record.lifetimeUsage);
+	const contextPercent = activity?.session
+		? getSessionContextPercent(activity.session as SessionLike)
+		: null;
 	return {
 		...base,
 		toolUses: record.toolUses,
 		tokens: totalTokens > 0 ? formatTokens(totalTokens) : "",
+		contextPercent,
+		outputTokens: record.lifetimeUsage.output,
 		turnCount: activity?.turnCount,
 		maxTurns: activity?.maxTurns,
 		durationMs:

package/src/types.ts

@@ -89,6 +89,11 @@ export interface AgentRecord {
 	lifetimeUsage: LifetimeUsage;
 	/** Number of times this agent's session has compacted. */
 	compactionCount: number;
+	/** Cumulative agentic turns. Persisted on the record so the finished widget
+	 * line stays full after agentActivity is cleared on completion. */
+	turnCount: number;
+	/** Turn cap, if any — for the ↻N≤M display. */
+	maxTurns?: number;
 	/** Resolved spawn params, captured for UI display. */
 	invocation?: AgentInvocation;
 }

package/src/ui/widget.ts

@@ -12,12 +12,22 @@ import { truncateToWidth } from "@earendil-works/pi-tui";
 import type { AgentManager } from "../agent-manager.ts";
 import { getConfig } from "../agent-types.ts";
 import type { AgentActivity, AgentDetails, Theme } from "../tools.ts";
-import { formatMs, formatTokens, formatTurns, SPINNER } from "../tools.ts";
+import {
+	formatMs,
+	formatSpeed,
+	formatTokens,
+	formatTurns,
+	SPINNER,
+} from "../tools.ts";
 import type { AgentInvocation, SubagentType } from "../types.ts";
-import { getLifetimeTotal, getSessionContextPercent } from "../usage.ts";
+import {
+	getLifetimeTotal,
+	getSessionContextPercent,
+	type SessionLike,
+} from "../usage.ts";
 
 export type { AgentActivity, AgentDetails, Theme };
-export { formatMs, formatTokens, formatTurns, SPINNER };
+export { formatMs, formatSpeed, formatTokens, formatTurns, SPINNER };
 
 // ── constants ─────────────────────────────────────────────────────────────────
 
@@ -97,14 +107,16 @@ export function buildInvocationTags(invocation: AgentInvocation | undefined): {
 	return { modelName: invocation.modelName, tags };
 }
 
-function truncateLine(text: string, len = 60): string {
-	const line =
-		text
-			.split("\n")
-			.find((l) => l.trim())
-			?.trim() ?? "";
+/**
+ * Live tail of agent output: latest non-empty line, tail-anchored to `len`
+ * chars (keeps the moving edge, not the stale first line). Leading … marks
+ * the clip. e.g. "…ting batch 6".
+ */
+function truncateLine(text: string, len = 16): string {
+	const lines = text.split("\n").filter((l) => l.trim());
+	const line = lines.length ? lines[lines.length - 1].trim() : "";
 	if (line.length <= len) return line;
-	return `${line.slice(0, len)}…`;
+	return `…${line.slice(-len)}`;
 }
 
 export function describeActivity(
@@ -184,12 +196,18 @@ export class AgentWidget {
 			completedAt?: number;
 			error?: string;
 			invocation?: AgentInvocation;
+			lifetimeUsage?: { input: number; output: number; cacheWrite: number };
+			session?: unknown;
+			compactionCount?: number;
+			turnCount?: number;
+			maxTurns?: number;
 		},
 		theme: Theme,
 	): string {
 		const name = getDisplayName(a.type);
 		const modeLabel = getPromptModeLabel(a.type);
-		const duration = formatMs((a.completedAt ?? Date.now()) - a.startedAt);
+		const durationMs = (a.completedAt ?? Date.now()) - a.startedAt;
+		const duration = formatMs(durationMs);
 
 		// model label (the pix twist — always shown)
 		const modelLabel = a.invocation?.modelName
@@ -218,12 +236,31 @@ export class AgentWidget {
 		}
 
 		const parts: string[] = [];
-		const activity = this.agentActivity.get(a.id);
-		if (activity)
-			parts.push(formatTurns(activity.turnCount, activity.maxTurns));
+		// Turns read from the record (a.*), not agentActivity — onComplete deletes
+		// the activity entry before this line renders, which had dropped ↻N.
+		if (a.turnCount != null && a.turnCount > 0)
+			parts.push(formatTurns(a.turnCount, a.maxTurns));
 		if (a.toolUses > 0)
 			parts.push(`${a.toolUses} tool use${a.toolUses === 1 ? "" : "s"}`);
+		// Token + context% + speed read from the record (survives the
+		// agentActivity delete that fires in onComplete before this renders).
+		const tokens = getLifetimeTotal(a.lifetimeUsage);
+		if (tokens > 0) {
+			const contextPercent = a.session
+				? getSessionContextPercent(a.session as SessionLike)
+				: null;
+			parts.push(
+				formatSessionTokens(
+					tokens,
+					contextPercent,
+					theme,
+					a.compactionCount ?? 0,
+				),
+			);
+		}
 		parts.push(duration);
+		const speed = formatSpeed(a.lifetimeUsage?.output ?? 0, durationMs);
+		if (speed) parts.push(speed);
 
 		return `${icon} ${theme.fg("dim", name)}${modelLabel}${modeTag}  ${theme.fg("dim", a.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", parts.join(" · "))}${statusText}`;
 	}
@@ -250,7 +287,8 @@ export class AgentWidget {
 		const truncate = (line: string) => truncateToWidth(line, w);
 		const hasActive = running.length > 0 || queued.length > 0;
 		const headingColor = hasActive ? "accent" : "dim";
-		const headingIcon = hasActive ? "●" : "○";
+		// ○ hollow = incomplete (still running), ● filled disk = complete (all done).
+		const headingIcon = hasActive ? "○" : "●";
 		const frame = SPINNER[this.widgetFrame % SPINNER.length];
 
 		const finishedLines: string[] = [];
@@ -262,7 +300,7 @@ export class AgentWidget {
 			);
 		}
 
-		const runningLines: string[][] = [];
+		const runningLines: string[] = [];
 		for (const a of running) {
 			const name = getDisplayName(a.type);
 			const modeLabel = getPromptModeLabel(a.type);
@@ -297,19 +335,26 @@ export class AgentWidget {
 				parts.push(`${toolUses} tool use${toolUses === 1 ? "" : "s"}`);
 			if (tokenText) parts.push(tokenText);
 			parts.push(elapsed);
+			const liveSpeed = formatSpeed(
+				bg?.lifetimeUsage.output ?? 0,
+				Date.now() - a.startedAt,
+			);
+			if (liveSpeed) parts.push(liveSpeed);
 			const statsText = parts.join(" · ");
 
+			// Activity leads (next to the spinner — the moving part by the moving
+			// part), then static identity + cumulative stats. One line per agent so
+			// many concurrent workers stay readable instead of doubling the height.
 			const activity = bg
 				? describeActivity(bg.activeTools, bg.responseText)
 				: "thinking…";
 
-			runningLines.push([
+			runningLines.push(
 				truncate(
 					theme.fg("dim", "├─") +
-						` ${theme.fg("accent", frame)} ${theme.bold(name)}${modelLabel}${modeTag}  ${theme.fg("muted", a.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", statsText)}`,
+						` ${theme.fg("accent", frame)} ${theme.fg("dim", activity)} ${theme.fg("dim", "·")} ${theme.bold(name)}${modelLabel}${modeTag}  ${theme.fg("muted", a.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", statsText)}`,
 				),
-				truncate(theme.fg("dim", "│  ") + theme.fg("dim", `  ⎿  ${activity}`)),
-			]);
+			);
 		}
 
 		const queuedLine =
@@ -322,7 +367,7 @@ export class AgentWidget {
 
 		const maxBody = MAX_WIDGET_LINES - 1;
 		const totalBody =
-			finishedLines.length + runningLines.length * 2 + (queuedLine ? 1 : 0);
+			finishedLines.length + runningLines.length + (queuedLine ? 1 : 0);
 
 		const lines: string[] = [
 			truncate(
@@ -334,27 +379,23 @@ export class AgentWidget {
 
 		if (totalBody <= maxBody) {
 			lines.push(...finishedLines);
-			for (const pair of runningLines) lines.push(...pair);
+			lines.push(...runningLines);
 			if (queuedLine) lines.push(queuedLine);
 
 			// Fix last connector ├─ → └─
 			if (lines.length > 1) {
 				const last = lines.length - 1;
 				lines[last] = lines[last].replace("├─", "└─");
-				if (runningLines.length > 0 && !queuedLine && last >= 2) {
-					lines[last - 1] = lines[last - 1].replace("├─", "└─");
-					lines[last] = lines[last].replace("│  ", "   ");
-				}
 			}
 		} else {
 			let budget = maxBody - 1;
 			let hiddenRunning = 0;
 			let hiddenFinished = 0;
 
-			for (const pair of runningLines) {
-				if (budget >= 2) {
-					lines.push(...pair);
-					budget -= 2;
+			for (const line of runningLines) {
+				if (budget >= 1) {
+					lines.push(line);
+					budget--;
 				} else {
 					hiddenRunning++;
 				}