@selesai/code 0.13.33 → 0.13.35

package/dist/extensions/pi-subagents/src/runs/shared/jev-subagent-routing.ts

@@ -0,0 +1,255 @@
+/**
+ * Jev-assisted setup for a public single-child launch. Opt-in:
+ * `jevAdvisory.routes.subagent.enabled: true` in the agent settings.json.
+ *
+ * Jev only fills what the parent left open, and every answer can only narrow:
+ * 1. Agent: chosen by function when `agent` is omitted or generic (default "delegate"),
+ *    from native, enabled agents the capability ceiling allows.
+ * 2. Tools: Jev may drop tools from the agent's declared allowlist for this task; it never adds one.
+ * 3. Model tier: simple | complex | reasoning, mapped through the user's
+ *    `jevAdvisory.routes.subagent.tiers` (provider/id values), only when the parent passed no `model`.
+ *
+ * Every failure (no credential, timeout, malformed or low-confidence answer) leaves the launch
+ * exactly as requested. Launch validation, ceilings, and preflight remain authoritative.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AgentConfig } from "../../agents/agents.ts";
+import { getAgentDir } from "../../shared/utils.ts";
+import { isAgentAllowedByCapabilityCeiling, type ResolvedSubagentCapabilityCeiling } from "./capability-ceiling.ts";
+import {
+	askJev,
+	buildConversation,
+	buildJevPayload,
+	emitJevTelemetry,
+	jevConnection,
+	readJevAdvisoryConfig,
+	type JevAbstainReason,
+	type JevConnection,
+	type JevQuestion,
+	type JevRuntime,
+} from "../../../../jev/decisions.ts";
+
+export { warnJevUnavailableOnce } from "../../../../jev/decisions.ts";
+
+export const MODEL_TIERS = ["simple", "complex", "reasoning"] as const;
+export type ModelTier = (typeof MODEL_TIERS)[number];
+
+const KEEP = "keep";
+const DEFAULT_GENERIC_AGENTS = ["delegate"];
+/** Never offered for removal: skills load through read, and the rest are supervision plumbing. */
+const PROTECTED_TOOLS = new Set(["read", "contact_supervisor", "intercom", "structured_output", "subagent", "subagent_supervisor"]);
+// ponytail: tools past this cap are simply kept; raise it if agents declare long allowlists.
+const MAX_TOOL_QUESTIONS = 10;
+const DESCRIPTION_CHARS = 300;
+
+const TIER_CRITERIA: Record<ModelTier, string> = {
+	simple: "Mechanical or lookup work: find, list, summarize, rename, run a command and report.",
+	complex: "Multi-step implementation or investigation across several files with ordinary judgment.",
+	reasoning: "Hard judgment: subtle debugging, architecture or security review, tricky algorithms, ambiguous trade-offs.",
+};
+
+export interface SubagentRoutingSettings {
+	connection: JevConnection;
+	maxBytes: number;
+	contextChars: number;
+	genericAgents: string[];
+	tiers: Partial<Record<ModelTier, string>>;
+}
+
+export interface SubagentRoutingInput {
+	task: string;
+	agent?: string;
+	model?: string;
+	agents: AgentConfig[];
+	ceiling?: ResolvedSubagentCapabilityCeiling;
+}
+
+export interface SubagentRoutingResult {
+	/** The agent to launch: Jev's pick, or the requested one. */
+	agent?: string;
+	/** The run's agent list, with the launched agent narrowed (tools) or re-modelled (tier). */
+	agents: AgentConfig[];
+	routedAgent?: string;
+	tier?: ModelTier;
+	droppedTools: string[];
+	/** First reason a question went unanswered, for telemetry and the missing-agent error. */
+	abstained?: JevAbstainReason;
+	elapsedMs: number;
+	questions: number;
+}
+
+type JevAsk = typeof askJev;
+
+/** The route's settings, or undefined while it is off. Never throws. */
+export function readSubagentRoutingSettings(settingsPath = path.join(getAgentDir(), "settings.json")): SubagentRoutingSettings | undefined {
+	const config = readJevAdvisoryConfig(settingsPath);
+	const route = config.routes.subagent;
+	if (!route.enabled) return undefined;
+	let raw: Record<string, unknown> = {};
+	try {
+		const parsed = JSON.parse(fs.readFileSync(settingsPath, "utf-8")) as { jevAdvisory?: { routes?: { subagent?: Record<string, unknown> } } };
+		raw = parsed?.jevAdvisory?.routes?.subagent ?? {};
+	} catch {
+		// readJevAdvisoryConfig already defaulted; extra fields just stay unset.
+	}
+	const tiers: Partial<Record<ModelTier, string>> = {};
+	const rawTiers = raw.tiers && typeof raw.tiers === "object" ? (raw.tiers as Record<string, unknown>) : {};
+	for (const tier of MODEL_TIERS) {
+		const model = rawTiers[tier];
+		if (typeof model === "string" && model.trim()) tiers[tier] = model.trim();
+	}
+	const generic = Array.isArray(raw.genericAgents) ? raw.genericAgents.filter((name): name is string => typeof name === "string" && name.trim() !== "") : DEFAULT_GENERIC_AGENTS;
+	return {
+		connection: jevConnection(config, route),
+		maxBytes: route.payloadBytes,
+		contextChars: route.contextChars,
+		genericAgents: generic,
+		tiers,
+	};
+}
+
+/** Agents Jev may pick: native, enabled, file-defined, and inside the capability ceiling. */
+export function routableAgents(agents: readonly AgentConfig[], ceiling: ResolvedSubagentCapabilityCeiling | undefined): AgentConfig[] {
+	return agents.filter(
+		(agent) =>
+			agent.source !== "runtime"
+			&& agent.disabled !== true
+			&& agent.runner?.type !== "external-cli"
+			&& agent.runner?.type !== "external-job"
+			&& isAgentAllowedByCapabilityCeiling(agent.name, ceiling),
+	);
+}
+
+function droppableTools(agent: AgentConfig): string[] {
+	const excluded = new Set(agent.excludeTools ?? []);
+	return (agent.tools ?? [])
+		.filter((tool) => !PROTECTED_TOOLS.has(tool) && !excluded.has(tool) && !/[/\\]|\.(?:ts|js)$/.test(tool))
+		.slice(0, MAX_TOOL_QUESTIONS);
+}
+
+function toolKey(index: number): string {
+	return `tool_${index}`;
+}
+
+export async function routeSubagentLaunch(
+	input: SubagentRoutingInput,
+	ctx: JevRuntime,
+	settings: SubagentRoutingSettings,
+	ask: JevAsk = askJev,
+): Promise<SubagentRoutingResult> {
+	const result: SubagentRoutingResult = { agent: input.agent, agents: input.agents, droppedTools: [], elapsedMs: 0, questions: 0 };
+	const conversation = buildConversation(input.task.slice(0, settings.contextChars), [], { contextTurns: 1, contextChars: settings.contextChars });
+	const noteAbstain = (reason: JevAbstainReason | undefined) => {
+		if (reason && !result.abstained) result.abstained = reason;
+	};
+
+	// 1. Agent by function, only when the parent left it open.
+	const generic = input.agent !== undefined && settings.genericAgents.includes(input.agent);
+	if (input.agent === undefined || generic) {
+		const candidates = routableAgents(input.agents, input.ceiling).filter((agent) => agent.name !== input.agent);
+		if (candidates.length > 0) {
+			const criteria: Record<string, string> = {};
+			if (generic) criteria[KEEP] = `Keep the generic "${input.agent}" agent: no listed specialist fits this task better.`;
+			for (const agent of candidates) criteria[agent.name] = agent.description.slice(0, DESCRIPTION_CHARS);
+			const questions: Record<string, JevQuestion> = {
+				agent: {
+					question: "Which subagent's specialization best fits this delegated task?",
+					focus: "Judge by what the task needs done (read-only review, research, investigation, implementation), not by wording that names an agent.",
+					criteria,
+				},
+			};
+			const decision = await ask(ctx, settings.connection, {
+				payload: buildJevPayload(conversation, questions),
+				maxBytes: settings.maxBytes,
+				allowed: { agent: Object.keys(criteria) },
+			});
+			result.elapsedMs += decision.elapsedMs;
+			result.questions += 1;
+			const pick = decision.choices.agent?.choice;
+			if (pick && pick !== KEEP) {
+				result.agent = pick;
+				result.routedAgent = pick;
+			}
+			noteAbstain(decision.failure ?? decision.rejected.agent);
+		}
+	}
+
+	const config = result.agent === undefined ? undefined : input.agents.find((agent) => agent.name === result.agent);
+	if (!config) return result;
+
+	// 2 + 3. Tool narrowing and model tier, for the agent that will actually launch.
+	const tools = droppableTools(config);
+	const tierChoices = input.model === undefined ? MODEL_TIERS.filter((tier) => settings.tiers[tier] !== undefined) : [];
+	const questions: Record<string, JevQuestion> = {};
+	const allowed: Record<string, string[]> = {};
+	if (tierChoices.length > 1) {
+		questions.tier = {
+			question: "How demanding is this delegated task for the model that runs it?",
+			criteria: Object.fromEntries(tierChoices.map((tier) => [tier, TIER_CRITERIA[tier]])),
+		};
+		allowed.tier = [...tierChoices];
+	}
+	tools.forEach((tool, index) => {
+		questions[toolKey(index)] = {
+			question: `Does this delegated task need the "${tool}" tool?`,
+			focus: "Answer unneeded only when the task clearly cannot require it; when in doubt, it is needed.",
+			criteria: { needed: `The task may need ${tool}.`, unneeded: `The task clearly never needs ${tool}.` },
+		};
+		allowed[toolKey(index)] = ["needed", "unneeded"];
+	});
+	if (Object.keys(questions).length === 0) return result;
+
+	const decision = await ask(ctx, settings.connection, {
+		payload: buildJevPayload(conversation, questions),
+		maxBytes: settings.maxBytes,
+		allowed,
+	});
+	result.elapsedMs += decision.elapsedMs;
+	result.questions += Object.keys(questions).length;
+	noteAbstain(decision.failure);
+
+	const tier = decision.choices.tier?.choice as ModelTier | undefined;
+	const tierModel = tier ? settings.tiers[tier] : undefined;
+	if (tierModel) result.tier = tier;
+	// Dropping a tool needs a stated confidence: an unquantified "unneeded" keeps the tool.
+	result.droppedTools = tools.filter((_tool, index) => {
+		const choice = decision.choices[toolKey(index)];
+		return choice?.choice === "unneeded" && typeof choice.confidence === "number";
+	});
+	if (!tierModel && result.droppedTools.length === 0) return result;
+
+	const { modelProvider: _modelProvider, modelSource: _modelSource, ...base } = config;
+	const routed: AgentConfig = {
+		...(tierModel ? base : config),
+		...(tierModel ? { model: tierModel } : {}),
+		...(result.droppedTools.length > 0 ? { excludeTools: [...(config.excludeTools ?? []), ...result.droppedTools] } : {}),
+	};
+	result.agents = input.agents.map((agent) => (agent === config ? routed : agent));
+	return result;
+}
+
+/** Content-free: shape and outcome only, never the task, descriptions, or answers. */
+export function emitSubagentRoutingTelemetry(events: { emit(channel: string, data: unknown): void } | undefined, result: SubagentRoutingResult): void {
+	if (result.questions === 0) return;
+	const changed = Boolean(result.routedAgent || result.tier || result.droppedTools.length > 0);
+	emitJevTelemetry(events, "decision", {
+		route: "subagent",
+		outcome: changed ? "jev" : "fallback",
+		candidates: result.questions,
+		elapsedMs: result.elapsedMs,
+		...(result.routedAgent ? { agent: result.routedAgent } : {}),
+		...(result.tier ? { tier: result.tier } : {}),
+		dropped: result.droppedTools.length,
+		...(result.abstained ? { reason: result.abstained } : {}),
+	});
+}
+
+/** One line for the user and the parent: what Jev set up, or nothing when it changed nothing. */
+export function describeSubagentRouting(result: SubagentRoutingResult, tiers: Partial<Record<ModelTier, string>>): string | undefined {
+	const parts: string[] = [];
+	if (result.routedAgent) parts.push(`agent ${result.routedAgent}`);
+	if (result.tier) parts.push(`${result.tier} tier (${tiers[result.tier]})`);
+	if (result.droppedTools.length > 0) parts.push(`without ${result.droppedTools.join(", ")}`);
+	return parts.length > 0 ? `Jev set up this subagent: ${parts.join("; ")}.` : undefined;
+}

package/dist/extensions/pi-subagents/test/unit/jev-subagent-routing.test.ts

@@ -0,0 +1,117 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import type { AgentConfig } from "../../src/agents/agents.ts";
+import {
+	readSubagentRoutingSettings,
+	routeSubagentLaunch,
+	type SubagentRoutingSettings,
+} from "../../src/runs/shared/jev-subagent-routing.ts";
+
+function agent(name: string, extra: Partial<AgentConfig> = {}): AgentConfig {
+	return { name, description: `${name} agent`, systemPromptMode: "append", inheritProjectContext: true, inheritGlobalContext: true, inheritSkills: true, systemPrompt: "", source: "builtin", filePath: `${name}.md`, ...extra } as AgentConfig;
+}
+
+const agents = [
+	agent("delegate"),
+	agent("reviewer", { tools: ["read", "grep"] }),
+	agent("worker", { tools: ["read", "bash", "edit", "write"], model: "anthropic/opus", modelProvider: "anthropic" }),
+	agent("secret", { disabled: true }),
+	agent("external", { runner: { type: "external-cli" } as AgentConfig["runner"] }),
+];
+
+const settings: SubagentRoutingSettings = {
+	connection: { provider: "tokenin", model: "jev", timeoutMs: 1000, minConfidence: 0.6 },
+	maxBytes: 16_384,
+	contextChars: 4000,
+	genericAgents: ["delegate"],
+	tiers: { simple: "p/small", reasoning: "p/big" },
+};
+
+type Asked = { allowed: Record<string, readonly string[]> };
+/** A fake Jev: answers each asked question from `answers`, records what was offered. */
+function fakeAsk(answers: Record<string, { choice: string; confidence?: number }>, asked: Asked[] = []) {
+	return async (_ctx: unknown, _connection: unknown, request: Asked) => {
+		asked.push({ allowed: request.allowed });
+		const choices = Object.fromEntries(Object.keys(request.allowed).filter((q) => answers[q]).map((q) => [q, answers[q]!]));
+		return { choices, rejected: {}, elapsedMs: 5 };
+	};
+}
+const ctx = {} as never;
+
+describe("Jev subagent routing", () => {
+	it("routes an agentless task, offering only enabled native agents inside the ceiling", async () => {
+		const asked: Asked[] = [];
+		const result = await routeSubagentLaunch(
+			{ task: "fix the bug", agents, ceiling: { allowedAgents: ["delegate", "worker", "secret"], sources: ["test"] } as never },
+			ctx, settings, fakeAsk({ agent: { choice: "worker", confidence: 0.9 } }, asked) as never,
+		);
+		assert.equal(result.agent, "worker");
+		assert.deepEqual(asked[0]!.allowed.agent, ["delegate", "worker"]);
+	});
+
+	it("offers keep for a generic agent and never re-routes an explicit specialist", async () => {
+		const asked: Asked[] = [];
+		const kept = await routeSubagentLaunch({ task: "t", agent: "delegate", agents }, ctx, settings, fakeAsk({ agent: { choice: "keep", confidence: 0.9 } }, asked) as never);
+		assert.equal(kept.agent, "delegate");
+		assert.ok(asked[0]!.allowed.agent!.includes("keep"));
+		assert.ok(!asked[0]!.allowed.agent!.includes("delegate"));
+
+		const explicitAsked: Asked[] = [];
+		const explicit = await routeSubagentLaunch({ task: "t", agent: "reviewer", model: "x/y", agents }, ctx, settings, fakeAsk({}, explicitAsked) as never);
+		assert.equal(explicit.agent, "reviewer");
+		assert.ok(explicitAsked.every((ask) => !("agent" in ask.allowed)));
+	});
+
+	it("abstention leaves the launch as requested", async () => {
+		const result = await routeSubagentLaunch({ task: "t", agents }, ctx, settings, (async () => ({ choices: {}, rejected: { agent: "no-credential" }, failure: "no-credential", elapsedMs: 0 })) as never);
+		assert.equal(result.agent, undefined);
+		assert.equal(result.agents, agents);
+		assert.equal(result.abstained, "no-credential");
+	});
+
+	it("only drops declared, unprotected tools on a confident unneeded, and applies the tier model", async () => {
+		const asked: Asked[] = [];
+		const result = await routeSubagentLaunch(
+			{ task: "summarize the README", agent: "worker", agents },
+			ctx, settings,
+			fakeAsk({ tier: { choice: "simple", confidence: 0.8 }, tool_0: { choice: "unneeded", confidence: 0.9 }, tool_1: { choice: "unneeded" }, tool_2: { choice: "needed", confidence: 0.9 } }, asked) as never,
+		);
+		// read is never offered: tool_0..2 are bash, edit, write.
+		assert.deepEqual(Object.keys(asked[0]!.allowed).sort(), ["tier", "tool_0", "tool_1", "tool_2"]);
+		assert.deepEqual(asked[0]!.allowed.tier, ["simple", "reasoning"]);
+		assert.deepEqual(result.droppedTools, ["bash"]);
+		const worker = result.agents.find((a) => a.name === "worker")!;
+		assert.deepEqual(worker.excludeTools, ["bash"]);
+		assert.equal(worker.model, "p/small");
+		assert.equal(worker.modelProvider, undefined);
+		assert.deepEqual(worker.tools, ["read", "bash", "edit", "write"]);
+		// The discovered list itself is untouched.
+		assert.equal(agents.find((a) => a.name === "worker")!.model, "anthropic/opus");
+	});
+
+	it("skips the tier question when the parent chose a model", async () => {
+		const asked: Asked[] = [];
+		const result = await routeSubagentLaunch({ task: "t", agent: "worker", model: "x/y", agents }, ctx, settings, fakeAsk({ tier: { choice: "simple", confidence: 0.9 } }, asked) as never);
+		assert.ok(!("tier" in asked[0]!.allowed));
+		assert.equal(result.tier, undefined);
+	});
+
+	it("reads settings: off by default, tiers and generic agents when enabled", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "jev-subagent-"));
+		try {
+			const file = path.join(dir, "settings.json");
+			fs.writeFileSync(file, JSON.stringify({ jevAdvisory: { routes: {} } }));
+			assert.equal(readSubagentRoutingSettings(file), undefined);
+			fs.writeFileSync(file, JSON.stringify({ jevAdvisory: { routes: { subagent: { enabled: true, tiers: { simple: " p/s ", bogus: "x" }, genericAgents: ["delegate", "general"] } } } }));
+			const read = readSubagentRoutingSettings(file)!;
+			assert.deepEqual(read.tiers, { simple: "p/s" });
+			assert.deepEqual(read.genericAgents, ["delegate", "general"]);
+			assert.equal(read.connection.timeoutMs, 5000);
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/public-execution.test.ts

@@ -19,6 +19,8 @@ describe("public subagent execution normalization", () => {
 				output: true,
 			},
 		});
+		// Agentless tasks are left for Jev subagent routing; the executor rejects them when it cannot choose.
+		assert.deepEqual(normalizePublicSubagentExecution({ task: "work" }), { ok: true, params: { task: "work", output: true } });
 		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker" }), {
 			ok: true,
 			params: {
@@ -171,7 +173,7 @@ describe("public subagent execution normalization", () => {
 			{ action: "reject-checkpoint", id: "run" },
 			{ agent: "" },
 			{ agent: 42 },
-			{ task: "work" },
+			{ task: " " },
 			{ agent: "worker", task: 42 },
 			{ agent: "worker", workflowScript: "return 1" },
 			{ action: "status", task: "work" },

package/dist/extensions/rtk.test.ts

@@ -41,9 +41,11 @@ esac
 function makePi() {
 	const handlers = new Map<string, Function[]>();
 	const pi = {
-		exec: async (cmd: string, args: string[], opts?: { timeout?: number }) =>
+		exec: async (cmd: string, args: string[]) =>
 			new Promise((resolve) => {
-				execFile(cmd, args, { timeout: opts?.timeout }, (error, stdout, stderr) => {
+				// The shim runs under the suite's own load: enforcing the extension's production
+				// 2s budget here kills it, which the extension reports as a failed probe.
+				execFile(cmd, args, (error, stdout, stderr) => {
 					if (error) {
 						// execFile reports non-zero exits as errors; keep the real exit code.
 						const code =
@@ -63,8 +65,14 @@ function makePi() {
 	return { pi: pi as any, handlers };
 }
 
+// Registration is deferred off startup (the managed-binary probe may spawn a process),
+// so hook installation can outlast vi.waitFor's 1s default on a loaded machine.
+function waitFor<T>(assertion: () => T | Promise<T>): Promise<T> {
+	return vi.waitFor(assertion, { timeout: 5_000 });
+}
+
 async function getToolCall(handlers: Map<string, Function[]>): Promise<Function> {
-	await vi.waitFor(() => expect(handlers.has("tool_call")).toBe(true));
+	await waitFor(() => expect(handlers.has("tool_call")).toBe(true));
 	return handlers.get("tool_call")![0]!;
 }
 
@@ -131,7 +139,7 @@ posixOnly("rtk extension", () => {
 			const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
 			const { pi, handlers } = makePi();
 			rtkExtension(pi);
-			await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("rtk gain failed")));
+			await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("rtk gain failed")));
 			expect(handlers.has("tool_call")).toBe(false);
 		} finally {
 			if (previousPath) process.env.PATH = previousPath;
@@ -156,7 +164,7 @@ posixOnly("rtk extension", () => {
 		// Override exec so --version fails.
 		pi.exec = vi.fn(async () => ({ code: 1, stdout: "", stderr: "not found", killed: false }));
 		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("failed --version")));
+		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("failed --version")));
 		expect(handlers.has("tool_call")).toBe(false);
 	});
 
@@ -166,7 +174,7 @@ posixOnly("rtk extension", () => {
 		ensureToolMock.mockResolvedValue("rtk");
 		pi.exec = vi.fn(async () => ({ code: 0, stdout: "garbage output", stderr: "", killed: false }));
 		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("could not parse version")));
+		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("could not parse version")));
 		expect(handlers.has("tool_call")).toBe(false);
 	});
 
@@ -176,7 +184,7 @@ posixOnly("rtk extension", () => {
 		ensureToolMock.mockResolvedValue("rtk");
 		pi.exec = vi.fn(async () => ({ code: 0, stdout: "   ", stderr: "", killed: false }));
 		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("<empty output>")));
+		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("<empty output>")));
 		expect(handlers.has("tool_call")).toBe(false);
 	});
 
@@ -186,7 +194,7 @@ posixOnly("rtk extension", () => {
 		ensureToolMock.mockResolvedValue("rtk");
 		pi.exec = vi.fn(async () => ({ code: 0, stdout: "rtk 0.22.0", stderr: "", killed: false }));
 		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("too old")));
+		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("too old")));
 		expect(handlers.has("tool_call")).toBe(false);
 	});
 
@@ -195,7 +203,7 @@ posixOnly("rtk extension", () => {
 		ensureToolMock.mockRejectedValue(new Error("download failed"));
 		const { pi, handlers } = makePi();
 		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("managed installation failed")));
+		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("managed installation failed")));
 		expect(handlers.has("tool_call")).toBe(false);
 	});
 
@@ -204,7 +212,7 @@ posixOnly("rtk extension", () => {
 		ensureToolMock.mockRejectedValue("plain string failure");
 		const { pi, handlers } = makePi();
 		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("plain string failure")));
+		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("plain string failure")));
 		expect(handlers.has("tool_call")).toBe(false);
 	});
 
@@ -213,7 +221,7 @@ posixOnly("rtk extension", () => {
 		ensureToolMock.mockResolvedValue(undefined);
 		const { pi, handlers } = makePi();
 		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("unavailable")));
+		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("unavailable")));
 		expect(handlers.has("tool_call")).toBe(false);
 	});
 
@@ -225,7 +233,7 @@ posixOnly("rtk extension", () => {
 			throw new Error("spawn ENOENT");
 		});
 		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("verification failed")));
+		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("verification failed")));
 		expect(handlers.has("tool_call")).toBe(false);
 	});
 
@@ -237,7 +245,7 @@ posixOnly("rtk extension", () => {
 			throw "string failure";
 		});
 		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("string failure")));
+		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("string failure")));
 		expect(handlers.has("tool_call")).toBe(false);
 	});
 

package/dist/extensions/tps.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { calculateLiveTps, calculateReliableTps, type TpsTiming } from "./tps.ts";
+import { calculateLiveTps, calculateReliableTps, setupTpsTracker, type TpsTiming } from "./tps.ts";
 
 function timing(overrides: Partial<TpsTiming> = {}): TpsTiming {
 	return {
@@ -23,6 +23,37 @@ describe("calculateLiveTps", () => {
 	});
 });
 
+describe("setupTpsTracker with anthropic-style usage", () => {
+	it("ignores the tiny usage.output seeded at message_start while streaming", async () => {
+		const handlers = new Map<string, (event: any, ctx: any) => Promise<void>>();
+		const statuses: string[] = [];
+		const ctx = { ui: { setStatus: (_k: string, v: string) => statuses.push(v), notify: () => {}, theme: { fg: (_c: string, t: string) => t } } };
+		setupTpsTracker({ on: (name: string, fn: any) => handlers.set(name, fn) } as any);
+
+		let now = 0;
+		const realNow = performance.now;
+		performance.now = () => now;
+		try {
+			const message = { role: "assistant", provider: "anthropic", model: "claude", usage: { output: 1 } };
+			await handlers.get("agent_start")!({}, ctx);
+			await handlers.get("message_start")!({ message }, ctx);
+			for (let i = 0; i < 20; i++) {
+				now += 50;
+				await handlers.get("message_update")!({ message, assistantMessageEvent: { type: "text_delta", delta: "x".repeat(40) } }, ctx);
+			}
+			// 20 deltas * 10 est. tokens over ~1s => ~200 tok/s, not ~1 tok/s
+			expect(statuses.at(-1)).toBe("211 tok/s");
+
+			message.usage.output = 200;
+			await handlers.get("message_end")!({ message }, ctx);
+			await handlers.get("agent_end")!({}, ctx);
+			expect(statuses.at(-1)).toMatch(/^done [1-9]\d* t\/s \(main [1-9]\d* t\/s\)$/);
+		} finally {
+			performance.now = realNow;
+		}
+	});
+});
+
 describe("calculateReliableTps", () => {
 	it("uses active stream time for sufficiently sampled output", () => {
 		expect(calculateReliableTps(100, timing())).toEqual({

package/dist/extensions/tps.ts

@@ -230,7 +230,9 @@ export function setupTpsTracker(pi: ExtensionAPI): void {
 		streamStart ??= now;
 		estimatedStreamedTokens += Math.max(0, streamEvent.delta.length / 4);
 		const officialTokens = generatedTokensFromUsage(asRecord(event.message.usage));
-		const currentTokens = officialTokens > 0 ? officialTokens : estimatedStreamedTokens;
+		// Anthropic seeds usage.output (~1) at message_start and only finalizes it at message_delta,
+		// so a nonzero official count mid-stream is not authoritative; take whichever is larger.
+		const currentTokens = Math.max(officialTokens, estimatedStreamedTokens);
 		const tps = calculateLiveTps(currentTokens, now - streamStart);
 		if (tps !== null) {
 			ctx.ui.setStatus("tps", ctx.ui.theme.fg("accent", `${tps} tok/s`));