mixdog 0.9.40 → 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

@@ -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/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/tools/builtin/bash-tool.mjs

@@ -297,10 +297,9 @@ export async function executeBashTool(args, workDir, options = {}) {
     // Keep foreground commands on a long tool-owned timeout. The MCP dispatch
     // layer must not add a shorter fallback ceiling when timeout is omitted.
     // Reference-CLI parity (opencode/codex/claude-code): sync-first, no hard
-    // upper ceiling on a caller-provided timeout. Default 120 s (2 min) when
-    // omitted; BASH_DEFAULT_TIMEOUT_MS / BASH_MAX_TIMEOUT_MS env overrides keep
-    // their semantics (max floored at default) but only bound the *omitted*
-    // default — an explicit args.timeout is honored UNCAPPED.
+    // upper ceiling on a caller-provided total timeout. Default 120 s (2 min)
+    // when omitted; BASH_DEFAULT_TIMEOUT_MS / BASH_MAX_TIMEOUT_MS env overrides
+    // bound the blocking window when timeout promotion is available.
     const _envDefaultTimeout = parseInt(process.env.BASH_DEFAULT_TIMEOUT_MS ?? '', 10);
     const DEFAULT_BASH_TIMEOUT_MS = _envDefaultTimeout > 0 ? _envDefaultTimeout : 120_000;
     // Background (async / run_in_background) jobs get NO omitted default: 0
@@ -315,8 +314,14 @@ export async function executeBashTool(args, workDir, options = {}) {
         : DEFAULT_BASH_TIMEOUT_MS;
     const hasExplicitTimeout = typeof args.timeout === 'number' && args.timeout > 0;
     const timeoutMs = hasExplicitTimeout ? args.timeout : defaultTimeoutMs;
-    // Explicit caller timeout is uncapped (only the wmic-rewrite ceiling, when
-    // present, still bounds it); the omitted default keeps the MAX ceiling.
+    const _bgTasksDisabled = /^(1|true|yes|on)$/i.test(
+        String(process.env.MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS || '').trim(),
+    );
+    const backgroundOnTimeout = !runInBackground
+        && !_bgTasksDisabled
+        && isAutobackgroundingAllowed(command, resolvedSpec.shellType);
+    // Explicit caller timeout remains the total deadline. When promotion is
+    // available, cap only its foreground blocking portion at MAX.
     // JS timers (setTimeout) and PS WaitForExit(ms) are 32-bit: a delay above
     // 2^31-1 wraps to a tiny/negative value and fires immediately. Clamp the
     // uncapped explicit timeout once here (~24.8 days ceiling) so every
@@ -325,11 +330,15 @@ export async function executeBashTool(args, workDir, options = {}) {
     const TIMER_MAX_MS = 2_147_483_647;
     // timeoutMs <= 0 (omitted background default) means unlimited: pass it
     // through untouched — the min() clamps below must not turn 0 into a bound.
-    const timeout = timeoutMs <= 0
+    const totalTimeout = timeoutMs <= 0
         ? 0
-        : (hasExplicitTimeout
-            ? Math.min(timeoutMs, wmicRewrite?.timeoutMs || TIMER_MAX_MS)
-            : Math.min(timeoutMs, wmicRewrite?.timeoutMs || MAX_BASH_TIMEOUT_MS));
+        : Math.min(timeoutMs, wmicRewrite?.timeoutMs || (hasExplicitTimeout ? TIMER_MAX_MS : MAX_BASH_TIMEOUT_MS));
+    const timeout = hasExplicitTimeout && backgroundOnTimeout
+        ? Math.min(totalTimeout, MAX_BASH_TIMEOUT_MS)
+        : totalTimeout;
+    const promotedTimeoutMs = hasExplicitTimeout && backgroundOnTimeout
+        ? Math.max(0, totalTimeout - timeout)
+        : 0;
     const mergeStderr = args.merge_stderr === true;
     const longForegroundHint = foregroundLongCommandHint(command, timeout, { ...args, run_in_background: runInBackground });
     if (longForegroundHint) return formatShellToolFailure(longForegroundHint);
@@ -458,12 +467,6 @@ export async function executeBashTool(args, workDir, options = {}) {
         // base commands (isAutobackgroundingAllowed), (b) the truthy
         // MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS env. Never applies to
         // run_in_background (already detached, handled above).
-        const _bgTasksDisabled = /^(1|true|yes|on)$/i.test(
-            String(process.env.MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS || '').trim(),
-        );
-        const backgroundOnTimeout = !runInBackground
-            && !_bgTasksDisabled
-            && isAutobackgroundingAllowed(command, shellType);
         const result = await execShellCommand({
             shell, shellArg, shellArgs, command: syncCommand,
             env: spawnEnv,
@@ -474,6 +477,7 @@ export async function executeBashTool(args, workDir, options = {}) {
             // On a foreground timeout, promote the still-running child to a
             // tracked background job (unlimited) instead of killing it.
             backgroundOnTimeout,
+            promotedTimeoutMs,
             // Threaded so an auto-backgrounded foreground job is stamped with
             // the dispatching terminal's claude.exe pid (per-terminal scope).
             clientHostPid: options?.clientHostPid,
@@ -507,10 +511,7 @@ export async function executeBashTool(args, workDir, options = {}) {
                             stdout: result.stdoutPath ? normalizeOutputPath(result.stdoutPath) : null,
                             stderr: (!mergeStderr && result.stderrPath) ? normalizeOutputPath(result.stderrPath) : null,
                             cwd: bashWorkDir,
-                            // Adopted foreground jobs run unlimited (timeoutMs 0)
-                            // — matches the async default; the original
-                            // foreground timeout no longer bounds the promoted job.
-                            timeoutMs: 0,
+                            timeoutMs: result.backgroundTimeoutMs || 0,
                         },
                         resultType: 'shell_task_result',
                         cancel: () => killShellJob(result.jobId),
@@ -530,7 +531,7 @@ export async function executeBashTool(args, workDir, options = {}) {
             const lines = [
                 task ? renderBackgroundTask(task) : (result.jobId ? `[task_id: ${result.jobId}]` : null),
                 '',
-                result.backgroundMessage || 'auto-backgrounded; still running',
+                result.backgroundMessage || 'auto-backgrounded; still running — judge from the partial output whether waiting can finish in budget, or diagnose and pursue an alternative.',
                 partialStdout ? `\n[partial stdout]\n${partialStdout}` : '',
                 (!mergeStderr && partialStderr) ? `\n[partial stderr]\n${partialStderr}` : '',
             ].filter((l) => l !== null && l !== '');

package/src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs

@@ -83,7 +83,7 @@ export const BUILTIN_TOOLS = [
             properties: {
                 command: { type: 'string', description: 'Command.' },
                 cwd: { type: 'string', description: 'Working directory; persists across calls. Omit to reuse; absolute path changes it.' },
-                timeout: { type: 'number', description: `Timeout ms. Default ${_shellDefaultTimeoutMs()} (${_shellDefaultTimeoutMs() / 60000} min) when omitted; an explicit value is honored uncapped — long-running commands may set it higher. On timeout the command is MOVED TO BACKGROUND (a task_id you can wait/status/read/cancel) and keeps running instead of being killed; sleep-like commands and MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS opt out (killed with a [timeout] marker). async/background runs with timeout omitted have NO timeout (run until done/cancelled); an explicit timeout is still enforced.` },
+                timeout: { type: 'number', description: `Timeout ms. Default ${_shellDefaultTimeoutMs()} (${_shellDefaultTimeoutMs() / 60000} min) when omitted. On sync timeout the command is MOVED TO BACKGROUND (a task_id you can wait/status/read/cancel) and keeps running instead of being killed; an explicit timeout blocks for at most BASH_MAX_TIMEOUT_MS (default 10 min), and only its remainder beyond that cap is still enforced as a background deadline. Sleep-like commands and MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS opt out (killed with a [timeout] marker after blocking for the full explicit timeout). async/background runs with timeout omitted have NO timeout (run until done/cancelled); an explicit timeout is still enforced.` },
                 merge_stderr: { type: 'boolean', description: 'Merge stderr.' },
                 mode: { type: 'string', enum: ['sync', 'async'], description: executionModeSchemaDescription('sync') },
                 shell: { type: 'string', enum: ['bash', 'powershell'], description: 'Force shell. Windows defaults to PowerShell; bash = Git Bash/POSIX.' },