praxis-agent 0.57.0 → 0.59.0

package/README.md

@@ -27,7 +27,7 @@ sessions, configuration, or compatibility directories.
 
 - macOS or Linux
 - Node.js 24 or newer
-- [`ripgrep`](https://github.com/BurntSushi/ripgrep) (`rg`) for the Grep tool
+- [`ripgrep`](https://github.com/BurntSushi/ripgrep) (`rg`) for the Grep and Glob tools
 - an API key and model ID for an Anthropic, OpenAI-compatible, or OpenAI
   Responses provider (the stable setup), or the explicitly enabled experimental
   ChatGPT-backed Codex subscription integration
@@ -124,7 +124,9 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
 - **Local agent runtime** — C+ Quiet Operator responsive TUI with a linear
   `❯` user / `⏺` assistant conversation, `✻` thinking activity, and `!` shell
   composer grammar, compact stable tool rows, responsive density,
-  terminal-native background, and a minimal composer/status row. Interactive
+  terminal-native background, and a minimal composer/status row. Successful
+  background Bash completion bursts collapse in normal reading, while
+  failed/stopped notifications remain detailed. Interactive
   surfaces share the same presentation across terminals, with English
   permission/configuration choices and a taught `❯` / Up/Down / Enter / Esc
   interaction grammar. While a regular turn is active, the composer remains
@@ -167,7 +169,8 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   `Ctrl+V` text/image clipboard paste, `Ctrl+Z` shell suspension and `fg`
   recovery, permission-gated provider-free `!` shell turns that persist shell
   input/output for later ordinary prompts without creating an assistant turn,
-  navigable current/per-turn Git diff views, semantic plan/question decision panels with complete
+  navigable session-start/current-per-turn Git diff views with bounded per-file
+  patches and readable binary/conflict/transient-path notes, semantic plan/question decision panels with complete
   screen-reader actions, semantic screen projection across selectable surfaces,
   deterministic resize-aware URL/form elicitation rendering, and measured
   context budgets; print mode,

package/dist/cli/interactive.d.ts

@@ -9,7 +9,7 @@ import { type ClaudePermissionMode } from '../permissions/claude-permission-reso
 import { type TranscriptItem, type TuiDisplayMetadata } from './tui/claude-style.js';
 import { type TuiMemoryFiles } from './tui/memory-files.js';
 import { type TuiHistoryChange } from './tui/tui-view-model.js';
-import { type TuiDiffSnapshot } from './tui/git-diff.js';
+import { type TuiGitDiffSession, type TuiDiffSnapshot } from './tui/git-diff.js';
 import { type TuiPermissionBehavior, type TuiPermissionRule } from './tui/permission-settings.js';
 import { type RecentlyDeniedStore } from './tui/recently-denied.js';
 import { type AgentColorSelection } from '../core/agent-color.js';
@@ -149,6 +149,7 @@ interface InteractiveAppProps {
     allowDangerouslySkipPermissions?: boolean;
     additionalDirectories?: readonly string[];
     diffLoader?: () => Promise<TuiDiffSnapshot>;
+    gitDiffSession?: TuiGitDiffSession;
     doctorLoader?: (onProgress?: DoctorProgressListener) => Promise<DoctorReport>;
     fileLoader?: () => Promise<readonly TuiFileEntry[]>;
     externalEditor?: (prompt: string, options: TuiEditorOptions) => Promise<TuiEditorResult>;
@@ -209,7 +210,7 @@ export interface InteractiveHistoryState {
 }
 /** Advances the React-owned transcript plus its exact local mutation fact. */
 export declare function advanceInteractiveHistoryState(current: InteractiveHistoryState, items: TranscriptItem[], changedFrom: number): InteractiveHistoryState;
-export declare function InteractiveApp({ dataPlane, configRoot: suppliedConfigRoot, statePath: suppliedStatePath, factory, initialSessions, initialPrompt, initialHistory, initialSessionColor, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader, ansiRenderer, allowNewSession, resume, display, terminalWidth, slashCommands, agents, allowDangerouslySkipPermissions, additionalDirectories, diffLoader, doctorLoader, fileLoader, externalEditor, keybindingsConfigRoot, keybindingsFile, keybindingsLoader, keybindingsEditor, memoryFilesLoader, memoryEditor, memoryFolderOpener, suspendProcess, clipboardReader, clipboardWriter, sideQuestionClipboardWriter, exportWriter, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver, workspaceDirectoryCompleter, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, notificationDelayMs, elicitationUrlOpener, releaseNotesLoader, settingSources, }: InteractiveAppProps): import("react").JSX.Element;
+export declare function InteractiveApp({ dataPlane, configRoot: suppliedConfigRoot, statePath: suppliedStatePath, factory, initialSessions, initialPrompt, initialHistory, initialSessionColor, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader, ansiRenderer, allowNewSession, resume, display, terminalWidth, slashCommands, agents, allowDangerouslySkipPermissions, additionalDirectories, diffLoader, gitDiffSession: suppliedGitDiffSession, doctorLoader, fileLoader, externalEditor, keybindingsConfigRoot, keybindingsFile, keybindingsLoader, keybindingsEditor, memoryFilesLoader, memoryEditor, memoryFolderOpener, suspendProcess, clipboardReader, clipboardWriter, sideQuestionClipboardWriter, exportWriter, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver, workspaceDirectoryCompleter, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, notificationDelayMs, elicitationUrlOpener, releaseNotesLoader, settingSources, }: InteractiveAppProps): import("react").JSX.Element;
 export declare function runInteractive(options: {
     dataPlane?: DataPlane;
     configRoot?: string;

package/dist/cli/interactive.js

@@ -33,7 +33,7 @@ import { QuietInkFrame } from './tui/quiet-frame-adapter.js';
 import { projectQuietScreenFrame, } from './tui/quiet-screen-projector.js';
 import { projectTuiHelpSurface } from './tui/help-surface-model.js';
 import { projectTuiHooksSurface, } from './tui/hooks-surface-model.js';
-import { loadGitDiff } from './tui/git-diff.js';
+import { createTuiGitDiffSession, } from './tui/git-diff.js';
 import { projectTuiDiffSurface, } from './tui/diff-surface-model.js';
 import { filterTuiSessionPickerChoices, projectTuiSessionPicker, tuiSessionPickerChoiceId, } from './tui/session-picker-model.js';
 import { addTuiPermissionRule, loadTuiPermissionRules, removeTuiPermissionRule, } from './tui/permission-settings.js';
@@ -257,7 +257,7 @@ export function advanceInteractiveHistoryState(current, items, changedFrom) {
             : createTuiHistoryChange(revision, changedFrom, items, current.items),
     };
 }
-export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: suppliedConfigRoot, statePath: suppliedStatePath, factory, initialSessions, initialPrompt, initialHistory = [], initialSessionColor, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader = false, ansiRenderer = false, allowNewSession = true, resume, display = { version: 'dev', cwd: process.cwd() }, terminalWidth, slashCommands = EMPTY_SLASH_COMMANDS, agents = EMPTY_AGENTS, allowDangerouslySkipPermissions = false, additionalDirectories = [], diffLoader, doctorLoader, fileLoader, externalEditor = editTuiPrompt, keybindingsConfigRoot, keybindingsFile = ensureTuiKeybindingsFile, keybindingsLoader = loadTuiKeybindings, keybindingsEditor = openTuiEditorFile, memoryFilesLoader, memoryEditor = openTuiEditorFile, memoryFolderOpener = openTuiMemoryFolder, suspendProcess = suspendTuiProcess, clipboardReader = readTuiClipboard, clipboardWriter = writeTuiClipboard, sideQuestionClipboardWriter = writeTuiOsc52Clipboard, exportWriter = writeConversationExport, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver = resolveTuiWorkspaceDirectory, workspaceDirectoryCompleter = completeTuiWorkspaceDirectory, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, notificationDelayMs = 6_000, elicitationUrlOpener = openTuiUrl, releaseNotesLoader = (configRoot) => loadClaudeReleaseNotes({ configRoot }), settingSources, }) {
+export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: suppliedConfigRoot, statePath: suppliedStatePath, factory, initialSessions, initialPrompt, initialHistory = [], initialSessionColor, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader = false, ansiRenderer = false, allowNewSession = true, resume, display = { version: 'dev', cwd: process.cwd() }, terminalWidth, slashCommands = EMPTY_SLASH_COMMANDS, agents = EMPTY_AGENTS, allowDangerouslySkipPermissions = false, additionalDirectories = [], diffLoader, gitDiffSession: suppliedGitDiffSession, doctorLoader, fileLoader, externalEditor = editTuiPrompt, keybindingsConfigRoot, keybindingsFile = ensureTuiKeybindingsFile, keybindingsLoader = loadTuiKeybindings, keybindingsEditor = openTuiEditorFile, memoryFilesLoader, memoryEditor = openTuiEditorFile, memoryFolderOpener = openTuiMemoryFolder, suspendProcess = suspendTuiProcess, clipboardReader = readTuiClipboard, clipboardWriter = writeTuiClipboard, sideQuestionClipboardWriter = writeTuiOsc52Clipboard, exportWriter = writeConversationExport, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver = resolveTuiWorkspaceDirectory, workspaceDirectoryCompleter = completeTuiWorkspaceDirectory, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, notificationDelayMs = 6_000, elicitationUrlOpener = openTuiUrl, releaseNotesLoader = (configRoot) => loadClaudeReleaseNotes({ configRoot }), settingSources, }) {
     const { exit, suspendTerminal, waitUntilRenderFlush } = useApp();
     const settingsDirectory = '.praxis';
     const keybindingsRoot = useMemo(() => resolve(suppliedConfigRoot ?? keybindingsConfigRoot ?? resolveDataPlaneRoot()), [dataPlane, keybindingsConfigRoot, suppliedConfigRoot]);
@@ -278,7 +278,10 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
     const [runtimeCwd, setRuntimeCwd] = useState(display.cwd);
     const runtimeCwdRef = useRef(display.cwd);
     const runtimeGitignoreRef = useRef(true);
-    const loadDiffSnapshot = useMemo(() => diffLoader ?? (() => loadGitDiff(runtimeCwd)), [diffLoader, runtimeCwd]);
+    const gitDiffSession = useMemo(() => suppliedGitDiffSession ?? createTuiGitDiffSession(display.cwd, signal), [display.cwd, signal, suppliedGitDiffSession]);
+    const loadDiffSnapshot = useMemo(() => diffLoader
+        ? () => diffLoader()
+        : (signal) => gitDiffSession.load(runtimeCwdRef.current, signal), [diffLoader, gitDiffSession]);
     const loadDoctorReport = useMemo(() => doctorLoader ??
         (async (onProgress) => {
             const runtimeSettings = await loadRuntimeSettings(configTarget);
@@ -1959,6 +1962,10 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                 append({
                     kind: event.status === 'failed' ? 'warning' : 'notice',
                     text: `Task ${event.status} · ${event.summary}`,
+                    taskNotification: {
+                        taskId: event.taskId,
+                        status: event.status,
+                    },
                 });
                 break;
             case 'compact-boundary':
@@ -2817,6 +2824,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                 setBusy(true);
                 setStatus('changing directory');
                 const cwd = await commands.changeCwd(sessionId ?? undefined, inspection.canonicalTarget, inspection.canonicalTarget);
+                await gitDiffSession.prepare(cwd, signal);
                 activeSessionTrust.add(cwd);
                 runtimeCwdRef.current = cwd;
                 setRuntimeCwd(cwd);
@@ -3427,7 +3435,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             }
             if (turnMutatedFilesRef.current) {
                 try {
-                    const snapshot = await loadDiffSnapshot();
+                    const snapshot = await loadDiffSnapshot(signal);
                     setTurnDiffs((current) => [
                         ...current.filter((source) => source.label !== `T${turnNumber}`),
                         { label: `T${turnNumber}`, snapshot },
@@ -6679,7 +6687,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                     setBusy(true);
                     setStatus('loading diff');
                     try {
-                        const current = await loadDiffSnapshot();
+                        const current = await loadDiffSnapshot(signal);
                         updateMenu({
                             kind: 'diff',
                             snapshots: [
@@ -7027,6 +7035,7 @@ export async function runInteractive(options) {
     const signal = options.signal
         ? AbortSignal.any([options.signal, controller.signal])
         : controller.signal;
+    const gitDiffSession = createTuiGitDiffSession(options.display?.cwd ?? process.cwd(), signal);
     let currentResume = options.resume;
     let currentInitialPrompt = options.initialPrompt;
     let initialAgentPromptResolved = false;
@@ -7145,7 +7154,7 @@ export async function runInteractive(options) {
         const ansiRendererEnabled = currentRenderer === 'fullscreen' &&
             interactiveTty &&
             options.axScreenReader !== true;
-        const instance = render(_jsx(InteractiveApp, { dataPlane: dataPlane, configRoot: configRoot, statePath: statePath, factory: options.factory, initialSessions: initialSessions, slashCommands: initialSlashCommands, agents: initialAgents, initialHistory: history, ...(initialSessionColor === undefined ? {} : { initialSessionColor }), runtimeSettings: currentRuntimeSettings, runtimeSettingsTarget: runtimeSettingsTarget, ...(options.settingSources === undefined
+        const instance = render(_jsx(InteractiveApp, { dataPlane: dataPlane, configRoot: configRoot, statePath: statePath, factory: options.factory, gitDiffSession: gitDiffSession, initialSessions: initialSessions, slashCommands: initialSlashCommands, agents: initialAgents, initialHistory: history, ...(initialSessionColor === undefined ? {} : { initialSessionColor }), runtimeSettings: currentRuntimeSettings, runtimeSettingsTarget: runtimeSettingsTarget, ...(options.settingSources === undefined
                 ? {}
                 : { settingSources: options.settingSources }), initialThemeSettings: initialThemeSettings, ...(initialThemeLoadError === undefined
                 ? {}

package/dist/cli/tui/diff-surface-model.js

@@ -46,7 +46,7 @@ export function projectTuiDiffSurface(input) {
     if (!input.viewingFile || files.length === 0) {
         return {
             kind: 'diff',
-            title: 'Uncommitted changes (git diff HEAD)',
+            title: 'Changes since session start',
             sourceTabs,
             currentSource: selectedSource
                 ? { index: sourceIndex, label: source.label }
@@ -101,7 +101,7 @@ export function projectTuiDiffSurface(input) {
     }));
     return {
         kind: 'diff',
-        title: 'Uncommitted changes (git diff HEAD)',
+        title: 'Changes since session start',
         sourceTabs,
         currentSource: selectedSource
             ? { index: sourceIndex, label: source.label }

package/dist/cli/tui/git-diff.d.ts

@@ -9,6 +9,11 @@ export interface TuiDiffSnapshot {
     additions: number;
     deletions: number;
 }
+export interface TuiGitDiffSession {
+    prepare(cwd: string, signal?: AbortSignal): Promise<void>;
+    load(cwd: string, signal?: AbortSignal): Promise<TuiDiffSnapshot>;
+}
 export declare function visiblePatchLines(patch: string): readonly string[];
+export declare function createTuiGitDiffSession(initialCwd: string, sessionSignal?: AbortSignal): TuiGitDiffSession;
 export declare function loadGitDiff(cwd: string): Promise<TuiDiffSnapshot>;
 //# sourceMappingURL=git-diff.d.ts.map

package/dist/cli/tui/git-diff.js

@@ -1,6 +1,12 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
+import { realpath } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { BoundedProcessRunner } from '../../platform/bounded-process-runner.js';
+function isOldFileHeader(line) {
+    return /^--- (?:a\/|"a\/|\/dev\/null$)/u.test(line);
+}
+function isNewFileHeader(line) {
+    return /^\+\+\+ (?:b\/|"b\/|\/dev\/null$)/u.test(line);
+}
 function changedLines(patch) {
     let additions = 0;
     let deletions = 0;
@@ -12,12 +18,6 @@ function changedLines(patch) {
     }
     return { additions, deletions };
 }
-function isOldFileHeader(line) {
-    return /^--- (?:a\/|"a\/|\/dev\/null$)/u.test(line);
-}
-function isNewFileHeader(line) {
-    return /^\+\+\+ (?:b\/|"b\/|\/dev\/null$)/u.test(line);
-}
 export function visiblePatchLines(patch) {
     return patch
         .split('\n')
@@ -28,95 +28,282 @@ export function visiblePatchLines(patch) {
         !isNewFileHeader(line) &&
         !line.startsWith('@@ '));
 }
-async function hasHead(cwd) {
-    try {
-        await execFileAsync('git', ['-C', cwd, 'rev-parse', '--verify', '--quiet', 'HEAD'], { encoding: 'utf8' });
-        return true;
-    }
-    catch {
-        return false;
-    }
+const CONTROL_LIMIT = 8 * 1024 * 1024;
+const PATCH_LIMIT = 256 * 1024;
+function makeRunner(root, limit = PATCH_LIMIT) {
+    return new BoundedProcessRunner({ cwd: root, maxOutputBytes: limit });
 }
-async function diffUnbornPath(cwd, path) {
+function note(path, text) {
+    return { path, additions: 0, deletions: 0, patch: text };
+}
+async function discover(cwd, signal) {
     try {
-        const result = await execFileAsync('git', [
-            '-C',
-            cwd,
-            'diff',
-            '--no-index',
-            '--no-ext-diff',
-            '--no-color',
-            '--unified=3',
-            '--',
-            '/dev/null',
-            path,
-        ], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
-        return result.stdout;
+        const process = makeRunner(cwd, CONTROL_LIMIT);
+        const rootPromise = process.run({
+            command: 'git',
+            args: ['-C', cwd, 'rev-parse', '--show-toplevel'],
+            timeoutMs: 5_000,
+            ...(signal ? { signal } : {}),
+        });
+        const headPromise = process.run({
+            command: 'git',
+            args: ['-C', cwd, 'rev-parse', '--verify', '--quiet', 'HEAD'],
+            timeoutMs: 5_000,
+            ...(signal ? { signal } : {}),
+        });
+        const [probe, head] = await Promise.all([rootPromise, headPromise]);
+        if (probe.code !== 0 ||
+            probe.timedOut ||
+            probe.truncated ||
+            !probe.stdout.trim())
+            throw new Error('Not a Git repository.');
+        const root = await realpath(resolve(probe.stdout.trim()));
+        if (head.timedOut || head.truncated)
+            throw new Error('Git HEAD inspection failed.');
+        if (head.code === 0 && head.stdout.trim())
+            return { root, oid: head.stdout.trim() };
+        if (head.code === 1 && !head.stdout.trim() && !head.stderr.trim())
+            return { root, oid: null };
+        throw new Error('Git HEAD inspection failed.');
     }
     catch (error) {
-        const execError = error;
-        // `git diff --no-index` exits with code 1 when the inputs differ.
-        if (execError.code === 1) {
-            return execError.stdout ?? '';
-        }
-        throw error;
+        return { error: error instanceof Error ? error : new Error(String(error)) };
     }
 }
-async function loadUnbornDiff(cwd) {
-    const stagedResult = await execFileAsync('git', ['-C', cwd, 'diff', '--cached', '--name-only', '-z', '--'], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
-    const untrackedResult = await execFileAsync('git', ['-C', cwd, 'ls-files', '--others', '--exclude-standard', '-z'], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
-    const stagedPaths = stagedResult.stdout.split('\0').filter(Boolean);
-    const untrackedPaths = untrackedResult.stdout.split('\0').filter(Boolean);
-    const files = [];
-    for (const path of stagedPaths) {
-        const result = await execFileAsync('git', [
+export function createTuiGitDiffSession(initialCwd, sessionSignal) {
+    const baselines = new Map();
+    const discoveries = new Map();
+    const initialKey = resolve(initialCwd);
+    const beginDiscovery = (key, signal) => {
+        let pending = discoveries.get(key);
+        if (!pending) {
+            pending = discover(key, signal).then((result) => {
+                if (!('error' in result) && !baselines.has(result.root)) {
+                    baselines.set(result.root, Promise.resolve(result));
+                }
+                return result;
+            });
+            discoveries.set(key, pending);
+        }
+        return pending;
+    };
+    // Start both repository and HEAD probes before returning the session so a
+    // later commit cannot move the initial baseline while the TUI is mounting.
+    const initialReady = beginDiscovery(initialKey, sessionSignal).then(() => undefined);
+    const prepare = async (cwd, signal = sessionSignal) => {
+        const key = resolve(cwd);
+        if (key !== initialKey)
+            await initialReady;
+        await beginDiscovery(key, signal);
+    };
+    const load = async (cwd, signal) => {
+        await prepare(cwd, signal);
+        if (signal?.aborted)
+            throw new DOMException('Tool execution aborted', 'AbortError');
+        const discovery = await discoveries.get(resolve(cwd));
+        const captured = discovery && !('error' in discovery)
+            ? await baselines.get(discovery.root)
+            : discovery;
+        if (!captured)
+            throw new Error('Git baseline unavailable.');
+        if ('error' in captured)
+            throw captured.error;
+        const { root, oid } = captured;
+        const git = makeRunner(root);
+        const control = makeRunner(root, CONTROL_LIMIT);
+        const runGit = (args) => git.run({
+            command: 'git',
+            args,
+            timeoutMs: 5_000,
+            ...(signal ? { signal } : {}),
+        });
+        const list = async (args) => {
+            const result = await control.run({
+                command: 'git',
+                args,
+                timeoutMs: 5_000,
+                ...(signal ? { signal } : {}),
+            });
+            if (result.code !== 0 || result.timedOut || result.truncated)
+                throw new Error('Git diff enumeration failed.');
+            return result.stdout.split('\0').filter(Boolean);
+        };
+        const untracked = await list([
             '-C',
-            cwd,
-            'diff',
-            '--cached',
-            '--no-ext-diff',
-            '--no-color',
-            '--unified=3',
-            '--',
-            path,
-        ], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
-        files.push({ path, patch: result.stdout, ...changedLines(result.stdout) });
-    }
-    for (const path of untrackedPaths) {
-        const patch = await diffUnbornPath(cwd, path);
-        files.push({ path, patch, ...changedLines(patch) });
-    }
-    return {
-        files,
-        additions: files.reduce((total, file) => total + file.additions, 0),
-        deletions: files.reduce((total, file) => total + file.deletions, 0),
+            root,
+            'ls-files',
+            '--others',
+            '--exclude-standard',
+            '-z',
+        ]);
+        const untrackedSet = new Set(untracked);
+        let paths;
+        if (oid === null) {
+            const cached = await list(['-C', root, 'ls-files', '--cached', '-z']);
+            const deleted = new Set(await list(['-C', root, 'ls-files', '--deleted', '-z']));
+            paths = [...new Set([...cached, ...untracked])]
+                .filter((path) => !deleted.has(path))
+                .sort();
+        }
+        else {
+            paths = [
+                ...new Set([
+                    ...(await list([
+                        '-C',
+                        root,
+                        'diff',
+                        '--no-ext-diff',
+                        '--no-renames',
+                        '--name-only',
+                        '-z',
+                        oid,
+                        '--',
+                    ])),
+                    ...(await list([
+                        '-C',
+                        root,
+                        'diff',
+                        '--cached',
+                        '--no-ext-diff',
+                        '--no-renames',
+                        '--name-only',
+                        '-z',
+                        oid,
+                        '--',
+                    ])),
+                    ...untracked,
+                ]),
+            ].sort();
+        }
+        const baselineOid = oid ?? '';
+        const files = [];
+        for (const path of paths) {
+            if (signal?.aborted)
+                throw new DOMException('Tool execution aborted', 'AbortError');
+            try {
+                const conflict = await runGit([
+                    '-C',
+                    root,
+                    'ls-files',
+                    '-u',
+                    '--',
+                    path,
+                ]);
+                if (conflict.code !== 0 || conflict.timedOut || conflict.truncated) {
+                    files.push(note(path, 'Diff unavailable; Git inspection failed.'));
+                    continue;
+                }
+                if (conflict.stdout.trim()) {
+                    files.push(note(path, 'Merge conflict; patch omitted.'));
+                    continue;
+                }
+                const numstatArgs = oid === null || untrackedSet.has(path)
+                    ? [
+                        '-C',
+                        root,
+                        'diff',
+                        '--no-index',
+                        '--no-ext-diff',
+                        '--numstat',
+                        '--',
+                        '/dev/null',
+                        path,
+                    ]
+                    : [
+                        '-C',
+                        root,
+                        'diff',
+                        '--no-ext-diff',
+                        '--no-renames',
+                        '--numstat',
+                        baselineOid,
+                        '--',
+                        path,
+                    ];
+                const numstat = await (untrackedSet.has(path) ? control : git).run({
+                    command: 'git',
+                    args: numstatArgs,
+                    timeoutMs: 5_000,
+                    ...(signal ? { signal } : {}),
+                });
+                const validNumstatDifference = (oid === null || untrackedSet.has(path)) &&
+                    numstat.code === 1 &&
+                    !/error|fatal|permission|cannot|no such/iu.test(numstat.stderr);
+                if ((numstat.code !== 0 && !validNumstatDifference) ||
+                    numstat.timedOut ||
+                    numstat.truncated) {
+                    files.push(note(path, 'Diff unavailable; Git inspection failed.'));
+                    continue;
+                }
+                if (/^-\s+-\s+/u.test(numstat.stdout)) {
+                    files.push(note(path, 'Binary file; patch omitted.'));
+                    continue;
+                }
+                const args = oid === null || untrackedSet.has(path)
+                    ? [
+                        '-C',
+                        root,
+                        'diff',
+                        '--no-index',
+                        '--no-ext-diff',
+                        '--no-color',
+                        '--unified=3',
+                        '--',
+                        '/dev/null',
+                        path,
+                    ]
+                    : [
+                        '-C',
+                        root,
+                        'diff',
+                        '--no-ext-diff',
+                        '--no-color',
+                        '--unified=3',
+                        baselineOid,
+                        '--',
+                        path,
+                    ];
+                const result = await runGit(args);
+                if (result.timedOut) {
+                    files.push(note(path, 'Diff unavailable; Git inspection timed out.'));
+                    continue;
+                }
+                const noIndexDifference = (oid === null || untrackedSet.has(path)) &&
+                    result.code === 1 &&
+                    !/error|fatal|permission|cannot|no such/iu.test(result.stderr);
+                if (result.code !== 0 && !noIndexDifference) {
+                    const disappeared = /no such|cannot stat|does not exist|not found/iu.test(result.stderr);
+                    files.push(note(path, disappeared
+                        ? 'Diff unavailable; path changed during inspection.'
+                        : 'Diff unavailable; Git inspection failed.'));
+                }
+                else
+                    files.push({
+                        path,
+                        patch: result.stdout,
+                        ...changedLines(result.stdout),
+                    });
+            }
+            catch (error) {
+                if (error instanceof DOMException && error.name === 'AbortError')
+                    throw error;
+                const message = error instanceof Error ? error.message : String(error);
+                files.push(note(path, /no such|cannot stat|does not exist|not found/iu.test(message)
+                    ? 'Diff unavailable; path changed during inspection.'
+                    : 'Diff unavailable; Git inspection failed.'));
+            }
+        }
+        return {
+            files,
+            additions: files.reduce((n, f) => n + f.additions, 0),
+            deletions: files.reduce((n, f) => n + f.deletions, 0),
+        };
     };
+    return { prepare, load };
 }
 export async function loadGitDiff(cwd) {
-    if (!(await hasHead(cwd))) {
-        return loadUnbornDiff(cwd);
-    }
-    const names = await execFileAsync('git', ['-C', cwd, 'diff', '--name-only', '-z', 'HEAD', '--'], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
-    const paths = names.stdout.split('\0').filter(Boolean);
-    const files = [];
-    for (const path of paths) {
-        const result = await execFileAsync('git', [
-            '-C',
-            cwd,
-            'diff',
-            '--no-ext-diff',
-            '--no-color',
-            '--unified=3',
-            'HEAD',
-            '--',
-            path,
-        ], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
-        files.push({ path, patch: result.stdout, ...changedLines(result.stdout) });
-    }
-    return {
-        files,
-        additions: files.reduce((total, file) => total + file.additions, 0),
-        deletions: files.reduce((total, file) => total + file.deletions, 0),
-    };
+    const session = createTuiGitDiffSession(cwd);
+    await session.prepare(cwd);
+    return session.load(cwd);
 }
 //# sourceMappingURL=git-diff.js.map

package/dist/cli/tui/transcript-presentation.d.ts

@@ -1,7 +1,15 @@
 import type { ModelToolCall } from '../../core/runtime.js';
+export type TaskNotificationMetadata = {
+    readonly taskId: string;
+    readonly status: 'completed' | 'failed' | 'stopped';
+};
 export type TranscriptItem = {
-    kind: 'user' | 'assistant' | 'notice' | 'warning';
+    kind: 'user' | 'assistant';
+    text: string;
+} | {
+    kind: 'notice' | 'warning';
     text: string;
+    taskNotification?: TaskNotificationMetadata;
 } | {
     kind: 'local-result';
     text: string;
@@ -102,6 +110,12 @@ export type TranscriptPresentationEntry = TranscriptPresentationEntryValue & {
 export declare function transcriptPresentationEntryKey(item: TranscriptItem, sourceIndex: number): string;
 /** Stable renderer key for a Normal-mode contiguous Read summary. */
 export declare function transcriptReadSummaryKey(sourceIndex: number): string;
+export declare function isCompletedBackgroundBashNotification(item: TranscriptItem): Extract<TranscriptItem, {
+    kind: 'notice' | 'warning';
+}> | undefined;
+export declare function completedBackgroundBashSummary(count: number): Extract<TranscriptItem, {
+    kind: 'notice' | 'warning';
+}>;
 export declare function projectTranscriptPresentation(items: readonly TranscriptItem[], mode: TranscriptPresentationMode): readonly TranscriptPresentationEntry[];
 export {};
 //# sourceMappingURL=transcript-presentation.d.ts.map

package/dist/cli/tui/transcript-presentation.js

@@ -1,3 +1,4 @@
+import { isBackgroundBashTaskId } from '../../application/background-task-id.js';
 /** Stable renderer key for one source Transcript item. */
 export function transcriptPresentationEntryKey(item, sourceIndex) {
     if (item.kind === 'tool')
@@ -14,6 +15,24 @@ export function transcriptPresentationEntryKey(item, sourceIndex) {
 export function transcriptReadSummaryKey(sourceIndex) {
     return `read-summary-${sourceIndex}`;
 }
+export function isCompletedBackgroundBashNotification(item) {
+    if (item.kind !== 'notice' && item.kind !== 'warning')
+        return undefined;
+    const metadata = item.taskNotification;
+    if (!metadata ||
+        metadata.status !== 'completed' ||
+        !isBackgroundBashTaskId(metadata.taskId))
+        return undefined;
+    return item;
+}
+export function completedBackgroundBashSummary(count) {
+    if (!Number.isInteger(count) || count <= 0)
+        throw new RangeError('count must be a positive integer');
+    return {
+        kind: 'notice',
+        text: `${count} background commands completed`,
+    };
+}
 function pairResults(items) {
     const toolResults = new Map();
     const toolResultIndexes = new Map();
@@ -124,6 +143,32 @@ export function projectTranscriptPresentation(items, mode) {
         const item = items[index];
         if (!item)
             continue;
+        if (mode === 'normal') {
+            const notification = isCompletedBackgroundBashNotification(item);
+            if (notification) {
+                const notifications = [notification];
+                let end = index + 1;
+                while (end < items.length) {
+                    const next = items[end];
+                    const nextNotification = next
+                        ? isCompletedBackgroundBashNotification(next)
+                        : undefined;
+                    if (!nextNotification)
+                        break;
+                    notifications.push(nextNotification);
+                    end += 1;
+                }
+                if (notifications.length >= 2) {
+                    entries.push({
+                        kind: 'item',
+                        key: transcriptPresentationEntryKey(item, index),
+                        item: completedBackgroundBashSummary(notifications.length),
+                    });
+                    index = end - 1;
+                    continue;
+                }
+            }
+        }
         if (mode === 'normal' &&
             item.kind === 'tool' &&
             item.call.name === 'Read') {

package/dist/cli/tui/transcript-window-model.d.ts

@@ -76,6 +76,12 @@ interface TailReadRun {
     readonly calls: readonly ReadRunCall[];
     readonly summarized: boolean;
 }
+interface TailCompletedBackgroundBashRun {
+    readonly startSourceIndex: number;
+    readonly startPresentationIndex: number;
+    readonly nextSourceIndex: number;
+    readonly count: number;
+}
 export interface TranscriptWindowState {
     readonly history: readonly TranscriptItem[];
     readonly mode: TranscriptPresentationMode;
@@ -84,6 +90,7 @@ export interface TranscriptWindowState {
     readonly pendingTools?: PendingNode;
     readonly pendingShells?: PendingNode;
     readonly tailReadRun?: TailReadRun;
+    readonly tailCompletedBackgroundBashRun?: TailCompletedBackgroundBashRun;
     readonly revision: number;
 }
 export interface TranscriptWindowInput {

package/dist/cli/tui/transcript-window-model.js

@@ -1,4 +1,4 @@
-import { projectTranscriptPresentation, transcriptPresentationEntryKey, transcriptReadSummaryKey, } from './transcript-presentation.js';
+import { completedBackgroundBashSummary, isCompletedBackgroundBashNotification, projectTranscriptPresentation, transcriptPresentationEntryKey, transcriptReadSummaryKey, } from './transcript-presentation.js';
 import { createTranscriptEntryViewportIndex, estimateTranscriptEntryLines, projectTranscriptEntryRange, } from './transcript-viewport.js';
 const historyChangeLineage = Symbol('tui-history-change-lineage');
 function retainedHistoryChange(revision, changedFrom, history, previousHistory) {
@@ -465,6 +465,29 @@ function coldTailReadRun(history, pairing) {
         summarized,
     };
 }
+function coldTailCompletedBackgroundBashRun(history, entries) {
+    let start = history.length;
+    while (start > 0) {
+        const candidate = history[start - 1];
+        if (!candidate || !isCompletedBackgroundBashNotification(candidate))
+            break;
+        start -= 1;
+    }
+    if (start >= history.length)
+        return undefined;
+    const first = history[start];
+    if (!first)
+        return undefined;
+    const startPresentationIndex = entries.findIndex((entry) => entry.key === transcriptPresentationEntryKey(first, start));
+    if (startPresentationIndex < 0)
+        return undefined;
+    return {
+        startSourceIndex: start,
+        startPresentationIndex,
+        nextSourceIndex: history.length,
+        count: history.length - start,
+    };
+}
 function canReuseEntry(previous, next) {
     if (previous.kind !== next.kind || previous.key !== next.key)
         return false;
@@ -508,6 +531,9 @@ function coldState(input, previous) {
     const tailReadRun = input.mode === 'normal'
         ? coldTailReadRun(input.history, pairing)
         : undefined;
+    const tailCompletedBackgroundBashRun = input.mode === 'normal'
+        ? coldTailCompletedBackgroundBashRun(input.history, entries)
+        : undefined;
     return {
         history: input.history,
         mode: input.mode,
@@ -516,6 +542,9 @@ function coldState(input, previous) {
         ...(pairing.pendingTools ? { pendingTools: pairing.pendingTools } : {}),
         ...(pairing.pendingShells ? { pendingShells: pairing.pendingShells } : {}),
         ...(tailReadRun ? { tailReadRun } : {}),
+        ...(tailCompletedBackgroundBashRun
+            ? { tailCompletedBackgroundBashRun }
+            : {}),
         revision: input.revision,
     };
 }
@@ -565,6 +594,7 @@ function appendState(input, previous, change) {
     let pendingTools = previous.pendingTools;
     let pendingShells = previous.pendingShells;
     let tailReadRun = previous.tailReadRun;
+    let tailCompletedBackgroundBashRun = previous.tailCompletedBackgroundBashRun;
     for (let offset = 0; offset < suffix.length; offset += 1) {
         const sourceIndex = previousLength + offset;
         const item = suffix[offset];
@@ -582,6 +612,38 @@ function appendState(input, previous, change) {
                     tailReadRun.calls.some((call) => call.sourceIndex === pendingTool.sourceIndex)));
         if (!continuesReadRun)
             tailReadRun = undefined;
+        const notification = input.mode === 'normal'
+            ? isCompletedBackgroundBashNotification(item)
+            : undefined;
+        if (notification) {
+            const continuesRun = tailCompletedBackgroundBashRun?.nextSourceIndex === sourceIndex;
+            if (continuesRun && tailCompletedBackgroundBashRun) {
+                const count = tailCompletedBackgroundBashRun.count + 1;
+                const firstItem = input.history[tailCompletedBackgroundBashRun.startSourceIndex] ?? item;
+                tree = updateEntry(tree, tailCompletedBackgroundBashRun.startPresentationIndex, {
+                    kind: 'item',
+                    key: transcriptPresentationEntryKey(firstItem, tailCompletedBackgroundBashRun.startSourceIndex),
+                    item: completedBackgroundBashSummary(count),
+                }, input.width, input.mode);
+                tailCompletedBackgroundBashRun = {
+                    ...tailCompletedBackgroundBashRun,
+                    nextSourceIndex: sourceIndex + 1,
+                    count,
+                };
+            }
+            else {
+                const presentationIndex = tree.entryCount;
+                tree = appendEntry(tree, entryForItem(item, sourceIndex), input.width, input.mode);
+                tailCompletedBackgroundBashRun = {
+                    startSourceIndex: sourceIndex,
+                    startPresentationIndex: presentationIndex,
+                    nextSourceIndex: sourceIndex + 1,
+                    count: 1,
+                };
+            }
+            continue;
+        }
+        tailCompletedBackgroundBashRun = undefined;
         if (item.kind === 'tool') {
             if (item.call.name === 'Read' && input.mode === 'normal') {
                 if (tailReadRun?.summarized) {
@@ -704,6 +766,9 @@ function appendState(input, previous, change) {
         ...(pendingTools ? { pendingTools } : {}),
         ...(pendingShells ? { pendingShells } : {}),
         ...(tailReadRun ? { tailReadRun } : {}),
+        ...(tailCompletedBackgroundBashRun
+            ? { tailCompletedBackgroundBashRun }
+            : {}),
         revision: input.revision,
     };
 }

package/dist/tools/glob.d.ts

@@ -1,9 +1,37 @@
-export interface GlobFilesOptions {
+import { type ProcessResult } from '../platform/bounded-process-runner.js';
+export interface GlobSearchRequest {
     root: string;
     displayRoot: string;
     absoluteRoot: string;
     pattern: string;
     signal?: AbortSignal;
 }
-export declare function globFiles(options: GlobFilesOptions): Promise<string>;
+export interface GlobSearchResult {
+    content: string;
+    isError: boolean;
+}
+export interface GlobSearch {
+    search(request: GlobSearchRequest): Promise<GlobSearchResult>;
+}
+export interface RipgrepGlobSearchOptions {
+    cwd: string;
+    timeoutMs: number;
+    environment?: Readonly<Record<string, string>>;
+    runner?: {
+        run(options: {
+            command: string;
+            args: readonly string[];
+            cwd?: string;
+            timeoutMs: number;
+            signal?: AbortSignal;
+            env?: Readonly<Record<string, string>>;
+        }): Promise<ProcessResult>;
+    };
+}
+export declare class RipgrepGlobSearch implements GlobSearch {
+    private readonly options;
+    private readonly runner;
+    constructor(options: RipgrepGlobSearchOptions);
+    search(request: GlobSearchRequest): Promise<GlobSearchResult>;
+}
 //# sourceMappingURL=glob.d.ts.map

package/dist/tools/glob.js

@@ -1,88 +1,97 @@
-import { lstat, opendir } from 'node:fs/promises';
 import { isAbsolute, join, resolve, sep } from 'node:path';
 import { minimatch } from 'minimatch';
+import { BoundedProcessRunner, joinedProcessOutput, } from '../platform/bounded-process-runner.js';
 const MAX_RESULTS = 100;
+const MAX_ENUMERATION_BYTES = 2 * 1024 * 1024;
+function portable(value) {
+    return sep === '/' ? value : value.split(sep).join('/');
+}
 function abortError() {
     return new DOMException('Tool execution aborted', 'AbortError');
 }
-function portablePath(path) {
-    return sep === '/' ? path : path.split(sep).join('/');
-}
-function compareMatches(left, right) {
-    return left.mtimeMs - right.mtimeMs || left.order - right.order;
-}
-function insertOldest(matches, candidate) {
-    let low = 0;
-    let high = matches.length;
-    while (low < high) {
-        const middle = Math.floor((low + high) / 2);
-        const current = matches[middle];
-        if (current && compareMatches(current, candidate) <= 0)
-            low = middle + 1;
-        else
-            high = middle;
+export class RipgrepGlobSearch {
+    options;
+    runner;
+    constructor(options) {
+        this.options = options;
+        this.runner =
+            options.runner ??
+                new BoundedProcessRunner({
+                    cwd: options.cwd,
+                    maxOutputBytes: MAX_ENUMERATION_BYTES,
+                });
     }
-    matches.splice(low, 0, candidate);
-    if (matches.length > MAX_RESULTS)
-        matches.pop();
-}
-export async function globFiles(options) {
-    const pattern = portablePath(options.pattern);
-    const absolutePattern = isAbsolute(options.pattern);
-    const matchBase = !absolutePattern && !pattern.includes('/');
-    const matches = [];
-    const directories = [''];
-    let matchCount = 0;
-    let order = 0;
-    while (directories.length > 0) {
-        if (options.signal?.aborted)
+    async search(request) {
+        if (request.signal?.aborted)
             throw abortError();
-        const relativeDirectory = directories.pop() ?? '';
-        const directory = await opendir(join(options.root, relativeDirectory));
-        for await (const entry of directory) {
-            if (options.signal?.aborted)
-                throw abortError();
-            const relativePath = join(relativeDirectory, entry.name);
-            if (entry.isDirectory()) {
-                directories.push(relativePath);
-                continue;
-            }
-            if (!entry.isFile())
-                continue;
-            const portableRelativePath = portablePath(relativePath);
-            const absolutePath = portablePath(resolve(options.absoluteRoot, relativePath));
-            if (pattern !== '' &&
-                !minimatch(absolutePattern ? absolutePath : portableRelativePath, pattern, { dot: true, matchBase, noext: true })) {
-                continue;
-            }
-            let metadata;
-            try {
-                metadata = await lstat(join(options.root, relativePath));
-            }
-            catch (error) {
-                if (error.code === 'ENOENT')
-                    continue;
-                throw error;
-            }
-            if (!metadata.isFile())
-                continue;
-            const displayPath = absolutePattern
-                ? absolutePath
-                : portablePath(join(options.displayRoot, relativePath));
-            insertOldest(matches, {
-                path: displayPath,
-                mtimeMs: metadata.mtimeMs,
-                order,
+        const hidden = this.options.environment?.CLAUDE_CODE_GLOB_HIDDEN !== 'false';
+        const noIgnore = this.options.environment?.CLAUDE_CODE_GLOB_NO_IGNORE !== 'false';
+        let result;
+        try {
+            result = await this.runner.run({
+                command: 'rg',
+                args: [
+                    '--files',
+                    '--null',
+                    '--sort',
+                    'modified',
+                    ...(hidden ? ['--hidden'] : []),
+                    ...(noIgnore ? ['--no-ignore'] : []),
+                ],
+                cwd: request.root,
+                timeoutMs: this.options.timeoutMs,
+                ...(request.signal ? { signal: request.signal } : {}),
+                ...(this.options.environment ? { env: this.options.environment } : {}),
             });
-            matchCount += 1;
-            order += 1;
         }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError')
+                throw error;
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Glob enumeration failed: ${message}`);
+        }
+        if (result.timedOut)
+            return {
+                content: `Search timed out after ${this.options.timeoutMs}ms`,
+                isError: true,
+            };
+        if (result.truncated)
+            throw new Error('Glob enumeration failed: output truncated');
+        if (result.code !== 0) {
+            if (result.code === 1 && !result.stdout && !result.stderr)
+                return { content: 'No files found', isError: false };
+            const output = joinedProcessOutput(result);
+            throw new Error(`Glob enumeration failed with exit code ${result.code}${output ? `: ${output}` : ''}`);
+        }
+        const pattern = portable(request.pattern);
+        const absolutePattern = isAbsolute(request.pattern);
+        const matchBase = !absolutePattern && !pattern.includes('/');
+        const paths = result.stdout.split('\0').filter(Boolean);
+        const matched = paths.filter((path) => {
+            const relativePath = portable(path);
+            const absolutePath = portable(resolve(request.absoluteRoot, relativePath));
+            return (pattern === '' ||
+                minimatch(absolutePattern ? absolutePath : relativePath, pattern, {
+                    dot: true,
+                    matchBase,
+                    noext: true,
+                }));
+        });
+        if (matched.length === 0)
+            return { content: 'No files found', isError: false };
+        const display = matched.slice(0, MAX_RESULTS).map((path) => {
+            const relativePath = portable(path);
+            if (absolutePattern)
+                return portable(resolve(request.absoluteRoot, relativePath));
+            return portable(join(request.displayRoot, relativePath));
+        });
+        const content = display.join('\n');
+        return {
+            content: matched.length > MAX_RESULTS
+                ? `${content}\n(Showing 100 of ${matched.length} matching files; ${matched.length - 100} more are not listed. Narrow the pattern or path to see the rest.)`
+                : content,
+            isError: false,
+        };
     }
-    if (matchCount === 0)
-        return 'No files found';
-    const content = matches.map((match) => match.path).join('\n');
-    return matchCount > MAX_RESULTS
-        ? `${content}\n(Showing ${MAX_RESULTS} of ${matchCount} matching files; ${matchCount - MAX_RESULTS} more are not listed. Narrow the pattern or path to see the rest.)`
-        : content;
 }
 //# sourceMappingURL=glob.js.map

package/dist/tools/local-tools.d.ts

@@ -1,4 +1,5 @@
 import type { ModelToolCall, ModelToolDefinition, ToolExecutionContext, ToolExecutionResult, ToolRegistry } from '../core/runtime.js';
+import { type GlobSearch } from './glob.js';
 import type { DataPlane } from '../persistence/data-plane.js';
 export interface LocalToolRegistryOptions {
     cwd: string;
@@ -17,6 +18,7 @@ export interface LocalToolRegistryOptions {
     sandbox?: BashSandboxRuntime;
     homeDirectory?: string;
     configRoot?: string;
+    globSearch?: GlobSearch;
 }
 export interface BashSandboxRuntime {
     shouldUseSandbox(input: {
@@ -46,6 +48,7 @@ export declare class LocalToolRegistry implements ToolRegistry {
     private readonly maxShellTimeoutMs;
     private readonly maxSearchTimeoutMs;
     private readonly processRunner;
+    private readonly globSearch;
     private readonly enableReportFindings;
     private readonly environment;
     private readonly sessionEnvironment;
@@ -55,6 +58,7 @@ export declare class LocalToolRegistry implements ToolRegistry {
     private readonly sessionCwds;
     private readonly protectedWriteReason;
     private readonly mutationTargetExisted;
+    private readonly preparedGlobRoots;
     constructor(options: LocalToolRegistryOptions);
     private assertProtectedWritePath;
     private assertProtectedBashCommand;

package/dist/tools/local-tools.js

@@ -7,7 +7,7 @@ import sharp from 'sharp';
 import { countTokens } from '@anthropic-ai/tokenizer';
 import { commandShell, commandShellArguments, } from '../platform/command-shell.js';
 import { BoundedProcessRunner, joinedProcessOutput, } from '../platform/bounded-process-runner.js';
-import { globFiles } from './glob.js';
+import { RipgrepGlobSearch } from './glob.js';
 import { countLineChanges } from './line-changes.js';
 import { editNotebook, formatNotebookForRead } from './notebook.js';
 import { openPdf } from './pdf.js';
@@ -537,6 +537,7 @@ export class LocalToolRegistry {
     maxShellTimeoutMs;
     maxSearchTimeoutMs;
     processRunner;
+    globSearch;
     enableReportFindings;
     environment;
     sessionEnvironment;
@@ -546,6 +547,7 @@ export class LocalToolRegistry {
     sessionCwds = new Map();
     protectedWriteReason;
     mutationTargetExisted = new WeakMap();
+    preparedGlobRoots = new WeakMap();
     constructor(options) {
         this.cwd = resolve(options.cwd);
         this.cwdProvider = options.cwdProvider;
@@ -576,6 +578,13 @@ export class LocalToolRegistry {
             cwd: this.cwd,
             maxOutputBytes: this.maxOutputBytes,
         });
+        this.globSearch =
+            options.globSearch ??
+                new RipgrepGlobSearch({
+                    cwd: this.cwd,
+                    timeoutMs: this.maxSearchTimeoutMs,
+                    ...(this.environment ? { environment: this.environment } : {}),
+                });
     }
     assertProtectedWritePath(filePath) {
         const reason = this.protectedWriteReason(filePath);
@@ -805,14 +814,16 @@ export class LocalToolRegistry {
             case 'Glob': {
                 const pathInput = call.input.path;
                 const requestedPath = pathInput === undefined ? '.' : stringInput(call.input, 'path');
-                await this.globRoot(requestedPath, context);
-                return {
+                const root = await this.globRoot(requestedPath, context);
+                const prepared = {
                     ...call,
                     input: {
                         pattern: stringInput(call.input, 'pattern', true),
                         ...(pathInput === undefined ? {} : { path: requestedPath }),
                     },
                 };
+                this.preparedGlobRoots.set(prepared, root);
+                return prepared;
             }
             case 'Grep': {
                 const glob = optionalString(call.input, 'glob');
@@ -857,6 +868,11 @@ export class LocalToolRegistry {
         if (JSON.stringify(prepared.input) !== JSON.stringify(call.input)) {
             throw new Error('Tool input changed after permission approval');
         }
+        const approvedGlobRoot = this.preparedGlobRoots.get(call);
+        if (approvedGlobRoot !== undefined &&
+            this.preparedGlobRoots.get(prepared) !== approvedGlobRoot) {
+            throw new Error('Tool input changed after permission approval');
+        }
         const executionTargetExisted = this.mutationTargetExisted.get(prepared);
         if (approvedTargetExisted !== undefined &&
             executionTargetExisted !== approvedTargetExisted) {
@@ -1466,37 +1482,21 @@ export class LocalToolRegistry {
     }
     async glob(call, context) {
         const requestedPath = call.input.path === undefined ? '.' : stringInput(call.input, 'path');
-        const root = await this.globRoot(requestedPath, context);
-        const timeoutSignal = AbortSignal.timeout(this.maxSearchTimeoutMs);
-        const searchSignal = context.signal
-            ? AbortSignal.any([context.signal, timeoutSignal])
-            : timeoutSignal;
-        try {
-            const content = await globFiles({
-                root,
-                displayRoot: call.input.path === undefined ? '.' : requestedPath,
-                absoluteRoot: isAbsolute(requestedPath)
-                    ? resolve(requestedPath)
-                    : resolve(this.currentCwd(context), requestedPath),
-                pattern: stringInput(call.input, 'pattern', true),
-                signal: searchSignal,
-            });
-            return {
-                content: truncateOutput(content, this.maxOutputBytes),
-                isError: false,
-            };
-        }
-        catch (error) {
-            if (context.signal?.aborted)
-                throw abortError();
-            if (timeoutSignal.aborted) {
-                return {
-                    content: `Search timed out after ${this.maxSearchTimeoutMs}ms`,
-                    isError: true,
-                };
-            }
-            throw error;
-        }
+        const root = this.preparedGlobRoots.get(call) ??
+            (await this.globRoot(requestedPath, context));
+        const result = await this.globSearch.search({
+            root,
+            displayRoot: call.input.path === undefined ? '.' : requestedPath,
+            absoluteRoot: isAbsolute(requestedPath)
+                ? resolve(requestedPath)
+                : resolve(this.currentCwd(context), requestedPath),
+            pattern: stringInput(call.input, 'pattern', true),
+            ...(context.signal ? { signal: context.signal } : {}),
+        });
+        return {
+            content: truncateOutput(result.content, this.maxOutputBytes),
+            isError: result.isError,
+        };
     }
     async grep(call, context) {
         const workspaceRoot = await realpath(this.currentCwd(context));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.57.0",
+  "version": "0.59.0",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",
@@ -62,7 +62,7 @@
     "verify:ci-coverage": "node scripts/verify-ci-coverage.mjs",
     "verify:fixture-contracts": "node scripts/verify-fixture-contracts.mjs",
     "test:fixtures": "node scripts/run-fixture-contracts.mjs",
-    "test:eval:baseline": "vitest run src/evals/coding-baseline.test.ts src/evals/project-eval-comparison.test.ts src/evals/apply-patch-admission.test.ts src/evals/lsp-diagnostics-admission.test.ts"
+    "test:eval:baseline": "vitest run src/evals/coding-baseline.test.ts src/evals/project-eval-comparison.test.ts src/evals/apply-patch-admission.test.ts src/evals/lsp-diagnostics-admission.test.ts src/evals/glob-ripgrep-admission.test.ts"
   },
   "engines": {
     "node": ">=24"