@dungle-scrubs/tallow 0.8.27 → 0.9.0

package/extensions/prompt-suggestions/__tests__/autocomplete.test.ts

@@ -5,6 +5,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import type { Api, Model } from "@mariozechner/pi-ai";
 import {
+	AUTOCOMPLETE_COMMAND_PREFIXES,
 	AUTOCOMPLETE_FALLBACKS,
 	type AutocompleteConfig,
 	AutocompleteEngine,
@@ -15,6 +16,7 @@ import {
 	resolveAutocompleteModel,
 	tryResolveModel,
 } from "../autocomplete.js";
+import { buildLoopAutocompletePrompt, selectAutocompletePrompt } from "../index.js";
 
 // ─── Test helpers ────────────────────────────────────────────────────────────
 
@@ -42,8 +44,9 @@ function createMockRegistry(
 		find(provider: string, modelId: string) {
 			return models.find((m) => m.provider === provider && m.id === modelId);
 		},
-		async getApiKey(model: Model<Api>) {
-			return keys.get(`${model.provider}/${model.id}`);
+		async getApiKeyForProvider(provider: string) {
+			const entry = [...keys.entries()].find(([k]) => k.startsWith(`${provider}/`));
+			return entry?.[1];
 		},
 		getAvailable() {
 			return models.filter((m) => keys.has(`${m.provider}/${m.id}`));
@@ -189,7 +192,7 @@ describe("resolveAutocompleteModel", () => {
 				findCalls.push(`${provider}/${modelId}`);
 				return undefined;
 			},
-			async getApiKey() {
+			async getApiKeyForProvider() {
 				return undefined;
 			},
 			getAvailable() {
@@ -224,6 +227,24 @@ describe("AutocompleteEngine.shouldTrigger", () => {
 	test("rejects slash commands", () => {
 		const { engine } = createTestEngine({});
 		expect(engine.shouldTrigger("/help")).toBe(false);
+		expect(engine.shouldTrigger("/clear")).toBe(false);
+		expect(engine.shouldTrigger("/debug")).toBe(false);
+	});
+
+	test("allows /loop with content after prefix", () => {
+		const { engine } = createTestEngine({});
+		expect(engine.shouldTrigger("/loop check ci")).toBe(true);
+		expect(engine.shouldTrigger("/loop run tests every 30s")).toBe(true);
+	});
+
+	test("rejects bare /loop without trailing content", () => {
+		const { engine } = createTestEngine({});
+		expect(engine.shouldTrigger("/loop")).toBe(false);
+		expect(engine.shouldTrigger("/loop ")).toBe(false);
+	});
+
+	test("AUTOCOMPLETE_COMMAND_PREFIXES includes /loop", () => {
+		expect(AUTOCOMPLETE_COMMAND_PREFIXES).toContain("/loop ");
 	});
 
 	test("rejects when disabled", () => {
@@ -504,3 +525,90 @@ describe("AutocompleteEngine conversation context", () => {
 		expect(receivedContext).toBeNull();
 	});
 });
+
+// ─── /loop autocomplete integration ─────────────────────────────────────────
+
+describe("/loop autocomplete", () => {
+	let engine: AutocompleteEngine;
+
+	afterEach(() => {
+		engine?.dispose();
+	});
+
+	test("triggers autocomplete for /loop commands", async () => {
+		const calls: string[] = [];
+		const result = createTestEngine({
+			config: { debounceMs: 5 },
+			completionFn: async (_m, _k, input) => {
+				calls.push(input);
+				return " every 2m until CI is green";
+			},
+			currentText: "/loop check ci",
+		});
+		engine = result.engine;
+
+		engine.trigger("/loop check ci");
+		await waitForDebounce();
+		expect(calls).toEqual(["/loop check ci"]);
+		expect(result.ghostTexts).toEqual([" every 2m until CI is green"]);
+	});
+
+	test("does not trigger for non-allowlisted slash commands", async () => {
+		const calls: string[] = [];
+		const result = createTestEngine({
+			config: { debounceMs: 5 },
+			completionFn: async (_m, _k, input) => {
+				calls.push(input);
+				return "completion";
+			},
+		});
+		engine = result.engine;
+
+		engine.trigger("/help something");
+		await waitForDebounce();
+		expect(calls.length).toBe(0);
+	});
+});
+
+// ─── Prompt selection ────────────────────────────────────────────────────────
+
+describe("selectAutocompletePrompt", () => {
+	test("returns loop prompt for /loop prefix", () => {
+		const prompt = selectAutocompletePrompt("/loop check ci", null);
+		expect(prompt).toContain("/loop");
+		expect(prompt).toContain("natural language");
+		expect(prompt).not.toContain("developer message");
+	});
+
+	test("returns general prompt for non-loop input", () => {
+		const prompt = selectAutocompletePrompt("refactor the auth", null);
+		expect(prompt).toContain("developer");
+		expect(prompt).not.toContain("/loop");
+	});
+
+	test("loop prompt includes conversation context when available", () => {
+		const ctx = { recentExchanges: "User: checking CI\n\nAssistant: it failed" };
+		const prompt = selectAutocompletePrompt("/loop check", ctx);
+		expect(prompt).toContain("checking CI");
+	});
+
+	test("general prompt includes conversation context when available", () => {
+		const ctx = { recentExchanges: "User: fix auth\n\nAssistant: done" };
+		const prompt = selectAutocompletePrompt("now also", ctx);
+		expect(prompt).toContain("fix auth");
+	});
+});
+
+describe("buildLoopAutocompletePrompt", () => {
+	test("includes example loop patterns", () => {
+		const prompt = buildLoopAutocompletePrompt(null);
+		expect(prompt).toContain("every 2m");
+		expect(prompt).toContain("until");
+		expect(prompt).toContain("observable");
+	});
+
+	test("warns against vague conditions", () => {
+		const prompt = buildLoopAutocompletePrompt(null);
+		expect(prompt).toContain("vague");
+	});
+});

package/extensions/prompt-suggestions/autocomplete.ts

@@ -14,8 +14,8 @@ import type { Api, Model } from "@mariozechner/pi-ai";
 export interface ModelRegistryLike {
 	/** Find a model by provider and ID. */
 	find(provider: string, modelId: string): Model<Api> | undefined;
-	/** Get API key for a model. */
-	getApiKey(model: Model<Api>): Promise<string | undefined>;
+	/** Get API key for a provider. */
+	getApiKeyForProvider(provider: string): Promise<string | undefined>;
 	/** Get all models that have auth configured. */
 	getAvailable(): Model<Api>[];
 	/** Register a provider dynamically. */
@@ -71,6 +71,15 @@ export const AUTOCOMPLETE_FALLBACKS = [
 /** Minimum characters before autocomplete triggers. */
 export const MIN_CHARS = 4;
 
+/**
+ * Command prefixes that opt into autocomplete despite starting with `/`.
+ *
+ * Most slash commands are short and syntactically rigid — autocomplete adds
+ * noise. But commands with complex, hard-to-remember syntax (like `/loop`)
+ * benefit from inline suggestions.
+ */
+export const AUTOCOMPLETE_COMMAND_PREFIXES = ["/loop "] as const;
+
 // ─── Model resolution ────────────────────────────────────────────────────────
 
 /**
@@ -93,7 +102,7 @@ export async function tryResolveModel(
 	const model = registry.find(provider, modelId);
 	if (!model) return null;
 
-	const apiKey = await registry.getApiKey(model);
+	const apiKey = await registry.getApiKeyForProvider(model.provider);
 	if (!apiKey) return null;
 
 	return { model, apiKey };
@@ -126,7 +135,7 @@ export async function resolveAutocompleteModel(
 	const available = registry.getAvailable();
 	const sorted = [...available].sort((a, b) => (a.cost?.input ?? 0) - (b.cost?.input ?? 0));
 	for (const model of sorted) {
-		const apiKey = await registry.getApiKey(model);
+		const apiKey = await registry.getApiKeyForProvider(model.provider);
 		if (apiKey) return { model, apiKey };
 	}
 
@@ -196,6 +205,10 @@ export class AutocompleteEngine {
 	/**
 	 * Determine whether a partial input should trigger autocomplete.
 	 *
+	 * Most `/` prefixed input is rejected (slash commands are short and rigid).
+	 * Commands listed in {@link AUTOCOMPLETE_COMMAND_PREFIXES} are allowed
+	 * because their syntax is complex enough to benefit from inline suggestions.
+	 *
 	 * @param input - Current editor text
 	 * @returns true if autocomplete should be scheduled
 	 */
@@ -203,7 +216,12 @@ export class AutocompleteEngine {
 		if (!this.config.enabled) return false;
 		if (this._busy) return false;
 		if (this._callCount >= this.config.maxCalls) return false;
-		if (input.startsWith("/")) return false;
+		if (input.startsWith("/")) {
+			const isAllowed = AUTOCOMPLETE_COMMAND_PREFIXES.some(
+				(prefix) => input.startsWith(prefix) && input.length > prefix.length
+			);
+			if (!isAllowed) return false;
+		}
 		if (input.trim().length < MIN_CHARS) return false;
 		return true;
 	}

package/extensions/prompt-suggestions/index.ts

@@ -154,7 +154,8 @@ export function buildConversationContext(
 // ─── LLM completion ──────────────────────────────────────────────────────────
 
 /**
- * Build the system prompt for autocomplete, optionally including conversation context.
+ * Build the system prompt for general autocomplete, optionally including
+ * conversation context.
  *
  * @param context - Recent conversation context, or null
  * @returns System prompt string
@@ -175,6 +176,60 @@ export function buildAutocompleteSystemPrompt(context: ConversationContext | nul
 	return `${base}\n\nHere is the recent conversation for context:\n\n${context.recentExchanges}`;
 }
 
+/**
+ * Build a system prompt for `/loop` command autocomplete.
+ *
+ * The prompt teaches the model about natural-language loop syntax so it
+ * suggests good intervals, specific conditions, and actionable tasks.
+ * The user writes in natural language; a separate NL parser converts the
+ * final command into strict `/loop` syntax.
+ *
+ * @param context - Recent conversation context, or null
+ * @returns System prompt string
+ */
+export function buildLoopAutocompletePrompt(context: ConversationContext | null): string {
+	const base =
+		"You are completing a /loop command in a coding CLI. " +
+		"The developer writes loops in natural language. The system parses it automatically.\n\n" +
+		"A loop needs: a task to perform, how often, and optionally when to stop.\n\n" +
+		"Good patterns:\n" +
+		'- "check the latest GitHub Actions run every 2m until CI is green"\n' +
+		'- "run the test suite every 30s until all tests pass"\n' +
+		'- "check deploy health every 1m until all pods are healthy"\n' +
+		'- "monitor build progress every 5m until the build completes"\n' +
+		'- "check disk usage every 10m, max 20 times"\n\n' +
+		"Reply with ONLY the completion text — the part that comes after what they typed. " +
+		"Keep suggestions specific and actionable — avoid vague conditions like 'it works' or 'it's done'. " +
+		"Suggest observable facts the agent can check. " +
+		"If they wrote a task, suggest the interval and condition. " +
+		"If they wrote an interval, suggest a clear task. " +
+		"One line only. Do not repeat what they typed. Do not add formatting or explanations.";
+
+	if (!context) return base;
+
+	return `${base}\n\nRecent conversation for context:\n\n${context.recentExchanges}`;
+}
+
+/**
+ * Select the appropriate system prompt based on the user's partial input.
+ *
+ * Commands with complex syntax (like `/loop`) get specialized prompts that
+ * understand their structure and suggest valid, high-quality completions.
+ *
+ * @param partialInput - Current editor text
+ * @param context - Recent conversation context, or null
+ * @returns System prompt string
+ */
+export function selectAutocompletePrompt(
+	partialInput: string,
+	context: ConversationContext | null
+): string {
+	if (partialInput.startsWith("/loop ")) {
+		return buildLoopAutocompletePrompt(context);
+	}
+	return buildAutocompleteSystemPrompt(context);
+}
+
 /**
  * Call the autocomplete model with the user's partial input and conversation context.
  *
@@ -193,14 +248,18 @@ async function getCompletion(
 	context: ConversationContext | null
 ): Promise<string | null> {
 	try {
+		const userMessage = partialInput.startsWith("/loop ")
+			? `Complete this /loop command:\n${partialInput}`
+			: `Complete this developer message:\n${partialInput}`;
+
 		const result = await completeSimple(
 			model,
 			{
-				systemPrompt: buildAutocompleteSystemPrompt(context),
+				systemPrompt: selectAutocompletePrompt(partialInput, context),
 				messages: [
 					{
 						role: "user",
-						content: `Complete this developer message:\n${partialInput}`,
+						content: userMessage,
 						timestamp: Date.now(),
 					},
 				],

package/extensions/read-tool-enhanced/index.ts

@@ -489,7 +489,11 @@ export default function readSummary(pi: ExtensionAPI): void {
 				const left =
 					formatPresentationText(theme, "identity", icon) +
 					` ${formatPresentationText(theme, "identity", `skill: ${skillName}`)}`;
-				const right = formatPresentationText(theme, "hint", keyHint("expandTools", "to expand"));
+				const right = formatPresentationText(
+					theme,
+					"hint",
+					keyHint("app.tools.expand", "to expand")
+				);
 
 				return {
 					render(width: number): string[] {

package/extensions/render-stabilizer/__tests__/render-stabilizer.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "bun:test";
+import renderStabilizerExtension from "../index.js";
+
+describe("render-stabilizer extension", () => {
+	it("registers session_start and session_before_switch handlers", () => {
+		const handlers = new Map<string, unknown[]>();
+
+		const mockPi = {
+			on(event: string, handler: unknown) {
+				if (!handlers.has(event)) handlers.set(event, []);
+				handlers.get(event)!.push(handler);
+			},
+		};
+
+		renderStabilizerExtension(mockPi as never);
+
+		expect(handlers.has("session_start")).toBe(true);
+		expect(handlers.get("session_start")!.length).toBe(1);
+		expect(handlers.has("session_before_switch")).toBe(true);
+		expect(handlers.get("session_before_switch")!.length).toBe(1);
+	});
+
+	it("does not register any commands or tools", () => {
+		let commandCount = 0;
+		let toolCount = 0;
+
+		const mockPi = {
+			on() {},
+			registerCommand() {
+				commandCount++;
+			},
+			registerTool() {
+				toolCount++;
+			},
+		};
+
+		renderStabilizerExtension(mockPi as never);
+
+		expect(commandCount).toBe(0);
+		expect(toolCount).toBe(0);
+	});
+});

package/extensions/render-stabilizer/extension.json

@@ -0,0 +1,5 @@
+{
+	"name": "render-stabilizer",
+	"version": "1.0.0",
+	"description": "Prevents screen flicker during session resume by suppressing screen-clearing redraws"
+}

package/extensions/render-stabilizer/index.ts

@@ -0,0 +1,66 @@
+/**
+ * Render Stabilizer Extension
+ *
+ * Prevents the visual flicker that occurs when resuming a session.
+ * During session switches, the chat container is cleared and rebuilt,
+ * which causes rapid content height changes. The TUI's shrink-detection
+ * redraws use screen clears (`\x1b[2J`) that produce visible blank frames.
+ *
+ * This extension resets the TUI's render grace period at the start of
+ * each session switch so the gentler line-by-line redraw is used instead
+ * of the screen-clearing approach.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { TUI } from "@mariozechner/pi-tui";
+
+/** Reference to the TUI instance, captured on first session_start. */
+let tuiRef: TUI | null = null;
+
+/**
+ * Capture the TUI reference by briefly setting a widget with a factory function.
+ * The factory receives the TUI instance as its first argument.
+ *
+ * @param ui - Extension UI context
+ */
+function captureTuiRef(ui: {
+	setWidget: (
+		key: string,
+		content:
+			| undefined
+			| ((tui: TUI, theme: unknown) => { render: (w: number) => string[]; invalidate: () => void })
+	) => void;
+}): void {
+	if (tuiRef) return;
+	ui.setWidget("_render-stabilizer", (tui: TUI) => {
+		tuiRef = tui;
+		return { render: () => [], invalidate: () => {} };
+	});
+	// Remove the widget immediately — it was only needed to capture the ref
+	ui.setWidget("_render-stabilizer", undefined);
+}
+
+/**
+ * Register render stabilization hooks.
+ *
+ * @param pi - Extension API
+ */
+export default function renderStabilizerExtension(pi: ExtensionAPI): void {
+	// Capture the TUI reference on first session_start
+	pi.on("session_start", async (_event, ctx) => {
+		captureTuiRef(ctx.ui);
+	});
+
+	// Reset the render grace period before a session switch so the
+	// chatContainer.clear() → renderInitialMessages() transition uses
+	// gentle line-by-line redraws instead of screen-clearing redraws.
+	pi.on("session_before_switch", async (_event, ctx) => {
+		captureTuiRef(ctx.ui);
+		if (
+			tuiRef &&
+			typeof (tuiRef as TUI & { resetRenderGrace?: () => void }).resetRenderGrace === "function"
+		) {
+			(tuiRef as TUI & { resetRenderGrace: () => void }).resetRenderGrace();
+		}
+	});
+}

package/extensions/session-memory/index.ts

@@ -381,7 +381,7 @@ export default function (pi: ExtensionAPI) {
 					};
 				}
 
-				const apiKey = await ctx.modelRegistry.getApiKey(model);
+				const apiKey = await ctx.modelRegistry.getApiKeyForProvider(model.provider);
 				if (!apiKey) {
 					ctx.ui.setWorkingMessage();
 					const sc = new Set(results.map((r) => r.sessionId)).size;

package/extensions/session-namer/index.ts

@@ -188,7 +188,7 @@ export default function (pi: ExtensionAPI): void {
 				const model = findNamingModel(ctx);
 				if (!model) return;
 
-				const apiKey = await ctx.modelRegistry.getApiKey(model);
+				const apiKey = await ctx.modelRegistry.getApiKeyForProvider(model.provider);
 				if (!apiKey) return;
 
 				const prompt = buildNamingPrompt(userText, assistantText);

package/extensions/subagent-tool/__tests__/auto-cheap-model.test.ts

@@ -39,14 +39,74 @@ const mockModels = [
 ];
 
 const mockScope = createMockScope(import.meta.url);
-mockScope.module("@mariozechner/pi-ai", () => ({
-	getProviders: () => ["anthropic", "google"],
-	getModels: (provider: string) => mockModels.filter((m) => m.provider === provider),
+mockScope.module("@dungle-scrubs/synapse", () => ({
+	listAvailableModels: () => mockModels.map((model) => `${model.provider}/${model.id}`),
+	parseModelMatrixOverrides: () => undefined,
+	resolveModelCandidates: (query: string) => {
+		const normalized = query.toLowerCase().trim();
+		return mockModels
+			.filter(
+				(model) =>
+					model.id.toLowerCase() === normalized ||
+					model.name.toLowerCase().includes(normalized) ||
+					`${model.provider}/${model.id}`.toLowerCase() === normalized
+			)
+			.map((model) => ({
+				displayName: `${model.provider}/${model.id}`,
+				id: model.id,
+				provider: model.provider,
+			}));
+	},
+	resolveModelFuzzy: (
+		query: string,
+		source?: () => Array<{ id: string; name: string; provider: string }>,
+		preferredProviders?: string[]
+	) => {
+		const normalized = query.toLowerCase().trim();
+		const candidates = source
+			? source().map((model) => ({
+					id: model.id,
+					name: model.name,
+					provider: model.provider,
+				}))
+			: mockModels;
+		const matches = candidates.filter(
+			(model) =>
+				model.id.toLowerCase() === normalized ||
+				model.name.toLowerCase().includes(normalized) ||
+				`${model.provider}/${model.id}`.toLowerCase() === normalized
+		);
+		const ordered = preferredProviders?.length
+			? [...matches].sort((left, right) => {
+					const leftIndex = preferredProviders.indexOf(left.provider);
+					const rightIndex = preferredProviders.indexOf(right.provider);
+					const safeLeft = leftIndex === -1 ? Number.MAX_SAFE_INTEGER : leftIndex;
+					const safeRight = rightIndex === -1 ? Number.MAX_SAFE_INTEGER : rightIndex;
+					return safeLeft - safeRight;
+				})
+			: matches;
+		const selected = ordered[0];
+		return selected
+			? {
+					displayName: `${selected.provider}/${selected.id}`,
+					id: selected.id,
+					provider: selected.provider,
+				}
+			: undefined;
+	},
+	selectModels: (_classification: unknown, costPreference: string) => {
+		const ordered =
+			costPreference === "premium"
+				? [mockModels[0], mockModels[1], mockModels[2], mockModels[3]]
+				: [mockModels[3], mockModels[2], mockModels[1], mockModels[0]];
+		return ordered.map((model) => ({
+			displayName: `${model.provider}/${model.id}`,
+			id: model.id,
+			provider: model.provider,
+		}));
+	},
 }));
 
-// NOTE: Do NOT mock ../model-resolver.js — it leaks across test files in bun.
-// The pi-ai mock above provides model data that resolveModelFuzzy uses.
-
 mockScope.module("../task-classifier.js", () => ({
 	classifyTask: async (_task: string, primaryType: string) => ({
 		type: primaryType,

package/extensions/subagent-tool/__tests__/model-router-explicit-resolution.test.ts

@@ -1,4 +1,7 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { createMockScope } from "../../../test-utils/mock-scope.js";
 
 const mockModels = [
@@ -35,9 +38,62 @@ const mockModels = [
 ];
 
 const mockScope = createMockScope(import.meta.url);
-mockScope.module("@mariozechner/pi-ai", () => ({
-	getProviders: () => ["anthropic", "opencode", "openrouter", "minimax", "zai"],
-	getModels: (provider: string) => mockModels.filter((model) => model.provider === provider),
+mockScope.module("@dungle-scrubs/synapse", () => ({
+	listAvailableModels: () => mockModels.map((model) => `${model.provider}/${model.id}`),
+	parseModelMatrixOverrides: () => undefined,
+	resolveModelCandidates: (query: string) => {
+		const normalized = query.toLowerCase().trim();
+		return mockModels
+			.filter(
+				(model) =>
+					model.id.toLowerCase() === normalized ||
+					model.name.toLowerCase().includes(normalized) ||
+					`${model.provider}/${model.id}`.toLowerCase() === normalized
+			)
+			.map((model) => ({
+				displayName: `${model.provider}/${model.id}`,
+				id: model.id,
+				provider: model.provider,
+			}));
+	},
+	resolveModelFuzzy: (
+		query: string,
+		source?: () => Array<{ id: string; name: string; provider: string }>,
+		preferredProviders?: string[]
+	) => {
+		const normalized = query.toLowerCase().trim();
+		const candidates = source
+			? source().map((model) => ({
+					id: model.id,
+					name: model.name,
+					provider: model.provider,
+				}))
+			: mockModels;
+		const matches = candidates.filter(
+			(model) =>
+				model.id.toLowerCase() === normalized ||
+				model.name.toLowerCase().includes(normalized) ||
+				`${model.provider}/${model.id}`.toLowerCase() === normalized
+		);
+		const ordered = preferredProviders?.length
+			? [...matches].sort((left, right) => {
+					const leftIndex = preferredProviders.indexOf(left.provider);
+					const rightIndex = preferredProviders.indexOf(right.provider);
+					const safeLeft = leftIndex === -1 ? Number.MAX_SAFE_INTEGER : leftIndex;
+					const safeRight = rightIndex === -1 ? Number.MAX_SAFE_INTEGER : rightIndex;
+					return safeLeft - safeRight;
+				})
+			: matches;
+		const selected = ordered[0];
+		return selected
+			? {
+					displayName: `${selected.provider}/${selected.id}`,
+					id: selected.id,
+					provider: selected.provider,
+				}
+			: undefined;
+	},
+	selectModels: () => [],
 }));
 
 mockScope.module("../task-classifier.js", () => ({
@@ -48,7 +104,23 @@ mockScope.module("../task-classifier.js", () => ({
 let routeModel!: typeof import("../model-router.js").routeModel;
 
 const ORIGINAL_ENV: Record<string, string | undefined> = {};
-const ENV_KEYS = ["OPENCODE_API_KEY", "ZAI_API_KEY"] as const;
+const ENV_KEYS = [
+	"ANTHROPIC_API_KEY",
+	"GEMINI_API_KEY",
+	"GOOGLE_API_KEY",
+	"MINIMAX_API_KEY",
+	"MINIMAX_CN_API_KEY",
+	"OPENCODE_API_KEY",
+	"OPENAI_API_KEY",
+	"OPENROUTER_API_KEY",
+	"TALLOW_CODING_AGENT_DIR",
+	"VERCEL_AI_GATEWAY_API_KEY",
+	"VERCEL_API_KEY",
+	"XAI_API_KEY",
+	"ZAI_API_KEY",
+] as const;
+
+let isolatedTallowHome: string;
 
 beforeAll(async () => {
 	mockScope.install();
@@ -65,6 +137,8 @@ beforeEach(() => {
 		ORIGINAL_ENV[key] = process.env[key];
 		delete process.env[key];
 	}
+	isolatedTallowHome = mkdtempSync(join(tmpdir(), "subagent-router-explicit-"));
+	process.env.TALLOW_CODING_AGENT_DIR = isolatedTallowHome;
 });
 
 afterEach(() => {
@@ -72,8 +146,8 @@ afterEach(() => {
 		if (ORIGINAL_ENV[key] === undefined) delete process.env[key];
 		else process.env[key] = ORIGINAL_ENV[key];
 	}
+	rmSync(isolatedTallowHome, { force: true, recursive: true });
 });
-
 describe("routeModel explicit model resolution", () => {
 	it("honors explicit provider/model choices without auto-routing", async () => {
 		const result = await routeModel(

package/extensions/subagent-tool/__tests__/presentation-rendering.test.ts

@@ -113,7 +113,7 @@ describe("subagent presentation rendering", () => {
 		else process.env.PI_IS_SUBAGENT = originalSubagentFlag;
 	});
 
-	it("renders single-call hierarchy with prominent title/action/identity and muted metadata", () => {
+	it("renders single-call with task preview and metadata (no redundant header)", () => {
 		const component = tool.renderCall?.(
 			{
 				agent: "worker",
@@ -126,9 +126,9 @@ describe("subagent presentation rendering", () => {
 		if (!component) throw new Error("subagent.renderCall returned undefined");
 
 		const rendered = renderComponent(component);
-		expect(rendered).toContain("<b><toolTitle>subagent</toolTitle></b>");
-		expect(rendered).toContain("<accent>single</accent>");
-		expect(rendered).toContain("worker");
+		// Single mode no longer renders "subagent single <agent>" header —
+		// the result renderer already shows "subagent running <duration> <agent>"
+		expect(rendered).not.toContain("<accent>single</accent>");
 		expect(rendered).toContain("<muted>scope:both • model:claude-sonnet</muted>");
 		expect(rendered).toContain("<dim>Implement authentication flow with retry handling</dim>");
 	});