mixdog 0.9.149 → 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/lib/list-helpers.mjs

@@ -18,9 +18,16 @@ export async function readFamilyPathEnoentOrError(workDir, fullPath, inputPath,
         rerun: (target, opts) => rerunTool({ ...args, path: target }, workDir, opts),
     });
     if (redirected) return redirected;
-    const msg = `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
+    const safeMsg = normalizeErrorMessage(err instanceof Error ? err.message : String(err));
     const hint = buildNotFoundHint(workDir, fullPath, 'List', err?.code);
-    return msg + finalizeReadFamilyEnoentTail(hint, inputPath, err?.code);
+    const tail = finalizeReadFamilyEnoentTail(hint, inputPath, err?.code);
+    // Conclusive absence is the list's ANSWER, not a tool failure (matches
+    // read's `[path absent]` and git's `repo:false` policy). Genuine
+    // not-found only — EACCES/EPERM etc. keep failure semantics.
+    if (err?.code === 'ENOENT' || err?.code === 'ENOTDIR') {
+        return `[path absent] ${safeMsg}${tail}`;
+    }
+    return `Error: ${safeMsg}${tail}`;
 }
 
 export function normalizeListHeadLimit(raw, defaultCap) {

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

@@ -41,6 +41,12 @@ test('list defaults to a 100-entry page with an offset continuation', async () =
         const out = await executeListTool({ path: root, hidden: true }, process.cwd());
         assert.equal(out.split('\n').filter((line) => line.endsWith('\tfile')).length, 100);
         assert.match(out, /\[entries 1-100 of 101; pass offset:100 to continue\]/);
+        const oversized = await executeListTool(
+            { path: root, hidden: true, head_limit: 200 },
+            process.cwd(),
+        );
+        assert.equal(oversized.split('\n').filter((line) => line.endsWith('\tfile')).length, 100);
+        assert.match(oversized, /\[entries 1-100 of 101; pass offset:100 to continue\]/);
     } finally {
         await rm(root, { recursive: true, force: true });
     }

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

@@ -13,6 +13,7 @@ import { normalizeErrorMessage } from './path-diagnostics.mjs';
 import {
     buildListCacheKey,
     DEFAULT_IGNORE_GLOBS,
+    rootScanIgnoreGlobs,
 } from './search-builders.mjs';
 import { markScopedCacheIncomplete } from '../../session/cache/scoped-cache-outcome.mjs';
 import {
@@ -256,7 +257,11 @@ export async function executeListTool(args, workDir, options = {}) {
     const hidden = Boolean(args.hidden);
     const sort = ['name', 'mtime', 'size'].includes(args.sort) ? args.sort : 'name';
     const typeFilter = ['any', 'file', 'dir'].includes(args.type) ? args.type : 'any';
-    const headLimit = normalizeListHeadLimit(args.head_limit, _listDefaultHeadLimit(100));
+    const listHeadLimitCap = _listDefaultHeadLimit(100);
+    const requestedHeadLimit = normalizeListHeadLimit(args.head_limit, listHeadLimitCap);
+    const headLimit = requestedHeadLimit === 0
+        ? 0
+        : Math.min(requestedHeadLimit, listHeadLimitCap);
     const offset = typeof args.offset === 'number' && args.offset > 0 ? args.offset : 0;
     const needsGlobalStat = sort === 'mtime' || sort === 'size';
     const includeNoise = Boolean(args.include_noise);
@@ -899,6 +904,7 @@ export async function prewarmFindEnumeration(root) {
         for (const ex of DEFAULT_IGNORE_GLOBS) {
             common.push('--glob', ex);
         }
+        for (const ex of rootScanIgnoreGlobs(normalizeOutputPath(root))) common.push('--glob', ex);
         common.push('.');
         await getBroadEnumeration({
             root: normalizeOutputPath(root),
@@ -971,6 +977,7 @@ async function getTargetedFindEnumeration({
             if (!includeNoise) {
                 for (const ex of DEFAULT_IGNORE_GLOBS) rgArgs.push('--glob', ex);
             }
+            for (const ex of rootScanIgnoreGlobs(root)) rgArgs.push('--glob', ex);
             rgArgs.push('.');
             try {
                 const stdout = await runRgImpl(rgArgs, {
@@ -1031,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) || '.';
@@ -1096,7 +1136,13 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
                 hidden,
                 includeNoise,
                 maxDepth: depth,
-                exclude: includeNoise ? [] : DEFAULT_IGNORE_GLOBS,
+                exclude: [
+                    ...(includeNoise ? [] : DEFAULT_IGNORE_GLOBS),
+                    // Kernel-virtual trees are pruned even under include_noise:
+                    // they are never dependency noise, and walking them starves
+                    // the fuzzy inventory budget on a full-root scan.
+                    ...rootScanIgnoreGlobs(fullPath),
+                ],
             }, {
                 cwd: fullPath,
                 timeout: FIND_FUZZY_TIMEOUT_MS,
@@ -1234,6 +1280,7 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
     if (!includeNoise) {
         for (const ex of DEFAULT_IGNORE_GLOBS) ignoreGlobs.push('--glob', ex);
     }
+    for (const ex of rootScanIgnoreGlobs(normalizeOutputPath(fullPath))) ignoreGlobs.push('--glob', ex);
     // The narrowed pass must treat `query` as a LITERAL filename substring, not
     // a glob. Wrap every globset metacharacter in a single-char character class
     // (`[` → `[[]`, `*` → `[*]`, …): character-class quoting is the only form
@@ -1476,6 +1523,7 @@ export async function executeFindFilesTool(args, workDir, options = {}) {
     if (!includeNoise) {
         for (const ex of DEFAULT_IGNORE_GLOBS) inventoryArgs.push('--glob', ex);
     }
+    for (const ex of rootScanIgnoreGlobs(fullPath)) inventoryArgs.push('--glob', ex);
     if (namePattern) {
         inventoryArgs.push('--iglob', nameIsGlob ? namePattern : `*${namePattern}*`);
     }

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

@@ -15,7 +15,13 @@ import { ensureGraphBinary } from '../graph-binary-fetcher.mjs';
 import { fuzzyRank, prepareFuzzyItems } from './fuzzy-match.mjs';
 
 const RESTART_BACKOFF_MS = 30_000;
-const REQUEST_TIMEOUT_MS = 20_000;
+// Default request budget. Deliberately BELOW the read-only I/O watchdog in
+// tool-exec.mjs (20s): with both at 20s the watchdog killed the call first on
+// a cold whole-filesystem walk, so the soft-deadline partial the server hands
+// back near its own budget never reached the model (observed as a bare
+// "timed out with no partial output" on a full-root glob). The 2.5s margin
+// covers caller preprocessing plus response serialization/ranking.
+const REQUEST_TIMEOUT_MS = 17_500;
 const SERVER_READY_TIMEOUT_MS = 1_000;
 const CANCEL_GRACE_MS = 1_000;
 const PROCESS_FAILURES_BEFORE_BACKOFF = 2;

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-glob-survey.test.mjs

@@ -0,0 +1,71 @@
+import assert from 'node:assert/strict';
+import { 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';
+
+function lines(fileTag, count) {
+    return Array.from({ length: count }, (_, i) => `${fileTag} line-${i + 1}`).join('\n') + '\n';
+}
+
+test('multi-file glob fan-out caps the survey window at 25 lines per file', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'mixdog-read-glob-survey-'));
+    try {
+        await writeFile(join(root, 'a.log'), lines('alpha', 200));
+        await writeFile(join(root, 'b.log'), lines('beta', 200));
+        const out = await executeBuiltinTool('read', { file_path: join(root, '*.log') }, root);
+        assert.equal(typeof out, 'string');
+        // Head of each file is present…
+        assert.match(out, /alpha line-1\b/);
+        assert.match(out, /beta line-1\b/);
+        assert.match(out, /alpha line-25\b/);
+        assert.match(out, /beta line-25\b/);
+        assert.doesNotMatch(out, /alpha line-26\b/);
+        assert.doesNotMatch(out, /beta line-26\b/);
+    } finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
+
+test('explicit limit is clamped to 25 lines per glob-expanded file', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'mixdog-read-glob-explicit-'));
+    try {
+        await writeFile(join(root, 'a.log'), lines('alpha', 200));
+        await writeFile(join(root, 'b.log'), lines('beta', 200));
+        const out = await executeBuiltinTool('read', { file_path: join(root, '*.log'), limit: 150 }, root);
+        assert.match(out, /alpha line-25\b/);
+        assert.doesNotMatch(out, /alpha line-26\b/);
+    } finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
+
+test('glob fan-out shares a 10 KB output budget across files', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'mixdog-read-glob-budget-'));
+    try {
+        const payload = 'x'.repeat(300);
+        for (let i = 0; i < 10; i++) {
+            await writeFile(join(root, `${i}.log`), lines(`${i}-${payload}`, 25));
+        }
+        const out = await executeBuiltinTool('read', { file_path: join(root, '*.log'), limit: 25 }, root);
+        assert.ok(Buffer.byteLength(out, 'utf8') <= 10 * 1024);
+        assert.match(out, /0\.log/);
+        assert.match(out, /9\.log/);
+    } finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
+
+test('single-file glob match uses the same 25-line cap', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'mixdog-read-glob-single-'));
+    try {
+        await writeFile(join(root, 'only.log'), lines('solo', 200));
+        const out = await executeBuiltinTool('read', { file_path: join(root, '*.log') }, root);
+        assert.match(out, /solo line-25\b/);
+        assert.doesNotMatch(out, /solo line-26\b/);
+    } finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});

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

@@ -105,7 +105,12 @@ async function loadSharp() {
         _sharpPromise = (async () => {
             try {
                 const mod = await import('sharp');
-                return mod?.default || mod || null;
+                const sharp = mod?.default || mod || null;
+                // libvips' internal operation cache (default ~50MB per
+                // process) duplicates the JS-level resize cache above and the
+                // on-disk rendition cache; keep pixels out of native memory.
+                try { sharp?.cache(false); } catch { /* cache stays default */ }
+                return sharp;
             } catch {
                 return null;
             }

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

@@ -272,6 +272,13 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
         hint = finalizeReadFamilyEnoentTail(hint, filePath, err?.code);
         const _rawMsg = err instanceof Error ? err.message : String(err);
         const _safeMsg = normalizeErrorMessage(_rawMsg, workDir);
+        // A conclusive "no such path" is the ANSWER to the read, not a tool
+        // failure (same policy as git's `repo:false`): the error envelope
+        // routed callers into recovery mode for an ordinary absence probe.
+        // Genuine not-found only — EACCES/EPERM etc. keep failure semantics.
+        if (err?.code === 'ENOENT' || err?.code === 'ENOTDIR') {
+            return `[path absent] ${_safeMsg}${hint}`;
+        }
         return `Error: ${_safeMsg}${hint}`;
     }
     // A successful edit/apply_patch leaves a session-scoped full-file snapshot.