mixdog 1.2.5 → 1.2.6

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)`;
       }

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

@@ -9,6 +9,7 @@ import { readFile } from 'node:fs/promises';
 import { sameFileVersion } from './file-version.mjs';
 import { canCacheReadFile, READ_PREFIX_HASH_BYTES } from './read-cache-policy.mjs';
 import { decodeUtf16Body, isUtf16Encoding } from './snapshot-helpers.mjs';
+import { capMarker, windowMarker } from './tool-output-limit.mjs';
 
 /**
  * Encoding-aware decode (fresh read AND raw-content cache hit both flow
@@ -51,17 +52,27 @@ function rangeFooter(ctx, render, rendered) {
   const emittedStart = offset + 1;
   if (byteCapTruncated) {
     const emittedEnd = offset + renderedLineCount;
-    const capKb = Math.round(readMaxOutputBytes / 1024);
-    const more = emittedEnd < lineCount ? `; pass offset:${emittedEnd + readOffsetBase} to continue` : '';
-    return { footer: `[lines ${emittedStart}-${emittedEnd} of ${lineCount}; output truncated at ${capKb} KB${more}]` };
+    return {
+      footer: windowMarker({
+        from: emittedStart,
+        to: emittedEnd,
+        total: lineCount,
+        capBytes: readMaxOutputBytes,
+        nextOffset: emittedEnd < lineCount ? emittedEnd + readOffsetBase : null,
+      }),
+    };
   }
   if (Buffer.byteLength(rendered, 'utf8') > readMaxOutputBytes) return {};
   const emittedEnd = offset + sliced.length;
   // Continuation uses the originating caller's coordinate base. Remaining
   // content is not automatically required evidence; when it is, it fits one
   // wider read, not a walk window by window.
-  const more = emittedEnd < lineCount ? `; pass offset:${emittedEnd + readOffsetBase} to continue` : '';
-  const footer = `[lines ${emittedStart}-${emittedEnd} of ${lineCount}${more}]`;
+  const footer = windowMarker({
+    from: emittedStart,
+    to: emittedEnd,
+    total: lineCount,
+    nextOffset: emittedEnd < lineCount ? emittedEnd + readOffsetBase : null,
+  });
   return { footer: widenNote ? `${footer}\n${widenNote}` : footer };
 }
 
@@ -110,8 +121,15 @@ function renderReadWindow(content, ctx, helpers) {
     const slice = byteCapSlice(rendered, readMaxOutputBytes);
     render.renderedLineCount = Math.max(0, slice.split('\n').length - 1);
     render.byteCapTruncated = true;
-    const ofFile = st?.size > 0 ? ` of a ${Math.max(1, Math.round(st.size / 1024))} KB file` : '';
-    out = `${slice}\n\n... [output truncated at ${Math.round(readMaxOutputBytes / 1024)} KB${ofFile}] ...`;
+    const ofFile = st?.size > 0 ? `${Math.max(1, Math.round(st.size / 1024))} KB file` : '';
+    // A windowed read's footer already carries the cap and continuation.
+    out = hasRangeArgs
+      ? slice
+      : `${slice}\n\n${capMarker({
+          limit: readMaxOutputBytes,
+          shown: ofFile ? `${render.renderedLineCount} of ${lineCount} lines shown (${ofFile})` : '',
+          nextOffset: offset + render.renderedLineCount + ctx.readOffsetBase,
+        })}`;
   } else {
     out = rendered;
   }

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

@@ -1,6 +1,7 @@
 import { readFile, stat } from 'node:fs/promises';
 import { MAX_PDF_BYTES, MAX_PDF_PAGES, isPdfBuffer } from '../../../../attachments/limits.mjs';
 import { READ_MAX_SIZE_BYTES } from './read-constants.mjs';
+import { capMarker } from './tool-output-limit.mjs';
 import { imageBlocksFromBuffer } from './read-image-resize.mjs';
 import { inspectPdfBuffer } from '../../../../attachments/pdf-extract.mjs';
 
@@ -190,7 +191,7 @@ function capNotebookText(blocks, maxOutputBytes) {
   if (truncated) {
     capped.push({
       type: 'text',
-      text: `\n\n... [notebook output truncated at ${Math.round(maxOutputBytes / 1024)} KB]`,
+      text: `\n\n${capMarker({ limit: maxOutputBytes, shown: 'notebook cells cut', narrow: 'grep the notebook for the cell text you need' })}`,
     });
   }
   return capped;

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

@@ -27,7 +27,9 @@ const bodyTextFor = (value) => {
     .join('\n');
 };
 
-const TRUNCATED_MARKER = /\[TRUNCATED (?:—|-) (\d+) lines \/ (\d+) KB;/;
+// The smart-read cap marker (read-formatting.mjs buildSmartReadTruncationMarker):
+// `[output capped at X; lines a-b of N omitted (K KB file); offset:a for more]`.
+const TRUNCATED_MARKER = /\[output capped at [^;\]]+; lines \d+-\d+ of (\d+) omitted \((\d+) KB file\);/;
 // When `read` emitted a smart-cap marker, surface the truncation state in the
 // header so downstream skimming spots it without parsing the body.
 const truncatedSuffix = (textBody) => {

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

@@ -1,4 +1,5 @@
 import { statSync } from 'node:fs';
+import { capMarker, windowMarker } from './tool-output-limit.mjs';
 import { isAbsolute, resolve } from 'node:path';
 import { expandAbsoluteGlobs } from './lib/absolute-glob-expand.mjs';
 import { buildGlobPatternGroups } from './lib/glob-static-prefix.mjs';
@@ -407,17 +408,22 @@ async function orderGlobPaths(unique, { nativeMtimeTotal, groupCount, sortMode,
 
 function globIntegritySuffix({ accumTruncated, rgStdoutTruncated, rgStdoutPartial, rgErrors }) {
   let truncSuffix = '';
-  if (accumTruncated) truncSuffix = `\n... [truncated at accumulation cap (${GLOB_ACCUM_CAP})]`;
-  if (rgStdoutTruncated) truncSuffix += '\n... [truncated at rg stdout cap (20MB); results incomplete]';
+  const narrow = 'narrow the pattern or path';
+  if (accumTruncated) {
+    truncSuffix = `\n${capMarker({ limit: `${GLOB_ACCUM_CAP} matches`, shown: 'results incomplete', narrow })}`;
+  }
+  if (rgStdoutTruncated) {
+    truncSuffix += `\n${capMarker({ limit: '20 MB of rg stdout', shown: 'results incomplete', narrow })}`;
+  }
   if (rgStdoutPartial) truncSuffix += '\n... [warning] rg exit 2 (partial results); listing may be incomplete';
   const errorSuffix = rgErrors.length > 0 ? `\n... [warning] ${rgErrors.join(' | ')}` : '';
   return errorSuffix + truncSuffix;
 }
 
-function globMoreSuffix({ rgWindowIncomplete, remaining, totalBeforeOffset, nextOffset }) {
-  if (rgWindowIncomplete) return `\n... [more entries available — pass offset:${nextOffset} to continue]`;
+function globMoreSuffix({ rgWindowIncomplete, remaining, totalBeforeOffset, from, nextOffset }) {
+  if (rgWindowIncomplete) return `\n${windowMarker({ unit: 'entries', from, to: nextOffset, nextOffset })}`;
   if (remaining > 0) {
-    return `\n... [${remaining} more entries of ${totalBeforeOffset} total — pass offset:${nextOffset} to continue]`;
+    return `\n${windowMarker({ unit: 'entries', from, to: nextOffset, total: totalBeforeOffset, nextOffset })}`;
   }
   return '';
 }
@@ -489,6 +495,7 @@ async function renderGlobPage(scan, merged, { capped, remaining, totalBeforeOffs
     rgWindowIncomplete: merged.rgWindowIncomplete,
     remaining,
     totalBeforeOffset,
+    from: offset + 1,
     nextOffset: offset + capped.length,
   });
   if (capped.length > 0) return `${capped.join('\n')}${moreSuffix}${errSuffix}`;

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

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { isAbsolute } from 'node:path';
+import { isAbsolute, resolve as resolvePath, sep as pathSep } from 'node:path';
 import {
   coerceReadFamilyPathArg,
   GREP_AUTO_CONTEXT_LINES,
@@ -12,6 +12,7 @@ import {
   appendNotFoundCwdNote,
   buildNotFoundHintBody,
   finalizeReadFamilyEnoentTail,
+  realRootOf,
 } from './search-path-diagnostics.mjs';
 import { buildGrepCacheKey, buildGrepRgArgs } from './search-builders.mjs';
 import { runRg, runRgWindowedLines } from './native-search-runner.mjs';
@@ -498,10 +499,7 @@ async function runLegacyContextGrep(scope, rgArgs) {
 async function runPlainGrep(scope, rgArgs, effectiveHeadLimit) {
   const { options, outputMode, headLimit, offset, cacheKey, grepResolvedPath } = scope;
   const window = await collectGrepWindow(scope, rgArgs, effectiveHeadLimit);
-  let { windowed } = window;
-  if (outputMode === 'files_with_matches' && windowed.length > 1) {
-    windowed = await sortNewestFirst(windowed, scope.rgSpawnCwd);
-  }
+  const { windowed } = window;
   let body = formatGrepOutput({
     windowed,
     totalWindowed: window.totalWindowed,
@@ -542,7 +540,12 @@ async function runPlainGrep(scope, rgArgs, effectiveHeadLimit) {
 // complete.
 async function collectGrepWindow(scope, rgArgs, effectiveHeadLimit) {
   const { outputMode, offset, searchExecOptions } = scope;
-  if (effectiveHeadLimit !== Infinity) {
+  // The native scan emits content matches in inventory path order (stable, so
+  // the streamed content window pages directly). File lists are presented
+  // newest-first, so they are pageable only once the WHOLE set is re-ordered;
+  // `offset` slices after the sort.
+  const fileList = outputMode === 'files_with_matches' || outputMode === 'count';
+  if (effectiveHeadLimit !== Infinity && !fileList) {
     const streamed = await runRgWindowedLines(rgArgs, searchExecOptions, {
       offset,
       limit: effectiveHeadLimit,
@@ -556,7 +559,8 @@ async function collectGrepWindow(scope, rgArgs, effectiveHeadLimit) {
     };
   }
   const stdout = await runRg(rgArgs, searchExecOptions);
-  const allLines = String(stdout).split('\n').filter(Boolean);
+  let allLines = String(stdout).split('\n').filter(Boolean);
+  if (fileList) allLines = await orderFileListLines(unifyRootSpelling(allLines, scope), outputMode, scope.rgSpawnCwd);
   const windowed = offset > 0 ? allLines.slice(offset) : allLines;
   const boxed = typeof stdout === 'object' ? stdout : {};
   return {
@@ -568,25 +572,60 @@ async function collectGrepWindow(scope, rgArgs, effectiveHeadLimit) {
   };
 }
 
-// files_with_matches: newest-first (mtime desc, path tiebreak) so recently
-// edited files surface first. Statting is bounded (64 workers, 5s
-// deadline); stat-failed entries keep rg traversal order after the statted
-// ones. Sort covers the shown window — with the default head limit the
-// common case is the complete result set.
-async function sortNewestFirst(windowed, rgSpawnCwd) {
-  const withStat = await statPathsForMtime(windowed, rgSpawnCwd, 64, { deadlineMs: 5000 });
+// A search root reached through a symlink or junction (macOS /var ->
+// /private/var) can come back from the walker under either spelling: rows that
+// the inventory repaired after a filesystem event carry the realpath while the
+// rest carry the given root. Left alone they sort apart, page twice and print
+// as absolute paths. Rewrite realpath rows to the given spelling, then drop the
+// repeats, so ordering, offset paging and relativization see one spelling.
+function unifyRootSpelling(lines, scope) {
+  const given = scope.searchPath;
+  const absGiven = resolvePath(scope.rgSpawnCwd, given);
+  const real = realRootOf(absGiven);
+  if (real === absGiven) return lines;
+  const fold = (text) => (process.platform === 'win32' ? text.toLocaleLowerCase() : text);
+  const realPrefix = fold(`${real.replace(/\\/g, '/').replace(/\/+$/, '')}/`);
+  const sep = given.includes('/') && !given.includes('\\') ? '/' : pathSep;
+  const givenPrefix = `${given.replace(/[\\/]+$/, '')}${sep}`;
+  const seen = new Set();
+  const unified = [];
+  for (const line of lines) {
+    const fwd = line.replace(/\\/g, '/');
+    const row = fold(fwd).startsWith(realPrefix)
+      ? givenPrefix + fwd.slice(realPrefix.length).replace(/\//g, sep)
+      : line;
+    if (seen.has(row)) continue;
+    seen.add(row);
+    unified.push(row);
+  }
+  return unified;
+}
+
+function compareCodeUnits(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+
+// Total order over the complete file list, applied BEFORE offset/limit slice:
+// files_with_matches is newest-first (mtime desc, path tiebreak) so recently
+// edited files surface first; stat-failed entries follow in path order
+// (statting is bounded: 64 workers, 5s deadline). count lines sort by path.
+async function orderFileListLines(lines, outputMode, rgSpawnCwd) {
+  if (lines.length < 2) return lines;
+  if (outputMode === 'count') {
+    const pathOf = (line) => parseGrepCountLine(line)?.path ?? line;
+    return [...lines].sort((a, b) => compareCodeUnits(pathOf(a), pathOf(b)) || compareCodeUnits(a, b));
+  }
+  const withStat = await statPathsForMtime(lines, rgSpawnCwd, 64, { deadlineMs: 5000 });
   const statted = [];
   const unstatted = [];
-  for (let i = 0; i < windowed.length; i++) {
+  for (let i = 0; i < lines.length; i++) {
     const entry = withStat[i];
-    if (entry?.stat) statted.push({ line: windowed[i], mtimeMs: entry.mtimeMs });
-    else unstatted.push(windowed[i]);
+    if (entry?.stat) statted.push({ line: lines[i], mtimeMs: entry.mtimeMs });
+    else unstatted.push(lines[i]);
   }
-  statted.sort((a, b) => {
-    const dm = b.mtimeMs - a.mtimeMs;
-    if (dm !== 0) return dm;
-    return a.line.localeCompare(b.line);
-  });
+  statted.sort((a, b) => b.mtimeMs - a.mtimeMs || compareCodeUnits(a.line, b.line));
+  unstatted.sort(compareCodeUnits);
   return [...statted.map((e) => e.line), ...unstatted];
 }
 

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

@@ -3,7 +3,7 @@
  * grep/glob in search-tool.mjs. search-tool.mjs re-exports these for unchanged
  * importers so it can stay a thin executor.
  */
-import { statSync } from 'node:fs';
+import { realpathSync, statSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { findDirectoryByBasename, findFileByBasename, listSiblings } from './path-diagnostics.mjs';
 import { normalizeOutputPath, resolveAgainstCwd } from './path-utils.mjs';
@@ -233,16 +233,40 @@ export async function buildNotFoundHintBody(workDir, missingPath, actionVerb, er
   return elsewhere.exhaustive === true ? ENOENT_ABSENT : '';
 }
 
+// The realpath of a working directory, memoized: a search root reached through
+// a symlink or junction (macOS /var -> /private/var) is reported by the walker
+// under its realpath, so results must be relativized against both spellings.
+const realRootCache = new Map();
+const REAL_ROOT_CACHE_MAX = 64;
+export function realRootOf(root) {
+  if (realRootCache.has(root)) return realRootCache.get(root);
+  let real;
+  try {
+    real = realpathSync.native(root);
+  } catch {
+    return root;
+  }
+  if (realRootCache.size >= REAL_ROOT_CACHE_MAX) realRootCache.clear();
+  realRootCache.set(root, real);
+  return real;
+}
+
+function relativeUnderRoot(absFwd, root) {
+  const rootFwd = root.replace(/\\/g, '/').replace(/\/+$/, '');
+  const haystack = process.platform === 'win32' ? absFwd.toLocaleLowerCase() : absFwd;
+  const needle = process.platform === 'win32' ? rootFwd.toLocaleLowerCase() : rootFwd;
+  if (haystack.startsWith(`${needle}/`) || haystack === needle) return absFwd.slice(rootFwd.length + 1) || '.';
+  return null;
+}
+
 export function relativePathPrefix(pathPrefix, workDir) {
   if (!workDir) return pathPrefix;
-  const cwdFwd = workDir.replace(/\\/g, '/').replace(/\/+$/, '');
   const absFwd = String(pathPrefix || '').replace(/\\/g, '/');
-  const haystack = process.platform === 'win32' ? absFwd.toLocaleLowerCase() : absFwd;
-  const needle = process.platform === 'win32' ? cwdFwd.toLocaleLowerCase() : cwdFwd;
-  if (haystack.startsWith(`${needle}/`) || haystack === needle) {
-    return absFwd.slice(cwdFwd.length + 1) || '.';
-  }
-  return pathPrefix;
+  const given = relativeUnderRoot(absFwd, workDir);
+  if (given !== null) return given;
+  const real = realRootOf(workDir);
+  if (real === workDir) return pathPrefix;
+  return relativeUnderRoot(absFwd, real) ?? pathPrefix;
 }
 
 export function relativeSearchResultPath(path, workDir) {