mixdog 0.9.4 → 0.9.5

package/src/rules/shared/01-tool.md

@@ -1,25 +1,21 @@
 # Tool Use
 
-- Independent lookups MUST batch in one turn; serialize only when a call needs
-  a prior result. This includes edit loops: batch the post-edit verification
-  read with the next target's lookup instead of emitting single-call turns.
-- Target validity comes first: symbols/callers/deps → `code_graph`; exact text in
-  a verified scope → `grep`; unknown path/name → `find`; structure → `glob`;
-  dirs → `list`; verified file → `read`; broad unknown with no anchor →
-  `explore`. Never call `grep`/`read` on guessed paths.
-- Concept normalization comes first: one concept gets one batched
-  `grep pattern:[...]` with `output_mode:"content_with_context"` (or one
-  `code_graph symbols[]`). Refine from returned paths; do not repeat equivalent
-  patterns or scopes.
+- Batch independent lookups in one turn; serialize only when a call needs a
+  prior result — including edit loops: batch the post-edit verification read
+  with the next target's lookup.
+- Pick by target: symbols/callers/deps → `code_graph`; exact text in a verified
+  scope → `grep`; unknown path/name → `find`; structure → `glob`; dirs →
+  `list`; verified file → `read`; broad unknown with no anchor → `explore`.
+  Never `grep`/`read` guessed paths.
+- One concept → one batched `grep pattern:[...]` with
+  `output_mode:"content_with_context"` (or one `code_graph symbols[]`). Refine
+  from returned paths; never repeat equivalent patterns or scopes.
 - On miss/error, normalize the target once and switch tool; on a plausible hit,
-  stop searching and answer from the framed context.
-- Lookup budget: retrieval exists to reach the NEXT action (edit, answer,
-  handoff), not to build certainty. One anchor is enough to act on; re-reading
-  or re-grepping an area you already saw this session is waste. When acting
-  and looking are both possible, act.
-- Avoid read fragmentation: `read` uses `offset`/`limit` only. If you need 2+
-  spans from one or more known files, make one batched `read` call with
-  `{path,offset,limit}` region objects instead of serial reads. Adjacent spans
-  in the same file (within a few hundred lines) are ONE window, not repeated
-  reads.
+  stop and answer from the framed context.
+- Retrieval serves the NEXT action (edit, answer, handoff), not certainty. One
+  anchor is enough to act on; re-reading/re-grepping an area seen this session
+  is waste. When acting and looking are both possible, act.
+- `read` uses `offset`/`limit` only. For 2+ spans from known file(s), make one
+  batched `read` with `{path,offset,limit}` region objects. Adjacent spans in
+  one file (within a few hundred lines) are ONE window, not repeated reads.
 - Don't mix `apply_patch` with shell or other state-changing calls in one turn.

package/src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs

@@ -356,6 +356,10 @@ export function makeAgentDispatch(opts = {}) {
         if (_idleController) {
             try { _linkSignal(session.id, _idleController.signal); } catch { /* ignore */ }
         }
+        // Watchdog blind spot guard: when the runtime snapshot is missing AND
+        // no progress timestamp exists (pre-liveness hang, swept runtime), the
+        // dispatch start time anchors staleness so the abort still fires.
+        const _watchdogAnchorTs = Date.now();
         const _idleTimer = (_idleController && (typeof _getProgressSnapshot === 'function' || typeof _getLastProgressAt === 'function'))
             ? setInterval(() => {
                 const now = Date.now();
@@ -363,9 +367,10 @@ export function makeAgentDispatch(opts = {}) {
                 const abortErr = snapshot
                     ? evaluateAgentWatchdogAbort(snapshot, now, _watchdogPolicy)
                     : null;
-                if (!abortErr && !snapshot && typeof _getLastProgressAt === 'function') {
-                    const last = _getLastProgressAt(session.id);
-                    if (_watchdogPolicy.idleStaleMs > 0 && last && now - last > _watchdogPolicy.idleStaleMs) {
+                if (!abortErr && !snapshot) {
+                    const reported = typeof _getLastProgressAt === 'function' ? _getLastProgressAt(session.id) : 0;
+                    const last = reported || _watchdogAnchorTs;
+                    if (_watchdogPolicy.idleStaleMs > 0 && now - last > _watchdogPolicy.idleStaleMs) {
                         try { _idleController.abort(new Error(`agent task stale (${_watchdogPolicy.idleStaleMs}ms without progress)`)); } catch { /* ignore */ }
                     }
                     return;

package/src/runtime/agent/orchestrator/providers/model-catalog.mjs

@@ -18,6 +18,10 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { getPluginData } from '../config.mjs';
 import { writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
+import {
+    providerCachedModelMetadataSync,
+    providerUsesEndpointScopedLimits,
+} from './provider-catalog-cache.mjs';
 
 const CATALOG_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
 const CATALOG_CACHE_FILE = 'litellm-catalog.json';
@@ -367,6 +371,7 @@ export function getModelsDevProviderModelsSync(provider, _test) {
 export function getModelMetadataSync(id, provider) {
     if (!id) return null;
     const mappedProvider = provider ? _modelsDevProviderId(provider) : null;
+    const providerNative = provider ? providerCachedModelMetadataSync(provider, id) : null;
     let meta = null;
     // 1. Manual overrides — authoritative + offline. Provider-guarded: when a
     //    provider hint is given, an override is only honoured if it belongs to
@@ -402,6 +407,15 @@ export function getModelMetadataSync(id, provider) {
         const md = _modelsDevMetadataSync(id, provider);
         if (md) meta = mergeModelMetadata(meta, md, { preserveBaseCosts: metaFromPricingOverride });
     }
+    if (providerUsesEndpointScopedLimits(provider) && !providerNative && meta) {
+        // OAuth/backend routes can expose smaller account/backend windows than
+        // the public API SKU. External catalogs remain useful for costs and
+        // capabilities, but their limits are not authoritative for these routes.
+        meta = { ...meta, contextWindow: null, outputTokens: null };
+    }
+    if (providerNative) {
+        meta = mergeModelMetadata(meta, providerNative, { preserveBaseCosts: true });
+    }
     return meta;
 }
 
@@ -493,6 +507,11 @@ export async function enrichModels(models) {
             const row = mappedProvider ? _mdCache?.[mappedProvider]?.models?.[id] : null;
             const providerMeta = row ? _normalize(_modelsDevRowToOverride(row)) : null;
             if (providerMeta) meta = mergeModelMetadata(meta, providerMeta, { preserveBaseCosts: metaFromPricingOverride });
+            const providerNative = providerCachedModelMetadataSync(m.provider, id);
+            if (providerUsesEndpointScopedLimits(m.provider) && !providerNative && meta) {
+                meta = { ...meta, contextWindow: null, outputTokens: null };
+            }
+            if (providerNative) meta = mergeModelMetadata(meta, providerNative, { preserveBaseCosts: true });
         }
         if (!meta) return m;
         return {

package/src/runtime/agent/orchestrator/providers/model-list-sanitize.mjs

@@ -145,6 +145,14 @@ function _releaseEpoch(row) {
   return Number.isFinite(t) ? t : null;
 }
 
+function _stalenessFamily(row, id) {
+  const modelId = String(id || row?.id || row?.name || '').trim().toLowerCase();
+  const claude = modelId.match(/(?:^|\/)claude-(opus|sonnet|haiku|fable)(?:-|$)/);
+  if (claude) return `claude-${claude[1]}`;
+  const family = row && typeof row.family === 'string' ? row.family.trim().toLowerCase() : '';
+  return family || null;
+}
+
 function _staleMonths() {
   const raw = process.env.MIXDOG_MODEL_STALE_MONTHS;
   if (raw == null || raw === '') return 12;
@@ -169,7 +177,7 @@ function _applyAutoStaleness(kept, provider, testCatalog) {
     return {
       row,
       cat: cr,
-      family: cr && typeof cr.family === 'string' ? cr.family.toLowerCase() : null,
+      family: cr ? _stalenessFamily(cr, row.id) : null,
       epoch: cr ? _releaseEpoch(cr) : null,
     };
   });
@@ -179,8 +187,8 @@ function _applyAutoStaleness(kept, provider, testCatalog) {
   // Compute the newest release_date per family from the FULL catalog so a
   // superseding model that isn't in this list still counts.
   const familyNewest = new Map();
-  for (const cr of Object.values(catModels)) {
-    const fam = cr && typeof cr.family === 'string' ? cr.family.toLowerCase() : null;
+  for (const [id, cr] of Object.entries(catModels)) {
+    const fam = _stalenessFamily(cr, id);
     const ep = _releaseEpoch(cr);
     if (!fam || ep == null) continue;
     const prev = familyNewest.get(fam);

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

@@ -125,7 +125,15 @@ function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey }) {
         'chatgpt-account-id': auth.account_id || '',
         'x-client-request-id': randomBytes(16).toString('hex'),
     };
-    if (cacheKey) headers.session_id = String(cacheKey);
+    if (cacheKey) {
+        const sid = String(cacheKey);
+        // Codex-native anchors (see openai-ws-pool _buildHandshakeHeaders):
+        // `session-id`/`thread-id` (hyphen) match codex-rs headers.rs; legacy
+        // underscore `session_id` kept for backward compat.
+        headers.session_id = sid;
+        headers['session-id'] = sid;
+        headers['thread-id'] = sid;
+    }
     return headers;
 }
 

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

@@ -288,6 +288,11 @@ function _codexWsCompatibilityHeaders(context = {}) {
     const headers = {};
     if (metadata['x-codex-window-id']) headers['x-codex-window-id'] = metadata['x-codex-window-id'];
     if (metadata['x-codex-turn-metadata']) headers['x-codex-turn-metadata'] = metadata['x-codex-turn-metadata'];
+    // codex sends x-codex-installation-id on EVERY request incl. the WS
+    // handshake (client.rs:582-584). We previously carried it only in the
+    // body client_metadata; the server may gate x-codex-turn-state issuance
+    // on handshake-level client identity, so mirror codex here.
+    if (metadata['x-codex-installation-id']) headers['x-codex-installation-id'] = metadata['x-codex-installation-id'];
     return headers;
 }
 
@@ -655,10 +660,16 @@ export async function sendViaWebSocket({
         let skippedResponseItems = 0;
         let wireFrameHadTurnState = false;
         let wireFrameMetadataTrace = _metadataTrace(null);
+        let framePrefixHash = null;
+        let framePrefixHeadHash = null;
+        let framePrefixPrevMatch = null;
         let result;
         const streamTimeouts = null;
         try {
-            if (warmupBody && typeof warmupBody === 'object' && attemptIndex === 0) {
+            // codex prewarm gate (client.rs:1686-1688): only when the session
+            // has no prior request state. A reused pooled socket with a live
+            // chain must go straight to the real request.
+            if (warmupBody && typeof warmupBody === 'object' && attemptIndex === 0 && !entry.lastResponseId) {
                 const warmupFrame = { type: 'response.create', ...warmupBody };
                 const wireWarmupFrame = _withCodexWsClientMetadata(warmupFrame, entry, useCodexWsClientMetadata, codexMetadataContext);
                 wireFrameHadTurnState = !!wireWarmupFrame?.client_metadata?.['x-codex-turn-state'];
@@ -723,13 +734,15 @@ export async function sendViaWebSocket({
                         payload: warmupPayload,
                     });
                 } catch {}
-                requestBody = { ...body, previous_response_id: warmupResult.responseId };
-                delete requestBody.instructions;
-                delete requestBody.generate;
-                entry.lastRequestSansInput = _stableStringify(_sansInput({
-                    ...requestBody,
-                    input: warmupInputArr,
-                }));
+                // Do NOT rewrite the main request after warmup (R23 finding).
+                // The old prev_id+no-instructions rewrite made it=1's frame a
+                // different shape from it=2+ full frames, so the first real
+                // full-frame cache write only landed at it=2 and it=3 raced
+                // its propagation (cached=0 early misses). Keeping it=1 as a
+                // normal full frame makes it byte-identical to the warmup's
+                // prefix (instant full hit on the cache warmup just wrote)
+                // and keeps every subsequent frame one consistent shape.
+                // Delta opt-in still chains via entry.lastResponseId above.
             }
 
             const delta = _computeDelta({ entry, body: requestBody });
@@ -741,6 +754,30 @@ export async function sendViaWebSocket({
             wireFrameHadTurnState = !!wireFrame?.client_metadata?.['x-codex-turn-state'];
             wireFrameMetadataTrace = _metadataTrace(wireFrame?.client_metadata);
             deltaTokens = _estimateFrameTokens(wireFrame);
+            // Prefix-consistency probe (item-level). Serialized-JSON byte
+            // prefixes can never match across appends (the shorter frame ends
+            // in "]}" where the longer has ","), so compare what the server's
+            // prefix cache actually sees: the non-input request header and the
+            // per-item content of the input array. prev_match=true means the
+            // current call's header is identical and its first N input items
+            // equal the previous call's N items (append-only history).
+            try {
+                const { client_metadata: _cm, input: frameInput, ...frameHeader } = frame;
+                const headerHash = _hashText(JSON.stringify(frameHeader), 16);
+                const itemHashes = (Array.isArray(frameInput) ? frameInput : [])
+                    .map((item) => _hashText(JSON.stringify(item), 12));
+                framePrefixHash = headerHash;
+                framePrefixHeadHash = _hashText(itemHashes.join(','), 16);
+                const prevHeader = entry.lastFrameHeaderHash;
+                const prevItems = entry.lastFrameItemHashes;
+                if (prevHeader && Array.isArray(prevItems)) {
+                    framePrefixPrevMatch = headerHash === prevHeader
+                        && itemHashes.length >= prevItems.length
+                        && prevItems.every((h, i) => itemHashes[i] === h);
+                }
+                entry.lastFrameHeaderHash = headerHash;
+                entry.lastFrameItemHashes = itemHashes;
+            } catch {}
 
             // Re-check abort after acquire/warmup — narrow window where
             // externalSignal could fire between successful acquire and
@@ -895,6 +932,11 @@ export async function sendViaWebSocket({
             entry.lastInputPrefixHash = null;
         }
 
+        // Cache observation must see the MAIN request's usage only. Folding
+        // warmup usage in first (R18) made prompt_tokens spike on it=1 and
+        // then "shrink" on it=2, faking prefix-rewrite/cache-drop signals in
+        // every warmup session (debugger 2026-07-03).
+        const cacheObservation = _cacheObservation({ entry, result });
         if (warmupResult?.usage) {
             result.usage = _combineUsageWithWarmup(result.usage, warmupResult.usage);
         }
@@ -915,7 +957,6 @@ export async function sendViaWebSocket({
             provider: traceProvider,
             serviceTier: responseServiceTier,
         });
-        const cacheObservation = _cacheObservation({ entry, result });
         const requestHasPreviousResponseId = typeof frame.previous_response_id === 'string' && frame.previous_response_id.length > 0;
         const transportCacheKeyHash = cacheKey
             ? createHash('sha256').update(String(cacheKey)).digest('hex').slice(0, 12)
@@ -987,6 +1028,9 @@ export async function sendViaWebSocket({
                 actual_cache_miss_reason: cacheObservation.missReason,
                 previous_max_cached_tokens: cacheObservation.previousMaxCached,
                 cache_drop_threshold_tokens: cacheObservation.dropThreshold,
+                frame_prefix_hash: framePrefixHash,
+                frame_prefix_head_hash: framePrefixHeadHash,
+                frame_prefix_prev_match: framePrefixPrevMatch,
                 ws_client_metadata: useCodexWsClientMetadata,
                 ws_client_metadata_key_count: wireFrameMetadataTrace.count,
                 ws_client_metadata_hash: wireFrameMetadataTrace.hash,

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

@@ -564,9 +564,11 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         // normalizes `ultra` -> `max` on the wire (reasoning_effort_for_request
         // in core/src/client.rs); the openai-oauth backend does not accept
         // `ultra` as a wire value, so mirror that mapping here.
-        ...(_codexModelSupportsReasoningSummaries(model)
-            ? { reasoning: { effort: _normalizeReasoningEffort(opts.effort), summary: 'auto' } }
-            : {}),
+        // WIRE-VERIFIED (codex desktop logs_2.sqlite, 40 response.create
+        // captures, 2026-07-03): codex sends reasoning as {"effort":"..."}
+        // with NO summary field on gpt-5.5, regardless of what the repo's
+        // build_reasoning() suggests. Match the observed bytes.
+        reasoning: { effort: _normalizeReasoningEffort(opts.effort) },
         store: process.env.MIXDOG_OAI_STORE === 'true' ? true : false,
         stream: true,
         include,
@@ -612,13 +614,12 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         cacheLaneSlot: promptCacheLane.slot,
         cacheLaneShards: promptCacheLane.shards,
     });
-    // codex only serializes `text` when a verbosity/schema is configured
-    // (common.rs create_text_param_for_request returns None otherwise); it has
-    // no unconditional { verbosity: 'medium' }. Sending an extra text object
-    // shifts every following byte vs codex's prefix layout.
-    const verbosity = typeof opts.verbosity === 'string' && opts.verbosity.trim()
+    // WIRE-VERIFIED (codex desktop logs, 2026-07-03): every live gpt-5.5
+    // response.create carries text:{"verbosity":"low"} (or a schema variant);
+    // none omit the field. Default to codex's observed "low", allow override.
+    const verbosity = (typeof opts.verbosity === 'string' && opts.verbosity.trim()
         ? opts.verbosity.trim().toLowerCase()
-        : null;
+        : null) || 'low';
     // Rebuild the body in codex struct order so JSON serialization is
     // byte-compatible with codex: ... input, tools, tool_choice,
     // parallel_tool_calls, reasoning, store, stream, include, service_tier,
@@ -636,7 +637,7 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         include: body.include,
         ...(body.service_tier ? { service_tier: body.service_tier } : {}),
         prompt_cache_key: promptCacheKey,
-        ...(verbosity ? { text: { verbosity } } : {}),
+        text: { verbosity },
         ...(body.max_output_tokens ? { max_output_tokens: body.max_output_tokens } : {}),
     };
     // NOTE: prompt_cache_retention is a public OpenAI Responses API parameter,
@@ -911,6 +912,18 @@ export class OpenAIOAuthProvider {
             useModel,
             displayModel: _displayCodexModel,
             forceFresh,
+            // codex-parity prewarm (generate:false full frame on a fresh
+            // socket, wire-verified 2026-07-03). DEFAULT ON: R19(off) vs
+            // R20(on) A/B shows prewarm removes ALL early-session zero-cache
+            // misses (4 -> 0 at it<=3; zero-miss 3 -> 0) by writing the cache
+            // and waiting for completion before the first real turn, exactly
+            // like codex prewarm_websocket (client.rs:1673-1705). Cost is one
+            // small (~5k tok) generate:false request per fresh socket, far
+            // below the 5-12k uncached tokens each early miss burned.
+            // Mid-session partial drops are server-side and unaffected.
+            warmupBody: _envFlag('MIXDOG_OPENAI_OAUTH_WS_WARMUP', true)
+                ? { ...body, generate: false }
+                : null,
         });
         if (opts.forceHttpFallback === true
             || httpFallbackActive()

package/src/runtime/agent/orchestrator/providers/openai-ws-delta.mjs

@@ -171,15 +171,17 @@ export function _stripResponseItemsFromHead(items, responseItems) {
 }
 
 export function _computeDelta({ entry, body }) {
-    // Codex-aligned default: reuse the cached WS response chain by sending
-    // previous_response_id plus only the incremental input tail when the
-    // current request is a strict extension of the last one. Keep a full-frame
-    // escape hatch for A/B runs and emergency rollback.
-    const deltaSetting = String(process.env.MIXDOG_OAI_WS_DELTA || '').trim().toLowerCase();
-    const forceFull = ['1', 'true', 'yes', 'on'].includes(String(process.env.MIXDOG_OAI_WS_FULL || '').trim().toLowerCase())
-        || ['0', 'false', 'no', 'off'].includes(deltaSetting);
-    if (forceFull) {
-        return { mode: 'full', reason: 'full_forced', frame: { type: 'response.create', ...body } };
+    // DEFAULT: full-frame sends. codex's delta path is only cache-safe with
+    // the x-codex-turn-state sticky-routing token, which the backend issues to
+    // codex but never to us (R11-R14 2026-07-03: zero turn-state events across
+    // 200+ calls despite UA/version/beta-features/client_metadata parity;
+    // delta measured 18-28% warm miss vs full-frame 0.0%). Without the sticky
+    // token, previous_response_id requests hop cache nodes and only the first
+    // prefix blocks hit. Re-enable delta explicitly via MIXDOG_OAI_WS_DELTA=1
+    // for future probes if the backend starts issuing turn-state.
+    const deltaOptIn = ['1', 'true', 'yes', 'on'].includes(String(process.env.MIXDOG_OAI_WS_DELTA || '').trim().toLowerCase());
+    if (!deltaOptIn) {
+        return { mode: 'full', reason: 'full_default', frame: { type: 'response.create', ...body } };
     }
     if (!entry || !entry.lastRequestSansInput || !entry.lastResponseId) {
         return { mode: 'full', reason: 'no_anchor', frame: { type: 'response.create', ...body } };

package/src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs

@@ -9,6 +9,7 @@
 import WebSocket from 'ws';
 import { errText } from '../../../shared/err-text.mjs';
 import { createHash, randomBytes } from 'crypto';
+import { appendFileSync } from 'node:fs';
 import { codexUserAgent, codexVersionHeader } from './codex-client-meta.mjs';
 import {
     PROVIDER_WS_ACQUIRE_TIMEOUT_MS,
@@ -162,12 +163,22 @@ function _buildHandshakeHeaders({ auth, sessionToken, turnState, cacheKey: _cach
             // (colder) cache-node class than codex.
             'User-Agent': codexUserAgent(),
             'version': codexVersionHeader(),
+            // codex advertises enabled beta features on every request incl.
+            // the WS handshake (client.rs:1038-1041 via build_responses_headers,
+            // session/mod.rs:1006-1027). With a default config the list is
+            // exactly "remote_compaction_v2" (features/src/lib.rs: the only
+            // always-advertised Stable default-on feature). Servers gate
+            // behavior (plausibly incl. x-codex-turn-state issuance) on it.
+            'x-codex-beta-features': process.env.MIXDOG_CODEX_BETA_FEATURES || 'remote_compaction_v2',
         };
     const isOpenAiOauth = auth.type !== 'xai' && auth.type !== 'openai-direct';
-    if (sessionToken && !isOpenAiOauth) {
-        // openai-direct keeps the legacy underscore header; codex-rs sends no
-        // underscore session_id on the OAuth WS handshake (client.rs:1033-1057),
-        // only the dashed session-id/thread-id pair below.
+    // codex-rs sends only the dashed session-id/thread-id pair
+    // (client.rs:1033-1057), but OUR backend measurements disagree with pure
+    // codex parity here: 2026-04-19 probes showed the OAuth backend dedupes
+    // its in-memory prefix state by the underscore session_id handshake
+    // header, and the only 0.0%-miss full-frame rounds (R7/R8, R15 regressed
+    // to 13% after this header was dropped) all had it present. Send both.
+    if (sessionToken) {
         headers['session_id'] = String(sessionToken);
     }
     if (isOpenAiOauth && (sessionToken || _cacheKey)) {
@@ -249,6 +260,24 @@ function _openSocket({ auth, sessionToken, turnState, externalSignal, cacheKey,
             try {
                 const ts = res?.headers?.['x-codex-turn-state'];
                 if (typeof ts === 'string' && ts.length) capturedHeaders.turnState = ts;
+                // Probe: dump the full 101-upgrade response header set so we can
+                // see what the server actually issues (turn-state investigation).
+                if (process.env.MIXDOG_WS_UPGRADE_HEADER_PROBE) {
+                    const all = res?.headers && typeof res.headers === 'object'
+                        ? Object.entries(res.headers).map(([k, v]) => `${k}: ${String(v).slice(0, 120)}`).join(' | ')
+                        : '(none)';
+                    const line = `[ws-upgrade-probe] ts=${new Date().toISOString()} status=${res?.statusCode} headers={ ${all} }\n`;
+                    process.stderr.write(line);
+                    // Bench runners swallow child stderr on success; persist to a
+                    // file so the probe survives (value of the env var = path, or
+                    // default under tmp).
+                    try {
+                        const probePath = process.env.MIXDOG_WS_UPGRADE_HEADER_PROBE !== '1'
+                            ? process.env.MIXDOG_WS_UPGRADE_HEADER_PROBE
+                            : `${process.env.TEMP || process.env.TMPDIR || '.'}/mixdog-ws-upgrade-probe.log`;
+                        appendFileSync(probePath, line);
+                    } catch {}
+                }
             } catch {}
         });
         socket.once('open', () => {

package/src/runtime/agent/orchestrator/providers/provider-catalog-cache.mjs

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getPluginData } from '../config.mjs';
+
+const PROVIDER_CACHE_FILES = Object.freeze({
+  'openai-oauth': ['openai-oauth-models.json'],
+  'anthropic-oauth': ['anthropic-oauth-models.json'],
+  anthropic: ['anthropic-oauth-models.json'],
+  gemini: ['gemini-models.json'],
+  'grok-oauth': ['grok-oauth-models.json'],
+});
+
+export function providerUsesEndpointScopedLimits(provider) {
+  const p = String(provider || '').toLowerCase();
+  return p === 'openai-oauth' || p === 'anthropic-oauth' || p === 'grok-oauth';
+}
+
+function num(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+
+function readModelsFromCacheFile(fileName) {
+  try {
+    const file = join(getPluginData(), fileName);
+    if (!existsSync(file)) return [];
+    const raw = JSON.parse(readFileSync(file, 'utf-8'));
+    return Array.isArray(raw?.models) ? raw.models : (Array.isArray(raw) ? raw : []);
+  } catch {
+    return [];
+  }
+}
+
+function modelAliases(id) {
+  const text = String(id || '').trim();
+  if (!text) return [];
+  const aliases = new Set([text]);
+  aliases.add(text.replace(/-\d{4}-\d{2}-\d{2}$/, ''));
+  aliases.add(text.replace(/-\d{8}$/, ''));
+  return [...aliases].filter(Boolean);
+}
+
+function rowId(row) {
+  return String(row?.id || row?.name || row?.slug || '').trim();
+}
+
+export function getProviderCachedModelSync(provider, model) {
+  const p = String(provider || '').toLowerCase();
+  const files = PROVIDER_CACHE_FILES[p] || [];
+  if (!files.length || !model) return null;
+  const aliases = new Set(modelAliases(model));
+  for (const fileName of files) {
+    for (const row of readModelsFromCacheFile(fileName)) {
+      const id = rowId(row);
+      if (!id || !aliases.has(id)) continue;
+      return row;
+    }
+  }
+  return null;
+}
+
+export function providerCachedModelMetadataSync(provider, model) {
+  const row = getProviderCachedModelSync(provider, model);
+  if (!row) return null;
+  return {
+    contextWindow: num(row.contextWindow ?? row.context_window ?? row.maxContextWindow ?? row.max_context_window ?? row.max_input_tokens),
+    outputTokens: num(row.outputTokens ?? row.maxOutputTokens ?? row.max_output_tokens ?? row.output_token_limit),
+    supportsVision: row.supportsVision === true,
+    supportsFunctionCalling: row.supportsFunctionCalling === true,
+    supportsWebSearch: row.supportsWebSearch === true,
+    supportsPromptCaching: row.supportsPromptCaching === true,
+    supportsReasoning: row.supportsReasoning === true,
+    reasoningOptions: Array.isArray(row.reasoningOptions) ? row.reasoningOptions : [],
+    reasoningContentField: row.reasoningContentField || null,
+    mode: row.mode || null,
+    displayName: row.displayName || row.display || row.name || null,
+    name: row.name || row.display || null,
+    rawProviderModel: row,
+  };
+}

package/src/runtime/agent/orchestrator/session/loop/recall-fasttrack.mjs

@@ -21,6 +21,53 @@ import {
     compactDebugLog,
 } from './compact-debug.mjs';
 import { positiveTokenInt } from './env.mjs';
+import { TOOL_OUTPUT_MAX_BYTES } from '../../tools/builtin/tool-output-limit.mjs';
+
+// ── Digest mode (compaction.recallDigest=true) ─────────────────────────────
+// Instead of folding the FULL chunked session dump into the compacted
+// messages (heavy: cycle1 drain + up to CONTEXT_SHARE_RATIO of the context
+// window), inject a small newest-first digest plus an instruction telling the
+// model to pull details lazily via recall(sessionId/query/period). The memory
+// DB already holds the full session (ingest_session below runs in both
+// modes), and raw rows are embedded synchronously at ingest, so recall serves
+// everything the big injection used to carry.
+// Default digest cap = the SHARED tool-output limit (TOOL_OUTPUT_MAX_BYTES,
+// 50KB default, env MIXDOG_TOOL_OUTPUT_MAX_BYTES) — the digest injection is
+// budgeted like any other tool result, not a special context share.
+// compaction.recallDigestMaxKb still overrides per-session.
+const DIGEST_DEFAULT_MAX_KB = Math.max(1, Math.floor(TOOL_OUTPUT_MAX_BYTES / 1024));
+
+// Byte-capped line-boundary truncation. Digest source is newest-first, so
+// keeping the HEAD keeps the newest turns.
+function truncateToKb(text, maxKb) {
+    const maxBytes = Math.max(1, maxKb) * 1024;
+    const s = String(text || '');
+    if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;
+    const lines = s.split('\n');
+    const out = [];
+    let used = 0;
+    for (const line of lines) {
+        const cost = Buffer.byteLength(line, 'utf8') + 1;
+        if (used + cost > maxBytes) break;
+        out.push(line);
+        used += cost;
+    }
+    return out.join('\n') + '\n[digest truncated at ' + maxKb + 'KB — pull the rest via recall]';
+}
+
+function buildRecallDigestText(sessionId, digestBody, maxKb) {
+    // No recall-usage instruction block here: the recall tool description
+    // already carries the usage-pattern cheatsheet (tool-defs.mjs), so
+    // repeating it per-compaction would be redundant injected tokens. The
+    // one-line header marks the compaction boundary and names the session id
+    // the model needs for a scoped recall.
+    return [
+        `[context compacted — session ${sessionId}]`,
+        `Full history is in memory — use the recall tool for details beyond this digest.`,
+        `Recent digest (newest first):`,
+        truncateToKb(digestBody, maxKb),
+    ].join('\n');
+}
 
 export async function runRecallFastTrackCompact({ sessionRef, messages, compactBudgetTokens, compactPolicy, sessionId, signal }) {
     if (!sessionId) throw new Error('recall-fasttrack requires a session id');
@@ -73,6 +120,52 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
     } finally {
         diagnostics.ingestMs = Date.now() - t0;
     }
+    // ── Digest mode: skip the dump + cycle1 drain entirely. Pull a small
+    // newest-first session browse (recall path: roots + raw fallback merged
+    // chronologically), cap it at recallDigestMaxKb, and inject it with a
+    // recall-usage instruction. The model pulls older/topical detail lazily.
+    const digestMode = sessionRef?.compaction?.recallDigest === true;
+    if (digestMode) {
+        const digestMaxKb = positiveTokenInt(sessionRef?.compaction?.recallDigestMaxKb) || DIGEST_DEFAULT_MAX_KB;
+        let digestBody = '';
+        t0 = Date.now();
+        try {
+            const browsed = await executeInternalTool('memory', {
+                action: 'search',
+                sessionId,
+                limit: positiveTokenInt(sessionRef?.compaction?.recallDigestLimit) || 30,
+                includeMembers: true,
+            }, callerCtx);
+            digestBody = typeof browsed === 'string' ? browsed : String(browsed?.text ?? browsed ?? '');
+        } catch (err) {
+            diagnostics.cycle1Error = compactDiagnosticError(err);
+            try { process.stderr.write(`[loop] recall-digest browse failed (sess=${sessionId || 'unknown'}): ${err?.message || err}\n`); } catch {}
+        }
+        diagnostics.initialDumpMs = Date.now() - t0;
+        diagnostics.cycle1Skipped = true;
+        diagnostics.cycle1SkipReason = 'digest mode';
+        diagnostics.cycle1Passes = 0;
+        const digestText = buildRecallDigestText(sessionId, digestBody, digestMaxKb);
+        diagnostics.finalRecallChars = digestText.length;
+        diagnostics.finalRecallBytes = compactByteLength(digestText);
+        const result = recallFastTrackCompactMessages(messages, compactBudgetTokens, {
+            reserveTokens: compactPolicy.reserveTokens,
+            force: true,
+            recallText: digestText,
+            query,
+            querySha,
+            allowEmptyRecall: true,
+            tailTurns: compactPolicy.tailTurns,
+            keepTokens: compactPolicy.keepTokens,
+            preserveRecentTokens: compactPolicy.preserveRecentTokens,
+        });
+        diagnostics.totalMs = Date.now() - startedAt;
+        if (result && typeof result === 'object') {
+            result.diagnostics = { ...(result.diagnostics || {}), pipeline: { ...diagnostics, digestMode: true } };
+        }
+        compactDebugLog('recall-digest pipeline', diagnostics);
+        return result;
+    }
     const dumpArgs = {
         action: 'dump_session_roots',
         sessionId,