mixdog 1.2.5 → 1.3.0

package/src/runtime/agent/orchestrator/tools/builtin/lib/shell-task-output.mjs

@@ -1,11 +1,34 @@
+// Incremental delivery of a shell task's output. Each task (the authorized
+// task object) owns one cursor per stream; every wait, read, background move
+// and completion notice delivers only the bytes after it, in the shared
+// delivery shape (lib/shell-delivery.mjs). The cursor always advances over the
+// whole unseen range, even when its middle is omitted: omitted bytes are never
+// re-sent, the marker's log path is how to get them back.
 import { closeSync, fstatSync, openSync, readSync } from 'node:fs';
 import { stripAnsi } from '../../shell-exec-output.mjs';
 import { FileEncodingSniffer, ShellStreamDecoder, alignedOffset, oemTextEncoding } from '../../shell-codepage.mjs';
+import {
+  DELIVERY_FULL_CHARS,
+  countNewlines,
+  createCarriageReturnFolder,
+  edgesPiece,
+  escapeHarnessTags,
+  fitPieces,
+  formatKb,
+  omissionMarker,
+  persistDeliveryLog,
+  prepareShellText,
+  textPiece,
+} from './shell-delivery.mjs';
 
-import { TOOL_OUTPUT_PAGE_BYTES, TOOL_OUTPUT_TAIL_BYTES } from '../../../../../shared/tool-output-budget.mjs';
 const cursors = new WeakMap();
 const ESC = '\x1b';
 const PENDING_ANSI_INTRODUCER = new RegExp(`${ESC}(?:\\[[0-?]*[ -/]*|\\](?:(?!${ESC}\\\\)[^\x07\x9c])*)?$`);
+// An unseen range up to this size is read whole; a longer one only at its two
+// ends (the middle is counted, never loaded).
+const FULL_READ_BYTES = 64 * 1024;
+const EDGE_READ_BYTES = 16 * 1024;
+const COUNT_CHUNK_BYTES = 1 << 20;
 
 function newCursor() {
   return {
@@ -13,6 +36,7 @@ function newCursor() {
     preview: '',
     decoder: new ShellStreamDecoder(),
     ansi: '',
+    fold: createCarriageReturnFolder(),
     sniffer: new FileEncodingSniffer(),
     committed: false,
   };
@@ -26,13 +50,6 @@ function pendingAnsiIntroducer(sequence) {
   return '\x1b';
 }
 
-// First index at or after `start` that does not sit inside a UTF-8 sequence.
-function utf8Boundary(bytes, start, end) {
-  let index = start;
-  while (index < end && (bytes[index] & 0xc0) === 0x80) index++;
-  return index;
-}
-
 function visibleText(cursor, text) {
   const value = cursor.ansi + text;
   // Retain only the introducer of an unfinished CSI/OSC, not its potentially
@@ -45,21 +62,123 @@ function visibleText(cursor, text) {
   return stripAnsi(value.slice(0, pending.index));
 }
 
+function readBytes(fd, start, length) {
+  const buffer = Buffer.alloc(Math.max(0, length));
+  const count = length > 0 ? readSync(fd, buffer, 0, length, start) : 0;
+  return buffer.subarray(0, count);
+}
+
+function countNewlinesInRange(fd, start, end) {
+  let count = 0;
+  const buffer = Buffer.alloc(Math.min(COUNT_CHUNK_BYTES, Math.max(1, end - start)));
+  for (let position = start; position < end; ) {
+    const bytes = readSync(fd, buffer, 0, Math.min(buffer.length, end - position), position);
+    if (bytes <= 0) break;
+    for (let i = 0; i < bytes; i += 1) if (buffer[i] === 10) count += 1;
+    position += bytes;
+  }
+  return count;
+}
+
+function decodeVisible(cursor, bytes, flush) {
+  let decoded = cursor.decoder.write(bytes);
+  if (flush) decoded += cursor.decoder.end();
+  return prepareShellText(visibleText(cursor, decoded), cursor.fold);
+}
+
+// One unseen file range [start, end) in the delivery shape. A long range is
+// read only at its ends; the tail starts a fresh decoder at a character
+// boundary, as the original paging did when it skipped bytes.
+function readRange(fd, cursor, { start, end, label, flush, path }) {
+  const total = end - start;
+  if (total <= FULL_READ_BYTES) {
+    const text = decodeVisible(cursor, readBytes(fd, start, total), flush);
+    return { piece: textPiece(text, { path }), bytes: total, lines: countNewlines(text), text };
+  }
+  const headText = decodeVisible(cursor, readBytes(fd, start, EDGE_READ_BYTES), false);
+  const tailStart = alignedOffset(fd, end - EDGE_READ_BYTES, label || 'utf-8');
+  cursor.decoder = new ShellStreamDecoder(oemTextEncoding(), label);
+  cursor.ansi = '';
+  cursor.fold = createCarriageReturnFolder();
+  const tailText = decodeVisible(cursor, readBytes(fd, tailStart, end - tailStart), flush);
+  const lines = countNewlinesInRange(fd, start, end);
+  return {
+    piece: edgesPiece(headText, tailText, { totalBytes: total, totalLines: lines, path }),
+    bytes: total,
+    lines,
+    text: tailText,
+  };
+}
+
+const PERCENT_RE = /(\d{1,3}(?:\.\d+)?)\s?%/g;
+const ETA_RE = /\b(?:ETA|eta|remaining|left)\b[:=\s]*(\d+(?::\d{2}){1,2}|\d+(?:\.\d+)?\s?(?:h|m|s|min|sec)\b)/g;
+
+function lastMatch(pattern, text) {
+  let found = null;
+  for (const match of text.matchAll(pattern)) found = match;
+  return found;
+}
+
+/** What changed since the agent last saw the job: growth, last line, any
+ *  visible percent/ETA. Used where a still-running job is reported. */
+function progressDigest(growth) {
+  const bytes = growth.reduce((sum, entry) => sum + entry.bytes, 0);
+  const lines = growth.reduce((sum, entry) => sum + entry.lines, 0);
+  const text = growth
+    .map((entry) => entry.text)
+    .filter(Boolean)
+    .join('\n');
+  const parts = [
+    bytes > 0 ? `+${formatKb(bytes)}, +${lines} lines since you last saw it` : 'no new output since you last saw it',
+  ];
+  const last = text
+    .split('\n')
+    .reverse()
+    .find((line) => line.trim());
+  if (last) parts.push(`last line: ${JSON.stringify(last.trim().slice(0, 200))}`);
+  const percent = lastMatch(PERCENT_RE, text);
+  if (percent && Number(percent[1]) <= 100) parts.push(`${percent[1]}%`);
+  const eta = lastMatch(ETA_RE, text);
+  if (eta) parts.push(`ETA ${eta[1].trim()}`);
+  return `[progress] ${parts.join(' · ')} — still running, not an error`;
+}
+
+/** A whole finished log as a piece of the delivery (a foreground command whose
+ *  capture spilled to disk), read with a fresh cursor. */
+export function shellLogPiece(path) {
+  const cursor = newCursor();
+  let fd;
+  try {
+    fd = openSync(path, 'r');
+    const size = fstatSync(fd).size;
+    const label = cursor.sniffer.probe(fd, size, true);
+    if (label) cursor.decoder.force(label);
+    return readRange(fd, cursor, { start: 0, end: size, label, flush: true, path }).piece;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
 // Cursor ownership follows the authorized task object, not a globally supplied
 // task id. Bounded synchronous reads make concurrent task reads non-overlapping.
 // Only bytes actually read advance the cursor; previews never stand in for a
 // file offset, since a preview may contain an omitted middle.
-// Explicit tail reads never change the incremental cursor. A terminal read
-// prioritizes the final diagnostics; any skipped bytes remain in the raw file.
-export function readShellTaskOutput(task, result = {}, { output = 'new' } = {}) {
+// Explicit tail reads (`output: 'tail'`) never change the incremental cursor.
+// `terminal` flushes the decoders (the producer finished); `digest` prefixes
+// the progress digest for a job reported while still running.
+export function readShellTaskOutput(
+  task,
+  result = {},
+  { output = 'new', terminal = task.status !== 'running', digest = false } = {}
+) {
   const replay = output === 'tail';
-  const terminal = task.status !== 'running';
-  const limit = terminal || replay ? TOOL_OUTPUT_TAIL_BYTES : TOOL_OUTPUT_PAGE_BYTES;
+  const growth = [];
   let streams = replay ? new Map() : cursors.get(task);
   if (!streams) {
     streams = new Map();
     cursors.set(task, streams);
   }
+  // A note, or a stream's body: stdout and stderr share one delivery budget.
   const sections = [];
   for (const stream of ['stdout', 'stderr']) {
     const path = result[`${stream}_path`];
@@ -73,15 +192,15 @@ export function readShellTaskOutput(task, result = {}, { output = 'new' } = {})
     if (!path) {
       const preview = String(result[`${stream}_preview`] || '');
       const delta = preview.startsWith(cursor.preview) ? preview.slice(cursor.preview.length) : preview;
-      const bytes = Buffer.from(delta);
-      const start = utf8Boundary(bytes, Math.max(0, bytes.length - limit), bytes.length);
-      if (start) {
-        sections.push(`[${stream}: ${start} preview bytes omitted; no original log path available]`);
-        cursor.ansi = '';
-      }
-      const text = visibleText(cursor, bytes.subarray(start).toString('utf8'));
+      const text = prepareShellText(visibleText(cursor, delta), cursor.fold);
       cursor.preview = preview;
-      if (text) sections.push(`[${stream}]\n${text}`);
+      growth.push({ bytes: Buffer.byteLength(delta), lines: countNewlines(text), text });
+      // A preview has no log of its own: a capped one is saved for the marker.
+      if (text)
+        sections.push({
+          prefix: `[${stream}]\n`,
+          piece: textPiece(text, { path: () => persistDeliveryLog(text, stream) }),
+        });
       continue;
     }
     let fd;
@@ -102,30 +221,37 @@ export function readShellTaskOutput(task, result = {}, { output = 'new' } = {})
         cursor.decoder.force(label);
       }
       const readEnd = label ? size : cursor.sniffer.safeEnd(size);
-      let start = terminal || replay ? Math.max(cursor.offset, readEnd - limit) : cursor.offset;
-      if (start > cursor.offset) {
-        start = Math.min(readEnd, alignedOffset(fd, start, label || 'utf-8'));
-        sections.push(`[${stream}: ${start - cursor.offset} earlier bytes omitted; read ${path} for the original log]`);
+      let start = cursor.offset;
+      let earlier = '';
+      if (replay && readEnd - start > FULL_READ_BYTES) {
+        // A replay shows the recent part; everything before it is counted.
+        start = Math.min(readEnd, alignedOffset(fd, readEnd - FULL_READ_BYTES, label || 'utf-8'));
+        earlier = omissionMarker({ lines: countNewlinesInRange(fd, 0, start), bytes: start, path });
         cursor.decoder = new ShellStreamDecoder(oemTextEncoding(), label);
-        cursor.ansi = '';
-      }
-      const buffer = Buffer.alloc(Math.min(limit, Math.max(0, readEnd - start)));
-      const count = buffer.length ? readSync(fd, buffer, 0, buffer.length, start) : 0;
-      cursor.offset = start + count;
-      let decoded = cursor.decoder.write(buffer.subarray(0, count));
-      if (terminal && cursor.offset === size) decoded += cursor.decoder.end();
-      const text = visibleText(cursor, decoded);
-      if (text) sections.push(`[${stream}]\n${text}`);
-      if (cursor.offset < size) {
-        sections.push(
-          `[${stream}: ${size - cursor.offset} unread bytes; task read continues, read ${path} for the original log]`
-        );
       }
+      const range = readRange(fd, cursor, { start, end: readEnd, label, flush: terminal && readEnd === size, path });
+      cursor.offset = readEnd;
+      growth.push(range);
+      if (range.piece.natural)
+        sections.push({ prefix: `[${stream}]\n${earlier ? `${earlier}\n` : ''}`, piece: range.piece });
     } catch (error) {
       sections.push(`[${stream} read error: ${error.message}]`);
     } finally {
       if (fd !== undefined) closeSync(fd);
     }
   }
-  return sections.join('\n\n') || (replay ? '(no output)' : '(no new output)');
+  // Notes and prefixes come off the budget; the streams split what is left.
+  const fixed = sections.reduce(
+    (sum, item) => sum + (item.prefix ?? item).length,
+    2 * Math.max(0, sections.length - 1)
+  );
+  const pieces = sections.filter((item) => item.piece);
+  const bodies = fitPieces(
+    pieces.map((item) => item.piece),
+    DELIVERY_FULL_CHARS - fixed
+  );
+  const body =
+    sections.map((item) => (item.piece ? `${item.prefix}${bodies[pieces.indexOf(item)]}` : item)).join('\n\n') ||
+    (replay ? '(no output)' : '(no new output)');
+  return escapeHarnessTags(digest ? `${progressDigest(growth)}\n\n${body}` : body);
 }

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

@@ -6,10 +6,16 @@ import { markScopedCacheIncomplete, markScopedCacheUnsafe } from '../../session/
 import { cacheGet, cacheSet, lstatPathsForMtime } from './cache-layers.mjs';
 import { runScopedSearchInFlight } from './lib/scoped-search-flight.mjs';
 import { NOISE_DIR_NAMES, walkDir } from './glob-walk.mjs';
-import { TOOL_OUTPUT_MAX_BYTES } from './tool-output-limit.mjs';
+import { TOOL_OUTPUT_MAX_BYTES, capMarker } from './tool-output-limit.mjs';
 import { runRgWindowedLines } from './native-search-runner.mjs';
 import { tryServeListMetadata } from './native-search-client.mjs';
-import { countTextFileLines, guardedWalkRoot, normalizeListHeadLimit, pageContinuationLine } from './lib/list-helpers.mjs';
+import {
+  countTextFileLines,
+  guardedWalkRoot,
+  comparePathsStable,
+  normalizeListHeadLimit,
+  pageContinuationLine,
+} from './lib/list-helpers.mjs';
 import { reportToolProgress } from './lib/tool-progress.mjs';
 import { displayRelPath, statWalkRoot } from './list-tool-shared.mjs';
 import { executeFindFilesTool } from './find-files-tool.mjs';
@@ -338,9 +344,9 @@ async function fillRowMetadata(rows, workDir, options) {
 }
 
 function sortListRows(rows, sort) {
-  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));
+  if (sort === 'mtime') rows.sort((a, b) => b.mtimeMs - a.mtimeMs || comparePathsStable(a.path, b.path));
+  else if (sort === 'size') rows.sort((a, b) => b.size - a.size || comparePathsStable(a.path, b.path));
+  else rows.sort((a, b) => a.path.localeCompare(b.path) || comparePathsStable(a.path, b.path));
 }
 
 // What an empty page means: offset past the end is a windowing condition,
@@ -390,15 +396,17 @@ async function scanList(request, cacheKey, workDir, options) {
   if (root.error) return root.error;
   if (!root.stat.isDirectory()) {
     if (!root.stat.isFile()) return `Error: not a directory — ${normalizeOutputPath(fullPath)}`;
-    const out = listFileLine(fullPath, root.stat, meta, meta ? await countTextFileLines(fullPath, root.stat.size) : null);
+    const out = listFileLine(
+      fullPath,
+      root.stat,
+      meta,
+      meta ? await countTextFileLines(fullPath, root.stat.size) : null
+    );
     cacheSet(cacheKey, out, { scopes: [fullPath] });
     return out;
   }
-  const { rows, walkResult, walkWarnings, truncatedByCap, nativeDeep, cacheSafe, nativeMetaMissing } = await collectListRows(
-    request,
-    workDir,
-    options
-  );
+  const { rows, walkResult, walkWarnings, truncatedByCap, nativeDeep, cacheSafe, nativeMetaMissing } =
+    await collectListRows(request, workDir, options);
   const rootFailure = walkRootFailureLine(options, walkResult, walkWarnings, 'list walk');
   if (rootFailure) return rootFailure;
   if (!nativeDeep && needsGlobalStat) await fillRowMetadata(rows, workDir, options);
@@ -439,7 +447,11 @@ async function renderListPage({ request, rows, walkWarnings, truncatedByCap, nat
   if (paged) lines.push(pageContinuationLine(offset, sliced.length, rows.length));
   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`
+      capMarker({
+        limit: `${LIST_ABSOLUTE_CAP} rows or ${LIST_WALK_TIMEOUT_MS}ms`,
+        shown: 'listing incomplete',
+        narrow: 'narrow the path or lower depth',
+      })
     );
   }
   for (const warning of walkWarnings) lines.push(directoryReadFailureLine(warning, true));
@@ -516,7 +528,7 @@ function renderTreeOutput(lines, walkWarnings, { headLimit, offset }) {
     outputCharTruncated = true;
     out =
       out.slice(0, TOOL_OUTPUT_MAX_BYTES) +
-      `\n... [output truncated at ${Math.round(TOOL_OUTPUT_MAX_BYTES / 1024)} KB; narrow path or lower depth]`;
+      `\n${capMarker({ limit: TOOL_OUTPUT_MAX_BYTES, narrow: 'narrow path or lower depth' })}`;
   }
   return { out, outputCharTruncated };
 }

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

@@ -8,7 +8,8 @@
 //
 // MIXDOG_SEARCH_SERVER=0 disables; MIXDOG_SEARCH_SERVER_BIN overrides the
 // executable.
-import { existsSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, realpathSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, resolve as resolvePath, sep } from 'node:path';
 import { bindChildLifecycle, createNativeSearchTransport } from './native-search-transport.mjs';
 import { invalidateBuiltinResultCache } from './cache-layers.mjs';
 import { getPluginData } from '../../config.mjs';
@@ -254,6 +255,32 @@ export async function shutdownNativeSearchServer(reason = 'process-exit', timeou
 
 export { bindChildLifecycle as _bindNativeSearchServerLifecycle };
 
+// Inventories persisted before search roots were canonicalized (see
+// canonicalPath) can hold another spelling of a folder's files under the
+// folder's canonical key; loading one would keep serving every file twice.
+// Drop that snapshot once per data dir, before a server of this process loads
+// it. The marker records that the remaining snapshot was written by servers
+// that only ever saw canonical roots.
+const INVENTORY_SNAPSHOT_FILE = 'file-inventories-v1.bin';
+const CANONICAL_ROOTS_MARKER = 'file-inventories-v1.canonical-roots';
+let _inventorySnapshotChecked = false;
+
+function dropAliasSpelledInventorySnapshot() {
+  if (_inventorySnapshotChecked) return;
+  _inventorySnapshotChecked = true;
+  const dir = join(getPluginData(), 'search-index');
+  const marker = join(dir, CANONICAL_ROOTS_MARKER);
+  if (existsSync(marker)) return;
+  try {
+    rmSync(join(dir, INVENTORY_SNAPSHOT_FILE), { force: true });
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(marker, '');
+  } catch {
+    // A snapshot that cannot be removed now (held open by another server) is
+    // retried by the next process; search itself does not depend on it.
+  }
+}
+
 function _ensureServer() {
   if (_server) return _server;
   if (
@@ -261,6 +288,7 @@ function _ensureServer() {
     Date.now() - _lastFailureAt < RESTART_BACKOFF_MS
   )
     return null;
+  dropAliasSpelledInventorySnapshot();
   let transport;
   try {
     transport = createNativeSearchTransport({
@@ -633,15 +661,93 @@ function consumedDeadline(response, deadlineMs) {
   );
 }
 
+// The server walks a root as the request spells it, but its file-change
+// updates carry the resolved path. Any other spelling of the same folder —
+// letter case on Windows, a junction or symlink, a `..` segment — therefore
+// listed every file twice (one copy per spelling). Roots are resolved once,
+// here, so the first walk, later updates and the inventory key agree.
+function canonicalPath(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
+
+// One positional operand resolved against the canonical cwd. An operand that
+// is already canonical is sent unchanged. An exact file that is itself a
+// symlink keeps its own name: --glob/--type filter the name the caller asked
+// for. `file` tells restoreOperandSpelling how the server prints the operand.
+function canonicalOperand(cwd, operand) {
+  const joined = isAbsolute(operand) ? operand : `${cwd}${sep}${operand}`;
+  let canonical;
+  let file;
+  try {
+    file = statSync(joined).isFile();
+    canonical =
+      file && lstatSync(joined).isSymbolicLink()
+        ? join(realpathSync.native(dirname(joined)), basename(joined))
+        : realpathSync.native(joined);
+  } catch {
+    return null;
+  }
+  if (canonical === (isAbsolute(operand) ? operand : resolvePath(cwd, operand))) return null;
+  // The server prints results with `/` when the operand only uses `/`.
+  const sent = operand.includes('/') && !operand.includes('\\') ? canonical.replaceAll('\\', '/') : canonical;
+  if (sent === operand) return null;
+  // A directory is printed with its trailing separators trimmed.
+  const printed = (path) => (file ? path : path.replace(/[\\/]+$/, ''));
+  return { sent, from: printed(sent), to: printed(operand), file };
+}
+
+// Canonical cwd and operands for a search request, plus the operands whose
+// spelling restoreOperandSpelling puts back into the result lines. Positional
+// operands follow the last `--` (search-builders emits it before them; a `--`
+// pattern is always an `-e` value before it).
+function canonicalSearchRequest(cwd, argsList) {
+  const root = canonicalPath(cwd);
+  const args = argsList.map(String);
+  const remaps = [];
+  const operandsAt = args.lastIndexOf('--') + 1;
+  if (operandsAt > 0) {
+    for (let i = operandsAt; i < args.length; i += 1) {
+      const remap = canonicalOperand(root, args[i]);
+      if (!remap) continue;
+      args[i] = remap.sent;
+      remaps.push(remap);
+    }
+  }
+  remaps.sort((a, b) => b.from.length - a.from.length);
+  return { cwd: root, args, remaps };
+}
+
+// Results under a canonicalized operand are printed by the server as
+// `<operand><sep><relative>` (a directory) or as the operand itself followed
+// by `:`/`-` fields (an exact file); show them under the caller's spelling.
+function restoreOperandSpelling(lines, remaps) {
+  if (remaps.length === 0) return lines;
+  return lines.map((line) => {
+    if (typeof line !== 'string') return line;
+    for (const { from, to, file } of remaps) {
+      if (!line.startsWith(from)) continue;
+      const rest = line.slice(from.length);
+      if (rest !== '' && !(file ? /^[:-]/ : /^[\\/]/).test(rest)) continue;
+      return `${to}${rest}`;
+    }
+    return line;
+  });
+}
+
 /** Returns a runRgWindowedLines-shaped result, or null when the native server
  *  is disabled or the response carries no line list. */
 export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
   if (searchServerDisabled()) return null;
   const deadlineMs = callerDeadlineMs(execOptions, REQUEST_TIMEOUT_MS);
+  const canonical = canonicalSearchRequest(String(execOptions.cwd || process.cwd()), argsList);
   const buildRequest = (server, remaining) => ({
     id: ++server.sequence,
-    cwd: String(execOptions.cwd || process.cwd()),
-    args: argsList.map(String),
+    cwd: canonical.cwd,
+    args: [...canonical.args],
     offset: Math.max(0, Math.floor(Number(opts.offset) || 0)),
     limit: Number.isFinite(Number(opts.limit)) && Number(opts.limit) > 0 ? Math.floor(Number(opts.limit)) : 0,
     deadlineMs: softDeadlineMs(remaining),
@@ -701,7 +807,7 @@ export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
     ? response.walkErrorDetails.map(String).slice(0, 8)
     : [];
   return {
-    lines: response.lines,
+    lines: restoreOperandSpelling(response.lines, canonical.remaps),
     complete: response.complete === true,
     totalSeen: Math.max(0, Math.floor(Number(response.totalSeen) || 0)),
     partial: response.partial === true,
@@ -731,7 +837,8 @@ export async function tryServeFuzzySearch(args, execOptions = {}) {
   const response = await requestNativeWithRestart(
     (server, remaining) => ({
       id: ++server.sequence,
-      cwd: String(args?.cwd || execOptions.cwd || process.cwd()),
+      // Matches are relative to cwd, so only the root needs canonicalizing.
+      cwd: canonicalPath(String(args?.cwd || execOptions.cwd || process.cwd())),
       fuzzy: String(args?.query || ''),
       limit: Math.max(1, Math.min(1_000, Math.floor(Number(args?.limit) || 25))),
       hidden: args?.hidden !== false,
@@ -813,4 +920,5 @@ export function _resetNativeSearchClientForTest() {
   _binaryResolveStarted = false;
   _warmPromise = null;
   _lastTimeoutRecycleAt = 0;
+  _inventorySnapshotChecked = false;
 }

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

@@ -1,4 +1,5 @@
 import { READ_BATCH_RANGE_COALESCE_GAP_LINES } from './read-constants.mjs';
+import { windowMarker } from './tool-output-limit.mjs';
 
 // Slices a `read` body (full mode) to the line window [origOffset+1,
 // origOffset+origLimit] (1-based line numbers in the body). Lines whose
@@ -81,15 +82,15 @@ export function sliceReadBodyByLines(body, origOffset, origLimit, readOffsetBase
   else if (finiteLast) requestedLast = lastLine;
   const emittedStart = keptFirst ?? firstLine;
   const emittedLast = keptLast !== null ? Math.min(requestedLast, keptLast) : requestedLast;
-  const totalPart = haveTotal ? ` of ${totalNum}` : '';
   const moreToRead = haveTotal ? emittedLast < totalNum : finiteLast;
   // Report the next caller coordinate without prescribing another read;
   // whatever remains fits one wider read, not a walk window by window.
-  let continuationPart = '';
-  if (moreToRead && Number.isFinite(emittedLast)) {
-    continuationPart = `; pass offset:${emittedLast + readOffsetBase} to continue`;
-  }
-  const newFooter = `[lines ${emittedStart}-${emittedLast}${totalPart}${continuationPart}]`;
+  const newFooter = windowMarker({
+    from: emittedStart,
+    to: emittedLast,
+    total: haveTotal ? totalNum : null,
+    nextOffset: moreToRead && Number.isFinite(emittedLast) ? emittedLast + readOffsetBase : null,
+  });
   return kept.join('\n') + (kept.length ? '\n' : '') + newFooter;
 }
 

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

@@ -1,6 +1,6 @@
 import { READ_LINE_NO_SEP } from '../../../../shared/read-row-numbers.mjs';
 import { mergeReadRanges } from './read-ranges.mjs';
-import { TOOL_OUTPUT_MAX_BYTES, positiveEnvInt } from './tool-output-limit.mjs';
+import { TOOL_OUTPUT_MAX_BYTES, capMarker, positiveEnvInt } from './tool-output-limit.mjs';
 
 // Smart-truncate cap: a no-window read returns the file until this cap, past
 // which head+tail are shown and the model pages the rest with offset (footer
@@ -18,9 +18,23 @@ const READ_MAX_RENDERED_LINE_CHARS = 2_000;
 // (runtime/shared/read-row-numbers.mjs).
 export const LINE_NO_SEP = READ_LINE_NO_SEP;
 
-export function buildSmartReadTruncationMarker(totalLines, fileBytes) {
+// Cap marker for the elided middle of a no-window read. With the omitted
+// line span it names the continuation offset; without, narrowing advice.
+export function buildSmartReadTruncationMarker(totalLines, fileBytes, omitted = null) {
   const kb = Math.max(1, Math.round((Number(fileBytes) || 0) / 1024));
-  return `... [TRUNCATED - ${totalLines} lines / ${kb} KB; read located windows with {file_path, offset, limit}] ...`;
+  const limit = fileBytes > SMART_READ_MAX_BYTES ? SMART_READ_MAX_BYTES : `${SMART_READ_MAX_LINES} lines`;
+  if (!omitted) {
+    return capMarker({
+      limit,
+      shown: `${totalLines} lines / ${kb} KB`,
+      narrow: 'read located windows with {file_path, offset, limit}',
+    });
+  }
+  return capMarker({
+    limit,
+    shown: `lines ${omitted.from}-${omitted.to} of ${totalLines} omitted (${kb} KB file)`,
+    nextOffset: omitted.from,
+  });
 }
 
 function rangeFromRenderedReadRows(rows, fallbackStartLine = 1) {
@@ -56,9 +70,10 @@ export function smartReadTruncate(renderedWithLineNos, totalLines, fileBytes) {
   const tailRows = rows.slice(tailStart);
   const head = headRows.join('\n');
   const tail = tailRows.join('\n');
-  const marker = buildSmartReadTruncationMarker(totalLines, fileBytes);
+  const marker = buildSmartReadTruncationMarker(totalLines, fileBytes, { from: headCount + 1, to: tailStart });
   return {
     text: `${head}\n${marker}\n${tail}`,
+    marker,
     truncated: true,
     totalLines,
     ranges: mergeReadRanges(

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

@@ -5,6 +5,7 @@
 import { READ_MAX_LINE_COLLECT_BYTES } from './read-constants.mjs';
 import { renderReadLine } from './read-formatting.mjs';
 import { maybeRecordReadRangeAnchor } from './read-range-index.mjs';
+import { capMarker, windowMarker } from './tool-output-limit.mjs';
 
 export function createReadLineCollector({ offset, limit, bodyOutputBytes, rangeIndex, startLine, fileSize = 0 }) {
   const collected = [];
@@ -148,10 +149,11 @@ export function createReadLineCollector({ offset, limit, bodyOutputBytes, rangeI
       let out = collected.join('\n');
       if (truncated) {
         const nextOffset = (lastEmitted || offset) + readOffsetBase;
-        const ofFile = fileSize > 0 ? ` of a ${Math.max(1, Math.round(fileSize / 1024))} KB file` : '';
-        out += `\n\n... [output truncated at ${Math.max(1, Math.round(maxOutputBytes / 1024))} KB${ofFile}; pass offset:${nextOffset} to continue] ...`;
+        const ofFile = fileSize > 0 ? `${Math.max(1, Math.round(fileSize / 1024))} KB file` : '';
+        out += `\n\n${capMarker({ limit: maxOutputBytes, shown: ofFile, nextOffset })}`;
       } else if (stoppedAtLimit) {
-        out += `${out ? '\n' : ''}... [range limit reached; next offset: ${offset + collected.length + readOffsetBase}]`;
+        const nextOffset = offset + collected.length + readOffsetBase;
+        out += `${out ? '\n' : ''}${windowMarker({ from: offset + 1, to: offset + collected.length, nextOffset })}`;
       } else if (!out && offset >= lineIdx) {
         out = `(no lines in range; file has ${lineIdx} lines)`;
       }