mixdog 0.9.40 → 0.9.43

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

@@ -3,8 +3,11 @@
 // runRecallFastTrackCompact stays in the loop (it drives the recall pipeline
 // against live session state).
 import {
+    contextMessagesSignature,
+    estimateMessagesTokens,
     estimateRequestReserveTokens,
     resolveSessionCompactPolicy,
+    toolSchemaSignature,
 } from '../context-utils.mjs';
 import {
     compactTypeIsRecallFastTrack,
@@ -18,6 +21,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 +95,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);
@@ -130,17 +134,121 @@ export function resolveWorkerCompactPolicy(sessionRef, tools) {
         reserveTokens: requestReserve + configuredReserve,
         requestReserveTokens: requestReserve,
         configuredReserveTokens: configuredReserve,
+        toolSchemaSignature: toolSchemaSignature(tools),
     };
 }
-/** 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',
+    sendTools = sessionRef?.tools,
+} = {}) {
+    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;
+    sessionRef.contextPressureBaselinePrefixSignature = contextMessagesSignature(messages);
+    sessionRef.contextPressureBaselineProvider = sessionRef.provider || null;
+    sessionRef.contextPressureBaselineModel = sessionRef.model || null;
+    sessionRef.contextPressureBaselineToolSignature = toolSchemaSignature(sendTools);
+    // 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.contextPressureBaselinePrefixSignature = null;
+    sessionRef.contextPressureBaselineProvider = null;
+    sessionRef.contextPressureBaselineModel = null;
+    sessionRef.contextPressureBaselineToolSignature = null;
+    sessionRef.contextPressureBaselineUpdatedAt = null;
+    sessionRef.lastContextTokensStaleAfterCompact = true;
+}
+
+function providerBaselinePressureTokens(messages, sessionRef, policy) {
+    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)
+        || sessionRef.contextPressureBaselineProvider !== (sessionRef.provider || null)
+        || sessionRef.contextPressureBaselineModel !== (sessionRef.model || null)
+        || sessionRef.contextPressureBaselineToolSignature !== policy?.toolSchemaSignature
+        || sessionRef.contextPressureBaselinePrefixSignature !== contextMessagesSignature(messages, count)) 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 + Math.max(0, Number(policy?.configuredReserveTokens) || 0));
+    } catch {
+        return null;
+    }
+}
+
+export function resolveCompactionPressureTokens(messageTokensEst, policy, { messages, sessionRef } = {}) {
+    return providerBaselinePressureTokens(messages, sessionRef, policy)
+        ?? 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 +260,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 +344,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,20 @@ 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 (_finalStopReason === 'refusal') {
+        return 'refusal';
+    }
+    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/loop/tool-exec.mjs

@@ -223,21 +223,30 @@ export async function executeTool(name, args, cwd, callerSessionId, sessionRef,
     })();
     if (typeof afterToolHook === 'function') {
         try {
+            // Tool outcome metadata is runtime-internal. Hooks receive the same
+            // model-visible result value they received before transient
+            // envelopes existed, never the envelope object itself.
+            const {
+                result: __res,
+                newMessages: __nm,
+                explicitSuccess: __explicitSuccess,
+            } = normalizeToolEnvelope(__result);
             const hookResult = await afterToolHook({
                 name,
                 args,
                 cwd,
                 sessionId: callerSessionId,
                 toolCallId: executeOpts.toolCallId || null,
-                result: __result,
+                result: __res,
             });
             // Envelope-aware hook override: a PostToolUse hook may override the
             // model-VISIBLE tool output (the envelope's `result` / stub), but it
             // must NEVER drop the `newMessages` channel. Split first, apply the
             // override to `result` only, then re-wrap so newMessages survive.
-            const { result: __res, newMessages: __nm } = normalizeToolEnvelope(__result);
             const __overridden = resolveToolResultAfterHook(__res, hookResult);
-            if (__nm.length) return makeToolEnvelope(__overridden, __nm);
+            if (__nm.length || __explicitSuccess) {
+                return makeToolEnvelope(__overridden, __nm, { explicitSuccess: __explicitSuccess });
+            }
             return __overridden;
         } catch {
             // PostToolUse hooks are best-effort; never let one break the tool result.

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', sendTools: d.sendTools });
+                        }
                         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,9 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             applyAskTerminalUsageTotals(session, result, {
                 skipTotalsIfIncremental: runtime?.usageMetricsTurnIncremental === true,
             });
+            recordProviderContextBaseline(session, session.messages, result.lastTurnUsage || result.usage, {
+                sendTools: result.lastSendTools,
+            });
             // 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

@@ -29,6 +29,7 @@ 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
@@ -539,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/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/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/result-classification.mjs

@@ -40,6 +40,8 @@
  *   "(no lines in range"    — read offset out-of-range       (builtin.mjs:739, 3571)
  *
  * @param {unknown} result
+ * @param {boolean} [explicitSuccess=false] true only when the tool handler
+ * explicitly returned `isError: false`
  * @returns {'normal' | 'error' | 'zero-match'}
  */
 const ZERO_MATCH_PREFIXES = [
@@ -56,7 +58,8 @@ const ZERO_MATCH_PREFIXES = [
     '(no lines in range',
 ];
 
-export function classifyResultKind(result) {
+export function classifyResultKind(result, explicitSuccess = false) {
+    if (explicitSuccess === true) return 'normal';
     if (typeof result !== 'string') return 'normal';
     const trimmed = result.trimStart();
     if (/^error(?:\s+\[code\b|\s*:)/i.test(trimmed) || /^\[error/i.test(trimmed) || /^\[exit code:/i.test(trimmed)) return 'error';

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/tool-batch.mjs

@@ -32,6 +32,11 @@ import { crossTurnSignature, crossTurnDedupStub, isEditProgressTool } from './lo
 import { getToolKind, isEagerDispatchable, parseNativeToolSearchPayload } from './loop/tool-helpers.mjs';
 import { restoreToolCallBodyForId, dropCompactedBodyArgsForId } from './loop/stored-tool-args.mjs';
 
+function classifyToolReturn(value) {
+    const normalized = normalizeToolEnvelope(value);
+    return classifyResultKind(normalized.result, normalized.explicitSuccess);
+}
+
 export async function processToolBatch(ctx) {
     const {
         calls, messages, tools, cwd, sessionId, sessionRef, signal, opts,
@@ -258,7 +263,7 @@ export async function processToolBatch(ctx) {
                     if (!settled.ok) throw settled.error;
                     result = settled.value;
                     toolEndedAt = eager.endedAt ?? Date.now();
-                    const _eagerKind = classifyResultKind(result);
+                    const _eagerKind = classifyToolReturn(result);
                     if (_eagerKind === 'error') {
                         _resultKind = 'error';
                         _executeOk = false;
@@ -286,7 +291,7 @@ export async function processToolBatch(ctx) {
                         // Boundary: tool-return string convention → structural kind.
                         // The only prefix check in this codebase; downstream layers
                         // operate on _resultKind.
-                        if (classifyResultKind(result) === 'error') {
+                        if (classifyToolReturn(result) === 'error') {
                             _resultKind = 'error';
                             _executeOk = false;
                         } else {

package/src/runtime/agent/orchestrator/session/tool-envelope.mjs

@@ -5,7 +5,8 @@
  *   - legacy: a string (or existing structured media object) — unchanged, OR
  *   - an envelope object:
  *       { __toolEnvelope: true, result: <string|structured>,
- *         newMessages: [{ role:'user', content:'...' }, ...] }
+ *         newMessages: [{ role:'user', content:'...' }, ...],
+ *         explicitSuccess?: true }
  *
  * The `__toolEnvelope` marker is deliberately namespaced so it can NEVER be
  * confused with the existing structured media content objects that
@@ -37,17 +38,18 @@ function isValidNewMessage(m) {
  * sees as the tool_result; `newMessages` are appended (as their own
  * messages, e.g. role:'user') AFTER the batch's tool results.
  */
-export function makeToolEnvelope(result, newMessages = []) {
+export function makeToolEnvelope(result, newMessages = [], options = {}) {
     return {
         [TOOL_ENVELOPE_MARKER]: true,
         result,
         newMessages: Array.isArray(newMessages) ? newMessages.filter(isValidNewMessage) : [],
+        ...(options.explicitSuccess === true ? { explicitSuccess: true } : {}),
     };
 }
 
 /**
- * Split a tool return value into `{ result, newMessages }`.
- *   - legacy string/object → { result: value, newMessages: [] }
+ * Split a tool return value into `{ result, newMessages, explicitSuccess }`.
+ *   - legacy string/object → { result: value, newMessages: [], explicitSuccess: false }
  *   - envelope             → { result, newMessages } (newMessages validated)
  */
 export function normalizeToolEnvelope(value) {
@@ -55,7 +57,7 @@ export function normalizeToolEnvelope(value) {
         const newMessages = Array.isArray(value.newMessages)
             ? value.newMessages.filter(isValidNewMessage)
             : [];
-        return { result: value.result, newMessages };
+        return { result: value.result, newMessages, explicitSuccess: value.explicitSuccess === true };
     }
-    return { result: value, newMessages: [] };
+    return { result: value, newMessages: [], explicitSuccess: false };
 }