@oh-my-pi/pi-coding-agent 8.11.14 → 8.12.2

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [8.12.2] - 2026-01-28
+
+### Changed
+- Replaced ripgrep-based file listing with fs.glob for project scans and find/read tooling
+
 ## [8.11.14] - 2026-01-28
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "8.11.14",
+	"version": "8.12.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -83,11 +83,11 @@
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@oh-my-pi/omp-stats": "8.11.14",
-		"@oh-my-pi/pi-agent-core": "8.11.14",
-		"@oh-my-pi/pi-ai": "8.11.14",
-		"@oh-my-pi/pi-tui": "8.11.14",
-		"@oh-my-pi/pi-utils": "8.11.14",
+		"@oh-my-pi/omp-stats": "8.12.2",
+		"@oh-my-pi/pi-agent-core": "8.12.2",
+		"@oh-my-pi/pi-ai": "8.12.2",
+		"@oh-my-pi/pi-tui": "8.12.2",
+		"@oh-my-pi/pi-utils": "8.12.2",
 		"@openai/agents": "^0.4.4",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",

package/src/cursor.ts

@@ -194,12 +194,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 
 	async shell(args: Parameters<NonNullable<ICursorExecHandlers["shell"]>>[0]) {
 		const toolCallId = decodeToolCallId(args.toolCallId);
-		const timeoutSeconds =
-			args.timeout && args.timeout > 0
-				? args.timeout > 1000
-					? Math.ceil(args.timeout / 1000)
-					: args.timeout
-				: undefined;
+		const timeoutSeconds = args.timeout && args.timeout > 0 ? args.timeout : undefined;
 		const toolResultMessage = await executeTool(this.options, "bash", toolCallId, {
 			command: args.command,
 			workdir: args.workingDirectory || undefined,

package/src/extensibility/extensions/types.ts

@@ -47,6 +47,8 @@ export interface ExtensionUIDialogOptions {
 	timeout?: number;
 	/** Initial cursor position for select dialogs (0-indexed) */
 	initialIndex?: number;
+	/** Render an outlined list for select dialogs */
+	outline?: boolean;
 }
 
 /**

package/src/modes/components/countdown-timer.ts

@@ -6,6 +6,7 @@ import type { TUI } from "@oh-my-pi/pi-tui";
 export class CountdownTimer {
 	private intervalId: ReturnType<typeof setInterval> | undefined;
 	private remainingSeconds: number;
+	private readonly initialMs: number;
 
 	constructor(
 		timeoutMs: number,
@@ -13,6 +14,7 @@ export class CountdownTimer {
 		private onTick: (seconds: number) => void,
 		private onExpire: () => void,
 	) {
+		this.initialMs = timeoutMs;
 		this.remainingSeconds = Math.ceil(timeoutMs / 1000);
 		this.onTick(this.remainingSeconds);
 
@@ -28,6 +30,13 @@ export class CountdownTimer {
 		}, 1000);
 	}
 
+	/** Reset the countdown to its initial value */
+	reset(): void {
+		this.remainingSeconds = Math.ceil(this.initialMs / 1000);
+		this.onTick(this.remainingSeconds);
+		this.tui?.requestRender();
+	}
+
 	dispose(): void {
 		if (this.intervalId) {
 			clearInterval(this.intervalId);

package/src/modes/components/hook-selector.ts

@@ -2,7 +2,7 @@
  * Generic selector component for hooks.
  * Displays a list of string options with keyboard navigation.
  */
-import { Container, matchesKey, Spacer, Text, type TUI } from "@oh-my-pi/pi-tui";
+import { Container, matchesKey, Spacer, Text, type TUI, visibleWidth } from "@oh-my-pi/pi-tui";
 import { theme } from "../../modes/theme/theme";
 import { CountdownTimer } from "./countdown-timer";
 import { DynamicBorder } from "./dynamic-border";
@@ -11,12 +11,36 @@ export interface HookSelectorOptions {
 	tui?: TUI;
 	timeout?: number;
 	initialIndex?: number;
+	outline?: boolean;
+	maxVisible?: number;
+}
+
+class OutlinedList extends Container {
+	private lines: string[] = [];
+
+	setLines(lines: string[]): void {
+		this.lines = lines;
+		this.invalidate();
+	}
+
+	render(width: number): string[] {
+		const borderColor = (text: string) => theme.fg("border", text);
+		const horizontal = borderColor(theme.boxSharp.horizontal.repeat(Math.max(1, width)));
+		const innerWidth = Math.max(1, width - 2);
+		const content = this.lines.map(line => {
+			const pad = Math.max(0, innerWidth - visibleWidth(line));
+			return `${borderColor(theme.boxSharp.vertical)}${line}${" ".repeat(pad)}${borderColor(theme.boxSharp.vertical)}`;
+		});
+		return [horizontal, ...content, horizontal];
+	}
 }
 
 export class HookSelectorComponent extends Container {
 	private options: string[];
 	private selectedIndex: number;
-	private listContainer: Container;
+	private maxVisible: number;
+	private listContainer: Container | undefined;
+	private outlinedList: OutlinedList | undefined;
 	private onSelectCallback: (option: string) => void;
 	private onCancelCallback: () => void;
 	private titleText: Text;
@@ -34,6 +58,7 @@ export class HookSelectorComponent extends Container {
 
 		this.options = options;
 		this.selectedIndex = Math.min(opts?.initialIndex ?? 0, options.length - 1);
+		this.maxVisible = Math.max(3, opts?.maxVisible ?? 12);
 		this.onSelectCallback = onSelect;
 		this.onCancelCallback = onCancel;
 		this.baseTitle = title;
@@ -62,8 +87,13 @@ export class HookSelectorComponent extends Container {
 			);
 		}
 
-		this.listContainer = new Container();
-		this.addChild(this.listContainer);
+		if (opts?.outline) {
+			this.outlinedList = new OutlinedList();
+			this.addChild(this.outlinedList);
+		} else {
+			this.listContainer = new Container();
+			this.addChild(this.listContainer);
+		}
 		this.addChild(new Spacer(1));
 		this.addChild(new Text(theme.fg("dim", "up/down navigate  enter select  esc cancel"), 1, 0));
 		this.addChild(new Spacer(1));
@@ -73,17 +103,38 @@ export class HookSelectorComponent extends Container {
 	}
 
 	private updateList(): void {
-		this.listContainer.clear();
-		for (let i = 0; i < this.options.length; i++) {
+		const lines: string[] = [];
+		const startIndex = Math.max(
+			0,
+			Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.options.length - this.maxVisible),
+		);
+		const endIndex = Math.min(startIndex + this.maxVisible, this.options.length);
+
+		for (let i = startIndex; i < endIndex; i++) {
 			const isSelected = i === this.selectedIndex;
 			const text = isSelected
 				? theme.fg("accent", `${theme.nav.cursor} `) + theme.fg("accent", this.options[i])
 				: `  ${theme.fg("text", this.options[i])}`;
-			this.listContainer.addChild(new Text(text, 1, 0));
+			lines.push(text);
+		}
+
+		if (startIndex > 0 || endIndex < this.options.length) {
+			lines.push(theme.fg("dim", `  (${this.selectedIndex + 1}/${this.options.length})`));
+		}
+		if (this.outlinedList) {
+			this.outlinedList.setLines(lines);
+			return;
+		}
+		this.listContainer?.clear();
+		for (const line of lines) {
+			this.listContainer?.addChild(new Text(line, 1, 0));
 		}
 	}
 
 	handleInput(keyData: string): void {
+		// Reset countdown on any interaction
+		this.countdown?.reset();
+
 		if (matchesKey(keyData, "up") || keyData === "k") {
 			this.selectedIndex = Math.max(0, this.selectedIndex - 1);
 			this.updateList();

package/src/modes/controllers/extension-ui-controller.ts

@@ -1,4 +1,4 @@
-import type { Component, TUI } from "@oh-my-pi/pi-tui";
+import type { Component, OverlayHandle, TUI } from "@oh-my-pi/pi-tui";
 import { Spacer, Text } from "@oh-my-pi/pi-tui";
 import { logger } from "@oh-my-pi/pi-utils";
 import { KeybindingsManager } from "../../config/keybindings";
@@ -18,6 +18,17 @@ import type { InteractiveModeContext } from "../../modes/types";
 import { setTerminalTitle } from "../../utils/title-generator";
 
 export class ExtensionUiController {
+	private hookSelectorOverlay: OverlayHandle | undefined;
+	private hookInputOverlay: OverlayHandle | undefined;
+
+	private readonly dialogOverlayOptions = {
+		anchor: "bottom-center",
+		width: "80%",
+		minWidth: 40,
+		maxHeight: "70%",
+		margin: 1,
+	} as const;
+
 	constructor(private ctx: InteractiveModeContext) {}
 
 	/**
@@ -491,6 +502,9 @@ export class ExtensionUiController {
 		dialogOptions?: ExtensionUIDialogOptions,
 	): Promise<string | undefined> {
 		const { promise, resolve } = Promise.withResolvers<string | undefined>();
+		this.hookSelectorOverlay?.hide();
+		this.hookSelectorOverlay = undefined;
+		const maxVisible = Math.max(4, Math.min(15, this.ctx.ui.terminal.rows - 12));
 		this.ctx.hookSelector = new HookSelectorComponent(
 			title,
 			options,
@@ -502,13 +516,15 @@ export class ExtensionUiController {
 				this.hideHookSelector();
 				resolve(undefined);
 			},
-			{ initialIndex: dialogOptions?.initialIndex, timeout: dialogOptions?.timeout, tui: this.ctx.ui },
+			{
+				initialIndex: dialogOptions?.initialIndex,
+				timeout: dialogOptions?.timeout,
+				tui: this.ctx.ui,
+				outline: dialogOptions?.outline,
+				maxVisible,
+			},
 		);
-
-		this.ctx.editorContainer.clear();
-		this.ctx.editorContainer.addChild(this.ctx.hookSelector);
-		this.ctx.ui.setFocus(this.ctx.hookSelector);
-		this.ctx.ui.requestRender();
+		this.hookSelectorOverlay = this.ctx.ui.showOverlay(this.ctx.hookSelector, this.dialogOverlayOptions);
 		return promise;
 	}
 
@@ -516,8 +532,9 @@ export class ExtensionUiController {
 	 * Hide the hook selector.
 	 */
 	hideHookSelector(): void {
-		this.ctx.editorContainer.clear();
-		this.ctx.editorContainer.addChild(this.ctx.editor);
+		this.ctx.hookSelector?.dispose();
+		this.hookSelectorOverlay?.hide();
+		this.hookSelectorOverlay = undefined;
 		this.ctx.hookSelector = undefined;
 		this.ctx.ui.setFocus(this.ctx.editor);
 		this.ctx.ui.requestRender();
@@ -536,6 +553,8 @@ export class ExtensionUiController {
 	 */
 	showHookInput(title: string, placeholder?: string): Promise<string | undefined> {
 		const { promise, resolve } = Promise.withResolvers<string | undefined>();
+		this.hookInputOverlay?.hide();
+		this.hookInputOverlay = undefined;
 		this.ctx.hookInput = new HookInputComponent(
 			title,
 			placeholder,
@@ -548,11 +567,7 @@ export class ExtensionUiController {
 				resolve(undefined);
 			},
 		);
-
-		this.ctx.editorContainer.clear();
-		this.ctx.editorContainer.addChild(this.ctx.hookInput);
-		this.ctx.ui.setFocus(this.ctx.hookInput);
-		this.ctx.ui.requestRender();
+		this.hookInputOverlay = this.ctx.ui.showOverlay(this.ctx.hookInput, this.dialogOverlayOptions);
 		return promise;
 	}
 
@@ -560,8 +575,9 @@ export class ExtensionUiController {
 	 * Hide the hook input.
 	 */
 	hideHookInput(): void {
-		this.ctx.editorContainer.clear();
-		this.ctx.editorContainer.addChild(this.ctx.editor);
+		this.ctx.hookInput?.dispose();
+		this.hookInputOverlay?.hide();
+		this.hookInputOverlay = undefined;
 		this.ctx.hookInput = undefined;
 		this.ctx.ui.setFocus(this.ctx.editor);
 		this.ctx.ui.requestRender();

package/src/prompts/system/custom-system-prompt.md

@@ -5,43 +5,55 @@
 {{#if appendPrompt}}
 {{appendPrompt}}
 {{/if}}
-{{#if contextFiles.length}}
-# Project Context
+{{#ifAny projectTree contextFiles.length git.isRepo}}
+<project>
+{{#if projectTree}}
+## Files
+<tree>
+{{projectTree}}
+</tree>
+{{/if}}
 
-<project_context_files>
+{{#if contextFiles.length}}
+## Context
+<instructions>
 {{#list contextFiles join="\n"}}
 <file path="{{path}}">
 {{content}}
 </file>
 {{/list}}
-</project_context_files>
+</instructions>
 {{/if}}
+
 {{#if git.isRepo}}
-# Git Status
+## Version Control
+This is a snapshot. It does not update during the conversation.
 
-This is the git status at the start of the conversation. Note that this status is a snapshot in time, and will not update during the conversation.
 Current branch: {{git.currentBranch}}
 Main branch: {{git.mainBranch}}
 
-Status:
 {{git.status}}
 
-Recent commits:
+### History
 {{git.commits}}
 {{/if}}
+</project>
+{{/ifAny}}
+
 {{#if skills.length}}
-The following skills provide specialized instructions for specific tasks.
-Use the read tool to load a skill's file when the task matches its description.
+Skills are specialized knowledge.
+They exist because someone learned the hard way.
 
-<available_skills>
+Scan descriptions against your task domain.
+If a skill covers what you're producing, read `skill://<name>` before proceeding.
+
+<skills>
 {{#list skills join="\n"}}
-<skill>
-<name>{{escapeXml name}}</name>
-<description>{{escapeXml description}}</description>
-<location>skill://{{escapeXml name}}</location>
+<skill name="{{name}}">
+{{description}}
 </skill>
 {{/list}}
-</available_skills>
+</skills>
 {{/if}}
 {{#if preloadedSkills.length}}
 The following skills are preloaded in full. Apply their instructions directly.
@@ -49,30 +61,24 @@ The following skills are preloaded in full. Apply their instructions directly.
 <preloaded_skills>
 {{#list preloadedSkills join="\n"}}
 <skill name="{{name}}">
-<location>skill://{{escapeXml name}}</location>
-<content>
 {{content}}
-</content>
 </skill>
 {{/list}}
 </preloaded_skills>
 {{/if}}
 {{#if rules.length}}
-The following rules define project-specific guidelines and constraints:
+Rules are local constraints.
+They exist because someone made a mistake here before.
+
+Read `rule://<name>` when working in their domain.
 
 <rules>
 {{#list rules join="\n"}}
-  <rule>
-    <name>{{escapeXml name}}</name>
-    <description>{{escapeXml description}}</description>
+<rule name="{{name}}">
+{{description}}
 {{#if globs.length}}
-    <globs>
-{{#list globs join="\n"}}
-      <glob>{{escapeXml this}}</glob>
-{{/list}}
-</globs>
+{{#list globs join="\n"}}<glob>{{this}}</glob>{{/list}}
 {{/if}}
-    <location>rule://{{escapeXml name}}</location>
 </rule>
 {{/list}}
 </rules>

package/src/prompts/system/system-prompt.md

@@ -221,22 +221,27 @@ It lies. The code that runs is not the code that works.
 - Resolve blockers before yielding.
 </procedure>
 
-<context>
+<project>
+{{#if projectTree}}
+## Files
+<tree>
+{{projectTree}}
+</tree>
+{{/if}}
+
 {{#if contextFiles.length}}
-<project_context_files>
+## Context
+<instructions>
 {{#list contextFiles join="\n"}}
 <file path="{{path}}">
 {{content}}
 </file>
 {{/list}}
-</project_context_files>
+</instructions>
 {{/if}}
-</context>
 
 {{#if git.isRepo}}
-<vcs>
-# Git Status
-
+## Version Control
 This is a snapshot. It does not update during the conversation.
 
 Current branch: {{git.currentBranch}}
@@ -244,23 +249,22 @@ Main branch: {{git.mainBranch}}
 
 {{git.status}}
 
-## History
-
+### History
 {{git.commits}}
-</vcs>
 {{/if}}
+</project>
+
 {{#if skills.length}}
 <skills>
 Skills are specialized knowledge.
 They exist because someone learned the hard way.
 
 Scan descriptions against your task domain.
-If a skill covers what you're producing, read it before proceeding.
+If a skill covers what you're producing, read `skill://<name>` before proceeding.
 
 {{#list skills join="\n"}}
 <skill name="{{name}}">
 {{description}}
-<path>skill://{{name}}</path>
 </skill>
 {{/list}}
 </skills>
@@ -271,7 +275,6 @@ The following skills are preloaded in full. Apply their instructions directly.
 
 {{#list preloadedSkills join="\n"}}
 <skill name="{{name}}">
-<location>skill://{{escapeXml name}}</location>
 {{content}}
 </skill>
 {{/list}}
@@ -282,12 +285,12 @@ The following skills are preloaded in full. Apply their instructions directly.
 Rules are local constraints.
 They exist because someone made a mistake here before.
 
-Load when working in their domain:
+Read `rule://<name>` when working in their domain.
+
 {{#list rules join="\n"}}
 <rule name="{{name}}">
 {{description}}
 {{#list globs join="\n"}}<glob>{{this}}</glob>{{/list}}
-<path>rule://{{name}}</path>
 </rule>
 {{/list}}
 </rules>

package/src/system-prompt.ts

@@ -1,8 +1,10 @@
 /**
  * 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 { globPaths } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import chalk from "chalk";
 import { contextFileCapability } from "./capability/context-file";
@@ -129,6 +131,24 @@ function stripQuotes(value: string): string {
 
 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;
@@ -166,6 +186,197 @@ 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 fs.promises.glob with exclusion filters.
+ * Returns null if glob fails.
+ */
+async function scanProjectTreeWithGlob(root: string): Promise<ProjectTreeScan | null> {
+	let entries: string[];
+	try {
+		entries = await globPaths("**/*", {
+			cwd: root,
+			gitignore: true,
+			timeoutMs: GLOB_TIMEOUT_MS,
+		});
+	} 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.trim();
+		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);
+}
+
 function getOsName(): string {
 	switch (process.platform) {
 		case "win32":
@@ -707,6 +918,7 @@ 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
@@ -744,6 +956,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 			customPrompt: resolvedCustomPrompt,
 			appendPrompt: resolvedAppendPrompt ?? "",
 			contextFiles,
+			projectTree,
 			agentsMdSearch,
 			git,
 			skills: filteredSkills,
@@ -759,6 +972,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		environment: await getEnvironmentInfo(),
 		systemPromptCustomization: systemPromptCustomization ?? "",
 		contextFiles,
+		projectTree,
 		agentsMdSearch,
 		git,
 		skills: filteredSkills,

package/src/tools/ask.ts

@@ -77,6 +77,7 @@ export interface AskToolDetails {
 
 const OTHER_OPTION = "Other (type your own)";
 const RECOMMENDED_SUFFIX = " (Recommended)";
+const ASK_TIMEOUT_MS = 30000;
 
 function getDoneOptionLabel(): string {
 	return `${theme.status.success} Done selecting`;
@@ -113,7 +114,7 @@ interface UIContext {
 	select(
 		prompt: string,
 		options: string[],
-		options_?: { initialIndex?: number; timeout?: number },
+		options_?: { initialIndex?: number; timeout?: number; outline?: boolean },
 	): Promise<string | undefined>;
 	input(prompt: string): Promise<string | undefined>;
 }
@@ -131,7 +132,7 @@ async function askSingleQuestion(
 
 	if (multi) {
 		const selected = new Set<string>();
-		let cursorIndex = 0;
+		let cursorIndex = Math.min(Math.max(recommended ?? 0, 0), optionLabels.length - 1);
 
 		while (true) {
 			const opts: string[] = [];
@@ -148,13 +149,22 @@ async function askSingleQuestion(
 			opts.push(OTHER_OPTION);
 
 			const prefix = selected.size > 0 ? `(${selected.size} selected) ` : "";
-			const choice = await ui.select(`${prefix}${question}`, opts, { initialIndex: cursorIndex });
+			const selectionStart = Date.now();
+			const choice = await ui.select(`${prefix}${question}`, opts, {
+				initialIndex: cursorIndex,
+				timeout: ASK_TIMEOUT_MS,
+				outline: true,
+			});
+			const elapsed = Date.now() - selectionStart;
+			const timedOut = elapsed >= ASK_TIMEOUT_MS;
 
 			if (choice === undefined || choice === doneLabel) break;
 
 			if (choice === OTHER_OPTION) {
-				const input = await ui.input("Enter your response:");
-				if (input) customInput = input;
+				if (!timedOut) {
+					const input = await ui.input("Enter your response:");
+					if (input) customInput = input;
+				}
 				break;
 			}
 
@@ -179,13 +189,18 @@ async function askSingleQuestion(
 					selected.add(opt);
 				}
 			}
+
+			if (timedOut) {
+				break;
+			}
 		}
 		selectedOptions = Array.from(selected);
 	} else {
 		const displayLabels = addRecommendedSuffix(optionLabels, recommended);
 		const choice = await ui.select(question, [...displayLabels, OTHER_OPTION], {
-			timeout: 30000,
+			timeout: ASK_TIMEOUT_MS,
 			initialIndex: recommended,
+			outline: true,
 		});
 		if (choice === OTHER_OPTION) {
 			const input = await ui.input("Enter your response:");

package/src/tools/fetch.ts

@@ -911,11 +911,8 @@ export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails
 	): Promise<AgentToolResult<FetchToolDetails>> {
 		const { url, timeout: rawTimeout = 20, raw = false } = params;
 
-		// Auto-convert milliseconds to seconds if value > 1000 (16+ min is unreasonable)
-		const timeoutSec = rawTimeout > 1000 ? rawTimeout / 1000 : rawTimeout;
-
 		// Clamp to valid range (seconds)
-		const effectiveTimeout = Math.min(Math.max(timeoutSec, 1), 45);
+		const effectiveTimeout = Math.min(Math.max(rawTimeout, 1), 45);
 
 		if (signal?.aborted) {
 			throw new ToolAbortError();

package/src/tools/find.ts

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { isEnoent, untilAborted } from "@oh-my-pi/pi-utils";
+import { globPaths, isEnoent, untilAborted } from "@oh-my-pi/pi-utils";
 import type { Static } from "@sinclair/typebox";
 import { Type } from "@sinclair/typebox";
 import { renderPromptTemplate } from "../config/prompt-templates";
@@ -11,14 +11,12 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import findDescription from "../prompts/tools/find.md" with { type: "text" };
 import { renderFileList, renderStatusLine, renderTreeList } from "../tui";
-import { ensureTool } from "../utils/tools-manager";
 import type { ToolSession } from ".";
-import { runRg } from "./grep";
 import { applyListLimit } from "./list-limit";
 import type { OutputMeta } from "./output-meta";
 import { resolveToCwd } from "./path-utils";
 import { formatCount, formatEmptyMessage, formatErrorMessage, PREVIEW_LIMITS } from "./render-utils";
-import { ToolError, throwIfAborted } from "./tool-errors";
+import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { type TruncationResult, truncateHead } from "./truncate";
 
@@ -30,7 +28,7 @@ const findSchema = Type.Object({
 });
 
 const DEFAULT_LIMIT = 1000;
-const RG_TIMEOUT_MS = 5000;
+const GLOB_TIMEOUT_MS = 5000;
 
 export interface FindToolDetails {
 	truncation?: TruncationResult;
@@ -80,7 +78,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 		params: Static<typeof findSchema>,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<FindToolDetails>,
-		context?: AgentToolContext,
+		_context?: AgentToolContext,
 	): Promise<AgentToolResult<FindToolDetails>> {
 		const { pattern, path: searchDir, limit, hidden } = params;
 
@@ -107,7 +105,6 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			}
 			const includeHidden = hidden ?? true;
 			const globPattern = normalizedPattern.replace(/\\/g, "/");
-			const globMatcher = new Bun.Glob(globPattern);
 
 			// If custom operations provided with glob, use that instead of fd
 			if (this.customOps?.glob) {
@@ -171,44 +168,30 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				throw new ToolError(`Path is not a directory: ${searchPath}`);
 			}
 
-			// Default: use rg
-			const rgPath = await ensureTool("rg", {
-				silent: true,
-				notify: message => context?.ui?.notify(message, "info"),
-			});
-			if (!rgPath) {
-				throw new ToolError("rg is not available and could not be downloaded");
+			let lines: string[];
+			try {
+				lines = await globPaths(globPattern, {
+					cwd: searchPath,
+					gitignore: true,
+					dot: includeHidden,
+					signal,
+					timeoutMs: GLOB_TIMEOUT_MS,
+				});
+			} catch (error) {
+				if (error instanceof Error && error.name === "AbortError") {
+					throw new ToolAbortError();
+				}
+				if (error instanceof Error && error.name === "TimeoutError") {
+					const timeoutSeconds = Math.max(1, Math.round(GLOB_TIMEOUT_MS / 1000));
+					throw new ToolError(`glob timed out after ${timeoutSeconds}s`);
+				}
+				throw error;
 			}
 
-			const args = [
-				"--files",
-				...(includeHidden ? ["--hidden"] : []),
-				"--no-require-git",
-				"--color=never",
-				"--glob",
-				"!**/.git/**",
-				"--glob",
-				"!**/node_modules/**",
-				searchPath,
-			];
-
-			// Run rg with timeout
-			const mainTimeoutSignal = AbortSignal.timeout(RG_TIMEOUT_MS);
-			const mainCombinedSignal = signal ? AbortSignal.any([signal, mainTimeoutSignal]) : mainTimeoutSignal;
-			const { stdout, stderr, exitCode } = await runRg(rgPath, args, mainCombinedSignal);
-			const output = stdout.trim();
-
-			// rg exit codes: 0 = found files, 1 = no matches, other = error
-			// Treat exit code 1 with no output as "no files found"
-			if (!output) {
-				if (exitCode !== 0 && exitCode !== 1) {
-					throw new ToolError(stderr.trim() || `rg failed (exit ${exitCode})`);
-				}
+			if (lines.length === 0) {
 				const details: FindToolDetails = { scopePath, fileCount: 0, files: [], truncated: false };
 				return toolResult(details).text("No files found matching pattern").done();
 			}
-
-			const lines = output.split("\n");
 			const relativized: string[] = [];
 			const mtimes: number[] = [];
 
@@ -220,16 +203,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				}
 
 				const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
-				let relativePath = line;
-				if (line.startsWith(searchPath)) {
-					relativePath = line.slice(searchPath.length + 1); // +1 for the /
-				} else {
-					relativePath = path.relative(searchPath, line);
-				}
-				const matchPath = relativePath.replace(/\\/g, "/");
-				if (!globMatcher.match(matchPath)) {
-					continue;
-				}
+				let relativePath = line.replace(/\\/g, "/");
 
 				let mtimeMs = 0;
 				let isDirectory = false;

package/src/tools/gemini-image.ts

@@ -691,10 +691,8 @@ export const geminiImageTool: CustomTool<typeof geminiImageSchema, GeminiImageTo
 			}
 
 			const { timeout: rawTimeout = DEFAULT_TIMEOUT_SECONDS } = params;
-			// Auto-convert milliseconds to seconds if value > 1000 (16+ min is unreasonable)
-			let timeoutSeconds = rawTimeout > 1000 ? rawTimeout / 1000 : rawTimeout;
 			// Clamp to reasonable range: 1s - 600s (10 min)
-			timeoutSeconds = Math.max(1, Math.min(600, timeoutSeconds));
+			const timeoutSeconds = Math.max(1, Math.min(600, rawTimeout));
 			const requestSignal = createRequestSignal(signal, timeoutSeconds);
 
 			if (provider === "antigravity") {

package/src/tools/grep.ts

@@ -73,13 +73,22 @@ export interface RgResult {
  *
  * @throws ToolAbortError if signal is aborted
  */
-export async function runRg(rgPath: string, args: string[], signal?: AbortSignal): Promise<RgResult> {
-	const child = ptree.cspawn([rgPath, ...args], { signal });
+export async function runRg(
+	rgPath: string,
+	args: string[],
+	options?: { signal?: AbortSignal; timeoutMs?: number },
+): Promise<RgResult> {
+	const child = ptree.cspawn([rgPath, ...args], { signal: options?.signal, timeout: options?.timeoutMs });
+	const timeoutSeconds = options?.timeoutMs ? Math.max(1, Math.round(options.timeoutMs / 1000)) : undefined;
+	const timeoutMessage = timeoutSeconds ? `rg timed out after ${timeoutSeconds}s` : "rg timed out";
 
 	let stdout: string;
 	try {
 		stdout = await child.nothrow().text();
 	} catch (err) {
+		if (err instanceof ptree.TimeoutError) {
+			throw new ToolError(timeoutMessage);
+		}
 		if (err instanceof ptree.Exception && err.aborted) {
 			throw new ToolAbortError();
 		}
@@ -91,6 +100,9 @@ export async function runRg(rgPath: string, args: string[], signal?: AbortSignal
 		await child.exited;
 	} catch (err) {
 		exitError = err;
+		if (err instanceof ptree.TimeoutError) {
+			throw new ToolError(timeoutMessage);
+		}
 		if (err instanceof ptree.Exception && err.aborted) {
 			throw new ToolAbortError();
 		}

package/src/tools/read.ts

@@ -4,7 +4,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { ptree } from "@oh-my-pi/pi-utils";
+import { globPaths, ptree } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
 import { CONFIG_DIR_NAME } from "../config";
 import { renderPromptTemplate } from "../config/prompt-templates";
@@ -16,7 +16,6 @@ import { renderCodeCell, renderOutputBlock, renderStatusLine } from "../tui";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { detectSupportedImageMimeTypeFromFile } from "../utils/mime";
 import { ensureTool } from "../utils/tools-manager";
-import { runRg } from "./grep";
 import { applyListLimit } from "./list-limit";
 import { LsTool } from "./ls";
 import type { OutputMeta } from "./output-meta";
@@ -49,6 +48,7 @@ const MAX_FUZZY_RESULTS = 5;
 const MAX_FUZZY_CANDIDATES = 20000;
 const MIN_BASE_SIMILARITY = 0.5;
 const MIN_FULL_SIMILARITY = 0.6;
+const GLOB_TIMEOUT_MS = 5000;
 
 function normalizePathForMatch(value: string): string {
 	return value
@@ -162,95 +162,32 @@ function similarityScore(a: string, b: string): number {
 async function listCandidateFiles(
 	searchRoot: string,
 	signal?: AbortSignal,
-	notify?: (message: string) => void,
+	_notify?: (message: string) => void,
 ): Promise<{ files: string[]; truncated: boolean; error?: string }> {
-	let rgPath: string | undefined;
+	let files: string[];
 	try {
-		rgPath = await ensureTool("rg", { silent: true, notify });
-	} catch {
-		return { files: [], truncated: false, error: "rg not available" };
-	}
-
-	if (!rgPath) {
-		return { files: [], truncated: false, error: "rg not available" };
-	}
-
-	const args: string[] = [
-		"--files",
-		"--color=never",
-		"--hidden",
-		"--glob",
-		"!**/.git/**",
-		"--glob",
-		"!**/node_modules/**",
-	];
-
-	const gitignoreFiles = new Set<string>();
-	const rootGitignore = path.join(searchRoot, ".gitignore");
-	if (await Bun.file(rootGitignore).exists()) {
-		gitignoreFiles.add(rootGitignore);
-	}
-
-	try {
-		const gitignoreArgs = [
-			"--files",
-			"--color=never",
-			"--hidden",
-			"--no-ignore",
-			"--glob",
-			"!**/.git/**",
-			"--glob",
-			"!**/node_modules/**",
-			"--glob",
-			".gitignore",
-			searchRoot,
-		];
-		const { stdout } = await runRg(rgPath, gitignoreArgs, signal);
-		const output = stdout.trim();
-		if (output) {
-			const nestedGitignores = output
-				.split("\n")
-				.map(line => line.replace(/\r$/, "").trim())
-				.filter(line => line.length > 0);
-			for (const file of nestedGitignores) {
-				const normalized = file.replace(/\\/g, "/");
-				if (normalized.includes("/node_modules/") || normalized.includes("/.git/")) {
-					continue;
-				}
-				gitignoreFiles.add(file);
-			}
-		}
+		files = await globPaths("**/*", {
+			cwd: searchRoot,
+			gitignore: true,
+			dot: true,
+			signal,
+			timeoutMs: GLOB_TIMEOUT_MS,
+		});
 	} catch (error) {
-		if (error instanceof ToolAbortError) {
-			throw error;
+		if (error instanceof Error && error.name === "AbortError") {
+			throw new ToolAbortError();
 		}
-		// Ignore gitignore scan errors.
-	}
-
-	for (const gitignorePath of gitignoreFiles) {
-		args.push("--ignore-file", gitignorePath);
-	}
-
-	args.push(searchRoot);
-
-	const { stdout, stderr, exitCode } = await runRg(rgPath, args, signal);
-	const output = stdout.trim();
-
-	if (!output) {
-		// rg exit codes: 0 = ok, 1 = no matches, other = error
-		if (exitCode !== 0 && exitCode !== 1) {
-			return { files: [], truncated: false, error: stderr.trim() || `rg failed (exit ${exitCode})` };
+		if (error instanceof Error && error.name === "TimeoutError") {
+			const timeoutSeconds = Math.max(1, Math.round(GLOB_TIMEOUT_MS / 1000));
+			return { files: [], truncated: false, error: `glob timed out after ${timeoutSeconds}s` };
 		}
-		return { files: [], truncated: false };
+		const message = error instanceof Error ? error.message : String(error);
+		return { files: [], truncated: false, error: message };
 	}
 
-	const files = output
-		.split("\n")
-		.map(line => line.replace(/\r$/, "").trim())
-		.filter(line => line.length > 0);
-
-	const truncated = files.length > MAX_FUZZY_CANDIDATES;
-	const limited = truncated ? files.slice(0, MAX_FUZZY_CANDIDATES) : files;
+	const normalizedFiles = files.map(line => line.replace(/\r$/, "").trim()).filter(line => line.length > 0);
+	const truncated = normalizedFiles.length > MAX_FUZZY_CANDIDATES;
+	const limited = truncated ? normalizedFiles.slice(0, MAX_FUZZY_CANDIDATES) : normalizedFiles;
 
 	return { files: limited, truncated };
 }
@@ -304,11 +241,7 @@ async function findReadPathSuggestions(
 		const cleaned = file.replace(/\r$/, "").trim();
 		if (!cleaned) continue;
 
-		const relativePath = path.isAbsolute(cleaned)
-			? cleaned.startsWith(searchRoot)
-				? cleaned.slice(searchRoot.length + 1)
-				: path.relative(searchRoot, cleaned)
-			: cleaned;
+		const relativePath = cleaned;
 
 		if (!relativePath || relativePath.startsWith("..")) {
 			continue;

package/src/tools/ssh.ts

@@ -162,10 +162,8 @@ export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
 		const hostInfo = await ensureHostInfo(hostConfig);
 		const remoteCommand = buildRemoteCommand(command, cwd, hostInfo);
 
-		// Auto-convert milliseconds to seconds if value > 1000 (16+ min is unreasonable)
-		let timeoutSec = rawTimeout > 1000 ? rawTimeout / 1000 : rawTimeout;
 		// Clamp to reasonable range: 1s - 3600s (1 hour)
-		timeoutSec = Math.max(1, Math.min(3600, timeoutSec));
+		const timeoutSec = Math.max(1, Math.min(3600, rawTimeout));
 		const timeoutMs = timeoutSec * 1000;
 
 		const tailBuffer = createTailBuffer(DEFAULT_MAX_BYTES);