@dungle-scrubs/tallow 0.8.26 → 0.8.28

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/random-spinner/__tests__/random-spinner.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import randomSpinner from "../index.js";
+
+describe("random-spinner extension", () => {
+	test("registers session_start handler", () => {
+		const events: string[] = [];
+		const pi = {
+			on: (event: string) => {
+				events.push(event);
+			},
+		} as unknown as ExtensionAPI;
+
+		randomSpinner(pi);
+		expect(events).toContain("session_start");
+	});
+
+	test("does not register any commands or tools", () => {
+		const commands: string[] = [];
+		const tools: string[] = [];
+		const pi = {
+			on: () => {},
+			registerCommand: (name: string) => {
+				commands.push(name);
+			},
+			registerTool: (opts: { name: string }) => {
+				tools.push(opts.name);
+			},
+		} as unknown as ExtensionAPI;
+
+		randomSpinner(pi);
+		expect(commands).toHaveLength(0);
+		expect(tools).toHaveLength(0);
+	});
+});

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/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/show-system-prompt/__tests__/show-system-prompt.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, mock, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import showPrompt from "../index.js";
+
+describe("show-system-prompt extension", () => {
+	test("registers show-system-prompt command", () => {
+		const commands: string[] = [];
+		const pi = {
+			registerCommand: (name: string) => {
+				commands.push(name);
+			},
+		} as unknown as ExtensionAPI;
+
+		showPrompt(pi);
+		expect(commands).toContain("show-system-prompt");
+	});
+
+	test("handler logs system prompt and notifies", async () => {
+		let handler: ((args: string, ctx: unknown) => Promise<void>) | undefined;
+		const pi = {
+			registerCommand: (
+				_name: string,
+				opts: { handler: (args: string, ctx: unknown) => Promise<void> }
+			) => {
+				handler = opts.handler;
+			},
+		} as unknown as ExtensionAPI;
+
+		showPrompt(pi);
+
+		const notify = mock(() => {});
+		const ctx = {
+			getSystemPrompt: () => "You are a test prompt",
+			ui: { notify },
+		};
+
+		const origLog = console.log;
+		const logged: string[] = [];
+		console.log = (...args: unknown[]) => {
+			logged.push(args.join(" "));
+		};
+		try {
+			await handler!("", ctx);
+		} finally {
+			console.log = origLog;
+		}
+
+		expect(logged.some((l) => l.includes("You are a test prompt"))).toBe(true);
+		expect(notify).toHaveBeenCalledWith("System prompt logged to terminal", "info");
+	});
+});

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,14 +126,14 @@ 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>");
 	});
 
-	it("keeps long parallel call previews informative without dumping the full tail", () => {
+	it("renders parallel call header without inlining task text", () => {
 		const component = tool.renderCall?.(
 			{
 				tasks: [
@@ -152,7 +152,8 @@ describe("subagent presentation rendering", () => {
 
 		const rendered = renderComponent(component);
 		expect(rendered).toContain("<accent>parallel (1 tasks)</accent>");
-		expect(rendered).toContain("KEEP_THIS_SEGMENT_VISIBLE");
+		// Parallel renderCall shows header + metadata only — no inline task preview
+		expect(rendered).not.toContain("KEEP_THIS_SEGMENT_VISIBLE");
 		expect(rendered).not.toContain("END_MARKER_SHOULD_TRUNCATE");
 	});
 
@@ -260,8 +261,8 @@ describe("subagent presentation rendering", () => {
 		if (!component) throw new Error("subagent.renderResult returned undefined");
 
 		const rendered = renderComponent(component);
-		expect(rendered).toContain("<b><toolTitle>subagent</toolTitle></b>");
-		expect(rendered).toContain("<accent>parallel</accent>");
+		// Result no longer repeats the "subagent parallel" header (call header already shows it)
+		expect(rendered).not.toContain("<toolTitle>subagent</toolTitle>");
 		expect(rendered).toContain("├─");
 		expect(rendered).toContain("└─");
 		expect(rendered).toContain("<dim>(gpt-5.1)</dim>");

package/extensions/subagent-tool/__tests__/process-liveness.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "bun:test";
 import type { SingleResult } from "../formatting.js";
 import {
 	applyStalledClassification,
+	createStalledSubagentErrorMessage,
 	createWatchdogHeartbeatState,
 	evaluateWatchdogStatus,
 	type ForegroundWatchdogThresholds,
@@ -13,6 +14,7 @@ import {
 	SUBAGENT_INACTIVITY_TIMEOUT_MS_ENV,
 	SUBAGENT_STARTUP_TIMEOUT_MS_ENV,
 	SUBAGENT_TOOL_EXECUTION_TIMEOUT_MS_ENV,
+	SUBAGENT_WALL_CLOCK_TIMEOUT_MS_ENV,
 	terminateProcessWithGrace,
 } from "../process.js";
 
@@ -21,6 +23,7 @@ const TEST_THRESHOLDS: ForegroundWatchdogThresholds = {
 	killGraceMs: 50,
 	startupTimeoutMs: 1_000,
 	toolExecutionTimeoutMs: 8_000,
+	wallClockTimeoutMs: 20_000,
 };
 
 interface ManualTimer {
@@ -124,6 +127,52 @@ describe("foreground subagent liveness watchdog", () => {
 		expect(state.activeToolCalls).toBe(0);
 	});
 
+	it("terminates active agents that exceed wall-clock timeout", () => {
+		let state = createWatchdogHeartbeatState(0);
+		// Agent is actively producing heartbeats — not stalled by liveness checks
+		state = recordWatchdogHeartbeat(state, 5_000);
+		state = recordWatchdogHeartbeat(state, 10_000);
+		state = recordWatchdogHeartbeat(state, 15_000);
+		state = recordWatchdogHeartbeat(state, 19_000);
+		expect(evaluateWatchdogStatus(state, 19_500, TEST_THRESHOLDS).kind).toBe("healthy");
+
+		// Wall-clock timeout (20s) fires even though last heartbeat was recent
+		const status = evaluateWatchdogStatus(state, 20_100, TEST_THRESHOLDS);
+		expect(status.kind).toBe("stalled");
+		if (status.kind !== "stalled") return;
+		expect(status.phase).toBe("wall_clock");
+	});
+
+	it("wall-clock timeout takes precedence over other stall phases", () => {
+		// Agent started and never sent a heartbeat — would normally be startup stall
+		const state = createWatchdogHeartbeatState(0);
+		// But wall-clock fires first when both thresholds are exceeded
+		const status = evaluateWatchdogStatus(state, 25_000, TEST_THRESHOLDS);
+		expect(status.kind).toBe("stalled");
+		if (status.kind !== "stalled") return;
+		expect(status.phase).toBe("wall_clock");
+	});
+
+	it("wall-clock error message differs from liveness stall messages", () => {
+		const wallClockMsg = createStalledSubagentErrorMessage({
+			elapsedMs: 900_000,
+			kind: "stalled",
+			phase: "wall_clock",
+			timeoutMs: 900_000,
+		});
+		expect(wallClockMsg).toContain("wall-clock timeout");
+		expect(wallClockMsg).toContain("TALLOW_SUBAGENT_WALL_CLOCK_TIMEOUT_MS");
+		expect(wallClockMsg).not.toContain("slow provider startup");
+
+		const startupMsg = createStalledSubagentErrorMessage({
+			elapsedMs: 60_000,
+			kind: "stalled",
+			phase: "startup",
+			timeoutMs: 60_000,
+		});
+		expect(startupMsg).not.toContain("wall-clock");
+	});
+
 	it("treats message updates and tool execution events as heartbeats", () => {
 		expect(isWatchdogHeartbeatEventType("message_update")).toBe(true);
 		expect(isWatchdogHeartbeatEventType("tool_execution_start")).toBe(true);
@@ -136,10 +185,12 @@ describe("foreground subagent liveness watchdog", () => {
 			[SUBAGENT_INACTIVITY_TIMEOUT_MS_ENV]: "7000",
 			[SUBAGENT_STARTUP_TIMEOUT_MS_ENV]: "3000",
 			[SUBAGENT_TOOL_EXECUTION_TIMEOUT_MS_ENV]: "11000",
+			[SUBAGENT_WALL_CLOCK_TIMEOUT_MS_ENV]: "1800000",
 		});
 		expect(thresholds.inactivityTimeoutMs).toBe(7_000);
 		expect(thresholds.startupTimeoutMs).toBe(3_000);
 		expect(thresholds.toolExecutionTimeoutMs).toBe(11_000);
+		expect(thresholds.wallClockTimeoutMs).toBe(1_800_000);
 	});
 
 	it("stalled termination escalates and resolves without hanging", async () => {