mixdog 0.7.1

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

@@ -0,0 +1,593 @@
+import { readdirSync } from 'fs';
+import { basename, relative } from 'path';
+import {
+    extractGlobBaseDirectory,
+    hasGlobMagic,
+    normalizeInputPath,
+    normalizeOutputPath,
+    resolveAgainstCwd,
+} from './path-utils.mjs';
+import { normalizeErrorMessage } from './path-diagnostics.mjs';
+import { isUncPath, isWindowsDevicePath, hasUnsafeWin32Component } from './device-paths.mjs';
+import { capShellOutput } from './shell-output.mjs';
+import {
+    buildListCacheKey,
+    DEFAULT_IGNORE_GLOBS,
+} from './search-builders.mjs';
+import { markScopedCacheIncomplete } from '../../session/cache/scoped-cache-outcome.mjs';
+import {
+    cacheGet,
+    cacheSet,
+    getCachedReadOnlyStat,
+    statPathsForMtime,
+    lstatPathsForMtime,
+} from './cache-layers.mjs';
+import {
+    compileSimpleGlob,
+    NOISE_DIR_NAMES,
+    walkDir,
+} from './glob-walk.mjs';
+import { formatMtime } from './list-formatting.mjs';
+import { runRg } from './rg-runner.mjs';
+import { fuzzyRank } from './fuzzy-match.mjs';
+import { assertPathReachable } from './fs-reachability.mjs';
+
+const FIND_WALK_TIMEOUT_MS = 20_000;
+const LIST_WALK_TIMEOUT_MS = 20_000;
+const LIST_ABSOLUTE_CAP = 50_000;
+
+/** undefined / invalid / negative → defaultCap; 0 = no page cap (absolute caps still apply). */
+function normalizeListHeadLimit(raw, defaultCap) {
+    if (raw === undefined || raw === null || raw === '') return defaultCap;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 0) return defaultCap;
+    return Math.floor(n);
+}
+
+// UNC / Windows-device / NTFS-ADS guard for directory-walking modes
+// (list / tree / find). Walking a UNC share auto-authenticates to the
+// remote host (NTLM hash leak); a raw-device / reserved-name path can
+// hang or grant raw access. Mirrors the read path's string-based checks.
+// Returns an Error string when the path is blocked, else null.
+function listGuardPath(p) {
+    if (typeof isUncPath === 'function' && isUncPath(p))
+        return `Error: cannot walk UNC / SMB path (network credential leak risk): ${normalizeOutputPath(p)}`;
+    if (typeof isWindowsDevicePath === 'function' && isWindowsDevicePath(p))
+        return `Error: cannot walk Windows device path (reserved name or raw-device namespace): ${normalizeOutputPath(p)}`;
+    if (typeof hasUnsafeWin32Component === 'function' && hasUnsafeWin32Component(p))
+        return `Error: cannot walk Windows path with trailing dot/space or NTFS ADS suffix (bypasses device guard): ${normalizeOutputPath(p)}`;
+    return null;
+}
+
+export async function executeListTool(args, workDir, options = {}) {
+    if (typeof args.fuzzy === 'string' && args.fuzzy.length > 0) {
+        return executeFuzzyFind(args, workDir);
+    }
+    if (args.mode === 'tree') return executeTreeTool(args, workDir, options);
+    if (args.mode === 'find') return executeFindFilesTool(args, workDir, options);
+    args.path = normalizeInputPath(args.path);
+    if (!args.name && hasGlobMagic(args.path)) {
+        return executeFindFilesTool({ ...args, mode: 'find' }, workDir);
+    }
+    const inputPath = args.path || '.';
+    const depth = Math.min(Math.max(parseInt(args.depth ?? 1, 10) || 1, 1), 10);
+    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, 200);
+    const offset = typeof args.offset === 'number' && args.offset > 0 ? args.offset : 0;
+    const needsGlobalStat = sort === 'mtime' || sort === 'size';
+    const includeNoise = Boolean(args.include_noise);
+    const _listGuard = listGuardPath(inputPath);
+    if (_listGuard) return _listGuard;
+    const fullPath = resolveAgainstCwd(inputPath, workDir);
+    const _listGuardFull = listGuardPath(fullPath);
+    if (_listGuardFull) return _listGuardFull;
+    const cacheKey = buildListCacheKey({
+        mode: 'list',
+        inputPath: normalizeOutputPath(fullPath),
+        depth,
+        hidden,
+        sort,
+        typeFilter,
+        headLimit,
+        offset,
+        includeNoise,
+    });
+    const cached = cacheGet(cacheKey);
+    if (cached !== null) return cached;
+    try { await assertPathReachable(fullPath); }
+    catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
+    let st;
+    try { st = getCachedReadOnlyStat(fullPath); }
+    catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
+    if (!st.isDirectory()) return `Error: not a directory — ${normalizeOutputPath(fullPath)}`;
+
+    const rows = [];
+    // Width guard: depth is capped above, but a single very wide directory
+    // tree could push unbounded rows before sort/slice runs and exhaust
+    // memory. Mirror the find-mode FIND_ABSOLUTE_CAP + walk deadline so the
+    // accumulator stops growing once the cap or timeout trips. Small dirs
+    // never hit either bound, so normal behavior is unchanged.
+    let truncatedByCap = false;
+    const walkDeadline = Date.now() + LIST_WALK_TIMEOUT_MS;
+    walkDir(fullPath, {
+        hidden,
+        maxDepth: depth,
+        excludeDirNames: includeNoise ? null : NOISE_DIR_NAMES,
+        visit: (ent, entPath) => {
+            if (Date.now() > walkDeadline) { truncatedByCap = true; return false; }
+            const isDir = ent.isDirectory();
+            const isFile = ent.isFile();
+            if (typeFilter === 'file' && !isFile) return;
+            if (typeFilter === 'dir' && !isDir) return;
+            const entType = isDir ? 'dir' : (isFile ? 'file' : (ent.isSymbolicLink() ? 'symlink' : 'other'));
+            rows.push({
+                path: entPath,
+                type: entType,
+                size: 0,
+                mtimeMs: 0,
+                fullPath: entPath,
+            });
+            if (rows.length >= LIST_ABSOLUTE_CAP) {
+                truncatedByCap = true;
+                return false;
+            }
+            // Pre-sort truncation removed: a global name sort needs all
+            // candidates collected before slicing, otherwise the visible
+            // window depends on traversal order rather than sort order.
+        },
+    });
+
+    if (needsGlobalStat && rows.length > 0) {
+        // lstat: symlinks should report own metadata, not the target's.
+        const stats = await lstatPathsForMtime(rows.map((row) => row.fullPath), workDir, 64, { deadlineMs: 5000 });
+        for (let i = 0; i < rows.length; i++) {
+            const item = stats[i];
+            if (!item?.stat) continue;
+            rows[i].size = item.size;
+            rows[i].mtimeMs = item.mtimeMs;
+        }
+    }
+
+    if (sort === 'mtime') rows.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    else if (sort === 'size') rows.sort((a, b) => b.size - a.size);
+    else rows.sort((a, b) => a.path.localeCompare(b.path));
+
+    const windowed = offset > 0 ? rows.slice(offset) : rows;
+    const sliced = headLimit > 0 ? windowed.slice(0, headLimit) : windowed;
+    if (!needsGlobalStat && sliced.length > 0) {
+        // Use lstat so a symlink reports its own size/mtime instead of
+        // the target's. The walker already typed symlinks from Dirent;
+        // following the link here would lie about the listed entry.
+        const stats = await lstatPathsForMtime(sliced.map((row) => row.fullPath), workDir, 64, { deadlineMs: 5000 });
+        for (let i = 0; i < sliced.length; i++) {
+            const item = stats[i];
+            if (!item?.stat) continue;
+            sliced[i].size = item.size;
+            sliced[i].mtimeMs = item.mtimeMs;
+        }
+    }
+    const lines = sliced.map(r =>
+        `${normalizeOutputPath(r.path)}\t${r.type}\t${r.size}\t${formatMtime(r.mtimeMs)}`);
+    if (windowed.length > sliced.length) lines.push(`... [entries ${offset + 1}-${offset + sliced.length} of ${rows.length}; pass offset:${offset + sliced.length} to continue]`);
+    if (truncatedByCap) lines.push(`... walk truncated at ${LIST_ABSOLUTE_CAP} rows or ${LIST_WALK_TIMEOUT_MS}ms timeout; narrow the path or lower depth for a complete listing`);
+    let emptyMsg = '(empty directory)';
+    if (lines.length === 0 && (typeFilter !== 'any' || hidden === false)) {
+        const filterParts = [];
+        if (typeFilter !== 'any') filterParts.push(`type=${typeFilter}`);
+        if (hidden === false) {
+            let hasHidden = false;
+            try {
+                const entries = readdirSync(fullPath, { withFileTypes: true });
+                hasHidden = entries.some(e => e.name && e.name.startsWith('.'));
+            } catch {}
+            if (hasHidden) filterParts.push(`hidden=false (dotfiles present — pass hidden:true to include)`);
+            else filterParts.push(`hidden=false`);
+        }
+        emptyMsg = `(no entries match filter) ${filterParts.join(', ')} path=${inputPath}`;
+    }
+    const out = lines.join('\n') || emptyMsg;
+    if (options?.scopedCacheOutcome && (truncatedByCap || windowed.length > sliced.length)) {
+        markScopedCacheIncomplete(options.scopedCacheOutcome);
+    }
+    cacheSet(cacheKey, out, { scopes: [fullPath] });
+    // ② completion progress (claude "Found N" parity). Best-effort, no-op
+    // when onProgress is absent (no progressToken).
+    if (typeof options?.onProgress === 'function') {
+        try { options.onProgress(`${windowed.length} entries`); } catch { /* best-effort */ }
+    }
+    return out;
+}
+
+export async function executeTreeTool(args, workDir, options = {}) {
+    args.path = normalizeInputPath(args.path);
+    const inputPath = args.path || '.';
+    const depth = Math.min(Math.max(parseInt(args.depth ?? 3, 10) || 3, 1), 6);
+    const hidden = Boolean(args.hidden);
+    const headLimit = normalizeListHeadLimit(args.head_limit, 200);
+    const offset = typeof args.offset === 'number' && args.offset > 0 ? args.offset : 0;
+    const includeNoise = Boolean(args.include_noise);
+    const _treeGuard = listGuardPath(inputPath);
+    if (_treeGuard) return _treeGuard;
+    const fullPath = resolveAgainstCwd(inputPath, workDir);
+    const _treeGuardFull = listGuardPath(fullPath);
+    if (_treeGuardFull) return _treeGuardFull;
+    const cacheKey = buildListCacheKey({
+        mode: 'tree',
+        inputPath: normalizeOutputPath(fullPath),
+        depth,
+        hidden,
+        sort: '',
+        typeFilter: '',
+        headLimit,
+        offset,
+        includeNoise,
+    });
+    const cached = cacheGet(cacheKey);
+    if (cached !== null) return cached;
+    try { await assertPathReachable(fullPath); }
+    catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
+    let st;
+    try { st = getCachedReadOnlyStat(fullPath); }
+    catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
+    if (!st.isDirectory()) return `Error: not a directory — ${normalizeOutputPath(fullPath)}`;
+    const lines = [`${normalizeOutputPath(fullPath)}/`];
+    const prefixStack = [''];
+    const TREE_BRANCH_LINE_CAP = 500;
+    walkDir(fullPath, {
+        hidden,
+        maxDepth: depth,
+        excludeDirNames: includeNoise ? null : NOISE_DIR_NAMES,
+        sort: (a, b) => {
+            const ad = a.isDirectory(), bd = b.isDirectory();
+            if (ad !== bd) return ad ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        },
+        visit: (ent, _entPath, ctx) => {
+            const prefix = prefixStack[ctx.depth - 1] || '';
+            const branch = ctx.isLast ? '└── ' : '├── ';
+            const display = ent.isDirectory() ? `${ent.name}/` : ent.name;
+            lines.push(`${prefix}${branch}${display}`);
+            if (ent.isDirectory()) {
+                prefixStack[ctx.depth] = prefix + (ctx.isLast ? '    ' : '│   ');
+            }
+            if (headLimit !== 0) {
+                const gatherLimit = headLimit > 0
+                    ? offset + headLimit + 1
+                    : offset + TREE_BRANCH_LINE_CAP + 1;
+                // Exclude the root line (lines[0]) from the body-row count:
+                // the windowed slice operates on lines.slice(1), so gather
+                // must measure body rows, not total. Without -1 the sentinel
+                // "+N more entries" misfires off-by-one on the boundary.
+                if (lines.length - 1 >= gatherLimit) return false;
+            }
+        },
+    });
+    const root = lines[0];
+    const body = lines.slice(1);
+    const windowed = offset > 0 ? body.slice(offset) : body;
+    // head_limit:0 means "no cap" (Infinity); negative/NaN means "use default cap".
+    const branchLimit = headLimit === 0
+        ? Infinity
+        : (headLimit > 0 ? headLimit : TREE_BRANCH_LINE_CAP);
+    const sliced = branchLimit === Infinity ? windowed : windowed.slice(0, branchLimit);
+    const outLines = [root, ...sliced];
+    if (windowed.length > sliced.length) {
+        // The walk stops gathering at gatherLimit, so when body filled to the
+        // cap the true total is unknown — render `N+` so the caller keeps
+        // paging instead of reading the capped count as the real total.
+        const gatherCap = headLimit > 0 ? offset + headLimit + 1 : offset + TREE_BRANCH_LINE_CAP + 1;
+        const totalLabel = body.length >= gatherCap ? `${body.length}+` : `${body.length}`;
+        outLines.push(`... [entries ${offset + 1}-${offset + sliced.length} of ${totalLabel}; pass offset:${offset + sliced.length} to continue]`);
+    }
+    const TREE_OUTPUT_CHAR_CAP = 50_000;
+    let out = outLines.join('\n');
+    let outputCharTruncated = false;
+    if (out.length > TREE_OUTPUT_CHAR_CAP) {
+        outputCharTruncated = true;
+        out = out.slice(0, TREE_OUTPUT_CHAR_CAP) + `\n... [output truncated at ${Math.round(TREE_OUTPUT_CHAR_CAP/1024)} KB; narrow path or lower depth]`;
+    }
+    if (options?.scopedCacheOutcome && (windowed.length > sliced.length || outputCharTruncated)) {
+        markScopedCacheIncomplete(options.scopedCacheOutcome);
+    }
+    cacheSet(cacheKey, out, { scopes: [fullPath] });
+    return out;
+}
+
+// Fuzzy filename search (codex file-search / nucleo style): collect the file
+// list via `rg --files`, then rank by subsequence score. Lets a partial name
+// like "edeng" surface "edit-engine.mjs" in one call instead of guessing an
+// exact glob pattern. Honors path/hidden/include_noise/depth/head_limit.
+async function executeFuzzyFind(args, workDir) {
+    const query = String(args.fuzzy);
+    const inputPath = normalizeInputPath(args.path) || '.';
+    const guard = listGuardPath(inputPath);
+    if (guard) return guard;
+    const fullPath = resolveAgainstCwd(inputPath, workDir);
+    const guardFull = listGuardPath(fullPath);
+    if (guardFull) return guardFull;
+    const hidden = Boolean(args.hidden);
+    const includeNoise = Boolean(args.include_noise);
+    // head_limit:0 means "no cap" per list semantics — keep 0 distinct from default.
+    const headLimit = normalizeListHeadLimit(args.head_limit, 40);
+    const depth = args.depth != null ? Math.max(parseInt(args.depth, 10) || 1, 1) : null;
+    const rgArgs = ['--files', '--no-ignore'];
+    if (hidden) rgArgs.push('--hidden');
+    if (depth != null) rgArgs.push('--max-depth', String(depth));
+    if (!includeNoise) {
+        for (const ex of DEFAULT_IGNORE_GLOBS) rgArgs.push('--glob', ex);
+    }
+    rgArgs.push('.');
+    let stdout;
+    try {
+        stdout = await runRg(rgArgs, { cwd: fullPath });
+    } catch (err) {
+        return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
+    }
+    const items = String(stdout)
+        .split('\n')
+        // Strip only the trailing CR from rg's line split — do NOT trim, or a
+        // filename with leading/trailing spaces would be corrupted.
+        .map((p) => (p.endsWith('\r') ? p.slice(0, -1) : p))
+        .filter((p) => p.length > 0)
+        .map((p) => ({ path: normalizeOutputPath(p.replace(/^\.[/\\]/, '')) }));
+    const ranked = fuzzyRank(query, items, headLimit);
+    if (ranked.length === 0) return `(no fuzzy match for "${query}")`;
+    const out = ranked.map((r) => r.item.path).join('\n');
+    return headLimit > 0 && ranked.length >= headLimit
+        ? `${out}\n... (top ${headLimit}; raise head_limit for more)`
+        : out;
+}
+
+export async function executeFindFilesTool(args, workDir, options = {}) {
+    args.path = normalizeInputPath(args.path);
+    let inputPath = args.path || '.';
+    let namePattern = typeof args.name === 'string' ? args.name : null;
+    if (!namePattern && hasGlobMagic(inputPath)) {
+        const { baseDir, relativePattern } = extractGlobBaseDirectory(inputPath);
+        inputPath = baseDir || '.';
+        namePattern = relativePattern.replace(/^\/+/, '');
+    }
+    if (namePattern) namePattern = normalizeInputPath(namePattern).replace(/^\/+/, '');
+    const typeFilter = ['any', 'file', 'dir'].includes(args.type) ? args.type : 'any';
+    const sortMode = ['name', 'size', 'mtime'].includes(args.sort) ? args.sort : 'mtime';
+    const minSize = typeof args.min_size === 'number' && args.min_size > 0 ? args.min_size : null;
+    const maxSize = typeof args.max_size === 'number' && args.max_size >= 0 ? args.max_size : null;
+    const headLimit = normalizeListHeadLimit(args.head_limit, 100);
+    const offset = typeof args.offset === 'number' && args.offset > 0 ? args.offset : 0;
+    const includeNoise = Boolean(args.include_noise);
+    const hidden = Boolean(args.hidden);
+    // Clamp depth to >=1 when caller passes it; null means unbounded (legacy
+    // find-mode behavior). Forwarded to walkDir.maxDepth and the rg fast
+    // path's --max-depth so both code paths honor the cap consistently.
+    const depth = args.depth != null
+        ? Math.max(parseInt(args.depth, 10) || 1, 1)
+        : null;
+    const _findGuard = listGuardPath(inputPath);
+    if (_findGuard) return _findGuard;
+    const fullPath = resolveAgainstCwd(inputPath, workDir);
+    const _findGuardFull = listGuardPath(fullPath);
+    if (_findGuardFull) return _findGuardFull;
+    const cacheKey = buildListCacheKey({
+        mode: 'find',
+        inputPath: normalizeOutputPath(fullPath),
+        depth: depth ?? '',
+        hidden,
+        sort: sortMode,
+        typeFilter,
+        headLimit,
+        offset,
+        namePattern,
+        minSize,
+        maxSize,
+        modifiedAfter: args.modified_after || '',
+        modifiedBefore: args.modified_before || '',
+        includeNoise,
+    });
+    const cached = cacheGet(cacheKey);
+    if (cached !== null) return cached;
+
+    const parseTime = (v) => {
+        if (typeof v !== 'string') return null;
+        const m = v.match(/^(\d+)([hdm])$/);
+        if (m) {
+            const n = parseInt(m[1], 10);
+            const unit = m[2] === 'h' ? 3600 * 1000
+                       : m[2] === 'd' ? 86400 * 1000
+                       : 60 * 1000;
+            return Date.now() - n * unit;
+        }
+        const t = Date.parse(v);
+        return isNaN(t) ? null : t;
+    };
+    const after = parseTime(args.modified_after);
+    const before = parseTime(args.modified_before);
+    // An unparseable date must FAIL, not silently disable the filter — a
+    // caller who passed a filter believes the listing is filtered.
+    if (args.modified_after && after === null) {
+        return `Error: invalid modified_after ${JSON.stringify(args.modified_after)}; expected an ISO date/time or a relative window like 90m / 12h / 7d`;
+    }
+    if (args.modified_before && before === null) {
+        return `Error: invalid modified_before ${JSON.stringify(args.modified_before)}; expected an ISO date/time or a relative window like 90m / 12h / 7d`;
+    }
+
+    // `name` is documented as a SUBSTRING filter (use glob mode for patterns).
+    // Compile it as a glob ONLY when it actually contains glob metacharacters;
+    // otherwise match by case-insensitive contains. The bug was that EVERY name
+    // was glob-compiled, so a plain fragment like ".mjs" anchored-matched nothing.
+    const nameIsGlob = Boolean(namePattern && /[*?\[\]{}]/.test(namePattern));
+    let nameRegex = null, nameRootOptionalRegex = null;
+    if (namePattern && nameIsGlob) {
+        try {
+            // compileSimpleGlob throws (R16 DoS caps: >256 brace variants /
+            // oversized pattern/regex body) — convert to a tool-error string.
+            nameRegex = compileSimpleGlob(namePattern);
+            nameRootOptionalRegex = namePattern.startsWith('**/')
+                ? compileSimpleGlob(namePattern.slice(3))
+                : null;
+        } catch (err) {
+            return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
+        }
+    }
+    const nameLower = namePattern ? namePattern.toLowerCase() : null;
+    const namePatternHasPath = Boolean(namePattern && /[\\/]/.test(namePattern));
+    const matchesFindNamePattern = (entName, entPath) => {
+        if (!namePattern) return true;
+        const subject = namePatternHasPath
+            ? normalizeOutputPath(relative(fullPath, entPath))
+            : entName;
+        if (nameIsGlob) return nameRegex.test(subject) || Boolean(nameRootOptionalRegex?.test(subject));
+        return subject.toLowerCase().includes(nameLower);
+    };
+
+    try { await assertPathReachable(fullPath); }
+    catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
+    let rootStat;
+    try { rootStat = getCachedReadOnlyStat(fullPath); }
+    catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
+    if (!rootStat.isDirectory()) return `Error: not a directory — ${normalizeOutputPath(fullPath)}`;
+
+    const matches = [];
+    const FIND_ABSOLUTE_CAP = 50_000;
+    let truncatedByCap = false;
+    let rgStdoutTruncated = false;
+    let rgStdoutPartial = false;
+    const useBatchedStat = minSize === null && maxSize === null && after === null && before === null;
+    let handledByRgFiles = false;
+    if (useBatchedStat && typeFilter === 'file') {
+        try {
+            // --no-ignore: do not consult .gitignore. The slow walk path
+            // never honours .gitignore, so the fast path must match that
+            // contract — otherwise the rg branch silently returns fewer
+            // results than the fallback. Noise dirs are still excluded
+            // via DEFAULT_IGNORE_GLOBS below (unless include_noise).
+            const rgArgs = ['--files', '--no-ignore'];
+            if (hidden) rgArgs.push('--hidden');
+            if (depth != null) rgArgs.push('--max-depth', String(depth));
+            if (!includeNoise) {
+                for (const ex of DEFAULT_IGNORE_GLOBS) rgArgs.push('--glob', ex);
+            }
+            // Substring `name` (no glob metachars) → contains-glob so rg's
+            // pre-filter matches the JS matcher; explicit globs pass through.
+            if (namePattern) rgArgs.push('--iglob', nameIsGlob ? namePattern : `*${namePattern}*`);
+            rgArgs.push('.');
+            const stdout = await runRg(rgArgs, { cwd: fullPath });
+            rgStdoutTruncated = Boolean(stdout && typeof stdout === 'object' && stdout.truncated);
+            rgStdoutPartial = Boolean(stdout && typeof stdout === 'object' && stdout.partial);
+            const candidates = [];
+            for (const line of String(stdout).split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed) continue;
+                const candidate = resolveAgainstCwd(normalizeInputPath(trimmed), fullPath);
+                if (!matchesFindNamePattern(basename(candidate), candidate)) continue;
+                candidates.push(candidate);
+                if (candidates.length >= FIND_ABSOLUTE_CAP) {
+                    truncatedByCap = true;
+                    break;
+                }
+            }
+            const withStat = await statPathsForMtime(candidates, workDir, 64, { deadlineMs: 5000 });
+            for (const item of withStat) {
+                if (!item?.stat) continue;
+                matches.push({ path: item.full, size: item.size, mtimeMs: item.mtimeMs });
+            }
+            handledByRgFiles = true;
+        } catch {
+            handledByRgFiles = false;
+        }
+    }
+    if (!handledByRgFiles && useBatchedStat) {
+        const candidates = [];
+        const walkDeadline1 = Date.now() + FIND_WALK_TIMEOUT_MS;
+        walkDir(fullPath, {
+            hidden,
+            maxDepth: depth ?? Infinity,
+            excludeDirNames: includeNoise ? null : NOISE_DIR_NAMES,
+            visit: (ent, entPath) => {
+                if (Date.now() > walkDeadline1) { truncatedByCap = true; return false; }
+                const isDir = ent.isDirectory();
+                const isFile = ent.isFile();
+                if (typeFilter === 'file' && !isFile) return;
+                if (typeFilter === 'dir' && !isDir) return;
+                if (!matchesFindNamePattern(ent.name, entPath)) return;
+                candidates.push(entPath);
+                if (candidates.length >= FIND_ABSOLUTE_CAP) {
+                    truncatedByCap = true;
+                    return false;
+                }
+            },
+        });
+        const withStat = await statPathsForMtime(candidates, workDir, 64, { deadlineMs: 5000 });
+        for (const item of withStat) {
+            if (!item?.stat) continue;
+            matches.push({ path: item.full, size: item.size, mtimeMs: item.mtimeMs });
+        }
+    } else if (!handledByRgFiles) {
+        // Size filters only have meaning for files; when the caller passed
+        // min_size/max_size without also restricting type, narrow the
+        // result set to files so directories don't slip past with their
+        // (usually 0-byte) directory size.
+        const sizeFiltered = (minSize !== null || maxSize !== null);
+        const effectiveTypeFilter = sizeFiltered && typeFilter === 'any' ? 'file' : typeFilter;
+        const candidates = [];
+        const walkDeadline2 = Date.now() + FIND_WALK_TIMEOUT_MS;
+        walkDir(fullPath, {
+            hidden,
+            maxDepth: depth ?? Infinity,
+            excludeDirNames: includeNoise ? null : NOISE_DIR_NAMES,
+            visit: (ent, entPath) => {
+                if (Date.now() > walkDeadline2) { truncatedByCap = true; return false; }
+                const isDir = ent.isDirectory();
+                const isFile = ent.isFile();
+                if (effectiveTypeFilter === 'file' && !isFile) return;
+                if (effectiveTypeFilter === 'dir' && !isDir) return;
+                if (!matchesFindNamePattern(ent.name, entPath)) return;
+                candidates.push(entPath);
+                if (candidates.length >= FIND_ABSOLUTE_CAP) {
+                    truncatedByCap = true;
+                    return false;
+                }
+            },
+        });
+        const withStat = await statPathsForMtime(candidates, workDir, 64, { deadlineMs: 5000 });
+        for (const item of withStat) {
+            if (!item?.stat) continue;
+            const { stat, full: entPath, mtimeMs } = item;
+            if (stat.isFile()) {
+                if (minSize !== null && stat.size < minSize) continue;
+                if (maxSize !== null && stat.size > maxSize) continue;
+            }
+            if (after !== null && mtimeMs < after) continue;
+            if (before !== null && mtimeMs > before) continue;
+            matches.push({ path: entPath, size: stat.size, mtimeMs });
+            if (matches.length >= FIND_ABSOLUTE_CAP) {
+                truncatedByCap = true;
+                break;
+            }
+        }
+    }
+
+    matches.sort((a, b) => {
+        if (sortMode === 'name') return normalizeOutputPath(a.path).localeCompare(normalizeOutputPath(b.path));
+        if (sortMode === 'size') return b.size - a.size;
+        return b.mtimeMs - a.mtimeMs;
+    });
+    const windowed = offset > 0 ? matches.slice(offset) : matches;
+    const sliced = headLimit > 0 ? windowed.slice(0, headLimit) : windowed;
+    const lines = sliced.map(m =>
+        `${normalizeOutputPath(m.path)}\t${m.size}\t${formatMtime(m.mtimeMs)}`);
+    if (windowed.length > sliced.length) lines.push(`... [entries ${offset + 1}-${offset + sliced.length} of ${matches.length}; pass offset:${offset + sliced.length} to continue]`);
+    if (rgStdoutTruncated) lines.push('... [warning] rg stdout truncated at 20MB cap; results incomplete');
+    if (rgStdoutPartial) lines.push('... [warning] rg exit 2 (partial results); listing may be incomplete');
+    if (truncatedByCap) lines.push(`... walk truncated at ${FIND_ABSOLUTE_CAP} matches; narrow the scope (path/name/modified_after) for accurate global sort`);
+    const out = lines.join('\n') || '(no matches)';
+    if (options?.scopedCacheOutcome && (truncatedByCap || rgStdoutTruncated || rgStdoutPartial || windowed.length > sliced.length)) {
+        markScopedCacheIncomplete(options.scopedCacheOutcome);
+    }
+    const findIncomplete = truncatedByCap || rgStdoutTruncated || rgStdoutPartial || windowed.length > sliced.length;
+    if (!findIncomplete) {
+        cacheSet(cacheKey, out, { scopes: [fullPath] });
+    }
+    return out;
+}

package/src/agent/orchestrator/tools/builtin/native-edit-runner.mjs

@@ -0,0 +1,89 @@
+import { existsSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { performance } from 'perf_hooks';
+import { fileURLToPath } from 'url';
+import { snapshotCoversFullFile } from './snapshot-helpers.mjs';
+import { getPluginData } from '../../config.mjs';
+import { findCachedPatchBinary } from '../patch-binary-fetcher.mjs';
+import { runServerEdit } from '../patch.mjs';
+
+const PLUGIN_ROOT = process.env.CLAUDE_PLUGIN_ROOT
+    || resolve(dirname(fileURLToPath(import.meta.url)), '../../../../..');
+const NATIVE_EDIT_DEFAULT_BIN = join(
+    PLUGIN_ROOT,
+    'native/mixdog-patch/target/release',
+    process.platform === 'win32' ? 'mixdog-patch.exe' : 'mixdog-patch',
+);
+
+export function nativeEditMode() {
+    return String(process.env.MIXDOG_EDIT_NATIVE || 'auto').toLowerCase();
+}
+
+export function nativeEditBinPath() {
+    const override = process.env.MIXDOG_EDIT_NATIVE_BIN || process.env.MIXDOG_PATCH_NATIVE_BIN;
+    if (override) return override;
+    if (existsSync(NATIVE_EDIT_DEFAULT_BIN)) return NATIVE_EDIT_DEFAULT_BIN;
+    return findCachedPatchBinary(getPluginData()) || NATIVE_EDIT_DEFAULT_BIN;
+}
+
+export function nativeEditShouldAttempt({ editSnapshot, oldStr, newStr, preloadedContent, preloadedRawBuf }) {
+    const mode = nativeEditMode();
+    if (/^(0|false|no|off|js|legacy)$/i.test(mode)) return false;
+    if (!existsSync(nativeEditBinPath())) return false;
+    if (!snapshotCoversFullFile(editSnapshot)) return false;
+    if (preloadedContent !== null || preloadedRawBuf !== null) return false;
+    if (typeof oldStr !== 'string' || oldStr.length === 0 || typeof newStr !== 'string') return false;
+    if (/^(1|true|yes|on|native)$/i.test(mode)) return true;
+    // auto: the persistent server removed per-call spawn cost, so route edits to
+    // native edit2 by default (B3). Same-size edits keep the JS in-place partial
+    // write, which rewrites bytes in place instead of the whole file.
+    const oldBytes = Buffer.byteLength(oldStr, 'utf-8');
+    const newBytes = Buffer.byteLength(newStr, 'utf-8');
+    if (oldBytes === newBytes) return false;
+    return true;
+}
+
+export async function runNativeExactEdit({ fullPath, oldStr, newStr, replaceAll, signal = null }) {
+    if (signal?.aborted) {
+        return { ok: false, fallback: false, error: signal.reason?.message || signal.reason || 'native edit aborted' };
+    }
+    const oldBuf = Buffer.from(oldStr, 'utf-8');
+    const newBuf = Buffer.from(newStr, 'utf-8');
+    const started = performance.now();
+    try {
+        // PARITY GUARD: the native engine MATCHES via the curly-quote fold
+        // tier but applies new_string verbatim, silently downgrading the
+        // file's typographic quotes (JS slow path preserves them via
+        // preserveQuoteTypography). When old_string carries quote-family
+        // chars — the only inputs that can land on the curly tier — probe
+        // with a dry run (persistent server, ~ms) and defer curly-tier
+        // matches to the JS editor.
+        if (/["'‘’“”]/.test(oldStr)) {
+            const probe = await runServerEdit({ fullPath, oldBuf, newBuf, replaceAll, dryRun: true, signal });
+            if (probe?.tier === 'curly') {
+                return { ok: false, fallback: true, error: 'curly-quote fold match — deferred to JS editor for typography preservation' };
+            }
+        }
+        const res = await runServerEdit({ fullPath, oldBuf, newBuf, replaceAll, signal });
+        return {
+            ok: true,
+            replacements: res.replacements,
+            readMs: res.readMs,
+            applyMs: res.applyMs,
+            writeMs: res.writeMs,
+            totalMs: res.totalMs,
+            roundtripMs: res.roundtripMs ?? (performance.now() - started),
+            stage: res.tier,
+            contentHash: res.contentHash,
+        };
+    } catch (err) {
+        if (err?.name === 'AbortError') {
+            return { ok: false, fallback: false, error: err.message };
+        }
+        const msg = String(err?.message || err);
+        // Tier misses and not-found map to a JS fallback; transport/spawn errors
+        // also fall back so a server hiccup never blocks an edit.
+        const fallback = /old_string (?:not found|found \d+ times)|not valid UTF-8|no exact match|not found|server/i.test(msg);
+        return { ok: false, fallback, error: msg };
+    }
+}