mixdog 0.8.0 → 0.9.0

package/src/runtime/agent/orchestrator/{bridge-trace.mjs → agent-trace.mjs}

@@ -32,12 +32,24 @@ const _LOCAL_TRACE_FLUSH_MS = 1000;
 const _LOCAL_TRACE_MAX_BYTES = 10 * 1024 * 1024; // 10 MB — rotate to .1 above this.
 const _TOOL_FAILURE_FLUSH_LINES = 50;
 const _TOOL_FAILURE_FLUSH_MS = 1000;
+const MIXDOG_SLOW_TOOL_TRACE_MS = (() => {
+    const v = parseInt(process.env.MIXDOG_SLOW_TOOL_TRACE_MS, 10);
+    return Number.isFinite(v) && v > 0 ? v : 3000;
+})();
+const MIXDOG_SLOW_TOOL_TRACE_NAMES_RAW = String(process.env.MIXDOG_SLOW_TOOL_TRACE_NAMES || 'recall,grep,code_graph');
+const MIXDOG_SLOW_TOOL_TRACE_ALL = MIXDOG_SLOW_TOOL_TRACE_NAMES_RAW.trim() === '*';
+const MIXDOG_SLOW_TOOL_TRACE_NAMES = new Set(
+    MIXDOG_SLOW_TOOL_TRACE_NAMES_RAW
+        .split(',')
+        .map((name) => name.trim())
+        .filter(Boolean)
+);
 // Throttle interval for local rotation stat checks. statSync on every flush
 // is unnecessary — rotation is a best-effort size guard. First flush always
 // checks; subsequent checks wait at least this many ms. Tune via env
-// MIXDOG_BRIDGE_TRACE_ROTATE_CHECK_MS (default 60000 ms, positive integer).
-const MIXDOG_BRIDGE_TRACE_ROTATE_CHECK_MS = (() => {
-    const v = parseInt(process.env.MIXDOG_BRIDGE_TRACE_ROTATE_CHECK_MS, 10);
+// MIXDOG_AGENT_TRACE_ROTATE_CHECK_MS (default 60000 ms, positive integer).
+const MIXDOG_AGENT_TRACE_ROTATE_CHECK_MS = (() => {
+    const v = parseInt(process.env.MIXDOG_AGENT_TRACE_ROTATE_CHECK_MS, 10);
     return Number.isFinite(v) && v > 0 ? v : 60000;
 })();
 let _lastRotateCheckMs = 0;
@@ -49,7 +61,7 @@ function _rotateLocalTraceIfNeeded(path) {
         if (stat && stat.size > _LOCAL_TRACE_MAX_BYTES) {
             try { renameSync(path, `${path}.1`); }
             catch (err) {
-                warnBridgeOnce('bridge-trace:local-rotate', `[bridge-trace] local rotate failed (${err?.message})`);
+                warnAgentOnce('agent-trace:local-rotate', `[agent-trace] local rotate failed (${err?.message})`);
             }
         }
     } catch {
@@ -58,11 +70,11 @@ function _rotateLocalTraceIfNeeded(path) {
 }
 
 function _resolveLocalTracePath() {
-    if (process.env.MIXDOG_BRIDGE_TRACE_LOCAL_DISABLE === '1') return null;
+    if (process.env.MIXDOG_AGENT_TRACE_LOCAL_DISABLE === '1') return null;
     if (_localTracePath) return _localTracePath;
     try {
-        _localTracePath = process.env.MIXDOG_BRIDGE_TRACE_PATH
-            || join(getPluginData(), 'history', 'bridge-trace.jsonl');
+        _localTracePath = process.env.MIXDOG_AGENT_TRACE_PATH
+            || join(getPluginData(), 'history', 'agent-trace.jsonl');
         // R4 data-at-rest: trace rows may carry tool payloads / prompts;
         // clamp dir to owner-only on POSIX (advisory on Windows).
         mkdirSync(dirname(_localTracePath), { recursive: true, mode: 0o700 });
@@ -83,7 +95,7 @@ function _appendLocalTrace(row) {
             _localTraceTimer.unref?.();
         }
     } catch (err) {
-        warnBridgeOnce('bridge-trace:local-spool', `[bridge-trace] local spool failed (${err?.message})`);
+        warnAgentOnce('agent-trace:local-spool', `[agent-trace] local spool failed (${err?.message})`);
     }
 }
 
@@ -106,12 +118,12 @@ function _flushLocalTrace() {
         // Throttle rotation stat checks to avoid unnecessary statSync calls
         // on every flush. First flush (_lastRotateCheckMs === 0) always checks.
         const now = Date.now();
-        if (_lastRotateCheckMs === 0 || now - _lastRotateCheckMs >= MIXDOG_BRIDGE_TRACE_ROTATE_CHECK_MS) {
+        if (_lastRotateCheckMs === 0 || now - _lastRotateCheckMs >= MIXDOG_AGENT_TRACE_ROTATE_CHECK_MS) {
             _rotateLocalTraceIfNeeded(path);
             _lastRotateCheckMs = now;
         }
     } catch (err) {
-        warnBridgeOnce('bridge-trace:local-spool', `[bridge-trace] local spool failed (${err?.message})`);
+        warnAgentOnce('agent-trace:local-spool', `[agent-trace] local spool failed (${err?.message})`);
         return;
     }
     // mode only applies on file creation; existing files keep their mode.
@@ -119,7 +131,7 @@ function _flushLocalTrace() {
     _localTraceFlushInFlight = true;
     appendFile(path, chunk, { encoding: 'utf8', mode: 0o600 })
         .catch((err) => {
-            warnBridgeOnce('bridge-trace:local-spool', `[bridge-trace] local spool failed (${err?.message})`);
+            warnAgentOnce('agent-trace:local-spool', `[agent-trace] local spool failed (${err?.message})`);
         })
         .finally(() => {
             _localTraceFlushInFlight = false;
@@ -142,13 +154,13 @@ function _flushLocalTraceSync() {
     _localTraceBuffer = [];
     try {
         const now = Date.now();
-        if (_lastRotateCheckMs === 0 || now - _lastRotateCheckMs >= MIXDOG_BRIDGE_TRACE_ROTATE_CHECK_MS) {
+        if (_lastRotateCheckMs === 0 || now - _lastRotateCheckMs >= MIXDOG_AGENT_TRACE_ROTATE_CHECK_MS) {
             _rotateLocalTraceIfNeeded(path);
             _lastRotateCheckMs = now;
         }
         appendFileSync(path, chunk, { encoding: 'utf8', mode: 0o600 });
     } catch (err) {
-        warnBridgeOnce('bridge-trace:local-spool', `[bridge-trace] local spool failed (${err?.message})`);
+        warnAgentOnce('agent-trace:local-spool', `[agent-trace] local spool failed (${err?.message})`);
     }
 }
 
@@ -187,7 +199,7 @@ async function _flush() {
     _flushTimer = null;
     if (_buffer.length === 0) return;
     if (_flushInFlight) {
-        if (!_flushTimer) _flushTimer = setTimeout(_flush, _FLUSH_INTERVAL_MS);
+        if (!_flushTimer) { _flushTimer = setTimeout(_flush, _FLUSH_INTERVAL_MS); _flushTimer.unref?.(); }
         return;
     }
     _flushInFlight = true;
@@ -195,7 +207,7 @@ async function _flush() {
         const url = _resolveServiceUrl();
         if (!url) {
             // Service not up yet — keep buffer, retry next timer tick
-            if (!_flushTimer) _flushTimer = setTimeout(_flush, _FLUSH_INTERVAL_MS);
+            if (!_flushTimer) { _flushTimer = setTimeout(_flush, _FLUSH_INTERVAL_MS); _flushTimer.unref?.(); }
             return;
         }
         const batch = _buffer.splice(0, _FLUSH_BATCH_SIZE);
@@ -206,12 +218,17 @@ async function _flush() {
                 body: JSON.stringify({ events: batch }),
                 signal: AbortSignal.timeout(5000),
             });
+            // Always drain the body. An undrained response body keeps the
+            // underlying keep-alive socket referenced, which can hold the event
+            // loop open and make a short-lived process (smoke scripts / one-shot
+            // agent tasks) appear to hang for seconds after its work is done.
+            try { await resp.arrayBuffer(); } catch { /* body already gone */ }
             if (!resp.ok) {
-                warnBridgeOnce('bridge-trace:flush-error', `[bridge-trace] /admin/trace-record returned ${resp.status} — dropping batch`);
+                warnAgentOnce('agent-trace:flush-error', `[agent-trace] /admin/trace-record returned ${resp.status} — dropping batch`);
             }
         } catch (err) {
             _serviceUrl = null;
-            warnBridgeOnce('bridge-trace:flush-fetch', `[bridge-trace] flush fetch failed (${err?.message}) — dropping batch`);
+            warnAgentOnce('agent-trace:flush-fetch', `[agent-trace] flush fetch failed (${err?.message}) — dropping batch`);
         }
         if (_buffer.length >= _FLUSH_BATCH_SIZE) {
             // More pending — schedule another flush immediately
@@ -228,25 +245,31 @@ function _scheduleFlush(immediate = false) {
         setImmediate(_flush);
     } else if (!_flushTimer) {
         _flushTimer = setTimeout(_flush, _FLUSH_INTERVAL_MS);
+        // Never let the periodic trace flush keep the event loop alive: a
+        // ref'd 5s timer prevented short-lived processes (smoke scripts, agent
+        // tasks) from exiting naturally after their work was done — they hung
+        // until an external timeout/kill. exit/beforeExit drains still flush
+        // the buffer, so unref loses no data.
+        _flushTimer.unref?.();
     }
 }
 
-async function drainBridgeTrace() {
+async function drainAgentTrace() {
     if (!_resolveServiceUrl()) return;
     if (_flushTimer) { clearTimeout(_flushTimer); _flushTimer = null; }
     for (let i = 0; i < 10 && _buffer.length > 0; i++) {
         await _flush();
     }
 }
-process.on('exit', drainBridgeTrace);
+process.on('exit', drainAgentTrace);
 
 function normalizeSessionId(sessionId) {
     return sessionId ? String(sessionId) : 'no-session';
 }
 
-function appendBridgeTrace(record = {}) {
+function appendAgentTrace(record = {}) {
     // Test isolation — when run-all-tests.mjs sets this env, skip entirely.
-    if (process.env.MIXDOG_BRIDGE_TRACE_DISABLE === '1') return;
+    if (process.env.MIXDOG_AGENT_TRACE_DISABLE === '1') return;
     try {
         // Coerce ts to epoch ms integer at enqueue time
         let ts = record.ts || Date.now();
@@ -265,14 +288,14 @@ function appendBridgeTrace(record = {}) {
 
         if (_buffer.length >= _BUFFER_MAX) {
             _buffer.shift(); // drop oldest
-            warnBridgeOnce('bridge-trace:buffer-full', '[bridge-trace] buffer full (2000) — dropping oldest event');
+            warnAgentOnce('agent-trace:buffer-full', '[agent-trace] buffer full (2000) — dropping oldest event');
         }
         _appendLocalTrace(row);
         _buffer.push(row);
         _scheduleFlush(_buffer.length >= _FLUSH_BATCH_SIZE);
     }
     catch {
-        // Never break bridge execution for telemetry
+        // Never break agent execution for telemetry
     }
 }
 
@@ -299,7 +322,7 @@ function extractCachedTokens(usage) {
     return 0;
 }
 
-function warnBridgeOnce(key, message) {
+function warnAgentOnce(key, message) {
     if (!key || WARNED_KEYS.has(key)) return;
     WARNED_KEYS.add(key);
     try {
@@ -310,9 +333,9 @@ function warnBridgeOnce(key, message) {
     }
 }
 
-function traceBridgeLoop({ sessionId, iteration, sendMs, messageCount, bodyBytesEst }) {
-    if (process.env.MIXDOG_BRIDGE_TRACE_VERBOSE !== '1') return;
-    appendBridgeTrace({
+function traceAgentLoop({ sessionId, iteration, sendMs, messageCount, bodyBytesEst }) {
+    if (process.env.MIXDOG_AGENT_TRACE_VERBOSE !== '1') return;
+    appendAgentTrace({
         sessionId,
         iteration,
         kind: 'loop',
@@ -336,10 +359,11 @@ function messagePrefixHash(messages) {
     }
 }
 
-function traceBridgeCompact({
+function traceAgentCompact({
     sessionId,
     iteration,
     stage,
+    trigger,
     prune_count,
     compact_changed,
     input_prefix_hash,
@@ -356,12 +380,13 @@ function traceBridgeCompact({
     error,
     error_code,
 }) {
-    if (process.env.MIXDOG_BRIDGE_TRACE_VERBOSE !== '1') return;
-    appendBridgeTrace({
+    if (process.env.MIXDOG_AGENT_TRACE_VERBOSE !== '1') return;
+    appendAgentTrace({
         sessionId,
         iteration,
         kind: 'compact_meta',
         stage: stage || null,
+        trigger: trigger || null,
         prune_count: prune_count ?? 0,
         compact_changed: !!compact_changed,
         input_prefix_hash: input_prefix_hash || null,
@@ -383,8 +408,12 @@ function traceBridgeCompact({
 const TOOL_ARG_KEYS = {
     read: ['path', 'offset', 'limit', 'line', 'context', 'symbol'],
     grep: ['pattern', 'path', 'glob', 'output_mode', 'head_limit', 'offset'],
-    glob: ['pattern', 'path', 'head_limit', 'offset'],
-    list: ['path', 'head_limit', 'offset', 'fuzzy'],
+    glob: ['pattern', 'path', 'head_limit', 'offset', 'sort'],
+    find: ['query', 'path', 'head_limit'],
+    list: ['path', 'head_limit', 'offset'],
+    recall: ['query', 'limit', 'session_id', 'cwd'],
+    search: ['query', 'limit', 'cwd'],
+    explore: ['query', 'queries', 'limit', 'cwd'],
     code_graph: ['mode', 'file', 'symbol', 'symbols', 'body', 'language', 'limit', 'depth', 'page', 'cwd'],
     shell: ['command', 'cwd', 'timeout', 'mode', 'run_in_background', 'persistent', 'session_id'],
     task: ['task_id', 'action', 'timeout_ms', 'poll_ms'],
@@ -480,7 +509,7 @@ function _scheduleToolFailureFlush(delayMs = _TOOL_FAILURE_FLUSH_MS) {
 
 function _maybeRotateToolFailureLog(path) {
     const now = Date.now();
-    if (_lastToolFailureRotateCheckMs !== 0 && now - _lastToolFailureRotateCheckMs < MIXDOG_BRIDGE_TRACE_ROTATE_CHECK_MS) return;
+    if (_lastToolFailureRotateCheckMs !== 0 && now - _lastToolFailureRotateCheckMs < MIXDOG_AGENT_TRACE_ROTATE_CHECK_MS) return;
     _rotateLocalTraceIfNeeded(path);
     _lastToolFailureRotateCheckMs = now;
 }
@@ -495,7 +524,7 @@ function _appendToolFailureRow(row) {
             _scheduleToolFailureFlush();
         }
     } catch (err) {
-        warnBridgeOnce('tool-failure-log:append', `[tool-failure-log] append failed (${err?.message})`);
+        warnAgentOnce('tool-failure-log:append', `[tool-failure-log] append failed (${err?.message})`);
     }
 }
 
@@ -516,12 +545,12 @@ function _flushToolFailures() {
     try {
         _maybeRotateToolFailureLog(path);
     } catch (err) {
-        warnBridgeOnce('tool-failure-log:rotate', `[tool-failure-log] rotate check failed (${err?.message})`);
+        warnAgentOnce('tool-failure-log:rotate', `[tool-failure-log] rotate check failed (${err?.message})`);
     }
     _toolFailureFlushInFlight = true;
     appendFile(path, chunk, { encoding: 'utf8', mode: 0o600 })
         .catch((err) => {
-            warnBridgeOnce('tool-failure-log:append', `[tool-failure-log] append failed (${err?.message})`);
+            warnAgentOnce('tool-failure-log:append', `[tool-failure-log] append failed (${err?.message})`);
         })
         .finally(() => {
             _toolFailureFlushInFlight = false;
@@ -543,7 +572,7 @@ function _flushToolFailuresSync() {
         _maybeRotateToolFailureLog(path);
         appendFileSync(path, chunk, { encoding: 'utf8', mode: 0o600 });
     } catch (err) {
-        warnBridgeOnce('tool-failure-log:append', `[tool-failure-log] append failed (${err?.message})`);
+        warnAgentOnce('tool-failure-log:append', `[tool-failure-log] append failed (${err?.message})`);
     }
 }
 
@@ -572,8 +601,8 @@ function classifyToolFailure(resultText, toolName) {
     return 'runtime/failure';
 }
 
-function traceBridgeToolFailure({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, role, model, cwd, resultText, resultKind = 'error' }) {
-    if (process.env.MIXDOG_BRIDGE_TRACE_DISABLE === '1') return;
+function traceAgentToolFailure({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, role, model, cwd, resultText, resultKind = 'error' }) {
+    if (process.env.MIXDOG_AGENT_TRACE_DISABLE === '1') return;
     if (!_resolveToolFailurePath()) return;
     try {
         const cleanText = _redactLogText(String(resultText ?? ''));
@@ -597,17 +626,21 @@ function traceBridgeToolFailure({ sessionId, iteration, toolName, toolKind, tool
         };
         _appendToolFailureRow(row);
     } catch (err) {
-        warnBridgeOnce('tool-failure-log:append', `[tool-failure-log] append failed (${err?.message})`);
+        warnAgentOnce('tool-failure-log:append', `[tool-failure-log] append failed (${err?.message})`);
     }
 }
 
-function traceBridgeTool({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, role, resultKind, model, resultText, cwd }) {
+function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, role, resultKind, model, resultText, cwd }) {
     const nextCallCount = countJsonNextCalls(resultText);
-    // Flat shape — fields named exactly as the bridge_calls PG columns so
-    // insertBridgeCalls can pick them up by direct property access without
+    const resultBytesEst = typeof resultText === 'string' ? Buffer.byteLength(resultText, 'utf8') : 0;
+    const resultLinesEst = typeof resultText === 'string' && resultText.length > 0 ? resultText.split('\n').length : 0;
+    const numericToolMs = Number(toolMs);
+    const summarizedArgs = summarizeToolArgs(toolName, toolArgs);
+    // Flat shape — fields named exactly as the agent_calls PG columns so
+    // insertAgentCalls can pick them up by direct property access without
     // a payload-unwrap step. result_kind has no column and rides as plain
     // sibling metadata for downstream consumers.
-    appendBridgeTrace({
+    appendAgentTrace({
         sessionId,
         iteration,
         kind: 'tool',
@@ -616,15 +649,41 @@ function traceBridgeTool({ sessionId, iteration, toolName, toolKind, toolMs, too
         tool_name: toolName,
         tool_kind: toolKind,
         tool_ms: toolMs,
-        tool_args: summarizeToolArgs(toolName, toolArgs),
+        tool_args: summarizedArgs,
         result_kind: resultKind || null,
         result_has_next_call: nextCallCount > 0,
         result_next_call_count: nextCallCount,
-        result_bytes_est: typeof resultText === 'string' ? Buffer.byteLength(resultText, 'utf8') : 0,
-        result_lines_est: typeof resultText === 'string' && resultText.length > 0 ? resultText.split('\n').length : 0,
+        result_bytes_est: resultBytesEst,
+        result_lines_est: resultLinesEst,
     });
+    if (
+        Number.isFinite(numericToolMs)
+        && numericToolMs >= MIXDOG_SLOW_TOOL_TRACE_MS
+        && (MIXDOG_SLOW_TOOL_TRACE_ALL || MIXDOG_SLOW_TOOL_TRACE_NAMES.size === 0 || MIXDOG_SLOW_TOOL_TRACE_NAMES.has(String(toolName || '')))
+    ) {
+        appendAgentTrace({
+            sessionId,
+            iteration,
+            kind: 'tool_slow',
+            role: role || null,
+            model: model || null,
+            tool_name: toolName,
+            tool_kind: toolKind,
+            tool_ms: numericToolMs,
+            payload: {
+                threshold_ms: MIXDOG_SLOW_TOOL_TRACE_MS,
+                result_kind: resultKind || null,
+                tool_args: summarizedArgs,
+                result_has_next_call: nextCallCount > 0,
+                result_next_call_count: nextCallCount,
+                result_bytes_est: resultBytesEst,
+                result_lines_est: resultLinesEst,
+                cwd: cwd || null,
+            },
+        });
+    }
     if (resultKind === 'error') {
-        traceBridgeToolFailure({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, role, model, cwd, resultText, resultKind });
+        traceAgentToolFailure({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, role, model, cwd, resultText, resultKind });
     }
 }
 
@@ -632,13 +691,13 @@ function traceBridgeTool({ sessionId, iteration, toolName, toolKind, toolMs, too
 // where compression actually changed the byte count, so `gain` analytics
 // can sum savings_pct over a window (mirrors RTK's `rtk gain` model
 // without an external binary). No-op rows are dropped at the call site.
-export function traceBridgeCompress({ sessionId, toolName, before, after }) {
+export function traceAgentCompress({ sessionId, toolName, before, after }) {
     // bytes_before/after/savings_pct moved into payload because the
     // trace_events table only carries known top-level columns (id, ts,
     // session_id, kind, tool_name, payload, ...) — fields outside that
     // set are silently dropped at insert time. payload is jsonb so any
     // shape survives. Aggregation: SELECT (payload->>'bytes_before')::int.
-    appendBridgeTrace({
+    appendAgentTrace({
         sessionId,
         kind: 'compress',
         tool_name: toolName,
@@ -654,24 +713,16 @@ export function traceBridgeCompress({ sessionId, toolName, before, after }) {
 // tool calls observed. Lets a consumer compute Lead-side multi-tool
 // adoption ratio (calls > 1 / total turns) directly from trace rows
 // instead of re-parsing every assistant message body.
-export function traceBridgeBatch({ sessionId, toolCallCount }) {
-    appendBridgeTrace({
+export function traceAgentBatch({ sessionId, toolCallCount }) {
+    appendAgentTrace({
         sessionId,
         kind: 'batch',
         tool_call_count: toolCallCount,
     });
 }
 
-function _sanitizeSample(sample) {
-    if (sample == null) return sample;
-    if (typeof sample === 'string' || typeof sample === 'object') {
-        return compactTraceArgValue(sample, '', 0);
-    }
-    return sample;
-}
-
 function traceStreamStalled({ sessionId, info }) {
-    appendBridgeTrace({
+    appendAgentTrace({
         sessionId,
         kind: 'stream_stalled',
         stale_seconds: info.staleSeconds,
@@ -681,7 +732,7 @@ function traceStreamStalled({ sessionId, info }) {
 }
 
 function traceStreamAborted({ sessionId, info }) {
-    appendBridgeTrace({
+    appendAgentTrace({
         sessionId,
         kind: 'stream_aborted',
         stale_seconds: info.staleSeconds,
@@ -690,12 +741,12 @@ function traceStreamAborted({ sessionId, info }) {
     });
 }
 
-function traceBridgePreset({ sessionId, role, presetName, model, provider, parentSessionId }) {
+function traceAgentPreset({ sessionId, role, presetName, model, provider, parentSessionId }) {
     // Fires once per dispatch right after the preset has been resolved and
     // its runtime spec (provider/model) assembled. Useful for after-the-fact
     // routing analysis: "which role landed on which preset / provider / model
     // on this request?"
-    appendBridgeTrace({
+    appendAgentTrace({
         sessionId,
         kind: 'preset_assign',
         role: role || null,
@@ -706,7 +757,7 @@ function traceBridgePreset({ sessionId, role, presetName, model, provider, paren
     });
 }
 
-function traceBridgeFetch({ sessionId, headersMs, httpStatus, handshakeRetries, handshakeRetryClassifiers, provider, model, transport }) {
+function traceAgentFetch({ sessionId, headersMs, httpStatus, handshakeRetries, handshakeRetryClassifiers, provider, model, transport }) {
     const payload = {
         headers_ms: headersMs,
         http_status: httpStatus,
@@ -720,7 +771,7 @@ function traceBridgeFetch({ sessionId, headersMs, httpStatus, handshakeRetries,
     if (Array.isArray(handshakeRetryClassifiers) && handshakeRetryClassifiers.length > 0) {
         payload.handshake_retry_classifiers = handshakeRetryClassifiers;
     }
-    appendBridgeTrace({
+    appendAgentTrace({
         sessionId,
         kind: 'fetch',
         headers_ms: headersMs,
@@ -734,8 +785,8 @@ function traceBridgeFetch({ sessionId, headersMs, httpStatus, handshakeRetries,
     });
 }
 
-function traceBridgeSse({ sessionId, sseParseMs, ttftMs, provider, model, transport }) {
-    appendBridgeTrace({
+function traceAgentSse({ sessionId, sseParseMs, ttftMs, provider, model, transport }) {
+    appendAgentTrace({
         sessionId,
         kind: 'sse',
         sse_parse_ms: sseParseMs,
@@ -753,7 +804,7 @@ function traceBridgeSse({ sessionId, sseParseMs, ttftMs, provider, model, transp
     });
 }
 
-function traceBridgeUsage({ sessionId, iteration, inputTokens, outputTokens, cachedTokens, cacheWriteTokens, promptTokens, model, modelDisplay, responseId, rawUsage, provider, serviceTier, requestKind }) {
+function traceAgentUsage({ sessionId, iteration, inputTokens, outputTokens, cachedTokens, cacheWriteTokens, promptTokens, model, modelDisplay, responseId, rawUsage, provider, serviceTier, requestKind }) {
     const inclusive = isInclusiveProvider(provider);
     const inTok = inputTokens || 0;
     const cacheRead = cachedTokens || 0;
@@ -765,7 +816,7 @@ function traceBridgeUsage({ sessionId, iteration, inputTokens, outputTokens, cac
             ? Math.max(inTok, cacheRead + cacheWrite)
             : inTok + cacheRead + cacheWrite);
     const resolvedServiceTier = serviceTier || rawUsage?.service_tier || rawUsage?.serviceTier || null;
-    appendBridgeTrace({
+    appendAgentTrace({
         sessionId,
         iteration,
         kind: 'usage_raw',
@@ -795,20 +846,20 @@ function traceBridgeUsage({ sessionId, iteration, inputTokens, outputTokens, cac
 }
 
 export {
-    appendBridgeTrace,
-    drainBridgeTrace,
+    appendAgentTrace,
+    drainAgentTrace,
     estimateProviderPayloadBytes,
     extractCachedTokens,
     messagePrefixHash,
-    traceBridgeFetch,
-    traceBridgeLoop,
-    traceBridgePreset,
-    traceBridgeSse,
-    traceBridgeTool,
-    traceBridgeToolFailure,
-    traceBridgeCompact,
-    traceBridgeUsage,
+    traceAgentFetch,
+    traceAgentLoop,
+    traceAgentPreset,
+    traceAgentSse,
+    traceAgentTool,
+    traceAgentToolFailure,
+    traceAgentCompact,
+    traceAgentUsage,
     traceStreamAborted,
     traceStreamStalled,
-    warnBridgeOnce,
+    warnAgentOnce,
 };

package/src/runtime/agent/orchestrator/cache-mtime.mjs

@@ -1,26 +1,5 @@
 import { statSync, readdirSync } from 'fs';
 
-/**
- * Return the maximum mtimeMs across all given paths.
- * Missing / unreadable paths are silently skipped (treated as mtime 0).
- * Pass file paths or directory paths; statSync on a directory returns the
- * mtime of the directory entry itself (updated when children are
- * added/removed), while file mtime covers content changes.
- * Use maxMtimeRecursive for cases where file-content edits within a
- * directory must also invalidate the cache (parent dir mtime is unchanged
- * on Linux/macOS when only a file's content changes).
- *
- * @param {string[]} paths
- * @returns {number}
- */
-export function maxMtime(paths) {
-    let max = 0;
-    for (const p of paths) {
-        try { const m = statSync(p).mtimeMs; if (m > max) max = m; } catch { /* missing — skip */ }
-    }
-    return max;
-}
-
 /**
  * Return the maximum mtimeMs across all given paths, recursing into
  * directories up to `depth` levels. Directory entries contribute their own