mixdog 0.9.40 → 0.9.41

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-credentials.mjs

@@ -7,10 +7,10 @@
  * the public functions so external callers keep their existing import path.
  */
 import { readFileSync, existsSync, statSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { createServer } from 'http';
 import { randomBytes, createHash } from 'crypto';
-import { writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
+import { writeJsonAtomicSync, withFileLock } from '../../../shared/atomic-file.mjs';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 
@@ -33,6 +33,7 @@ export const TOKEN_URL = assertSafeTokenURL(process.env.ANTHROPIC_OAUTH_TOKEN_UR
 export const DEFAULT_CREDENTIALS_PATH = join(resolvePluginData(), 'anthropic-oauth-credentials.json');
 export const CLAUDE_CODE_CLIENT_ID = process.env.ANTHROPIC_OAUTH_CLIENT_ID || '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
 export const TOKEN_REFRESH_SKEW_MS = 5 * 60_000;
+export const ANTHROPIC_OAUTH_REFRESH_DISABLED_ENV = 'MIXDOG_ANTHROPIC_OAUTH_REFRESH_DISABLED';
 const CLAUDE_AI_AUTHORIZE_URL = 'https://claude.com/cai/oauth/authorize';
 const ALL_OAUTH_SCOPES = [
     'org:create_api_key',
@@ -67,10 +68,9 @@ function _pushUnique(list, value) {
 }
 
 export function credentialCandidates() {
-    const paths = [];
-    _pushUnique(paths, process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH);
-    _pushUnique(paths, DEFAULT_CREDENTIALS_PATH);
-    return paths;
+    const explicit = process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH;
+    if (explicit) return [resolve(explicit)];
+    return [DEFAULT_CREDENTIALS_PATH];
 }
 
 // Fallback expiry from the access_token's JWT `exp` claim (epoch ms) when the
@@ -109,6 +109,11 @@ function _loadCredentialsFile(path) {
     }
 }
 
+export function loadCredentialsFromPath(path) {
+    if (!path) return null;
+    return _loadCredentialsFile(resolve(path));
+}
+
 // Cross-process safe credential save. Lockfile (O_EXCL) prevents two Mixdog
 // refreshers from clobbering each other; atomic rename guarantees readers see
 // either the old or new file, never a half-written one. Used so refresh_token
@@ -215,7 +220,15 @@ export function _scrubTokens(text) {
         .replace(/"refresh_token"\s*:\s*"[^"]+"/g, '"refresh_token":"[REDACTED]"');
 }
 
-export async function refreshOAuthCredentials(creds) {
+export function isAnthropicOAuthRefreshDisabled() {
+    return process.env[ANTHROPIC_OAUTH_REFRESH_DISABLED_ENV] === '1';
+}
+
+function _refreshLockPath(path) {
+    return `${resolve(path)}.anthropic-oauth-refresh.lock`;
+}
+
+async function _refreshOAuthCredentialsUnlocked(creds) {
     if (!creds?.refreshToken) {
         throw new Error('Anthropic OAuth refresh token not available. Open /providers in mixdog to sign in again.');
     }
@@ -294,6 +307,130 @@ export async function refreshOAuthCredentials(creds) {
     }
 }
 
+export async function refreshOAuthCredentials(creds) {
+    if (isAnthropicOAuthRefreshDisabled()) {
+        throw new Error(
+            'Anthropic OAuth refresh is disabled in this process; '
+            + 'host credential preflight must provide a fresh snapshot.',
+        );
+    }
+    const credentialPath = resolve(
+        creds?.path
+        || process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH
+        || DEFAULT_CREDENTIALS_PATH,
+    );
+    return withFileLock(_refreshLockPath(credentialPath), async () => {
+        const disk = _loadCredentialsFile(credentialPath);
+        // A waiter that started with the prior generation must consume the
+        // winner's persisted rotation, not replay the single-use token.
+        if (disk?.accessToken && creds?.accessToken
+            && disk.accessToken !== creds.accessToken
+            && (!disk.expiresAt || disk.expiresAt > Date.now())) {
+            return disk;
+        }
+        return _refreshOAuthCredentialsUnlocked(
+            disk || { ...creds, path: credentialPath },
+        );
+    }, {
+        timeoutMs: 120_000,
+        staleMs: 120_000,
+        secret: true,
+    });
+}
+
+/**
+ * Serialize host-side refresh, establish a bounded access-token lease, and
+ * optionally write an owner-only snapshot while the lease lock is still held.
+ * The returned object deliberately contains metadata only, never token bytes.
+ */
+export async function preflightAnthropicOAuthCredentials({
+    credentialsPath = null,
+    minimumValidityMs = TOKEN_REFRESH_SKEW_MS,
+    snapshotPath = null,
+    refreshFn = refreshOAuthCredentials,
+    now = () => Date.now(),
+    lockTimeoutMs = 120_000,
+} = {}) {
+    if (isAnthropicOAuthRefreshDisabled()) {
+        throw new Error('Anthropic OAuth host preflight cannot run while refresh is disabled.');
+    }
+    const requiredMs = Number(minimumValidityMs);
+    if (!Number.isFinite(requiredMs) || requiredMs < 0) {
+        throw new Error('Anthropic OAuth host preflight minimumValidityMs must be a non-negative number.');
+    }
+    const pinnedPath = resolve(
+        credentialsPath
+        || process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH
+        || DEFAULT_CREDENTIALS_PATH,
+    );
+    const initial = _loadCredentialsFile(pinnedPath);
+    if (!initial?.path || !initial.accessToken) {
+        throw new Error(
+            `Anthropic OAuth host preflight found no credentials at ${pinnedPath}. `
+            + 'Open /providers in mixdog to sign in.',
+        );
+    }
+
+    return withFileLock(_refreshLockPath(pinnedPath), async () => {
+        let leased = _loadCredentialsFile(pinnedPath);
+        if (!leased?.path || !leased.accessToken) {
+            throw new Error('Anthropic OAuth credentials disappeared during host preflight.');
+        }
+
+        const validAfter = now() + requiredMs;
+        let refreshed = false;
+        if (!leased.expiresAt || leased.expiresAt < validAfter) {
+            if (!leased.refreshToken) {
+                throw new Error(
+                    'Anthropic OAuth host preflight cannot establish the required lease: '
+                    + 'refresh token is unavailable.',
+                );
+            }
+            // The public refresh function owns this same lock. Call its
+            // unlocked exchange only because preflight already owns it;
+            // injected test exchanges run under the identical ownership.
+            const next = refreshFn === refreshOAuthCredentials
+                ? await _refreshOAuthCredentialsUnlocked(leased)
+                : await refreshFn(leased);
+            const persisted = _loadCredentialsFile(pinnedPath);
+            if (!persisted?.accessToken || persisted.accessToken !== next?.accessToken) {
+                throw new Error('Anthropic OAuth host preflight refresh was not persisted.');
+            }
+            leased = persisted;
+            refreshed = true;
+        }
+
+        const remainingMs = leased.expiresAt ? leased.expiresAt - now() : 0;
+        if (remainingMs < requiredMs) {
+            throw new Error(
+                `Anthropic OAuth host preflight cannot satisfy the ${Math.ceil(requiredMs / 1000)}s `
+                + `credential lease (provider granted ${Math.max(0, Math.floor(remainingMs / 1000))}s).`,
+            );
+        }
+
+        if (snapshotPath) {
+            const raw = JSON.parse(readFileSync(leased.path, 'utf-8'));
+            // Containers need only the leased access token. Never distribute
+            // the rotating refresh credential, even into disposable storage.
+            if (raw?.claudeAiOauth) {
+                delete raw.claudeAiOauth.refreshToken;
+                delete raw.claudeAiOauth.refresh_token;
+            }
+            _saveCredentialsFile(snapshotPath, raw);
+        }
+        return {
+            expiresAt: leased.expiresAt,
+            remainingMs,
+            refreshed,
+            snapshotWritten: Boolean(snapshotPath),
+        };
+    }, {
+        timeoutMs: lockTimeoutMs,
+        staleMs: 120_000,
+        secret: true,
+    });
+}
+
 // --- Login flow (PKCE loopback, export for setup UI / CLI) ---
 
 function _oauthGeneratePKCE() {

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

@@ -27,6 +27,7 @@ import {
 import { sanitizeToolPairs, sanitizeAnthropicContentPairs, foldUserTextIntoToolResultTail } from '../session/context-utils.mjs';
 import {
     TOKEN_REFRESH_SKEW_MS,
+    isAnthropicOAuthRefreshDisabled,
     resolveCliVersion,
     loadCredentials,
     hasAnthropicOAuthCredentials,
@@ -342,7 +343,7 @@ function toAnthropicMessages(messages) {
         const m = messages[idx];
         if (m.role === 'system') continue;
 
-        if (m.role === 'assistant' && (m.toolCalls?.length || m.assistantBlocks?.length)) {
+        if (m.role === 'assistant' && (m.toolCalls?.length || m.assistantBlocks?.length || m.thinkingBlocks?.length)) {
             let content;
             if (m.assistantBlocks?.length) {
                 content = m.assistantBlocks.slice();
@@ -358,7 +359,7 @@ function toAnthropicMessages(messages) {
                     }
                 }
                 if (m.content) content.push({ type: 'text', text: m.content });
-                for (const tc of m.toolCalls) {
+                for (const tc of m.toolCalls || []) {
                     content.push({
                         type: 'tool_use',
                         id: tc.id,
@@ -703,6 +704,12 @@ export class AnthropicOAuthProvider {
         const expiring = this.credentials.expiresAt
             && this.credentials.expiresAt < Date.now() + TOKEN_REFRESH_SKEW_MS;
         if (forceRefresh || expiring) {
+            if (isAnthropicOAuthRefreshDisabled()) {
+                throw new Error(
+                    'Anthropic OAuth credentials require refresh, but refresh is disabled '
+                    + 'in this container. Host credential preflight must provide a fresh snapshot.',
+                );
+            }
             this.credentials = await this._refreshCredentials({ force: forceRefresh, reason });
         }
 
@@ -710,6 +717,12 @@ export class AnthropicOAuthProvider {
     }
 
     async _refreshCredentials({ force = false, reason = 'preemptive' } = {}) {
+        if (isAnthropicOAuthRefreshDisabled()) {
+            throw new Error(
+                'Anthropic OAuth refresh is disabled in this container; '
+                + 'host credential preflight must provide a fresh snapshot.',
+            );
+        }
         const currentToken = this.credentials?.accessToken || null;
         const disk = loadCredentials();
         const validAfter = Date.now() + (force ? 0 : TOKEN_REFRESH_SKEW_MS);

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

@@ -347,7 +347,7 @@ function toAnthropicMessages(messages) {
     for (let idx = 0; idx < messages.length; idx++) {
         const m = messages[idx];
         if (m.role === 'system') continue;
-        if (m.role === 'assistant' && (m.toolCalls?.length || m.assistantBlocks?.length)) {
+        if (m.role === 'assistant' && (m.toolCalls?.length || m.assistantBlocks?.length || m.thinkingBlocks?.length)) {
             let content;
             if (m.assistantBlocks?.length) {
                 content = m.assistantBlocks.slice();
@@ -362,7 +362,7 @@ function toAnthropicMessages(messages) {
                     }
                 }
                 if (m.content) content.push({ type: 'text', text: m.content });
-                for (const tc of m.toolCalls) {
+                for (const tc of m.toolCalls || []) {
                     content.push({
                         type: 'tool_use',
                         id: tc.id,

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

@@ -51,6 +51,11 @@ import {
     createActiveToolItemTracker,
     hasCompleteToolCall as sharedHasCompleteToolCall,
 } from './tool-stream-state.mjs';
+import {
+    enableSessionTransportTracking,
+    disableSessionTransportTracking,
+    markSessionTransportActivity,
+} from '../session/manager/runtime-liveness.mjs';
 
 // Facade re-exports: the delta/matching helpers and usage/event helpers below
 // were extracted to openai-ws-delta.mjs / openai-ws-events.mjs (no behavior
@@ -92,6 +97,11 @@ export const WS_PRE_RESPONSE_CREATED_MS = (() => {
 // including metadata/keepalive, proves the socket is live.
 export const WS_INTER_CHUNK_MS = PROVIDER_WS_INTER_CHUNK_TIMEOUT_MS;
 const X_CODEX_TURN_STATE_HEADER = 'x-codex-turn-state';
+const WS_TRACE_ENABLED = process.env.MIXDOG_WS_TRACE === '1';
+
+function _writeWsLifecycleTrace(lifecycle) {
+    process.stderr.write(`[ws-trace] t=${new Date().toISOString()} lifecycle=${lifecycle}\n`);
+}
 
 function _responseItemKey(item, fallbackIndex = 0) {
     if (!item || typeof item !== 'object') return `primitive:${fallbackIndex}`;
@@ -239,6 +249,7 @@ export async function _streamResponse({
 }) {
     const errLabel = _wsErrLabel(traceProvider);
     const socket = entry.socket;
+    enableSessionTransportTracking(state?.sessionId);
     const preResponseCreatedMs = _positiveInt(_timeouts?.preResponseCreatedMs, WS_PRE_RESPONSE_CREATED_MS);
     const interChunkMs = _positiveInt(_timeouts?.interChunkMs, WS_INTER_CHUNK_MS);
     // First-MEANINGFUL-frame deadline. Distinct from preResponseCreatedMs (a
@@ -471,6 +482,9 @@ export async function _streamResponse({
     let messageHandler = null;
     let closeHandler = null;
     let errorHandler = null;
+    let traceOpenHandler = null;
+    let tracePingHandler = null;
+    let tracePongHandler = null;
     // SEMANTIC idle timer: distinct from the inter-chunk
     // timer, which resets on EVERY frame (rate_limits/metadata/keepalive keep
     // the socket "alive"). This timer resets ONLY on meaningful output deltas
@@ -668,6 +682,7 @@ export async function _streamResponse({
         // frames never reach here, so they cannot satisfy the watchdog.
         const bumpSemanticIdle = () => { clearFirstMeaningfulWatchdog(); resetSemanticIdle(); };
         const cleanup = () => {
+            disableSessionTransportTracking(midState.sessionId);
             if (idleTimer) clearTimeout(idleTimer);
             if (interChunkTimer) { clearTimeout(interChunkTimer); interChunkTimer = null; }
             if (semanticIdleTimer) { clearTimeout(semanticIdleTimer); semanticIdleTimer = null; }
@@ -676,6 +691,9 @@ export async function _streamResponse({
             if (messageHandler) socket.off('message', messageHandler);
             if (closeHandler) socket.off('close', closeHandler);
             if (errorHandler) socket.off('error', errorHandler);
+            if (traceOpenHandler) socket.off('open', traceOpenHandler);
+            if (tracePingHandler) socket.off('ping', tracePingHandler);
+            if (tracePongHandler) socket.off('pong', tracePongHandler);
             if (abortHandler && externalSignal) externalSignal.removeEventListener('abort', abortHandler);
         };
         const finish = () => {
@@ -755,6 +773,15 @@ export async function _streamResponse({
             const text = typeof data === 'string' ? data : data.toString('utf-8');
             const event = _parseEvent(text);
             if (!event) return;
+            if (WS_TRACE_ENABLED) {
+                const type = typeof event.type === 'string' ? event.type : '';
+                const empty = type.endsWith('.delta')
+                    && (event.delta == null || event.delta === '');
+                process.stderr.write(
+                    `[ws-trace] t=${new Date().toISOString()} type=${type} bytes=${Buffer.byteLength(text)} empty=${empty}\n`,
+                );
+            }
+            markSessionTransportActivity(midState.sessionId);
             _traceWsHeaderKeys(entry, event, midState, traceProvider, model);
             _captureTurnStateFromEvent(entry, event);
             if (event.error) {
@@ -780,12 +807,9 @@ export async function _streamResponse({
                     // first-meaningful watchdog (keepalive/metadata frames do
                     // NOT reach this case, so they never clear it).
                     clearFirstMeaningfulWatchdog();
-                    // Arm the semantic idle/stall timer from response.created
-                    // too: it otherwise only arms on the first meaningful delta
-                    // (bumpSemanticIdle), so a created+keepalive-only stream that
-                    // never emits a delta would stall unbounded until the outer
-                    // watchdog. Arming here bounds that gap.
-                    resetSemanticIdle();
+                    // Do not arm semantic idle until actual model progress.
+                    // Transport-only reasoning heartbeats are bounded by the
+                    // outer first-visible ceiling instead.
                     break;
                 case 'response.output_text.delta':
                     try {
@@ -814,14 +838,12 @@ export async function _streamResponse({
                 case 'response.reasoning_summary_text.delta':
                     if (event.type === 'response.reasoning_text.delta') reasoningTextDeltaCount += 1;
                     else reasoningSummaryTextDeltaCount += 1;
-                    // Reasoning text is live model progress — refresh
-                    // lastStreamDeltaAt so stream-watchdog does not flag a
-                    // long reasoning span as a stall. The local WS idle timer
-                    // was already reset by resetIdle() at the top of
-                    // messageHandler. Reasoning is still suppressed from user
-                    // content (no `content +=` here).
-                    try { onStreamDelta?.(); } catch {}
-                    bumpSemanticIdle();
+                    // Only non-empty reasoning text is model progress. Empty
+                    // deltas remain transport activity via resetIdle() above.
+                    if (event.delta) {
+                        try { onStreamDelta?.(); } catch {}
+                        bumpSemanticIdle();
+                    }
                     break;
                 case 'response.output_item.added':
                     if (event.item?.type === 'function_call') {
@@ -1184,25 +1206,24 @@ export async function _streamResponse({
                         && event.type.startsWith('response.reasoning')
                         && event.type.endsWith('.delta')) {
                         reasoningOtherDeltaCount += 1;
-                        // These ARE live model progress (reviewer Medium): a
-                        // provider that emits only these reasoning variants for a
-                        // long span would otherwise trip the SEMANTIC idle abort.
-                        // Refresh both the watchdog and the semantic idle timer,
-                        // matching the named reasoning_text.delta case above.
-                        try { onStreamDelta?.(); } catch {}
-                        bumpSemanticIdle();
+                        // Only non-empty reasoning deltas are model progress;
+                        // empty variants remain transport activity only.
+                        if (event.delta) {
+                            try { onStreamDelta?.(); } catch {}
+                            bumpSemanticIdle();
+                        }
                     }
-                    // response.in_progress is a server lifecycle heartbeat during
-                    // long tool/generation latency — reset semantic idle so it is
-                    // not counted as silence (resetIdle already ran at the top).
+                    // response.in_progress is transport activity only;
+                    // resetIdle() already kept the socket alive above.
                     else if (event.type === 'response.in_progress') {
-                        resetSemanticIdle();
+                        // No semantic/model progress.
                     }
                     // Other trace-only events fall through.
                     break;
             }
         };
         closeHandler = (code, reason) => {
+            if (WS_TRACE_ENABLED) _writeWsLifecycleTrace('close');
             if (done) return;
             midState.wsCloseCode = code;
             if (!terminalError) {
@@ -1219,6 +1240,7 @@ export async function _streamResponse({
             finish();
         };
         errorHandler = (err) => {
+            if (WS_TRACE_ENABLED) _writeWsLifecycleTrace('error');
             if (done) return;
             const wrapped = err instanceof Error ? err : new Error(String(err));
             if (terminalError) {
@@ -1268,6 +1290,15 @@ export async function _streamResponse({
         socket.on('message', messageHandler);
         socket.on('close', closeHandler);
         socket.on('error', errorHandler);
+        if (WS_TRACE_ENABLED) {
+            traceOpenHandler = () => _writeWsLifecycleTrace('open');
+            tracePingHandler = () => _writeWsLifecycleTrace('ping');
+            tracePongHandler = () => _writeWsLifecycleTrace('pong');
+            socket.on('open', traceOpenHandler);
+            socket.on('ping', tracePingHandler);
+            socket.on('pong', tracePongHandler);
+            if (socket.readyState === WebSocket.OPEN) _writeWsLifecycleTrace('open');
+        }
         armPreStreamWatchdog();
         armFirstMeaningfulWatchdog();
         // Periodic client-side WS ping while the stream is active. The server's
@@ -1280,6 +1311,7 @@ export async function _streamResponse({
         keepaliveTimer = setInterval(() => {
             try {
                 if (socket.readyState !== WebSocket.OPEN) return;
+                if (WS_TRACE_ENABLED) _writeWsLifecycleTrace('ping');
                 socket.ping();
             } catch {}
         }, 10_000);

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

@@ -83,7 +83,7 @@ import {
     restoreToolCallBodyForId,
 } from './loop/stored-tool-args.mjs';
 import { repairTranscriptBeforeProviderSend } from './loop/transcript-repair.mjs';
-import { classifyTerminationReason, INCOMPLETE_STOP_REASONS } from './loop/termination.mjs';
+import { classifyTerminationReason, INCOMPLETE_STOP_REASONS, isOutputLimitStopReason } from './loop/termination.mjs';
 import { createSteeringLadder } from './loop/steering-ladder.mjs';
 import { runPreSendCompactPass } from './pre-send-compact.mjs';
 import { createEagerDispatcher } from './eager-dispatch.mjs';
@@ -116,6 +116,11 @@ export {
 // this catches tight deterministic-failure loops (e.g. a command that errors
 // the same way every time) far earlier than 100 iterations.
 const REPEAT_FAIL_LIMIT = 3;
+// A provider max-output stop is not a completed assistant turn, even when it
+// contains useful text. Preserve each partial in the provider transcript and
+// grant at most three direct continuations before surfacing a hard truncation.
+const MAX_OUTPUT_RECOVERY_LIMIT = 3;
+const MAX_OUTPUT_EXHAUSTED_NOTICE = '[mixdog-runtime] Output remained truncated after 3 continuation attempts.';
 // _scopedCacheOutcomeForCall and executeTool moved to ./loop/tool-exec.mjs
 // (imported above).
 /**
@@ -233,10 +238,16 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         const reasoningItems = Array.isArray(resp.reasoningItems) && resp.reasoningItems.length
             ? resp.reasoningItems
             : null;
-        if (!content && !reasoningContent && !reasoningItems) return false;
+        const thinkingBlocks = Array.isArray(resp.thinkingBlocks) && resp.thinkingBlocks.length
+            ? resp.thinkingBlocks
+            : null;
+        if (!content && !reasoningContent && !reasoningItems && !thinkingBlocks) return false;
         messages.push({
             role: 'assistant',
             content,
+            // Anthropic adaptive-thinking signatures must be replayed verbatim
+            // before the continuation turn, just like tool-call trajectories.
+            ...(thinkingBlocks ? { thinkingBlocks } : {}),
             ...(reasoningItems ? { reasoningItems } : {}),
             ...(reasoningContent ? { reasoningContent } : {}),
         });
@@ -270,6 +281,8 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     // the loop as an explicit empty termination instead.
     let _emptyNudgeStreak = 0;
     const EMPTY_NUDGE_MAX = 3;
+    let _maxOutputRecoveryCount = 0;
+    const _maxOutputContentParts = [];
     // Claude Code parity: queued prompt/task notifications are attached after a
     // tool batch, before the continuation provider send. Normal batches drain
     // up to 'next'; a Sleep-like tool grants a 'later' flush.
@@ -517,22 +530,15 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         // Provider may have returned despite an abort (SDKs that don't honour
         // signal) — bail before processing any of its output.
         throwIfAborted();
-        // P1 audit fix (Step4): a text-only turn truncated by the provider's
-        // max-output limit (response.truncated, set by the provider layer
-        // when stopReason==='length' AND content is non-empty) used to look
-        // identical to a clean completion — the model's answer could be
-        // silently cut mid-sentence with zero signal to the operator. Surface
-        // it as a one-line stderr warning + trace event WITHOUT failing the
-        // turn (the partial content is still usable and the loop's own
-        // isIncompleteStop nudge below already re-prompts when content is
-        // empty).
+        // Keep a diagnostic for every provider-declared truncation. Eligible
+        // no-tool text turns are recovered below rather than accepted as final.
         if (response?.truncated === true) {
             try {
                 process.stderr.write(
                     `[loop] provider output truncated at max-output limit (sess=${sessionId || 'unknown'} `
                     + `iter=${iterations} stopReason=${response.stopReason ?? response.stop_reason ?? 'length'} `
                     + `contentLen=${typeof response.content === 'string' ? response.content.length : 0}); `
-                    + `answer may be cut off mid-sentence.\n`,
+                    + `continuation recovery will be attempted when eligible.\n`,
                 );
             } catch { /* best-effort */ }
             try {
@@ -600,6 +606,33 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             const isHidden = HIDDEN_AGENT_NAMES.has(sessionAgent);
             const stopReason = response.stopReason ?? response.stop_reason ?? null;
             const isIncompleteStop = stopReason && INCOMPLETE_STOP_REASONS.has(stopReason);
+            const isOutputLimitStop = isOutputLimitStopReason(stopReason);
+            if (hasContent && isOutputLimitStop) {
+                _maxOutputContentParts.push(response.content);
+                if (_maxOutputRecoveryCount < MAX_OUTPUT_RECOVERY_LIMIT) {
+                    // The partial assistant turn must be visible to the model so
+                    // it can resume at the exact cutoff instead of reconstructing
+                    // or repeating it. askSession persists this natural recovery
+                    // chain; historyContent below prevents the aggregate returned
+                    // to callers from being persisted a second time.
+                    pushIntermediateAssistantResponse(response);
+                    _maxOutputRecoveryCount += 1;
+                    messages.push({
+                        role: 'user',
+                        content: 'Output token limit hit. Resume directly — no apology, no recap. Pick up exactly where the previous text stopped.',
+                        meta: { source: 'max-output-recovery', attempt: _maxOutputRecoveryCount },
+                    });
+                    continue;
+                }
+                const terminalSegment = `${response.content}\n\n${MAX_OUTPUT_EXHAUSTED_NOTICE}`;
+                response = {
+                    ...response,
+                    content: `${_maxOutputContentParts.slice(0, -1).join('')}${terminalSegment}`,
+                    historyContent: terminalSegment,
+                    maxOutputRecoveryAttempts: _maxOutputRecoveryCount,
+                };
+                break;
+            }
             if (!hasContent && !isHidden) {
                 _emptyNudgeStreak += 1;
                 if (_emptyNudgeStreak > EMPTY_NUDGE_MAX) {
@@ -622,6 +655,15 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                 messages.push({ role: 'user', content: nudgeMsg });
                 continue;
             }
+            if (_maxOutputContentParts.length > 0) {
+                const terminalSegment = typeof response.content === 'string' ? response.content : '';
+                response = {
+                    ...response,
+                    content: `${_maxOutputContentParts.join('')}${terminalSegment}`,
+                    historyContent: terminalSegment,
+                    maxOutputRecoveryAttempts: _maxOutputRecoveryCount,
+                };
+            }
             break;
         }
         _emptyNudgeStreak = 0;

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

@@ -307,6 +307,7 @@ function contextSummaryResult(state, count) {
 
 export const DEFAULT_COMPACTION_BUFFER_TOKENS = 0;
 export const DEFAULT_COMPACTION_BUFFER_RATIO = 0.1;
+export const MAIN_COMPACTION_TRIGGER_RATIO = 0.95;
 export const MAX_COMPACTION_BUFFER_RATIO = 0.25;
 export const DEFAULT_COMPACTION_KEEP_TOKENS = 8_000;
 const LEGACY_DEFAULT_COMPACTION_BUFFER_RATIO = 0.1;
@@ -443,8 +444,8 @@ export function resolveCompactTriggerTokens(sessionOrConfig = {}, boundaryTokens
 //     (trigger = limit) for every session type;
 //   - agent-owned semantic sessions otherwise keep the default early-trigger
 //     buffer (config-driven, default 10% -> compact at 90% of the boundary);
-//   - main/user recall-fasttrack sessions have NO default buffer and compact on
-//     the boundary itself (100%).
+//   - main/user recall-fasttrack sessions keep 5% headroom and compact at 95%
+//     of the effective boundary.
 // Returns the sanitized explicit limit (null when absent/legacy full-window)
 // plus triggerTokens / bufferTokens / bufferRatio for the given boundary.
 export function resolveSessionCompactPolicy(sessionOrConfig = {}, boundaryTokens = 0) {
@@ -466,7 +467,7 @@ export function resolveSessionCompactPolicy(sessionOrConfig = {}, boundaryTokens
     } else if (isAgentOwner(sessionOrConfig)) {
         triggerTokens = Math.max(1, boundary - resolveCompactBufferTokens(boundary, cfg));
     } else {
-        triggerTokens = boundary;
+        triggerTokens = Math.max(1, Math.floor(boundary * MAIN_COMPACTION_TRIGGER_RATIO));
     }
     const bufferTokens = Math.max(0, boundary - triggerTokens);
     const bufferRatio = bufferTokens / boundary;