@dungle-scrubs/tallow 0.8.27 → 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/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/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>");
 	});

package/extensions/subagent-tool/index.ts

@@ -1414,14 +1414,16 @@ function renderSubagentCall(args: Record<string, unknown>, theme: Theme) {
 
 	const agentName = (args.agent as string) || "...";
 	const task = typeof args.task === "string" ? args.task : "...";
-	appendSection(lines, [formatSubagentHeader(theme, "single", agentName)]);
+	// Single mode: skip the redundant "subagent single" header — the result
+	// renderer already shows "subagent running <duration> <agent>" with a spinner.
+	// Just show the task preview so the user sees what was requested.
 	const metaLine = formatMetaLine(theme, [scopeEntry, model ? `model:${model}` : undefined]);
 	if (metaLine) appendSection(lines, [metaLine]);
 	appendSection(
 		lines,
 		[formatPresentationText(theme, "process_output", toCompactPreview(task, 200))],
 		{
-			blankBefore: true,
+			blankBefore: false,
 		}
 	);
 	return new Text(lines.join("\n"), 0, 0);

package/extensions/subagent-tool/process.ts

@@ -1049,8 +1049,13 @@ export async function spawnBackgroundSubagent(
 		buffer = lines.pop() || "";
 		for (const line of lines) {
 			if (!line.trim()) continue;
+			// Strip leading terminal escape sequences — see foreground processLine.
+			let cleaned = line;
+			const jsonStart = cleaned.indexOf("{");
+			if (jsonStart > 0) cleaned = cleaned.slice(jsonStart);
+			else if (jsonStart < 0) continue;
 			try {
-				const event = JSON.parse(line);
+				const event = JSON.parse(cleaned);
 
 				// Emit subagent_tool_call when tool starts
 				if (event.type === "tool_call_start") {
@@ -1120,13 +1125,18 @@ export async function spawnBackgroundSubagent(
 
 	proc.on("close", (code) => {
 		if (buffer.trim()) {
-			try {
-				const event = JSON.parse(buffer);
-				if (event.type === "message_end" && event.message) {
-					result.messages.push(event.message);
+			let cleaned = buffer;
+			const jsonStart = cleaned.indexOf("{");
+			if (jsonStart > 0) cleaned = cleaned.slice(jsonStart);
+			if (jsonStart >= 0) {
+				try {
+					const event = JSON.parse(cleaned);
+					if (event.type === "message_end" && event.message) {
+						result.messages.push(event.message);
+					}
+				} catch {
+					/* ignore */
 				}
-			} catch {
-				/* ignore */
 			}
 		}
 		const finalOutput = getFinalOutput(result.messages);
@@ -1508,10 +1518,18 @@ export async function runSingleAgent(
 
 			const processLine = (line: string) => {
 				if (!line.trim()) return;
+				// Strip leading terminal escape sequences (e.g. OSC 1337 SetUserVar)
+				// that may leak into stdout when extensions write directly to
+				// process.stdout in JSON-mode child processes. Without this,
+				// JSON.parse silently fails and heartbeat events are lost.
+				let cleaned = line;
+				const jsonStart = cleaned.indexOf("{");
+				if (jsonStart > 0) cleaned = cleaned.slice(jsonStart);
+				else if (jsonStart < 0) return;
 				// biome-ignore lint/suspicious/noExplicitAny: pi subagent JSON protocol has dynamic shape
 				let event: Record<string, any>;
 				try {
-					event = JSON.parse(line);
+					event = JSON.parse(cleaned);
 				} catch {
 					return;
 				}

package/extensions/teams-tool/sessions/spawn.ts

@@ -15,7 +15,7 @@ import {
 	SessionManager,
 	SettingsManager,
 } from "@mariozechner/pi-coding-agent";
-import { applyKnownModelMetadataOverrides } from "../../../src/model-metadata-overrides.js";
+import { applyKnownModelMetadataOverrides } from "../../../runtime/model-metadata-overrides.js";
 import { getTallowHomeDir, getTallowPath } from "../../_shared/tallow-paths.js";
 import {
 	type AgentConfig,
@@ -255,7 +255,7 @@ export async function spawnTeammateSession(
 	// Use the user's tallow auth and model config so teammates inherit
 	// API keys and custom model definitions from the main session.
 	const authStorage = AuthStorage.create(getTallowPath("auth.json"));
-	const modelRegistry = new ModelRegistry(authStorage, getTallowPath("models.json"));
+	const modelRegistry = ModelRegistry.create(authStorage, getTallowPath("models.json"));
 	applyKnownModelMetadataOverrides(modelRegistry);
 	const model = modelRegistry.find(resolvedModel.provider, resolvedModel.id);
 	if (!model) {

package/extensions/welcome-screen/__tests__/welcome-screen.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import welcomeScreen from "../index.js";
+
+describe("welcome-screen extension", () => {
+	test("registers session_start handler", () => {
+		const events: string[] = [];
+		const pi = {
+			on: (event: string) => {
+				events.push(event);
+			},
+		} as unknown as ExtensionAPI;
+
+		welcomeScreen(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;
+
+		welcomeScreen(pi);
+		expect(commands).toHaveLength(0);
+		expect(tools).toHaveLength(0);
+	});
+});

package/extensions/welcome-screen/extension.json

@@ -0,0 +1,20 @@
+{
+	"name": "welcome-screen",
+	"version": "0.1.0",
+	"description": "ASCII art welcome screen with version display and update notification",
+	"whenToUse": "Replaces the default startup header with a branded ASCII art welcome screen.",
+	"capabilities": {
+		"events": ["session_start"]
+	},
+	"permissionSurface": {
+		"filesystem": "none",
+		"shell": false,
+		"network": true,
+		"subprocess": false
+	},
+	"category": "ui",
+	"tags": ["welcome", "header", "startup", "branding"],
+	"files": ["index.ts"],
+	"relationships": [],
+	"npmDependencies": {}
+}