mixdog 0.8.0 → 0.9.0

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

@@ -17,14 +17,23 @@ export const BUILTIN_TOOLS = [
         name: 'read',
         title: 'Mixdog Read',
         annotations: { title: 'Mixdog Read', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false },
-        description: 'Read a specific file window or symbol body after narrowing the target. Do not reread content already shown by code_graph or grep.',
+        description: 'Read known file path(s). Use line+context for small windows. Batch paths.',
         inputSchema: {
             type: 'object',
             properties: {
-                path: { type: 'string', description: 'File path only; dirs use list.' },
-                line: { type: 'number', minimum: 1, description: 'Anchor line. Do not combine with offset/limit.' },
-                context: { type: 'number', minimum: 0, maximum: 200, description: 'Lines around line. Use only with line; max 200.' },
-                symbol: { type: 'string', description: 'Symbol body via code graph.' },
+                path: {
+                    anyOf: [
+                        { type: 'string' },
+                        {
+                            type: 'array',
+                            items: { type: 'string' },
+                            minItems: 1,
+                        },
+                    ],
+                    description: 'File path or array. Dirs use list.',
+                },
+                line: { type: 'number', minimum: 1, description: 'Anchor line.' },
+                context: { type: 'number', minimum: 0, maximum: 200, description: 'Lines around line; max 200.' },
             },
         },
     },
@@ -32,11 +41,11 @@ export const BUILTIN_TOOLS = [
         name: 'diagnostics',
         title: 'Mixdog Diagnostics',
         annotations: { title: 'Mixdog Diagnostics', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: 'Run the matching type/lint checker under a file or directory (tsc/eslint/ruff/etc.). Default cwd; no LSP.',
+        description: 'Run matching type/lint checker. Default cwd; no LSP.',
         inputSchema: {
             type: 'object',
             properties: {
-                path: { type: 'string', description: 'File or directory to diagnose. Defaults to cwd.' },
+                path: { type: 'string', description: 'File/dir. Default cwd.' },
             },
             required: [],
         },
@@ -45,29 +54,29 @@ export const BUILTIN_TOOLS = [
         name: 'open_config',
         title: 'Open Config UI',
         annotations: { title: 'Open Config UI', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-        description: 'Open the mixdog settings UI (Providers + Presets) in the browser. Starts the resident config server if needed and returns the UI URL. No params.',
+        description: 'Open settings UI; returns URL. No params.',
         inputSchema: { type: 'object', properties: {}, additionalProperties: false },
     },
     {
         name: 'shell',
         title: 'Mixdog Shell',
         annotations: { title: 'Mixdog Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: `Run an OS shell command for git/build/test/run only. Do NOT use shell grep/cat/head for source; use code_graph/grep/read/list/glob. Set shell explicitly: 'powershell' for PowerShell or 'bash' for Git Bash/POSIX. Use cwd; omit empty workdir. Windows native shell does not support persistent/session_id. mode=async uses the shared background task system and returns task_id. ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
+        description: `Run shell for git/build/test/run. Not for source browsing; use code_graph/grep/read/list/glob. Set shell: powershell or bash. ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
         inputSchema: {
             type: 'object',
             properties: {
-                command: { type: 'string', description: 'Shell command to run.' },
-                cwd: { type: 'string', description: 'Working directory for the command; omit when using current cwd.' },
+                command: { type: 'string', description: 'Command.' },
+                cwd: { type: 'string', description: 'Working directory.' },
                 workdir: { type: 'string', description: 'Alias for cwd; omit if empty.' },
-                timeout: { type: 'number', description: 'Timeout in milliseconds.' },
-                merge_stderr: { type: 'boolean', description: 'Merge stderr into stdout in the returned output.' },
+                timeout: { type: 'number', description: 'Timeout ms.' },
+                merge_stderr: { type: 'boolean', description: 'Merge stderr.' },
                 mode: { type: 'string', enum: ['sync', 'async'], description: executionModeSchemaDescription('sync') },
                 run_in_background: { type: 'boolean', description: `Legacy alias for mode=async. ${TOOL_ASYNC_EXECUTION_CONTRACT}` },
-                persistent: { type: 'boolean', description: 'Persistent shell mode; unsupported on Windows native shell.' },
-                session_id: { type: 'string', description: 'Persistent shell id; omit on Windows native shell.' },
-                create: { type: 'boolean', description: 'Allow creating a new persistent session for an explicit session_id.' },
-                close: { type: 'boolean', description: 'Close the persistent session after this command when supported.' },
-                shell: { type: 'string', enum: ['bash', 'powershell'], description: "Force the shell. On Windows: 'bash' runs the command through Git Bash (POSIX syntax), 'powershell' forces PowerShell. On POSIX: 'powershell' resolves pwsh if installed (errors if absent); 'bash' is /bin/sh (already the default). Always set this explicitly; omitting uses the OS default (PowerShell on Windows), where POSIX syntax fails to parse." },
+                persistent: { type: 'boolean', description: 'Persistent shell mode.' },
+                session_id: { type: 'string', description: 'Persistent shell id.' },
+                create: { type: 'boolean', description: 'Create session_id if missing.' },
+                close: { type: 'boolean', description: 'Close persistent session.' },
+                shell: { type: 'string', enum: ['bash', 'powershell'], description: 'Force shell. Windows default is PowerShell; bash means Git Bash/POSIX.' },
             },
             required: ['command'],
         },
@@ -76,14 +85,14 @@ export const BUILTIN_TOOLS = [
         name: 'task',
         title: 'Background Task Control',
         annotations: { title: 'Background Task Control', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
-        description: `Manual control for an async background task by task_id. action: list | status | read | wait | cancel. ${TOOL_MANUAL_CONTROL_CONTRACT} Not for bridge_*/sess_* ids.`,
+        description: `Manual control for shell async task_id. actions: list/status/read/wait/cancel. ${TOOL_MANUAL_CONTROL_CONTRACT} Not sess_* or agent ids.`,
         inputSchema: {
             type: 'object',
             properties: {
-                task_id: { type: 'string', description: 'task_id from shell mode=async. Use only for manual control; normal completion arrives as a notification.' },
-                action: { type: 'string', enum: ['list', 'status', 'read', 'wait', 'cancel'], description: 'Manual control only: list all visible tasks; status is non-blocking; read includes available result/output; wait blocks inside this one call until done/timeout; cancel terminates when the task supports it. Do not call repeatedly as a polling loop.' },
-                timeout_ms: { type: 'number', description: 'Maximum time for a single manual wait call. Prefer the completion notification instead of repeated waits.' },
-                poll_ms: { type: 'number', description: 'Internal polling interval used only inside one manual wait call.' },
+                task_id: { type: 'string', description: 'shell async task_id.' },
+                action: { type: 'string', enum: ['list', 'status', 'read', 'wait', 'cancel'], description: 'Manual action. Avoid polling loops.' },
+                timeout_ms: { type: 'number', description: 'Wait timeout ms.' },
+                poll_ms: { type: 'number', description: 'Wait poll ms.' },
             },
             required: [],
         },
@@ -92,7 +101,7 @@ export const BUILTIN_TOOLS = [
         name: 'grep',
         title: 'Mixdog Grep',
         annotations: { title: 'Mixdog Grep', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
-        description: 'Search text or regex within a known file or directory.',
+        description: 'Search text/logs/regex.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -101,19 +110,19 @@ export const BUILTIN_TOOLS = [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Literal/substring or ripgrep regex. Array = OR terms. Legacy `\\|` in a single string is accepted as OR.',
+                    description: 'Text/regex. Array = OR.',
                 },
-                path: { type: 'string', description: 'One file or directory only; for many paths use common parent + glob.' },
+                path: { type: 'string', description: 'File or directory.' },
                 glob: {
                     anyOf: [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Glob filter(s).',
+                    description: 'Optional narrowing glob(s).',
                 },
-                output_mode: { type: 'string', enum: ['files_with_matches', 'content', 'count'], description: 'Default content.' },
-                head_limit: { type: 'number', description: 'Max result lines.' },
-                offset: { type: 'number', description: 'Skip N result lines for paging.' },
+                output_mode: { type: 'string', enum: ['files_with_matches', 'content', 'count'], description: 'Output mode.' },
+                head_limit: { type: 'number', description: 'Max lines.' },
+                offset: { type: 'number', description: 'Skip lines.' },
             },
             required: [],
         },
@@ -122,7 +131,7 @@ export const BUILTIN_TOOLS = [
         name: 'glob',
         title: 'Mixdog Glob',
         annotations: { title: 'Mixdog Glob', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
-        description: 'Find files by glob pattern. Use for broad file-space narrowing.',
+        description: 'Find files by glob.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -131,33 +140,47 @@ export const BUILTIN_TOOLS = [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Glob pattern, or array of patterns.',
+                    description: 'Glob pattern(s).',
                 },
                 path: {
                     anyOf: [
                         { type: 'string' },
                         { type: 'array', items: { type: 'string' }, minItems: 1 },
                     ],
-                    description: 'Base directory, or array of base directories.',
+                    description: 'Base directory/directories.',
                 },
                 head_limit: { type: 'number', description: 'Max entries.' },
-                offset: { type: 'number', description: 'Skip N entries for paging.' },
+                offset: { type: 'number', description: 'Skip entries.' },
             },
             required: ['pattern'],
         },
     },
+    {
+        name: 'find',
+        title: 'Mixdog Find Files',
+        annotations: { title: 'Mixdog Find Files', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
+        description: 'Fuzzy-find files by partial path/name. Returns paths.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Partial path/name words.' },
+                path: { type: 'string', description: 'Base directory.' },
+                head_limit: { type: 'number', description: 'Max paths.' },
+            },
+            required: ['query'],
+        },
+    },
     {
         name: 'list',
         title: 'Mixdog List Directory',
         annotations: { title: 'Mixdog List Directory', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
-        description: 'List directory entries or fuzzy-rank filenames. Use for broad directory/file discovery.',
+        description: 'List known directory entries. Use glob for broad discovery.',
         inputSchema: {
             type: 'object',
             properties: {
-                path: { type: 'string', description: 'Directory to list; omit for current cwd.' },
+                path: { type: 'string', description: 'Directory.' },
                 head_limit: { type: 'number', description: 'Max entries.' },
                 offset: { type: 'number', description: 'Skip N entries for paging.' },
-                fuzzy: { type: 'string', description: 'Rank files by partial name.' },
             },
             required: [],
         },

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

@@ -5,6 +5,7 @@ import { deleteReadRangeIndexForPath } from './read-range-index.mjs';
 import { resolveAgainstCwd } from './path-utils.mjs';
 
 const RESULT_CACHE = new Map(); // key → { ts, value, paths, scopes, readSnapshotMeta, contentPrefixHash, bytes }
+const RESULT_CACHE_INFLIGHT = new Map(); // key → Promise<value>
 const RESULT_CACHE_TTL_MS = 30_000;
 const RESULT_CACHE_MAX_ENTRIES = 200;
 const RESULT_CACHE_MAX_BYTES = (() => {
@@ -140,6 +141,22 @@ export function cacheSet(key, value, meta = {}) {
     }
 }
 
+export async function runResultCacheInFlight(key, compute) {
+    const cached = cacheGet(key);
+    if (cached !== null) return cached;
+    const existing = RESULT_CACHE_INFLIGHT.get(key);
+    if (existing) return await existing;
+    const promise = Promise.resolve()
+        .then(() => compute())
+        .finally(() => {
+            if (RESULT_CACHE_INFLIGHT.get(key) === promise) {
+                RESULT_CACHE_INFLIGHT.delete(key);
+            }
+        });
+    RESULT_CACHE_INFLIGHT.set(key, promise);
+    return await promise;
+}
+
 function rawContentCacheDelete(key) {
     const entry = RAW_CONTENT_CACHE.get(key);
     if (entry?.rawBuf) RAW_CONTENT_CACHE_BYTES = Math.max(0, RAW_CONTENT_CACHE_BYTES - entry.rawBuf.length);
@@ -230,7 +247,7 @@ export async function statPathsForMtime(paths, workDir, concurrency = 64, opts =
     // Hard per-stat deadline (0 = disabled, legacy behaviour). A hung stat
     // (dead mount / unresponsive network path) must not pin a worker forever;
     // on expiry the entry resolves to null (stat-failed) so glob's post-rg stat
-    // phase is bounded instead of running to the 600s bridge watchdog.
+    // phase is bounded instead of running to the 600s agent watchdog.
     const deadlineMs = Number(opts.deadlineMs) > 0 ? Number(opts.deadlineMs) : 0;
     // Injectable stat impl for testing hung-FS behaviour deterministically.
     const statImpl = typeof opts._statImpl === 'function' ? opts._statImpl : fsPromises.stat;
@@ -293,7 +310,7 @@ export async function lstatPathsForMtime(paths, workDir, concurrency = 64, opts
     // Hard per-lstat deadline (0 = disabled, legacy behaviour). A hung lstat
     // (dead mount / unresponsive network path) must not pin a worker forever;
     // on expiry the entry resolves to null (stat-failed) so list's stat phase
-    // is bounded instead of running to the 600s bridge watchdog.
+    // is bounded instead of running to the 600s agent watchdog.
     const deadlineMs = Number(opts.deadlineMs) > 0 ? Number(opts.deadlineMs) : 0;
     // Injectable lstat impl for testing hung-FS behaviour deterministically.
     const lstatImpl = typeof opts._lstatImpl === 'function' ? opts._lstatImpl : fsPromises.lstat;
@@ -342,6 +359,7 @@ export async function lstatPathsForMtime(paths, workDir, concurrency = 64, opts
 
 function cacheInvalidateAll() {
     RESULT_CACHE.clear();
+    RESULT_CACHE_INFLIGHT.clear();
     RESULT_CACHE_BYTES = 0;
     STAT_CACHE.clear();
     RAW_CONTENT_CACHE.clear();
@@ -356,6 +374,7 @@ function cacheInvalidatePaths(paths) {
         cacheInvalidateAll();
         return;
     }
+    RESULT_CACHE_INFLIGHT.clear();
     for (const [key, entry] of RESULT_CACHE) {
         if (cacheEntryOverlapsPaths(entry, affectedPaths)) {
             resultCacheDelete(key);

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

@@ -1,4 +1,4 @@
-// G6: device path block list (Claude Code parity). Reading these paths
+// G6: device path block list (reference parity). Reading these paths
 // would either hang (waiting for stdin / tty) or produce infinite output
 // (/dev/zero, /dev/random). The device block list catches pseudo-files on
 // POSIX hosts that a user-allowed path can still hit.

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

@@ -282,11 +282,4 @@ async function _executeDiagnosticsImpl(args, workDir) {
     }
 }
 
-function _isDir(p, workDir) {
-    try {
-        const abs = isAbsolute(p) ? p : pathResolve(workDir, p);
-        return statSync(abs).isDirectory();
-    } catch { return false; }
-}
-
 export default executeDiagnosticsTool;

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

@@ -118,12 +118,10 @@ export function compileSimpleGlob(pattern) {
 // simpler and matches the noise patterns developers actually create.
 export const NOISE_DIR_NAMES = new Set([
     'node_modules', '.git',
-    'dist', 'build', 'out', 'target',
     '.next', '.nuxt', '.svelte-kit',
     '.cache', '.parcel-cache', '.turbo',
     'venv', '.venv', '__pycache__', '.pytest_cache',
-    '.gradle', 'coverage',
-    'refs',
+    '.gradle',
 ]);
 
 export const MAX_WALK_ENTRIES = 200_000;

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

@@ -60,7 +60,7 @@ function listGuardPath(p) {
 
 export async function executeListTool(args, workDir, options = {}) {
     if (typeof args.fuzzy === 'string' && args.fuzzy.length > 0) {
-        return executeFuzzyFind(args, workDir);
+        return executeFuzzyFindTool({ ...args, query: args.fuzzy }, workDir, options);
     }
     if (args.mode === 'tree') return executeTreeTool(args, workDir, options);
     if (args.mode === 'find') return executeFindFilesTool(args, workDir, options);
@@ -296,12 +296,13 @@ export async function executeTreeTool(args, workDir, options = {}) {
     return out;
 }
 
-// Fuzzy filename search (codex file-search / nucleo style): collect the file
-// list via `rg --files`, then rank by subsequence score. Lets a partial name
-// like "edeng" surface matching files in one call instead of guessing an exact
-// glob pattern. Honors path/hidden/include_noise/depth/head_limit.
-async function executeFuzzyFind(args, workDir) {
-    const query = String(args.fuzzy);
+ // Fuzzy filename search (nucleo-style): collect the file
+// list via `rg --files`, then rank by subsequence score. `list.fuzzy` still
+// routes here for hidden backward compatibility, but the model-facing tool is
+// `find`.
+export async function executeFuzzyFindTool(args, workDir, options = {}) {
+    const query = String(args.query ?? args.fuzzy ?? '').trim();
+    if (!query) return 'Error: find requires query.';
     const inputPath = normalizeInputPath(args.path) || '.';
     const guard = listGuardPath(inputPath);
     if (guard) return guard;
@@ -310,10 +311,25 @@ async function executeFuzzyFind(args, workDir) {
     if (guardFull) return guardFull;
     const hidden = Boolean(args.hidden);
     const includeNoise = Boolean(args.include_noise);
-    // head_limit:0 means "no cap" per list semantics — keep 0 distinct from default.
-    const headLimit = normalizeListHeadLimit(args.head_limit, 40);
+    // head_limit:0 means "no cap" per list semantics; default is intentionally
+    // compact so ambiguous discovery does not dump a huge candidate list.
+    const headLimit = normalizeListHeadLimit(args.head_limit, 25);
     const depth = args.depth != null ? Math.max(parseInt(args.depth, 10) || 1, 1) : null;
-    const rgArgs = ['--files', '--no-ignore'];
+    const cacheKey = buildListCacheKey({
+        mode: 'fuzzy_find',
+        inputPath: normalizeOutputPath(fullPath),
+        depth: depth ?? '',
+        hidden,
+        sort: 'score',
+        typeFilter: 'file',
+        headLimit,
+        offset: '',
+        namePattern: query,
+        includeNoise,
+    });
+    const cached = cacheGet(cacheKey);
+    if (cached !== null) return cached;
+    const rgArgs = ['--files'];
     if (hidden) rgArgs.push('--hidden');
     if (depth != null) rgArgs.push('--max-depth', String(depth));
     if (!includeNoise) {
@@ -333,12 +349,20 @@ async function executeFuzzyFind(args, workDir) {
         .map((p) => (p.endsWith('\r') ? p.slice(0, -1) : p))
         .filter((p) => p.length > 0)
         .map((p) => ({ path: normalizeOutputPath(p.replace(/^\.[/\\]/, '')) }));
-    const ranked = fuzzyRank(query, items, headLimit);
+    const rankLimit = headLimit > 0 ? headLimit + 1 : headLimit;
+    const rankedRaw = fuzzyRank(query, items, rankLimit);
+    const hasMore = headLimit > 0 && rankedRaw.length > headLimit;
+    const ranked = hasMore ? rankedRaw.slice(0, headLimit) : rankedRaw;
     if (ranked.length === 0) return `(no fuzzy match for "${query}")`;
     const out = ranked.map((r) => r.item.path).join('\n');
-    return headLimit > 0 && ranked.length >= headLimit
+    const result = hasMore
         ? `${out}\n... (top ${headLimit}; raise head_limit for more)`
         : out;
+    cacheSet(cacheKey, result, { scopes: [fullPath] });
+    if (typeof options?.onProgress === 'function') {
+        try { options.onProgress(`${ranked.length} candidates`); } catch { /* best-effort */ }
+    }
+    return result;
 }
 
 export async function executeFindFilesTool(args, workDir, options = {}) {

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

@@ -98,6 +98,8 @@ export function normaliseReadLineWindowArgs(inputArgs, workDir) {
                 args.limit = limit;
             }
         }
+        delete args.line;
+        delete args.context;
     }
     return args;
 }

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

@@ -3,7 +3,7 @@ import { SMART_READ_MAX_BYTES } from './read-formatting.mjs';
 // Read tool caps.
 //
 // READ_MAX_SIZE_BYTES (10 MB) — fast-path file-size threshold mirroring
-// Claude Code's FAST_PATH_MAX_SIZE (readFileInRange.ts:44). Files at or below
+// Reference FAST_PATH_MAX_SIZE (readFileInRange.ts:44). Files at or below
 // this size use readFile + in-memory split by default, which CC measured at
 // ~2x faster than createReadStream + readline for typical source. Explicit
 // offset/limit windows on files above READ_STREAM_RANGE_MIN_BYTES take the
@@ -14,7 +14,7 @@ import { SMART_READ_MAX_BYTES } from './read-formatting.mjs';
 //
 // READ_WHOLE_FILE_MAX_BYTES (256 KiB) — soft threshold: default whole-file
 // reads larger than this prefer stream smart-elide + READ_MAX_OUTPUT_BYTES
-// truncation (Codex-style proceed) rather than refusing. Hard in-memory cap
+// 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

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

@@ -12,7 +12,7 @@ export const SMART_READ_TAIL_LINES = 100;
 export const READ_CONTEXT_ADVISORY_BYTES = 40 * 1024;
 export const READ_MAX_RENDERED_LINE_CHARS = 2_000;
 // Claude-Code parity: the read line-prefix separator is `→` (the `→`
-// arrow), matching Claude Code's default cat -n format `<n>→<content>`. It
+// arrow), matching default cat -n format `<n>→<content>`. It
 // MUST be a NON-WHITESPACE glyph: a tab/space separator collides with the
 // content's own leading indentation, so a model hand-reconstructing an edit
 // old_string cannot tell the separator from the indent and produces
@@ -42,22 +42,15 @@ function rangeFromRenderedReadRows(rows, fallbackStartLine = 1) {
     };
 }
 
-// Optional `budget` { maxLines, headLines, tailLines } lets a caller request a
-// TIGHTER head+tail elision than the 600-line / 200+100 default (e.g. read
-// budget:'compact' or max_lines:N) to bound lead-context cost. Omitted -> the
-// standard caps, so existing 4-arg callers are byte-for-byte unchanged.
-export function smartReadTruncate(renderedWithLineNos, totalLines, fileBytes, filePath = '', budget = null) {
-    const maxLines = budget?.maxLines ?? SMART_READ_MAX_LINES;
-    const headLines = budget?.headLines ?? SMART_READ_HEAD_LINES;
-    const tailLines = budget?.tailLines ?? SMART_READ_TAIL_LINES;
+export function smartReadTruncate(renderedWithLineNos, totalLines, fileBytes, filePath = '') {
     const overByBytes = fileBytes > SMART_READ_MAX_BYTES;
-    const overByLines = totalLines > maxLines;
+    const overByLines = totalLines > SMART_READ_MAX_LINES;
     if (!overByBytes && !overByLines) {
         return { text: renderedWithLineNos, truncated: false, totalLines, ranges: null };
     }
     const rows = renderedWithLineNos.split('\n');
-    const headCount = Math.min(headLines, rows.length);
-    const tailStart = Math.max(headCount, rows.length - tailLines);
+    const headCount = Math.min(SMART_READ_HEAD_LINES, rows.length);
+    const tailStart = Math.max(headCount, rows.length - SMART_READ_TAIL_LINES);
     const elidedRows = tailStart - headCount;
     if (elidedRows <= 0) {
         return { text: renderedWithLineNos, truncated: false, totalLines, ranges: null };

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

@@ -1,4 +1,4 @@
-// Optional-sharp image resize / downsample helper. Mirrors Claude Code's
+// Optional-sharp image resize / downsample helper. Mirrors reference
 // imageResizer.ts (maybeResizeAndDownsampleImageBuffer +
 // readImageWithTokenBudget) so a `read` on an image returns a viewable,
 // budget-bounded image block instead of refusing oversized originals.

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

@@ -12,23 +12,6 @@ function snapshotBodyWasReturnedByRead(snapshot) {
     return String(snapshot?.source || '').startsWith('read');
 }
 
-// Optional context-budget for a whole-file read: `max_lines:N` requests a
-// TIGHTER head+tail elision than the default 600-line / 200+100 cap, to bound
-// lead-context cost when only a glance is needed. Returns null (= default) when
-// unset. No heuristic guessing — the budget is explicit and reuses the existing
-// smartReadTruncate head/tail invariant. (`budget:'compact'` is a SEPARATE,
-// pre-existing knob handled upstream in read-tool.mjs applyCompactReadBudget —
-// it remaps a whole-file read to mode:'count' stats, not head+tail content.)
-function resolveReadBudget(args) {
-    const ml = Number(args?.max_lines);
-    if (Number.isFinite(ml) && ml > 0) {
-        const maxLines = Math.trunc(ml);
-        const headLines = Math.max(1, Math.ceil(maxLines * 0.7));
-        return { maxLines, headLines, tailLines: Math.max(0, maxLines - headLines) };
-    }
-    return null;
-}
-
 function withSymbolReadNote(text, args) {
     const note = typeof args?._symbolReadNote === 'string' ? args._symbolReadNote.trim() : '';
     if (!note || typeof text !== 'string') return text;
@@ -159,9 +142,6 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
     // emits a compact truncation marker when rendered bytes overflow
     // READ_MAX_OUTPUT_BYTES.
     const limit = parseLineLimitArg(args.limit, wantFull ? Infinity : 2000);
-    // Context-budget (compact / max_lines) — only meaningful on a whole-file
-    // read (no range, not full). Ignored otherwise.
-    const _readBudget = (!hasRangeArgs && !wantFull) ? resolveReadBudget(args) : null;
     let st;
     let _statErr;
     try {
@@ -265,7 +245,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
         }
         return _ipynbOut;
     }
-    const cacheKey = `read|${fullPath}|${st.mtimeMs}|${st.size}|${hasOffsetArg ? offset : 'd'}|${hasLimitArg ? limit : 'd'}|${wantFull ? 'f' : 's'}|${_readBudget ? `b${_readBudget.maxLines}` : 'd'}`;
+    const cacheKey = `read|${fullPath}|${st.mtimeMs}|${st.size}|${hasOffsetArg ? offset : 'd'}|${hasLimitArg ? limit : 'd'}|${wantFull ? 'f' : 's'}`;
     // Race-guard helper: same-mtime same-size rapid rewrite (NTFS / exFAT 1 s
     // resolution) can pass mtimeMs+size yet differ in content. When the cache
     // entry stores a contentPrefixHash, recompute the current prefix and bail
@@ -358,7 +338,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
             _recordReadSnapshot(fullPath, st, readStateScope, cachedEntry.readSnapshotMeta || { source: 'read_cached' });
             // G6: file_unchanged stub. The full body is already in the
             // prior tool_result; resending it wastes cache_creation
-            // tokens (Claude Code upstream measured ~18% on Read calls).
+            // tokens (reference upstream measured ~18% on Read calls).
             // The stub keeps the snapshot tracking intact (Edit
             // validation still works) while collapsing the response
             // payload. Falls back to the full body when the cached
@@ -496,19 +476,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
                 ? await streamSmartReadSummary(fullPath, st, 'read_smart_stream')
                 : null;
             if (_streamSmart?.text) {
-                let out = _streamSmart.text;
-                // Honor a compact/max_lines budget on a large file: the stream
-                // already elided to head 200/tail 100; re-apply the tighter
-                // head+tail so the lead sees only the requested glance.
-                if (_readBudget) {
-                    // Use the file's REAL line count from the stream pass
-                    // (snapshotMeta.fileLineCount — the result has no top-level
-                    // totalLines), not the already-elided output's row count: the
-                    // re-budget marker otherwise reports "[TRUNCATED - 301 lines]"
-                    // for a 3800-line file.
-                    const _rebud = smartReadTruncate(out, _streamSmart.snapshotMeta?.fileLineCount || out.split('\n').length, st.size, filePath, _readBudget);
-                    if (_rebud?.truncated) out = _rebud.text;
-                }
+                const out = _streamSmart.text;
                 const snapshotMeta = _streamSmart.snapshotMeta || {
                     source: 'read_smart_stream',
                     ranges: [],
@@ -625,7 +593,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
         // green-light an overwrite against bytes the read never returned.
         let _byteCapTruncated = false;
         const smart = (!hasRangeArgs && !wantFull && typeof smartReadTruncate === 'function')
-            ? smartReadTruncate(rendered, lineCount, st.size, filePath, _readBudget)
+            ? smartReadTruncate(rendered, lineCount, st.size, filePath)
             : null;
         let _smartTruncated = false;
         let _smartVisibleRanges = null;

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

@@ -79,34 +79,6 @@ async function _readReachPreflight(rawPath, workDir, helpers) {
     catch (e) { return `Error: ${e?.message || e}`; }
 }
 
-function capPositiveNumber(value, max, fallback = max) {
-    const n = Number(value);
-    if (!Number.isFinite(n) || n <= 0) return fallback;
-    return Math.min(max, Math.max(1, Math.trunc(n)));
-}
-
-function applyCompactReadBudget(entry) {
-    if (!entry || String(entry.budget || '').toLowerCase() !== 'compact') return entry;
-    const next = { ...entry };
-    const isFullMode = !next.mode || next.mode === 'full';
-    const hasLine = next.line !== undefined && next.line !== null;
-    const hasRange = next.offset !== undefined || next.limit !== undefined;
-    const hasPathLine = hasLineCoordinate(next.path);
-    if (hasLine && (next.context === undefined || next.context === null || Number(next.context) > 20)) {
-        next.context = 20;
-    }
-    if (hasRange && (next.limit === undefined || next.limit === null || Number(next.limit) > 120)) {
-        next.limit = 120;
-    }
-    if ((next.mode === 'head' || next.mode === 'tail') && (next.n === undefined || next.n === null || Number(next.n) > 80)) {
-        next.n = capPositiveNumber(next.n, 80, 80);
-    }
-    if (isFullMode && !hasLine && !hasRange && !hasPathLine && next.full !== true) {
-        next.mode = 'count';
-    }
-    return next;
-}
-
 export async function executeReadTool(args, workDir, readStateScope, executeChildBuiltinTool, options = {}, helpers = {}) {
     const {
         classifyResultKind,
@@ -217,10 +189,7 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
             if (r?.line !== undefined) entry.line = r.line;
             if (r?.context !== undefined) entry.context = r.context;
             if (r?.full !== undefined) entry.full = r.full;
-            if (r?.budget !== undefined) entry.budget = r.budget;
-            entry = applyCompactReadBudget(entry);
             entry = normaliseReadLineWindowArgs(entry, workDir);
-            entry = applyCompactReadBudget(entry);
             return entry;
         });
         const _invertedRawEntry = rawEntries.find((e) => e && e._invertedRangeError);
@@ -269,10 +238,7 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
             if (args.line !== undefined) entry.line = args.line;
             if (args.context !== undefined) entry.context = args.context;
             if (args.full !== undefined) entry.full = args.full;
-            if (args.budget !== undefined) entry.budget = args.budget;
-            entry = applyCompactReadBudget(entry);
             entry = normaliseReadLineWindowArgs(entry, workDir);
-            entry = applyCompactReadBudget(entry);
             return entry;
         });
         const _invertedStrEntry = entries.find((e) => e && e._invertedRangeError);
@@ -450,9 +416,9 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
         args.path = normalizeInputPath(args.path);
         // Symbol reads are span-driven. Models (notably gpt-5.5) co-send the whole
         // schema filled with placeholder/zero values (offset:0, limit:0, line:0,
-        // context:0, pages:'', max_lines:0, mode, budget) alongside symbol, which
+        // context:0, pages:'', mode) alongside symbol, which
         // otherwise makes the symbol branch think a window was requested and falls
-        // back to a 0-window read. Treat those zero/empty/mode/budget params as
+        // back to a 0-window read. Treat those zero/empty/mode params as
         // absent so the whole symbol body returns in ONE call; a MEANINGFUL window
         // (offset>0 / limit>0 / non-empty pages / real line) is kept and overrides.
         if (typeof args.symbol === 'string' && args.symbol.trim()) {
@@ -460,11 +426,8 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
             if (args.limit === 0) delete args.limit;
             if (args.line === 0) delete args.line;
             if (args.pages === '') delete args.pages;
-            if (args.max_lines === 0) delete args.max_lines;
-            if (args.budget !== undefined) delete args.budget;
             if (args.mode !== undefined) delete args.mode;
         }
-        args = applyCompactReadBudget(args);
         const sym = typeof args.symbol === 'string' ? args.symbol.trim() : '';
         if (sym) {
             const hasOffset = args.offset !== undefined && args.offset !== null;
@@ -515,7 +478,6 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
         }
         args = normaliseReadLineWindowArgs(args, workDir);
         if (args._invertedRangeError) return args._invertedRangeError;
-        args = applyCompactReadBudget(args);
     }
     // Mode routing. A window already dropped any conflicting head/tail/summary
     // glance above (so the window is served by executeSingleReadTool); what