mixdog 0.9.15 → 0.9.17

package/src/runtime/agent/orchestrator/providers/anthropic-sse.mjs

@@ -102,6 +102,11 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
     let content = '';
     let hasThinkingContent = false;
     const contentBlockTypes = new Set();
+    // Ordered extended-thinking blocks, keyed by content_block index. Each
+    // holds the accumulated thinking text + signature exactly as received so
+    // it can be round-tripped verbatim on tool-continuation turns (required
+    // back on tool_use turns; empty thinking + signature is valid).
+    const thinkingBlocks = new Map();
     let model = '';
     let toolCalls = [];
     let usage = { inputTokens: 0, outputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, raw: null };
@@ -389,6 +394,26 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
                                 inputJson: '',
                             });
                         }
+                        if (block?.type === 'thinking' || block?.type === 'redacted_thinking') {
+                            if (block.type === 'redacted_thinking') {
+                                // Redacted blocks round-trip EXACTLY as
+                                // {type:'redacted_thinking',data} — no thinking/
+                                // signature fields (the API rejects the extras).
+                                // `data` carries the opaque payload verbatim.
+                                thinkingBlocks.set(event.index, {
+                                    type: 'redacted_thinking',
+                                    data: typeof block.data === 'string' ? block.data : '',
+                                });
+                            } else {
+                                // Seed an ordered thinking block; deltas below
+                                // append text + signature into this same slot.
+                                thinkingBlocks.set(event.index, {
+                                    type: 'thinking',
+                                    thinking: typeof block.thinking === 'string' ? block.thinking : '',
+                                    signature: typeof block.signature === 'string' ? block.signature : '',
+                                });
+                            }
+                        }
                     }
 
                     if (event.type === 'content_block_delta') {
@@ -433,6 +458,21 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
                             // tool_use) can be classified by the loop as
                             // synthesis-stalled rather than silent empty.
                             hasThinkingContent = true;
+                            // Accumulate the block content in order so it can be
+                            // returned intact and round-tripped on the next turn.
+                            // A signature_delta may arrive before any thinking_delta
+                            // seeded the slot (display-omitted models emit only a
+                            // signature) — lazily create it.
+                            let tb = thinkingBlocks.get(event.index);
+                            if (!tb) {
+                                tb = { type: 'thinking', thinking: '', signature: '' };
+                                thinkingBlocks.set(event.index, tb);
+                            }
+                            if (delta.type === 'thinking_delta') {
+                                tb.thinking += delta.thinking || '';
+                            } else {
+                                tb.signature += delta.signature || '';
+                            }
                             try { onStreamDelta?.(); } catch {}
                         }
                         if (delta?.type === 'input_json_delta') {
@@ -577,6 +617,15 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
             stopReason,
             hasThinkingContent,
             contentBlockTypes: Array.from(contentBlockTypes),
+            // Ordered extended-thinking blocks (verbatim thinking text +
+            // signature) for round-tripping on tool-continuation turns. Emitted
+            // in content_block index order. Empty thinking + signature is a
+            // valid block (display-omitted models) and is kept intact.
+            thinkingBlocks: thinkingBlocks.size
+                ? [...thinkingBlocks.entries()]
+                    .sort((a, b) => a[0] - b[0])
+                    .map(([, b]) => b)
+                : undefined,
         };
     } finally {
         if (idleTimer) clearTimeout(idleTimer);

package/src/runtime/agent/orchestrator/providers/anthropic.mjs

@@ -1,6 +1,6 @@
 import { createRequire } from 'node:module';
 import { loadConfig } from '../config.mjs';
-import { sanitizeToolPairs, sanitizeAnthropicContentPairs } from '../session/context-utils.mjs';
+import { sanitizeToolPairs, sanitizeAnthropicContentPairs, foldUserTextIntoToolResultTail } from '../session/context-utils.mjs';
 import { classifyError, midstreamBackoffFor, sleepWithAbort, withRetry } from './retry-classifier.mjs';
 import { traceAgentUsage } from '../agent-trace.mjs';
 import {
@@ -310,6 +310,10 @@ function nativeAnthropicTools(opts) {
 }
 function deferredAnthropicTools(activeTools, opts) {
     if (opts?.session?.deferredNativeTools !== true) return [];
+    // Guard against an all-deferred tools array — the API rejects it with
+    // `400: At least one tool must have defer_loading=false` (iteration-cap
+    // final turn sends tools: []). See anthropic-oauth.mjs counterpart.
+    if (!Array.isArray(activeTools) || activeTools.length === 0) return [];
     const active = new Set((activeTools || []).map((tool) => String(tool?.name || '').trim()).filter(Boolean));
     const catalog = Array.isArray(opts.session.deferredToolCatalog) ? opts.session.deferredToolCatalog : [];
     return catalog
@@ -333,6 +337,14 @@ function toAnthropicMessages(messages) {
                 content = m.assistantBlocks.slice();
             } else {
                 content = [];
+                // Adaptive-thinking round-trip: prior-turn thinking blocks are
+                // REQUIRED back, unmodified (signature intact; empty thinking
+                // field allowed), and MUST precede tool_use blocks.
+                if (Array.isArray(m.thinkingBlocks)) {
+                    for (const tb of m.thinkingBlocks) {
+                        if (tb && typeof tb === 'object') content.push(tb);
+                    }
+                }
                 if (m.content) content.push({ type: 'text', text: m.content });
                 for (const tc of m.toolCalls) {
                     content.push({
@@ -366,6 +378,12 @@ function toAnthropicMessages(messages) {
             }
             continue;
         }
+        // Claude Code parity: fold a user text turn that directly follows a
+        // tool_result turn into that tool_result's content (empty end_turn
+        // livelock prevention; see foldUserTextIntoToolResultTail).
+        if (m.role === 'user' && foldUserTextIntoToolResultTail(result, normalizeContentForAnthropic(m.content))) {
+            continue;
+        }
         result.push({ role: m.role, content: normalizeContentForAnthropic(m.content) });
     }
     return sanitizeAnthropicContentPairs(result);
@@ -662,6 +680,12 @@ export class AnthropicProvider {
                 contentBlockTypes: Array.isArray(parseResult.contentBlockTypes)
                     ? parseResult.contentBlockTypes
                     : [],
+                // Round-trip adaptive-thinking blocks (verbatim thinking +
+                // signature) so the loop can store them and replay them before
+                // tool_use on the next turn. Matches anthropic-oauth's return.
+                thinkingBlocks: Array.isArray(parseResult.thinkingBlocks) && parseResult.thinkingBlocks.length
+                    ? parseResult.thinkingBlocks
+                    : undefined,
                 usage: {
                     inputTokens: input,
                     outputTokens: output,
@@ -808,6 +832,16 @@ export class AnthropicProvider {
                         if (attemptIndex > 0 && firstAttemptError) {
                             try { firstAttemptError.midstreamRetries = attemptIndex; } catch {}
                             try { firstAttemptError.midstreamClassifier = firstAttemptClassifier; } catch {}
+                            // firstAttemptError (from an earlier retried attempt)
+                            // is what actually propagates when live text was
+                            // emitted this attempt — stamp the unsafe/partial
+                            // flags onto IT too, otherwise upstream sees an
+                            // unmarked error and retries, duplicating streamed
+                            // output.
+                            try {
+                                firstAttemptError.liveTextEmitted = true;
+                                firstAttemptError.unsafeToRetry = true;
+                            } catch {}
                             throw firstAttemptError;
                         }
                         throw err;

package/src/runtime/agent/orchestrator/providers/gemini-stream.mjs

@@ -47,22 +47,38 @@ export function geminiTruncatedStreamError(message) {
 // stall after visible output was silently retried. Visible-text stalls also
 // gain streamStalled + partialContent so the loop's partial-final path can
 // keep the streamed output instead of dropping the turn.
-export function stampGeminiStreamFailure(err, { relayedText = '', textLeakGuard = null } = {}) {
+export function stampGeminiStreamFailure(err, { relayedText = '', textLeakGuard = null, sawFunctionCall = false } = {}) {
     if (!err || typeof err !== 'object') return err;
     const leaked = (textLeakGuard?.getLeakedToolCalls?.() || []).length > 0;
     const visible = relayedText.length > 0;
+    // A native functionCall chunk (not a text-leaked one) is also an in-flight
+    // tool use — replaying would double-dispatch, and partial-final must NOT
+    // treat it as a clean no-tool summary.
+    const pendingTool = leaked || sawFunctionCall === true;
     try {
         if (visible) { err.liveTextEmitted = true; err.unsafeToRetry = true; }
-        if (leaked) { err.emittedToolCall = true; err.unsafeToRetry = true; }
-        if (visible && !leaked && err.code === 'EGEMINITIMEOUT') {
+        if (pendingTool) { err.emittedToolCall = true; err.unsafeToRetry = true; }
+        // TRUNCATED_STREAM EOF after visible output must also carry the
+        // partial-final stamps (streamStalled/partialContent), aligning with the
+        // compat streams — otherwise live output is dropped instead of kept.
+        if (visible && !leaked
+            && (err.code === 'EGEMINITIMEOUT' || err.code === 'TRUNCATED_STREAM' || err.truncatedStream === true)) {
             err.streamStalled = true;
             if (typeof err.partialContent !== 'string') err.partialContent = relayedText;
-            if (err.pendingToolUse === undefined) err.pendingToolUse = false;
+            if (err.pendingToolUse === undefined) err.pendingToolUse = pendingTool;
         }
     } catch { /* best-effort */ }
     return err;
 }
 
+// True when a streamed Gemini chunk carries a native functionCall part (as
+// opposed to a tool call leaked as plain text, tracked by textLeakGuard).
+export function geminiChunkHasFunctionCall(chunk) {
+    const parts = chunk?.candidates?.[0]?.content?.parts;
+    if (!Array.isArray(parts)) return false;
+    return parts.some((p) => p && p.functionCall);
+}
+
 /**
  * Aggregate streamed GenerateContentResponse chunks into one response object
  * (same shape as a non-streaming generateContent JSON body).
@@ -245,6 +261,7 @@ export async function consumeGeminiRestStreamResponse(response, { signal, onStre
     let idleTimer = null;
     let idleReject = null;
     let relayedText = '';
+    let sawFunctionCall = false;
 
     let firstByteTimer = setTimeout(() => {
         try { reader.cancel('first byte timeout'); } catch {}
@@ -332,6 +349,7 @@ export async function consumeGeminiRestStreamResponse(response, { signal, onStre
                 }
                 allChunks.push(parsed);
                 try { onStreamDelta?.(); } catch {}
+                if (!sawFunctionCall && geminiChunkHasFunctionCall(parsed)) sawFunctionCall = true;
                 if (onTextDelta || textLeakGuard) {
                     const t = geminiChunkText(parsed);
                     if (t) relayedText += t;
@@ -352,6 +370,7 @@ export async function consumeGeminiRestStreamResponse(response, { signal, onStre
                         }
                         allChunks.push(parsed);
                         try { onStreamDelta?.(); } catch {}
+                        if (!sawFunctionCall && geminiChunkHasFunctionCall(parsed)) sawFunctionCall = true;
                         if (onTextDelta || textLeakGuard) {
                             const t = geminiChunkText(parsed);
                             if (t) relayedText += t;
@@ -362,7 +381,7 @@ export async function consumeGeminiRestStreamResponse(response, { signal, onStre
             }
         }
     } catch (err) {
-        throw stampGeminiStreamFailure(err, { relayedText, textLeakGuard });
+        throw stampGeminiStreamFailure(err, { relayedText, textLeakGuard, sawFunctionCall });
     } finally {
         clearFirstByteTimer();
         if (idleTimer) clearTimeout(idleTimer);
@@ -380,7 +399,7 @@ export async function consumeGeminiRestStreamResponse(response, { signal, onStre
     try {
         assertGeminiStreamCompleted({ sawStreamChunk, finishReason, label });
     } catch (err) {
-        throw stampGeminiStreamFailure(err, { relayedText, textLeakGuard });
+        throw stampGeminiStreamFailure(err, { relayedText, textLeakGuard, sawFunctionCall });
     }
     return aggregated;
 }
@@ -393,6 +412,7 @@ export async function consumeGeminiSdkStream(streamResult, { signal, onStreamDel
     let firstByteTimer = null;
     let inFlightReject = null;
     let relayedText = '';
+    let sawFunctionCall = false;
 
     const armFirstByteTimer = () => {
         if (firstByteTimer) clearTimeout(firstByteTimer);
@@ -504,6 +524,7 @@ export async function consumeGeminiSdkStream(streamResult, { signal, onStreamDel
             resetIdleTimer();
             if (step.value) collectedChunks.push(step.value);
             try { onStreamDelta?.(); } catch {}
+            if (!sawFunctionCall && geminiChunkHasFunctionCall(step.value)) sawFunctionCall = true;
             if (onTextDelta || textLeakGuard) {
                 const t = geminiChunkText(step.value);
                 if (t) relayedText += t;
@@ -519,7 +540,7 @@ export async function consumeGeminiSdkStream(streamResult, { signal, onStreamDel
             const reason = signal.reason;
             throw reason instanceof Error ? reason : new Error(`${label} aborted`);
         }
-        throw stampGeminiStreamFailure(err, { relayedText, textLeakGuard });
+        throw stampGeminiStreamFailure(err, { relayedText, textLeakGuard, sawFunctionCall });
     } finally {
         clearFirstByteTimer();
         if (idleTimer) clearTimeout(idleTimer);
@@ -559,7 +580,7 @@ export async function consumeGeminiSdkStream(streamResult, { signal, onStreamDel
     try {
         assertGeminiStreamCompleted({ sawStreamChunk, finishReason, label });
     } catch (err) {
-        throw stampGeminiStreamFailure(err, { relayedText, textLeakGuard });
+        throw stampGeminiStreamFailure(err, { relayedText, textLeakGuard, sawFunctionCall });
     }
     return raw;
 }

package/src/runtime/agent/orchestrator/providers/gemini.mjs

@@ -68,7 +68,7 @@ const DEFAULT_MODEL = MODELS[0].id;
 const MODEL_CACHE_TTL_MS = 24 * 60 * 60_000;
 // Bump when the on-disk cache shape changes so stale-shape entries are
 // discarded instead of misread.
-const GEMINI_MODEL_CACHE_SCHEMA_VERSION = 1;
+const GEMINI_MODEL_CACHE_SCHEMA_VERSION = 2;
 
 // De-dupes concurrent force-refreshes so they share one HTTP round-trip,
 // mirroring anthropic-oauth's _modelRefreshInFlight.
@@ -155,6 +155,10 @@ export class GeminiProvider {
             const cfg = freshConfig.providers?.gemini;
             const newKey = cfg?.apiKey || process.env.GEMINI_API_KEY;
             if (newKey) {
+                // Keep this.config in sync so REST/cache paths (which read the
+                // key via _getApiKey() → this.config.apiKey) don't keep using
+                // the stale key after a rotation; genAI alone is not enough.
+                this.config = { ...(this.config || {}), ...(cfg || {}), apiKey: newKey };
                 this.genAI = new GoogleGenerativeAI(newKey);
             }
         } catch { /* best effort */ }
@@ -871,10 +875,11 @@ export class GeminiProvider {
         if (!res.ok) throw new Error(`gemini list_models ${res.status}`);
         const data = await res.json();
         const items = Array.isArray(data?.models) ? data.models : [];
-        // Filter to Gemini family; skip embedding/imagen endpoints.
+        // Filter to Gemini family; skip embedding/imagen and non-coding SKUs
+        // (robotics, computer-use) that the chat picker should never show.
         const normalized = items
             .filter(m => (m?.name || '').includes('gemini'))
-            .filter(m => !/embedding|aqa|imagen/.test(m?.name || ''))
+            .filter(m => !/embedding|aqa|imagen|robotics|computer-use/.test(m?.name || ''))
             .map(m => {
                 const id = (m.name || '').replace(/^models\//, '');
                 const family = /flash-lite/.test(id) ? 'gemini-flash-lite'
@@ -886,8 +891,11 @@ export class GeminiProvider {
                     display: m.displayName || id,
                     family,
                     provider: 'gemini',
-                    contextWindow: m.inputTokenLimit || 1000000,
-                    outputTokens: m.outputTokenLimit || 8192,
+                    // No fabricated fallbacks: when the API omits limits leave
+                    // them null so enrichModels can fill from the catalog and
+                    // the picker shows no context label instead of a fake 1M.
+                    contextWindow: m.inputTokenLimit || null,
+                    outputTokens: m.outputTokenLimit || null,
                     tier: 'version',
                     latest: false,
                     description: m.description || '',

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

@@ -250,7 +250,7 @@ function saveTokens(tokens) {
         expires_at: tokens.expires_at || 0,
         token_endpoint: tokens.token_endpoint || null,
         user_id: tokens.user_id || tokens.userId || _identityFromAccessToken(tokens.access_token).user_id || undefined,
-    }, { lock: true, fsyncDir: true });
+    }, { lock: true, fsyncDir: true, mode: 0o600, secret: true });
 }
 
 function _scrubTokens(text) {

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

@@ -41,6 +41,7 @@ const NON_CHAT_RE = new RegExp(
       'dall[-_]?e', 'sora', 'imagen', 'imagine', 'veo', 'kling', 'runway',
       'realtime', 'transcribe', 'transcription', 'diarize',
       'guard', 'safety', 'classifier',
+      'robotics', 'computer[-_]?use',
     ].join('|') +
     ')([-_/\\s]|$)',
   'i',
@@ -64,6 +65,15 @@ const NON_LLM_ID_PATTERNS = [
   /^gpt-audio(\b|-)/i,               // gpt-audio, gpt-audio-mini, gpt-audio-1.5
   /^gpt-realtime(\b|-)/i,            // gpt-realtime*, gpt-realtime-mini
   /-tts(\b|-)/i,                      // any *-tts SKU
+  // Purpose-specific SKUs that report mode:'chat' but are never useful for a
+  // coding agent (embodied/robotics, browser computer-use, audio-native,
+  // customtools picker-duplicate variants).
+  /(^|-)robotics(\b|-)/i,             // gemini-robotics-er-*
+  /computer[-_]?use/i,                // gemini-2.5-computer-use-preview-*
+  /native[-_]?audio/i,                // gemini-2.5-flash-native-audio-*
+  /-customtools(\b|-|$)/i,            // gemini-3.1-pro-preview-customtools
+  /^codex-auto-review$/i,             // Codex backend auto-review model, not a picker choice
+  /^grok-build$/i,                    // proxy alias duplicating grok-build-0.1 (exact — 0.1 stays)
 ];
 
 function _isNonLlmId(lid) {
@@ -89,6 +99,7 @@ const LEGACY_PATTERNS = [
   /^claude-(1|2|3|instant)(\b|-|\.)/i,
   // Gemini legacy — gemini-1*, gemini-pro. gemini-2/3 not matched.
   /^gemini-1(\b|-|\.)/i,
+  /^gemini-2\.0(\b|-|\.)/i,
   /^gemini-pro(\b|-)/i,
   // Grok legacy — grok-1/2/3 and grok-beta. The digit boundary stops grok-3
   // from catching grok-4.20-beta.

package/src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs

@@ -669,6 +669,17 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
             } else if (event.response.status === 'incomplete') {
                 const reason = incompleteReasonFromResponsesEvent(event);
                 if (isMaxOutputIncompleteReason(reason)) {
+                    // Max-output cutoff with a tool call still in flight means
+                    // the function-call arguments were truncated — do NOT mark
+                    // this a clean completion, or partial args surface as a
+                    // successful tool call. Treat as unsafe/partial instead.
+                    if (state.toolInFlight || (state.pendingCalls && state.pendingCalls.size > 0)) {
+                        const err = truncatedCompatStreamError(label, `incomplete (${reason}) with tool call in flight`);
+                        err.streamStalled = true;
+                        err.pendingToolUse = true;
+                        err.partialContent = state.content || '';
+                        throw err;
+                    }
                     state.completed = true;
                     state.stopReason = 'length';
                     state.completedResponse = event.response || state.completedResponse;
@@ -686,6 +697,13 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
         case 'response.incomplete': {
             const reason = incompleteReasonFromResponsesEvent(event);
             if (isMaxOutputIncompleteReason(reason)) {
+                if (state.toolInFlight || (state.pendingCalls && state.pendingCalls.size > 0)) {
+                    const err = truncatedCompatStreamError(label, `incomplete (${reason}) with tool call in flight`);
+                    err.streamStalled = true;
+                    err.pendingToolUse = true;
+                    err.partialContent = state.content || '';
+                    throw err;
+                }
                 state.completed = true;
                 state.stopReason = 'length';
                 state.completedResponse = event.response || state.completedResponse;

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

@@ -113,7 +113,7 @@ async function _resolveCodexClientVersion() {
     return CODEX_CLIENT_VERSION_FLOOR;
 }
 const CODEX_MODEL_CACHE_TTL_MS = 24 * 60 * 60_000;
-const CODEX_MODEL_CACHE_SCHEMA_VERSION = 2;
+const CODEX_MODEL_CACHE_SCHEMA_VERSION = 3;
 const TOKEN_REFRESH_SKEW_MS = 5 * 60_000;
 
 const _codexModelCache = makeModelCache({

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

@@ -587,6 +587,10 @@ export async function _streamResponse({
                 // Partial-final recovery: attach streamed partial state so
                 // a wedged FINAL no-tool summary can be accepted as partial-final
                 // success by the loop. pendingToolUse gates out mid-flight tools.
+                // Fold the held leak-guard tail into `content` FIRST so the
+                // partial snapshot below keeps legitimate trailing text; finish()
+                // then skips flushLeak (terminalError set) without losing it.
+                flushLeak();
                 try {
                     terminalError.partialContent = content;
                     terminalError.partialToolCalls = toolCalls.length ? toolCalls.slice() : undefined;
@@ -631,9 +635,14 @@ export async function _streamResponse({
         };
         const finish = () => {
             logReasoningDeltaSuppression();
+            // On a terminal error we must NOT flush buffered text/tool calls:
+            // finish() rejects below, so flushing would emit partial output the
+            // caller then never consumes as a clean result (double-render/
+            // double-dispatch risk). The partial-final path reads partialContent
+            // off the error instead. Only flush the held-back tail on success.
+            if (!terminalError) flushLeak();
             // Flush any partial-sentinel tail held back mid-stream so
             // legitimate trailing text is never lost (streamed-text path).
-            flushLeak();
             cleanup();
             if (terminalError) { reject(terminalError); return; }
             resolve({
@@ -694,6 +703,12 @@ export async function _streamResponse({
                     // first-meaningful watchdog (keepalive/metadata frames do
                     // NOT reach this case, so they never clear it).
                     clearFirstMeaningfulWatchdog();
+                    // Arm the semantic idle/stall timer from response.created
+                    // too: it otherwise only arms on the first meaningful delta
+                    // (bumpSemanticIdle), so a created+keepalive-only stream that
+                    // never emits a delta would stall unbounded until the outer
+                    // watchdog. Arming here bounds that gap.
+                    resetSemanticIdle();
                     break;
                 case 'response.output_text.delta':
                     try {
@@ -748,6 +763,10 @@ export async function _streamResponse({
                         // response.output_item.done.
                         _toolInFlight = true;
                     }
+                    // Item lifecycle is genuine progress: reset the semantic-idle
+                    // timer so long server-side tool latency after item-added
+                    // (before any arg delta) is not mistaken for a silent stall.
+                    resetSemanticIdle();
                     break;
                 case 'response.function_call_arguments.delta':
                     _toolInFlight = true;
@@ -826,6 +845,9 @@ export async function _streamResponse({
                     if (event.item?.type === 'custom_tool_call') {
                         pushCustomToolCall(event.item);
                     }
+                    // Item-done is genuine lifecycle progress — reset semantic
+                    // idle so latency before the next item/args does not stall.
+                    resetSemanticIdle();
                     break;
                 case 'response.completed': {
                     const completedServiceTier = event.response?.service_tier || event.response?.serviceTier || '';
@@ -1048,7 +1070,13 @@ export async function _streamResponse({
                         try { onStreamDelta?.(); } catch {}
                         bumpSemanticIdle();
                     }
-                    // Trace-only events (response.in_progress, etc.)
+                    // response.in_progress is a server lifecycle heartbeat during
+                    // long tool/generation latency — reset semantic idle so it is
+                    // not counted as silence (resetIdle already ran at the top).
+                    else if (event.type === 'response.in_progress') {
+                        resetSemanticIdle();
+                    }
+                    // Other trace-only events fall through.
                     break;
             }
         };

package/src/runtime/agent/orchestrator/session/cache/scoped-cache.mjs

@@ -134,6 +134,25 @@ function _scopedDependencyRoots(toolName, args, cwd) {
     }
     if (rawPaths.length > 0) {
         for (const p of rawPaths) add(p);
+        // `glob` results are gated on the pattern's static (non-magic) prefix,
+        // not just cwd/path root — a pattern like "src/**/*.mjs" must register
+        // "src", not just cwd, or edits under src/ that are not directly under
+        // the given path root will not invalidate the cached glob result.
+        if (toolName === 'glob' && canonicalArgs && typeof canonicalArgs.pattern !== 'undefined') {
+            const patterns = [];
+            _collectPathValues(canonicalArgs.pattern, patterns);
+            for (const pattern of patterns) {
+                if (typeof pattern !== 'string' || !_hasGlobMagic(pattern)) continue;
+                const patternRoot = _extractGlobRoot(pattern);
+                if (_pathIsAbs(patternRoot)) {
+                    add(patternRoot);
+                } else if (rawPaths.length > 0) {
+                    for (const p of rawPaths) add(join(p, patternRoot));
+                } else {
+                    add(patternRoot);
+                }
+            }
+        }
     } else if (cwd && typeof cwd === 'string') {
         add(cwd);
     }

package/src/runtime/agent/orchestrator/session/compact/constants.mjs

@@ -22,11 +22,11 @@ export {
 export const SUMMARY_PREFIX = 'A previous model worked on this task and produced the compacted handoff summary below. Build on the work already done and avoid duplicating it; treat the summary as authoritative context for continuing the task. You also retain the preserved recent turns that follow.';
 export const SUMMARY_OUTPUT_TOKENS = 4_096;
 // Unified context-share rule: every derived "how much of the model context
-// may this budget take" ratio uses ONE number — 5%. Consumers:
+// may this budget take" ratio uses ONE number — 10%. Consumers:
 //   - compact target budget (loop/compact-policy.mjs COMPACT_TARGET_RATIO)
 //   - recall-fasttrack injection cap (loop.mjs recallTokenCap)
 // Keep them in lockstep; do not fork per-consumer ratios without a decision.
-export const CONTEXT_SHARE_RATIO = 0.05;
+export const CONTEXT_SHARE_RATIO = 0.10;
 // Floor for the recall-injection cap so small-context models still get a
 // usable recall slice (cap = max(floor, contextWindow * CONTEXT_SHARE_RATIO)).
 export const RECALL_TOKEN_CAP_FLOOR_TOKENS = 2_048;

package/src/runtime/agent/orchestrator/session/compact/engine.mjs

@@ -672,7 +672,7 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
     };
     // Recall injection room is capped separately from the mandatory
     // (system + preserved tail) budget: recall text never gets more than
-    // opts.recallTokenCap (5% of context window, floor 2048 tokens, set by
+    // opts.recallTokenCap (10% of context window, floor 2048 tokens, set by
     // the caller); the remaining budget stays reserved for live
     // conversation. Only applied when the cap is a positive finite number,
     // preserving current uncapped behavior otherwise.

package/src/runtime/agent/orchestrator/session/compact/summary.mjs

@@ -253,21 +253,43 @@ export function fitCompactionPrompt(input, targetTokens) {
     const buildReduced = (k) => {
         const kept = k > 0 ? head.slice(head.length - k) : [];
         const omitted = head.length - kept.length;
-        const stubHead = omitted > 0
-            ? [{ role: 'user', content: `[${omitted} older messages omitted]` }, ...kept]
-            : kept;
-        let inp = { ...baseNoFacts, head: stubHead };
-        // Also shrink/drop a prior <previous-summary> (same as the normal fitAt
-        // path) — a large prior summary can keep the prompt over budget even at
-        // K=0. fitPreviousSummaryForCompactionPrompt is a no-op when there is no
-        // previousSummary, so this is safe for the summary-less case.
-        if (estimateCompactionPromptTokens(inp, 0) > targetTokens) {
-            const fitted = fitPreviousSummaryForCompactionPrompt(inp, 0, targetTokens);
-            if (!fitted) return null;
-            inp = fitted;
-            if (estimateCompactionPromptTokens(inp, 0) > targetTokens) return null;
-        }
-        return buildCompactionPrompt(inp, 0);
+        const finalize = (stubHead) => {
+            let inp = { ...baseNoFacts, head: stubHead };
+            // Also shrink/drop a prior <previous-summary> (same as the normal
+            // fitAt path) — a large prior summary can keep the prompt over
+            // budget even at K=0. fitPreviousSummaryForCompactionPrompt is a
+            // no-op when there is no previousSummary, so this is safe for the
+            // summary-less case.
+            if (estimateCompactionPromptTokens(inp, 0) > targetTokens) {
+                const fitted = fitPreviousSummaryForCompactionPrompt(inp, 0, targetTokens);
+                if (!fitted) return null;
+                inp = fitted;
+                if (estimateCompactionPromptTokens(inp, 0) > targetTokens) return null;
+            }
+            return buildCompactionPrompt(inp, 0);
+        };
+        if (omitted <= 0) return finalize(kept);
+        // The omitted head messages never reappear in the session afterward
+        // (the caller replaces the whole head with the produced summary), so
+        // a bare "[N older messages omitted]" stub used to discard their
+        // content with zero trace. Prefer a compact per-message digest line
+        // for each omitted message so at least a sliver of detail survives
+        // into the summary input; only fall back to the count-only stub if
+        // even the digest cannot fit the emergency budget, preserving the
+        // original guarantee that this reduction always finds a fit.
+        const digestLines = head.slice(0, omitted).map((m, i) => {
+            const role = m?.role || 'unknown';
+            const text = truncateMiddle(extractText(m).trim(), 30);
+            return text ? `${i + 1}. ${role}: ${text}` : `${i + 1}. ${role}`;
+        });
+        const digestStub = {
+            role: 'user',
+            content: [`[${omitted} older messages compacted to a digest below]`, ...digestLines].join('\n'),
+        };
+        const withDigest = finalize([digestStub, ...kept]);
+        if (withDigest) return withDigest;
+        const countStub = { role: 'user', content: `[${omitted} older messages omitted]` };
+        return finalize([countStub, ...kept]);
     };
     let lo = 0;
     let hi = head.length;