@oh-my-pi/pi-coding-agent 10.2.2 → 10.3.0

package/src/prompts/tools/task.md

@@ -5,23 +5,23 @@ Launch agents to handle complex, multi-step tasks autonomously.
 <critical>
 ## Context is everything
 
-Subagents fail when context is vague. They cannot read your mind or infer project conventions. Every task needs:
+Subagents fail with vague context. Every task needs:
 1. **Goal** - What this accomplishes (one sentence)
 2. **Constraints** - Hard requirements, banned approaches, naming conventions
 3. **Existing Code** - File paths and function signatures to use as patterns
 4. **API Contract** - If the task produces or consumes an interface, spell it out
 
-Subagents CAN grep the parent conversation file for supplementary details. They CANNOT grep for:
+Subagents CAN grep parent conversation file for supplementary details, but CANNOT grep for:
 - Decisions you made but didn't write down
 - Conventions that exist only in your head
 - Which of 50 possible approaches you want
-  **Rule of thumb:** If you'd need to answer a clarifying question for a junior dev to do this task, that information belongs in context.
+  **Rule of thumb:** If you'd answer clarifying question for junior dev, info belongs in context.
 </critical>
 
 <context-structure>
 ## Required context structure
 
-Use this template. Sections can be omitted only if truly N/A.
+Use this template. Omit sections only if N/A.
 
 ````
 ## Goal
@@ -33,7 +33,7 @@ Use this template. Sections can be omitted only if truly N/A.
 - [What already exists vs what to create]
 
 ## Existing Code
-Reference files the agent MUST read or use as patterns:
+Reference files the agent MUST read/use as patterns:
 - `path/to/file.ts` - [what pattern it demonstrates]
 - `path/to/other.rs` - [what to reuse from it]
 
@@ -50,19 +50,13 @@ fn example(input: Type) -> Result<Output>
 {{files}}
 ````
 
-### Bad context (agent will fail or guess wrong)
+### Bad context (agent fails or guesses wrong)
 
 ```
 N-API migration. Keep highlight sync. Use JsString. No WASM.
 Task: {{description}} Files: {{files}}
 ```
 
-Why it fails:
-- No existing code to reference - agent doesn't know your patterns
-- No API contract - agent will invent signatures that don't match consumers
-- No goal - agent doesn't know what success looks like
-- "Keep highlight sync" is meaningless without knowing what highlight is or where it lives
-
 ### Good context (agent can act confidently)
 
 ````
@@ -71,9 +65,9 @@ Port grep module from WASM to N-API, matching existing text module patterns.
 
 ## Constraints
 - Use `#[napi]` attribute macro on all exports (not `#[napi(js_name = "...")]`)
-- Return `napi::Result<T>` for fallible ops, never panic
-- Use `spawn_blocking` for any operation that touches filesystem or runs >1ms
-- Accept `JsString` for string params (NOT JsStringUtf8 - it has lifetime issues)
+- Return `napi::Result<T>` for fallible ops; never panic
+- Use `spawn_blocking` for filesystem ops or >1ms work
+- Accept `JsString` for string params (NOT JsStringUtf8; lifetime issues)
 - Keep all existing function names - TS bindings depend on them
 - No new crate dependencies
 
@@ -104,36 +98,36 @@ pub async fn search(pattern: JsString, path: JsString, env: Env) -> napi::Result
 
 <parallelization>
 ## When to parallelize vs sequence
-**The test:** Can agent B write correct code without seeing agent A's output?
+**Test:** Can agent B write correct code without seeing A's output?
 - If YES → parallelize
 - If NO → sequence (A completes, then B runs with A's output in context)
 
-### Dependency patterns that MUST be sequential
+### Dependencies that MUST be sequential
 
 |First|Then|Why|
 |---|---|---|
-|Create Rust API|Update TS bindings|Bindings need to know export names and signatures|
-|Define interface/types|Implement consumers|Consumers need the contract|
-|Scaffold with signatures|Implement bodies|Implementations need the shape|
+|Create Rust API|Update TS bindings|Bindings need export names and signatures|
+|Define interface/types|Implement consumers|Consumers need contract|
+|Scaffold with signatures|Implement bodies|Implementations need shape|
 |Core module|Dependent modules|Dependents import from core|
 
 ### Safe to parallelize
-- Independent modules that don't import each other
+- Independent modules not importing each other
 - Tests for already-implemented code
 - Documentation for stable APIs
 - Refactors in isolated file scopes
 
 ### Phased execution pattern
 
-For migrations/refactors with layers:
+For layered migrations/refactors:
 **Phase 1 - Foundation (do yourself or single task):**
-Create the scaffold, define interfaces, establish API shape. Never fan out until the contract is known.
+Create scaffold, define interfaces, establish API shape. Never fan out until contract known.
 **Phase 2 - Parallel implementation:**
-Fan out to independent tasks that all consume the same known interface. Include the API contract from Phase 1 in every task's context.
+Fan out to independent tasks consuming same known interface. Include Phase 1 API contract in every task's context.
 **Phase 3 - Integration (do yourself):**
-Wire things together, update build/CI, fix any mismatches.
+Wire things together, update build/CI, fix mismatches.
 **Phase 4 - Dependent layer:**
-Fan out again for work that consumes Phase 2 outputs.
+Fan out again for work consuming Phase 2 outputs.
 
 ### Example: WASM to N-API migration
 **WRONG** (launched together, will fail):
@@ -168,15 +162,14 @@ tasks: [
 
 <parameters>
 - `agent`: Agent type for all tasks
-- `context`: Template with `{{placeholders}}`. **Must follow the structure above.** Include Goal, Constraints, Existing Code references. Subagents can search parent context for background, but core requirements must be explicit here.
+- `context`: Template with `{{placeholders}}`; **Must follow structure above**.
 - `isolated`: (optional) Run in git worktree, return patches
 - `tasks`: Array of `{id, description, args}`
   - `id`: CamelCase identifier (max 32 chars)
-  - `description`: What the task does (for logging)
+  - `description`: What task does (for logging)
   - `args`: Object with keys matching `{{placeholders}}` in context
   - `skills`: (optional) Skill names to preload
-- `schema`: JTD schema for response structure. **Required.** Use typed properties, not `{ "type": "string" }`.
-**Schema goes in `schema` parameter. Never describe output format in `context`.**
+- `schema`: JTD schema for response structure (**required**; use typed properties, not `{ "type": "string" }`). **Schema goes in `schema`; never describe output format in `context`.**
 </parameters>
 
 <agents>
@@ -189,11 +182,6 @@ tasks: [
 </agents>
 
 <avoid>
-- Terse context that requires agents to guess conventions
-- Launching dependent tasks in parallel (bindings + API, consumer + producer)
-- Missing "Existing Code" references - agents need patterns to follow
-- Assuming agents know your codebase - they start fresh each time
-- Describing output format in context instead of schema
 - Single tasks doing too much - prefer focused, file-scoped tasks
 </avoid>
 ````

package/src/prompts/tools/todo-write.md

@@ -1,49 +1,43 @@
 # Todo Write
 
-Create and manage a structured task list for your current coding session.
+Create/manage structured task list for coding session.
 
 <conditions>
-Use this tool proactively in these scenarios:
-1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-3. User explicitly requests todo list - When the user directly asks you to use the todo list
-4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-5. After receiving new instructions - Immediately capture user requirements as todos
-6. When you start working on a task - Mark it as in_progress BEFORE beginning work
-7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+Use proactively:
+1. Complex multi-step tasks requiring 3+ steps/actions
+2. User requests todo list
+3. User provides multiple tasks (numbered/comma-separated)
+4. After new instructions—capture requirements as todos
+5. Starting task—mark in_progress BEFORE beginning
+6. After completing—mark completed, add follow-up tasks found
 </conditions>
 
 <protocol>
-1. **Task States**: Use these states to track progress:
-	 - pending: Task not yet started
-	 - in_progress: Currently working on
-	 - completed: Task finished successfully
+1. **Task States**:
+	 - pending: not started
+	 - in_progress: working
+	 - completed: finished
 2. **Task Management**:
-   - Update task status in real-time as you work
-   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
-   - Multiple tasks may be in_progress simultaneously when working in parallel
-   - Remove tasks that are no longer relevant from the list entirely
+   - Update status in real time
+   - Mark complete IMMEDIATELY after finishing (no batching)
+   - Multiple tasks may be in_progress in parallel
+   - Remove tasks no longer relevant
 3. **Task Completion Requirements**:
-   - ONLY mark a task as completed when you have FULLY accomplished it
-   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
-   - When blocked, create a new task describing what needs to be resolved
-   - Never mark a task as completed if:
-     - Tests are failing
-     - Implementation is partial
-     - You encountered unresolved errors
-	   - You couldn't find necessary files or dependencies
+   - ONLY mark completed when FULLY accomplished
+   - On errors/blockers/inability to finish, keep in_progress
+   - When blocked, create task describing what needs resolving
 4. **Task Breakdown**:
 	 - Create specific, actionable items
-	 - Break complex tasks into smaller, manageable steps
-	 - Use clear, descriptive task names
+	 - Break complex tasks into smaller steps
+	 - Use clear, descriptive names
 </protocol>
 
 <output>
-Returns confirmation that the todo list has been updated. The updated list is displayed to the user in the UI, showing each task's status (pending, in_progress, completed) and description.
+Returns confirmation todo list updated.
 </output>
 
 <important>
-When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.
+When in doubt, use this.
 </important>
 
 <example name="use-dark-mode">
@@ -53,20 +47,17 @@ User: Add dark mode toggle to settings. Run tests when done.
 
 <example name="use-features">
 User: Implement user registration, product catalog, shopping cart, checkout.
-→ Creates todos for each feature, broken into subtasks
+→ Creates todos per feature with subtasks
 </example>
 
 <example name="skip">
 User: Run npm install / Add a comment to this function / What does git status do?
-→ Just do it directly. Single-step or informational tasks don't need tracking.
+→ Do directly. Single-step/informational tasks need no tracking.
 </example>
 
 <avoid>
-Skip using this tool when:
-1. There is only a single, straightforward task
-2. The task is trivial and tracking it provides no organizational benefit
-3. The task can be completed in less than 3 trivial steps
-4. The task is purely conversational or informational
-
-If there is only one trivial task to do, just do it directly.
+Skip when:
+1. Single straightforward task
+2. Task completable in <3 trivial steps
+3. Task purely conversational/informational
 </avoid>

package/src/prompts/tools/write.md

@@ -1,14 +1,14 @@
 # Write
 
-Creates or overwrites a file at the specified path.
+Creates or overwrites file at specified path.
 
 <conditions>
-- Creating new files explicitly required by the task
+- Creating new files explicitly required by task
 - Replacing entire file contents when editing would be more complex
 </conditions>
 
 <output>
-Confirmation of file creation/write with path. When LSP is available, content may be auto-formatted before writing and diagnostics are returned. Returns error if write fails (permissions, invalid path, disk full).
+Confirmation of file creation/write with path. When LSP available, content may be auto-formatted before writing and diagnostics returned. Returns error if write fails (permissions, invalid path, disk full).
 </output>
 
 <critical>

package/src/sdk.ts

@@ -96,7 +96,6 @@ import {
 	FindTool,
 	GrepTool,
 	getWebSearchTools,
-	LsTool,
 	loadSshTool,
 	PythonTool,
 	ReadTool,
@@ -235,7 +234,6 @@ export {
 	FindTool,
 	GrepTool,
 	loadSshTool,
-	LsTool,
 	PythonTool,
 	ReadTool,
 	WriteTool,

package/src/session/agent-session.ts

@@ -2461,13 +2461,15 @@ Be thorough - include exact file paths, function names, error messages, and tech
 	 * Check if agent stopped with incomplete todos and prompt to continue.
 	 */
 	private async _checkTodoCompletion(): Promise<void> {
-		const todoSettings = this.settings.getGroup("todoCompletion");
-		if (!todoSettings.enabled) {
+		const remindersEnabled = this.settings.get("todo.reminders");
+		const todosEnabled = this.settings.get("todo.enabled");
+		if (!remindersEnabled || !todosEnabled) {
 			this._todoReminderCount = 0;
 			return;
 		}
 
-		if (this._todoReminderCount >= todoSettings.maxReminders) {
+		const remindersMax = this.settings.get("todo.reminders.max");
+		if (this._todoReminderCount >= remindersMax) {
 			logger.debug("Todo completion: max reminders reached", { count: this._todoReminderCount });
 			return;
 		}
@@ -2503,7 +2505,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			`<system_reminder>\n` +
 			`You stopped with ${incomplete.length} incomplete todo item(s):\n${todoList}\n\n` +
 			`Please continue working on these tasks or mark them complete if finished.\n` +
-			`(Reminder ${this._todoReminderCount}/${todoSettings.maxReminders})\n` +
+			`(Reminder ${this._todoReminderCount}/${remindersMax})\n` +
 			`</system_reminder>`;
 
 		logger.debug("Todo completion: sending reminder", {
@@ -2516,7 +2518,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			type: "todo_reminder",
 			todos: incomplete,
 			attempt: this._todoReminderCount,
-			maxAttempts: todoSettings.maxReminders,
+			maxAttempts: remindersMax,
 		});
 
 		// Inject reminder and continue the conversation
@@ -3811,13 +3813,32 @@ Be thorough - include exact file paths, function names, error messages, and tech
 
 		// Include available tools
 		const tools = this.agent.state.tools;
+
+		// Recursively strip all fields starting with 'TypeBox.' from an object
+		function stripTypeBoxFields(obj: any): any {
+			if (Array.isArray(obj)) {
+				return obj.map(stripTypeBoxFields);
+			}
+			if (obj && typeof obj === "object") {
+				const result: Record<string, any> = {};
+				for (const [k, v] of Object.entries(obj)) {
+					if (!k.startsWith("TypeBox.")) {
+						result[k] = stripTypeBoxFields(v);
+					}
+				}
+				return result;
+			}
+			return obj;
+		}
+
 		if (tools.length > 0) {
 			lines.push("## Available Tools\n");
 			for (const tool of tools) {
 				lines.push(`### ${tool.name}\n`);
 				lines.push(tool.description);
 				lines.push("\n```yaml");
-				lines.push(YAML.stringify(tool.parameters, null, 2));
+				const parametersClean = stripTypeBoxFields(tool.parameters);
+				lines.push(YAML.stringify(parametersClean, null, 2));
 				lines.push("```\n");
 			}
 			lines.push("\n");

package/src/system-prompt.ts

@@ -1,11 +1,9 @@
 /**
  * System prompt construction and project context loading
  */
-import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
-import { FileType, getSystemInfo as getNativeSystemInfo, glob, type SystemInfo } from "@oh-my-pi/pi-natives";
-import { untilAborted } from "@oh-my-pi/pi-utils";
+import { getSystemInfo as getNativeSystemInfo, type SystemInfo } from "@oh-my-pi/pi-natives";
 import { $ } from "bun";
 import chalk from "chalk";
 import { contextFileCapability } from "./capability/context-file";
@@ -106,24 +104,6 @@ function parseWmicTable(output: string, header: string): string | null {
 
 const AGENTS_MD_PATTERN = "**/AGENTS.md";
 const AGENTS_MD_LIMIT = 200;
-const PROJECT_TREE_LIMIT = 2000;
-const PROJECT_TREE_PER_DIR_LIMIT = 10;
-const PROJECT_TREE_PER_DIR_DEPTH = 2;
-const PROJECT_TREE_IGNORED = new Set([
-	".git",
-	".hg",
-	".svn",
-	".next",
-	".turbo",
-	".cache",
-	".venv",
-	".idea",
-	".vscode",
-	"build",
-	"dist",
-	"node_modules",
-	"target",
-]);
 
 interface AgentsMdSearch {
 	scopePath: string;
@@ -161,201 +141,6 @@ function buildAgentsMdSearch(cwd: string): AgentsMdSearch {
 	};
 }
 
-type ProjectTreeEntry = {
-	name: string;
-	isDirectory: boolean;
-	path: string;
-};
-
-type ProjectTreeScan = {
-	children: Map<string, ProjectTreeEntry[]>;
-	truncated: boolean;
-	truncatedDirs: Set<string>;
-};
-
-const GLOB_TIMEOUT_MS = 5000;
-
-/**
- * Scan project tree using ripgrep-wasm find with exclusion filters.
- * Returns null if scan fails.
- */
-async function scanProjectTreeWithGlob(root: string): Promise<ProjectTreeScan | null> {
-	let entries: string[];
-	const timeoutSignal = AbortSignal.timeout(GLOB_TIMEOUT_MS);
-	try {
-		const result = await untilAborted(timeoutSignal, () =>
-			glob({
-				pattern: "**/*",
-				path: root,
-				fileType: FileType.File,
-			}),
-		);
-		entries = result.matches.map(match => match.path).filter(entry => entry.length > 0);
-	} catch {
-		return null;
-	}
-
-	// Build directory contents map from file list
-	// Map<dirPath, Map<entryPath, isDirectory>>
-	const dirContents = new Map<string, Map<string, boolean>>();
-	dirContents.set(root, new Map());
-
-	for (const entry of entries) {
-		const filePath = entry;
-		if (!filePath) continue;
-		const absolutePath = path.join(root, filePath);
-		// Check static ignores on path components
-		const relative = path.relative(root, absolutePath);
-		const parts = relative.split(path.sep);
-		if (parts.some(p => PROJECT_TREE_IGNORED.has(p))) continue;
-
-		// Add file to its parent directory
-		const parent = path.dirname(absolutePath);
-		if (!dirContents.has(parent)) dirContents.set(parent, new Map());
-		dirContents.get(parent)!.set(absolutePath, false);
-
-		// Add all intermediate directories
-		let dir = parent;
-		while (dir.length >= root.length && dir !== path.dirname(dir)) {
-			const parentDir = path.dirname(dir);
-			if (!dirContents.has(parentDir)) dirContents.set(parentDir, new Map());
-			dirContents.get(parentDir)!.set(dir, true);
-			dir = parentDir;
-		}
-	}
-
-	// BFS to build the tree with limits
-	const children = new Map<string, ProjectTreeEntry[]>();
-	let entryCount = 0;
-	let truncated = false;
-	const truncatedDirs = new Set<string>();
-
-	const queue: Array<{ dirPath: string; depth: number }> = [{ dirPath: root, depth: 0 }];
-	let cursor = 0;
-
-	while (cursor < queue.length && !truncated) {
-		const { dirPath, depth } = queue[cursor];
-		cursor += 1;
-
-		const contents = dirContents.get(dirPath);
-		if (!contents || contents.size === 0) continue;
-
-		// Get stats for sorting
-		const entries = Array.from(contents.entries());
-		const withStats = await Promise.all(
-			entries.map(async ([entryPath, isDirectory]) => {
-				try {
-					const stats = await fs.stat(entryPath);
-					return { entryPath, isDirectory, mtimeMs: stats.mtimeMs };
-				} catch {
-					return { entryPath, isDirectory, mtimeMs: 0 };
-				}
-			}),
-		);
-
-		withStats.sort((a, b) => {
-			if (a.mtimeMs !== b.mtimeMs) return b.mtimeMs - a.mtimeMs;
-			return path.basename(a.entryPath).localeCompare(path.basename(b.entryPath));
-		});
-
-		const perDirLimit = depth >= PROJECT_TREE_PER_DIR_DEPTH ? PROJECT_TREE_PER_DIR_LIMIT : null;
-		const limited = perDirLimit === null ? withStats : withStats.slice(0, perDirLimit);
-		const hasMoreEntries = perDirLimit !== null && withStats.length > perDirLimit;
-
-		const mapped: ProjectTreeEntry[] = [];
-		for (const { entryPath, isDirectory } of limited) {
-			if (entryCount >= PROJECT_TREE_LIMIT) {
-				truncated = true;
-				break;
-			}
-
-			mapped.push({
-				name: path.basename(entryPath),
-				isDirectory,
-				path: entryPath,
-			});
-			entryCount += 1;
-
-			if (isDirectory) {
-				queue.push({ dirPath: entryPath, depth: depth + 1 });
-			}
-		}
-
-		if (!truncated && hasMoreEntries) {
-			truncatedDirs.add(dirPath);
-		}
-		children.set(dirPath, mapped);
-	}
-
-	return { children, truncated, truncatedDirs };
-}
-
-async function scanProjectTree(root: string): Promise<ProjectTreeScan> {
-	const globResult = await scanProjectTreeWithGlob(root);
-	if (globResult) return globResult;
-	return { children: new Map(), truncated: false, truncatedDirs: new Set() };
-}
-
-function renderProjectTree(scan: ProjectTreeScan, root: string): string {
-	const lines: string[] = [];
-
-	const collapseDir = (dirPath: string): { path: string; entries: ProjectTreeEntry[] } | null => {
-		let currentPath = dirPath;
-		while (true) {
-			const entries = scan.children.get(currentPath);
-			if (!entries || entries.length === 0) return null;
-			const files = entries.filter(entry => !entry.isDirectory);
-			const dirs = entries.filter(entry => entry.isDirectory);
-			if (files.length === 0 && dirs.length === 1 && !scan.truncatedDirs.has(currentPath)) {
-				currentPath = dirs[0].path;
-				continue;
-			}
-			return { path: currentPath, entries };
-		}
-	};
-
-	const renderDir = (dirPath: string, indent: string, isRoot: boolean): void => {
-		const collapsed = collapseDir(dirPath);
-		if (!collapsed) return;
-		const { path: collapsedPath, entries } = collapsed;
-
-		// For non-root directories, print the header and indent contents
-		const contentIndent = isRoot ? indent : `${indent}  `;
-		if (!isRoot) {
-			const relative = path.relative(root, collapsedPath) || ".";
-			lines.push(`${indent}@ ${relative}`);
-		}
-
-		const files = entries.filter(entry => !entry.isDirectory);
-		const dirs = entries.filter(entry => entry.isDirectory);
-
-		for (const entry of files) {
-			lines.push(`${contentIndent}- ${entry.name}`);
-		}
-
-		if (scan.truncatedDirs.has(collapsedPath)) {
-			lines.push(`${contentIndent}- …`);
-		}
-
-		for (const entry of dirs) {
-			renderDir(entry.path, contentIndent, false);
-		}
-	};
-
-	renderDir(root, "", true);
-
-	if (scan.truncated) {
-		lines.push("…");
-	}
-
-	return lines.join("\n");
-}
-
-async function buildProjectTreeSnapshot(root: string): Promise<string> {
-	const scan = await scanProjectTree(root);
-	return renderProjectTree(scan, root);
-}
-
 async function getGpuModel(): Promise<string | null> {
 	switch (process.platform) {
 		case "win32": {
@@ -704,7 +489,6 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	// Resolve context files: use provided or discover
 	const contextFiles = providedContextFiles ?? (await loadProjectContextFiles({ cwd: resolvedCwd }));
 	const agentsMdSearch = buildAgentsMdSearch(resolvedCwd);
-	const projectTree = await buildProjectTreeSnapshot(resolvedCwd);
 
 	// Build tool descriptions array
 	// Priority: toolNames (explicit list) > tools (Map) > defaults
@@ -742,7 +526,6 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 			customPrompt: resolvedCustomPrompt,
 			appendPrompt: resolvedAppendPrompt ?? "",
 			contextFiles,
-			projectTree,
 			agentsMdSearch,
 			git,
 			skills: filteredSkills,
@@ -759,7 +542,6 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		environment: await getEnvironmentInfo(),
 		systemPromptCustomization: systemPromptCustomization ?? "",
 		contextFiles,
-		projectTree,
 		agentsMdSearch,
 		git,
 		skills: filteredSkills,

package/src/task/agents.ts

@@ -18,6 +18,7 @@ import type { AgentDefinition, AgentSource } from "./types";
 interface AgentFrontmatter {
 	name: string;
 	description: string;
+	tools?: string[];
 	spawns?: string;
 	model?: string | string[];
 	thinkingLevel?: string;
@@ -54,7 +55,7 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 		fileName: "quick_task.md",
 		frontmatter: {
 			name: "quick_task",
-			description: "Quick task for fast execution",
+			description: "Low-reasoning agent for strictly mechanical updates or data collection only",
 			model: "pi/smol",
 		},
 		template: taskMd,

package/src/tools/bash-interceptor.ts

@@ -103,27 +103,3 @@ export function checkBashInterception(
 
 	return { block: false };
 }
-
-/**
- * Check if a command is a simple directory listing that should use `ls` tool.
- * Only applies to bare `ls` without complex flags.
- */
-export function checkSimpleLsInterception(command: string, availableTools: string[]): InterceptionResult {
-	if (!availableTools.includes("ls")) {
-		return { block: false };
-	}
-
-	// Match simple ls commands (ls, ls -la, ls /path, etc.)
-	// Don't intercept complex pipes or commands
-	const simpleLsPattern = /^\s*ls(\s+(-[a-zA-Z]+\s*)*)?(\s+[^|;&]+)?\s*$/;
-
-	if (simpleLsPattern.test(command.trim())) {
-		return {
-			block: true,
-			message: `Use the \`ls\` tool instead of bash ls. It provides structured output.\n\nOriginal command: ${command}`,
-			suggestedTool: "ls",
-		};
-	}
-
-	return { block: false };
-}