mixdog 1.2.0 → 1.2.2

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

@@ -19,6 +19,15 @@ const READ_RANGE_INDEX_SWEEP_CONCURRENCY = 8;
 const READ_RANGE_INDEX_CACHE = new Map();
 const READ_RANGE_INDEX_DRAFTS = new WeakMap();
 const READ_RANGE_INDEX_PERSIST_PENDING = new Map();
+const READ_RANGE_INDEX_INFLIGHT = new Map();
+const READ_RANGE_INDEX_LAST_PERSISTED = new Map();
+// key -> outstanding deletes whose unlink / cancelled write has not settled.
+const READ_RANGE_INDEX_DELETING = new Map();
+let readRangeIndexDeleteSeq = 0;
+const READ_RANGE_INDEX_LAST_PERSISTED_MAX = 256;
+const READ_RANGE_INDEX_WRITE_CONCURRENCY = 2;
+const READ_RANGE_INDEX_WRITE_WAITERS = [];
+let readRangeIndexWritesActive = 0;
 let readRangeIndexDiskSwept = false;
 
 let traceReadRangeIndex = () => {};
@@ -99,7 +108,9 @@ async function computePrefixHashForIndex(fullPath, st, handle = null, prefixBuff
       if (!handle) {
         try {
           await fh.close();
-        } catch {}
+        } catch {
+          /* close failure after a completed read is irrelevant */
+        }
       }
     }
   } catch {
@@ -123,14 +134,21 @@ async function loadReadRangeIndexFromDisk(fullPath, st, handle, prefixBuffer) {
   // No existsSync preflight: a missing file surfaces as an ENOENT from
   // readFile below, caught by the same try/catch — one FS pass, not two.
   if (!file || !st) return null;
+  // A delete wins over any disk content: while a cancelled write may still be
+  // landing the file is invisible, and a read that straddled a delete is void.
+  const key = canonicalCachePath(fullPath);
+  const deleteSeq = readRangeIndexDeleteSeq;
+  const deleted = () => READ_RANGE_INDEX_DELETING.has(key) || readRangeIndexDeleteSeq !== deleteSeq;
+  if (deleted()) return null;
   try {
     const row = JSON.parse(await readFile(file, 'utf-8'));
-    if (!readRangeIndexMatches(row, fullPath, st)) return null;
+    if (deleted() || !readRangeIndexMatches(row, fullPath, st)) return null;
     // The prefix is an extra check, not proof that later byte offsets survived.
     if (typeof row.prefixHash === 'string' && row.prefixHash) {
       const cur = await computePrefixHashForIndex(fullPath, st, handle, prefixBuffer);
       if (!cur || cur !== row.prefixHash) return null;
     }
+    if (deleted()) return null;
     const anchors = new Map([[0, 0]]);
     for (const entry of row.anchors) {
       if (!Array.isArray(entry) || entry.length < 2) continue;
@@ -161,35 +179,133 @@ function currentReadRangeIndex(index) {
   return !!index?.published && READ_RANGE_INDEX_CACHE.get(canonicalCachePath(index.fullPath)) === index;
 }
 
-function persistReadRangeIndexSync(index) {
+function rememberPersisted(key, text) {
+  READ_RANGE_INDEX_LAST_PERSISTED.delete(key);
+  READ_RANGE_INDEX_LAST_PERSISTED.set(key, text);
+  if (READ_RANGE_INDEX_LAST_PERSISTED.size > READ_RANGE_INDEX_LAST_PERSISTED_MAX) {
+    READ_RANGE_INDEX_LAST_PERSISTED.delete(READ_RANGE_INDEX_LAST_PERSISTED.keys().next().value);
+  }
+}
+
+// job = { index, row }: row is a pre-serialised evicted row (index no longer cached).
+// Returns false only when a write was needed but failed (e.g. lock contended).
+function persistReadRangeIndexSync(job) {
+  const { index, row: evictedRow } = job;
   const file = readRangeIndexFilePath(index?.fullPath);
-  if (!file || !currentReadRangeIndex(index)) return;
+  if (!file || (!evictedRow && !currentReadRangeIndex(index))) return true;
   try {
-    if (!sameFileVersion(index.fileVersion, statSync(index.fullPath))) return;
-    const row = serialiseReadRangeIndex(index);
-    if (row) writeJsonAtomicSync(file, row, { compact: true, lock: true, fsync: false });
-  } catch {}
+    if (!sameFileVersion(evictedRow?.fileVersion || index.fileVersion, statSync(index.fullPath))) return true;
+    const row = evictedRow || serialiseReadRangeIndex(index);
+    if (!row) return true;
+    const key = canonicalCachePath(index.fullPath);
+    const text = JSON.stringify(row);
+    if (READ_RANGE_INDEX_LAST_PERSISTED.get(key) === text) return true;
+    writeJsonAtomicSync(file, row, { compact: true, lock: true, fsync: false });
+    rememberPersisted(key, text);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
-async function persistReadRangeIndex(index, evictedRow = null) {
+function acquireReadRangeIndexWriteSlot() {
+  if (readRangeIndexWritesActive < READ_RANGE_INDEX_WRITE_CONCURRENCY) {
+    readRangeIndexWritesActive += 1;
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => READ_RANGE_INDEX_WRITE_WAITERS.push(resolve));
+}
+
+function releaseReadRangeIndexWriteSlot() {
+  const next = READ_RANGE_INDEX_WRITE_WAITERS.shift();
+  if (next) next();
+  else readRangeIndexWritesActive -= 1;
+}
+
+// One write attempt. `state.epoch` changes when the path is deleted: a write
+// that straddles a delete removes what it just wrote instead of resurrecting it.
+async function persistReadRangeIndexOnce(key, job, state) {
+  const { index, row: evictedRow } = job;
   const file = readRangeIndexFilePath(index?.fullPath);
   if (!file || (!evictedRow && !currentReadRangeIndex(index))) return;
+  const epoch = state.epoch;
+  // Admission precedes every stat/lock so waiting writers hold no file lock.
+  await acquireReadRangeIndexWriteSlot();
   try {
+    if (state.epoch !== epoch || (!evictedRow && !currentReadRangeIndex(index))) return;
     if (!sameFileVersion(evictedRow?.fileVersion || index.fileVersion, await stat(index.fullPath))) return;
     await mkdir(READ_RANGE_INDEX_DISK_DIR, { recursive: true });
-    if (!evictedRow && !currentReadRangeIndex(index)) return;
+    if (state.epoch !== epoch || (!evictedRow && !currentReadRangeIndex(index))) return;
     const row = evictedRow || serialiseReadRangeIndex(index);
-    if (row) await writeJsonAtomicAsync(file, row, { compact: true, lock: true, fsync: false });
-  } catch {}
+    if (!row) return;
+    const text = JSON.stringify(row);
+    if (READ_RANGE_INDEX_LAST_PERSISTED.get(key) === text) return;
+    readRangeIndexPersistStats.concurrent += 1;
+    readRangeIndexPersistStats.maxConcurrent = Math.max(
+      readRangeIndexPersistStats.maxConcurrent,
+      readRangeIndexPersistStats.concurrent
+    );
+    try {
+      await writeJsonAtomicAsync(file, row, { compact: true, lock: true, fsync: false });
+      readRangeIndexPersistStats.writes += 1;
+    } finally {
+      readRangeIndexPersistStats.concurrent -= 1;
+    }
+    if (state.epoch !== epoch) {
+      await unlink(file).catch(() => {});
+      return;
+    }
+    rememberPersisted(key, text);
+  } catch {
+    /* persisting the index is best-effort */
+  } finally {
+    releaseReadRangeIndexWriteSlot();
+  }
+}
+
+// Single-flight per cache file: a request during an in-flight write only
+// replaces the pending job; one follow-up write persists the latest state.
+function requestReadRangeIndexPersist(key, job) {
+  const state = READ_RANGE_INDEX_INFLIGHT.get(key);
+  if (state) {
+    state.next = job;
+    return;
+  }
+  const fresh = { epoch: 0, next: null, cancelWaiters: [] };
+  READ_RANGE_INDEX_INFLIGHT.set(key, fresh);
+  const settleCancelled = () => {
+    for (const resolve of fresh.cancelWaiters.splice(0)) resolve();
+  };
+  void (async () => {
+    try {
+      let cur = job;
+      while (cur) {
+        await persistReadRangeIndexOnce(key, cur, fresh);
+        // A cancelled write has finished (and cleaned up) once Once returns.
+        settleCancelled();
+        cur = fresh.next;
+        fresh.next = null;
+      }
+    } finally {
+      settleCancelled();
+      READ_RANGE_INDEX_INFLIGHT.delete(key);
+    }
+  })();
 }
 
 export function scheduleReadRangeIndexPersist(index) {
   if (!READ_RANGE_INDEX_DISK_DIR || !currentReadRangeIndex(index)) return;
   const key = canonicalCachePath(index.fullPath);
+  const inflight = READ_RANGE_INDEX_INFLIGHT.get(key);
+  if (inflight) {
+    inflight.next = { index, row: null };
+    return;
+  }
   if (READ_RANGE_INDEX_PERSIST_PENDING.has(key)) return;
   const t = setTimeout(() => {
     READ_RANGE_INDEX_PERSIST_PENDING.delete(key);
-    void persistReadRangeIndex(index);
+    const latest = READ_RANGE_INDEX_CACHE.get(key);
+    if (latest) requestReadRangeIndexPersist(key, { index: latest, row: null });
   }, READ_RANGE_INDEX_PERSIST_DEBOUNCE_MS);
   t.unref();
   READ_RANGE_INDEX_PERSIST_PENDING.set(key, t);
@@ -199,10 +315,19 @@ export function flushReadRangeIndexesSync() {
   for (const [key, timer] of READ_RANGE_INDEX_PERSIST_PENDING) {
     try {
       clearTimeout(timer);
-    } catch {}
+    } catch {
+      /* a timer that cannot be cleared must not block the flush */
+    }
     READ_RANGE_INDEX_PERSIST_PENDING.delete(key);
     const index = READ_RANGE_INDEX_CACHE.get(key);
-    if (index) persistReadRangeIndexSync(index);
+    if (index) persistReadRangeIndexSync({ index, row: null });
+  }
+  // Writes queued behind an in-flight one are still pending state at exit.
+  for (const state of READ_RANGE_INDEX_INFLIGHT.values()) {
+    // Keep the job unless it was durably handled: when the async writer holds
+    // the lock, its follow-up still persists it if the process keeps running.
+    const job = state.next;
+    if (job && persistReadRangeIndexSync(job) && state.next === job) state.next = null;
   }
 }
 
@@ -213,11 +338,32 @@ function dropReadRangeIndexSlot(key) {
 }
 
 export function deleteReadRangeIndexForPath(fullPath) {
-  dropReadRangeIndexSlot(canonicalCachePath(fullPath));
+  const key = canonicalCachePath(fullPath);
+  dropReadRangeIndexSlot(key);
+  READ_RANGE_INDEX_LAST_PERSISTED.delete(key);
+  readRangeIndexDeleteSeq += 1;
+  // Disk loads for this path are void until the unlink and any cancelled
+  // in-flight write (which removes its own output) have settled.
+  READ_RANGE_INDEX_DELETING.set(key, (READ_RANGE_INDEX_DELETING.get(key) || 0) + 1);
+  const inflight = READ_RANGE_INDEX_INFLIGHT.get(key);
+  let cancelled = Promise.resolve();
+  if (inflight) {
+    inflight.epoch += 1;
+    inflight.next = null;
+    cancelled = new Promise((resolve) => inflight.cancelWaiters.push(resolve));
+  }
   const file = readRangeIndexFilePath(fullPath);
-  if (file) void unlink(file).catch(() => {});
+  const unlinked = file ? unlink(file).catch(() => {}) : Promise.resolve();
+  void Promise.all([unlinked, cancelled]).then(() => {
+    const left = (READ_RANGE_INDEX_DELETING.get(key) || 1) - 1;
+    if (left > 0) READ_RANGE_INDEX_DELETING.set(key, left);
+    else READ_RANGE_INDEX_DELETING.delete(key);
+  });
 }
 
+// Test observability for write coalescing and the concurrency cap.
+export const readRangeIndexPersistStats = { writes: 0, concurrent: 0, maxConcurrent: 0 };
+
 export async function sweepStaleReadRangeIndexes(directory = READ_RANGE_INDEX_DISK_DIR) {
   if (!directory) return;
   let entries;
@@ -235,8 +381,14 @@ export async function sweepStaleReadRangeIndexes(directory = READ_RANGE_INDEX_DI
       const full = join(directory, name);
       try {
         const st = await stat(full);
-        if (now - st.mtimeMs > READ_RANGE_INDEX_DISK_STALE_MS) await unlink(full);
-      } catch {}
+        if (now - st.mtimeMs > READ_RANGE_INDEX_DISK_STALE_MS) {
+          await unlink(full);
+          // A removed file invalidates the unchanged-content skip.
+          READ_RANGE_INDEX_LAST_PERSISTED.clear();
+        }
+      } catch {
+        /* best-effort sweep: a file that vanished or cannot be removed is skipped */
+      }
     }
   }
   await Promise.all(Array.from({ length: Math.min(READ_RANGE_INDEX_SWEEP_CONCURRENCY, entries.length) }, worker));
@@ -255,7 +407,7 @@ function refreshReadRangeIndexSlot(key, index) {
     // their slot immediately. Disk IO must not delay the foreground lookup.
     const row = serialiseReadRangeIndex(evicted);
     dropReadRangeIndexSlot(oldest);
-    if (row) void persistReadRangeIndex(evicted, row);
+    if (row) requestReadRangeIndexPersist(oldest, { index: evicted, row });
   }
   return index;
 }
@@ -346,8 +498,7 @@ export async function publishReadRangeIndex(index, handle, signal = null, before
   // result requesting producer certification still owes its terminal stats.
   if (slot && READ_RANGE_INDEX_CACHE.get(key) !== slot && !onValidated) return false;
   try {
-    if (!sameFileVersion(version, await handle.stat()) || !sameFileVersion(version, await stat(fullPath)))
-      return false;
+    if (!sameFileVersion(version, await handle.stat()) || !sameFileVersion(version, await stat(fullPath))) return false;
   } catch {
     return false;
   }

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

@@ -108,7 +108,9 @@ async function symlinkTargetGuard(fullPath, filePath, helpers) {
     if (typeof isSpecialFileStat === 'function' && isSpecialFileStat(targetStat)) {
       return guardResponse('special', helpers, filePath, realTarget);
     }
-  } catch {}
+  } catch {
+    /* vanished target: see above */
+  }
   return null;
 }
 
@@ -138,7 +140,9 @@ export async function statReadTarget(fullPath, filePath, options, helpers) {
       const error = await symlinkTargetGuard(fullPath, filePath, helpers);
       if (error) return { st, error };
     }
-  } catch {}
+  } catch {
+    /* lstat failure is non-fatal: see above */
+  }
   return { st };
 }
 
@@ -148,12 +152,12 @@ export async function statReadTarget(fullPath, filePath, options, helpers) {
  * recovery mode for an ordinary absence probe. Genuine not-found only —
  * EACCES/EPERM etc. keep failure semantics.
  */
-export function readNotFoundResponse(err, { fullPath, filePath, workDir }, helpers) {
+export async function readNotFoundResponse(err, { fullPath, filePath, workDir }, helpers) {
   const { findSimilarFile, normalizeErrorMessage, normalizeOutputPath } = helpers;
   const similar = findSimilarFile(fullPath);
   let hint = similar
     ? appendNotFoundCwdNote(` Did you mean "${normalizeOutputPath(similar)}"?`, workDir, err?.code)
-    : buildNotFoundHint(workDir, fullPath, 'Read', err?.code);
+    : await buildNotFoundHint(workDir, fullPath, 'Read', err?.code);
   hint = finalizeReadFamilyEnoentTail(hint, filePath, err?.code);
   const safeMsg = normalizeErrorMessage(err instanceof Error ? err.message : String(err), workDir);
   if (err?.code === 'ENOENT' || err?.code === 'ENOTDIR') return `[path absent] ${safeMsg}${hint}`;

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

@@ -30,9 +30,10 @@ async function prefetchRawBody(fullPath, st, helpers, forceFresh = false) {
   const cachedRaw = !forceFresh && _rawContentCacheGet ? _rawContentCacheGet(fullPath, st) : null;
   if (cachedRaw) return { buf: cachedRaw, fromCache: true };
   try {
-    const buf = !forceFresh && _runRawContentInFlight
-      ? await _runRawContentInFlight(fullPath, readFile, st)
-      : await readFile(fullPath);
+    const buf =
+      !forceFresh && _runRawContentInFlight
+        ? await _runRawContentInFlight(fullPath, readFile, st)
+        : await readFile(fullPath);
     return { buf, fromCache: false };
   } catch {
     return { buf: null, fromCache: false };
@@ -84,7 +85,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
     let widenNote = '';
     const target = await statReadTarget(fullPath, filePath, options, helpers);
     if (target.error) return target.error;
-    if (!target.st) return readNotFoundResponse(target.statErr, { fullPath, filePath, workDir }, helpers);
+    if (!target.st) return await readNotFoundResponse(target.statErr, { fullPath, filePath, workDir }, helpers);
     const st = target.st;
     // Reactive widen + window-history bookkeeping (ranged text reads only).
     if (

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

@@ -45,7 +45,10 @@ async function scanSourceWindows(path, intervals, signal) {
     let parts = [];
     let partBytes = 0;
     const lines = new Map();
-    const buffer = Buffer.allocUnsafe(64 * 1024);
+    const minChunkBytes = 64 * 1024;
+    const maxChunkBytes = 1024 * 1024;
+    let chunkBytes = minChunkBytes;
+    let buffer = Buffer.allocUnsafe(chunkBytes);
     const deadline = Date.now() + READ_STREAM_TIMEOUT_MS;
     const check = () => {
       signal?.throwIfAborted();
@@ -70,7 +73,11 @@ async function scanSourceWindows(path, intervals, signal) {
     };
     while (interval < intervals.length) {
       check();
-      const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+      if (buffer.length < chunkBytes) buffer = Buffer.allocUnsafe(chunkBytes);
+      // Consume every byte inside the budget, even when a seeking chunk would
+      // cross it. The one-byte EOF probe never becomes usable source text.
+      const readBytes = Math.min(chunkBytes, Math.max(1, READ_MAX_SCAN_BYTES - scanned));
+      const { bytesRead } = await handle.read(buffer, 0, readBytes, position);
       check();
       if (!bytesRead) {
         if (partBytes) save(Buffer.alloc(0), true);
@@ -95,6 +102,12 @@ async function scanSourceWindows(path, intervals, signal) {
         start = end + 1;
       }
       position += bytesRead;
+      // Deep windows still validate coordinates from current bytes. Amortize
+      // positional IO while skipping, then return to small reads in a window.
+      chunkBytes =
+        interval < intervals.length && line < intervals[interval].start
+          ? Math.min(maxChunkBytes, chunkBytes * 2)
+          : minChunkBytes;
     }
     // Publication checks after its async stats, immediately before committing.
     // An unpublished result still owes a final deadline/cancellation check.

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

@@ -254,8 +254,8 @@ function absolutePaths(lines, rgCwd) {
   return lines.map((line) => (isAbsolute(line) ? line : resolveAgainstCwd(line, rgCwd)));
 }
 
-function missingGlobRoot(scan, root, rgCwd, err) {
-  const hint = buildNotFoundHint(scan.workDir, rgCwd, 'Search', err?.code);
+async function missingGlobRoot(scan, root, rgCwd, err) {
+  const hint = await buildNotFoundHint(scan.workDir, rgCwd, 'Search', err?.code);
   return {
     error: `path does not exist: ${normalizeOutputPath(rgCwd)} (${err?.code || 'ENOENT'})${finalizeReadFamilyEnoentTail(hint, root, err?.code)}`,
     paths: [],
@@ -422,14 +422,14 @@ function globMoreSuffix({ rgWindowIncomplete, remaining, totalBeforeOffset, next
   return '';
 }
 
-function globEmptyDiagnostic(scan, { totalBeforeOffset }) {
+async function globEmptyDiagnostic(scan, { totalBeforeOffset }) {
   const { patterns, basePath, baseEntries, workDir, statCache, offset } = scan;
   const patternStr = patterns.length === 1 ? JSON.stringify(patterns[0]) : JSON.stringify(patterns);
   const baseLabel = normalizeOutputPath(basePath);
   if (totalBeforeOffset > 0 && offset >= totalBeforeOffset) {
     return `(no entries after offset=${offset}; total=${totalBeforeOffset}) pattern=${patternStr} path=${baseLabel}`;
   }
-  const diagnostic = basePathDiagnostic(
+  const diagnostic = await basePathDiagnostic(
     baseEntries.map((e) => e.root),
     workDir,
     statCache
@@ -473,7 +473,7 @@ async function scanGlobGroups(scan) {
     const shown = await directAbsoluteMatches({ patterns, headLimit, offset });
     if (shown.length > 0) return patternCapNote + shown.join('\n');
   }
-  const out = patternCapNote + renderGlobPage(scan, merged, { capped, remaining, totalBeforeOffset, miss });
+  const out = patternCapNote + (await renderGlobPage(scan, merged, { capped, remaining, totalBeforeOffset, miss }));
   settleGlobScanCache(scan, merged, out, remaining);
   reportToolProgress(options, `found ${totalBeforeOffset} files`);
   return out;
@@ -482,7 +482,7 @@ async function scanGlobGroups(scan) {
 // The page body with its more/integrity suffixes. Empty partials are not
 // proof of absence: diagnostics are preserved even when there is no path
 // body, rather than silently dropping the integrity suffix.
-function renderGlobPage(scan, merged, { capped, remaining, totalBeforeOffset, miss }) {
+async function renderGlobPage(scan, merged, { capped, remaining, totalBeforeOffset, miss }) {
   const { offset } = scan;
   const errSuffix = globIntegritySuffix(merged);
   const moreSuffix = globMoreSuffix({
@@ -492,7 +492,7 @@ function renderGlobPage(scan, merged, { capped, remaining, totalBeforeOffset, mi
     nextOffset: offset + capped.length,
   });
   if (capped.length > 0) return `${capped.join('\n')}${moreSuffix}${errSuffix}`;
-  const emptyDiag = miss ? globEmptyDiagnostic(scan, { totalBeforeOffset }) : '';
+  const emptyDiag = miss ? await globEmptyDiagnostic(scan, { totalBeforeOffset }) : '';
   const emptyBody = (emptyDiag || '(no files found)').replace(
     '(no files found)',
     merged.rgStdoutPartial || merged.rgWindowIncomplete ? '(no files found yet)' : '(no files found)'
@@ -608,9 +608,12 @@ export async function executeGlobTool(args, workDir, options = {}) {
   };
   return await runScopedSearchInFlight(
     cacheKey,
-    ({ signal: sharedSignal, scopedCacheOutcome }) => scanGlobGroups({
-      ...scan, sharedSignal, options: { ...options, scopedCacheOutcome },
-    }),
+    ({ signal: sharedSignal, scopedCacheOutcome }) =>
+      scanGlobGroups({
+        ...scan,
+        sharedSignal,
+        options: { ...options, scopedCacheOutcome },
+      }),
     { signal: options?.signal || options?.abortSignal || null, scopes },
     options?.scopedCacheOutcome
   );

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

@@ -211,7 +211,7 @@ async function runGrepSearch(request, sharedSignal) {
 
 async function grepMissingPathResult({ workDir, grepResolvedPath, searchPath, executeChildBuiltinTool }, err) {
   const msg = `Error: path does not exist: ${normalizeOutputPath(grepResolvedPath)} (${err?.code || 'ENOENT'})`;
-  let hint = buildNotFoundHintBody(workDir, grepResolvedPath, 'Search', err?.code, {});
+  let hint = await buildNotFoundHintBody(workDir, grepResolvedPath, 'Search', err?.code, {});
   if (!hint) hint = await _suggestIndexedPaths(grepResolvedPath, executeChildBuiltinTool, workDir);
   return msg + finalizeReadFamilyEnoentTail(appendNotFoundCwdNote(hint, workDir, err?.code), searchPath, err?.code);
 }

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

@@ -65,10 +65,10 @@ const ENOENT_ABSENT =
 
 // Share diagnostic lookup results within one invocation without changing
 // the requested operand or executing a replacement operation.
-function cachedFileByBasename(workDir, missingPath, cache) {
+async function cachedFileByBasename(workDir, missingPath, cache) {
   if (!cache) return findFileByBasename(workDir, missingPath);
   if (!('fileHits' in cache)) cache.fileHits = findFileByBasename(workDir, missingPath);
-  return cache.fileHits;
+  return await cache.fileHits;
 }
 
 // A missing ABSOLUTE path that resolves outside the project cannot be
@@ -180,15 +180,15 @@ export function appendNotFoundCwdNote(hint, workDir, errCode = 'ENOENT') {
   return `${hint} (relative paths resolve from ${normalizeOutputPath(workDir)})`;
 }
 
-export function buildNotFoundHint(workDir, missingPath, actionVerb, errCode = 'ENOENT', cache = null) {
+export async function buildNotFoundHint(workDir, missingPath, actionVerb, errCode = 'ENOENT', cache = null) {
   return appendNotFoundCwdNote(
-    buildNotFoundHintBody(workDir, missingPath, actionVerb, errCode, cache),
+    await buildNotFoundHintBody(workDir, missingPath, actionVerb, errCode, cache),
     workDir,
     errCode
   );
 }
 
-export function buildNotFoundHintBody(workDir, missingPath, actionVerb, errCode = 'ENOENT', cache = null) {
+export async function buildNotFoundHintBody(workDir, missingPath, actionVerb, errCode = 'ENOENT', cache = null) {
   if (!NOT_FOUND_CODES.has(String(errCode || 'ENOENT'))) return '';
   // `C:tmpsmp` shape: a Windows path whose separators were eaten by JSON
   // escaping (`"C:\\tmp\\smp"` written as `"C:\tmp\smp"`). Name the cause —
@@ -200,12 +200,12 @@ export function buildNotFoundHintBody(workDir, missingPath, actionVerb, errCode
   if (missingPathIsOutsideProject(workDir, missingPath)) {
     return outsideProjectNotFoundHint(missingPath, actionVerb);
   }
-  const elsewhere = cachedFileByBasename(workDir, missingPath, cache);
+  const elsewhere = await cachedFileByBasename(workDir, missingPath, cache);
   if (elsewhere.length) {
     return ` Not found at this path; the same filename exists at: ${elsewhere.map((p) => `"${normalizeOutputPath(p)}"`).join(', ')}. ${actionVerb} that path directly.`;
   }
   if (isDirectoryPathGuess(missingPath)) {
-    const dirHits = findDirectoryByBasename(workDir, missingPath, { limit: 5 });
+    const dirHits = await findDirectoryByBasename(workDir, missingPath, { limit: 5 });
     if (dirHits.length > 1) {
       return ` Not found at this path; same-named directories exist at: ${dirHits
         .slice(0, 5)
@@ -268,9 +268,9 @@ export function uncRefusalMessage(toolName, original, resolved) {
   return `Error: ${toolName} refuses UNC/SMB path ${JSON.stringify(shown)}; remote share access is blocked to prevent NTLM credential leaks`;
 }
 
-export function basePathDiagnostic(basePaths, workDir, statCache = null) {
-  return basePaths
-    .map((basePath) => {
+export async function basePathDiagnostic(basePaths, workDir, statCache = null) {
+  const parts = await Promise.all(
+    basePaths.map(async (basePath) => {
       const resolved = resolveSearchScope(basePath, workDir);
       // Reuse the caller's call-scoped stat cache (glob preflight + per-group
       // rg runs already stat'd this same resolved root) instead of re-stating.
@@ -291,8 +291,13 @@ export function basePathDiagnostic(basePaths, workDir, statCache = null) {
       }
       return (
         `${normalizeOutputPath(basePath)}: path does not exist (${err?.code || 'ENOENT'})` +
-        finalizeReadFamilyEnoentTail(buildNotFoundHint(workDir, resolved, 'Search', err?.code), basePath, err?.code)
+        finalizeReadFamilyEnoentTail(
+          await buildNotFoundHint(workDir, resolved, 'Search', err?.code),
+          basePath,
+          err?.code
+        )
       );
     })
-    .join('; ');
+  );
+  return parts.join('; ');
 }

package/src/runtime/agent/orchestrator/tools/code-graph/dispatch/root-resolution.mjs

@@ -79,10 +79,10 @@ export function resolveAggregateAnchorRoot(name, args, baseCwd, { explicitCwdArg
  * One `file` anchor: an error string when it does not exist, otherwise the
  * root it re-homes the call to (null keeps the current cwd).
  */
-export function resolveFileAnchorRoot(name, args, fileArg, baseCwd) {
+export async function resolveFileAnchorRoot(name, args, fileArg, baseCwd) {
   const abs = _absFrom(baseCwd, fileArg);
   if (!existsSync(abs)) {
-    const elsewhere = findFileByBasename(pathResolve(baseCwd), abs);
+    const elsewhere = await findFileByBasename(pathResolve(baseCwd), abs);
     const hint = elsewhere.length
       ? ` Same filename exists at: ${elsewhere.map((p) => `"${toDisplayPath(p, baseCwd).replace(/\\/g, '/')}"`).join(', ')}. Use that path.`
       : '';

package/src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs

@@ -345,7 +345,7 @@ async function executeCodeGraphToolRaw(name, rawArgs, cwd, signal = null, option
     args = resolved.args;
   }
   if (fileArg && !hasAggregateFileArgs) {
-    const anchor = resolveFileAnchorRoot(name, args, fileArg, baseCwd);
+    const anchor = await resolveFileAnchorRoot(name, args, fileArg, baseCwd);
     if (anchor.error) return anchor.error;
     if (anchor.root) effectiveCwd = anchor.root;
   }

package/src/runtime/agent/orchestrator/tools/patch/apply-patch/codex-batch.mjs

@@ -47,7 +47,7 @@ export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, p
   let v4aRenamePlan = null;
   if (isV4APatchInput(patchStr, requestedFormat)) {
     try {
-      const parsedSections = preParsedV4ASections || rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
+      const parsedSections = preParsedV4ASections || (await rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath));
       const allSections = coalesceCompatibleV4ASections(parsedSections, basePath);
       v4aRenamePlan = await planV4ARenameSections(allSections, basePath);
       inputPatchStr = await convertV4ASectionsToUnifiedPatch(v4aRenamePlan.remainingSections, basePath, v4aConvertOpts);
@@ -56,7 +56,7 @@ export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, p
     }
   } else if (requestedFormat !== 'unified' && hasUnifiedBareV4AHunk(patchStr)) {
     try {
-      const sections = rewriteV4AReadRedirects(parseUnifiedBareV4APatch(patchStr), basePath);
+      const sections = await rewriteV4AReadRedirects(parseUnifiedBareV4APatch(patchStr), basePath);
       inputPatchStr = await convertV4ASectionsToUnifiedPatch(sections, basePath, v4aConvertOpts);
     } catch (err) {
       throw new Error(`apply_patch: bare @@ parse failed — ${err?.message || String(err)}`);
@@ -82,7 +82,7 @@ export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, p
       );
     }
     try {
-      const sections = rewriteV4AReadRedirects(parseUnifiedCountedAsV4APatch(patchStr), basePath);
+      const sections = await rewriteV4AReadRedirects(parseUnifiedCountedAsV4APatch(patchStr), basePath);
       inputPatchStr = await convertV4ASectionsToUnifiedPatch(sections, basePath, v4aConvertOpts);
       parsed = parsePatch(prepareInput(inputPatchStr));
     } catch (fallbackErr) {
@@ -91,7 +91,7 @@ export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, p
       );
     }
   }
-  parsed = rewriteParsedReadRedirects(parsed, basePath);
+  parsed = await rewriteParsedReadRedirects(parsed, basePath);
   if (!Array.isArray(parsed) || parsed.length === 0) {
     return { error: 'Error: patch contained no file sections' };
   }

package/src/runtime/agent/orchestrator/tools/patch/apply-patch/route.mjs

@@ -7,11 +7,11 @@ import { pathKey, resolveV4AEntryPath } from '../paths.mjs';
 import { rewriteV4AReadRedirects } from '../read-redirects.mjs';
 import { isV4ARenameSection } from '../v4a-convert.mjs';
 
-export function selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath }) {
+export async function selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath }) {
   let preParsedV4ASections = null;
   if (isV4APatchInput(patchStr, requestedFormat)) {
     try {
-      preParsedV4ASections = rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
+      preParsedV4ASections = await rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
     } catch {
       // The selected execution path reports the authoritative parse error.
     }

package/src/runtime/agent/orchestrator/tools/patch/orchestrator.mjs

@@ -34,7 +34,7 @@ async function apply_patch(rawArgs, cwd, options = {}) {
   }
   const rejectedV4AHunks = [];
   const v4aConvertOpts = { rejectPartial, rejectedHunks: rejectedV4AHunks, fuzzy, dryRun, readStateScope };
-  const route = selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath });
+  const route = await selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath });
   if (route.useSequence) {
     const seqOut = await applyPatchSequence(patchStr, requestedFormat, basePath, {
       v4aConvertOpts,