mixdog 0.9.93 → 0.9.95

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

@@ -5,9 +5,11 @@
 import { normalizeOutputPath } from '../path-utils.mjs';
 import {
     groupGrepContentByFile,
+    parseGrepContextHeader,
     splitGrepLineNumberOnlyPrefix,
     splitGrepLinePrefix,
 } from '../grep-formatting.mjs';
+import { relativePathPrefix } from '../search-path-diagnostics.mjs';
 import { relativeGrepLine } from './search-input-helpers.mjs';
 
 export function grepMissingPatternMessage() {
@@ -22,30 +24,84 @@ export function globMissingPatternMessage() {
 // In context mode (explicit -A/-B/-C or content_with_context auto), head_limit
 // and offset count MATCH BLOCKS, not raw output lines, and truncation keeps a
 // head+tail slice with a middle marker instead of dropping the tail.
-function grepBlockMatchAnchor(line, filenameOmitted) {
+function grepContextSourceLine(line, filenameOmitted, fallbackPath = '') {
     if (filenameOmitted) {
         const p = splitGrepLineNumberOnlyPrefix(line);
-        return p && p.delimiter === ':' ? `#${p.lineNo}` : '';
+        return p ? {
+            path: fallbackPath,
+            lineNo: p.lineNo,
+            delimiter: p.delimiter,
+            content: String(line).slice(p.markerEnd),
+        } : null;
     }
     const s = splitGrepLinePrefix(line);
-    return s && s.delimiter === ':' ? `${s.path}\0${s.lineNo}` : '';
+    return s ? {
+        path: s.path,
+        lineNo: s.lineNo,
+        delimiter: s.delimiter,
+        content: String(line).slice(s.markerEnd),
+    } : null;
 }
 
-function parseGrepContextBlocks(lines, filenameOmitted) {
+function grepBlockMatchAnchor(line, filenameOmitted, fallbackPath) {
+    const parsed = grepContextSourceLine(line, filenameOmitted, fallbackPath);
+    return parsed && parsed.delimiter === ':' ? `${parsed.path}\0${parsed.lineNo}` : '';
+}
+
+function parseRenderableGrepContextBlock(block, filenameOmitted, fallbackPath) {
+    const parsed = block.lines.map((line) => grepContextSourceLine(line, filenameOmitted, fallbackPath));
+    const contiguous = parsed.length > 0
+        && parsed.every((entry, index) => entry
+            && entry.path
+            && entry.path === parsed[0].path
+            && (index === 0 || entry.lineNo === parsed[index - 1].lineNo + 1));
+    const match = contiguous ? parsed.find((entry) => entry.delimiter === ':') : null;
+    if (!match) return { raw: block.lines.join('\n') };
+    return {
+        path: match.path,
+        matchLine: match.lineNo,
+        startLine: parsed[0].lineNo,
+        endLine: parsed.at(-1).lineNo,
+        contents: parsed.map((entry) => entry.content),
+    };
+}
+
+function renderGrepContextBlocks(blocks, filenameOmitted, fallbackPath) {
+    const merged = [];
+    for (const block of blocks) {
+        const current = parseRenderableGrepContextBlock(block, filenameOmitted, fallbackPath);
+        const previous = merged.at(-1);
+        if (previous?.path
+            && current.path === previous.path
+            && current.startLine <= previous.endLine + 1) {
+            const overlap = Math.max(0, previous.endLine - current.startLine + 1);
+            previous.contents.push(...current.contents.slice(overlap));
+            previous.endLine = Math.max(previous.endLine, current.endLine);
+            continue;
+        }
+        merged.push(current);
+    }
+    return merged.map((block) => {
+        if (!block.path) return block.raw;
+        return `# ${block.path}:${block.matchLine} [lines ${block.startLine}-${block.endLine}]\n${block.contents.join('\n')}`;
+    });
+}
+
+function parseGrepContextBlocks(lines, filenameOmitted, fallbackPath) {
     const blocks = [];
     let pending = [];
     let i = 0;
     while (i < lines.length) {
         const line = lines[i];
         if (line === '--') { pending = []; i++; continue; }
-        const anchor = grepBlockMatchAnchor(line, filenameOmitted);
+        const anchor = grepBlockMatchAnchor(line, filenameOmitted, fallbackPath);
         if (anchor) {
             const blockLines = pending.concat([line]);
             pending = [];
             i++;
             while (i < lines.length) {
                 const next = lines[i];
-                if (next === '--' || grepBlockMatchAnchor(next, filenameOmitted)) break;
+                if (next === '--' || grepBlockMatchAnchor(next, filenameOmitted, fallbackPath)) break;
                 blockLines.push(next);
                 i++;
             }
@@ -58,9 +114,12 @@ function parseGrepContextBlocks(lines, filenameOmitted) {
     return blocks;
 }
 
-export function formatGrepContextOutput({ allLines, workDir, outputMode, filenameOmitted, headLimit, offset, totalKnown = true }) {
+export function formatGrepContextOutput({ allLines, workDir, outputMode, filenameOmitted, headLimit, offset, searchPath, totalKnown = true }) {
     const norm = allLines.map((l) => (l === '--' ? '--' : relativeGrepLine(l, workDir, false, outputMode, filenameOmitted)));
-    const blocks = parseGrepContextBlocks(norm, filenameOmitted);
+    const fallbackPath = filenameOmitted
+        ? relativePathPrefix(normalizeOutputPath(searchPath), workDir)
+        : '';
+    const blocks = parseGrepContextBlocks(norm, filenameOmitted, fallbackPath);
     const total = blocks.length;
     if (total === 0) return { text: '', total: 0, shown: 0, omitted: 0 };
     // Finding 2/3: denominator is the PRE-offset grand total; on a partial rg
@@ -78,7 +137,7 @@ export function formatGrepContextOutput({ allLines, workDir, outputMode, filenam
     }
     const shown = headLimit === Infinity ? afterOffset.length : Math.min(headLimit, afterOffset.length);
     const omitted = afterOffset.length - shown;
-    const render = (arr) => arr.map((b) => b.lines.join('\n'));
+    const render = (arr) => renderGrepContextBlocks(arr, filenameOmitted, fallbackPath);
     let segments;
     let nextOffset = offset + shown;
     if (omitted > 0 && shown > 0) {
@@ -99,16 +158,35 @@ export function formatGrepContextOutput({ allLines, workDir, outputMode, filenam
     const notice = (omitted > 0 || !totalKnown)
         ? `\n[Showing ${shown} of ${totalStr} matches${totalKnown ? '' : ' (results partial)'}; pass offset:${nextOffset} for more]`
         : '';
-    return { text: segments.join('\n--\n') + notice, total, shown, omitted };
+    return {
+        text: `${segments.join('\n')}${notice}`,
+        total,
+        shown,
+        omitted,
+    };
 }
 
-// Part 1: drop path:line match lines already emitted by an earlier pattern in
-// a pattern[] fan-out. Context ('-') lines and non-match lines pass through.
+// Part 1: drop a numbered match line or patch-ready context block already
+// emitted by an earlier pattern in a pattern[] fan-out.
 export function dedupeFanoutMatchLines(body, seen) {
     const text = String(body);
     if (/^Error:/.test(text)) return text;
     const out = [];
-    for (const line of text.split('\n')) {
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const header = parseGrepContextHeader(line);
+        if (header) {
+            const key = `${header.path}\0${header.matchLine}`;
+            const duplicate = seen.has(key);
+            seen.add(key);
+            if (!duplicate) out.push(line);
+            for (let sourceIndex = 0; sourceIndex < header.sourceLineCount && i + 1 < lines.length; sourceIndex++) {
+                i++;
+                if (!duplicate) out.push(lines[i]);
+            }
+            continue;
+        }
         const s = splitGrepLinePrefix(line);
         if (s && s.delimiter === ':') {
             const key = `${s.path}\0${s.lineNo}`;

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

@@ -20,7 +20,6 @@ import {
     getCachedReadOnlyStat,
     statCacheSet,
     statPathsForMtime,
-    lstatPathsForMtime,
     registerCacheInvalidationListener,
 } from './cache-layers.mjs';
 import {
@@ -28,8 +27,11 @@ import {
     NOISE_DIR_NAMES,
     walkDir,
 } from './glob-walk.mjs';
-import { formatMtime, formatListSize } from './list-formatting.mjs';
-import { TOOL_OUTPUT_MAX_BYTES } from './tool-output-limit.mjs';
+import {
+    capLineOrientedToolOutput,
+    LOCATOR_OUTPUT_MAX_BYTES,
+    TOOL_OUTPUT_MAX_BYTES,
+} from './tool-output-limit.mjs';
 import { runRg } from './rg-runner.mjs';
 import { hasSpareCapacity as childSpawnHasSpareCapacity } from '../../../../shared/child-spawn-gate.mjs';
 import { fuzzyRank } from './fuzzy-match.mjs';
@@ -52,6 +54,36 @@ function _findDefaultHeadLimit(fallback) {
     return parsed > 0 ? parsed : fallback;
 }
 
+function _findOutputBudgetBytes(options = {}) {
+    const requested = Number(options?.__findOutputBudgetBytes);
+    const explicit = Number(options?.toolOutputMaxBytes);
+    return Math.max(1, Math.min(
+        LOCATOR_OUTPUT_MAX_BYTES,
+        Number.isFinite(requested) && requested > 0 ? Math.trunc(requested) : LOCATOR_OUTPUT_MAX_BYTES,
+        Number.isFinite(explicit) && explicit > 0 ? Math.trunc(explicit) : LOCATOR_OUTPUT_MAX_BYTES,
+    ));
+}
+
+function _splitFindBudget(total, count, index) {
+    if (!(count > 0)) return 0;
+    const base = Math.floor(total / count);
+    return base + (index < (total % count) ? 1 : 0);
+}
+
+// Entry paths render relative to the listed root — the caller supplied the
+// base via `path`, so repeating the absolute prefix on every row is pure
+// duplication (~2KB per 80 rows). Falls back to the absolute form when the
+// entry escapes the root (drive change / `..`), where a relative form would
+// be ambiguous. Cache-safe: keys already include the absolute root, and the
+// rendered rows no longer depend on the session workDir.
+function displayRelPath(entPath, rootPath) {
+    const rel = relative(rootPath, entPath);
+    if (!rel || rel === '.' || rel.startsWith('..') || /^[A-Za-z]:/.test(rel)) {
+        return normalizeOutputPath(entPath);
+    }
+    return normalizeOutputPath(rel);
+}
+
 export async function executeListTool(args, workDir, options = {}) {
     args.path = coerceReadFamilyPathArg(args.path, workDir);
     if (Array.isArray(args.path)) {
@@ -209,20 +241,10 @@ export async function executeListTool(args, workDir, options = {}) {
 
     const windowed = offset > 0 ? rows.slice(offset) : rows;
     const sliced = headLimit > 0 ? windowed.slice(0, headLimit) : windowed;
-    if (!needsGlobalStat && sliced.length > 0) {
-        // Use lstat so a symlink reports its own size/mtime instead of
-        // the target's. The walker already typed symlinks from Dirent;
-        // following the link here would lie about the listed entry.
-        const stats = await lstatPathsForMtime(sliced.map((row) => row.fullPath), workDir, 64, { deadlineMs: 5000 });
-        for (let i = 0; i < sliced.length; i++) {
-            const item = stats[i];
-            if (!item?.stat) continue;
-            sliced[i].size = item.size;
-            sliced[i].mtimeMs = item.mtimeMs;
-        }
-    }
-    const lines = sliced.map(r =>
-        `${normalizeOutputPath(r.path)}\t${r.type}\t${formatListSize(r.type, r.size)}\t${formatMtime(r.mtimeMs)}`);
+    // Paths and entry types are the list contract. Size/mtime columns were
+    // neither exposed in the model schema nor used by routing, yet consumed
+    // roughly 28–40% of live list output and forced a stat per visible entry.
+    const lines = sliced.map(r => `${displayRelPath(r.path, fullPath)}\t${r.type}`);
     if (windowed.length > sliced.length) lines.push(`... [entries ${offset + 1}-${offset + sliced.length} of ${rows.length}; pass offset:${offset + sliced.length} to continue]`);
     if (truncatedByCap) lines.push(`... walk truncated at ${LIST_ABSOLUTE_CAP} rows or ${LIST_WALK_TIMEOUT_MS}ms timeout; narrow the path or lower depth for a complete listing`);
     let emptyMsg = '(empty directory)';
@@ -563,24 +585,60 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
         const capped = list.length > 5;
         const targets = capped ? list.slice(0, 5) : list;
         if (targets.length > 1) {
+            // head_limit is one call-level result budget, not a multiplier per
+            // query. Split it deterministically in caller order; if it cannot
+            // fund one result per query, return the remaining queries exactly.
+            const totalHeadLimit = normalizeListHeadLimit(args.head_limit, _findDefaultHeadLimit(25));
+            const activeCount = totalHeadLimit > 0
+                ? Math.min(targets.length, totalHeadLimit)
+                : targets.length;
+            const activeTargets = targets.slice(0, activeCount);
+            const omittedByHeadLimit = targets.slice(activeCount);
+            const notes = [];
+            if (omittedByHeadLimit.length) {
+                notes.push(
+                    `... [head_limit ${totalHeadLimit} exhausted across query[]; `
+                    + `retry query=${JSON.stringify(omittedByHeadLimit)}]`,
+                );
+            }
+            if (capped) notes.push(`... [capped at 5 of ${list.length} queries]`);
+            const sectionHeaders = activeTargets.map((query) => `# find ${query}\n`);
+            const separatorBytes = Math.max(0, activeTargets.length + notes.length - 1) * 2;
+            const fixedBytes = sectionHeaders.reduce(
+                (sum, header) => sum + Buffer.byteLength(header, 'utf8'),
+                separatorBytes + notes.reduce((sum, note) => sum + Buffer.byteLength(note, 'utf8'), 0),
+            );
+            const bodyBudget = Math.max(activeTargets.length, _findOutputBudgetBytes(options) - fixedBytes);
             // 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.
+            // while each query receives a fair share of the call-level count and
+            // byte budgets before any aggregate result is assembled.
             const batchContext = {
-                queries: targets,
+                queries: activeTargets,
                 targetedRuns: new Map(),
                 itemsByFiles: new WeakMap(),
             };
-            const nestedOptions = { ...options, __findBatchContext: batchContext };
-            const bodies = await Promise.all(targets.map(async (query) => {
+            const bodies = await Promise.all(activeTargets.map(async (query, index) => {
+                const queryHeadLimit = totalHeadLimit > 0
+                    ? _splitFindBudget(totalHeadLimit, activeTargets.length, index)
+                    : 0;
+                const nestedOptions = {
+                    ...options,
+                    __findBatchContext: batchContext,
+                    __findOutputBudgetBytes: _splitFindBudget(bodyBudget, activeTargets.length, index),
+                };
                 try {
-                    return await executeFuzzyFindTool({ ...args, query }, workDir, nestedOptions);
+                    return await executeFuzzyFindTool(
+                        { ...args, query, head_limit: queryHeadLimit },
+                        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]`);
+            const sections = activeTargets.map((q, i) => `${sectionHeaders[i]}${bodies[i]}`);
+            sections.push(...notes);
             return sections.join('\n\n');
         }
         args.query = targets[0];
@@ -616,7 +674,12 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
         includeNoise,
     });
     const cached = cacheGet(cacheKey);
-    if (cached !== null) return cached;
+    const capFindResult = (value) => capLineOrientedToolOutput(
+        value,
+        _findOutputBudgetBytes(options),
+        () => `... [find result budget reached for query=${JSON.stringify(query)}; narrow path/head_limit]`,
+    );
+    if (cached !== null) return capFindResult(cached);
     // Common discovery respects .gitignore even outside a Git repository.
     // include_noise deliberately retains the old hardened --no-ignore behavior.
     // Noise dirs stay excluded via DEFAULT_IGNORE_GLOBS below.
@@ -751,7 +814,7 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
     if (typeof options?.onProgress === 'function') {
         try { options.onProgress(`${ranked.length} candidates`); } catch { /* best-effort */ }
     }
-    return result;
+    return capFindResult(result);
 }
 
 export async function executeFindFilesTool(args, workDir, options = {}) {
@@ -1014,7 +1077,7 @@ export async function executeFindFilesTool(args, workDir, options = {}) {
     const windowed = offset > 0 ? matches.slice(offset) : matches;
     const sliced = headLimit > 0 ? windowed.slice(0, headLimit) : windowed;
     const lines = sliced.map(m =>
-        `${normalizeOutputPath(m.path)}\t${formatListSize('file', m.size)}\t${formatMtime(m.mtimeMs)}`);
+        `${displayRelPath(m.path, fullPath)}\t${formatListSize('file', m.size)}\t${formatMtime(m.mtimeMs)}`);
     if (windowed.length > sliced.length) lines.push(`... [entries ${offset + 1}-${offset + sliced.length} of ${matches.length}; pass offset:${offset + sliced.length} to continue]`);
     if (rgStdoutTruncated) lines.push('... [warning] rg stdout truncated at 20MB cap; results incomplete');
     if (rgStdoutPartial) lines.push('... [warning] rg exit 2 (partial results); listing may be incomplete');

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

@@ -103,6 +103,11 @@ function firstPresentArg(args, names) {
     return undefined;
 }
 
+// Shared semantic default for grep calls that omit output_mode/context.
+// Scoped-cache canonicalization imports this so omitted context and an
+// explicit context:25 resolve to the same cache key.
+export const GREP_AUTO_CONTEXT_LINES = 25;
+
 export function normalizeGrepArgs(args) {
     if (!args || typeof args !== 'object') return args;
     if (args.pattern === undefined || args.pattern === null || args.pattern === '') {
@@ -119,7 +124,7 @@ export function normalizeGrepArgs(args) {
     }
     if ((args.output_mode === undefined || args.output_mode === null || args.output_mode === '') && typeof args.mode === 'string') {
         const mode = args.mode.trim();
-        if (['files_with_matches', 'content', 'count'].includes(mode)) args.output_mode = mode;
+        if (['files_with_matches', 'content', 'content_with_context', 'count'].includes(mode)) args.output_mode = mode;
     }
     return args;
 }
@@ -284,6 +289,20 @@ export function coerceReadFamilyPathArg(path, workDir = null) {
             } catch { /* not a literal bracket path — allow JSON coercion */ }
         }
     }
+    // Absorb: a truncated JSON path array ('["C:\\a\\b.mjs' — a streamed
+    // argument cut mid-emit). Repaired only when exactly ONE path survives,
+    // so a real batch can never be silently narrowed to its first entry.
+    if (typeof path === 'string') {
+        const trimmed = path.trim();
+        if (trimmed.startsWith('["') && !trimmed.endsWith(']')) {
+            try {
+                const repaired = JSON.parse(`${trimmed}"]`);
+                if (Array.isArray(repaired) && repaired.length === 1 && typeof repaired[0] === 'string') {
+                    return repaired[0];
+                }
+            } catch { /* not a repairable truncation — fall through */ }
+        }
+    }
     const coerced = coerceShapeFlex(path);
     if (!Array.isArray(coerced)) return coerced;
     const list = coerced

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

@@ -54,7 +54,7 @@ export function sliceReadBodyByLines(body, origOffset, origLimit) {
     const _remaining = haveTotal ? totalNum - emittedLast : null;
     const continuationPart = moreToRead && Number.isFinite(emittedLast)
         ? (_remaining !== null && _remaining > 0 && _remaining <= 600
-            ? `; ${_remaining} lines left — take the rest in ONE window: offset:${emittedLast}, limit:${_remaining}`
+            ? `; ${_remaining} left — ONE window: offset:${emittedLast} limit:${_remaining}`
             : `; pass offset:${emittedLast} to continue`)
         : '';
     const newFooter = `[lines ${firstLine}-${emittedLast}${totalPart}${continuationPart}]`;

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

@@ -18,11 +18,11 @@ import { TOOL_OUTPUT_MAX_BYTES } from './tool-output-limit.mjs';
 // truncation (proceed with cap) rather than refusing. Hard in-memory cap
 // for loading a full file remains READ_MAX_SIZE_BYTES (10 MiB).
 //
-// READ_MAX_OUTPUT_BYTES (30 KB) — output-truncation cap. Lead-facing default tightened from 50k. Mirrors CC's
-// MAX_OUTPUT_SIZE intent (utils/file.ts:48) and the throw-vs-truncate
+// READ_MAX_OUTPUT_BYTES (30 KB) — output-truncation cap. Lead-facing default tightened from 50k. Follows the
+// common max-output-size intent and the throw-vs-truncate
 // trade-off Anthropic chose in #21841 (throw is more token-efficient).
-// NOTE: CC's parallel output budget is maxTokens = 25,000 tokens
-// (limits.ts:18), enforced post-read via a tokenizer throw. mixdog
+// NOTE: the usual alternative is a ~25,000-token output budget
+// enforced post-read via a tokenizer throw. mixdog
 // caps on BYTES at read time instead (no tokenizer in the hot path);
 // 30 KB ≈ well under a 25k-token budget, so the byte cap is left as-is
 // rather than converted to a token count that can't be expressed

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

@@ -15,8 +15,8 @@ export const API_IMAGE_MAX_BASE64_SIZE = 5 * 1024 * 1024; // 5 MB
 export const IMAGE_TARGET_RAW_SIZE = (API_IMAGE_MAX_BASE64_SIZE * 3) / 4; // 3.75 MB
 const IMAGE_MAX_WIDTH = 2000;
 const IMAGE_MAX_HEIGHT = 2000;
-// Token budget for a single image. est tokens = base64.length * 0.125 (CC's
-// per-image heuristic). Default aligns to the 5MB base64 API ceiling so the
+// Token budget for a single image. est tokens = base64.length * 0.125 (the
+// common per-image heuristic). Default aligns to the 5MB base64 API ceiling so the
 // dimension/raw-size resize governs the common case and the token gate only
 // fires on pathologically dense images.
 const DEFAULT_IMAGE_MAX_TOKENS = Math.ceil(API_IMAGE_MAX_BASE64_SIZE * 0.125);

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

@@ -99,6 +99,9 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
         _rawContentCacheSet,
         _recordReadSnapshot,
     } = helpers;
+    const _readMaxOutputBytes = Number(options?.readOutputBudgetBytes) > 0
+        ? Math.min(READ_MAX_OUTPUT_BYTES, Math.trunc(Number(options.readOutputBudgetBytes)))
+        : READ_MAX_OUTPUT_BYTES;
     // Normalize path (strip whitespace, expand ~, posix→windows) up front so
     // LLM-injected stray spaces don't trigger an ENOENT retry that pollutes
     // the conversation history and breaks the cache prefix on later turns.
@@ -454,7 +457,10 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
             return withSymbolReadNote(text, args);
         }
         try {
-            const _streamRes = await streamReadRange(fullPath, offset, limit, st, { displayPath: filePath });
+            const _streamRes = await streamReadRange(fullPath, offset, limit, st, {
+                displayPath: filePath,
+                maxOutputBytes: _readMaxOutputBytes,
+            });
             const out = _streamRes.text;
             // W1 H: snapshot only emitted line bounds, not the
             // requested window — byte-cap truncation can stop short.
@@ -547,9 +553,13 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
             // Fall through to the regular read path; it still enforces output caps.
         }
     }
-    if (!_isUtf16 && hasRangeArgs && !wantFull && st.size > READ_STREAM_RANGE_MIN_BYTES) {
+    if (!_isUtf16 && hasRangeArgs && !wantFull
+        && (options?.forceReadRangeStream === true || st.size > READ_STREAM_RANGE_MIN_BYTES)) {
         try {
-            const _streamRes = await streamReadRange(fullPath, offset, limit, st, { displayPath: filePath });
+            const _streamRes = await streamReadRange(fullPath, offset, limit, st, {
+                displayPath: filePath,
+                maxOutputBytes: _readMaxOutputBytes,
+            });
             const out = _streamRes.text;
             const _emittedRanges = (_streamRes.firstEmitted && _streamRes.lastEmitted)
                 ? [{ startLine: _streamRes.firstEmitted, endLine: _streamRes.lastEmitted }]
@@ -649,19 +659,19 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
             _smartTruncated = true;
             _smartVisibleRanges = Array.isArray(smart.ranges) ? smart.ranges : null;
             _renderedLineCount = 0;
-        } else if (Buffer.byteLength(rendered, 'utf8') > READ_MAX_OUTPUT_BYTES) {
+        } else if (Buffer.byteLength(rendered, 'utf8') > _readMaxOutputBytes) {
             let lo = 0;
             let hi = rendered.length;
             while (lo < hi) {
                 const mid = Math.ceil((lo + hi) / 2);
-                if (Buffer.byteLength(rendered.slice(0, mid), 'utf8') <= READ_MAX_OUTPUT_BYTES) lo = mid;
+                if (Buffer.byteLength(rendered.slice(0, mid), 'utf8') <= _readMaxOutputBytes) lo = mid;
                 else hi = mid - 1;
             }
             const slice = rendered.slice(0, lo);
             const completeRenderedLines = Math.max(0, slice.split('\n').length - 1);
             _renderedLineCount = completeRenderedLines;
             _byteCapTruncated = true;
-            out = slice + `\n\n... [output truncated at ${Math.round(READ_MAX_OUTPUT_BYTES/1024)} KB] ...`;
+            out = slice + `\n\n... [output truncated at ${Math.round(_readMaxOutputBytes/1024)} KB] ...`;
         } else {
             out = rendered;
         }
@@ -671,10 +681,10 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
             } else if (_byteCapTruncated) {
                 const emittedStart = offset + 1;
                 const emittedEnd = offset + _renderedLineCount;
-                const capKb = Math.round(READ_MAX_OUTPUT_BYTES / 1024);
+                const capKb = Math.round(_readMaxOutputBytes / 1024);
                 const footer = `[lines ${emittedStart}-${emittedEnd} of ${lineCount}; output truncated at ${capKb} KB${emittedEnd < lineCount ? `; pass offset:${emittedEnd} to continue` : ''}]`;
                 out += `${out ? '\n' : ''}${footer}`;
-            } else if (Buffer.byteLength(rendered, 'utf8') <= READ_MAX_OUTPUT_BYTES) {
+            } else if (Buffer.byteLength(rendered, 'utf8') <= _readMaxOutputBytes) {
                 const emittedStart = offset + 1;
                 const emittedEnd = offset + sliced.length;
                 // Anti-fragmentation: when the remainder is modest, hand the
@@ -683,7 +693,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
                 const _remaining = lineCount - emittedEnd;
                 const _cont = emittedEnd < lineCount
                     ? (_remaining <= 600
-                        ? `; ${_remaining} lines left — take the rest in ONE window: offset:${emittedEnd}, limit:${_remaining}`
+                        ? `; ${_remaining} left — ONE window: offset:${emittedEnd} limit:${_remaining}`
                         : `; pass offset:${emittedEnd} to continue`)
                     : '';
                 const footer = `[lines ${emittedStart}-${emittedEnd} of ${lineCount}${_cont}]`;

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

@@ -12,6 +12,7 @@ import {
     rawContentCacheSet,
 } from './cache-layers.mjs';
 import {
+    rememberReadSnapshot,
     readFilesForScope,
     readScopeKey,
     scheduleScopePersist,
@@ -146,7 +147,7 @@ export function recordReadSnapshot(fullPath, st, scope = null, meta = {}) {
     } else if (!batchSliced && sameFile && Number.isFinite(existing?.fileLineCount) && existing.fileLineCount >= 0) {
         next.fileLineCount = Math.trunc(existing.fileLineCount);
     }
-    readFiles.set(fullPath, next);
+    rememberReadSnapshot(fullPath, next, scope, readFiles);
     scheduleScopePersist(readScopeKey(scope));
 }
 

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

@@ -8,8 +8,8 @@ const requireCjs = createRequire(import.meta.url);
 const DEFAULT_READ_MAX_OUTPUT_BYTES = 100 * 1024;
 
 // PDFs at or under this size are emitted as an Anthropic base64 document
-// block (the model reads the rendered PDF directly). Mirrors CC's
-// PDF_TARGET_RAW_SIZE (20MB raw → ~27MB base64, under the 32MB request cap).
+// block (the model reads the rendered PDF directly): 20MB raw → ~27MB
+// base64, which stays under the 32MB request cap.
 // Larger PDFs fall back to pdf-parse TEXT extraction.
 const PDF_DOCUMENT_MAX_BYTES = 20 * 1024 * 1024;
 
@@ -19,7 +19,7 @@ const PDF_DOCUMENT_MAX_BYTES = 20 * 1024 * 1024;
 const PDF_MAGIC = Buffer.from('%PDF-', 'latin1');
 
 // Per-output text ceiling inside a notebook. A single cell output larger than
-// this is replaced with a jq hint (port of CC's large-notebook guidance) so a
+// this is replaced with a jq hint (large-notebook guidance) so a
 // runaway stdout / data dump can't blow the read budget.
 const IPYNB_OUTPUT_MAX_CHARS = 10_000;
 

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

@@ -62,6 +62,10 @@ export async function streamReadRange(fullPath, offset, limit, stHint = null, ho
     let pendingBytes = 0;
     let lineCollectCapped = false;
     let prefixHash = rangeIndex?.prefixHash || '';
+    const maxOutputBytes = Number(hooks.maxOutputBytes) > 0
+        ? Math.min(READ_MAX_OUTPUT_BYTES, Math.trunc(Number(hooks.maxOutputBytes)))
+        : READ_MAX_OUTPUT_BYTES;
+    const bodyOutputBytes = Math.max(1, maxOutputBytes - Math.min(384, Math.floor(maxOutputBytes / 3)));
     const deadline = Date.now() + READ_STREAM_TIMEOUT_MS;
     let bytesScanned = anchor.byteOffset;
 
@@ -85,7 +89,7 @@ export async function streamReadRange(fullPath, offset, limit, stHint = null, ho
         // Truncation drops the entire rendered line (codepoint-safe by
         // construction), so no mid-codepoint cut can occur here.
         collectedBytes += Buffer.byteLength(rendered, 'utf8') + 1;
-        if (collectedBytes > READ_MAX_OUTPUT_BYTES) {
+        if (collectedBytes > bodyOutputBytes) {
             truncated = true;
             return false;
         }
@@ -207,7 +211,8 @@ export async function streamReadRange(fullPath, offset, limit, stHint = null, ho
 
     let out = collected.join('\n');
     if (truncated) {
-        out += `\n\n... [output truncated at ${Math.round(READ_MAX_OUTPUT_BYTES/1024)} KB] ...`;
+        const nextOffset = lastEmitted || offset;
+        out += `\n\n... [output truncated at ${Math.max(1, Math.round(maxOutputBytes/1024))} KB; pass offset:${nextOffset} to continue] ...`;
     } else if (stoppedAtLimit) {
         out += `${out ? '\n' : ''}... [range limit reached; next offset: ${offset + collected.length}]`;
     } else if (!out && offset >= lineIdx) {