@oh-my-pi/pi-coding-agent 14.1.1 → 14.2.0

package/src/task/index.ts

@@ -18,6 +18,7 @@ import path from "node:path";
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env, prompt, Snowflake } from "@oh-my-pi/pi-utils";
+import type { TSchema } from "@sinclair/typebox";
 import type { ToolSession } from "..";
 import { resolveAgentModelPatterns } from "../config/model-resolver";
 import type { Theme } from "../modes/theme/theme";
@@ -34,17 +35,16 @@ import { runSubprocess } from "./executor";
 import { resolveIsolationBackendForTaskExecution } from "./isolation-backend";
 import { AgentOutputManager } from "./output-manager";
 import { mapWithConcurrencyLimit, Semaphore } from "./parallel";
-import { renderCall, renderResult } from "./render";
+import { renderResult, renderCall as renderTaskCall } from "./render";
+import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
 import { renderTemplate } from "./template";
 import {
 	type AgentDefinition,
 	type AgentProgress,
+	getTaskSchema,
 	type SingleResult,
 	type TaskParams,
-	type TaskSchema,
 	type TaskToolDetails,
-	taskSchema,
-	taskSchemaNoIsolation,
 } from "./types";
 import {
 	applyBaseline,
@@ -133,16 +133,54 @@ function renderDescription(
 	isolationEnabled: boolean,
 	asyncEnabled: boolean,
 	disabledAgents: string[],
+	simpleMode: TaskSimpleMode,
 ): string {
 	const filteredAgents = disabledAgents.length > 0 ? agents.filter(a => !disabledAgents.includes(a.name)) : agents;
+	const { contextEnabled, customSchemaEnabled } = getTaskSimpleModeCapabilities(simpleMode);
 	return prompt.render(taskDescriptionTemplate, {
 		agents: filteredAgents,
 		MAX_CONCURRENCY: maxConcurrency,
 		isolationEnabled,
 		asyncEnabled,
+		contextEnabled,
+		customSchemaEnabled,
+		defaultMode: simpleMode === "default",
+		schemaFreeMode: simpleMode === "schema-free",
+		independentMode: simpleMode === "independent",
 	});
 }
 
+function createTaskModeError(text: string): AgentToolResult<TaskToolDetails> {
+	return {
+		content: [{ type: "text", text }],
+		details: { projectAgentsDir: null, results: [], totalDurationMs: 0 },
+	};
+}
+
+function validateTaskModeParams(simpleMode: TaskSimpleMode, params: TaskParams): string | undefined {
+	const { contextEnabled, customSchemaEnabled } = getTaskSimpleModeCapabilities(simpleMode);
+	const disallowedFields: string[] = [];
+	if (!contextEnabled && params.context !== undefined) {
+		disallowedFields.push("context");
+	}
+	if (!customSchemaEnabled && params.schema !== undefined) {
+		disallowedFields.push("schema");
+	}
+	if (disallowedFields.length === 0) {
+		return undefined;
+	}
+
+	if (simpleMode === "schema-free") {
+		return "task.simple is set to schema-free, so the task tool does not accept `schema`. Remove it and rely on the selected agent definition or inherited session schema.";
+	}
+
+	if (disallowedFields.length === 1) {
+		return `task.simple is set to independent, so the task tool does not accept \`${disallowedFields[0]}\`. Put everything the subagent needs inside each task assignment.`;
+	}
+
+	return "task.simple is set to independent, so the task tool does not accept `context` or `schema`. Put all required background and output expectations inside each task assignment or the selected agent definition.";
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Tool Class
 // ═══════════════════════════════════════════════════════════════════════════
@@ -153,16 +191,23 @@ function renderDescription(
  * Requires async initialization to discover available agents.
  * Use `TaskTool.create(session)` to instantiate.
  */
-export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
+export class TaskTool implements AgentTool<TSchema, TaskToolDetails, Theme> {
 	readonly name = "task";
 	readonly label = "Task";
 	readonly strict = true;
-	readonly parameters: TaskSchema;
-	readonly renderCall = renderCall;
 	readonly renderResult = renderResult;
 	readonly #discoveredAgents: AgentDefinition[];
 	readonly #blockedAgent: string | undefined;
 
+	get parameters(): TSchema {
+		const isolationEnabled = this.session.settings.get("task.isolation.mode") !== "none";
+		return getTaskSchema({ isolationEnabled, simpleMode: this.#getTaskSimpleMode() });
+	}
+
+	renderCall(args: unknown, options: Parameters<typeof renderTaskCall>[1], theme: Theme) {
+		return renderTaskCall(args as TaskParams, options, theme);
+	}
+
 	/** Dynamic description that reflects current disabled-agent settings */
 	get description(): string {
 		const disabledAgents = this.session.settings.get("task.disabledAgents") as string[];
@@ -174,33 +219,42 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 			isolationMode !== "none",
 			this.session.settings.get("async.enabled"),
 			disabledAgents,
+			this.#getTaskSimpleMode(),
 		);
 	}
 	private constructor(
 		private readonly session: ToolSession,
 		discoveredAgents: AgentDefinition[],
-		isolationEnabled: boolean,
 	) {
-		this.parameters = isolationEnabled ? taskSchema : taskSchemaNoIsolation;
 		this.#blockedAgent = $env.PI_BLOCKED_AGENT;
 		this.#discoveredAgents = discoveredAgents;
 	}
 
+	#getTaskSimpleMode(): TaskSimpleMode {
+		return this.session.settings.get("task.simple");
+	}
+
 	/**
 	 * Create a TaskTool instance with async agent discovery.
 	 */
 	static async create(session: ToolSession): Promise<TaskTool> {
-		const isolationMode = session.settings.get("task.isolation.mode");
 		const { agents } = await discoverAgents(session.cwd);
-		return new TaskTool(session, agents, isolationMode !== "none");
+		return new TaskTool(session, agents);
 	}
 
 	async execute(
 		_toolCallId: string,
-		params: TaskParams,
+		rawParams: unknown,
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<TaskToolDetails>,
 	): Promise<AgentToolResult<TaskToolDetails>> {
+		const params = rawParams as TaskParams;
+		const simpleMode = this.#getTaskSimpleMode();
+		const validationError = validateTaskModeParams(simpleMode, params);
+		if (validationError) {
+			return createTaskModeError(validationError);
+		}
+
 		const asyncEnabled = this.session.settings.get("async.enabled");
 		const selectedAgent = this.#discoveredAgents.find(agent => agent.name === params.agent);
 		if (!asyncEnabled || selectedAgent?.blocking === true) {
@@ -225,7 +279,9 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 		const uniqueIds = await outputManager.allocateBatch(taskItems.map(t => t.id));
 		const fallbackAgentSource =
 			this.#discoveredAgents.find(agent => agent.name === params.agent)?.source ?? "bundled";
-		const renderedTasks = taskItems.map(taskItem => renderTemplate(params.context, taskItem));
+		const { contextEnabled } = getTaskSimpleModeCapabilities(simpleMode);
+		const sharedContext = contextEnabled ? params.context : undefined;
+		const renderedTasks = taskItems.map(taskItem => renderTemplate(sharedContext, taskItem, simpleMode));
 		const progressByTaskId = new Map<string, AgentProgress>();
 		for (let index = 0; index < renderedTasks.length; index++) {
 			const renderedTask = renderedTasks[index];
@@ -445,6 +501,9 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 		const startTime = Date.now();
 		const { agents, projectAgentsDir } = await discoverAgents(this.session.cwd);
 		const { agent: agentName, context, schema: outputSchema } = params;
+		const simpleMode = this.#getTaskSimpleMode();
+		const { contextEnabled, customSchemaEnabled } = getTaskSimpleModeCapabilities(simpleMode);
+		const sharedContext = contextEnabled ? context : undefined;
 		const isolationMode = this.session.settings.get("task.isolation.mode");
 		const isolationRequested = "isolated" in params ? params.isolated === true : false;
 		const isIsolated = isolationMode !== "none" && isolationRequested;
@@ -530,8 +589,11 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 		});
 		const thinkingLevelOverride = effectiveAgent.thinkingLevel;
 
-		// Output schema priority: caller params > agent frontmatter > inherited from parent session
-		const effectiveOutputSchema = outputSchema ?? effectiveAgent.output ?? this.session.outputSchema;
+		// Output schema priority: task call > agent frontmatter > inherited parent session.
+		// task.simple can disable the task-call override while leaving agent/session schemas intact.
+		const effectiveOutputSchema = customSchemaEnabled
+			? (outputSchema ?? effectiveAgent.output ?? this.session.outputSchema)
+			: (effectiveAgent.output ?? this.session.outputSchema);
 
 		// Handle empty or missing tasks
 		if (!params.tasks || params.tasks.length === 0) {
@@ -539,7 +601,9 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 				content: [
 					{
 						type: "text",
-						text: `No tasks provided. Use: { agent, context, tasks: [{id, description, args}, ...] }`,
+						text: contextEnabled
+							? "No tasks provided. Use: { agent, context?, tasks: [{ id, description, assignment }, ...] }"
+							: "No tasks provided. Use: { agent, tasks: [{ id, description, assignment }, ...] }",
 					},
 				],
 				details: {
@@ -728,8 +792,8 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 			}
 			const tasksWithUniqueIds = tasks.map((t, i) => ({ ...t, id: uniqueIds[i] }));
 
-			// Build full prompts with context prepended
-			const tasksWithContext = tasksWithUniqueIds.map(t => renderTemplate(context, t));
+			// Build full prompts using shared context only when the current task mode allows it.
+			const tasksWithContext = tasksWithUniqueIds.map(t => renderTemplate(sharedContext, t, simpleMode));
 			const availableSkills = [...(this.session.skills ?? [])];
 			const contextFiles = this.session.contextFiles?.filter(
 				file => path.basename(file.path).toLowerCase() !== "agents.md",

package/src/task/simple-mode.ts

@@ -0,0 +1,27 @@
+export const TASK_SIMPLE_MODES = ["default", "schema-free", "independent"] as const;
+
+export type TaskSimpleMode = (typeof TASK_SIMPLE_MODES)[number];
+
+interface TaskSimpleModeCapabilities {
+	contextEnabled: boolean;
+	customSchemaEnabled: boolean;
+}
+
+const TASK_SIMPLE_MODE_CAPABILITIES: Record<TaskSimpleMode, TaskSimpleModeCapabilities> = {
+	default: {
+		contextEnabled: true,
+		customSchemaEnabled: true,
+	},
+	"schema-free": {
+		contextEnabled: true,
+		customSchemaEnabled: false,
+	},
+	independent: {
+		contextEnabled: false,
+		customSchemaEnabled: false,
+	},
+};
+
+export function getTaskSimpleModeCapabilities(mode: TaskSimpleMode): TaskSimpleModeCapabilities {
+	return TASK_SIMPLE_MODE_CAPABILITIES[mode];
+}

package/src/task/template.ts

@@ -1,5 +1,6 @@
 import { prompt } from "@oh-my-pi/pi-utils";
 import subagentUserPromptTemplate from "../prompts/system/subagent-user-prompt.md" with { type: "text" };
+import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
 import type { TaskItem } from "./types";
 
 interface RenderResult {
@@ -16,16 +17,29 @@ interface RenderResult {
  *
  * If context is provided, it is prepended with a separator.
  */
-export function renderTemplate(context: string | undefined, task: TaskItem): RenderResult {
+export function renderTemplate(
+	context: string | undefined,
+	task: TaskItem,
+	simpleMode: TaskSimpleMode = "default",
+): RenderResult {
 	let { id, description, assignment } = task;
 	assignment = assignment.trim();
-	context = context?.trim();
+	const { contextEnabled } = getTaskSimpleModeCapabilities(simpleMode);
+	context = contextEnabled ? context?.trim() : undefined;
 
 	if (!context || !assignment) {
+		if (simpleMode === "independent" && assignment) {
+			return {
+				task: prompt.render(subagentUserPromptTemplate, { assignment, independentMode: true }),
+				assignment,
+				id,
+				description,
+			};
+		}
 		return { task: assignment || context!, assignment: assignment || context!, id, description };
 	}
 	return {
-		task: prompt.render(subagentUserPromptTemplate, { context, assignment }),
+		task: prompt.render(subagentUserPromptTemplate, { context, assignment, independentMode: false }),
 		assignment,
 		id,
 		description,

package/src/task/types.ts

@@ -1,7 +1,8 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import { type Static, type TSchema, Type } from "@sinclair/typebox";
+import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
 import type { NestedRepoPatch } from "./worktree";
 
 /** Source of an agent definition */
@@ -56,42 +57,58 @@ export interface SubagentLifecyclePayload {
 	index: number;
 }
 
-/** Single task item for parallel execution */
-export const taskItemSchema = Type.Object({
-	id: Type.String({
-		description: "CamelCase identifier, max 48 chars",
-		maxLength: 48,
-	}),
-	description: Type.String({
-		description: "Short one-liner for UI display only — not seen by the subagent",
-	}),
-	assignment: Type.String({
-		description:
-			"Complete per-task instructions the subagent executes. Must follow the Target/Change/Edge Cases/Acceptance structure. Only include per-task deltas — shared background belongs in `context`.",
-	}),
-});
+const assignmentDescriptionForContextEnabled =
+	"Complete per-task instructions the subagent executes. Must follow the Target/Change/Edge Cases/Acceptance structure. Only include per-task deltas — shared background belongs in `context`.";
+const assignmentDescriptionForContextDisabled =
+	"Complete per-task instructions the subagent executes. Must follow the Target/Change/Edge Cases/Acceptance structure, and include any background that would otherwise live in `context` since shared context is disabled in this mode.";
+
+const createTaskItemSchema = (contextEnabled: boolean) =>
+	Type.Object({
+		id: Type.String({
+			description: "CamelCase identifier, max 48 chars",
+			maxLength: 48,
+		}),
+		description: Type.String({
+			description: "Short one-liner for UI display only — not seen by the subagent",
+		}),
+		assignment: Type.String({
+			description: contextEnabled ? assignmentDescriptionForContextEnabled : assignmentDescriptionForContextDisabled,
+		}),
+	});
+
+/** Single task item for parallel execution (default shape with context enabled). */
+export const taskItemSchema = createTaskItemSchema(true);
 export type TaskItem = Static<typeof taskItemSchema>;
 
-const createTaskSchema = (options: { isolationEnabled: boolean }) => {
-	const properties = {
+const createTaskSchema = (options: { isolationEnabled: boolean; simpleMode: TaskSimpleMode }) => {
+	const { contextEnabled, customSchemaEnabled } = getTaskSimpleModeCapabilities(options.simpleMode);
+	const itemSchema = createTaskItemSchema(contextEnabled);
+	const properties: Record<string, TSchema> = {
 		agent: Type.String({ description: "Agent type for all tasks in this batch" }),
-		context: Type.Optional(
+		tasks: Type.Array(itemSchema, {
+			description: contextEnabled
+				? "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and self-contained given context + assignment."
+				: "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and fully self-contained inside assignment because shared context is disabled.",
+		}),
+	};
+
+	if (contextEnabled) {
+		properties.context = Type.Optional(
 			Type.String({
 				description:
 					"Shared background prepended to every task's assignment. Put goal, non-goals, constraints, conventions, reference paths, API contracts, and global acceptance commands here once — instead of duplicating across assignments.",
 			}),
-		),
-		schema: Type.Optional(
+		);
+	}
+
+	if (customSchemaEnabled) {
+		properties.schema = Type.Optional(
 			Type.String({
 				description:
 					"JSON-encoded JTD schema defining expected response structure. Output format belongs here — never in context or assignment.",
 			}),
-		),
-		tasks: Type.Array(taskItemSchema, {
-			description:
-				"Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and self-contained given context + assignment.",
-		}),
-	};
+		);
+	}
 
 	if (options.isolationEnabled) {
 		return Type.Object({
@@ -107,12 +124,42 @@ const createTaskSchema = (options: { isolationEnabled: boolean }) => {
 	return Type.Object(properties);
 };
 
-export const taskSchema = createTaskSchema({ isolationEnabled: true });
-export const taskSchemaNoIsolation = createTaskSchema({ isolationEnabled: false });
+export const taskSchema = createTaskSchema({ isolationEnabled: true, simpleMode: "default" });
+export const taskSchemaNoIsolation = createTaskSchema({ isolationEnabled: false, simpleMode: "default" });
+const taskSchemaSchemaFree = createTaskSchema({ isolationEnabled: true, simpleMode: "schema-free" });
+const taskSchemaSchemaFreeNoIsolation = createTaskSchema({ isolationEnabled: false, simpleMode: "schema-free" });
+const taskSchemaIndependent = createTaskSchema({ isolationEnabled: true, simpleMode: "independent" });
+const taskSchemaIndependentNoIsolation = createTaskSchema({ isolationEnabled: false, simpleMode: "independent" });
+const ALL_TASK_SCHEMAS = [
+	taskSchema,
+	taskSchemaNoIsolation,
+	taskSchemaSchemaFree,
+	taskSchemaSchemaFreeNoIsolation,
+	taskSchemaIndependent,
+	taskSchemaIndependentNoIsolation,
+] as const;
 
-export type TaskSchema = typeof taskSchema | typeof taskSchemaNoIsolation;
+type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
+export type TaskSchema = typeof taskSchema;
 
-export type TaskParams = Static<TaskSchema>;
+export function getTaskSchema(options: { isolationEnabled: boolean; simpleMode: TaskSimpleMode }): DynamicTaskSchema {
+	switch (options.simpleMode) {
+		case "schema-free":
+			return options.isolationEnabled ? taskSchemaSchemaFree : taskSchemaSchemaFreeNoIsolation;
+		case "independent":
+			return options.isolationEnabled ? taskSchemaIndependent : taskSchemaIndependentNoIsolation;
+		default:
+			return options.isolationEnabled ? taskSchema : taskSchemaNoIsolation;
+	}
+}
+
+export interface TaskParams {
+	agent: string;
+	context?: string;
+	schema?: string;
+	tasks: TaskItem[];
+	isolated?: boolean;
+}
 
 /** A code review finding reported by the reviewer agent */
 export interface ReviewFinding {

package/src/tools/ask.ts

@@ -407,10 +407,8 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 	): Promise<AgentToolResult<AskToolDetails>> {
 		// Headless fallback
 		if (!context?.hasUI || !context.ui) {
-			return {
-				content: [{ type: "text" as const, text: "Error: User prompt requires interactive mode" }],
-				details: {},
-			};
+			context?.abort();
+			throw new ToolAbortError("Ask tool requires interactive mode");
 		}
 
 		const extensionUi = context.ui;

package/src/tools/ast-edit.ts

@@ -12,6 +12,7 @@ import astEditDescription from "../prompts/tools/ast-edit.md" with { type: "text
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
+import { createFileRecorder, formatResultPath } from "./file-recorder";
 import type { OutputMeta } from "./output-meta";
 import {
 	combineSearchGlobs,
@@ -41,6 +42,7 @@ const astEditOpSchema = Type.Object({
 
 const astEditSchema = Type.Object({
 	ops: Type.Array(astEditOpSchema, {
+		minItems: 1,
 		description: "Rewrite ops as [{ pat, out }]",
 	}),
 	lang: Type.Optional(Type.String({ description: "Language override" })),
@@ -163,24 +165,11 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 			});
 
 			const dedupedParseErrors = dedupeParseErrors(result.parseErrors);
-			const formatPath = (filePath: string): string => {
-				const cleanPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
-				if (isDirectory) {
-					return cleanPath.replace(/\\/g, "/");
-				}
-				return path.basename(cleanPath);
-			};
+			const formatPath = (filePath: string): string => formatResultPath(filePath, isDirectory);
 
-			const files = new Set<string>();
-			const fileList: string[] = [];
+			const { record: recordFile, list: fileList } = createFileRecorder();
 			const fileReplacementCounts = new Map<string, number>();
 			const changesByFile = new Map<string, AstReplaceChange[]>();
-			const recordFile = (relativePath: string) => {
-				if (!files.has(relativePath)) {
-					files.add(relativePath);
-					fileList.push(relativePath);
-				}
-			};
 			for (const fileChange of result.fileChanges) {
 				const relativePath = formatPath(fileChange.path);
 				recordFile(relativePath);

package/src/tools/ast-grep.ts

@@ -5,13 +5,14 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { computeLineHash } from "../edit/line-hash";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import astGrepDescription from "../prompts/tools/ast-grep.md" with { type: "text" };
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
+import { createFileRecorder, formatResultPath } from "./file-recorder";
+import { formatMatchLine } from "./match-line-format";
 import type { OutputMeta } from "./output-meta";
 import {
 	combineSearchGlobs,
@@ -39,8 +40,8 @@ const astGrepSchema = Type.Object({
 	path: Type.Optional(Type.String({ description: "File, directory, or glob pattern to search (default: cwd)" })),
 	glob: Type.Optional(Type.String({ description: "Optional glob filter relative to path" })),
 	sel: Type.Optional(Type.String({ description: "Optional selector for contextual pattern mode" })),
-	limit: Type.Optional(Type.Number({ description: "Max matches (default: 50)" })),
-	offset: Type.Optional(Type.Number({ description: "Skip first N matches (default: 0)" })),
+	limit: Type.Optional(Type.Number({ description: "Max matches", default: 50 })),
+	offset: Type.Optional(Type.Number({ description: "Skip first N matches", default: 0 })),
 	context: Type.Optional(Type.Number({ description: "Context lines around each match" })),
 });
 
@@ -155,24 +156,11 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 				return parseError?.[1] ?? error;
 			});
 			const dedupedParseErrors = dedupeParseErrors(normalizedParseErrors);
-			const formatPath = (filePath: string): string => {
-				const cleanPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
-				if (isDirectory) {
-					return cleanPath.replace(/\\/g, "/");
-				}
-				return path.basename(cleanPath);
-			};
+			const formatPath = (filePath: string): string => formatResultPath(filePath, isDirectory);
 
-			const files = new Set<string>();
-			const fileList: string[] = [];
+			const { record: recordFile, list: fileList } = createFileRecorder();
 			const fileMatchCounts = new Map<string, number>();
 			const matchesByFile = new Map<string, AstFindMatch[]>();
-			const recordFile = (relativePath: string) => {
-				if (!files.has(relativePath)) {
-					files.add(relativePath);
-					fileList.push(relativePath);
-				}
-			};
 			for (const match of result.matches) {
 				const relativePath = formatPath(match.path);
 				recordFile(relativePath);
@@ -211,15 +199,8 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 					const matchLines = match.text.split("\n");
 					const lineNumbers = matchLines.map((_, index) => match.startLine + index);
 					const lineWidth = Math.max(...lineNumbers.map(value => value.toString().length));
-					const formatLine = (lineNumber: number, line: string, isMatch: boolean): string => {
-						const separator = isMatch ? ":" : "-";
-						if (useHashLines) {
-							const ref = `${lineNumber}#${computeLineHash(lineNumber, line)}`;
-							return `${ref}${separator}${line}`;
-						}
-						const padded = lineNumber.toString().padStart(lineWidth, " ");
-						return `${padded}${separator}${line}`;
-					};
+					const formatLine = (lineNumber: number, line: string, isMatch: boolean): string =>
+						formatMatchLine(lineNumber, line, isMatch, { useHashLines, lineWidth });
 					for (let index = 0; index < matchLines.length; index++) {
 						outputLines.push(formatLine(match.startLine + index, matchLines[index], index === 0));
 					}

package/src/tools/bash-skill-urls.ts

@@ -4,14 +4,14 @@ import type { Skill } from "../extensibility/skills";
 import { type LocalProtocolOptions, resolveLocalUrlToPath } from "../internal-urls";
 import { validateRelativePath } from "../internal-urls/skill-protocol";
 import type { InternalResource } from "../internal-urls/types";
+import { normalizeLocalScheme } from "./path-utils";
 import { ToolError } from "./tool-errors";
 
 /** Regex to find skill:// tokens in command text. */
 const SKILL_URL_PATTERN = /'skill:\/\/[^'\s")`\\]+'|"skill:\/\/[^"\s')`\\]+"|skill:\/\/[^\s'")`\\]+/g;
 
-/** Regex to find supported internal URL tokens in command text. */
-const INTERNAL_URL_PATTERN =
-	/'(?:skill|agent|artifact|plan|memory|rule|local):\/\/[^'\s")`\\]+'|"(?:skill|agent|artifact|plan|memory|rule|local):\/\/[^"\s')`\\]+"|(?:skill|agent|artifact|plan|memory|rule|local):\/\/[^\s'")`\\]+/g;
+const INTERNAL_URL_PATTERN_INCLUDING_NORMALIZED_LOCAL =
+	/'(?:skill|agent|artifact|plan|memory|rule|local):\/\/[^'\s")`\\]+'|"(?:skill|agent|artifact|plan|memory|rule|local):\/\/[^"\s')`\\]+"|(?:skill|agent|artifact|plan|memory|rule|local):\/\/[^\s'")`\\]+|'local:\/[^'\s")`\\]+'|"local:\/[^"\s')`\\]+"|(?<![./\\\\\w-])local:\/[^\s'")`\\]+/g;
 
 const SUPPORTED_INTERNAL_SCHEMES = ["skill", "agent", "artifact", "plan", "memory", "rule", "local"] as const;
 
@@ -146,12 +146,13 @@ function shellEscape(p: string): string {
 }
 
 async function resolveInternalUrlToPath(
-	url: string,
+	rawUrl: string,
 	skills: readonly Skill[],
 	internalRouter?: InternalUrlResolver,
 	localOptions?: LocalProtocolOptions,
 	ensureLocalParentDirs?: boolean,
 ): Promise<string> {
+	const url = normalizeLocalScheme(rawUrl);
 	const scheme = extractScheme(url);
 	if (!scheme) {
 		throw new ToolError(`Unsupported internal URL in bash command: ${url}`);
@@ -218,9 +219,9 @@ export function expandSkillUrls(command: string, skills: readonly Skill[]): stri
  * Supported schemes: skill://, agent://, artifact://, memory://, rule://, local://
  */
 export async function expandInternalUrls(command: string, options: InternalUrlExpansionOptions): Promise<string> {
-	if (!command.includes("://")) return command;
+	if (!command.includes("://") && !command.includes("local:/")) return command;
 
-	const matches = Array.from(command.matchAll(INTERNAL_URL_PATTERN));
+	const matches = Array.from(command.matchAll(INTERNAL_URL_PATTERN_INCLUDING_NORMALIZED_LOCAL));
 	if (matches.length === 0) return command;
 
 	let expanded = command;
@@ -230,7 +231,8 @@ export async function expandInternalUrls(command: string, options: InternalUrlEx
 		const index = match.index;
 		if (index === undefined) continue;
 
-		const url = unquoteToken(token);
+		const rawUrl = unquoteToken(token);
+		const url = normalizeLocalScheme(rawUrl);
 		const resolvedPath = await resolveInternalUrlToPath(
 			url,
 			options.skills,

package/src/tools/bash.ts

@@ -9,7 +9,7 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { truncateToVisualLines } from "../modes/components/visual-truncate";
 import type { Theme } from "../modes/theme/theme";
 import bashDescription from "../prompts/tools/bash.md" with { type: "text" };
-import { DEFAULT_MAX_BYTES, TailBuffer } from "../session/streaming-output";
+import { DEFAULT_MAX_BYTES, streamTailUpdates, TailBuffer } from "../session/streaming-output";
 import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { getSixelLineMask } from "../utils/sixel";
@@ -38,7 +38,7 @@ const bashSchemaBase = Type.Object({
 				"Additional environment variables passed to the command and rendered inline as shell assignments; prefer this for multiline or quote-heavy content",
 		}),
 	),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 300)" })),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds", default: 300 })),
 	cwd: Type.Optional(Type.String({ description: "Working directory (default: cwd)" })),
 	head: Type.Optional(Type.Number({ description: "Return only first N lines of output" })),
 	tail: Type.Optional(Type.Number({ description: "Return only last N lines of output" })),
@@ -512,7 +512,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			: undefined;
 
 		// Resolve protocol URLs (skill://, agent://, etc.) in extracted cwd.
-		if (cwd?.includes("://")) {
+		if (cwd?.includes("://") || cwd?.includes("local:/")) {
 			cwd = await expandInternalUrls(cwd, { ...internalUrlOptions, noEscape: true });
 		}
 
@@ -612,15 +612,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 					env: resolvedEnv,
 					artifactPath,
 					artifactId,
-					onChunk: chunk => {
-						tailBuffer.append(chunk);
-						if (onUpdate) {
-							onUpdate({
-								content: [{ type: "text", text: tailBuffer.text() }],
-								details: {},
-							});
-						}
-					},
+					onChunk: streamTailUpdates(tailBuffer, onUpdate),
 				});
 		if (result.cancelled) {
 			if (signal?.aborted) {

package/src/tools/browser.ts

@@ -411,7 +411,7 @@ const browserSchema = Type.Object({
 	value: Type.Optional(Type.String({ description: "Value to set (fill)" })),
 	attribute: Type.Optional(Type.String({ description: "Attribute name to read (get_attribute)" })),
 	key: Type.Optional(Type.String({ description: "Keyboard key to press (press)" })),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 30)" })),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds", default: 30 })),
 	wait_until: Type.Optional(
 		StringEnum(["load", "domcontentloaded", "networkidle0", "networkidle2"], {
 			description: "Navigation wait condition (goto)",