mixdog 0.9.150 → 0.9.151

package/src/runtime/agent/orchestrator/tools/builtin/lib/grep-single-file-rescue.mjs

@@ -0,0 +1,218 @@
+// Single-FILE grep rescue: scan the one explicitly targeted file in JS when
+// the native search server cannot answer it.
+//
+// A file operand has no tree to walk — the server scans it directly — so a
+// deadline reached on a file scope is never about this file. It is queue
+// starvation: the resident server is shared, and one scope rooted in a virtual
+// filesystem (/proc, /sys) walks a tree that cannot finish inside any budget
+// and holds the queue while it burns. Measured in the wild: three /sys glob
+// reads spent 17.5s each, the grep behind them failed after 17.7s on a
+// six-line /proc/self/status, and a plain read of that same file answered in
+// 7ms three seconds later.
+//
+// Reading one file is bounded work, so the call answers instead of spending a
+// whole turn on someone else's walk. Anything this scanner cannot reproduce
+// exactly — multiline patterns, type filters, a PCRE-only regex, a binary or
+// oversized file — declines (returns null) and the caller keeps the original
+// native error.
+import { readFile } from 'node:fs/promises';
+
+import { formatGrepContextOutput, formatGrepOutput } from './grep-output.mjs';
+
+/** Reading is the whole point of the rescue, so the file must stay small
+ *  enough that reading it is cheaper than the failed search. */
+export const MAX_RESCUE_BYTES = 8 * 1024 * 1024;
+/** Bounds memory on a pathological match rate; a truncated window is reported
+ *  as incomplete, exactly like a capped native result. */
+const MAX_RESCUE_LINES = 5_000;
+
+function compilePatterns(patterns, caseInsensitive) {
+    const flags = caseInsensitive ? 'i' : '';
+    const compiled = [];
+    for (const pattern of patterns) {
+        try {
+            compiled.push(new RegExp(String(pattern), flags));
+        } catch {
+            // A PCRE-only construct (lookbehind variants, \p classes, inline
+            // flags) has no faithful JS twin: decline rather than answer with
+            // different semantics than the caller asked for.
+            return null;
+        }
+    }
+    return compiled.length > 0 ? compiled : null;
+}
+
+export async function runGrepSingleFileRescue({
+    filePath,
+    searchPath,
+    patterns,
+    caseInsensitive,
+    multilineMode,
+    onlyMatching,
+    fileType,
+    outputMode,
+    showLineNumbers,
+    withFilename,
+    filenameOmitted,
+    beforeN,
+    afterN,
+    contextN,
+    headLimit,
+    offset,
+    workDir,
+    grepResolvedPath,
+    patternCapNote = '',
+    globPatterns = [],
+}) {
+    if (multilineMode || fileType) return null;
+    const list = (Array.isArray(patterns) ? patterns : [patterns]).filter(Boolean);
+    const compiled = compilePatterns(list, caseInsensitive);
+    if (!compiled) return null;
+
+    let raw;
+    try {
+        raw = await readFile(filePath);
+    } catch {
+        return null;
+    }
+    if (raw.length > MAX_RESCUE_BYTES || raw.includes(0)) return null;
+    const text = raw.toString('utf8');
+    const fileLines = text.split(/\r?\n/);
+    if (fileLines.length > 0 && fileLines[fileLines.length - 1] === '') fileLines.pop();
+
+    const matched = [];
+    for (let index = 0; index < fileLines.length; index += 1) {
+        if (compiled.some((re) => re.test(fileLines[index]))) matched.push(index);
+    }
+
+    const pathPrefix = (separator) => (withFilename ? `${searchPath}${separator}` : '');
+    const numberPrefix = (index, separator) => (showLineNumbers ? `${index + 1}${separator}` : '');
+
+    if (outputMode === 'files_with_matches') {
+        const windowed = matched.length > 0 ? [String(searchPath)] : [];
+        return renderPlain({
+            windowed, patternCapNote, outputMode, headLimit, offset, searchPath,
+            grepResolvedPath, workDir, globPatterns, filenameOmitted: false,
+            beforeN, afterN, contextN, patterns: list,
+        });
+    }
+    if (outputMode === 'count') {
+        const windowed = matched.length > 0
+            ? [`${pathPrefix(':')}${matched.length}`]
+            : [];
+        return renderPlain({
+            windowed, patternCapNote, outputMode, headLimit, offset, searchPath,
+            grepResolvedPath, workDir, globPatterns, filenameOmitted,
+            beforeN, afterN, contextN, patterns: list,
+        });
+    }
+
+    const before = Math.max(Number(beforeN) || 0, Number(contextN) || 0);
+    const after = Math.max(Number(afterN) || 0, Number(contextN) || 0);
+    const hasContext = before > 0 || after > 0;
+    const isMatch = new Set(matched);
+    const emit = new Set();
+    for (const index of matched) {
+        for (let i = Math.max(0, index - before); i <= Math.min(fileLines.length - 1, index + after); i += 1) {
+            emit.add(i);
+        }
+    }
+    const ordered = [...emit].sort((left, right) => left - right);
+    const lines = [];
+    let previous = -1;
+    let truncated = false;
+    for (const index of ordered) {
+        if (lines.length >= MAX_RESCUE_LINES) {
+            truncated = true;
+            break;
+        }
+        // rg separates non-adjacent context blocks; the context formatter reads
+        // the same marker.
+        if (hasContext && previous >= 0 && index > previous + 1) lines.push('--');
+        previous = index;
+        const line = fileLines[index];
+        if (isMatch.has(index)) {
+            if (onlyMatching) {
+                for (const re of compiled) {
+                    const global = new RegExp(re.source, `${re.flags}g`);
+                    for (const found of line.matchAll(global)) {
+                        lines.push(`${pathPrefix(':')}${numberPrefix(index, ':')}${found[0]}`);
+                    }
+                }
+                continue;
+            }
+            lines.push(`${pathPrefix(':')}${numberPrefix(index, ':')}${line}`);
+            continue;
+        }
+        lines.push(`${pathPrefix('-')}${numberPrefix(index, '-')}${line}`);
+    }
+
+    if (hasContext) {
+        const body = formatGrepContextOutput({
+            allLines: lines,
+            workDir,
+            outputMode,
+            filenameOmitted,
+            headLimit,
+            offset,
+            searchPath,
+            totalKnown: !truncated,
+        });
+        return withRescueNotice(patternCapNote + (body.text || noMatchBody({
+            patterns: list, searchPath, globPatterns,
+        })));
+    }
+    return renderPlain({
+        windowed: offset > 0 ? lines.slice(offset) : lines,
+        patternCapNote,
+        outputMode,
+        headLimit,
+        offset,
+        searchPath,
+        grepResolvedPath,
+        workDir,
+        globPatterns,
+        filenameOmitted,
+        beforeN,
+        afterN,
+        contextN,
+        patterns: list,
+        totalKnown: !truncated,
+    });
+}
+
+function noMatchBody({ patterns, searchPath, globPatterns }) {
+    const patternStr = patterns.length === 1 ? JSON.stringify(patterns[0]) : JSON.stringify(patterns);
+    const globStr = globPatterns.length > 0 ? ` glob=${JSON.stringify(globPatterns)}` : '';
+    return `(no matches) pattern=${patternStr} path=${searchPath}${globStr}; path exists (file)`;
+}
+
+function withRescueNotice(body) {
+    return `${body}\n[notice] native search could not serve this file scope; the file was scanned directly.`;
+}
+
+function renderPlain({
+    windowed, patternCapNote, outputMode, headLimit, offset, searchPath, grepResolvedPath,
+    workDir, globPatterns, filenameOmitted, beforeN, afterN, contextN, patterns,
+    totalKnown = true,
+}) {
+    const body = formatGrepOutput({
+        windowed,
+        totalWindowed: windowed.length,
+        totalKnown,
+        headLimit,
+        offset,
+        outputMode,
+        patterns,
+        beforeN,
+        afterN,
+        contextN,
+        searchPath,
+        grepResolvedPath,
+        workDir,
+        globPatterns,
+        filenameOmitted,
+        includeMatchCount: false,
+    }) || noMatchBody({ patterns, searchPath, globPatterns });
+    return withRescueNotice(patternCapNote + body);
+}

package/src/runtime/agent/orchestrator/tools/builtin/list-tool.mjs

@@ -1038,7 +1038,40 @@ async function getTargetedFindEnumeration({
 // list via `rg --files`, then rank by subsequence score. `list.fuzzy` still
 // routes here for hidden backward compatibility, but the model-facing tool is
 // `find`.
+// A pruned tree cannot report what it never enumerated. Dependency and cache
+// directories are skipped by DEFAULT, so a file that exists only inside one —
+// a __pycache__ artifact, a vendored source, a build cache — came back as
+// "(no fuzzy match for X)", which reads as PROVEN ABSENCE and ends the search.
+// A second, noise-including pass turns that into the truth, but the default
+// answer still may not list dependency paths (that is the point of the
+// default), so the miss keeps its body and gains the one fact it was missing:
+// a match exists, and which flag surfaces it. Only a CLEAN miss retries — a
+// partial or timed-out pass says "no fuzzy match YET" and is already telling
+// the caller to narrow, so it never pays for a second walk.
 export async function executeFuzzyFindTool(args, workDir, options = {}) {
+    const startedAt = performance.now();
+    const result = await runFuzzyFindPass(args, workDir, options);
+    const text = String(result ?? '');
+    if (!/^\(no fuzzy match for /.test(text)) return result;
+    if (args?.include_noise === true || options?._findNoiseWidened === true) return result;
+    // The retry walks the same tree again. A miss that was already expensive
+    // pays for itself twice, so only a cheap pass earns the second look.
+    if (performance.now() - startedAt > FIND_NOISE_WIDEN_BUDGET_MS) return result;
+    const widened = String(await runFuzzyFindPass(
+        { ...args, include_noise: true },
+        workDir,
+        { ...options, _findNoiseWidened: true },
+    ) ?? '');
+    if (!widened || /^\(no fuzzy match/.test(widened)) return result;
+    const hits = widened.split('\n').filter((line) => line && !line.startsWith('... [') && !line.startsWith('[')).length;
+    return `${text}\n[notice] ${hits} match${hits === 1 ? '' : 'es'} exist inside dependency/cache trees the default scan skips`
+        + ' — pass include_noise:true to list them.';
+}
+
+/** A miss cheaper than this earns the one widening retry below. */
+const FIND_NOISE_WIDEN_BUDGET_MS = 2_000;
+
+async function runFuzzyFindPass(args, workDir, options = {}) {
     const query = String(args.query ?? args.fuzzy ?? '').trim();
     if (!query) return 'Error: find requires query.';
     const inputPath = normalizeInputPath(args.path) || '.';

package/src/runtime/agent/orchestrator/tools/builtin/noise-dir-visibility.test.mjs

@@ -0,0 +1,69 @@
+// Dependency/cache trees stay hidden by default, but a caller who NAMES one is
+// asking for it, and a clean fuzzy miss must not report a file that exists as
+// absent.
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import { executeBuiltinTool } from '../builtin.mjs';
+
+async function withNoiseTree(run) {
+    const root = await mkdtemp(join(tmpdir(), 'mixdog-noise-vis-'));
+    try {
+        await mkdir(join(root, '__pycache__'), { recursive: true });
+        await mkdir(join(root, 'src'), { recursive: true });
+        await writeFile(join(root, '__pycache__', 'convert_masks.cpython-311.pyc'), 'cached MARKER blob\n');
+        await writeFile(join(root, 'src', 'app.py'), 'print("hello")\n');
+        return await run(root);
+    } finally {
+        await rm(root, { recursive: true, force: true });
+    }
+}
+
+test('a glob that names a pruned directory searches inside it', async () => {
+    await withNoiseTree(async (root) => {
+        const named = String(await executeBuiltinTool('glob', { pattern: '__pycache__/*.pyc' }, root));
+        assert.match(named, /convert_masks\.cpython-311\.pyc/);
+
+        // Unnamed: the default prune still applies, so noise stays out of a
+        // broad sweep.
+        const broad = String(await executeBuiltinTool('glob', { pattern: '**/*.pyc' }, root));
+        assert.match(broad, /no files found/);
+    });
+});
+
+test('a grep glob filter that names a pruned directory searches inside it', async () => {
+    await withNoiseTree(async (root) => {
+        const out = String(await executeBuiltinTool('grep', {
+            pattern: 'MARKER',
+            path: '.',
+            glob: '__pycache__/*.pyc',
+            mode: 'files',
+        }, root));
+        assert.match(out, /convert_masks/);
+    });
+});
+
+test('a clean fuzzy miss reports that the hit exists in a skipped tree', async () => {
+    await withNoiseTree(async (root) => {
+        const out = String(await executeBuiltinTool('find', { query: 'convert_masks' }, root));
+        assert.match(out, /no fuzzy match/);
+        assert.match(out, /include_noise:true/);
+        // The default answer still lists no dependency path.
+        assert.doesNotMatch(out, /convert_masks\.cpython-311\.pyc/);
+
+        // The flag it names actually produces the file.
+        const noisy = String(await executeBuiltinTool('find', {
+            query: 'convert_masks',
+            include_noise: true,
+        }, root));
+        assert.match(noisy, /convert_masks\.cpython-311\.pyc/);
+
+        // A query with no file behind it stays a plain miss.
+        const missing = String(await executeBuiltinTool('find', { query: 'no_such_artifact_here' }, root));
+        assert.match(missing, /no fuzzy match/);
+        assert.doesNotMatch(missing, /include_noise:true/);
+    });
+});

package/src/runtime/agent/orchestrator/tools/builtin/path-diagnostics.mjs

@@ -61,20 +61,36 @@ export async function listSiblingsAsync(dir, limit = 12) {
 // and hard-capped on directories scanned, and returns up to `limit` real
 // locations so the error can name them directly. Pure best-effort; any error
 // returns [].
+// A directory-count cap is not a time cap: on a slow or synthetic tree each
+// readdir costs milliseconds, and one missing path burned 17.5s of a turn in
+// this BFS — three times in a row — before the caller ever saw its answer.
+// The hint is an optional courtesy, so it gets a wall-clock budget and reports
+// an out-of-time walk as inconclusive rather than as a proven absence.
+const BASENAME_SCAN_DEADLINE_MS = 750;
 const BASENAME_SCAN_SKIP_DIRS = new Set([
     'node_modules', '.git', '.hg', '.svn', 'dist', 'build', 'out',
     'coverage', '.next', '.nuxt', '.turbo', '.cache', 'vendor',
     'target', '.venv', 'venv', '__pycache__', '.idea', '.vscode',
 ]);
-export function findFileByBasename(searchRoot, fullPath, { limit = 3, maxDirs = 6000 } = {}) {
+export function findFileByBasename(
+    searchRoot,
+    fullPath,
+    { limit = 3, maxDirs = 6000, deadlineMs = BASENAME_SCAN_DEADLINE_MS } = {},
+) {
     try {
         if (typeof searchRoot !== 'string' || !searchRoot) return [];
         const target = basename(fullPath).toLowerCase();
         if (!target) return [];
         const matches = [];
         const queue = [searchRoot];
+        const stopAt = Date.now() + Math.max(1, deadlineMs);
         let scanned = 0;
+        let expired = false;
         while (queue.length && matches.length < limit && scanned < maxDirs) {
+            if (Date.now() >= stopAt) {
+                expired = true;
+                break;
+            }
             const dir = queue.shift();
             scanned++;
             let entries;
@@ -96,9 +112,10 @@ export function findFileByBasename(searchRoot, fullPath, { limit = 3, maxDirs =
                 }
             }
         }
-        // Queue drained without hitting maxDirs/limit → the walk covered the
-        // whole (non-vendor, non-hidden) tree; a miss is conclusive.
-        matches.exhaustive = queue.length === 0;
+        // Queue drained without hitting maxDirs/limit/deadline → the walk
+        // covered the whole (non-vendor, non-hidden) tree; a miss is
+        // conclusive. A walk that ran out of time proves nothing.
+        matches.exhaustive = queue.length === 0 && !expired;
         return matches;
     } catch { return []; }
 }
@@ -146,15 +163,25 @@ export function findBySuffixStrip(searchRoot, fullPath, { maxIterations = 12 } =
 
 // Same as findFileByBasename but for directories sharing the missing path's
 // final segment name (e.g. guessed `src/shared` → the real `lib/shared`).
-export function findDirectoryByBasename(searchRoot, fullPath, { limit = 3, maxDirs = 6000 } = {}) {
+export function findDirectoryByBasename(
+    searchRoot,
+    fullPath,
+    { limit = 3, maxDirs = 6000, deadlineMs = BASENAME_SCAN_DEADLINE_MS } = {},
+) {
     try {
         if (typeof searchRoot !== 'string' || !searchRoot) return [];
         const target = basename(fullPath).toLowerCase();
         if (!target) return [];
         const matches = [];
         const queue = [searchRoot];
+        const stopAt = Date.now() + Math.max(1, deadlineMs);
         let scanned = 0;
+        let expired = false;
         while (queue.length && matches.length < limit && scanned < maxDirs) {
+            if (Date.now() >= stopAt) {
+                expired = true;
+                break;
+            }
             const dir = queue.shift();
             scanned++;
             let entries;
@@ -176,7 +203,7 @@ export function findDirectoryByBasename(searchRoot, fullPath, { limit = 3, maxDi
                 }
             }
         }
-        matches.exhaustive = queue.length === 0;
+        matches.exhaustive = queue.length === 0 && !expired;
         return matches;
     } catch { return []; }
 }

package/src/runtime/agent/orchestrator/tools/builtin/read-tool.mjs

@@ -10,6 +10,16 @@ import { coerceReadFamilyPathArg, hasGlobMagic } from './path-utils.mjs';
 import { readIoAdmission } from '../../../../shared/tool-workload-gates.mjs';
 import { currentToolExecutionOwner } from '../../../../shared/tool-execution-owner.mjs';
 
+// Per-entry status in a batch. A conclusively missing file is not a failed
+// read — that is why its body is `[path absent]` and not `Error:` — but it is
+// not `ok` either: the header said `missing.png [ok]` above a body saying the
+// file does not exist, which is the one line a skimming reader trusts. Absence
+// gets its own tag so the header and the body agree.
+function batchEntryStatus(body, failed, textBody) {
+    if (failed) return 'error';
+    return /^\s*\[path absent\]/.test(String(textBody ?? body ?? '')) ? 'absent' : 'ok';
+}
+
 function hasLineCoordinate(path) {
     return typeof path === 'string' && /(?:#L\d+|:\d+(?:-\d+)?(?::|$))/i.test(path);
 }
@@ -538,12 +548,18 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
         // reject_partial:true — when the caller asked for all-or-none,
         // refuse to return a mixed payload that downstream parsers
         // would have to disambiguate per-entry.
-        if (failedReads > 0 && args.reject_partial === true) {
-            const reasons = orderedResults
-                .filter((r) => bodyFailed(r.body))
+        // All-or-none is about DELIVERY: an entry that returned no content did
+        // not deliver, whether it failed outright or was conclusively absent.
+        // Counting only hard failures let a batch with a missing file through
+        // as a mixed payload — exactly what the caller asked not to receive.
+        const undelivered = orderedResults.filter(
+            (r) => batchEntryStatus(r.body, bodyFailed(r.body), bodyTextFor(r.body)) !== 'ok',
+        );
+        if (undelivered.length > 0 && args.reject_partial === true) {
+            const reasons = undelivered
                 .map((r) => `${normalizeOutputPath(r.path)}: ${bodyTextFor(r.body).split('\n')[0] || 'structured media read failed'}`)
                 .join('; ');
-            return `Error: batch read rejected (${failedReads} of ${orderedResults.length} failed; reject_partial:true) — ${reasons}`;
+            return `Error: batch read rejected (${undelivered.length} of ${orderedResults.length} failed; reject_partial:true) — ${reasons}`;
         }
         // Default: surface per-entry status tags ([ok]/[error]) so a
         // downstream classifyResultKind treats the aggregate as a
@@ -564,8 +580,8 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
                 const mode = r.n !== undefined ? `${r.mode} n=${r.n}` : r.mode;
                 // Default full mode carries no information — tag only non-default modes.
                 const modeTag = mode && mode !== 'full' ? ` [${mode}]` : '';
-                const status = bodyFailed(r.body) ? 'error' : 'ok';
                 const textBody = bodyTextFor(r.body);
+                const status = batchEntryStatus(r.body, bodyFailed(r.body), textBody);
                 const match = /\[TRUNCATED (?:—|-) file is (\d+) lines \/ (\d+) KB\./.exec(textBody);
                 const suffix = match ? ` (truncated ${match[1]}L/${match[2]}KB)` : '';
                 const entryHeader = `${path}${modeTag} [${status}]${suffix}`;
@@ -608,7 +624,11 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
             const path = normalizeOutputPath(r.path);
             const mode = r.n !== undefined ? `${r.mode} n=${r.n}` : r.mode;
             const modeTag = mode && mode !== 'full' ? ` [${mode}]` : '';
-            const status = classifyResultKind(String(r.body || '')) === 'error' ? 'error' : 'ok';
+            const status = batchEntryStatus(
+                r.body,
+                classifyResultKind(String(r.body || '')) === 'error',
+                String(r.body || ''),
+            );
             const dupKey = JSON.stringify([path, mode, r.body || '']);
             const priorIdx = _seenEntryBody.get(dupKey);
             if (priorIdx !== undefined) {

package/src/runtime/agent/orchestrator/tools/builtin/runtime-capabilities.mjs

@@ -1,13 +1,11 @@
 import { accessSync, constants as fsConstants, readFileSync, statSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import {
-    basename,
     delimiter as pathDelimiter,
     dirname as pathDirname,
     join as pathJoin,
     resolve as pathResolveAbsolute,
 } from 'node:path';
-import { resolveShellFor } from './shell-runtime.mjs';
 
 export const SHELL_RUNTIME_CANDIDATES = Object.freeze([
     'node',
@@ -30,31 +28,6 @@ export const SHELL_RUNTIME_CANDIDATES = Object.freeze([
     'bash',
 ]);
 
-export const SHELL_DEPENDENCY_CANDIDATES = Object.freeze([
-    'git',
-    'rg',
-    'jq',
-    'curl',
-    'wget',
-    'gcc',
-    'clang',
-    'make',
-    'cmake',
-    'ninja',
-    'cargo',
-    'sqlite3',
-    'psql',
-    'docker',
-    'kubectl',
-    'openssl',
-    'tar',
-]);
-
-export const SHELL_CAPABILITY_CANDIDATES = Object.freeze([
-    ...SHELL_RUNTIME_CANDIDATES,
-    ...SHELL_DEPENDENCY_CANDIDATES,
-]);
-
 function _pathDirectory(value) {
     const text = String(value || '').trim();
     return text.length >= 2 && text.startsWith('"') && text.endsWith('"')
@@ -96,35 +69,12 @@ export function findPathExecutable(name, {
     return null;
 }
 
-export function detectPathCapabilities({
-    candidates = SHELL_CAPABILITY_CANDIDATES,
-    ...pathOptions
-} = {}) {
-    const available = [];
-    const unavailable = [];
-    for (const name of candidates) {
-        (findPathExecutable(name, pathOptions) ? available : unavailable).push(name);
-    }
-    return { available, unavailable };
-}
-
-export function describeShellStartupPolicy({
-    os = process.platform,
-    shell = null,
-    // Accept a pre-computed scan so a caller emitting several startup lines
-    // walks PATH once instead of once per line.
-    capabilities = null,
-    ...pathOptions
-} = {}) {
-    const { available, unavailable } = capabilities ?? detectPathCapabilities(pathOptions);
-    const resolvedShell = shell || basename(String(resolveShellFor('default')?.shell || 'unknown'));
-    // Shell networking is independent from the web-search tool surface:
-    // applyShellEgressPolicy leaves the spawn env untouched, so package
-    // managers, source-control clients, and proxies keep working even with
-    // MIXDOG_FEATURE_WEB_SEARCH=0. This line therefore never claims an
-    // egress block the runtime does not enforce.
-    return `- Shell startup environment: OS=${os}; shell=${resolvedShell}; available=${available.join(', ') || 'none'}; unavailable=${unavailable.join(', ') || 'none'}. For shell commands, treat every unavailable entry as absent. Invoke one only if the same command first installs it or exposes it on PATH.`;
-}
+// A startup PATH inventory is deliberately not rendered into the prompt: it
+// would be measured in this process's PATH while commands run under the
+// login-shell snapshot (shell-snapshot.mjs), which does not exist until the
+// first shell call, and it would freeze at session start while an install
+// during the session changes the answer. bash-tool's _exitClassDiagnostic
+// reports a missing command after it has run, from the environment that ran it.
 
 // Walk up for a `.git` marker instead of shelling out to `git rev-parse`: it
 // costs no process spawn, and it still answers on images where the git binary
@@ -190,12 +140,9 @@ function _repositoryChangeState(root) {
 // rather than forbidding calls.
 export function describeGitStartupState({
     cwd = process.cwd(),
-    capabilities = null,
     ...pathOptions
 } = {}) {
-    const installed = capabilities
-        ? capabilities.available.includes('git')
-        : Boolean(findPathExecutable('git', pathOptions));
+    const installed = Boolean(findPathExecutable('git', pathOptions));
     if (!installed) {
         return '- Git startup state: git is not installed here; git tool calls fail until something installs it.';
     }
@@ -213,9 +160,3 @@ export function appendGitStartupState(rules, tools, options = {}) {
     if (!text || !Array.isArray(tools) || !tools.some((tool) => tool?.name === 'git')) return text;
     return `${text}\n${describeGitStartupState(options)}`;
 }
-
-export function appendShellStartupPolicy(rules, tools, options = {}) {
-    const text = String(rules || '').trimEnd();
-    if (!text || !Array.isArray(tools) || !tools.some((tool) => tool?.name === 'shell')) return text;
-    return `${text}\n${describeShellStartupPolicy(options)}`;
-}

package/src/runtime/agent/orchestrator/tools/builtin/search-builders.mjs

@@ -137,11 +137,22 @@ export function buildGrepRgArgs(parts) {
     // globs (no trailing /**) always apply. searchPath is normalized to forward
     // slashes and de-trailing-slashed for the comparison.
     const _sp = String(searchPath || '').replace(/\\/g, '/').replace(/\/+$/, '');
+    // A positive --glob filter that NAMES a pruned directory is asking to
+    // search inside it; only the path operand used to count, so
+    // `glob:"__pycache__/*.pyc"` matched nothing while the files were there.
+    // Negative filters never re-admit their own target.
+    const _namedByGlobs = new Set(
+        (Array.isArray(globPatterns) ? globPatterns : [])
+            .filter((g) => typeof g === 'string' && g && !g.startsWith('!'))
+            .flatMap((g) => g.replace(/\\/g, '/').split('/'))
+            .filter((segment) => segment && !/[*?[\]{}]/.test(segment)),
+    );
     for (const ex of DEFAULT_IGNORE_GLOBS) {
         const m = /^!\*\*\/([^/]+)\/\*\*$/.exec(ex);
         if (m) {
             const name = m[1];
             if (_sp === name || _sp.endsWith(`/${name}`) || _sp.includes(`/${name}/`) || _sp.startsWith(`${name}/`)) continue;
+            if (_namedByGlobs.has(name)) continue;
         }
         rgArgs.push('--glob', ex);
     }

package/src/runtime/agent/orchestrator/tools/builtin/search-glob-tool.mjs

@@ -3,6 +3,7 @@ import { stat } from 'node:fs/promises';
 import { createHash } from 'crypto';
 import { isAbsolute, resolve } from 'path';
 import { trueCasePath } from './path-utils.mjs';
+import { expandAbsoluteGlobs } from './lib/absolute-glob-expand.mjs';
 import {
     canonicalizeGlobSlashes,
     coerceReadFamilyPathArg,
@@ -409,8 +410,19 @@ export async function executeGlobTool(args, workDir, options = {}) {
             const base = String(rel).split('/').filter(Boolean).pop() || '';
             return base !== '' && !hasGlobMagic(base);
         });
+        // A pattern that NAMES a pruned directory is asking for it: only the
+        // wildcard basename decided this before, so `node_modules/**/index.js`
+        // was answered while `__pycache__/*.pyc` returned "(no files found)"
+        // for a file sitting right there. The yield is per-directory — every
+        // other prune stays on — and a negative pattern never counts as a
+        // request for its own target.
+        const namedDirs = new Set([
+            ...rels.flatMap((rel) => String(rel).replace(/^!/, '').split('/')),
+            ...String(root || '').replace(/\\/g, '/').split('/'),
+        ].filter((segment) => segment && !hasGlobMagic(segment)));
         for (const ex of DEFAULT_IGNORE_GLOBS) {
-            if (explicitBasenames && /^!\*\*\/[^/]+\/\*\*$/.test(ex)) continue;
+            const pruned = /^!\*\*\/([^/]+)\/\*\*$/.exec(ex);
+            if (pruned && (explicitBasenames || namedDirs.has(pruned[1]))) continue;
             rgArgs.push('--glob', ex);
         }
         for (const ex of extraIgnoreGlobs) rgArgs.push('--glob', ex);
@@ -594,6 +606,18 @@ export async function executeGlobTool(args, workDir, options = {}) {
         : (rgStdoutTruncated ? '\n... [truncated at rg stdout cap (20MB); results incomplete]' : '')
             + (rgStdoutPartial ? '\n... [warning] rg exit 2 (partial results); listing may be incomplete' : '');
     const errSuffix = (rgErrors.length > 0 ? `\n... [warning] ${rgErrors.join(' | ')}` : '') + truncSuffix;
+    // An absolute pattern that enumerated nothing may still have real matches
+    // the inventory walker cannot see: it does not follow symlinked
+    // directories, and /sys, /proc and friends are made of them. Expand those
+    // patterns straight off the filesystem before declaring the miss.
+    if (capped.length === 0 && rgErrors.length === 0) {
+        const direct = await expandAbsoluteGlobs(patterns, {
+            limit: headLimit === Infinity ? 50 : offset + headLimit,
+        });
+        const window = offset > 0 ? direct.slice(offset) : direct;
+        const shown = headLimit === Infinity ? window : window.slice(0, headLimit);
+        if (shown.length > 0) return globPatternCapNote + shown.join('\n');
+    }
     let emptyDiag = '';
     if (capped.length === 0 && rgErrors.length === 0) {
         const patternStr = patterns.length === 1 ? JSON.stringify(patterns[0]) : JSON.stringify(patterns);