mixdog 0.9.14 → 0.9.16

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;

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

@@ -641,3 +641,58 @@ export function sanitizeAnthropicContentPairs(messages) {
     }
     return out;
 }
+
+/**
+ * Fold a plain user text turn into the trailing tool_result block of the
+ * previous user message (Claude Code parity: utils/messages.ts
+ * mergeUserContentBlocks / smooshIntoToolResult). Any sibling text after a
+ * tool_result renders as `</function_results>\n\nHuman:<...>` on the
+ * Anthropic wire; repeated mid-conversation this teaches the model to emit
+ * 3-token empty end_turn completions (upstream A/B sai-20260310-161901:
+ * 92% → 0% after smooshing). Observed in mixdog as the empty-turn nudge
+ * livelock: each contract nudge was pushed as its own user turn right after
+ * a tool_result turn, reinforcing the empty-completion pattern.
+ *
+ * Returns true when the text was folded (caller must NOT push the message);
+ * false when the message must keep its own turn (no tool_result tail,
+ * tool_reference result, or non-text content such as images).
+ */
+export function foldUserTextIntoToolResultTail(result, content) {
+    const last = result[result.length - 1];
+    if (last?.role !== 'user' || !Array.isArray(last.content) || last.content.length === 0) return false;
+    const tail = last.content[last.content.length - 1];
+    if (tail?.type !== 'tool_result') return false;
+    // tool_reference results must keep their exact shape — leave as sibling.
+    if (Array.isArray(tail.content) && tail.content.some((b) => b?.type === 'tool_reference')) return false;
+    // Only fold pure text (string or all-text blocks). Images/documents keep
+    // their own user turn.
+    let texts;
+    if (typeof content === 'string') {
+        texts = content.trim() ? [content.trim()] : [];
+    } else if (Array.isArray(content) && content.every((b) => b?.type === 'text' && typeof b.text === 'string')) {
+        texts = content.map((b) => b.text.trim()).filter(Boolean);
+    } else {
+        return false;
+    }
+    if (texts.length === 0) return true; // empty text turn — drop it entirely
+    const joined = texts.join('\n\n');
+    if (typeof tail.content === 'string') {
+        last.content[last.content.length - 1] = {
+            ...tail,
+            content: tail.content.trim() ? `${tail.content}\n\n${joined}` : joined,
+        };
+        return true;
+    }
+    if (Array.isArray(tail.content)) {
+        const blocks = tail.content.slice();
+        const prev = blocks[blocks.length - 1];
+        if (prev?.type === 'text' && typeof prev.text === 'string') {
+            blocks[blocks.length - 1] = { ...prev, text: `${prev.text}\n\n${joined}` };
+        } else {
+            blocks.push({ type: 'text', text: joined });
+        }
+        last.content[last.content.length - 1] = { ...tail, content: blocks };
+        return true;
+    }
+    return false;
+}

package/src/runtime/agent/orchestrator/session/lifecycle-scan.mjs

@@ -0,0 +1,177 @@
+/**
+ * Cheap, bounded top-level-only scan for the `closed`/`generation`
+ * lifecycle fields in a serialized session JSON document — a substitute
+ * for JSON.parse on the session-store save-guard hot path.
+ *
+ * Why not JSON.parse: `generation` is a top-level field on every persisted
+ * session (added by _ensureLifecycleFields on first save), so a raw
+ * substring pre-check (`raw.includes('"generation"')`) is true for nearly
+ * every guarded write — paying full-parse-and-allocate cost (building the
+ * entire messages array, unescaping every string) on the hot path even
+ * though only two scalar fields are ever consulted.
+ *
+ * Why not a regex-only check: a stored message body can itself contain the
+ * literal text `{"closed":true}` (a tool result, a pasted JSON blob, an
+ * assistant-authored snippet) inside `messages[i].content`. A substring or
+ * naively-anchored regex cannot tell that occurrence apart from the real
+ * top-level lifecycle field, so it is spoofable. This scanner walks the raw
+ * text as a real (bracket-depth + string-escape aware) tokenizer, but only
+ * *interprets* key/value pairs at depth 1 (directly inside the root
+ * object); every nested object/array/string value — including the entire
+ * `messages` array — is skipped by depth counting alone, never allocated
+ * or parsed. That keeps it both spoof-proof (nested `"closed"` can never be
+ * mistaken for the top-level one) and cheap (no JS object/array/string
+ * allocation for content we don't care about).
+ *
+ * Returns `{ closed, generation }` (either key absent if the field wasn't
+ * present at depth 1) or `null` if `raw` is not a well-formed top-level
+ * JSON object (caller should treat that the same as a parse failure).
+ *
+ * Scope contract: this is not a general JSON validator. `raw` is always our
+ * own JSON.stringify output (or truncated/concatenated fragments thereof
+ * from partial writes) — never hand-authored or third-party JSON. It is
+ * only responsible for detecting the failure modes a writer like ours can
+ * actually produce: mid-write truncation, nested-field spoofing, mismatched
+ * brackets, and trailing garbage from a botched/partial write. It does NOT
+ * validate separator-level well-formedness (missing/trailing commas,
+ * missing colons beyond the one check above, etc.) since JSON.stringify
+ * cannot emit those — a well-formed prefix is assumed between structural
+ * checks. Anything the scanner doesn't positively confirm returns `null`,
+ * and the caller falls back to `JSON.parse` for the definitive answer.
+ */
+
+function isWs(ch) {
+    return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r';
+}
+
+// True iff raw[i..] is nothing but whitespace to EOF. Enforces the "single
+// complete root JSON object" contract: trailing garbage after the root `}`
+// (e.g. a concatenated second document, or corruption) must not be silently
+// accepted as if `raw` were exactly one well-formed object.
+function isTrailingWhitespaceOnly(raw, i) {
+    const len = raw.length;
+    while (i < len) {
+        if (!isWs(raw[i])) return false;
+        i++;
+    }
+    return true;
+}
+
+// Advances past a JSON string literal starting at raw[i] === '"'.
+// Escape handling only needs to skip exactly one char after each `\` —
+// even for `\u0041`-style escapes, the trailing hex digits can never be
+// `"` or `\`, so a naive 2-char skip never misses the real closing quote.
+function skipString(raw, i) {
+    const len = raw.length;
+    i++; // opening quote
+    while (i < len) {
+        const ch = raw[i];
+        if (ch === '\\') { i += 2; continue; }
+        if (ch === '"') return i + 1;
+        i++;
+    }
+    return i;
+}
+
+// Advances past one JSON value (string/object/array/number/true/false/null)
+// starting at raw[i]. Objects/arrays are skipped via universal bracket-depth
+// counting (any `{`/`[` opens, any `}`/`]` closes) with string-awareness so
+// braces inside string content never perturb the count — never descends
+// into the structure to interpret its keys.
+function skipValue(raw, i) {
+    const len = raw.length;
+    const c = raw[i];
+    if (c === '"') return skipString(raw, i);
+    if (c === '{' || c === '[') {
+        let depth = 1;
+        i++;
+        while (i < len && depth > 0) {
+            const ch = raw[i];
+            if (ch === '"') { i = skipString(raw, i); continue; }
+            if (ch === '{' || ch === '[') depth++;
+            else if (ch === '}' || ch === ']') depth--;
+            i++;
+        }
+        return i;
+    }
+    // number / true / false / null — run to the next structural delimiter.
+    while (i < len && raw[i] !== ',' && raw[i] !== '}' && raw[i] !== ']' && !isWs(raw[i])) i++;
+    return i;
+}
+
+export function scanTopLevelLifecycle(raw) {
+    const len = raw.length;
+    let i = 0;
+    while (i < len && isWs(raw[i])) i++;
+    if (raw[i] !== '{') return null;
+    i++;
+    const result = {};
+    let found = 0;
+    while (i < len) {
+        while (i < len && isWs(raw[i])) i++;
+        if (i >= len) return null;
+        if (raw[i] === '}') {
+            i++;
+            return isTrailingWhitespaceOnly(raw, i) ? result : null;
+        }
+        if (raw[i] === ',') { i++; continue; }
+        if (raw[i] !== '"') return null;
+        const keyStart = i;
+        i = skipString(raw, i);
+        let key;
+        try { key = JSON.parse(raw.slice(keyStart, i)); } catch { return null; }
+        while (i < len && isWs(raw[i])) i++;
+        if (raw[i] !== ':') return null;
+        i++;
+        while (i < len && isWs(raw[i])) i++;
+        if (i >= len) return null;
+        if (key === 'closed' || key === 'generation') {
+            const valStart = i;
+            i = skipValue(raw, i);
+            try { result[key] = JSON.parse(raw.slice(valStart, i)); } catch { return null; }
+            found++;
+            // Both lifecycle fields resolved. We no longer need to interpret
+            // further keys, but we MUST still confirm the root object is not
+            // truncated (e.g. a session file cut off mid-write as
+            // `{"closed":true,"generation":1,"messages":[`) before trusting
+            // `result` — otherwise a truncated-but-field-bearing prefix would
+            // be treated as well-formed. Finish with a cheap depth-only walk
+            // (no key/value JSON.parse) to the matching close of the root
+            // object; only return `result` once that close is actually
+            // reached before EOF.
+            if (found === 2) {
+                // Track exact bracket types (not just depth) so a mismatched
+                // pair anywhere — including the root itself, e.g. malformed
+                // `{"closed":true,"generation":1]` closing the root object
+                // with `]` instead of `}` — is rejected rather than silently
+                // accepted because *a* bracket happened to bring the count to
+                // zero. `stack[0]` is always '}' (the root object we opened
+                // at function entry); the walk must consume exactly that to
+                // finish, and any closer that doesn't match the innermost
+                // opener is a structural error.
+                const stack = ['}'];
+                while (i < len) {
+                    const ch = raw[i];
+                    if (ch === '"') { i = skipString(raw, i); continue; }
+                    if (ch === '{') { stack.push('}'); i++; continue; }
+                    if (ch === '[') { stack.push(']'); i++; continue; }
+                    if (ch === '}' || ch === ']') {
+                        if (stack.pop() !== ch) return null; // mismatched bracket pair
+                        i++;
+                        if (stack.length === 0) {
+                            // Root object closed with '}' — only trust it if
+                            // nothing but whitespace follows to EOF.
+                            return isTrailingWhitespaceOnly(raw, i) ? result : null;
+                        }
+                        continue;
+                    }
+                    i++;
+                }
+                return null; // ran off the end (or hit EOF) before the root object closed: truncated
+            }
+        } else {
+            i = skipValue(raw, i);
+        }
+    }
+    return null; // ran off the end without a closing '}': malformed/truncated
+}

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

@@ -10,29 +10,29 @@ import {
 import {
     compactTypeIsRecallFastTrack,
     compactTypeIsSemantic,
-    normalizeCompactType,
     DEFAULT_COMPACT_TYPE,
     DEFAULT_COMPACTION_KEEP_TOKENS,
     CONTEXT_SHARE_RATIO,
+    COMPACT_TYPE_RECALL_FASTTRACK,
 } from '../compact.mjs';
 import { positiveTokenInt, envFlag, envTokenInt } from './env.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
 
 const COMPACT_SAFETY_PERCENT = 1.00;
 // Unified context-share rule (compact/constants.mjs CONTEXT_SHARE_RATIO): the
-// post-compaction target is 5% of the boundary/context window — the same 5%
+// post-compaction target is 10% of the boundary/context window — the same 10%
 // the recall-fasttrack injection cap uses (loop.mjs recallTokenCap). One
 // number governs every "share of model context" budget.
 const COMPACT_TARGET_RATIO = CONTEXT_SHARE_RATIO;
 const COMPACT_TARGET_MIN_TOKENS = 4_000;
-const COMPACT_TARGET_MAX_TOKENS = 16_000;
 
 function resolveSemanticCompactSetting(sessionRef, cfg = {}) {
-    if (process.env.MIXDOG_AGENT_COMPACT_SEMANTIC !== undefined) return envFlag('MIXDOG_AGENT_COMPACT_SEMANTIC', true);
-    if (cfg.semantic === false || cfg.semantic === 'false' || cfg.semantic === 'off') return false;
-    if (cfg.semantic === true || cfg.semantic === 'true' || cfg.semantic === 'on') return true;
-    // The compact type is already explicit (`semantic` by default). Honor it
-    // directly instead of substituting another compaction path.
+    // Types are hard-locked (agent -> semantic, main/user -> recall-fasttrack).
+    // Semantic must always be available as a compact path or agent sessions
+    // would have none (loop.mjs throws when no type is available). Env/cfg
+    // off-switches no longer apply.
+    void sessionRef;
+    void cfg;
     return true;
 }
 
@@ -43,12 +43,9 @@ function resolveCompactTypeSetting(sessionRef, cfg = {}) {
     // fasttrack compact would inject unrelated main-session memories and drop
     // the agent's own working context. Env/config overrides do not apply.
     if (isAgentOwner(sessionRef)) return DEFAULT_COMPACT_TYPE;
-    const configured = process.env.MIXDOG_AGENT_COMPACT_TYPE
-        ?? process.env.MIXDOG_COMPACT_TYPE
-        ?? cfg.type
-        ?? cfg.compactType
-        ?? cfg.compact_type;
-    return normalizeCompactType(configured, DEFAULT_COMPACT_TYPE);
+    // Non-agent (main/user) sessions are ALWAYS recall-fasttrack. Hard-locked:
+    // config/env overrides no longer change the type.
+    return COMPACT_TYPE_RECALL_FASTTRACK;
 }
 
 function resolveCompactTargetRatio(cfg = {}) {
@@ -74,12 +71,8 @@ function resolveCompactTargetTokens(boundaryTokens, cfg = {}) {
         || envTokenInt('MIXDOG_AGENT_COMPACT_TARGET_MIN_TOKENS')
         || envTokenInt('MIXDOG_COMPACT_TARGET_MIN_TOKENS')
         || COMPACT_TARGET_MIN_TOKENS);
-    const maxTarget = Math.min(boundary, positiveTokenInt(cfg.targetMaxTokens ?? cfg.maxTargetTokens)
-        || envTokenInt('MIXDOG_AGENT_COMPACT_TARGET_MAX_TOKENS')
-        || envTokenInt('MIXDOG_COMPACT_TARGET_MAX_TOKENS')
-        || COMPACT_TARGET_MAX_TOKENS);
     const byRatio = Math.max(1, Math.floor(boundary * resolveCompactTargetRatio(cfg)));
-    return Math.max(1, Math.min(boundary, maxTarget, Math.max(minTarget, byRatio)));
+    return Math.max(1, Math.min(boundary, Math.max(minTarget, byRatio)));
 }
 function resolveCompactKeepTokens(cfg = {}) {
     return positiveTokenInt(cfg.keepTokens ?? cfg.keep?.tokens ?? cfg.preserveRecentTokens)

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

@@ -10,6 +10,8 @@ import { createHash } from 'crypto';
 import { executeInternalTool } from '../../internal-tools.mjs';
 import {
     recallFastTrackCompactMessages,
+    CONTEXT_SHARE_RATIO,
+    RECALL_TOKEN_CAP_FLOOR_TOKENS,
 } from '../compact.mjs';
 import {
     compactDiagnosticError,
@@ -146,6 +148,13 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
     const digestText = buildRecallDigestText(sessionId, digestBody, digestMaxKb);
     diagnostics.finalRecallChars = digestText.length;
     diagnostics.finalRecallBytes = compactByteLength(digestText);
+    const contextWindow = positiveTokenInt(compactPolicy?.contextWindow)
+        || positiveTokenInt(compactPolicy?.boundaryTokens)
+        || positiveTokenInt(sessionRef?.contextWindow)
+        || positiveTokenInt(sessionRef?.compactBoundaryTokens);
+    const recallTokenCap = contextWindow
+        ? Math.max(RECALL_TOKEN_CAP_FLOOR_TOKENS, Math.floor(contextWindow * CONTEXT_SHARE_RATIO))
+        : null;
     const result = recallFastTrackCompactMessages(messages, compactBudgetTokens, {
         reserveTokens: compactPolicy.reserveTokens,
         force: true,
@@ -156,6 +165,7 @@ export async function runRecallFastTrackCompact({ sessionRef, messages, compactB
         tailTurns: compactPolicy.tailTurns,
         keepTokens: compactPolicy.keepTokens,
         preserveRecentTokens: compactPolicy.preserveRecentTokens,
+        recallTokenCap,
     });
     diagnostics.totalMs = Date.now() - startedAt;
     if (result && typeof result === 'object') {

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

@@ -243,6 +243,14 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     let _capFinalTurnUsed = false;
     // True while the granted hard-cap final turn is active (no tool defs).
     let _capFinalToolsDisabled = false;
+    // Consecutive empty-turn contract nudges. A model that answers the same
+    // nudge with another empty turn is in a deterministic livelock (same
+    // context in → same empty completion out); re-sending an identical nudge
+    // 199× just burns the iteration budget (observed: sess_10400…9dfdc436,
+    // 199 identical nudges to the 200-iteration cap). Cap the streak and end
+    // the loop as an explicit empty termination instead.
+    let _emptyNudgeStreak = 0;
+    const EMPTY_NUDGE_MAX = 3;
     // Completion-first steering ladder controller. Owns the (cumulative) level-1
     // fire count, the all-read-only / serial-single / same-file-grep streaks,
     // and the level-2 latch. Threaded via live getters so it reads the loop's
@@ -1158,17 +1166,30 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 continue;
             }
             if (!hasContent && !isHidden) {
+                _emptyNudgeStreak += 1;
+                if (_emptyNudgeStreak > EMPTY_NUDGE_MAX) {
+                    // Livelock: identical nudges keep producing identical empty
+                    // completions. Stop re-prompting; classifyTerminationReason
+                    // tags this final empty response as 'empty' so the caller
+                    // surfaces an explicit error instead of a silent finish.
+                    process.stderr.write(`[loop] empty-turn nudge cap ${EMPTY_NUDGE_MAX} reached (sess=${sessionId || 'unknown'}); ending loop as empty termination.\n`);
+                    break;
+                }
                 let nudgeMsg;
                 if (isIncompleteStop) {
                     nudgeMsg = `[mixdog-runtime] Previous turn ended mid-synthesis (stopReason=${stopReason}) with empty content. Continue — emit your final handoff (fragments, file:line) with your synthesis so far, or call more tools to finish.`;
                 } else {
-                    nudgeMsg = '[mixdog-runtime] Your previous response was empty (no handoff text and no tool call). Either emit your final handoff text now, or continue with tool calls. Do not return an empty turn.';
+                    // Vary the nudge per attempt — a byte-identical repeat
+                    // reinforces the empty-completion pattern it is trying to
+                    // break (the request context stays effectively constant).
+                    nudgeMsg = `[mixdog-runtime] Your previous response was empty (no handoff text and no tool call) — attempt ${_emptyNudgeStreak}/${EMPTY_NUDGE_MAX}. Either emit your final handoff text now, or continue with tool calls. Do not return an empty turn.`;
                 }
                 messages.push({ role: 'user', content: nudgeMsg });
                 continue;
             }
             break;
         }
+        _emptyNudgeStreak = 0;
         const calls = response.toolCalls;
         toolCallsTotal += calls.length;
         // Surface any mid-turn assistant text (preamble that precedes a tool

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

@@ -12,6 +12,8 @@ import {
     effectiveBudget as compactEffectiveBudget,
     compactTypeIsRecallFastTrack,
     compactTypeIsSemantic,
+    CONTEXT_SHARE_RATIO,
+    RECALL_TOKEN_CAP_FLOOR_TOKENS,
 } from '../compact.mjs';
 import { estimateMessagesTokens, estimateRequestReserveTokens, estimateTranscriptContextUsage, resolveCompactBufferRatio } from '../context-utils.mjs';
 import { executeInternalTool } from '../../internal-tools.mjs';
@@ -195,6 +197,11 @@ export async function runSessionCompaction(session, opts = {}) {
     if (compactTypeIsRecallFastTrack(compactType)) {
         try {
             const recallPayload = await runRecallFastTrackForSession(session, messages, opts);
+            const contextWindow = positiveContextWindow(session.contextWindow) || boundary;
+            const recallTokenCap = Math.max(
+                RECALL_TOKEN_CAP_FLOOR_TOKENS,
+                Math.floor(contextWindow * CONTEXT_SHARE_RATIO),
+            );
             recallFastTrackResult = recallFastTrackCompactMessages(messages, budget, {
                 reserveTokens,
                 force: true,
@@ -209,6 +216,7 @@ export async function runSessionCompaction(session, opts = {}) {
                 tailTurns: positiveContextWindow(session.compaction?.tailTurns) || 2,
                 keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
                 preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
+                recallTokenCap,
             });
             if (Array.isArray(recallFastTrackResult?.messages)) {
                 compacted = recallFastTrackResult.messages;