mixdog 0.9.87 → 0.9.89

package/src/runtime/agent/orchestrator/session/token-native.mjs

@@ -19,7 +19,6 @@ import { existsSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { resolve as pathResolve, dirname as pathDirname, join as pathJoin } from 'node:path';
-import { startChildGuardian } from '../../../shared/child-guardian.mjs';
 import { getPluginData } from '../config.mjs';
 import { ensureTokenBinary, findCachedTokenBinary } from '../tools/token-binary-fetcher.mjs';
 
@@ -112,9 +111,8 @@ function _ensureServer() {
     child.stdin?.unref?.();
     child.stdout?.unref?.();
     child.stdin?.on?.('error', () => { /* EPIPE on teardown */ });
-    try {
-        startChildGuardian({ childPid: child.pid, label: 'mixdog-token', orphanGraceMs: 8000, forceGraceMs: 3000 });
-    } catch { /* guardian best-effort */ }
+    // The native server exits when its stdio owner closes. A second Electron
+    // guardian duplicated that same ownership signal while retaining ~100 MB.
     server.ready = _request(server, OP_PING, null, READY_TIMEOUT_MS).then((count) => count !== null);
     _server = server;
     return server;

package/src/runtime/agent/orchestrator/session/tool-batch.mjs

@@ -117,6 +117,12 @@ export async function processToolBatch(ctx) {
                     role: 'tool',
                     content: _stub,
                     toolCallId: call.id,
+                    // Explicitly NOT a success: no tool executed for this call.
+                    // 'skipped' keeps the transcript/UI non-error (a benign
+                    // dedup, not a failure) while the unresolved-tool-failure
+                    // stop hook refuses to count it as the executed success
+                    // that would resolve a prior failure.
+                    toolKind: 'skipped',
                 });
                 continue;
             }
@@ -137,6 +143,10 @@ export async function processToolBatch(ctx) {
                         role: 'tool',
                         content: _stub,
                         toolCallId: call.id,
+                        // Same rule as the intra-turn stub above: the earlier
+                        // result is replayed from context, nothing executed, so
+                        // this can never resolve a prior tool failure.
+                        toolKind: 'skipped',
                     });
                     try {
                         appendAgentTrace({
@@ -172,6 +182,15 @@ export async function processToolBatch(ctx) {
                         role: 'tool',
                         content: `[repeat-failure-guard] This exact \`${call.name}\` call (identical arguments) has already failed ${_rfg.count} times in a row; not re-executing because the result will not change. Change approach: use different arguments, a different tool, or skip this step.`,
                         toolCallId: call.id,
+                        // The call is still UNRESOLVED — the guard only skips the
+                        // re-execution. Tagging it as an error keeps it a failure
+                        // for every downstream consumer, notably the turn stop
+                        // hook (a skip must never read as a success that resolves
+                        // an earlier failure).
+                        toolKind: 'error',
+                        // …but nothing was dispatched, so this skip is not a real
+                        // tool failure and must never ARM the stop hook either.
+                        guardSkip: true,
                     });
                     continue;
                 }

package/src/runtime/agent/orchestrator/tools/bash-session.mjs

@@ -151,11 +151,9 @@ function resolveBash() {
 // Map<id, { proc, lastUsed, stdoutBuf, stderrBuf, busy }>
 const _sessions = new Map();
 let _reaperTimer = null;
-// R17 parent-exit hook installed exactly once at first _spawnSession. Without
-// it, persistent bash shells orphan on server-main death (the async
-// 'process-exit' path at the bottom of this module never gets to run its
-// awaits when the host dies abruptly). Sync iteration of _sessions + direct
-// _killProcessTree (sync taskkill on win, sync process.kill on posix).
+// R17 terminating-signal hooks installed exactly once at first _spawnSession.
+// The module-level synchronous exit drain below owns normal process teardown;
+// these handlers cover signals that another listener may consume before exit.
 let _parentExitInstalled = false;
 function _installParentExitHook() {
     if (_parentExitInstalled) return;
@@ -165,7 +163,6 @@ function _installParentExitHook() {
             try { _killProcessTree(s.proc); } catch { /* ignore */ }
         }
     };
-    try { process.on('exit', sweep); } catch { /* ignore */ }
     // For terminating signals, sweep children then restore default POSIX
     // termination. A sweep-only handler swallows the signal and leaves the
     // process alive, so after sweeping we remove our handler and re-raise the
@@ -367,6 +364,7 @@ function _spawnSession(id, initialCwd = process.cwd(), resourceLease = null) {
         childPid: proc.pid,
         childGroupPid: proc.pid,
         label: 'bash-session',
+        protectHostMemory: true,
     });
     proc.stdout.setEncoding('utf-8');
     proc.stderr.setEncoding('utf-8');

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

@@ -36,7 +36,7 @@ export const BUILTIN_TOOLS = [
         name: 'read',
         title: 'Mixdog Read',
         annotations: { title: 'Mixdog Read', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false },
-        description: 'Read file contents; guessed path/name → find first. Batch paths/regions as real arrays: path[] or {path,offset,limit}[] regions in one call. Not for directories.',
+        description: 'Read file contents. Batch paths/regions as real arrays: path[] or {path,offset,limit}[] regions in one call. Not for directories.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -74,8 +74,8 @@ export const BUILTIN_TOOLS = [
         name: 'shell',
         title: 'Mixdog Shell',
         annotations: { title: 'Mixdog Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: 'Run programs/change state; not file inspection. Calls in one turn run parallel; '
-            + 'combine order-dependent commands. Use async for sleep/watch/dev loops.'
+        description: 'Run programs/change state; not file inspection. '
+            + 'Combine order-dependent commands into one command. Use async for sleep/watch/dev loops.'
             + `${_shellSyntaxCheat} ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
         inputSchema: {
             type: 'object',
@@ -123,7 +123,7 @@ export const BUILTIN_TOOLS = [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Text/regex; pattern[] batches variants in one call. path[] batches verified scopes only; file/span reads use read path[] regions.',
+                    description: 'Text/regex; pattern[] batches variants in one call.',
                 },
                 path: {
                     anyOf: [
@@ -154,7 +154,7 @@ export const BUILTIN_TOOLS = [
         name: 'glob',
         title: 'Mixdog Glob',
         annotations: { title: 'Mixdog Glob', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
-        description: 'Match exact glob patterns from verified base directories (project root is verified); guessed root/name → find first. Batch pattern[]/path[].',
+        description: 'Match exact glob patterns from verified base directories (project root is verified). Batch pattern[]/path[].',
         inputSchema: {
             type: 'object',
             properties: {

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

@@ -351,7 +351,7 @@ export async function executeTreeTool(args, workDir, options = {}) {
 // plus a short TTL for serial reuse. Truncated/partial sweeps are
 // known-incomplete and are NEVER cached.
 const FIND_ENUM_CACHE = new Map(); // key -> { files, expiresAt, gen }
-const FIND_ENUM_INFLIGHT = new Map(); // key -> Promise<{files,truncated,partial}>
+const FIND_ENUM_INFLIGHT = new Map(); // key -> { promise, controller, subscribers }
 let FIND_ENUM_GEN = 0;
 
 // The broad enumeration is a DERIVED cache the scope/path invalidation layer
@@ -388,13 +388,56 @@ function parseRgFileList(stdout) {
         .map((p) => normalizeOutputPath(p.replace(/^\.[/\\]/, '')));
 }
 
+function findEnumerationAbortError(signal) {
+    const reason = signal?.reason;
+    return reason instanceof Error ? reason : new Error(String(reason || 'find canceled'));
+}
+
+function subscribeToFindEnumeration(key, entry, signal = null) {
+    const token = {};
+    entry.subscribers.add(token);
+    return new Promise((resolve, reject) => {
+        let done = false;
+        const detach = () => {
+            if (signal instanceof AbortSignal) {
+                try { signal.removeEventListener('abort', onAbort); } catch { /* ignore */ }
+            }
+        };
+        const settle = (fn, value) => {
+            if (done) return;
+            done = true;
+            entry.subscribers.delete(token);
+            detach();
+            fn(value);
+        };
+        function onAbort() {
+            const error = findEnumerationAbortError(signal);
+            settle(reject, error);
+            // A shared broad sweep survives one caller canceling, but when every
+            // subscriber is gone it is useless work and must release its rg.
+            if (entry.subscribers.size === 0) {
+                try { entry.controller.abort(error); } catch { /* ignore */ }
+                if (FIND_ENUM_INFLIGHT.get(key) === entry) FIND_ENUM_INFLIGHT.delete(key);
+            }
+        }
+        if (signal instanceof AbortSignal) {
+            if (signal.aborted) { onAbort(); return; }
+            signal.addEventListener('abort', onAbort, { once: true });
+        }
+        entry.promise.then(
+            (value) => settle(resolve, value),
+            (error) => settle(reject, error),
+        );
+    });
+}
+
 // Run (or reuse) the broad `rg --files` sweep for a root. Returns
 // { files, truncated, partial }. The returned `files` array is SHARED — callers
 // must treat it as read-only. `rgArgs` must be the broad-pass args (no per-query
 // narrowing); the cache key includes every enumeration-affecting dimension, so
 // any caller producing an
 // equivalent sweep for the same dims reuses the result.
-async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMode, rgArgs, cwd, runRgImpl = runRg, bestEffort = false }) {
+async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMode, rgArgs, cwd, runRgImpl = runRg, bestEffort = false, signal = null }) {
     const ttl = findEnumTtlMs();
     const key = findEnumKey({ root, hidden, depth, includeNoise, ignoreMode });
     if (ttl > 0) {
@@ -409,7 +452,7 @@ async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMo
     // query[] fan-out should still share the one broad `rg --files` sweep
     // instead of spawning N identical enumerations.
     const inflight = FIND_ENUM_INFLIGHT.get(key);
-    if (inflight) return inflight;
+    if (inflight) return subscribeToFindEnumeration(key, inflight, signal);
     // Non-competing prewarm: past the cache/single-flight fast paths this runs
     // a fresh `rg` sweep (a child-spawn slot). Best-effort warmers skip that
     // spawn when the gate has no spare capacity, returning a known-incomplete
@@ -419,8 +462,10 @@ async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMo
         return { files: [], truncated: false, partial: true };
     }
     const genAtStart = FIND_ENUM_GEN;
-    const run = (async () => {
-        const stdout = await runRgImpl(rgArgs, { cwd });
+    const controller = new AbortController();
+    const entry = { promise: null, controller, subscribers: new Set() };
+    entry.promise = (async () => {
+        const stdout = await runRgImpl(rgArgs, { cwd, signal: controller.signal });
         const truncated = Boolean(stdout && typeof stdout === 'object' && stdout.truncated);
         const partial = Boolean(stdout && typeof stdout === 'object' && stdout.partial);
         const files = parseRgFileList(stdout);
@@ -433,11 +478,12 @@ async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMo
         }
         return { files, truncated, partial };
     })();
-    FIND_ENUM_INFLIGHT.set(key, run);
-    try { return await run; }
-    finally {
-        if (FIND_ENUM_INFLIGHT.get(key) === run) FIND_ENUM_INFLIGHT.delete(key);
-    }
+    FIND_ENUM_INFLIGHT.set(key, entry);
+    const cleanup = () => {
+        if (FIND_ENUM_INFLIGHT.get(key) === entry) FIND_ENUM_INFLIGHT.delete(key);
+    };
+    entry.promise.then(cleanup, cleanup);
+    return subscribeToFindEnumeration(key, entry, signal);
 }
 
 // Best-effort warm of the broad enumeration for a root using the `find` tool's
@@ -458,6 +504,43 @@ export async function prewarmFindEnumeration(root) {
     } catch { /* best-effort warm; never surface */ }
 }
 
+function escapeFindGlobLiteral(value) {
+    return String(value).replace(/[*?[\]{}]/g, (char) => `[${char}]`);
+}
+
+async function getTargetedFindEnumeration({
+    context,
+    queries,
+    root,
+    hidden,
+    depth,
+    includeNoise,
+    runRgImpl,
+    signal,
+}) {
+    const terms = [...new Set((queries || []).map((query) => String(query || '').trim()).filter(Boolean))];
+    const key = JSON.stringify([root, hidden, depth ?? '', includeNoise, terms]);
+    const runs = context?.targetedRuns;
+    if (runs?.has(key)) return runs.get(key);
+    const run = (async () => {
+        const rgArgs = ['--files', '--no-ignore'];
+        if (hidden) rgArgs.push('--hidden');
+        if (depth != null) rgArgs.push('--max-depth', String(depth));
+        for (const query of terms) rgArgs.push('--iglob', `*${escapeFindGlobLiteral(query)}*`);
+        rgArgs.push('.');
+        const stdout = await runRgImpl(rgArgs, { cwd: root, signal });
+        const paths = parseRgFileList(stdout).filter((path) =>
+            includeNoise || !path.split('/').some((segment) => NOISE_DIR_NAMES.has(segment)));
+        return {
+            files: paths,
+            truncated: Boolean(stdout && typeof stdout === 'object' && stdout.truncated),
+            partial: Boolean(stdout && typeof stdout === 'object' && stdout.partial),
+        };
+    })();
+    if (runs) runs.set(key, run);
+    return run;
+}
+
  // Fuzzy filename search (nucleo-style): collect the file
 // list via `rg --files`, then rank by subsequence score. `list.fuzzy` still
 // routes here for hidden backward compatibility, but the model-facing tool is
@@ -468,30 +551,22 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
         const capped = list.length > 5;
         const targets = capped ? list.slice(0, 5) : list;
         if (targets.length > 1) {
-            // Bounded parallel fan-out: every query shares ONE broad `rg --files`
-            // sweep via the enumeration cache's in-flight single-flight dedup, so
-            // running them concurrently collapses N broad sweeps into one and
-            // overlaps the tiny per-query narrowed passes. Bodies land at a fixed
-            // index so the emitted section order still matches the caller's
-            // query[] order — only wall-clock cost changes. Concurrency is capped
-            // so a 5-query batch cannot exhaust the child-spawn budget.
-            const FIND_FANOUT_CONCURRENCY = 4;
-            const bodies = new Array(targets.length);
-            let cursor = 0;
-            const runWorker = async () => {
-                for (;;) {
-                    const i = cursor++;
-                    if (i >= targets.length) return;
-                    try {
-                        bodies[i] = await executeFuzzyFindTool({ ...args, query: targets[i] }, workDir, options);
-                    } catch (err) {
-                        bodies[i] = `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
-                    }
-                }
+            // Full parallelism is intentional. All sections share one common
+            // broad enumeration and one unioned ignored/truncated targeted pass,
+            // but ranking and output remain isolated per query.
+            const batchContext = {
+                queries: targets,
+                targetedRuns: new Map(),
+                itemsByFiles: new WeakMap(),
             };
-            await Promise.all(
-                Array.from({ length: Math.min(FIND_FANOUT_CONCURRENCY, targets.length) }, runWorker),
-            );
+            const nestedOptions = { ...options, __findBatchContext: batchContext };
+            const bodies = await Promise.all(targets.map(async (query) => {
+                try {
+                    return await executeFuzzyFindTool({ ...args, query }, workDir, nestedOptions);
+                } catch (err) {
+                    return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
+                }
+            }));
             const sections = targets.map((q, i) => `# find ${q}\n${bodies[i]}`);
             if (capped) sections.push(`... [capped at 5 of ${list.length} queries]`);
             return sections.join('\n\n');
@@ -551,7 +626,6 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
     // literal path separator and does NOT escape. So a query like "[slug].tsx"
     // still produces the intended `*[[]slug[]].tsx*` include instead of a
     // character-class that matches one of s/l/u/g.
-    const escapeGlobLiteral = (s) => s.replace(/[*?[\]{}]/g, (c) => `[${c}]`);
     // Test-only seam: allow a caller to inject a runRg stand-in (e.g. to
     // simulate a truncated broad pass) without touching the production path.
     // Never set on the real tool-execution options object.
@@ -576,13 +650,19 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
             rgArgs: [...baseRgArgs, ...ignoreGlobs, '.'],
             cwd: fullPath,
             runRgImpl,
+            signal: options.signal,
         });
     } catch (err) {
         return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
     }
     let rgTruncated = broadEnum.truncated;
     let rgPartial = broadEnum.partial;
-    const passOneItems = broadEnum.files.map((path) => ({ path }));
+    const batchContext = options?.__findBatchContext;
+    let passOneItems = batchContext?.itemsByFiles?.get(broadEnum.files);
+    if (!passOneItems) {
+        passOneItems = broadEnum.files.map((path) => ({ path }));
+        batchContext?.itemsByFiles?.set(broadEnum.files, passOneItems);
+    }
     // Any single path segment is an exact-name candidate, including names with
     // spaces, extensionless names, and literal glob characters. The comparison
     // below is direct, so glob syntax has no special meaning in this decision.
@@ -590,57 +670,36 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
     const queryLower = query.toLowerCase();
     const passOneHasExactBasename = !exactFilenameQuery || broadEnum.files.some((path) =>
         path.slice(path.lastIndexOf('/') + 1).toLowerCase() === queryLower);
-    const passOneHasCandidate = fuzzyRank(query, passOneItems, 1).length > 0;
-    let fallbackRan = false;
-    let fallbackPaths = [];
-    // Only pay for the hardened tree walk when common discovery has no answer,
-    // or when an exact filename could be hidden by .gitignore. Reuse the
-    // hardened broad cache shared with find_files: its key distinguishes
-    // ignoreMode, so this cannot collide with the common pass.
-    if (!includeNoise && (!passOneHasCandidate || !passOneHasExactBasename)) {
+    const rankLimit = headLimit > 0 ? headLimit + 1 : headLimit;
+    const passOneRanked = fuzzyRank(query, passOneItems, rankLimit);
+    const passOneHasCandidate = passOneRanked.length > 0;
+    let targetedProbeRan = false;
+    let targetedPaths = [];
+    // A full --no-ignore enumeration can exceed 20MB, then trigger one more
+    // whole-tree narrowed pass PER query. Probe only requested names instead,
+    // unioning every query in this find batch into one rg process.
+    if (rgTruncated || rgPartial || (!includeNoise && (!passOneHasCandidate || !passOneHasExactBasename))) {
         try {
-            const fallbackArgs = ['--files', '--no-ignore', ...baseRgArgs.slice(2), ...ignoreGlobs, '.'];
-            const fallbackEnum = await getBroadEnumeration({
-                root: normalizeOutputPath(fullPath),
-                hidden, depth, includeNoise, ignoreMode: 'all',
-                rgArgs: fallbackArgs, cwd: fullPath, runRgImpl,
+            const targeted = await getTargetedFindEnumeration({
+                context: batchContext,
+                queries: batchContext?.queries || [query],
+                root: fullPath,
+                hidden,
+                depth,
+                includeNoise,
+                runRgImpl,
+                signal: options.signal,
             });
-            rgTruncated ||= fallbackEnum.truncated;
-            rgPartial ||= fallbackEnum.partial;
-            fallbackPaths = fallbackEnum.files;
-            fallbackRan = true;
+            rgTruncated ||= targeted.truncated;
+            rgPartial ||= targeted.partial;
+            targetedPaths = targeted.files.filter((path) => path.toLowerCase().includes(queryLower));
+            targetedProbeRan = true;
         } catch {
-            // This required fallback leaves the result incomplete. Surface the
-            // existing partial warning and prevent the final output cache from
-            // preserving a pass-one-only answer.
+            if (options.signal?.aborted) throw findEnumerationAbortError(options.signal);
             rgPartial = true;
         }
     }
-    // Narrowed enumeration: only files whose NAME contains the query
-    // (case-insensitive substring glob). This output is tiny and effectively
-    // never truncated, so exact/substring hits are guaranteed to reach ranking
-    // regardless of whether the broad pass was cut at the cap. Best-effort:
-    // failures here never fail the tool — the broad pass still stands.
-    let narrowPaths = [];
-    // Only spawn the per-query narrowed rg pass when the broad enumeration was
-    // cut (cap/exit-2): an untruncated broad pass already contains every file,
-    // so every narrowed substring hit is a broad-set duplicate that the
-    // dedup below drops — running it would add zero items. Skipping it there
-    // removes a redundant full-tree walk per query with identical output.
-    if (rgTruncated || rgPartial) try {
-        // A positive --iglob whitelist makes ripgrep re-admit paths its own
-        // `!**/<noise>/**` negations would otherwise exclude (the whitelist
-        // wins regardless of glob order), so noise dirs are pruned in JS here
-        // instead — matching the broad pass's effective exclusion set.
-        const narrowBaseArgs = fallbackRan
-            ? ['--files', '--no-ignore', ...baseRgArgs.slice(2)]
-            : baseRgArgs;
-        const narrowStdout = await runRgImpl([...narrowBaseArgs, '--iglob', `*${escapeGlobLiteral(query)}*`, '.'], { cwd: fullPath });
-        narrowPaths = parseRgFiles(narrowStdout).filter((p) =>
-            includeNoise || !p.split('/').some((seg) => NOISE_DIR_NAMES.has(seg)));
-    } catch { /* best-effort backstop; broad pass already collected */ }
-    // Merge pass one + fallback + narrowed, deduplicating by path. Pass-one
-    // order always wins so the fallback cannot perturb common-path ranking.
+    // Merge common + targeted results, preserving common-path order.
     const seen = new Set();
     const items = [];
     for (const p of broadEnum.files) {
@@ -648,18 +707,14 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
         seen.add(p);
         items.push({ path: p });
     }
-    for (const p of fallbackPaths) {
+    for (const p of targetedPaths) {
         if (seen.has(p)) continue;
         seen.add(p);
         items.push({ path: p });
     }
-    for (const p of narrowPaths) {
-        if (seen.has(p)) continue;
-        seen.add(p);
-        items.push({ path: p });
-    }
-    const rankLimit = headLimit > 0 ? headLimit + 1 : headLimit;
-    const rankedRaw = fuzzyRank(query, items, rankLimit);
+    const rankedRaw = targetedPaths.length > 0
+        ? fuzzyRank(query, items, rankLimit)
+        : passOneRanked;
     const hasMore = headLimit > 0 && rankedRaw.length > headLimit;
     const ranked = hasMore ? rankedRaw.slice(0, headLimit) : rankedRaw;
     // Build output lines uniformly for the hit and no-match cases so a
@@ -671,7 +726,7 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
     if (!noMatch && hasMore) lines.push(`... (top ${headLimit}; raise head_limit for more)`);
     if (rgTruncated) lines.push('... [warning] rg stdout truncated at 20MB cap; broad ranking incomplete (exact-name hits still merged)');
     if (rgPartial && !rgTruncated) lines.push('... [warning] rg exit 2 (partial results); broad ranking may be incomplete');
-    if (!fallbackRan && headLimit > 0 && fuzzyRank(query, passOneItems, headLimit).length >= headLimit) {
+    if (!targetedProbeRan && headLimit > 0 && passOneRanked.length >= headLimit) {
         lines.push('[gitignored trees not searched; retry with include_noise:true]');
     }
     const result = lines.join('\n');
@@ -834,12 +889,13 @@ export async function executeFindFilesTool(args, workDir, options = {}) {
                     root: normalizeOutputPath(fullPath),
                     hidden, depth, includeNoise, ignoreMode: 'all',
                     rgArgs, cwd: fullPath,
+                    signal: options.signal,
                 });
                 rgStdoutTruncated = enumRes.truncated;
                 rgStdoutPartial = enumRes.partial;
                 relPaths = enumRes.files;
             } else {
-                const stdout = await runRg(rgArgs, { cwd: fullPath });
+                const stdout = await runRg(rgArgs, { cwd: fullPath, signal: options.signal });
                 rgStdoutTruncated = Boolean(stdout && typeof stdout === 'object' && stdout.truncated);
                 rgStdoutPartial = Boolean(stdout && typeof stdout === 'object' && stdout.partial);
                 relPaths = parseRgFileList(stdout);

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

@@ -5,6 +5,7 @@ import { extname } from 'path';
 import { normalizeInputPath } from './path-utils.mjs';
 import { buildNotFoundHint, finalizeReadFamilyEnoentTail, tryReadFamilyEnoentRedirect } from './search-path-diagnostics.mjs';
 import { getReadSnapshot } from './read-snapshot-runtime.mjs';
+import { recordReadPathRedirect } from './snapshot-store.mjs';
 import { snapshotCoversFullFile, statMatchesSnapshot } from './snapshot-helpers.mjs';
 import { formatBinaryReadPreview } from './binary-file.mjs';
 
@@ -247,6 +248,11 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
                 opts,
                 helpers,
             ),
+            onRedirect: (requested, target) => recordReadPathRedirect(
+                requested,
+                resolveAgainstCwd(normalizeInputPath(target), workDir),
+                readStateScope,
+            ),
         });
         if (redirected) return redirected;
         const similar = findSimilarFile(fullPath);