mixdog 0.9.62 → 0.9.64

package/src/runtime/agent/orchestrator/stall-policy.mjs

@@ -3,9 +3,9 @@ import { getHiddenAgent } from './internal-agents.mjs';
 const SECOND_MS = 1000;
 const MIN_PROVIDER_TIMEOUT_MS = 30_000;
 
-export const STALL_TICK_MS = 15_000;
-export const DEFAULT_STALL_WARN_S = 300;
-export const DEFAULT_STALL_ABORT_S = 600;
+const STALL_TICK_MS = 15_000;
+const DEFAULT_STALL_WARN_S = 300;
+const DEFAULT_STALL_ABORT_S = 600;
 // First-byte (no-stream-delta) abort for the agent stall watchdog. A wedged
 // socket can sit at stage=requesting with zero server events. The 30s deadline
 // trialed here false-aborted slow high-reasoning first bytes (e.g. gpt-5.5
@@ -13,14 +13,14 @@ export const DEFAULT_STALL_ABORT_S = 600;
 // with dispatch auto-retry, produced premature aborts + duplicate re-dispatches.
 // Auto-retry is now removed, so a single
 // attempt must get a generous first-byte window: 300s (5 min). Env-overridable.
-export const DEFAULT_STALL_FIRST_BYTE_ABORT_S = (() => {
+const DEFAULT_STALL_FIRST_BYTE_ABORT_S = (() => {
     const raw = process.env.MIXDOG_STALL_FIRST_BYTE_ABORT_S;
     const n = Number.parseInt(raw, 10);
     if (Number.isFinite(n) && n > 0) return Math.min(Math.max(n, 5), 600);
     return 300;
 })();
 
-export function envThresholdSeconds(env = process.env) {
+function envThresholdSeconds(env = process.env) {
     const raw = env.STALL_TIMEOUT_S;
     if (!raw) return null;
     const n = Number.parseInt(raw, 10);
@@ -28,17 +28,17 @@ export function envThresholdSeconds(env = process.env) {
     return n;
 }
 
-export function resolveBaseStallThresholds(env = process.env) {
+function resolveBaseStallThresholds(env = process.env) {
     const abort = envThresholdSeconds(env) ?? DEFAULT_STALL_ABORT_S;
     const warn = abort > DEFAULT_STALL_WARN_S ? DEFAULT_STALL_WARN_S : Math.floor(abort / 2);
     return { warn, abort };
 }
 
 const _baseThresholds = resolveBaseStallThresholds();
-export const STALL_WARN_S = _baseThresholds.warn;
+const STALL_WARN_S = _baseThresholds.warn;
 export const STALL_ABORT_S = _baseThresholds.abort;
-export const STALL_WARN_MS = STALL_WARN_S * SECOND_MS;
-export const STALL_ABORT_MS = STALL_ABORT_S * SECOND_MS;
+const STALL_WARN_MS = STALL_WARN_S * SECOND_MS;
+const STALL_ABORT_MS = STALL_ABORT_S * SECOND_MS;
 
 export const PROVIDER_MAX_BEFORE_WARN_MS = Math.max(
     SECOND_MS,
@@ -78,7 +78,7 @@ export const PROVIDER_GENERATE_TOTAL_TIMEOUT_MS = resolveTimeoutMs(
     { minMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS, maxMs: PROVIDER_MAX_BEFORE_WARN_MS },
 );
 
-export const PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS = resolveTimeoutMs(
+const PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS = resolveTimeoutMs(
     ['MIXDOG_NONSTREAM_TOTAL_TIMEOUT_MS', 'MIXDOG_COMPAT_NONSTREAM_TOTAL_TIMEOUT_MS'],
     480_000,
     { minMs: PROVIDER_GENERATE_TOTAL_TIMEOUT_MS, maxMs: STALL_ABORT_MS },
@@ -187,7 +187,7 @@ export const PROVIDER_WS_ACQUIRE_TIMEOUT_MS = resolveTimeoutMs(
 // silently blackholes response.create frames until a downstream timeout. An
 // idle pooled socket is pinged on this cadence; a reused socket that has been
 // quiet longer than the stale window is ping-probed before hand-out.
-// Gated OFF by default for codex/opencode parity — neither pings model
+// Gated OFF by default for reference-CLI parity — they do not ping model
 // sockets. Enable with MIXDOG_PROVIDER_WS_PING_ENABLED=1. When disabled, no
 // liveness interval is armed and the acquire-reuse ping probe is skipped (the
 // non-OPEN eviction scan still runs); lastAliveAt stamping is harmless.

package/src/runtime/agent/orchestrator/tools/bash-policy-scan.mjs

@@ -29,7 +29,7 @@ function _extractSubstitutionBodies(s) {
   return out;
 }
 
-export function injectionBlockTargets(cmd) {
+function injectionBlockTargets(cmd) {
   const targets = [];
   const decoded = _decodeAnsiCQuotes(cmd);
   if (decoded && decoded !== cmd) targets.push(decoded);

package/src/runtime/agent/orchestrator/tools/bash-session.mjs

@@ -52,7 +52,7 @@ import { resourceAdmission } from '../../../shared/resource-admission.mjs';
 
 globalThis.__mixdogBashSessionRuntimeLoaded = true;
 
-// Claude Code parity (refs/claude-code src/utils/timeouts.ts): default 120 s
+// Official-client parity: default 120 s
 // (2 min), max 600 s (10 min), BASH_DEFAULT_TIMEOUT_MS / BASH_MAX_TIMEOUT_MS
 // env overrides (max floored at default). Matches the one-shot bash tool
 // (builtin/bash-tool.mjs): an omitted `timeout` uses the 120 s default bounded
@@ -804,7 +804,7 @@ export async function shutdownBashSessions(reason = 'runtime-close') {
 
 // Best-effort cleanup on process exit so orphan bash children don't linger
 // when the plugin host shuts down. Self-registered exit drain; bare 'exit' hook stays as idempotent backup.
-export function drainBashSessions(reason = 'process-exit') {
+function drainBashSessions(reason = 'process-exit') {
     let closed = 0;
     for (const id of [..._sessions.keys()]) {
         if (_killSessionNow(id, reason)) closed += 1;

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

@@ -79,7 +79,7 @@ function tryCreateLock(lockFile, token) {
     return true;
 }
 
-export async function acquireAdvisoryLock(targetPath, { timeoutMs = 5000, pollMs = 25 } = {}) {
+async function acquireAdvisoryLock(targetPath, { timeoutMs = 5000, pollMs = 25 } = {}) {
     const lockFile = lockFileFor(targetPath);
     // Ensure parent directory exists before openSync('wx'); the lockfile lives
     // next to the target, so writes to new files in missing parent dirs would

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

@@ -23,12 +23,12 @@ export const GREP_CONTEXT_MAX = 200;
 // explicit requests are honored up to the generic GREP_CONTEXT_MAX; total
 // output stays bounded by the block clamp, the stream line cap, and the
 // tool-output byte cap.
-export const GREP_CTX_HEAD_LIMIT_MAX = 40;
+const GREP_CTX_HEAD_LIMIT_MAX = 40;
 
 // Unbounded (no offset/limit) plain full reads default to this window instead of
 // pulling the whole file; the read tool's ranged-read footer then hands the
 // caller the next offset to page with.
-export const READ_GUARD_DEFAULT_LIMIT = 800;
+const READ_GUARD_DEFAULT_LIMIT = 800;
 
 // Best-effort clamp notice channel: stash a one-line note on the args so a
 // surfacing consumer can echo it. Underscore-prefixed; ignored by executors.

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

@@ -57,7 +57,7 @@ function ioTraceDone(event, started, fields = {}) {
     });
 }
 
-export function atomicWriteShouldFsync(value) {
+function atomicWriteShouldFsync(value) {
     if (value === true || value === false) return value;
     return /^(1|true|yes|on|sync)$/i.test(String(process.env.MIXDOG_ATOMIC_FSYNC || ''));
 }

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

@@ -328,7 +328,7 @@ export async function executeBashTool(args, workDir, options = {}) {
     }
     // Keep foreground commands on a long tool-owned timeout. The MCP dispatch
     // layer must not add a shorter fallback ceiling when timeout is omitted.
-    // Reference-CLI parity (opencode/codex/claude-code): sync-first, no hard
+    // Reference-CLI parity: sync-first, no hard
     // upper ceiling on a caller-provided total timeout. Default 120 s (2 min)
     // when omitted; BASH_DEFAULT_TIMEOUT_MS / BASH_MAX_TIMEOUT_MS env overrides
     // bound the blocking window when timeout promotion is available.
@@ -683,156 +683,4 @@ export async function executeBashTool(args, workDir, options = {}) {
     }
 }
 
-const TERMINAL_TASK_STATUSES = new Set(['completed', 'failed', 'cancelled']);
-
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function shellJobToTaskStatus(status) {
-    if (status === 'completed') return 'completed';
-    if (status === 'cancelled') return 'cancelled';
-    if (status === 'running') return 'running';
-    return 'failed';
-}
-
-function refreshShellTask(taskId, { includeRunning = false } = {}) {
-    const job = peekShellJob(taskId);
-    if (!job) return null;
-    const publicResult = shellJobPublicTaskResult(job);
-    if (job.status !== 'running') {
-        completeBackgroundTask(taskId, {
-            status: shellJobToTaskStatus(job.status),
-            result: publicResult,
-            resultText: JSON.stringify(publicResult, null, 2),
-            notify: false,
-        });
-    } else if (includeRunning) {
-        const task = getBackgroundTask(taskId);
-        if (task) {
-            task.result = publicResult;
-            task.resultText = JSON.stringify(publicResult, null, 2);
-        }
-    }
-    return job;
-}
-
-async function waitForGenericTask(taskId, { timeoutMs = 30_000, pollMs = 250, context = {} } = {}) {
-    const started = Date.now();
-    const deadline = started + Math.max(0, Number(timeoutMs) || 0);
-    let task = getBackgroundTask(taskId, { context });
-    if (!task) return null;
-    while (task && task.status === 'running' && Date.now() < deadline) {
-        await sleep(Math.max(25, Number(pollMs) || 250));
-        task = getBackgroundTask(taskId, { context });
-    }
-    return {
-        task,
-        waitedMs: Date.now() - started,
-        waitTimedOut: Boolean(task && task.status === 'running'),
-    };
-}
-
-function renderTaskCancelSuccess(taskId, task) {
-    const surface = task?.surface || 'task';
-    const operation = task?.operation || 'run';
-    return [
-        'status: completed',
-        `task_id: ${taskId}`,
-        `cancelled: ${surface}/${operation}`,
-    ].join('\n');
-}
-
-export async function executeTaskTool(args, options = {}) {
-    const action = typeof args.action === 'string' ? args.action.toLowerCase() : (args.task_id ? 'wait' : 'list');
-    if (action === 'list') return renderBackgroundTaskList({ context: options });
-
-    const taskId = typeof args.task_id === 'string' ? args.task_id.trim() : '';
-    if (!taskId) return 'Error: task_id is required';
-    // sess_* values are agent/orchestrator session ids, not background shell
-    // tasks. task only resolves `shell mode=async` tasks, so surface a
-    // self-correcting hint instead of the bare "task not found" that otherwise
-    // invites a wrong-tool retry loop.
-    if (/^sess_/.test(taskId)) {
-        return `Error: "${taskId}" is an agent/session id, not a background task_id. Agent tasks deliver completion notifications; use agent list/read only for manual recovery.`;
-    }
-
-    const task = getBackgroundTask(taskId, { context: options });
-    if (!task) return `Error: task not found: ${taskId}`;
-    const isShellTask = task.surface === 'shell';
-
-    if (action === 'status' || action === 'read') {
-        if (isShellTask) refreshShellTask(taskId, { includeRunning: action === 'read' });
-        const latest = getBackgroundTask(taskId, { context: options }) || task;
-        return renderBackgroundTask(latest, { includeResult: action === 'read' });
-    }
-
-    if (action === 'cancel') {
-        if (isShellTask) {
-            const job = killShellJob(taskId);
-            cancelBackgroundShellJobWatch(taskId);
-            clearShellJobNotifyCtx(taskId);
-            cancelBackgroundTask(taskId, 'cancelled by task control');
-            return job ? renderTaskCancelSuccess(taskId, getBackgroundTask(taskId, { context: options }) || task) : buildJobNotFoundMessage(taskId);
-        }
-        cancelBackgroundTask(taskId, 'cancelled by task control');
-        return renderTaskCancelSuccess(taskId, getBackgroundTask(taskId, { context: options }) || task);
-    }
-
-    if (action !== 'wait') {
-        return `Error: task action must be one of list|status|read|wait|cancel (got ${JSON.stringify(args.action)})`;
-    }
-
-    if (!isShellTask) {
-        const waited = await waitForGenericTask(taskId, {
-            timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : 30_000,
-            pollMs: typeof args.poll_ms === 'number' ? args.poll_ms : 250,
-            context: options,
-        });
-        if (!waited?.task) return `Error: task not found: ${taskId}`;
-        const rendered = renderBackgroundTask(waited.task, { includeResult: TERMINAL_TASK_STATUSES.has(waited.task.status) });
-        return waited.waitTimedOut ? `${rendered}\nwait_timed_out: true\nwaited_ms: ${waited.waitedMs}` : rendered;
-    }
-    // Register as a synchronous waiter and cancel the armed watcher BEFORE
-    // awaiting: the caller consumes the outcome via task wait, so no async
-    // push is wanted, and cancelling up front closes the race where the armed
-    // watcher (watch callback or 2s poll) fires during the await window. The
-    // persistent notify ctx survives the cancel for a possible re-arm.
-    beginShellJobWait(taskId);
-    cancelBackgroundShellJobWatch(taskId);
-    try {
-        const job = await waitForShellJob(taskId, {
-            timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : 30_000,
-            pollMs: typeof args.poll_ms === 'number' ? args.poll_ms : 250,
-        });
-        if (!job) return buildJobNotFoundMessage(taskId);
-        if (job.status !== 'running') {
-            const publicResult = shellJobPublicTaskResult(job);
-            completeBackgroundTask(taskId, {
-                status: shellJobToTaskStatus(job.status),
-                result: publicResult,
-                resultText: JSON.stringify(publicResult, null, 2),
-                notify: false,
-            });
-        }
-        const latest = getBackgroundTask(taskId, { context: options }) || task;
-        const rendered = renderBackgroundTask(latest, { includeResult: job.status !== 'running' });
-        return job.status === 'running' ? `${rendered}\nwait_timed_out: true\nwaited_ms: ${job.waitedMs}` : rendered;
-    } finally {
-        // Only the LAST concurrent waiter (post-decrement count 0) may re-arm,
-        // and only for a still-running job (timed-out wait). Re-arm with no ctx
-        // arg — watchBackgroundShellJob falls back to the persistent ctx. This
-        // prevents the concurrent-waiter double-deliver: while any other waiter
-        // is still synchronously consuming the outcome, the watcher stays off.
-        const remaining = endShellJobWait(taskId);
-        if (remaining === 0) {
-            const latest = peekShellJob(taskId);
-            if (latest && latest.status === 'running') watchBackgroundShellJob(taskId);
-            // LAST waiter out and the job already finished — the outcome was
-            // consumed synchronously, so no re-arm. Drop the persisted ctx here
-            // or it leaks (cleanup only runs on a real watcher settle, which
-            // never happens for a never-re-armed entry).
-            else clearShellJobNotifyCtx(taskId);
-        }
-    }
-}
+export { executeTaskTool } from './task-tool.mjs';

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

@@ -79,7 +79,7 @@ function bumpPathMutationGeneration(path) {
     }
 }
 
-export function getPathMutationGeneration(path) {
+function getPathMutationGeneration(path) {
     const key = canonicalCachePath(path);
     let generation = PATH_MUTATION_GLOBAL_GENERATION;
     for (const [changedPath, value] of PATH_MUTATION_GENERATIONS) {

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

@@ -6,7 +6,7 @@ import {
     resolveAgainstCwd,
 } from './path-utils.mjs';
 
-export function literalPathHint(rawPath) {
+function literalPathHint(rawPath) {
     const s = String(rawPath || '');
     if (/\$env:[A-Za-z_][A-Za-z0-9_]*|\$[A-Za-z_][A-Za-z0-9_]*|%[^%]+%/.test(s)) {
         return ' Path fields do not expand shell environment variables; pass the resolved absolute path.';

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

@@ -12,7 +12,7 @@
 // logic is unchanged; we only refuse to enter it when the path is unreachable.
 import { stat } from 'node:fs/promises';
 
-export const FS_REACHABILITY_DEADLINE_MS = 5000;
+const FS_REACHABILITY_DEADLINE_MS = 5000;
 
 // Resolve true when the path is reachable (exists OR cleanly absent — ENOENT,
 // EACCES, etc. are "the FS answered", let the real sync logic produce its own

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

@@ -85,7 +85,7 @@ function prepareFuzzyScore(query) {
  * @param {string} str     candidate path (relative)
  * @returns {number|null}  score, or null if `query` is not a subsequence
  */
-export function fuzzyScore(query, str) {
+function fuzzyScore(query, str) {
     const scorer = prepareFuzzyScore(query);
     return typeof scorer === 'function' ? scorer(str) : scorer;
 }

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

@@ -124,7 +124,7 @@ export const NOISE_DIR_NAMES = new Set([
     '.gradle',
 ]);
 
-export const MAX_WALK_ENTRIES = 200_000;
+const MAX_WALK_ENTRIES = 200_000;
 
 // Unified directory walk used by list / tree / find_files. The visitor
 // callback owns the "should I record this entry?" decision; returning

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

@@ -2,7 +2,7 @@
 // chain so that overlapping calls for the same file are serialised in-process.
 const editLocks = new Map();
 
-export function pathLockKey(absPath) {
+function pathLockKey(absPath) {
     const text = String(absPath || '');
     return process.platform === 'win32' ? text.toLowerCase() : text;
 }

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

@@ -35,7 +35,7 @@ export function posixPathToWindowsPath(posixPath) {
 // a literal under WSL — the drive surfaces at `/mnt/<letter>/...`. Map
 // `<drive>:` → `/mnt/<lowercase-drive>` and flip backslashes to slashes. Only
 // drive-letter paths are touched; anything else is returned unchanged.
-export function windowsPathToPosixPath(winPath) {
+function windowsPathToPosixPath(winPath) {
     if (typeof winPath !== 'string') return winPath;
     const m = winPath.match(/^([a-zA-Z]):[\\/](.*)$/);
     if (m) return `/mnt/${m[1].toLowerCase()}/${m[2].replace(/\\/g, '/')}`;

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

@@ -6,7 +6,7 @@ export function parseReadLineNumberArg(value) {
     return Number.isFinite(n) && n > 0 ? Math.trunc(n) : null;
 }
 
-export function parseReadPathLineSpec(rawPath) {
+function parseReadPathLineSpec(rawPath) {
     if (typeof rawPath !== 'string' || rawPath.length === 0) return null;
     const text = rawPath.trim();
     let m = /^(.+?)#L(\d+)(?:-L?(\d+))?(?:\b.*)?$/i.exec(text);
@@ -23,7 +23,7 @@ export function parseReadPathLineSpec(rawPath) {
     return { path: m[1], lineNo, endLine, inverted, invertedEnd: inverted ? endLineRaw : null };
 }
 
-export function resolveExistingPathLineCoordinate(rawPath, workDir) {
+function resolveExistingPathLineCoordinate(rawPath, workDir) {
     const spec = parseReadPathLineSpec(rawPath);
     if (!spec) return null;
     const normalizedRawPath = normalizeInputPath(rawPath);

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

@@ -18,8 +18,7 @@ export const SMART_READ_TAIL_LINES = _readEnvInt('MIXDOG_READ_TAIL_LINES', 400);
 // floor mostly fired on full:true mid-size reads where the advisory was pure
 // tail bloat. Raised to 40 KB to keep the guidance only where re-reading a big
 // file actually hurts.
-export const READ_CONTEXT_ADVISORY_BYTES = 40 * 1024;
-export const READ_MAX_RENDERED_LINE_CHARS = 2_000;
+const READ_MAX_RENDERED_LINE_CHARS = 2_000;
 // The read line-prefix separator is `→` (the `→`
 // arrow), matching default cat -n format `<n>→<content>`. It
 // MUST be a NON-WHITESPACE glyph: a tab/space separator collides with the
@@ -84,7 +83,7 @@ export function appendReadContextAdvisory(out, { filePath: _filePath, lineCount:
     return out;
 }
 
-export function formatPaginationHint(remaining, nextOffset) {
+function formatPaginationHint(remaining, nextOffset) {
     const n = Number(remaining);
     const label = Number.isFinite(n) && n > 0 ? `${n} more entries` : 'more entries';
     return `... [${label}; next offset: ${nextOffset}]`;

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

@@ -13,13 +13,13 @@
 // that stays under that cap after the 4/3 base64 inflation.
 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
-export const IMAGE_MAX_WIDTH = 2000;
-export const IMAGE_MAX_HEIGHT = 2000;
+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
 // dimension/raw-size resize governs the common case and the token gate only
 // fires on pathologically dense images.
-export const DEFAULT_IMAGE_MAX_TOKENS = Math.ceil(API_IMAGE_MAX_BASE64_SIZE * 0.125);
+const DEFAULT_IMAGE_MAX_TOKENS = Math.ceil(API_IMAGE_MAX_BASE64_SIZE * 0.125);
 
 // Cached dynamic import. Resolves to the sharp factory or null (absent /
 // failed). Cached so repeated reads don't re-attempt a failing import.
@@ -39,7 +39,7 @@ async function loadSharp() {
 }
 
 // True when sharp resolved; used for the per-file change summary / fallback note.
-export async function sharpAvailable() {
+async function sharpAvailable() {
     return (await loadSharp()) !== null;
 }
 

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

@@ -106,7 +106,7 @@ export function readPathStringGuardError(filePath, workDir) {
 }
 
 /** Post-stat / symlink guards. Returns error message or null. */
-export function readPathStatGuardError(userPath, fullPath, st) {
+function readPathStatGuardError(userPath, fullPath, st) {
     if (isSpecialFileStat(st)) {
         return `cannot read special file (FIFO / character / block device / socket): ${normalizeOutputPath(userPath)}`;
     }

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

@@ -225,7 +225,7 @@ export async function streamReadRange(fullPath, offset, limit, stHint = null, ho
     return { text: out, firstEmitted, lastEmitted, prefixHash };
 }
 
-export function tryWindowedSmartReadSummary(fullPath, st, source = 'read_smart_stream', hooks = {}) {
+function tryWindowedSmartReadSummary(fullPath, st, source = 'read_smart_stream', hooks = {}) {
     const { ioTraceStart, ioTraceDone } = streamingHooks(hooks);
     const displayPath = hooks.displayPath || fullPath;
     const traceStart = ioTraceStart();

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

@@ -81,7 +81,7 @@ function _walkRgArgs(argsList, visit) {
 // is the NEXT arg, short-attached (`-j8`), and long-attached (`--threads=8`).
 // Used by both the _withRgThreads injection guard and the EAGAIN retry guard
 // so the two never disagree.
-export function _hasRgThreadArg(argsList) {
+function _hasRgThreadArg(argsList) {
     let found = false;
     _walkRgArgs(argsList, (a, _index, _valueIndex, options) => {
         if (!options || typeof a !== 'string') return;
@@ -121,7 +121,7 @@ export function _rgEagainRetryArgs(argsList) {
 // retry would change nothing. Matches the separated `-j 1` / `--threads 1` form
 // and the attached `-j1` / `--threads=1` form. Any other thread pin (e.g. -j8)
 // is NOT "single-thread pinned": the retry should still run and downshift it.
-export function _isRgSingleThreadPinned(argsList) {
+function _isRgSingleThreadPinned(argsList) {
     let found = false;
     _walkRgArgs(argsList, (a, _index, valueIndex, options) => {
         if (!options || typeof a !== 'string') return;

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

@@ -65,7 +65,7 @@ export function stripEmbeddedPathQuotes(p) {
 // must not trigger same-basename guidance or the BFS scan.
 const NOT_FOUND_CODES = new Set(['ENOENT', 'ENOTDIR']);
 
-export const ENOENT_FIND_NUDGE = 'Locate with find on the basename before retrying.';
+const ENOENT_FIND_NUDGE = 'Locate with find on the basename before retrying.';
 
 // Per-invocation memo for the ENOENT recovery fs scans. A single grep/glob
 // ENOENT surfaces the SAME missing path through tryReadFamilyEnoentRedirect
@@ -109,7 +109,7 @@ function nearestExistingParentRel(workDir, missingPath) {
     return null;
 }
 
-export function spaceJoinedPathHint(requestedPath) {
+function spaceJoinedPathHint(requestedPath) {
     if (typeof requestedPath !== 'string') return '';
     const trimmed = requestedPath.trim();
     if (!/\s/.test(trimmed)) return '';
@@ -118,7 +118,7 @@ export function spaceJoinedPathHint(requestedPath) {
     return ' Pass multiple scopes as path[] array (not a space-joined string).';
 }
 
-export function appendEnoentFindNudge(text = '') {
+function appendEnoentFindNudge(text = '') {
     const base = String(text || '');
     if (base.includes(ENOENT_FIND_NUDGE)) return base;
     const sep = base.length && !/\s$/.test(base) ? ' ' : '';
@@ -130,7 +130,7 @@ export function finalizeReadFamilyEnoentTail(hint, requestedPath, errCode = 'ENO
     return appendEnoentFindNudge(String(hint || '') + spaceJoinedPathHint(requestedPath));
 }
 
-export function resolveUniqueEnoentRedirect(workDir, missingPath, errCode = 'ENOENT', cache = null) {
+function resolveUniqueEnoentRedirect(workDir, missingPath, errCode = 'ENOENT', cache = null) {
     if (!NOT_FOUND_CODES.has(String(errCode || 'ENOENT'))) return null;
     const suffixHit = cachedSuffixStrip(workDir, missingPath, cache);
     if (suffixHit) return suffixHit;
@@ -143,7 +143,7 @@ export function resolveUniqueEnoentRedirect(workDir, missingPath, errCode = 'ENO
     return null;
 }
 
-export function redirectedFromPrefix(requestedPath) {
+function redirectedFromPrefix(requestedPath) {
     return `[redirected from ${normalizeOutputPath(requestedPath)}]\n`;
 }
 

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

@@ -761,7 +761,7 @@ export async function analyzeShellCommandEffects(command, cwd) {
 // its deadline. Only the first top-level segment is considered — sleeps inside
 // pipelines/subshells/scripts are legitimate pacing and pass through. Float
 // durations (sleep 0.5) are allowed, mirroring the reference CLI.
-export function detectBlockedSleepPattern(command) {
+function detectBlockedSleepPattern(command) {
     const cmd = String(command || '').trim();
     if (!cmd) return null;
     const sep = cmd.match(/&&|\|\||;|\|/);

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

@@ -13,7 +13,7 @@ const SHELL_JOB_SPILL_KEEP_BYTES = 4 * 1024 * 1024;
 // Tail-trim a single spill log in place: if it exceeds maxBytes, rewrite it
 // keeping only the last keepBytes. Sync, best-effort, no-op on a missing file.
 // Mirrors rotateBoundedLog in src/lib/mixdog-debug.cjs. Returns true if trimmed.
-export function trimShellJobSpillFile(filePath, maxBytes = SHELL_JOB_SPILL_MAX_BYTES, keepBytes = SHELL_JOB_SPILL_KEEP_BYTES) {
+function trimShellJobSpillFile(filePath, maxBytes = SHELL_JOB_SPILL_MAX_BYTES, keepBytes = SHELL_JOB_SPILL_KEEP_BYTES) {
     try {
         const st = statSync(filePath);
         if (st.size <= maxBytes) return false;
@@ -214,7 +214,7 @@ export function shellJobEnforcedPath(jobId) { return join(getShellJobsDir(), `${
 // precede its per-tick scan cap — otherwise other sessions' newer jobs evict
 // this session's live jobs before filtering. Swept alongside the other
 // artefacts.
-export function shellJobOwnerPath(jobId, pid) { return join(getShellJobsDir(), `${jobId}.owner-${pid}`); }
+function shellJobOwnerPath(jobId, pid) { return join(getShellJobsDir(), `${jobId}.owner-${pid}`); }
 
 // Resolve the CLI host pid that owns a freshly-spawned job. Standalone CLI
 // execution is process-owned: background tasks are scoped to this CLI lifetime,

package/src/runtime/agent/orchestrator/tools/builtin/shell-job-process.mjs

@@ -20,7 +20,7 @@ export function isPidAlive(pid) {
 // detached group. Windows has no process-group probe in Node; the root PID is
 // the strongest non-invasive lifecycle signal available here (tree-kill still
 // uses taskkill /T).
-export function isProcessTreeAlive(pid) {
+function isProcessTreeAlive(pid) {
     if (!Number.isFinite(pid) || pid <= 0) return false;
     if (process.platform === 'win32') return isPidAlive(pid);
     try {
@@ -301,7 +301,7 @@ export function _killLiveJobPid(pid, { sync = false } = {}) {
         return false;
     }
 }
-export function _sweepLiveJobsSync() {
+function _sweepLiveJobsSync() {
     for (const pid of _liveJobPids) {
         _killLiveJobPid(pid, { sync: true });
     }