mixdog 0.9.39 → 0.9.41

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

@@ -3,6 +3,7 @@
 // runRecallFastTrackCompact stays in the loop (it drives the recall pipeline
 // against live session state).
 import {
+    estimateMessagesTokens,
     estimateRequestReserveTokens,
     resolveSessionCompactPolicy,
 } from '../context-utils.mjs';
@@ -18,6 +19,7 @@ import {
 } from '../compact.mjs';
 import { positiveTokenInt, envFlag, envTokenInt } from './env.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
+import { providerInputExcludesCache } from '../../providers/registry.mjs';
 
 // Unified context-share rule (compact/constants.mjs CONTEXT_SHARE_RATIO): the
 // post-compaction target is 10% of the boundary/context window — the same 10%
@@ -91,8 +93,8 @@ export function resolveWorkerCompactPolicy(sessionRef, tools) {
     if (!boundaryTokens) return null;
     const compactBoundaryTokens = Math.max(1, Math.floor(boundaryTokens * COMPACT_SAFETY_PERCENT));
     // Shared session-compaction policy (context-utils): agent semantic keeps the
-    // default early-trigger buffer (90%); main/user compact on the boundary
-    // (100%); a truly-explicit sub-boundary limit wins. explicitAutoCompactTokenLimit
+    // default early-trigger buffer (90%); main/user keep 5% headroom (95%);
+    // a truly-explicit sub-boundary limit wins. explicitAutoCompactTokenLimit
     // is the sanitized (null when legacy full-window) value so telemetry never
     // re-persists a boundary-collapsing limit.
     const policy = resolveSessionCompactPolicy(sessionRef, compactBoundaryTokens);
@@ -132,15 +134,103 @@ export function resolveWorkerCompactPolicy(sessionRef, tools) {
         configuredReserveTokens: configuredReserve,
     };
 }
-/** Transcript + request reserve only (never provider lastContextTokens). */
+/** Transcript + request reserve fallback used until an aligned provider baseline exists. */
 function compactPressureTokens(messageTokensEst, policy) {
     if (messageTokensEst === null) return 0;
     return Math.max(0, messageTokensEst + (policy?.reserveTokens || 0));
 }
 
+function providerPressureTokens(sessionRef, usage) {
+    if (!usage || typeof usage !== 'object') return 0;
+    const input = Math.max(0, Number(usage.inputTokens) || 0);
+    const cachedRead = Math.max(0, Number(usage.cachedTokens) || 0);
+    const cacheWrite = Math.max(0, Number(usage.cacheWriteTokens) || 0);
+    const explicitPrompt = Math.max(0, Number(usage.promptTokens) || 0);
+    const normalizedPrompt = providerInputExcludesCache(sessionRef?.provider)
+        ? input + cachedRead + cacheWrite
+        : input;
+    const prompt = Math.max(explicitPrompt, normalizedPrompt);
+    const output = Math.max(0, Number(usage.outputTokens) || 0);
+    return Math.max(0, Math.round(prompt + output));
+}
+
+/**
+ * Align an authoritative provider usage snapshot to the message prefix it
+ * covers. Later pressure checks add estimates only for messages after this
+ * baseline, matching Claude Code's actual-usage-plus-growth accounting.
+ */
+export function recordProviderContextBaseline(sessionRef, messages, usage, { boundary = 'complete' } = {}) {
+    if (!sessionRef || !Array.isArray(messages)) return false;
+    const tokens = providerPressureTokens(sessionRef, usage);
+    if (!tokens) return false;
+    sessionRef.contextPressureBaselineTokens = tokens;
+    sessionRef.contextPressureBaselineOutputTokens = Math.max(0, Math.round(Number(usage?.outputTokens) || 0));
+    sessionRef.contextPressureBaselineMessageCount = messages.length;
+    // provider_send usage arrives before the response's assistant message is
+    // appended. Mark that request boundary so pressure resolution skips the
+    // first subsequent assistant representation: its output (including opaque
+    // reasoningItems/tool calls) is already authoritative provider usage.
+    sessionRef.contextPressureBaselineBoundary = boundary === 'request' ? 'request' : 'complete';
+    sessionRef.contextPressureBaselineUpdatedAt = Date.now();
+    sessionRef.lastContextTokensStaleAfterCompact = false;
+    return true;
+}
+
+/** A changed transcript cannot reuse usage measured against its old prefix. */
+export function invalidateProviderContextBaseline(sessionRef) {
+    if (!sessionRef) return;
+    sessionRef.contextPressureBaselineTokens = null;
+    sessionRef.contextPressureBaselineOutputTokens = null;
+    sessionRef.contextPressureBaselineMessageCount = null;
+    sessionRef.contextPressureBaselineBoundary = null;
+    sessionRef.contextPressureBaselineUpdatedAt = null;
+    sessionRef.lastContextTokensStaleAfterCompact = true;
+}
+
+function providerBaselinePressureTokens(messages, sessionRef) {
+    if (!Array.isArray(messages) || !sessionRef
+        || sessionRef.lastContextTokensStaleAfterCompact === true) return null;
+    let tokens = positiveTokenInt(sessionRef.contextPressureBaselineTokens);
+    const outputTokens = Math.max(0, Number(sessionRef.contextPressureBaselineOutputTokens) || 0);
+    let count = Number(sessionRef.contextPressureBaselineMessageCount);
+    const baselineAt = Number(sessionRef.contextPressureBaselineUpdatedAt || 0);
+    const compactAt = Number(sessionRef.compaction?.lastChangedAt || sessionRef.compaction?.lastCompactAt || 0);
+    if (!tokens || !Number.isInteger(count) || count < 0 || count > messages.length
+        || (compactAt > 0 && baselineAt > 0 && baselineAt < compactAt)) return null;
+    if (sessionRef.contextPressureBaselineBoundary === 'request') {
+        const assistantOffset = messages.slice(count).findIndex(message => message?.role === 'assistant');
+        if (assistantOffset >= 0) {
+            // The represented assistant is covered by actual output usage.
+            count += assistantOffset + 1;
+        } else {
+            // Empty/thinking-only continuations append no assistant replay.
+            // Their output was billed but is absent from the next request, so
+            // remove it and estimate every genuinely later message (the nudge).
+            tokens = Math.max(0, tokens - outputTokens);
+        }
+    }
+    try {
+        const growth = count < messages.length
+            ? estimateMessagesTokens(messages.slice(count))
+            : 0;
+        return Math.max(0, tokens + growth);
+    } catch {
+        return null;
+    }
+}
+
+export function resolveCompactionPressureTokens(messageTokensEst, policy, { messages, sessionRef } = {}) {
+    return providerBaselinePressureTokens(messages, sessionRef)
+        ?? compactPressureTokens(messageTokensEst, policy);
+}
+
 /** Telemetry pressure when a reactive overflow retry forces the next compact. */
-export function compactionTelemetryPressureTokens(messageTokensEst, policy, { reactivePending = false } = {}) {
-    const base = compactPressureTokens(messageTokensEst, policy);
+export function compactionTelemetryPressureTokens(messageTokensEst, policy, {
+    reactivePending = false,
+    messages,
+    sessionRef,
+} = {}) {
+    const base = resolveCompactionPressureTokens(messageTokensEst, policy, { messages, sessionRef });
     if (!reactivePending) return base;
     const floor = positiveTokenInt(policy?.triggerTokens) || positiveTokenInt(policy?.boundaryTokens) || 0;
     return floor ? Math.max(base, floor) : base;
@@ -152,11 +242,19 @@ export function compactTargetBudget(policy) {
     const targetEffective = resolveCompactTargetTokens(boundary, policy) || boundary;
     return Math.max(1, Math.min(boundary, targetEffective + reserve));
 }
-export function shouldCompactForSession(messageTokensEst, policy, { forceReactive = false } = {}) {
+export function shouldCompactForSession(messageTokensEst, policy, {
+    forceReactive = false,
+    messages,
+    sessionRef,
+    pressureTokens,
+} = {}) {
     if (!policy?.auto || !policy.boundaryTokens) return false;
     if (forceReactive) return true;
     if (messageTokensEst === null) return true;
-    return compactPressureTokens(messageTokensEst, policy) >= (policy.triggerTokens || policy.boundaryTokens);
+    const pressure = Number.isFinite(Number(pressureTokens))
+        ? Number(pressureTokens)
+        : resolveCompactionPressureTokens(messageTokensEst, policy, { messages, sessionRef });
+    return pressure >= (policy.triggerTokens || policy.boundaryTokens);
 }
 export function countPrunedToolOutputs(before, after) {
     if (!Array.isArray(before) || !Array.isArray(after)) return 0;
@@ -228,7 +326,7 @@ export function rememberCompactTelemetry(sessionRef, policy, meta = {}) {
         const changedAt = Date.now();
         sessionRef.compaction.lastChangedAt = changedAt;
         sessionRef.compaction.lastCompactAt = changedAt;
-        sessionRef.lastContextTokensStaleAfterCompact = true;
+        invalidateProviderContextBaseline(sessionRef);
     }
     sessionRef.contextWindow = policy.contextWindow || sessionRef.contextWindow;
     sessionRef.rawContextWindow = policy.rawContextWindow || sessionRef.rawContextWindow;

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

@@ -146,6 +146,14 @@ export function createSteeringLadder(ctx) {
     // read-permission sessions legitimately never edit, so they get the
     // report-oriented level-2 text.
     const readOnlyRole = ctx.readOnlyRole === true;
+    // Edit-push steering is EXPLORER-ONLY: leads legitimately read broadly
+    // before delegating, and reviewer/debugger-style roles read continuously
+    // by design. Pushing "start editing / apply the edit" at those roles
+    // suppresses delegation (observed on TB2.1: forced-delegation workflow
+    // leads went solo right after these nudges). Non-explorer roles keep the
+    // batching guidance but never receive an edit directive, and level-2
+    // edit-push is skipped for them entirely.
+    const editPushEligible = sessionAgent === 'explorer';
 
     // Step 1: escalation ladder. _level1FireCount is CUMULATIVE (never reset)
     // so repeated batching reminders accumulate across the whole session.
@@ -194,6 +202,7 @@ export function createSteeringLadder(ctx) {
     // level-1 streak and the independent all-read-only streak). Sets the latch
     // so it fires at most once per 5 turns regardless of which path triggered.
     const _emitLevel2Steer = () => {
+        if (!editPushEligible && !readOnlyRole) return;
         const iterations = getIterations();
         _level2LatchAtIteration = iterations;
         _level2FireCount += 1;
@@ -252,7 +261,9 @@ export function createSteeringLadder(ctx) {
                     if (_canEscalate) {
                         _emitLevel2Steer();
                     } else {
-                        pushSystemReminder('Last 2 turns each ran a single read-only tool. Batch independent lookups (read/grep/glob/code_graph) into ONE turn, or start editing if you have enough context.');
+                        pushSystemReminder(editPushEligible
+                            ? 'Last 2 turns each ran a single read-only tool. Batch independent lookups (read/grep/glob/code_graph) into ONE turn, or start editing if you have enough context.'
+                            : 'Last 2 turns each ran a single read-only tool. Batch independent lookups (read/grep/glob/code_graph) into ONE turn.');
                     }
                     _hintFiredThisTurn = true;
                 }

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

@@ -3,14 +3,27 @@
 // the classification ladder is verbatim from the tail of agentLoop.
 import { HIDDEN_AGENT_NAMES } from './hidden-agents.mjs';
 
-// Stop reasons that signal the turn was cut short mid-synthesis (token cap,
-// provider pause). Empty content + one of these reasons means the worker
-// was not done. Covers Anthropic (pause_turn, max_tokens), OpenAI (length),
-// Gemini (MAX_TOKENS, OTHER), and case variants.
+// Stop reasons that signal the turn was cut short mid-synthesis. This broad set
+// retains the pre-existing EMPTY-turn nudge semantics for provider pauses and
+// unknown Gemini stops; only OUTPUT_LIMIT_STOP_REASONS below is eligible for
+// non-empty continuation recovery.
 export const INCOMPLETE_STOP_REASONS = new Set([
     'pause_turn', 'max_tokens', 'length', 'MAX_TOKENS', 'OTHER',
 ]);
 
+// True provider output ceilings. pause_turn is a provider-controlled pause and
+// Gemini OTHER is intentionally opaque; neither is safe to treat as a token-cap
+// continuation. Compare case-insensitively so provider spelling variants do not
+// create a second policy.
+export const OUTPUT_LIMIT_STOP_REASONS = new Set([
+    'length', 'max_tokens', 'max_output_tokens',
+]);
+
+export function isOutputLimitStopReason(reason) {
+    return typeof reason === 'string'
+        && OUTPUT_LIMIT_STOP_REASONS.has(reason.trim().toLowerCase());
+}
+
 // Classify WHY the loop ended so agent-tool can promote an empty/abnormal
 // finish to an explicit Lead-facing error instead of a silent empty
 // "completed". Determine "has content" exactly the way the no-tool-call
@@ -23,15 +36,17 @@ export function classifyTerminationReason(response, {
         || (typeof response?.reasoningContent === 'string' && response.reasoningContent.trim().length > 0);
     const _finalStopReason = response?.stopReason ?? response?.stop_reason ?? null;
     const _finalIncompleteStop = _finalStopReason && INCOMPLETE_STOP_REASONS.has(_finalStopReason);
+    const _finalOutputLimitStop = isOutputLimitStopReason(_finalStopReason);
     const _finalIsHidden = HIDDEN_AGENT_NAMES.has(sessionAgent);
     if (terminatedByCap) {
         // Real problem regardless of hidden/public: the loop never terminated
         // on its own contract.
         return 'iteration_cap';
     }
-    if (!_finalHasContent && _finalIncompleteStop) {
-        // Cut short mid-synthesis (token cap / provider pause). Real problem
-        // for hidden agents too.
+    if (_finalOutputLimitStop || (!_finalHasContent && _finalIncompleteStop)) {
+        // Exhausted token-cap recovery is abnormal even with preserved partial
+        // text. pause_turn/OTHER retain their prior non-empty completion
+        // semantics, while their empty forms remain abnormal.
         return 'truncated';
     }
     if (!_finalHasContent && !_finalIsHidden) {

package/src/runtime/agent/orchestrator/session/manager/ask-session.mjs

@@ -44,6 +44,7 @@ import { _tryBridgeExplicitPrefetch } from './prefetch-bridge.mjs';
 import { sanitizeSessionMessagesForModel, persistCompactedOutgoingAfterAskFailure } from './message-sanitize.mjs';
 import { _getAgentLoop } from './runtime-loaders.mjs';
 import { getAgentRuntimeSync } from './agent-runtime-singleton.mjs';
+import { recordProviderContextBaseline } from '../loop/compact-policy.mjs';
 
 /**
  * Wrap an async call so that if the session's controller aborts mid-flight,
@@ -327,6 +328,21 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     onAssistantText: typeof askOpts?.onAssistantText === 'function' ? askOpts.onAssistantText : undefined,
                     onUsageDelta: (d) => {
                         persistIterationMetrics(d).catch(() => {});
+                        // provider_send usage arrives before agentLoop appends
+                        // the assistant response. Preserve the full actual
+                        // input/cache/output count and mark this request
+                        // boundary; compact pressure will skip that first
+                        // assistant representation and estimate only later
+                        // tool results/steering.
+                        if (d?.source === 'provider_send') {
+                            recordProviderContextBaseline(session, outgoing, {
+                                inputTokens: d.deltaInput,
+                                outputTokens: d.deltaOutput,
+                                promptTokens: d.deltaPrompt,
+                                cachedTokens: d.deltaCachedRead,
+                                cacheWriteTokens: d.deltaCacheWrite,
+                            }, { boundary: 'request' });
+                        }
                         try { askOpts?.onUsageDelta?.(d); } catch {}
                     },
                     onToolResult: typeof askOpts?.onToolResult === 'function' ? askOpts.onToolResult : undefined,
@@ -401,12 +417,20 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // contextStatus() reverts to the authoritative committed transcript.
             session.liveTurnMessages = null;
             if (result.content || result.reasoningContent) {
+                // Max-output recovery returns the complete concatenated text to
+                // callers/TUI, while outgoing already contains prior partial
+                // assistant turns and their continuation prompts. Persist only
+                // the terminal segment here so model history contains every byte
+                // exactly once.
+                const persistedAssistantContent = typeof result.historyContent === 'string'
+                    ? result.historyContent
+                    : (result.content || '');
                 session.messages.push({
                     role: 'assistant',
                     // Keep content as-is in memory (model-visible). Image bytes,
                     // if any, are swapped for a placeholder only at disk write
                     // time inside the session store (store.mjs _sessionForDisk).
-                    content: result.content || '',
+                    content: persistedAssistantContent,
                     ...(typeof result.reasoningContent === 'string' && result.reasoningContent
                         ? { reasoningContent: result.reasoningContent }
                         : {}),
@@ -458,6 +482,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             applyAskTerminalUsageTotals(session, result, {
                 skipTotalsIfIncremental: runtime?.usageMetricsTurnIncremental === true,
             });
+            recordProviderContextBaseline(session, session.messages, result.lastTurnUsage || result.usage);
             // Agent Runtime cache stats — record hit/miss after every successful
             // ask so the registry reflects all agent traffic, not just
             // maintenance cycles. Guarded against any agent-runtime error so

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

@@ -26,6 +26,10 @@ 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';
+import { invalidateProviderContextBaseline } from '../loop/compact-policy.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 +493,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 || {}),
@@ -524,7 +540,7 @@ export async function runSessionCompaction(session, opts = {}) {
         } : null,
         compactCount: (session.compaction?.compactCount || 0) + (changed ? 1 : 0),
     };
-    if (changed && mode === 'auto') session.lastContextTokensStaleAfterCompact = true;
+    if (changed) invalidateProviderContextBaseline(session);
     return {
         changed,
         reason: unchangedReason,

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -1,6 +1,7 @@
 // Steering / pending-message queue with sync buffered + atomic-file persistence.
 // Extracted verbatim from manager.mjs (behavior-preserving).
 import { join } from 'path';
+import { readFileSync } from 'fs';
 import { resolvePluginData } from '../../../../shared/plugin-paths.mjs';
 import { updateJsonAtomicSync, updateJsonAtomic } from '../../../../shared/atomic-file.mjs';
 import { promptContentText, isInternalRuntimeNotificationText } from './prompt-utils.mjs';
@@ -458,6 +459,31 @@ export function drainPendingMessages(sessionId) {
     return out;
 }
 
+// Snapshot queued entries without draining them. Compaction uses this to keep
+// sidecars referenced by a message that is waiting for the next turn, whether
+// it is still in memory, buffered for persistence, or already on disk.
+export function _getPendingMessagesForSession(sessionId) {
+    if (!isValidPendingSessionId(sessionId)) return [];
+    const queued = [
+        ...(_sessionPendingMessages.get(sessionId) || []),
+        ...(_pendingPersistBuffers.get(sessionId) || []),
+    ];
+    let raw;
+    try {
+        raw = readFileSync(pendingMessagesPath(), 'utf8');
+    } catch (err) {
+        if (err?.code === 'ENOENT') return queued;
+        throw err;
+    }
+    try {
+        const persisted = normalizePendingStore(JSON.parse(raw)).sessions[sessionId];
+        if (Array.isArray(persisted)) queued.push(...persisted);
+    } catch (err) {
+        throw err;
+    }
+    return queued;
+}
+
 // Cleanup hook for closeSession — drop the in-memory queue and buffered-persist
 // entry so both Maps do not accumulate one entry per closed session.
 export function _dropPendingMessageState(id, { clearPersisted = true } = {}) {

package/src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs

@@ -11,7 +11,7 @@
 // avoid a circular import back into manager.mjs.
 //
 // Entry shape: {
-//   stage, lastStreamDeltaAt, lastToolCall, lastError, updatedAt,
+//   stage, lastStreamDeltaAt, lastTransportAt, lastToolCall, lastError, updatedAt,
 //   controller?: AbortController,  // set while an ask is in flight
 //   generation?: number,            // snapshot taken at ask start
 //   closed?: boolean,               // flipped by closeSession()
@@ -46,7 +46,7 @@ export function configureRuntimeLiveness(deps = {}) {
 export function _touchRuntime(id) {
     let entry = _runtimeState.get(id);
     if (!entry) {
-        entry = { stage: 'idle', lastStreamDeltaAt: null, lastToolCall: null, lastError: null, updatedAt: Date.now() };
+        entry = { stage: 'idle', lastStreamDeltaAt: null, lastTransportAt: null, lastToolCall: null, lastError: null, updatedAt: Date.now() };
         _runtimeState.set(id, entry);
     }
     return entry;
@@ -106,6 +106,8 @@ export function markSessionAskStart(id) {
     if (sessionForTurn) bumpUsageMetricsTurnId(sessionForTurn);
     entry.stage = 'connecting';
     entry.lastStreamDeltaAt = null;
+    entry.lastTransportAt = null;
+    entry.transportTrackingEnabled = false;
     entry.lastToolCall = null;
     entry.toolStartedAt = null;
     entry.toolSelfDeadlineMs = null;
@@ -134,6 +136,27 @@ export function markSessionAskStart(id) {
     // markSessionStreamDelta keeps refreshing once chunks arrive.
     publishHeartbeat(id, now);
 }
+export function enableSessionTransportTracking(id) {
+    if (!id) return;
+    const entry = _runtimeState.get(id);
+    if (!entry || entry.closed || entry.controller?.signal?.aborted) return;
+    entry.transportTrackingEnabled = true;
+}
+export function disableSessionTransportTracking(id) {
+    if (!id) return;
+    const entry = _runtimeState.get(id);
+    if (!entry) return;
+    entry.transportTrackingEnabled = false;
+}
+export function markSessionTransportActivity(id) {
+    if (!id) return;
+    const entry = _runtimeState.get(id);
+    if (!entry || entry.closed || entry.controller?.signal?.aborted) return;
+    const now = Date.now();
+    entry.lastTransportAt = now;
+    entry.updatedAt = now;
+    publishHeartbeat(id, now);
+}
 export async function markSessionStreamDelta(id) {
     if (!id) return;
     // Non-creating lookup: a live ask ALWAYS has a runtime entry (markSessionAskStart
@@ -285,16 +308,20 @@ export function getSessionProgressSnapshot(sessionId) {
         entry.toolStartedAt || 0,
     );
     const stage = entry.stage || 'idle';
+    const waitingStage = stage === 'connecting'
+        || stage === 'requesting'
+        || (stage === 'streaming' && entry.transportTrackingEnabled === true);
     const waitingForFirstActivity = Boolean(
         modelRequestStartedAt
-        && (stage === 'connecting' || stage === 'requesting')
-        && firstActivityAt <= modelRequestStartedAt
+        && waitingStage
+        && (!firstActivityAt || firstActivityAt <= modelRequestStartedAt)
     );
     return {
         stage,
         askStartedAt,
         modelRequestStartedAt,
         firstActivityAt,
+        lastTransportAt: entry.lastTransportAt || 0,
         lastStreamDeltaAt: entry.lastStreamDeltaAt || 0,
         toolStartedAt: entry.toolStartedAt || 0,
         currentTool: entry.lastToolCall || null,

package/src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs

@@ -163,6 +163,8 @@ export function bumpUsageMetricsTurnId(session) {
     if (!session || typeof session !== 'object') return 0;
     const next = (Number(session.usageMetricsTurnId) || 0) + 1;
     session.usageMetricsTurnId = next;
+    const seen = _metricSeenIter.get(session.id);
+    if (seen) seen.clear();
     return next;
 }
 

package/src/runtime/agent/orchestrator/session/pre-send-compact.mjs

@@ -61,8 +61,17 @@ export async function runPreSendCompactPass(state) {
             };
             const messageTokensEst = estimateMessagesTokensSafe(messages);
             const reactivePending = reactiveOverflowRetryPending === true;
-            const shouldCompact = shouldCompactForSession(messageTokensEst, compactPolicy, { forceReactive: reactivePending });
-            const pressureTokens = compactionTelemetryPressureTokens(messageTokensEst, compactPolicy, { reactivePending });
+            const pressureTokens = compactionTelemetryPressureTokens(messageTokensEst, compactPolicy, {
+                reactivePending,
+                messages,
+                sessionRef,
+            });
+            const shouldCompact = shouldCompactForSession(messageTokensEst, compactPolicy, {
+                forceReactive: reactivePending,
+                messages,
+                sessionRef,
+                pressureTokens,
+            });
             // A pending reactive-overflow retry makes THIS compact pass the
             // recovery from a provider overflow refusal, not the proactive
             // pressure trigger. Tag the emitted events so telemetry can tell

package/src/runtime/agent/orchestrator/session/send-with-recovery.mjs

@@ -9,6 +9,24 @@ import { isContextOverflowError } from '../providers/retry-classifier.mjs';
 import { resolveWorkerCompactPolicy } from './loop/compact-policy.mjs';
 import { agentContextOverflowError } from './loop/context-overflow.mjs';
 import { estimateMessagesTokensSafe } from './loop/compact-debug.mjs';
+import { isOutputLimitStopReason } from './loop/termination.mjs';
+
+function normalizedIncompleteUsage(raw) {
+    if (!raw || typeof raw !== 'object') return undefined;
+    const inputTokens = Number(raw.promptTokenCount ?? raw.prompt_token_count ?? raw.input_tokens ?? raw.prompt_tokens ?? 0) || 0;
+    const candidateTokens = Number(raw.candidatesTokenCount ?? raw.candidates_token_count ?? 0) || 0;
+    const thoughtTokens = Number(raw.thoughtsTokenCount ?? raw.thoughts_token_count ?? 0) || 0;
+    const outputFallback = Number(raw.output_tokens ?? raw.completion_tokens ?? 0) || 0;
+    const cachedTokens = Number(raw.cachedContentTokenCount ?? raw.cached_content_token_count ?? raw.cached_tokens ?? 0) || 0;
+    return {
+        inputTokens,
+        outputTokens: candidateTokens + thoughtTokens || outputFallback,
+        cachedTokens,
+        cacheWriteTokens: 0,
+        promptTokens: inputTokens,
+        raw,
+    };
+}
 
 export async function sendWithRecovery(ctx) {
     const {
@@ -19,6 +37,33 @@ export async function sendWithRecovery(ctx) {
         try {
             response = await provider.send(messages, model, sendTools.length ? sendTools : undefined, opts);
         } catch (sendErr) {
+            // Gemini REST/SDK reports MAX_TOKENS by throwing a typed
+            // ProviderIncompleteError after preserving the streamed candidate.
+            // Normalize only that exact, safe no-tool output-limit shape into a
+            // regular truncated response; all moderation/OTHER/tool-bearing and
+            // unrelated errors continue through their existing error paths.
+            if (
+                sendErr?.providerIncomplete === true
+                && sendErr.code === 'PROVIDER_INCOMPLETE'
+                && isOutputLimitStopReason(sendErr.finishReason)
+                && typeof sendErr.partialContent === 'string'
+                && sendErr.partialContent.trim().length > 0
+                && sendErr.pendingToolUse !== true
+                && sendErr.emittedToolCall !== true
+                && !(Array.isArray(sendErr.partialToolCalls) && sendErr.partialToolCalls.length > 0)
+            ) {
+                response = {
+                    content: sendErr.partialContent,
+                    model: sendErr.model || model,
+                    toolCalls: undefined,
+                    usage: normalizedIncompleteUsage(sendErr.rawUsage),
+                    stopReason: sendErr.finishReason,
+                    truncated: true,
+                    providerState: opts.providerState,
+                    providerIncompleteRecovery: true,
+                };
+                return { action: 'proceed', response };
+            } else
             // Partial-final recovery (owner-notify fix): the recurring "worker
             // finished but the task hung / no result delivered" case is a FINAL,
             // no-tool summary stream that wedges (ping-only) AFTER all real tool

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

@@ -289,7 +289,10 @@ function _getOrSpawnWorker() {
         // (the originating call plus any that coalesced onto it before it was
         // posted). A supersede never lands here as a rejection — only a real
         // worker failure does.
-        if (ok) { for (const w of waiters) w.resolve(); }
+        if (ok) {
+            clearSessionSaveError(id);
+            for (const w of waiters) w.resolve();
+        }
         else {
             const e = new Error(`[session-store] worker save failed: ${error}`);
             for (const w of waiters) w.reject(e);
@@ -441,6 +444,7 @@ function _doSaveSync(payload) {
         }
         _renameWithRetrySync(tmp, target);
         _upsertSessionSummary(session);
+        clearSessionSaveError(id);
     } catch (err) {
         try { unlinkSync(tmp); } catch { /* ignore cleanup failure */ }
         throw err;
@@ -580,6 +584,7 @@ async function _doSave(payload) {
         }
         _renameWithRetrySync(tmp, target);
         _upsertSessionSummary(session);
+        clearSessionSaveError(id);
     } catch (err) {
         try { unlinkSync(tmp); } catch { /* ignore cleanup failure */ }
         _savePending.delete(id);
@@ -643,6 +648,7 @@ export function markSessionClosed(id, reason = 'manual') {
         return null;
     }
     _savePending.delete(id);
+    clearSessionSaveError(id);
     _clearLiveSession(id);
     _deleteHeartbeat(id);
     _upsertSessionSummary(tombstone);
@@ -702,6 +708,7 @@ export function bumpSessionGeneration(id, reason = 'detach') {
         return null;
     }
     _savePending.delete(id);
+    clearSessionSaveError(id);
     _clearLiveSession(id);
     _deleteHeartbeat(id);
     _upsertSessionSummary(detached);
@@ -748,6 +755,7 @@ export function deleteSession(id, options = {}) {
         catch { /* fall through to .hb cleanup */ }
     }
     _deleteHeartbeat(id);
+    if (removed || !existsSync(path)) clearSessionSaveError(id);
     // deferSummaryUpdate: bulk callers (tombstone sweep) remove thousands of
     // rows — a per-id _removeSessionSummary would parse+rewrite the multi-MB
     // summary index once PER DELETION. They batch the index update themselves.