mixdog 0.9.38 → 0.9.40

package/src/runtime/agent/orchestrator/agent-trace-io.mjs

@@ -26,6 +26,7 @@ let _localTracePath = null;
 let _localTraceBuffer = [];
 let _localTraceTimer = null;
 let _localTraceFlushInFlight = false;
+let _localTraceFlushPromise = null;
 let _toolFailurePath = null;
 let _toolFailureBuffer = [];
 let _toolFailureTimer = null;
@@ -132,12 +133,10 @@ function _flushLocalTrace() {
         clearTimeout(_localTraceTimer);
         _localTraceTimer = null;
     }
-    if (_localTraceBuffer.length === 0) return;
     if (_localTraceFlushInFlight) {
-        _localTraceTimer = setTimeout(_flushLocalTrace, 25);
-        _localTraceTimer.unref?.();
-        return;
+        return _localTraceFlushPromise;
     }
+    if (_localTraceBuffer.length === 0) return null;
     const path = _resolveLocalTracePath();
     if (!path) return;
     const chunk = _localTraceBuffer.join('');
@@ -157,17 +156,20 @@ function _flushLocalTrace() {
     // mode only applies on file creation; existing files keep their mode.
     // Windows ignores POSIX bits — ACL governs there.
     _localTraceFlushInFlight = true;
-    appendFile(path, chunk, { encoding: 'utf8', mode: 0o600 })
+    const pending = appendFile(path, chunk, { encoding: 'utf8', mode: 0o600 })
         .catch((err) => {
             warnAgentOnce('agent-trace:local-spool', `[agent-trace] local spool failed (${err?.message})`);
         })
         .finally(() => {
             _localTraceFlushInFlight = false;
+            _localTraceFlushPromise = null;
             if (_localTraceBuffer.length > 0) {
                 _localTraceTimer = setTimeout(_flushLocalTrace, 0);
                 _localTraceTimer.unref?.();
             }
         });
+    _localTraceFlushPromise = pending;
+    return pending;
 }
 
 function _flushLocalTraceSync() {
@@ -294,7 +296,20 @@ function _scheduleFlush(immediate = false) {
     }
 }
 
+async function _drainLocalTrace() {
+    if (!_resolveLocalTracePath()) return;
+    if (_localTraceTimer) {
+        clearTimeout(_localTraceTimer);
+        _localTraceTimer = null;
+    }
+    while (_localTraceBuffer.length > 0 || _localTraceFlushInFlight) {
+        const pending = _flushLocalTrace();
+        if (pending) await pending;
+    }
+}
+
 async function drainAgentTrace() {
+    await _drainLocalTrace();
     if (!_resolveServiceUrl()) return;
     if (_flushTimer) { clearTimeout(_flushTimer); _flushTimer = null; }
     for (let i = 0; i < 10 && _buffer.length > 0; i++) {

package/src/runtime/agent/orchestrator/providers/codex-client-meta.mjs

@@ -16,7 +16,10 @@
 import os from 'node:os';
 
 // Offline fallback only; live value refreshes from npm (24h TTL, in-process).
-export const CODEX_CLIENT_VERSION_FLOOR = '0.142.5';
+// The backend gates model exposure AND per-request model access on the client
+// version (gpt-5.6-* require >= 0.144.0 per codex models-manager/models.json,
+// verified 2026-07-09), so keep this at the current release when bumping.
+export const CODEX_CLIENT_VERSION_FLOOR = '0.144.1';
 const VERSION_TTL_MS = 24 * 60 * 60_000;
 let _cache = { value: null, fetchedAt: 0 };
 let _refreshInFlight = null;
@@ -52,6 +55,23 @@ export function codexClientVersionSync() {
     return _cache.value || CODEX_CLIENT_VERSION_FLOOR;
 }
 
+/**
+ * Awaitable warmup for cold-start paths: resolves the live npm version (or
+ * floor on failure) and fills the shared cache so codexClientVersionSync()
+ * and codexVersionHeader() stop reporting the floor. Never rejects; dedupes
+ * with the in-flight background refresh. First turns await this so the
+ * backend's minimal_client_version gate never sees a stale floor.
+ */
+export function warmCodexClientVersion() {
+    if (_cache.value && Date.now() - _cache.fetchedAt < VERSION_TTL_MS) {
+        return Promise.resolve(_cache.value);
+    }
+    if (!_refreshInFlight) {
+        _refreshInFlight = _refresh().finally(() => { _refreshInFlight = null; });
+    }
+    return _refreshInFlight;
+}
+
 function _osType() {
     // codex os_info reports "Windows"/"Mac OS"/"Linux"; node os.type() gives
     // Windows_NT/Darwin/Linux. Map to codex's vocabulary.

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

@@ -59,6 +59,7 @@ import {
     _shouldUseOpenAIHttpFallback,
 } from './openai-oauth-http-sse.mjs';
 import { createOpenAIOAuthLogin } from './openai-oauth-login.mjs';
+import { warmCodexClientVersion } from './codex-client-meta.mjs';
 import {
     _displayCodexModel,
     _codexFamily,
@@ -77,42 +78,13 @@ const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
 export const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs';
 const TOKEN_URL = 'https://auth.openai.com/oauth/token';
 export const CODEX_RESPONSES_URL = 'https://chatgpt.com/backend-api/codex/responses';
-// Version string baked into the models endpoint query — the OAuth backend
-// rejects the request without it, and gates new model exposures (e.g.
-// gpt-5.5 only on >= 0.130.0) on this client_version header; older versions
-// trigger a visibility-filtered catalog (e.g. only rollout models). Resolved
-// dynamically from npm so newly-shipped models surface within a day instead
-// of waiting on a hardcoded bump here. Cached 24h in-process; npm failure
-// falls back to the floor below.
-// Offline fallback only — _resolveCodexClientVersion() fetches the live
-// @openai/codex latest from npm first. Bumped to the current release
-// (0.142.5, verified 2026-07-03) so the offline path stays close to what the
-// backend expects for client-version gating.
-const CODEX_CLIENT_VERSION_FLOOR = '0.142.5';
-const CODEX_VERSION_CACHE_TTL_MS = 24 * 60 * 60_000;
-let _codexVersionCache = { value: null, fetchedAt: 0 };
-
-async function _resolveCodexClientVersion() {
-    const now = Date.now();
-    if (_codexVersionCache.value && now - _codexVersionCache.fetchedAt < CODEX_VERSION_CACHE_TTL_MS) {
-        return _codexVersionCache.value;
-    }
-    try {
-        const res = await fetch('https://registry.npmjs.org/@openai/codex/latest', {
-            signal: AbortSignal.timeout(5_000),
-        });
-        if (res.ok) {
-            const j = await res.json();
-            const v = String(j?.version || '').trim();
-            if (/^\d+\.\d+\.\d+/.test(v)) {
-                _codexVersionCache = { value: v, fetchedAt: now };
-                return v;
-            }
-        }
-    } catch { /* network down / npm rejects — use floor */ }
-    _codexVersionCache = { value: CODEX_CLIENT_VERSION_FLOOR, fetchedAt: now };
-    return CODEX_CLIENT_VERSION_FLOOR;
-}
+// Client version for the models endpoint query and the `version`/User-Agent
+// request headers — the OAuth backend rejects requests without it, gates new
+// model exposures on it (gpt-5.6-* require >= 0.144.0), and rejects turns on
+// gated models when the reported version is below the model's
+// minimal_client_version. Resolution is unified in codex-client-meta.mjs
+// (live npm @openai/codex latest, 24h in-process cache, offline floor) so the
+// catalog query and the transport headers can never disagree.
 const CODEX_MODEL_CACHE_TTL_MS = 24 * 60 * 60_000;
 const CODEX_MODEL_CACHE_SCHEMA_VERSION = 3;
 const TOKEN_REFRESH_SKEW_MS = 5 * 60_000;
@@ -784,7 +756,14 @@ export class OpenAIOAuthProvider {
             ? Promise.resolve(opts._prebuiltBody)
             : Promise.resolve().then(() => buildRequestBody(messages, useModel, tools, bodyOpts));
         const _authP = this.ensureAuth();
+        // Cold-start guard: the WS/SSE transports read the client version via
+        // the SYNC accessor for the `version` header + User-Agent. Await the
+        // shared resolver (parallel with auth; never rejects; no-op once
+        // cached) so the first turn after boot doesn't report the offline
+        // floor and trip the backend's minimal_client_version gate.
+        const _verP = warmCodexClientVersion();
         let auth = await _authP;
+        await _verP;
         const body = await _bodyP;
         // poolKey != cacheKey by design (see openai-oauth-ws.mjs header note).
         // poolKey is per-session so parallel reviewer/worker callers each get
@@ -1038,7 +1017,7 @@ export class OpenAIOAuthProvider {
         }
         try {
             const auth = await this.ensureAuth();
-            const clientVersion = await _resolveCodexClientVersion();
+            const clientVersion = await warmCodexClientVersion();
             const url = `https://chatgpt.com/backend-api/codex/models?client_version=${clientVersion}`;
             const res = await fetch(url, {
                 signal: AbortSignal.timeout(10_000),
@@ -1076,7 +1055,7 @@ export class OpenAIOAuthProvider {
         _codexRefreshInFlight = (async () => {
             try {
                 const auth = await this.ensureAuth();
-                const clientVersion = await _resolveCodexClientVersion();
+                const clientVersion = await warmCodexClientVersion();
                 const url = `https://chatgpt.com/backend-api/codex/models?client_version=${clientVersion}`;
                 const res = await fetch(url, {
                     signal: AbortSignal.timeout(10_000),

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

@@ -305,11 +305,18 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     // cut off early. Other runaway protection is behavior-based (steering
     // ladder hints, REPEAT_FAIL_LIMIT), never a lower iteration count.
     let _iterWarnStage = 0;
-    const _iterWarnAt = [
-        Math.floor(maxLoopIterations * 0.5),
-        Math.floor(maxLoopIterations * 0.75),
-        Math.floor(maxLoopIterations * 0.9),
-    ];
+    // Tiny-cap loops (e.g. explorer cap=3) can't afford staged 50/75/90%
+    // steers — the 50% stage lands on iteration 1 in every session, spamming
+    // the normal batch→answer path. For caps < 10 emit ONE wrap-up warning at
+    // the penultimate iteration instead; caps >= 10 keep staged behavior.
+    const _singleWarn = maxLoopIterations < 10;
+    const _iterWarnAt = _singleWarn
+        ? [Math.max(1, maxLoopIterations - 1)]
+        : [
+            Math.floor(maxLoopIterations * 0.5),
+            Math.floor(maxLoopIterations * 0.75),
+            Math.floor(maxLoopIterations * 0.9),
+        ];
     while (true) {
         throwIfAborted();
         if (iterations >= maxLoopIterations) {
@@ -341,9 +348,11 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         if (_iterWarnStage < _iterWarnAt.length && iterations >= _iterWarnAt[_iterWarnStage]) {
             _iterWarnStage += 1;
             const warnAt = _iterWarnAt[_iterWarnStage - 1];
-            const stageMsg = _iterWarnStage === 1
-                ? `Iteration budget notice: ${warnAt} of ${maxLoopIterations} iterations used. Converge on a conclusion: prefer finishing the current objective over opening new exploration.`
-                : `Iteration budget warning (stage ${_iterWarnStage}): ${warnAt} of ${maxLoopIterations} iterations used — the loop hard-stops at ${maxLoopIterations}. Wrap up now: summarize progress, state what remains, and finish with your best current result.`;
+            const stageMsg = _singleWarn
+                ? `Iteration budget nearly spent: ${warnAt} of ${maxLoopIterations} iterations used — answer NOW with the best anchors you already hold.`
+                : _iterWarnStage === 1
+                    ? `Iteration budget notice: ${warnAt} of ${maxLoopIterations} iterations used. Converge on a conclusion: prefer finishing the current objective over opening new exploration.`
+                    : `Iteration budget warning (stage ${_iterWarnStage}): ${warnAt} of ${maxLoopIterations} iterations used — the loop hard-stops at ${maxLoopIterations}. Wrap up now: summarize progress, state what remains, and finish with your best current result.`;
             messages.push({ role: 'user', content: `<system-reminder>\n${stageMsg}\n</system-reminder>`, meta: 'hook' });
             process.stderr.write(`[loop] iteration warning stage ${_iterWarnStage} at ${iterations} (sess=${sessionId || 'unknown'}); continuing with steer.\n`);
             try {

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -99,6 +99,212 @@ export function estimateMessagesTokens(messages) {
     return messages.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
 }
 
+// Context status is polled while the agent loop mutates and replaces message
+// arrays. Keep the accumulated summary on that array, but cheaply validate
+// every entry before reusing its contribution. The fingerprint deliberately
+// avoids serializing content/blocks on the warm path; it compares the
+// references of every estimator-visible string instead.
+// Producer invariant: compaction copies message/call objects, transcript repair
+// replaces array entries, stored-tool-args replaces `arguments`, and MCP reload
+// replaces tool descriptors; settled nested non-string payloads are not mutated
+// in place without replacing their containing reference.
+const contextMessageMemo = new WeakMap();
+const contextTranscriptMemo = new WeakMap();
+
+function contextValueFingerprint(value) {
+    if (typeof value === 'string') return { value, entries: null };
+    if (Array.isArray(value)) return {
+        value,
+        entries: value.map(contextBlockFingerprint),
+    };
+    return value && typeof value === 'object'
+        ? { value, entries: [contextBlockFingerprint(value)] }
+        : { value, entries: null };
+}
+
+function contextBlockFingerprint(block) {
+    if (!block || typeof block !== 'object') return { value: block };
+    const fn = block.function;
+    return {
+        value: block,
+        text: typeof block.text === 'string' ? block.text : null,
+        content: typeof block.content === 'string' ? block.content : null,
+        args: typeof block.args === 'string' ? block.args : null,
+        arguments: block.arguments,
+        input: typeof block.input === 'string' ? block.input : null,
+        function: fn,
+        functionArguments: typeof fn?.arguments === 'string' ? fn.arguments : null,
+    };
+}
+
+function contextMessageFingerprint(message) {
+    if (!message || typeof message !== 'object') {
+        return {
+            role: undefined,
+            content: contextValueFingerprint(''),
+            toolCalls: contextValueFingerprint(null),
+            thinkingBlocks: contextValueFingerprint(null),
+            assistantBlocks: contextValueFingerprint(null),
+            toolCallId: null,
+        };
+    }
+    return {
+        role: message.role,
+        content: contextValueFingerprint(message.content),
+        toolCalls: contextValueFingerprint(message.toolCalls),
+        thinkingBlocks: contextValueFingerprint(message.thinkingBlocks),
+        assistantBlocks: contextValueFingerprint(message.assistantBlocks),
+        toolCallId: message?.toolCallId || null,
+    };
+}
+
+function sameContextValueFingerprint(a, b) {
+    if (!a || !b || a.value !== b.value) return false;
+    if (a.entries === null || b.entries === null) return a.entries === b.entries;
+    if (a.entries.length !== b.entries.length) return false;
+    for (let index = 0; index < a.entries.length; index += 1) {
+        if (!sameContextBlockFingerprint(a.entries[index], b.entries[index])) return false;
+    }
+    return true;
+}
+
+function sameContextBlockFingerprint(a, b) {
+    return !!a && !!b
+        && a.value === b.value
+        && a.text === b.text
+        && a.content === b.content
+        && a.args === b.args
+        && Object.is(a.arguments, b.arguments)
+        && a.input === b.input
+        && a.function === b.function
+        && a.functionArguments === b.functionArguments;
+}
+
+function sameContextMessageFingerprint(a, b) {
+    return !!a && a.role === b.role
+        && sameContextValueFingerprint(a.content, b.content)
+        && sameContextValueFingerprint(a.toolCalls, b.toolCalls)
+        && sameContextValueFingerprint(a.thinkingBlocks, b.thinkingBlocks)
+        && sameContextValueFingerprint(a.assistantBlocks, b.assistantBlocks)
+        && a.toolCallId === b.toolCallId;
+}
+
+function contextMessageContribution(message) {
+    const fingerprint = contextMessageFingerprint(message);
+    if (message && typeof message === 'object') {
+        const cached = contextMessageMemo.get(message);
+        if (cached && sameContextMessageFingerprint(cached.fingerprint, fingerprint)) return cached.contribution;
+    }
+    const role = ['system', 'user', 'assistant', 'tool'].includes(fingerprint.role) ? fingerprint.role : 'other';
+    const text = messageEstimateText(message);
+    const tokens = estimateTokens(text) + 4;
+    const contribution = {
+        role,
+        tokens,
+        reminderBuckets: null,
+        toolCallCount: 0,
+        toolCallTokens: 0,
+        toolResultCount: role === 'tool' ? 1 : 0,
+        toolResultTokens: role === 'tool' ? tokens : 0,
+    };
+    if (role === 'user' && String(text || '').trim().startsWith('<system-reminder>')) {
+        const buckets = { tokens: contribution.tokens, otherTokens: contribution.tokens };
+        let sectionTokens = 0;
+        for (const section of splitMarkdownSections(stripSystemReminder(text))) {
+            const bucket = reminderSectionBucket(section);
+            const sectionTokenCount = estimateTokens(section);
+            buckets[bucket] = (buckets[bucket] || 0) + sectionTokenCount;
+            sectionTokens += sectionTokenCount;
+        }
+        buckets.otherTokens = Math.max(0, contribution.tokens - sectionTokens);
+        contribution.reminderBuckets = buckets;
+    }
+    if (fingerprint.role === 'assistant' && Array.isArray(message?.toolCalls) && message.toolCalls.length) {
+        contribution.toolCallCount = message.toolCalls.length;
+        try { contribution.toolCallTokens = estimateTokens(JSON.stringify(message.toolCalls)); }
+        catch { contribution.toolCallTokens = estimateTokens(`[${message.toolCalls.length} tool calls]`); }
+    }
+    if (message && typeof message === 'object') {
+        contextMessageMemo.set(message, { fingerprint, contribution });
+    }
+    return contribution;
+}
+
+function emptyContextSummaryState() {
+    return {
+        rows: {
+            system: { count: 0, tokens: 0 },
+            user: { count: 0, tokens: 0 },
+            assistant: { count: 0, tokens: 0 },
+            tool: { count: 0, tokens: 0 },
+            other: { count: 0, tokens: 0 },
+        },
+        semantic: {
+            system: { count: 0, tokens: 0 },
+            chat: { count: 0, tokens: 0 },
+            assistant: { count: 0, tokens: 0 },
+            toolResults: { count: 0, tokens: 0 },
+            reminders: { count: 0, tokens: 0, otherTokens: 0 },
+            workflow: { tokens: 0 },
+            memory: { tokens: 0 },
+            workspace: { tokens: 0 },
+            environment: { tokens: 0 },
+            other: { tokens: 0 },
+        },
+        estimatedTokens: 0,
+        toolCallCount: 0,
+        toolCallTokens: 0,
+        toolResultCount: 0,
+        toolResultTokens: 0,
+    };
+}
+
+function applyContextMessageContribution(state, contribution, direction) {
+    const { role, tokens } = contribution;
+    state.estimatedTokens += direction * tokens;
+    state.rows[role].count += direction;
+    state.rows[role].tokens += direction * tokens;
+    if (role === 'system') {
+        state.semantic.system.count += direction;
+        state.semantic.system.tokens += direction * tokens;
+    } else if (role === 'user') {
+        if (contribution.reminderBuckets) {
+            state.semantic.reminders.count += direction;
+            state.semantic.reminders.tokens += direction * contribution.reminderBuckets.tokens;
+            state.semantic.reminders.otherTokens += direction * contribution.reminderBuckets.otherTokens;
+            for (const bucket of ['workflow', 'memory', 'workspace', 'environment', 'other']) {
+                state.semantic[bucket].tokens += direction * (contribution.reminderBuckets[bucket] || 0);
+            }
+        } else {
+            state.semantic.chat.count += direction;
+            state.semantic.chat.tokens += direction * tokens;
+        }
+    } else if (role === 'assistant') {
+        state.semantic.assistant.count += direction;
+        state.semantic.assistant.tokens += direction * tokens;
+    } else if (role === 'tool') {
+        state.semantic.toolResults.count += direction;
+        state.semantic.toolResults.tokens += direction * tokens;
+    }
+    state.toolCallCount += direction * contribution.toolCallCount;
+    state.toolCallTokens += direction * contribution.toolCallTokens;
+    state.toolResultCount += direction * contribution.toolResultCount;
+    state.toolResultTokens += direction * contribution.toolResultTokens;
+}
+
+function contextSummaryResult(state, count) {
+    return {
+        count,
+        estimatedTokens: state.estimatedTokens,
+        roles: Object.fromEntries(Object.entries(state.rows).map(([role, row]) => [role, { ...row }])),
+        semantic: Object.fromEntries(Object.entries(state.semantic).map(([name, row]) => [name, { ...row }])),
+        toolCallCount: state.toolCallCount,
+        toolCallTokens: state.toolCallTokens,
+        toolResultCount: state.toolResultCount,
+        toolResultTokens: state.toolResultTokens,
+    };
+}
+
 export const DEFAULT_COMPACTION_BUFFER_TOKENS = 0;
 export const DEFAULT_COMPACTION_BUFFER_RATIO = 0.1;
 export const MAX_COMPACTION_BUFFER_RATIO = 0.25;
@@ -301,81 +507,23 @@ function reminderSectionBucket(section) {
 }
 
 export function summarizeContextMessages(messages) {
-    const rows = {
-        system: { count: 0, tokens: 0 },
-        user: { count: 0, tokens: 0 },
-        assistant: { count: 0, tokens: 0 },
-        tool: { count: 0, tokens: 0 },
-        other: { count: 0, tokens: 0 },
-    };
-    const semantic = {
-        system: { count: 0, tokens: 0 },
-        chat: { count: 0, tokens: 0 },
-        assistant: { count: 0, tokens: 0 },
-        toolResults: { count: 0, tokens: 0 },
-        reminders: { count: 0, tokens: 0, otherTokens: 0 },
-        workflow: { tokens: 0 },
-        memory: { tokens: 0 },
-        workspace: { tokens: 0 },
-        environment: { tokens: 0 },
-        other: { tokens: 0 },
-    };
-    let toolCallCount = 0;
-    let toolCallTokens = 0;
-    let toolResultCount = 0;
-    let toolResultTokens = 0;
-    for (const message of messages || []) {
-        const role = rows[message?.role] ? message.role : 'other';
-        const text = messageEstimateText(message);
-        const tokens = estimateMessageTokens(message);
-        rows[role].count += 1;
-        rows[role].tokens += tokens;
-        if (role === 'system') {
-            semantic.system.count += 1;
-            semantic.system.tokens += tokens;
-        } else if (role === 'user') {
-            if (String(text || '').trim().startsWith('<system-reminder>')) {
-                semantic.reminders.count += 1;
-                semantic.reminders.tokens += tokens;
-                let sectionTokens = 0;
-                for (const section of splitMarkdownSections(stripSystemReminder(text))) {
-                    const bucket = reminderSectionBucket(section);
-                    const sectionTokenCount = estimateTokens(section);
-                    semantic[bucket].tokens += sectionTokenCount;
-                    sectionTokens += sectionTokenCount;
-                }
-                semantic.reminders.otherTokens += Math.max(0, tokens - sectionTokens);
-            } else {
-                semantic.chat.count += 1;
-                semantic.chat.tokens += tokens;
-            }
-        } else if (role === 'assistant') {
-            semantic.assistant.count += 1;
-            semantic.assistant.tokens += tokens;
-        } else if (role === 'tool') {
-            semantic.toolResults.count += 1;
-            semantic.toolResults.tokens += tokens;
-        }
-        if (message?.role === 'assistant' && Array.isArray(message.toolCalls) && message.toolCalls.length) {
-            toolCallCount += message.toolCalls.length;
-            try { toolCallTokens += estimateTokens(JSON.stringify(message.toolCalls)); }
-            catch { toolCallTokens += estimateTokens(`[${message.toolCalls.length} tool calls]`); }
-        }
-        if (message?.role === 'tool') {
-            toolResultCount += 1;
-            toolResultTokens += tokens;
-        }
+    if (!Array.isArray(messages)) return contextSummaryResult(emptyContextSummaryState(), 0);
+    let cached = contextTranscriptMemo.get(messages);
+    if (!cached || messages.length < cached.count) {
+        cached = { count: 0, contributions: [], state: emptyContextSummaryState() };
+        contextTranscriptMemo.set(messages, cached);
     }
-    return {
-        count: Array.isArray(messages) ? messages.length : 0,
-        estimatedTokens: Array.isArray(messages) ? estimateMessagesTokens(messages) : 0,
-        roles: rows,
-        semantic,
-        toolCallCount,
-        toolCallTokens,
-        toolResultCount,
-        toolResultTokens,
-    };
+    for (let index = 0; index < messages.length; index += 1) {
+        const previous = cached.contributions[index];
+        const contribution = contextMessageContribution(messages[index]);
+        if (previous === contribution) continue;
+        if (previous) applyContextMessageContribution(cached.state, previous, -1);
+        cached.contributions[index] = contribution;
+        applyContextMessageContribution(cached.state, contribution, 1);
+    }
+    cached.contributions.length = messages.length;
+    cached.count = messages.length;
+    return contextSummaryResult(cached.state, messages.length);
 }
 
 // Per-request overhead the provider injects that never appears in the
@@ -383,6 +531,39 @@ export function summarizeContextMessages(messages) {
 // provider wraps around the request. The chars/4 message estimate misses all
 // of it, so a "fits" verdict computed from messages alone is optimistic.
 const REQUEST_OVERHEAD_TOKENS = 512;
+const toolSchemaTokenMemo = new WeakMap();
+const requestReserveTokenMemo = new WeakMap();
+
+function sameToolArrayEntries(cached, tools) {
+    if (!cached || cached.entries.length !== tools.length) return false;
+    for (let index = 0; index < tools.length; index += 1) {
+        const entry = cached.entries[index];
+        const tool = tools[index];
+        if (entry.tool !== tool
+            || entry.name !== tool?.name
+            || entry.description !== tool?.description
+            || entry.inputSchema !== tool?.inputSchema
+            || entry.input_schema !== tool?.input_schema
+            || entry.parameters !== tool?.parameters
+            || entry.schema !== tool?.schema) return false;
+    }
+    return true;
+}
+
+function cacheToolArrayValue(tools, value) {
+    return {
+        entries: tools.map((tool) => ({
+            tool,
+            name: tool?.name,
+            description: tool?.description,
+            inputSchema: tool?.inputSchema,
+            input_schema: tool?.input_schema,
+            parameters: tool?.parameters,
+            schema: tool?.schema,
+        })),
+        value,
+    };
+}
 
 /**
  * Estimate the token cost of the tool/function schemas a provider appends to
@@ -394,10 +575,14 @@ const REQUEST_OVERHEAD_TOKENS = 512;
  */
 export function estimateToolSchemaTokens(tools) {
     if (!Array.isArray(tools) || tools.length === 0) return 0;
+    const cached = toolSchemaTokenMemo.get(tools);
+    if (sameToolArrayEntries(cached, tools)) return cached.value;
     let text = '';
     try { text = JSON.stringify(tools); }
     catch { text = tools.map(t => String(t?.name ?? '')).join(''); }
-    return estimateTokens(text);
+    const tokens = estimateTokens(text);
+    toolSchemaTokenMemo.set(tools, cacheToolArrayValue(tools, tokens));
+    return tokens;
 }
 
 /**
@@ -407,7 +592,12 @@ export function estimateToolSchemaTokens(tools) {
  * request-side bytes the message estimate cannot see.
  */
 export function estimateRequestReserveTokens(tools) {
-    return estimateToolSchemaTokens(tools) + REQUEST_OVERHEAD_TOKENS;
+    if (!Array.isArray(tools)) return estimateToolSchemaTokens(tools) + REQUEST_OVERHEAD_TOKENS;
+    const cached = requestReserveTokenMemo.get(tools);
+    if (sameToolArrayEntries(cached, tools)) return cached.value;
+    const reserve = estimateToolSchemaTokens(tools) + REQUEST_OVERHEAD_TOKENS;
+    requestReserveTokenMemo.set(tools, cacheToolArrayValue(tools, reserve));
+    return reserve;
 }
 
 /**
@@ -418,13 +608,15 @@ export function estimateRequestReserveTokens(tools) {
  *
  * @param {unknown[]} messages
  * @param {unknown[]|number} toolsOrReserve tool list or precomputed reserve tokens
- * @param {{ messageCount?: number }} [opts]
+ * @param {{ messageCount?: number, estimatedMessageTokens?: number }} [opts]
  */
 export function estimateTranscriptContextUsage(messages, toolsOrReserve, opts = {}) {
     const list = Array.isArray(messages) ? messages : [];
     const count = Number.isFinite(Number(opts.messageCount)) ? Number(opts.messageCount) : list.length;
     if (count <= 0 || list.length === 0) return 0;
-    const messageTokens = estimateMessagesTokens(list);
+    const messageTokens = Number.isFinite(Number(opts.estimatedMessageTokens))
+        ? Number(opts.estimatedMessageTokens)
+        : summarizeContextMessages(list).estimatedTokens;
     const reserve = typeof toolsOrReserve === 'number' && Number.isFinite(toolsOrReserve)
         ? Math.max(0, toolsOrReserve)
         : estimateRequestReserveTokens(toolsOrReserve);

package/src/runtime/agent/orchestrator/session/loop/tool-helpers.mjs

@@ -15,7 +15,8 @@ import { isAgentOwner } from '../../agent-owner.mjs';
 
 // Eager-dispatch: tools with readOnlyHint:true in their declaration are safe
 // to execute during SSE parsing so tool work overlaps with the rest of the
-// stream. Writes, bash, MCP and skills stay serial after send() returns.
+// stream. MCP follows that annotation; writes, bash, and skills stay serial
+// after send() returns.
 // Memoized: the read-only name Set is built once per distinct `tools` array
 // (keyed by identity via a module-level WeakMap) so repeated per-call lookups
 // are O(1) instead of O(N) tools.find scans.

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -26,6 +26,9 @@ import {
     compactTypeForSession,
 } from './context-meta.mjs';
 import { uncachedInputTokensForProvider } from './usage-metrics.mjs';
+import { pruneOffloadSession } from '../tool-result-offload.mjs';
+import { _getPendingMessagesForSession } from './pending-messages.mjs';
+import { isSessionCompactionBlocked } from './runtime-liveness.mjs';
 
 // 'compacting' is a transient in-flight stage written just before semantic /
 // recall-fasttrack compaction runs. If the process crashes or only partially
@@ -489,6 +492,18 @@ export async function runSessionCompaction(session, opts = {}) {
     const unchangedReason = changed ? null : (force ? 'nothing to compact' : 'below threshold');
     const now = Date.now();
     session.messages = compacted;
+    // Best-effort GC only: the 10-minute mtime gate plus this idle-only guard
+    // lets an in-flight turn's sidecars survive until a later compaction/close.
+    const pruneSessionId = opts.sessionId || session.id;
+    if (!isSessionCompactionBlocked(pruneSessionId)) {
+        try {
+            await pruneOffloadSession(pruneSessionId, () => [
+                session.messages,
+                session.liveTurnMessages,
+                _getPendingMessagesForSession(pruneSessionId),
+            ]);
+        } catch { /* best-effort */ }
+    }
     session.providerState = undefined;
     session.compaction = {
         ...(session.compaction || {}),