mixdog 0.9.0 → 0.9.1

package/src/runtime/agent/orchestrator/providers/openai-oauth.mjs

@@ -33,7 +33,7 @@ import {
     PROVIDER_HTTP_RESPONSE_TIMEOUT_MS,
     createTimeoutSignal,
 } from '../stall-policy.mjs';
-import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
+import { populateHttpStatusFromMessage, shouldFallbackTransport } from './retry-classifier.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { makeInvalidToolArgsMarker } from './openai-compat-stream.mjs';
 import {
@@ -742,36 +742,14 @@ function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey }) {
     return headers;
 }
 
+// WS→HTTP/SSE fallback predicate → shared shouldFallbackTransport
+// (retry-classifier.mjs). The per-provider env flag is computed here and passed
+// as `enabled`; the deny-order + allow-list are identical to the former copy.
 function _shouldUseOpenAIHttpFallback(err, externalSignal) {
-    if (!_envFlag('MIXDOG_OPENAI_OAUTH_HTTP_FALLBACK', true)) return false;
-    if (externalSignal?.aborted) return false;
-    // Live-text invariant: if the WS attempt already relayed a non-empty text
-    // chunk to the client, the HTTP fallback would re-run the request and
-    // concatenate a second attempt onto rendered output. Never fall back.
-    if (err?.liveTextEmitted === true) return false;
-    if (err?.emittedToolCall === true || err?.unsafeToRetry === true) return false;
-    const status = Number(err?.httpStatus || err?.status || 0);
-    if (status === 401 || status === 403 || status === 404 || status === 429) return false;
-    if (status >= 500 && status < 600) return true;
-    const code = String(err?.code || '');
-    if (['EWSACQUIRETIMEOUT', 'ETIMEDOUT', 'ESOCKETTIMEDOUT', 'ECONNRESET', 'EAI_AGAIN', 'ENOTFOUND', 'EAI_NODATA', 'ECONNREFUSED', 'ENETUNREACH', 'EHOSTUNREACH', 'EPIPE'].includes(code)) {
-        return true;
-    }
-    const classifier = String(err?.retryClassifier || err?.midstreamClassifier || '');
-    if ([
-        'timeout', 'reset', 'dns', 'refused', 'network', 'acquire_timeout', 'http_5xx',
-        'first_byte_timeout', 'first_meaningful_timeout',
-        'ws_1006', 'ws_1011', 'ws_1012', 'ws_1000', 'ws_4000', 'agent_stall', 'stream_stalled',
-        'response_failed_disconnected', 'response_failed_network', 'response_failed_auth_expired',
-        'ws_send_failed',
-    ].includes(classifier)) {
-        return true;
-    }
-    if (/^http_5\d\d$/.test(classifier)) return true;
-    if (err?.firstByteTimeout) return true;
-    if (err?.firstMeaningfulTimeout) return true;
-    const msg = String(err?.message || '');
-    return /opening handshake has timed out|socket hang up|acquire timed out|no first server event|no meaningful output/i.test(msg);
+    return shouldFallbackTransport(err, {
+        signal: externalSignal,
+        enabled: _envFlag('MIXDOG_OPENAI_OAUTH_HTTP_FALLBACK', true),
+    });
 }
 
 // Exported for the single-emit regression smoke (scripts/openai-oauth-

package/src/runtime/agent/orchestrator/providers/retry-classifier.mjs

@@ -231,6 +231,264 @@ export function jitterDelayMs(ms, ratio = PROVIDER_RETRY_JITTER_RATIO, mode = 's
   return Math.max(0, Math.round(base + offset))
 }
 
+// ── Shared network-resilience interface ──────────────────────────────────────
+// One home for the logic that used to be copied per provider: mid-stream
+// classifier (WS + SSE), transport fallback predicate, stream-safety stamp
+// latches, abort-aware sleep, handshake classifier, and the retry-budget table.
+// Provider differences are passed as ARGUMENTS (policy objects), never branched
+// on a hardcoded provider name. Behavior is preserved EXACTLY — each path below
+// is the relocated original, selected by policy.mode.
+
+// F) Retry-budget profiles as DATA. The numbers live ONLY here now.
+//    ws.transientCloseRetries (4) — ws_1006 / ws_1011 connection-loss buckets.
+//    ws.defaultRetries (2)        — every other WS mid-stream bucket.
+//    sse.defaultRetries (3)       — anthropic single-shot SSE mid-stream budget.
+export const MIDSTREAM_RETRY_POLICY = {
+  ws: { transientCloseRetries: 4, defaultRetries: 2, backoff: [250, 1000, 2000, 4000] },
+  sse: { defaultRetries: 3, backoff: [250, 1000, 2000, 4000] },
+}
+
+// WS buckets that earn the larger transient-close retry budget.
+const WS_TRANSIENT_CLOSE_CLASSIFIERS = new Set(['ws_1006', 'ws_1011'])
+
+function _midstreamLimitFor(classifier, policy) {
+  if (policy.mode === 'ws') {
+    return WS_TRANSIENT_CLOSE_CLASSIFIERS.has(classifier)
+      ? policy.transientCloseRetries
+      : policy.defaultRetries
+  }
+  return policy.defaultRetries
+}
+
+// WS gates each classifier against its own budget (mirrors the old
+// _allowMidstreamRetry). SSE applies a single top-of-function budget gate and
+// then returns raw classifier strings, so perClassifierGate:false returns the
+// classifier unconditionally here.
+function _allowMidstream(classifier, attemptIndex, policy) {
+  if (policy.perClassifierGate === false) return classifier
+  return attemptIndex < _midstreamLimitFor(classifier, policy) ? classifier : null
+}
+
+// A) Unified mid-stream classifier. Returns a classifier string or null.
+//    `signals` is the provider's mid-stream state object (field names unchanged
+//    from each provider's midState). `policy.mode` selects the WS or SSE path so
+//    both providers reproduce their exact current branch order and gating.
+export function classifyMidstreamError(err, signals, policy = {}) {
+  if (!signals) return null
+  const attemptIndex = signals.attemptIndex | 0
+  if (policy.mode === 'sse') return _classifyMidstreamSse(err, signals, attemptIndex, policy)
+  return _classifyMidstreamWs(err, signals, attemptIndex, policy)
+}
+
+// Verbatim relocation of openai-oauth-ws's _classifyMidstreamError. `signals`
+// carries sawResponseCreated / sawCompleted / emittedText / emittedToolCall /
+// wsCloseCode / firstByteTimeout / firstMeaningfulTimeout / wsSendFailed /
+// userAbort / watchdogAbort / responseFailedPayload exactly as before.
+function _classifyMidstreamWs(err, state, attemptIndex, policy) {
+  if (state.sawCompleted) return null
+  if (state.emittedToolCall) {
+    const _cc = Number(err?.wsCloseCode || state.wsCloseCode || 0)
+    if (!(_cc === 1000 && state.sawResponseCreated && !state.sawCompleted)) return null
+  }
+  if (state.emittedText || err?.liveTextEmitted) return null
+  if (state.firstByteTimeout || err?.firstByteTimeout) {
+    return _allowMidstream('first_byte_timeout', attemptIndex, policy)
+  }
+  if (state.firstMeaningfulTimeout || err?.firstMeaningfulTimeout) {
+    return _allowMidstream('first_meaningful_timeout', attemptIndex, policy)
+  }
+  if (err?.wsSendFailed || state.wsSendFailed) {
+    return _allowMidstream('ws_send_failed', attemptIndex, policy)
+  }
+  if (!state.sawResponseCreated) {
+    const closeCode = Number(err?.wsCloseCode || state.wsCloseCode || 0)
+    if (closeCode !== 1011 && closeCode !== 1012) return null
+  }
+  if (state.userAbort) return null
+
+  if (!err) return null
+  const status = Number(err?.httpStatus || 0)
+  if (status === 401 || status === 403 || status === 429) return null
+  if (status >= 500 && status < 600) {
+    return _allowMidstream(`http_${status}`, attemptIndex, policy)
+  }
+
+  const name = err?.name || ''
+  if (name === 'AgentStallAbortError') return _allowMidstream('agent_stall', attemptIndex, policy)
+  if (name === 'StreamStalledAbortError') return _allowMidstream('stream_stalled', attemptIndex, policy)
+
+  if (state.watchdogAbort === 'AgentStallAbortError') return _allowMidstream('agent_stall', attemptIndex, policy)
+  if (state.watchdogAbort === 'StreamStalledAbortError') return _allowMidstream('stream_stalled', attemptIndex, policy)
+
+  const closeCode = Number(err?.wsCloseCode || state.wsCloseCode || 0)
+  if (closeCode === 1006) return _allowMidstream('ws_1006', attemptIndex, policy)
+  if (closeCode === 1011) return _allowMidstream('ws_1011', attemptIndex, policy)
+  if (closeCode === 1012) return _allowMidstream('ws_1012', attemptIndex, policy)
+  if (closeCode >= 4000 && closeCode < 5000 && closeCode !== 4000) return null
+  if (closeCode === 4000) return _allowMidstream('ws_4000', attemptIndex, policy)
+  if (closeCode === 1000 && state.sawResponseCreated && !state.sawCompleted) return _allowMidstream('ws_1000', attemptIndex, policy)
+
+  const failed = err?.responseFailed || state.responseFailedPayload
+  if (failed) {
+    try {
+      const blob = JSON.stringify(failed).toLowerCase()
+      if (blob.includes('stream_disconnected')) return _allowMidstream('response_failed_disconnected', attemptIndex, policy)
+      if (blob.includes('network_error')) return _allowMidstream('response_failed_network', attemptIndex, policy)
+      if (blob.includes('auth context expired')) return _allowMidstream('response_failed_auth_expired', attemptIndex, policy)
+    } catch {}
+  }
+
+  return null
+}
+
+// Verbatim relocation of anthropic-oauth's _classifyMidstreamError. `signals`
+// carries sawMessageStart / sawCompleted / emittedToolCall / userAbort /
+// watchdogAbort exactly as before.
+function _classifyMidstreamSse(err, state, attemptIndex, policy) {
+  if (attemptIndex >= policy.defaultRetries) return null
+  if (state.sawCompleted) return null
+  if (!state.sawMessageStart) return null
+  if (state.userAbort) return null
+  if (state.emittedToolCall) return null
+
+  if (!err) return null
+  const status = Number(err?.httpStatus || 0)
+  if (status === 401 || status === 403 || status === 429) return null
+
+  const name = err?.name || ''
+  if (name === 'AgentStallAbortError') return 'agent_stall'
+  if (name === 'StreamStalledAbortError') return 'stream_stalled'
+  if (state.watchdogAbort === 'AgentStallAbortError') return 'agent_stall'
+  if (state.watchdogAbort === 'StreamStalledAbortError') return 'stream_stalled'
+
+  const code = err?.code || err?.cause?.code || ''
+  if (code === 'ECONNRESET') return 'reset'
+  if (code === 'ETIMEDOUT' || code === 'ESOCKETTIMEDOUT') return 'timeout'
+  if (code === 'ENOTFOUND' || code === 'EAI_AGAIN' || code === 'EAI_NODATA') return 'dns'
+
+  const msg = String(err?.message || '').toLowerCase()
+  if (msg.includes('stream timed out after') && msg.includes('of inactivity')) return 'sse_idle_timeout'
+  if (msg.includes('body stream') && msg.includes('terminated')) return 'stream_terminated'
+  if (msg.includes('fetch failed')) return 'fetch_failed'
+
+  return null
+}
+
+// B) Unified transport (WS→HTTP) fallback predicate. Identical deny-order +
+//    allow-list to the two former copies; `enabled` replaces the per-provider
+//    env-flag check (caller computes the flag and passes it).
+const TRANSPORT_FALLBACK_CLASSIFIERS = new Set([
+  'timeout', 'reset', 'dns', 'refused', 'network', 'acquire_timeout', 'http_5xx',
+  'first_byte_timeout', 'first_meaningful_timeout',
+  'ws_1006', 'ws_1011', 'ws_1012', 'ws_1000', 'ws_4000', 'agent_stall', 'stream_stalled',
+  'response_failed_disconnected', 'response_failed_network', 'response_failed_auth_expired',
+  'ws_send_failed',
+])
+const TRANSPORT_FALLBACK_ERRNO = new Set([
+  'EWSACQUIRETIMEOUT', 'ETIMEDOUT', 'ESOCKETTIMEDOUT', 'ECONNRESET', 'EAI_AGAIN',
+  'ENOTFOUND', 'EAI_NODATA', 'ECONNREFUSED', 'ENETUNREACH', 'EHOSTUNREACH', 'EPIPE',
+])
+
+export function shouldFallbackTransport(err, { signal, enabled = true } = {}) {
+  if (!enabled) return false
+  if (signal?.aborted) return false
+  if (err?.liveTextEmitted === true) return false
+  if (err?.emittedToolCall === true || err?.unsafeToRetry === true) return false
+  const status = Number(err?.httpStatus || err?.status || 0)
+  if (status === 401 || status === 403 || status === 404 || status === 429) return false
+  if (status >= 500 && status < 600) return true
+  const code = String(err?.code || '')
+  if (TRANSPORT_FALLBACK_ERRNO.has(code)) return true
+  const classifier = String(err?.retryClassifier || err?.midstreamClassifier || '')
+  if (TRANSPORT_FALLBACK_CLASSIFIERS.has(classifier)) return true
+  if (/^http_5\d\d$/.test(classifier)) return true
+  if (err?.firstByteTimeout) return true
+  if (err?.firstMeaningfulTimeout) return true
+  const msg = String(err?.message || '')
+  return /opening handshake has timed out|socket hang up|acquire timed out|no first server event|no meaningful output/i.test(msg)
+}
+
+// C) Stream-safety stamp latches. Mirrors openai-oauth-ws's _stampLiveText /
+//    _stampTool: once text/tool has been marked, every subsequent throw path
+//    re-applies the liveTextEmitted/emittedToolCall + unsafeToRetry markers so
+//    no upstream gate can reissue the turn and concatenate attempts.
+export function createStreamSafetyStamps() {
+  let textLatched = false
+  let toolLatched = false
+  const stampText = (e) => {
+    if (textLatched && e) { try { e.liveTextEmitted = true; e.unsafeToRetry = true } catch {} }
+    return e
+  }
+  const stampTool = (e) => {
+    if (toolLatched && e) { try { e.emittedToolCall = true; e.unsafeToRetry = true } catch {} }
+    return e
+  }
+  return {
+    markText() { textLatched = true },
+    markTool() { toolLatched = true },
+    stampText,
+    stampTool,
+    stampAll: (e) => stampTool(stampText(e)),
+  }
+}
+
+const _defaultAbortSleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+// D) Abort-aware sleep (single copy). Resolves after `ms`, or rejects with the
+//    signal's reason (or `abortMessage`) the moment the signal aborts. `sleepFn`
+//    is the injectable no-signal sleep (test seam); `abortMessage` preserves
+//    each caller's prior fallback text when the abort reason is not an Error.
+export async function sleepWithAbort(ms, signal, sleepFn = _defaultAbortSleep, abortMessage = 'sleep aborted') {
+  if (!ms) return
+  if (!signal) {
+    await (sleepFn || _defaultAbortSleep)(ms)
+    return
+  }
+  await new Promise((resolve, reject) => {
+    const t = setTimeout(() => {
+      try { signal.removeEventListener('abort', onAbort) } catch {}
+      resolve()
+    }, ms)
+    const onAbort = () => {
+      clearTimeout(t)
+      const reason = signal.reason
+      reject(reason instanceof Error ? reason : new Error(abortMessage))
+    }
+    if (signal.aborted) { onAbort(); return }
+    signal.addEventListener('abort', onAbort, { once: true })
+  })
+}
+
+// E) Handshake classifier (moved here from openai-oauth-ws). Default-deny:
+//    anything not recognized as transient returns null. 401/403/404/429 are
+//    permanent. Returns 'timeout' | 'reset' | 'dns' | 'refused' | 'network' |
+//    'acquire_timeout' | `http_5xx` | null.
+export function classifyHandshakeError(err) {
+  if (!err) return null
+  const code = err.code || ''
+  const msg = String(err.message || '')
+  const status = Number(err.httpStatus || 0)
+
+  if (status === 401 || status === 403 || status === 404 || status === 429) {
+    return null
+  }
+  if (status >= 500 && status < 600) {
+    return `http_${status}`
+  }
+
+  if (code === 'ECONNRESET') return 'reset'
+  if (code === 'EAI_AGAIN' || code === 'ENOTFOUND' || code === 'EAI_NODATA') return 'dns'
+  if (code === 'ECONNREFUSED') return 'refused'
+  if (code === 'ETIMEDOUT' || code === 'ESOCKETTIMEDOUT') return 'timeout'
+  if (code === 'EWSACQUIRETIMEOUT') return 'acquire_timeout'
+  if (code === 'ENETUNREACH' || code === 'EHOSTUNREACH' || code === 'EPIPE') return 'network'
+
+  if (/opening handshake has timed out/i.test(msg)) return 'timeout'
+  if (/socket hang up/i.test(msg)) return 'reset'
+
+  return null
+}
+
 /**
  * Run an async function with exponential-backoff retry on transient errors.
  *

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

@@ -44,7 +44,7 @@ import { invalidateBuiltinResultCache, analyzeShellCommandEffects, preflightShel
 import { markCodeGraphDirtyPaths, drainCodeGraphCache } from './code-graph-state.mjs';
 import { maybeRewriteWmicProcessCommand } from './shell-policy.mjs';
 import { _maybeEncodePowerShellCommand } from './shell-command.mjs';
-import { _captureTrackedMtimes, _trackedDriftNoteAfter, _injectionBlockTargets, getDedupedDestructiveWarnings } from './builtin/bash-tool.mjs';
+import { _captureTrackedMtimes, _trackedDriftNoteAfter, getDedupedDestructiveWarnings } from './builtin/bash-tool.mjs';
 import { scrubLoaderVars, scrubProviderSecrets } from './env-scrub.mjs';
 import { checkExecPolicyMessage } from './bash-policy-scan.mjs';
 import { startChildGuardian } from '../../../shared/child-guardian.mjs';

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

@@ -76,11 +76,6 @@ function isStringOrStringArray(v) {
     return true;
 }
 
-function hasBackslashPipe(value) {
-    if (typeof value === 'string') return false;
-    return false;
-}
-
 function hasUnsupportedRipgrepRegex(value) {
     const values = Array.isArray(value) ? value : [value];
     return values.some((item) => {
@@ -144,9 +139,6 @@ function guardGrep(a) {
         if (hasOwn(a, k) && !isStringOrStringArray(a[k])) {
             return `Error: grep arg "${k}" must be string or string[] (got ${describeType(a[k])})`;
         }
-        if (hasOwn(a, k) && hasBackslashPipe(a[k])) {
-            return `Error: grep arg "${k}" contains \\|. Use pattern:["a","b"] for OR terms, or unescaped | for regex alternation.`;
-        }
         if (hasOwn(a, k) && hasUnsupportedRipgrepRegex(a[k])) {
             return `Error: grep arg "${k}" uses regex syntax ripgrep does not support here (lookaround/backrefs). Use plain pattern arrays or simpler regex.`;
         }

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

@@ -3,7 +3,7 @@ import { execShellCommand, stripAnsi } from '../shell-command.mjs';
 import { wrapCommandWithSnapshot } from '../shell-snapshot.mjs';
 import { getDestructiveCommandWarning } from '../destructive-warning.mjs';
 import { maybeRewriteWmicProcessCommand } from '../shell-policy.mjs';
-import { buildBashPolicyScanTargets, checkExecPolicyMessage, injectionBlockTargets } from '../bash-policy-scan.mjs';
+import { buildBashPolicyScanTargets, checkExecPolicyMessage } from '../bash-policy-scan.mjs';
 import { markCodeGraphDirtyPaths, drainCodeGraphCache } from '../code-graph-state.mjs';
 import {
     buildJobNotFoundMessage,
@@ -27,7 +27,6 @@ import {
     cancelBackgroundTask,
     completeBackgroundTask,
     getBackgroundTask,
-    listBackgroundTasks,
     registerBackgroundTask,
     renderBackgroundTask,
     renderBackgroundTaskList,
@@ -48,7 +47,6 @@ import { scrubLoaderVars, scrubProviderSecrets } from '../env-scrub.mjs';
 // closing the "external write -> stale old_string -> code 8" gap when shell is
 // routed through this tool. Bounded to the tracked-read set (capped) so cost
 // stays off the whole-cwd path; emits nothing when no read file changed.
-const _DRIFT_SCAN_CAP = 256;
 export function _captureTrackedMtimes(_scope) {
     return new Map();
 }
@@ -86,53 +84,12 @@ function _combineAbortSignals(sessionSignal, externalSignal) {
     return ctl.signal;
 }
 
-// Decode ANSI-C $'…' and locale $"…" escapes so the blocklist scan sees the
-// literal command (e.g. $'\x72m' → "rm"). Defensive against quoting bypass.
-function _decodeAnsiCQuotes(s) {
-    if (typeof s !== 'string') return '';
-    if (s.indexOf('$') === -1) return s;
-    return s.replace(/\$(['"])((?:\\.|[^\\])*?)\1/g, (_full, _q, body) =>
-        body
-            .replace(/\\x([0-9a-fA-F]{1,2})/g, (_m, h) => String.fromCharCode(parseInt(h, 16)))
-            .replace(/\\u([0-9a-fA-F]{1,4})/g, (_m, h) => String.fromCharCode(parseInt(h, 16)))
-            .replace(/\\0([0-7]{1,3})/g, (_m, o) => String.fromCharCode(parseInt(o, 8)))
-            .replace(/\\([0-7]{1,3})/g, (_m, o) => String.fromCharCode(parseInt(o, 8)))
-            .replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\r/g, '\r')
-            .replace(/\\\\/g, '\\').replace(/\\(['"])/g, '$1'),
-    );
-}
-
-// Extract $(…) and `…` command-substitution bodies so each is re-scanned by
-// isBlockedCommand (e.g. eval $(printf 'rm -rf ~')).
-function _extractSubstitutionBodies(s) {
-    if (typeof s !== 'string') return [];
-    const out = [];
-    const re = /\$\(([^()]*(?:\([^()]*\)[^()]*)*)\)|`([^`]*)`/g;
-    let m;
-    while ((m = re.exec(s)) !== null) {
-        const body = m[1] != null ? m[1] : m[2];
-        if (body && body.trim()) out.push(body);
-    }
-    return out;
-}
-
-// Combined injection-aware block targets: decoded form + substitution bodies
-// (and their decoded forms). Used on BOTH the persistent and stateless paths.
-export function _injectionBlockTargets(cmd) {
-    return injectionBlockTargets(cmd);
-}
-
 function _prefixPowerShellUtf8(command) {
     const prefix = '[Console]::OutputEncoding=[System.Text.Encoding]::UTF8; $OutputEncoding=[System.Text.Encoding]::UTF8;';
     const text = String(command || '');
     return text.trimStart().startsWith(prefix) ? text : `${prefix}\n${text}`;
 }
 
-const _unquoteSpansForPolicy = (s) => s.replace(/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/g, (m) => m.slice(1, -1));
-
-// Same normalized + decoded target set as hard-block (strip/unquote/shell -c/PS).
-export { buildBashPolicyScanTargets } from '../bash-policy-scan.mjs';
-
 export function getDedupedDestructiveWarnings(command) {
     const seenMsg = new Set();
     const warnings = [];

package/src/runtime/channels/index.mjs

@@ -387,16 +387,6 @@ function sendNotifyToParent(method, params) {
   }
 }
 
-const recapState = { state: 'idle', running: false, startedAt: null, lastCompletedAt: null, updatedAt: null, errorMessage: null };
-function sendRecapStateToParent() {
-  if (!process.send) return;
-  try {
-    process.send({ type: 'recap_status', recap: { ...recapState } });
-  } catch (err) {
-    try { process.stderr.write(`mixdog channels: recap status IPC send failed: ${err && err.message || err}\n`); } catch {}
-  }
-}
-
 // ── Memory worker bridge (worker → parent → memory) ─────────────────
 // The channels worker does not own the memory worker handle. To trigger
 // memory tool actions (e.g. cycle1) we send `memory_call_request` to the
@@ -1141,26 +1131,6 @@ const OWNER_ROUTES = {
       res.end(JSON.stringify({ error: "Method not allowed" }));
     }
   },
-  "/recap/reset": async (req, res /*, body*/) => {
-    if (req.method !== "POST") { res.writeHead(405); res.end(JSON.stringify({ error: "POST required" })); return; }
-    if (!requireOwnerToken(req, res)) return;
-    // Called by hooks/session-start.cjs on `/clear` (matcher startup|clear).
-    // The session-start hook runs in a separate cjs process with no IPC
-    // handle to this forked channels child, so it can't drop recap
-    // status directly. Reset to an `empty` baseline so the statusline
-    // doesn't carry the prior session's `injected`/`error` recap badge
-    // into the cleared session.
-    const now = Date.now();
-    recapState.state = 'empty';
-    recapState.running = false;
-    recapState.startedAt = null;
-    recapState.lastCompletedAt = now;
-    recapState.updatedAt = now;
-    recapState.errorMessage = null;
-    sendRecapStateToParent();
-    res.writeHead(200);
-    res.end(JSON.stringify({ ok: true }));
-  },
   "/cycle1": async (req, res, body) => {
     if (req.method !== "POST") { res.writeHead(405); res.end(JSON.stringify({ ok: false, reason: "method-not-allowed", error: "POST required" })); return; }
     if (!requireOwnerToken(req, res)) return;

package/src/runtime/channels/lib/cli-worker-host.mjs

@@ -1,12 +1,5 @@
-function hasCliWorker() {
-  return true;
-}
 function startCliWorker(_options) {
 }
-async function stopCliWorker() {
-}
 export {
-  hasCliWorker,
-  startCliWorker,
-  stopCliWorker
+  startCliWorker
 };

package/src/runtime/channels/lib/config.mjs

@@ -276,7 +276,6 @@ function loadProfileConfig() {
 export {
   DATA_DIR,
   DEFAULT_HOLIDAY_COUNTRY,
-  applyDefaults,
   createBackend,
   getDiscordToken,
   isInQuietWindow,

package/src/runtime/channels/lib/drop-trace.mjs

@@ -68,4 +68,4 @@ function dropTrace(event, fields) {
   } catch {}
 }
 
-export { dropTrace, _dtPreview, DROP_TRACE_ENABLED };
+export { dropTrace, _dtPreview };

package/src/runtime/channels/lib/executor.mjs

@@ -196,8 +196,5 @@ export {
   ensureNopluginDir,
   evaluateFilter,
   logEvent,
-  parseGeneric,
-  parseGithub,
-  parseSentry,
   runScript
 };

package/src/runtime/channels/lib/memory-client.mjs

@@ -109,41 +109,3 @@ export async function ingestTranscript(filePath, { cwd } = {}) {
   }
 }
 
-export async function listCoreMemories(args = {}) {
-  const rawProjectId = args && Object.prototype.hasOwnProperty.call(args, 'project_id')
-    ? args.project_id
-    : args?.projectScope
-  const projectId = rawProjectId == null || rawProjectId === 'all' ? '*' : rawProjectId
-  const result = await memoryFetch('POST', '/api/tool', {
-    name: 'memory',
-    arguments: {
-      action: 'core',
-      op: 'list',
-      project_id: projectId,
-    },
-  }, 30_000)
-  if (!result || result.error) {
-    throw new Error(result?.error || 'core memory list: empty response')
-  }
-  return result
-}
-
-export async function searchMemories(args = {}) {
-  const result = await memoryFetch('POST', '/api/tool', {
-    name: 'search_memories',
-    arguments: args && typeof args === 'object' ? args : {},
-  }, 30_000)
-  if (!result || result.error) {
-    throw new Error(result?.error || 'memory_search: empty response')
-  }
-  return result
-}
-
-export async function isHealthy() {
-  try {
-    const result = await memoryFetch('GET', '/health')
-    return result.status === 'ok'
-  } catch {
-    return false
-  }
-}

package/src/runtime/channels/lib/output-forwarder.mjs

@@ -754,12 +754,5 @@ ${_bt.trim()}` : _bt.trim();
   }
 }
 export {
-  OutputForwarder,
-  cwdToProjectSlug,
-  detectCurrentSessionTranscript,
-  discoverCurrentClaudeSession,
-  discoverSessionBoundTranscript,
-  findLatestTranscriptByMtime,
-  getLatestInteractiveClaudeSession,
-  listInteractiveClaudeSessions
+  OutputForwarder
 };

package/src/runtime/channels/lib/runtime-paths.mjs

@@ -468,11 +468,7 @@ function clearActiveInstance(instanceId) {
   });
 }
 export {
-  ACTIVE_INSTANCE_FILE,
-  OWNER_DIR,
   RUNTIME_ROOT,
-  RUNTIME_STALE_TTL,
-  buildActiveInstanceState,
   cleanupInstanceRuntimeFiles,
   cleanupStaleRuntimeFiles,
   clearActiveInstance,
@@ -485,13 +481,11 @@ export {
   getPermissionResultPath,
   getTerminalLeadPid,
   getStatusPath,
-  getStopFlagPath,
   getTurnEndPath,
   notePreviousServerIfAny,
   makeInstanceId,
   readActiveInstance,
   refreshActiveInstance,
   releaseOwnedChannelLocks,
-  writeActiveInstance,
   writeServerPid
 };

package/src/runtime/channels/lib/session-discovery.mjs

@@ -1,7 +1,6 @@
 import { readFileSync, readdirSync, statSync } from "fs";
 import { execFileSync } from "child_process";
 import { basename, join, resolve } from "path";
-import { homedir } from "os";
 import { mixdogHome } from "../../shared/plugin-paths.mjs";
 
 function cwdToProjectSlug(cwd) {
@@ -94,9 +93,6 @@ function getLatestInteractiveClaudeSession() {
 
 export {
   cwdToProjectSlug,
-  getParentPid,
-  readSessionRecord,
-  isInteractiveSession,
   discoverCurrentClaudeSession,
   listInteractiveClaudeSessions,
   getLatestInteractiveClaudeSession

package/src/runtime/channels/lib/tool-format.mjs

@@ -116,7 +116,6 @@ export {
   HIDDEN_TOOLS,
   isRecallMemory,
   isMemoryFile,
-  isHidden,
   buildDedupKey,
   buildToolLine
 };

package/src/runtime/channels/lib/transcript-discovery.mjs

@@ -1,6 +1,5 @@
 import { readdirSync, existsSync, statSync } from "fs";
 import { basename, join, resolve } from "path";
-import { homedir } from "os";
 import {
   cwdToProjectSlug,
   discoverCurrentClaudeSession,
@@ -181,16 +180,8 @@ function discoverSessionBoundTranscript() {
 }
 
 export {
-  resolveTranscriptForSession,
   findLatestTranscriptByMtime,
-  isPidAlive,
   sameResolvedPath,
-  transcriptStat,
-  sessionTranscriptCandidate,
-  latestMtimeTranscriptCandidate,
-  candidateAffinity,
-  compareTranscriptCandidates,
   detectCurrentSessionTranscript,
-  discoverSessionBoundTranscript,
-  TRANSCRIPT_MTIME_DECISIVE_MS
+  discoverSessionBoundTranscript
 };

package/src/runtime/lib/keychain-cjs.cjs

@@ -148,7 +148,6 @@ function loadKeytar() {
 // Avoids Atomics.wait on main thread (which hangs when SAB is not forwarded to worker).
 function keytarSync(method, ...args) {
     loadKeytar(); // throws if not installed — before spawning child
-    const { spawnSync } = require('child_process');
     // Pass service/account/value via env to avoid shell injection entirely.
     const env = {
         ...process.env,