@cereworker/core 26.330.2 → 26.403.1

package/dist/orchestrator.js

@@ -12,8 +12,15 @@ const log = createLogger('orchestrator');
 const TASK_COMPLETE_TOOL = 'task_complete';
 const TASK_BLOCKED_TOOL = 'task_blocked';
 const TASK_CHECKPOINT_TOOL = 'task_checkpoint';
-const INTERNAL_TASK_TOOL_NAMES = new Set([TASK_COMPLETE_TOOL, TASK_BLOCKED_TOOL, TASK_CHECKPOINT_TOOL]);
-const COMPLETION_RETRY_PROMPT = '[Cerebellum] Your last turn ended without a final answer. Continue from where you left off and end by calling task_complete or task_blocked before your final answer.';
+const INTERNAL_TASK_TOOL_NAMES = new Set([
+    TASK_COMPLETE_TOOL,
+    TASK_BLOCKED_TOOL,
+    TASK_CHECKPOINT_TOOL,
+]);
+const SYSTEM_FALLBACK_COMPLETION_PROMPT = '[System fallback] The last turn ended without a final answer. Continue from the last verified state and end by calling task_complete or task_blocked before your final answer.';
+const SYSTEM_FALLBACK_STALL_PROMPT = '[System fallback] The stalled turn is being retried from the last verified state.';
+const DEBUG_TOOL_OUTPUT_MAX_CHARS = 8_000;
+const DEBUG_TOOL_STRUCTURED_MAX_CHARS = 16_000;
 const READ_ONLY_TOOL_NAMES = new Set([
     'browserGetText',
     'browserGetUrl',
@@ -48,9 +55,16 @@ export class Orchestrator extends TypedEventEmitter {
     fineTuneMethod = 'auto';
     fineTuneSchedule = 'auto';
     fineTuneStatus = {
-        status: 'idle', jobId: '', progress: 0, currentStep: 0,
-        totalSteps: 0, currentLoss: 0, error: '', checkpointPath: '',
-        startedAt: 0, completedAt: 0,
+        status: 'idle',
+        jobId: '',
+        progress: 0,
+        currentStep: 0,
+        totalSteps: 0,
+        currentLoss: 0,
+        error: '',
+        checkpointPath: '',
+        startedAt: 0,
+        completedAt: 0,
     };
     _fineTuneHistory = [];
     gatewayMode = 'standalone';
@@ -64,13 +78,22 @@ export class Orchestrator extends TypedEventEmitter {
     lastStreamActivityAt = 0;
     streamWatchdog = null;
     streamNudgeCount = 0;
+    streamDeferredUntil = 0;
     streamStallThreshold = 30_000;
     maxNudgeRetries = 2;
     maxCompletionRetries = 2;
+    turnJournalRetention = {
+        maxDays: 30,
+        maxFilesPerConversation: 100,
+    };
     streamPhase = 'idle';
     activeToolCall = null;
     currentStreamTurn = null;
     currentAttemptCompletionState = null;
+    currentPartialContent = '';
+    currentLastContentKind = 'empty';
+    currentJournaledContentLength = 0;
+    pendingRecoveryDecision = null;
     streamAbortGraceMs = 1_000;
     taskConversations = new Map();
     taskRunning = new Set();
@@ -96,6 +119,12 @@ export class Orchestrator extends TypedEventEmitter {
             this.maxNudgeRetries = options.maxNudgeRetries;
             this.maxCompletionRetries = options.maxNudgeRetries;
         }
+        if (options?.turnJournalRetention) {
+            this.turnJournalRetention = {
+                ...this.turnJournalRetention,
+                ...options.turnJournalRetention,
+            };
+        }
     }
     setCerebrum(cerebrum) {
         this.cerebrum = cerebrum;
@@ -175,9 +204,19 @@ export class Orchestrator extends TypedEventEmitter {
             parameters: {
                 type: 'object',
                 properties: {
-                    step: { type: 'string', description: 'Short milestone name, such as "profile continuity checked"' },
-                    status: { type: 'string', enum: ['done', 'in_progress'], description: 'Whether the milestone is done or currently in progress' },
-                    evidence: { type: 'string', description: 'Concrete evidence showing what happened at this milestone' },
+                    step: {
+                        type: 'string',
+                        description: 'Short milestone name, such as "profile continuity checked"',
+                    },
+                    status: {
+                        type: 'string',
+                        enum: ['done', 'in_progress'],
+                        description: 'Whether the milestone is done or currently in progress',
+                    },
+                    evidence: {
+                        type: 'string',
+                        description: 'Concrete evidence showing what happened at this milestone',
+                    },
                 },
                 required: ['step', 'status', 'evidence'],
                 additionalProperties: false,
@@ -214,8 +253,8 @@ export class Orchestrator extends TypedEventEmitter {
                     isError: true,
                 };
             }
-            const hasVerifiedProgress = state.successfulExternalToolCount > 0
-                || state.continuity.progressLedger.some((entry) => entry.source === 'tool' && !entry.isError);
+            const hasVerifiedProgress = state.successfulExternalToolCount > 0 ||
+                state.continuity.progressLedger.some((entry) => entry.source === 'tool' && !entry.isError);
             if (!hasVerifiedProgress) {
                 return {
                     output: 'task_complete requires at least one successful external tool result in this turn.',
@@ -240,6 +279,22 @@ export class Orchestrator extends TypedEventEmitter {
             state.summary = undefined;
             state.evidence = evidence;
         }
+        const boundarySummary = signal === 'complete'
+            ? `Task completion recorded: ${state.summary}`
+            : `Task blocker recorded: ${state.blocker}`;
+        this.recordBoundary(state.continuity, {
+            kind: 'completion',
+            action: signal === 'complete' ? TASK_COMPLETE_TOOL : TASK_BLOCKED_TOOL,
+            summary: boundarySummary,
+            stateChanging: true,
+            evidence,
+        });
+        this.appendTurnJournalEntry('completion_signal', boundarySummary, {
+            signal,
+            evidence,
+            summary: state.summary,
+            blocker: state.blocker,
+        });
         this.emitCompletionTrace('signal_recorded', signal === 'complete'
             ? `Recorded task_complete signal with evidence: ${evidence}`
             : `Recorded task_blocked signal with evidence: ${evidence}`, signal, 'info');
@@ -263,9 +318,7 @@ export class Orchestrator extends TypedEventEmitter {
         const step = String(args.step ?? '').trim();
         const evidence = String(args.evidence ?? '').trim();
         const statusValue = String(args.status ?? '').trim();
-        const status = statusValue === 'done' || statusValue === 'in_progress'
-            ? statusValue
-            : null;
+        const status = statusValue === 'done' || statusValue === 'in_progress' ? statusValue : null;
         if (!step) {
             return {
                 output: 'A non-empty step field is required.',
@@ -454,7 +507,12 @@ export class Orchestrator extends TypedEventEmitter {
         if (!result.started) {
             throw new Error(result.error || 'Failed to start fine-tuning');
         }
-        this.fineTuneStatus = { ...this.fineTuneStatus, status: 'running', jobId: result.jobId, startedAt: Date.now() };
+        this.fineTuneStatus = {
+            ...this.fineTuneStatus,
+            status: 'running',
+            jobId: result.jobId,
+            startedAt: Date.now(),
+        };
         this.emit({ type: 'finetune:start', jobId: result.jobId });
         log.info('Fine-tuning started', { jobId: result.jobId });
         // 5. Poll for progress
@@ -493,7 +551,10 @@ export class Orchestrator extends TypedEventEmitter {
                         jobId: status.jobId,
                         checkpointPath: status.checkpointPath,
                     });
-                    log.info('Fine-tuning completed', { jobId: status.jobId, checkpoint: status.checkpointPath });
+                    log.info('Fine-tuning completed', {
+                        jobId: status.jobId,
+                        checkpoint: status.checkpointPath,
+                    });
                     this.stopFineTunePoller();
                 }
                 else if (status.status === 'failed') {
@@ -534,7 +595,10 @@ export class Orchestrator extends TypedEventEmitter {
         return {
             name: nameMatch?.[1]?.trim() || 'Cere',
             role: roleMatch?.[1]?.trim() || 'general-purpose assistant',
-            traits: traitsMatch?.[1]?.split(',').map((t) => t.trim().toLowerCase()).filter(Boolean) ?? [],
+            traits: traitsMatch?.[1]
+                ?.split(',')
+                .map((t) => t.trim().toLowerCase())
+                .filter(Boolean) ?? [],
         };
     }
     getActiveConversationId() {
@@ -638,7 +702,7 @@ export class Orchestrator extends TypedEventEmitter {
         return {
             streaming: this.streamWatchdog !== null,
             lastActivityAt: this.lastStreamActivityAt,
-            stallDetected: this.streamWatchdog !== null && (Date.now() - this.lastStreamActivityAt) > stallThresholdMs,
+            stallDetected: this.streamWatchdog !== null && Date.now() - this.lastStreamActivityAt > stallThresholdMs,
             nudgeCount: this.streamNudgeCount,
             phase: this.streamPhase,
             activeToolName: this.activeToolCall?.name,
@@ -659,9 +723,9 @@ export class Orchestrator extends TypedEventEmitter {
     }
     markStreamWaitingTool(toolCall, activityAt = Date.now()) {
         const normalizedToolName = toolCall.name.trim() || toolCall.name;
-        const phaseChanged = this.streamPhase !== 'waiting_tool'
-            || this.activeToolCall?.id !== toolCall.id
-            || this.activeToolCall?.name !== normalizedToolName;
+        const phaseChanged = this.streamPhase !== 'waiting_tool' ||
+            this.activeToolCall?.id !== toolCall.id ||
+            this.activeToolCall?.name !== normalizedToolName;
         this.lastStreamActivityAt = activityAt;
         this.streamPhase = 'waiting_tool';
         this.activeToolCall = {
@@ -680,6 +744,123 @@ export class Orchestrator extends TypedEventEmitter {
     resetStreamState() {
         this.streamPhase = 'idle';
         this.activeToolCall = null;
+        this.streamDeferredUntil = 0;
+        this.currentPartialContent = '';
+        this.currentLastContentKind = 'empty';
+        this.currentJournaledContentLength = 0;
+    }
+    appendTurnJournalEntry(type, summary, data) {
+        if (!this.currentStreamTurn)
+            return;
+        const entry = {
+            turnId: this.currentStreamTurn.turnId,
+            attempt: this.currentStreamTurn.attempt,
+            timestamp: Date.now(),
+            type,
+            summary: this.truncateResumeText(summary, 500),
+            ...(data ? { data } : {}),
+        };
+        this.conversations.appendTurnJournalEntry(this.currentStreamTurn.conversationId, this.currentStreamTurn.turnId, entry);
+    }
+    pruneTurnJournals(conversationId) {
+        try {
+            const result = this.conversations.pruneTurnJournals(conversationId, this.turnJournalRetention);
+            if (result.prunedByAge > 0 || result.prunedByCount > 0) {
+                log.debug('Pruned turn journals', {
+                    conversationId,
+                    prunedByAge: result.prunedByAge,
+                    prunedByCount: result.prunedByCount,
+                    remaining: result.remaining,
+                });
+            }
+        }
+        catch (error) {
+            log.warn('Failed to prune turn journals', {
+                conversationId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    persistPartialContentSnapshot(force = false) {
+        const normalized = this.currentPartialContent.trim();
+        if (!normalized)
+            return;
+        if (!force && this.currentPartialContent.length - this.currentJournaledContentLength < 200) {
+            return;
+        }
+        this.currentJournaledContentLength = this.currentPartialContent.length;
+        this.appendTurnJournalEntry('partial_text', `Assistant partial text: ${this.truncateResumeText(normalized, 220)}`, {
+            chars: this.currentPartialContent.length,
+            excerpt: this.truncateResumeText(normalized, 1200),
+        });
+    }
+    recordBoundary(continuity, boundary) {
+        const createdAt = Date.now();
+        const summary = {
+            id: nanoid(10),
+            createdAt,
+            browserState: this.cloneBrowserState(boundary.browserState ?? continuity.browserState),
+            ...boundary,
+        };
+        continuity.boundaries.push(summary);
+        while (continuity.boundaries.length > 20) {
+            continuity.boundaries.shift();
+        }
+        this.appendTurnJournalEntry('boundary', summary.summary, {
+            boundaryId: summary.id,
+            kind: summary.kind,
+            action: summary.action,
+            stateChanging: summary.stateChanging,
+            url: summary.url,
+            tabId: summary.tabId,
+            checkpointStatus: summary.checkpointStatus,
+            evidence: summary.evidence,
+            browserState: summary.browserState,
+        });
+        return summary;
+    }
+    deriveRepetitionSignals(continuity) {
+        const signals = [];
+        const recentToolEntries = continuity.progressLedger
+            .filter((entry) => entry.source === 'tool')
+            .slice(-10);
+        const recentActions = recentToolEntries.map((entry) => entry.action);
+        if (recentActions.length >= 4 && new Set(recentActions.slice(-4)).size <= 2) {
+            signals.push(`Recent tool actions are cycling between ${Array.from(new Set(recentActions.slice(-4))).join(', ')}`);
+        }
+        const summaryCounts = new Map();
+        for (const boundary of continuity.boundaries.slice(-12)) {
+            if (boundary.kind !== 'tool' || !boundary.stateChanging)
+                continue;
+            const key = `${boundary.action}|${boundary.summary}`;
+            summaryCounts.set(key, (summaryCounts.get(key) ?? 0) + 1);
+        }
+        for (const [key, count] of summaryCounts.entries()) {
+            if (count < 2)
+                continue;
+            const [, summary] = key.split('|', 2);
+            signals.push(`Repeated verified action x${count}: ${summary}`);
+        }
+        return signals.slice(0, 5);
+    }
+    classifyTurnOutcome(displayContent, finishMeta, completionState) {
+        const trimmed = displayContent.trim();
+        const endedOnToolCalls = finishMeta?.finishReason === 'tool-calls' ||
+            finishMeta?.stepFinishReasons.at(-1) === 'tool-calls' ||
+            finishMeta?.endedWithToolCall === true;
+        if (endedOnToolCalls) {
+            return 'ended_on_tool_calls';
+        }
+        if (completionState.externalToolCallCount > 0 && completionState.signal === 'none') {
+            return 'completion_signal_missing';
+        }
+        if (finishMeta?.finishReason === 'error' || finishMeta?.lastContentKind === 'error') {
+            return 'protocol_error';
+        }
+        if (trimmed.length > 0) {
+            return 'completed';
+        }
+        return 'completed_no_text';
     }
     getStreamDiagnostics(elapsedSeconds) {
         return {
@@ -692,17 +873,13 @@ export class Orchestrator extends TypedEventEmitter {
     }
     describeStreamLocation(phase = this.streamPhase, activeToolName = this.activeToolCall?.name) {
         if (phase === 'waiting_tool') {
-            return activeToolName
-                ? `waiting_tool/${activeToolName}`
-                : 'waiting_tool';
+            return activeToolName ? `waiting_tool/${activeToolName}` : 'waiting_tool';
         }
         return phase;
     }
     getCurrentStallThresholdMs(phase = this.streamPhase, nudgeCount = this.streamNudgeCount) {
-        const phaseBase = phase === 'waiting_model'
-            ? this.streamStallThreshold * 3
-            : this.streamStallThreshold;
-        return phaseBase + (nudgeCount * this.streamStallThreshold);
+        const phaseBase = phase === 'waiting_model' ? this.streamStallThreshold * 3 : this.streamStallThreshold;
+        return phaseBase + nudgeCount * this.streamStallThreshold;
     }
     logStreamDebug(msg, data) {
         if (!this.currentStreamTurn)
@@ -785,121 +962,235 @@ export class Orchestrator extends TypedEventEmitter {
             progressLedger: [],
             taskCheckpoints: [],
             browserState: {},
+            boundaries: [],
         };
     }
-    buildStallRetrySnapshot(params) {
+    buildRecoveryRequest(params) {
         const partialContent = this.truncateResumeText(params.partialContent, 600);
         const continuity = params.completionState.continuity;
-        if (!partialContent
-            && continuity.progressLedger.length === 0
-            && continuity.taskCheckpoints.length === 0
-            && !params.activeToolName
-            && !continuity.browserState.currentUrl
-            && !continuity.browserState.activeTabId) {
-            return null;
-        }
+        const latestBoundary = continuity.boundaries.at(-1);
         return {
-            cause: 'stall',
+            conversationId: this.currentStreamTurn?.conversationId ?? '',
+            turnId: this.currentStreamTurn?.turnId ?? '',
             attempt: params.attempt,
-            phase: params.phase,
-            activeToolName: params.activeToolName,
-            activeToolCallId: params.activeToolCallId,
+            cause: params.cause,
+            phase: this.streamPhase,
+            activeToolName: this.activeToolCall?.name,
+            activeToolCallId: this.activeToolCall?.id,
+            stallRetryCount: this.streamNudgeCount,
+            completionRetryCount: params.completionRetryCount ?? 0,
+            finishReason: params.finishMeta?.finishReason ?? params.finishMeta?.stepFinishReasons.at(-1),
+            turnOutcome: params.turnOutcome,
+            lastContentKind: params.finishMeta?.lastContentKind ?? this.currentLastContentKind,
+            elapsedSeconds: params.elapsedSeconds,
             partialContent: partialContent || undefined,
-            progressEntries: continuity.progressLedger.slice(-20),
-            taskCheckpoints: continuity.taskCheckpoints.slice(-8),
+            latestUserMessage: params.latestUserMessage
+                ? this.truncateResumeText(params.latestUserMessage, 600)
+                : undefined,
+            progressEntries: continuity.progressLedger.slice(-50).map((entry) => ({ ...entry })),
+            taskCheckpoints: continuity.taskCheckpoints.map((checkpoint) => ({ ...checkpoint })),
             browserState: this.cloneBrowserState(continuity.browserState),
+            latestBoundary: latestBoundary
+                ? {
+                    ...latestBoundary,
+                    ...(latestBoundary.browserState
+                        ? { browserState: this.cloneBrowserState(latestBoundary.browserState) }
+                        : {}),
+                }
+                : undefined,
+            recentBoundaries: continuity.boundaries.slice(-20).map((boundary) => ({
+                ...boundary,
+                ...(boundary.browserState
+                    ? { browserState: this.cloneBrowserState(boundary.browserState) }
+                    : {}),
+            })),
+            repetitionSignals: this.deriveRepetitionSignals(continuity),
         };
     }
-    buildCompletionRetrySnapshot(params) {
-        const partialContent = this.truncateResumeText(params.partialContent, 600);
-        const continuity = params.completionState.continuity;
-        const finishReason = params.finishMeta?.finishReason ?? params.finishMeta?.stepFinishReasons.at(-1);
-        if (!partialContent
-            && continuity.progressLedger.length === 0
-            && continuity.taskCheckpoints.length === 0
-            && !continuity.browserState.currentUrl
-            && !continuity.browserState.activeTabId
-            && !finishReason) {
-            return null;
+    emitRecoveryTrace(cause, source, assessment, level = 'info') {
+        if (!this.currentStreamTurn)
+            return;
+        const payload = {
+            type: 'cerebellum:recovery',
+            cause,
+            action: assessment.action,
+            turnId: this.currentStreamTurn.turnId,
+            attempt: this.currentStreamTurn.attempt,
+            conversationId: this.currentStreamTurn.conversationId,
+            message: assessment.operatorMessage,
+            operatorMessage: assessment.operatorMessage,
+            diagnosis: assessment.diagnosis,
+            nextStep: assessment.nextStep,
+            completedSteps: assessment.completedSteps,
+            waitSeconds: assessment.waitSeconds,
+            source,
+            ...this.getStreamDiagnostics(),
+        };
+        switch (level) {
+            case 'debug':
+                log.debug('cerebellum_recovery', payload);
+                break;
+            case 'warn':
+                log.warn('cerebellum_recovery', payload);
+                break;
+            case 'error':
+                log.error('cerebellum_recovery', payload);
+                break;
+            default:
+                log.info('cerebellum_recovery', payload);
+                break;
+        }
+        this.emit(payload);
+    }
+    async assessTurnRecovery(request) {
+        log.debug('turn_recovery_request', {
+            turnId: request.turnId,
+            attempt: request.attempt,
+            conversationId: request.conversationId,
+            cause: request.cause,
+            phase: request.phase,
+            activeToolName: request.activeToolName,
+            activeToolCallId: request.activeToolCallId,
+            stallRetryCount: request.stallRetryCount,
+            completionRetryCount: request.completionRetryCount,
+            finishReason: request.finishReason,
+            turnOutcome: request.turnOutcome,
+            lastContentKind: request.lastContentKind,
+            elapsedSeconds: request.elapsedSeconds,
+            hasPartialContent: Boolean(request.partialContent),
+            latestUserMessage: request.latestUserMessage
+                ? this.truncateResumeText(request.latestUserMessage, 300)
+                : '',
+            browserState: request.browserState,
+            progressEntries: request.progressEntries,
+            taskCheckpoints: request.taskCheckpoints,
+            latestBoundary: request.latestBoundary,
+            recentBoundaries: request.recentBoundaries,
+            repetitionSignals: request.repetitionSignals,
+        });
+        if (this.cerebellum?.isConnected() && this.cerebellum.assessTurnRecovery) {
+            try {
+                const assessment = await this.cerebellum.assessTurnRecovery(request);
+                if (assessment) {
+                    if (request.cause === 'completion' && assessment.action === 'wait') {
+                        return {
+                            source: 'cerebellum',
+                            assessment: {
+                                ...assessment,
+                                action: 'retry',
+                                waitSeconds: undefined,
+                            },
+                        };
+                    }
+                    return { source: 'cerebellum', assessment };
+                }
+            }
+            catch (error) {
+                log.warn('Turn recovery assessment failed', {
+                    turnId: request.turnId,
+                    attempt: request.attempt,
+                    conversationId: request.conversationId,
+                    cause: request.cause,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
         }
         return {
-            cause: 'completion',
-            attempt: params.attempt,
-            finishReason,
-            partialContent: partialContent || undefined,
-            progressEntries: continuity.progressLedger.slice(-20),
-            taskCheckpoints: continuity.taskCheckpoints.slice(-8),
-            browserState: this.cloneBrowserState(continuity.browserState),
+            source: 'fallback',
+            assessment: this.buildFallbackRecoveryAssessment(request),
         };
     }
-    buildRetryContextMessage(snapshot) {
-        if (!snapshot)
-            return null;
-        const isStall = snapshot.cause === 'stall';
-        const header = isStall ? '[Watchdog resume context]' : '[Completion resume context]';
-        const lines = [
-            header,
-            isStall
-                ? `The previous attempt (${snapshot.attempt}) was interrupted after stalling while ${this.describeStreamLocation(snapshot.phase, snapshot.activeToolName)}.`
-                : `The previous attempt (${snapshot.attempt}) ended without a valid completion${snapshot.finishReason ? ` (finish reason: ${snapshot.finishReason})` : ''}.`,
-            'IMPORTANT: The tool call history from the failed attempt has been removed from this conversation. The ledger below is the authoritative record of what was already verified.',
-            'Do NOT repeat completed steps unless the current page state clearly contradicts this ledger.',
-            'Continue from the NEXT incomplete step, then either finish the task or report a concrete blocker.',
-        ];
-        if (snapshot.browserState.currentUrl || snapshot.browserState.activeTabId || snapshot.browserState.tabs?.length) {
-            lines.push('', 'Last known browser state:');
-            if (snapshot.browserState.currentUrl) {
-                lines.push(`- Current URL: ${snapshot.browserState.currentUrl}`);
-            }
-            if (snapshot.browserState.activeTabId) {
-                lines.push(`- Active tab: ${snapshot.browserState.activeTabId}`);
-            }
-            if (snapshot.browserState.tabs?.length) {
-                const visibleTabs = snapshot.browserState.tabs.slice(0, 6);
-                for (const tab of visibleTabs) {
-                    lines.push(`- Tab ${tab.id}${tab.active ? ' [active]' : ''}: ${tab.url}${tab.title ? ` (${tab.title})` : ''}`);
-                }
-                if (snapshot.browserState.tabs.length > visibleTabs.length) {
-                    lines.push(`- ... ${snapshot.browserState.tabs.length - visibleTabs.length} more tab(s)`);
-                }
+    deriveCompletedSteps(request) {
+        const completed = new Set();
+        for (const boundary of request.recentBoundaries) {
+            if ((boundary.kind === 'tool' ||
+                boundary.kind === 'checkpoint' ||
+                boundary.kind === 'completion') &&
+                boundary.summary) {
+                completed.add(boundary.summary);
             }
         }
-        if (snapshot.taskCheckpoints.length > 0) {
-            lines.push('', 'Recorded task checkpoints:');
-            for (const checkpoint of snapshot.taskCheckpoints) {
-                lines.push(`- ${checkpoint.summary}`);
+        for (const checkpoint of request.taskCheckpoints) {
+            if (checkpoint.status === 'done') {
+                completed.add(checkpoint.summary);
             }
         }
-        const toolEntries = snapshot.progressEntries.filter((entry) => entry.source === 'tool');
-        if (toolEntries.length > 0) {
-            lines.push('', 'Confirmed actions from the previous attempt:');
-            for (const entry of toolEntries) {
-                const prefix = entry.isError ? '[error]' : entry.stateChanging ? '[done]' : '[seen]';
-                lines.push(`- ${prefix} ${entry.summary}`);
+        for (const entry of request.progressEntries) {
+            if (entry.source === 'tool' && entry.stateChanging && !entry.isError) {
+                completed.add(entry.summary);
             }
         }
-        if (snapshot.cause === 'stall' && snapshot.activeToolName) {
-            lines.push('', `The attempt was last waiting on: ${snapshot.activeToolName}${snapshot.activeToolCallId ? ` (${snapshot.activeToolCallId})` : ''}.`);
+        return Array.from(completed).slice(-10);
+    }
+    buildFallbackRecoveryAssessment(request, options) {
+        const completedSteps = this.deriveCompletedSteps(request);
+        const browserHints = [];
+        if (request.browserState.currentUrl)
+            browserHints.push(`Current URL: ${request.browserState.currentUrl}`);
+        if (request.browserState.activeTabId)
+            browserHints.push(`Active tab: ${request.browserState.activeTabId}`);
+        const diagnosis = options?.reason ??
+            (request.cause === 'stall'
+                ? `Recovery guidance is unavailable while the stream is stalled in ${this.describeStreamLocation(request.phase, request.activeToolName)}.`
+                : `Recovery guidance is unavailable after the turn ended with ${request.turnOutcome} (${request.finishReason ?? 'no final answer'}).`);
+        const nextStep = request.cause === 'stall'
+            ? 'Resume from the last verified browser state and continue with the next unfinished step.'
+            : 'Use the verified progress below to continue from the next unfinished step and avoid repeating confirmed work.';
+        const lines = [
+            '[System fallback recovery]',
+            diagnosis,
+            'The failed attempt tool history has been removed; rely on this verified summary instead.',
+        ];
+        if (completedSteps.length > 0) {
+            lines.push('', 'Completed steps:');
+            for (const step of completedSteps)
+                lines.push(`- ${step}`);
+        }
+        if (browserHints.length > 0) {
+            lines.push('', 'Last known browser state:');
+            for (const hint of browserHints)
+                lines.push(`- ${hint}`);
+        }
+        if (request.latestBoundary) {
+            lines.push('', `Latest verified boundary: ${request.latestBoundary.summary}`);
+        }
+        if (request.repetitionSignals.length > 0) {
+            lines.push('', 'Repetition warnings:');
+            for (const signal of request.repetitionSignals)
+                lines.push(`- ${signal}`);
         }
-        if (snapshot.partialContent) {
-            lines.push('', 'Partial assistant text emitted before the attempt ended:', snapshot.partialContent);
+        if (request.partialContent) {
+            lines.push('', 'Partial assistant text from the failed attempt:', request.partialContent);
         }
-        lines.push('', 'End your final answer by calling task_complete or task_blocked.');
+        lines.push('', `Next step: ${nextStep}`);
+        lines.push('Only repeat a completed action if the current page state clearly contradicts this summary.');
+        lines.push('End your final answer by calling task_complete or task_blocked.');
+        return {
+            action: options?.action ?? 'retry',
+            operatorMessage: request.cause === 'stall'
+                ? SYSTEM_FALLBACK_STALL_PROMPT
+                : SYSTEM_FALLBACK_COMPLETION_PROMPT,
+            modelMessage: lines.join('\n'),
+            diagnosis,
+            nextStep,
+            completedSteps,
+        };
+    }
+    buildRetryContextMessage(cause, attempt, modelMessage, source) {
         return {
-            id: `system:${snapshot.cause}-retry:${snapshot.attempt}`,
+            id: `system:${cause}-retry:${attempt}`,
             role: 'system',
-            content: lines.join('\n'),
+            content: modelMessage,
             timestamp: 0,
             metadata: {
                 transient: true,
-                source: snapshot.cause === 'stall' ? 'watchdog-resume' : 'completion-resume',
+                source: cause === 'stall' ? 'watchdog-resume' : 'completion-resume',
+                recoverySource: source,
             },
         };
     }
     formatToolOutputPreview(output) {
-        return this.truncateResumeText(output, 180)
-            .replace(/\s+/g, ' ')
-            .trim();
+        return this.truncateResumeText(output, 180).replace(/\s+/g, ' ').trim();
     }
     truncateResumeText(text, maxChars) {
         const normalized = text.replace(/\r\n/g, '\n').trim();
@@ -907,6 +1198,54 @@ export class Orchestrator extends TypedEventEmitter {
             return normalized;
         return `${normalized.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`;
     }
+    serializeDebugValue(value, maxChars) {
+        const raw = typeof value === 'string' ? value : (JSON.stringify(value, null, 2) ?? String(value));
+        if (raw.length <= maxChars) {
+            return { value: raw, truncated: false };
+        }
+        return {
+            value: `${raw.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`,
+            truncated: true,
+        };
+    }
+    buildToolDebugPayload(toolCall, result, toolName) {
+        const argsPreview = this.serializeDebugValue(toolCall.args, DEBUG_TOOL_STRUCTURED_MAX_CHARS);
+        if (!result) {
+            return {
+                requestedToolName: toolCall.name,
+                toolName: toolName ?? (toolCall.name.trim() || toolCall.name),
+                toolCallId: toolCall.id,
+                toolArgs: argsPreview.value,
+                debugPayloadTruncated: argsPreview.truncated,
+            };
+        }
+        const outputPreview = this.serializeDebugValue(result.output, DEBUG_TOOL_OUTPUT_MAX_CHARS);
+        const detailsPreview = result.details
+            ? this.serializeDebugValue(result.details, DEBUG_TOOL_STRUCTURED_MAX_CHARS)
+            : null;
+        const resumeMetadata = result.metadata && typeof result.metadata === 'object'
+            ? (result.metadata.resume ?? null)
+            : null;
+        const resumePreview = resumeMetadata
+            ? this.serializeDebugValue(resumeMetadata, DEBUG_TOOL_STRUCTURED_MAX_CHARS)
+            : null;
+        return {
+            requestedToolName: toolCall.name,
+            toolName: toolName ?? (toolCall.name.trim() || toolCall.name),
+            toolCallId: toolCall.id,
+            toolArgs: argsPreview.value,
+            toolOutput: outputPreview.value,
+            toolDetails: detailsPreview?.value ?? null,
+            toolResume: resumePreview?.value ?? null,
+            isError: result.isError,
+            warnings: result.warnings ?? [],
+            truncated: result.truncated ?? false,
+            debugPayloadTruncated: argsPreview.truncated ||
+                outputPreview.truncated ||
+                Boolean(detailsPreview?.truncated) ||
+                Boolean(resumePreview?.truncated),
+        };
+    }
     recordCheckpoint(continuity, step, status, evidence) {
         const checkpoint = {
             step,
@@ -929,6 +1268,19 @@ export class Orchestrator extends TypedEventEmitter {
             isError: false,
             checkpointStatus: status,
         });
+        this.recordBoundary(continuity, {
+            kind: 'checkpoint',
+            action: 'task_checkpoint',
+            summary: checkpoint.summary,
+            stateChanging: status === 'done',
+            evidence,
+            checkpointStatus: status,
+        });
+        this.appendTurnJournalEntry('checkpoint', checkpoint.summary, {
+            step,
+            status,
+            evidence,
+        });
         return checkpoint;
     }
     recordAttemptToolProgress(completionState, toolName, result) {
@@ -938,6 +1290,16 @@ export class Orchestrator extends TypedEventEmitter {
             return;
         this.recordProgressEntry(continuity, entry);
         this.updateBrowserState(continuity.browserState, result);
+        if (entry.stateChanging && !entry.isError) {
+            this.recordBoundary(continuity, {
+                kind: 'tool',
+                action: entry.action,
+                summary: entry.summary,
+                stateChanging: true,
+                url: entry.url,
+                tabId: entry.tabId,
+            });
+        }
     }
     createProgressEntry(toolName, result) {
         const resume = this.getBrowserResumeMetadata(result);
@@ -967,19 +1329,19 @@ export class Orchestrator extends TypedEventEmitter {
     }
     recordProgressEntry(continuity, entry) {
         const last = continuity.progressLedger.at(-1);
-        if (last
-            && entry.source === 'tool'
-            && last.source === 'tool'
-            && !entry.stateChanging
-            && !last.stateChanging
-            && last.action === entry.action
-            && last.summary === entry.summary
-            && last.url === entry.url
-            && last.tabId === entry.tabId) {
+        if (last &&
+            entry.source === 'tool' &&
+            last.source === 'tool' &&
+            !entry.stateChanging &&
+            !last.stateChanging &&
+            last.action === entry.action &&
+            last.summary === entry.summary &&
+            last.url === entry.url &&
+            last.tabId === entry.tabId) {
             return;
         }
         continuity.progressLedger.push(entry);
-        while (continuity.progressLedger.length > 20) {
+        while (continuity.progressLedger.length > 50) {
             const removableIndex = continuity.progressLedger.findIndex((candidate) => candidate.source === 'tool' && !candidate.stateChanging);
             continuity.progressLedger.splice(removableIndex >= 0 ? removableIndex : 0, 1);
         }
@@ -997,18 +1359,27 @@ export class Orchestrator extends TypedEventEmitter {
         const resume = this.getBrowserResumeMetadata(result);
         if (!resume)
             return;
-        if (resume.url) {
-            browserState.currentUrl = resume.url;
+        const stateDelta = resume.stateDelta && typeof resume.stateDelta === 'object'
+            ? resume.stateDelta
+            : null;
+        const deltaUrl = typeof stateDelta?.currentUrl === 'string' ? stateDelta.currentUrl : undefined;
+        const deltaActiveTabId = typeof stateDelta?.activeTabId === 'string' ? stateDelta.activeTabId : undefined;
+        const deltaTabs = Array.isArray(stateDelta?.tabs)
+            ? stateDelta.tabs
+            : undefined;
+        if (resume.url ?? deltaUrl) {
+            browserState.currentUrl = resume.url ?? deltaUrl;
         }
-        if (resume.activeTabId) {
-            browserState.activeTabId = resume.activeTabId;
+        if (resume.activeTabId ?? deltaActiveTabId) {
+            browserState.activeTabId = resume.activeTabId ?? deltaActiveTabId;
         }
         else if (resume.tabId && resume.stateChanging) {
             browserState.activeTabId = resume.tabId;
         }
-        if (resume.tabs?.length) {
-            browserState.tabs = resume.tabs.map((tab) => ({ ...tab }));
-            const active = resume.tabs.find((tab) => tab.active);
+        const nextTabs = resume.tabs?.length ? resume.tabs : deltaTabs;
+        if (nextTabs?.length) {
+            browserState.tabs = nextTabs.map((tab) => ({ ...tab }));
+            const active = nextTabs.find((tab) => tab.active);
             if (active) {
                 browserState.activeTabId = active.id;
                 browserState.currentUrl = active.url;
@@ -1028,8 +1399,8 @@ export class Orchestrator extends TypedEventEmitter {
     evaluateCompletionGuard(displayContent, finishMeta, completionState) {
         const trimmedContent = displayContent.trim();
         const hadExternalToolActivity = completionState.externalToolCallCount > 0;
-        const endedOnToolCalls = finishMeta?.finishReason === 'tool-calls'
-            || finishMeta?.stepFinishReasons.at(-1) === 'tool-calls';
+        const endedOnToolCalls = finishMeta?.finishReason === 'tool-calls' ||
+            finishMeta?.stepFinishReasons.at(-1) === 'tool-calls';
         if (trimmedContent.length === 0 && hadExternalToolActivity) {
             return {
                 message: 'Turn ended after tool activity without a final answer.',
@@ -1098,10 +1469,15 @@ export class Orchestrator extends TypedEventEmitter {
             streamPromise.then(settleResolve, settleReject);
         });
     }
-    startStreamWatchdog() {
+    startStreamWatchdog(latestUserMessage) {
         this.stopStreamWatchdog();
         this.markStreamWaitingModel();
+        this.streamDeferredUntil = 0;
         this.streamWatchdog = setInterval(() => {
+            if (!this.currentAttemptCompletionState || !this.currentStreamTurn)
+                return;
+            if (this.streamDeferredUntil > Date.now())
+                return;
             const elapsed = Date.now() - this.lastStreamActivityAt;
             const stallThresholdMs = this.getCurrentStallThresholdMs();
             if (elapsed < stallThresholdMs)
@@ -1115,31 +1491,106 @@ export class Orchestrator extends TypedEventEmitter {
             this.emitWatchdog('stalled', `Stalled after ${elapsedSeconds}s while ${this.describeStreamLocation()}.`, { level: 'warn', elapsedSeconds });
             this.emit({ type: 'cerebrum:stall', ...diagnostics });
             if (!this.cerebellum?.isConnected()) {
-                // Cerebellum dropped mid-stream — abort the current turn
                 this.emitWatchdog('abort_issued', 'Cerebellum disconnected during an active stream; aborting the turn.', { level: 'warn', elapsedSeconds });
                 this.abortController?.abort();
                 return;
             }
             this._nudgeInFlight = true;
-            const doNudge = () => {
-                this.streamNudgeCount++;
-                this.emitWatchdog('nudge_requested', `Cerebellum requested nudge ${this.streamNudgeCount}/${this.maxNudgeRetries} after ${elapsedSeconds}s while ${this.describeStreamLocation()}.`, { level: 'info', elapsedSeconds });
-                this.emit({ type: 'cerebrum:stall:nudge', attempt: this.streamNudgeCount, ...diagnostics });
-                this.emitWatchdog('abort_issued', `Aborting stalled stream attempt ${this.currentStreamTurn?.attempt ?? 0}.`, { level: 'warn', elapsedSeconds });
-                this.abortController?.abort();
-            };
             void (async () => {
                 try {
-                    const result = await this.cerebellum.verifyToolResult('stream_watchdog', { action: 'check_stall', elapsed: String(elapsedSeconds) }, `Stream silent for ${elapsedSeconds}s — no chunks or tool calls received`, false);
-                    // Cerebellum decides: passed=false → nudge. passed=true → wait.
-                    // null (disconnected mid-call) → nudge as safety fallback.
-                    if (!result || !result.passed) {
-                        doNudge();
+                    const request = this.buildRecoveryRequest({
+                        cause: 'stall',
+                        attempt: this.currentStreamTurn.attempt,
+                        partialContent: this.currentPartialContent,
+                        completionState: this.currentAttemptCompletionState,
+                        turnOutcome: 'stalled',
+                        latestUserMessage,
+                        elapsedSeconds,
+                    });
+                    const { source, assessment } = await this.assessTurnRecovery(request);
+                    this.emitRecoveryTrace('stall', source, assessment, assessment.action === 'stop' ? 'warn' : 'info');
+                    this.appendTurnJournalEntry('recovery', assessment.operatorMessage, {
+                        cause: 'stall',
+                        source,
+                        action: assessment.action,
+                        diagnosis: assessment.diagnosis,
+                        nextStep: assessment.nextStep,
+                        waitSeconds: assessment.waitSeconds,
+                        completedSteps: assessment.completedSteps,
+                    });
+                    if (assessment.action === 'wait') {
+                        const waitSeconds = Math.max(15, assessment.waitSeconds ?? this.streamStallThreshold / 1000);
+                        this.streamDeferredUntil = Date.now() + waitSeconds * 1000;
+                        return;
+                    }
+                    if (assessment.action === 'retry') {
+                        this.streamNudgeCount++;
+                        this.pendingRecoveryDecision = { cause: 'stall', source, assessment };
+                        this.recordBoundary(this.currentAttemptCompletionState.continuity, {
+                            kind: 'recovery',
+                            action: 'stall_retry',
+                            summary: assessment.diagnosis,
+                            stateChanging: false,
+                        });
+                        this.emitWatchdog('nudge_requested', `Cerebellum requested nudge ${this.streamNudgeCount}/${this.maxNudgeRetries} after ${elapsedSeconds}s while ${this.describeStreamLocation()}.`, { level: 'info', elapsedSeconds });
+                        this.emit({
+                            type: 'cerebrum:stall:nudge',
+                            attempt: this.streamNudgeCount,
+                            ...diagnostics,
+                        });
+                        this.emitWatchdog('abort_issued', `Aborting stalled stream attempt ${this.currentStreamTurn?.attempt ?? 0}.`, { level: 'warn', elapsedSeconds });
+                        this.abortController?.abort();
+                        return;
                     }
+                    this.pendingRecoveryDecision = { cause: 'stall', source, assessment };
+                    this.recordBoundary(this.currentAttemptCompletionState.continuity, {
+                        kind: 'recovery',
+                        action: 'stall_stop',
+                        summary: assessment.diagnosis,
+                        stateChanging: false,
+                    });
+                    this.emitWatchdog('abort_issued', 'Aborting stalled stream because recovery guidance requested stop.', { level: 'warn', elapsedSeconds });
+                    this.abortController?.abort();
                 }
                 catch {
-                    // gRPC error (including deadline exceeded) → nudge
-                    doNudge();
+                    const request = this.buildRecoveryRequest({
+                        cause: 'stall',
+                        attempt: this.currentStreamTurn.attempt,
+                        partialContent: this.currentPartialContent,
+                        completionState: this.currentAttemptCompletionState,
+                        turnOutcome: 'stalled',
+                        latestUserMessage,
+                        elapsedSeconds,
+                    });
+                    const assessment = this.buildFallbackRecoveryAssessment(request, {
+                        reason: `Recovery assessment failed after ${elapsedSeconds}s while ${this.describeStreamLocation()}.`,
+                    });
+                    this.pendingRecoveryDecision = { cause: 'stall', source: 'fallback', assessment };
+                    this.emitRecoveryTrace('stall', 'fallback', assessment, 'warn');
+                    this.appendTurnJournalEntry('recovery', assessment.operatorMessage, {
+                        cause: 'stall',
+                        source: 'fallback',
+                        action: assessment.action,
+                        diagnosis: assessment.diagnosis,
+                        nextStep: assessment.nextStep,
+                        waitSeconds: assessment.waitSeconds,
+                        completedSteps: assessment.completedSteps,
+                    });
+                    this.streamNudgeCount++;
+                    this.recordBoundary(this.currentAttemptCompletionState.continuity, {
+                        kind: 'recovery',
+                        action: 'stall_retry',
+                        summary: assessment.diagnosis,
+                        stateChanging: false,
+                    });
+                    this.emitWatchdog('nudge_requested', `Fallback retry ${this.streamNudgeCount}/${this.maxNudgeRetries} after ${elapsedSeconds}s while ${this.describeStreamLocation()}.`, { level: 'info', elapsedSeconds });
+                    this.emit({
+                        type: 'cerebrum:stall:nudge',
+                        attempt: this.streamNudgeCount,
+                        ...diagnostics,
+                    });
+                    this.emitWatchdog('abort_issued', `Aborting stalled stream attempt ${this.currentStreamTurn?.attempt ?? 0}.`, { level: 'warn', elapsedSeconds });
+                    this.abortController?.abort();
                 }
                 finally {
                     this._nudgeInFlight = false;
@@ -1168,6 +1619,11 @@ export class Orchestrator extends TypedEventEmitter {
             const userMessage = this.conversations.appendMessage(convId, 'user', content);
             this.emit({ type: 'message:user', message: userMessage });
         }
+        const latestUserMessage = content ||
+            [...this.conversations.getMessages(convId)]
+                .reverse()
+                .find((message) => message.role === 'user')?.content ||
+            '';
         this.streamNudgeCount = 0;
         let completionRetryCount = 0;
         let nextRetryContext = null;
@@ -1196,6 +1652,10 @@ export class Orchestrator extends TypedEventEmitter {
                     attempt: attemptNumber,
                     conversationId: convId,
                 };
+                this.currentPartialContent = '';
+                this.currentLastContentKind = 'empty';
+                this.currentJournaledContentLength = 0;
+                this.pendingRecoveryDecision = null;
                 log.info('stream_started', {
                     turnId,
                     attempt: attemptNumber,
@@ -1204,8 +1664,14 @@ export class Orchestrator extends TypedEventEmitter {
                     completionRetryCount,
                     retryCause,
                 });
+                this.appendTurnJournalEntry('turn_started', `Turn attempt ${attemptNumber} started.`, {
+                    retryCause: retryCause ?? null,
+                    latestUserMessage: this.truncateResumeText(latestUserMessage, 600),
+                    stallRetryCount: this.streamNudgeCount,
+                    completionRetryCount,
+                });
                 this.emit({ type: 'message:cerebrum:start', conversationId: convId });
-                this.startStreamWatchdog();
+                this.startStreamWatchdog(latestUserMessage);
                 let messages = this.conversations.getMessages(convId);
                 // On retry: exclude failed attempts' messages from history.
                 // The resume context already summarizes what happened — sending the raw tool calls
@@ -1274,6 +1740,8 @@ export class Orchestrator extends TypedEventEmitter {
                 ];
                 const toolDefs = Object.fromEntries(allTools);
                 let fullContent = '';
+                let finalDisplayContent = '';
+                let attemptFinishMeta;
                 const throwIfToolAttemptAborted = () => {
                     if (!isCurrentAttempt()) {
                         throw createAbortError('Tool execution aborted');
@@ -1286,26 +1754,42 @@ export class Orchestrator extends TypedEventEmitter {
                             if (!isCurrentAttempt() || abortController.signal.aborted)
                                 return;
                             fullContent += chunk;
+                            this.currentPartialContent = fullContent;
+                            this.currentLastContentKind = 'text';
                             this.markStreamWaitingModel();
+                            this.persistPartialContentSnapshot();
                             this.emit({ type: 'message:cerebrum:chunk', chunk });
                         },
                         onToolCall: async (toolCall) => {
                             throwIfToolAttemptAborted();
-                            this.logStreamDebug('tool_callback_started', {
-                                toolName: toolCall.name.trim() || toolCall.name,
-                                toolCallId: toolCall.id,
-                            });
+                            this.logStreamDebug('tool_callback_started', this.buildToolDebugPayload(toolCall));
                             this.markStreamWaitingTool(toolCall);
+                            this.currentLastContentKind = 'tool-call';
                             const requestedToolName = toolCall.name;
                             const normalizedToolName = requestedToolName.trim() || requestedToolName;
+                            this.appendTurnJournalEntry('tool_start', `Calling ${normalizedToolName}`, {
+                                requestedToolName,
+                                toolName: normalizedToolName,
+                                callId: toolCall.id,
+                                args: toolCall.args,
+                            });
                             const isInternalTaskSignal = this.isInternalTaskSignalTool(normalizedToolName);
                             if (isInternalTaskSignal) {
                                 completionState.internalToolCallCount++;
                             }
                             else {
                                 completionState.externalToolCallCount++;
-                                this.emit({ type: 'message:cerebrum:toolcall', toolCall: { ...toolCall, name: normalizedToolName } });
-                                this.emit({ type: 'tool:start', callId: toolCall.id, name: normalizedToolName });
+                                this.emit({
+                                    type: 'message:cerebrum:toolcall',
+                                    toolCall: { ...toolCall, name: normalizedToolName },
+                                });
+                                this.emit({
+                                    type: 'tool:start',
+                                    callId: toolCall.id,
+                                    name: normalizedToolName,
+                                    requestedName: requestedToolName !== normalizedToolName ? requestedToolName : undefined,
+                                    args: toolCall.args,
+                                });
                             }
                             const { toolName, result } = await this.toolRuntime.execute({
                                 toolCall,
@@ -1315,21 +1799,27 @@ export class Orchestrator extends TypedEventEmitter {
                                 scopeKey: convId,
                                 abortSignal: abortController.signal,
                             });
-                            this.logStreamDebug('tool_callback_finished', {
-                                toolName,
-                                toolCallId: toolCall.id,
-                                isError: result.isError,
-                            });
+                            this.logStreamDebug('tool_callback_finished', this.buildToolDebugPayload(toolCall, result, toolName));
                             throwIfAborted(abortController.signal, 'Tool execution aborted');
                             this.markStreamWaitingModel();
+                            this.currentLastContentKind = result.isError ? 'error' : 'tool-call';
                             if (!isInternalTaskSignal) {
-                                this.emit({ type: 'tool:end', result });
+                                this.emit({
+                                    type: 'tool:end',
+                                    callId: toolCall.id,
+                                    name: toolName,
+                                    requestedName: requestedToolName !== toolName ? requestedToolName : undefined,
+                                    args: toolCall.args,
+                                    result,
+                                });
                             }
                             if (!isInternalTaskSignal && !result.isError) {
                                 completionState.successfulExternalToolCount++;
                             }
                             // Cerebellum verification (non-blocking)
-                            if (!isInternalTaskSignal && this.cerebellum?.isConnected() && this.verificationEnabled) {
+                            if (!isInternalTaskSignal &&
+                                this.cerebellum?.isConnected() &&
+                                this.verificationEnabled) {
                                 try {
                                     throwIfAborted(abortController.signal, 'Tool execution aborted');
                                     this.emit({ type: 'verification:start', callId: toolCall.id, toolName });
@@ -1364,6 +1854,18 @@ export class Orchestrator extends TypedEventEmitter {
                                 }
                             }
                             throwIfToolAttemptAborted();
+                            const toolJournalEntry = this.createProgressEntry(toolName, result);
+                            this.appendTurnJournalEntry('tool_end', toolJournalEntry?.summary ??
+                                `${toolName}: ${this.formatToolOutputPreview(result.output)}`, {
+                                requestedToolName,
+                                toolName,
+                                callId: toolCall.id,
+                                isError: result.isError,
+                                args: toolCall.args,
+                                output: this.truncateResumeText(result.output, 2_000),
+                                details: result.details,
+                                metadata: result.metadata,
+                            });
                             if (!isInternalTaskSignal) {
                                 this.recordAttemptToolProgress(completionState, toolName, result);
                                 const toolMsg = this.conversations.appendMessage(convId, 'tool', result.output, {
@@ -1382,18 +1884,27 @@ export class Orchestrator extends TypedEventEmitter {
                                 return;
                             this.stopStreamWatchdog();
                             let displayContent = content;
+                            finalDisplayContent = content;
+                            attemptFinishMeta = finishMeta;
+                            this.currentLastContentKind =
+                                finishMeta?.lastContentKind ??
+                                    (content.trim() ? 'text' : this.currentLastContentKind);
+                            this.persistPartialContentSnapshot(true);
                             const visibleToolCalls = toolCalls?.filter((toolCall) => !this.isInternalTaskSignalTool(toolCall.name));
+                            const turnOutcome = this.classifyTurnOutcome(displayContent, finishMeta, completionState);
                             log.info('stream_finish_observed', {
                                 turnId,
                                 attempt: attemptNumber,
                                 conversationId: convId,
                                 finishReason: finishMeta?.finishReason,
                                 rawFinishReason: finishMeta?.rawFinishReason,
+                                lastContentKind: finishMeta?.lastContentKind,
                                 stepCount: finishMeta?.stepCount ?? 0,
                                 chunkCount: finishMeta?.chunkCount ?? 0,
                                 toolCallCount: finishMeta?.toolCallCount ?? 0,
                                 textChars: finishMeta?.textChars ?? content.length,
                                 completionSignal: completionState.signal,
+                                turnOutcome,
                             });
                             // Check for discovery completion — parse and strip the tag before storing
                             if (this.discoveryMode && content.includes('<discovery_complete>')) {
@@ -1402,36 +1913,28 @@ export class Orchestrator extends TypedEventEmitter {
                                 displayContent = content
                                     .replace(/<discovery_complete>[\s\S]*?<\/discovery_complete>/g, '')
                                     .trim();
+                                finalDisplayContent = displayContent;
                                 if (parsed && this.onDiscoveryComplete) {
                                     this.discoveryMode = false;
                                     this.onDiscoveryComplete(parsed);
                                     log.info('Discovery completed', { name: parsed.name });
                                 }
                             }
+                            this.appendTurnJournalEntry('turn_finished', `Turn ended with ${turnOutcome}.`, {
+                                finishReason: finishMeta?.finishReason,
+                                rawFinishReason: finishMeta?.rawFinishReason,
+                                lastContentKind: finishMeta?.lastContentKind ?? this.currentLastContentKind,
+                                turnOutcome,
+                                textChars: finishMeta?.textChars ?? displayContent.length,
+                                toolCallCount: finishMeta?.toolCallCount ?? 0,
+                                completionSignal: completionState.signal,
+                                finalContent: this.truncateResumeText(displayContent, 2_000),
+                            });
+                            this.pruneTurnJournals(convId);
                             const guardFailure = this.evaluateCompletionGuard(displayContent, finishMeta, completionState);
                             if (guardFailure) {
                                 completionGuardFailure = guardFailure;
-                                nextRetryContext = this.buildRetryContextMessage(this.buildCompletionRetrySnapshot({
-                                    attempt: attemptNumber,
-                                    partialContent: fullContent || displayContent,
-                                    completionState,
-                                    finishMeta,
-                                }));
-                                if (nextRetryContext) {
-                                    log.info('completion_retry_context_prepared', {
-                                        turnId,
-                                        attempt: attemptNumber,
-                                        conversationId: convId,
-                                        finishReason: finishMeta?.finishReason,
-                                        rawFinishReason: finishMeta?.rawFinishReason,
-                                        hasPartialContent: (fullContent || displayContent).trim().length > 0,
-                                        progressEntries: completionState.continuity.progressLedger.length,
-                                        taskCheckpoints: completionState.continuity.taskCheckpoints.length,
-                                        hasBrowserState: Boolean(completionState.continuity.browserState.currentUrl
-                                            || completionState.continuity.browserState.activeTabId
-                                            || completionState.continuity.browserState.tabs?.length),
-                                    });
-                                }
+                                finalDisplayContent = displayContent;
                                 this.emitCompletionTrace('guard_triggered', guardFailure.message, guardFailure.signal, 'warn');
                                 log.warn('completion_guard_triggered', {
                                     turnId,
@@ -1439,11 +1942,13 @@ export class Orchestrator extends TypedEventEmitter {
                                     conversationId: convId,
                                     finishReason: finishMeta?.finishReason,
                                     rawFinishReason: finishMeta?.rawFinishReason,
+                                    lastContentKind: finishMeta?.lastContentKind,
                                     stepCount: finishMeta?.stepCount ?? 0,
                                     chunkCount: finishMeta?.chunkCount ?? 0,
                                     toolCallCount: finishMeta?.toolCallCount ?? 0,
                                     textChars: finishMeta?.textChars ?? displayContent.length,
                                     completionSignal: completionState.signal,
+                                    turnOutcome,
                                 });
                                 return;
                             }
@@ -1452,7 +1957,11 @@ export class Orchestrator extends TypedEventEmitter {
                             if (failedAttemptMessageIds.length > 0) {
                                 const deleted = this.conversations.deleteMessages(convId, failedAttemptMessageIds);
                                 if (deleted > 0) {
-                                    log.info('Cleaned up failed attempt messages', { deleted, convId, attempt: attemptNumber });
+                                    log.info('Cleaned up failed attempt messages', {
+                                        deleted,
+                                        convId,
+                                        attempt: attemptNumber,
+                                    });
                                 }
                             }
                             const cerebrumMessage = this.conversations.appendMessage(convId, 'cerebrum', displayContent, visibleToolCalls?.length ? { toolCalls: visibleToolCalls } : undefined);
@@ -1486,10 +1995,74 @@ export class Orchestrator extends TypedEventEmitter {
                     await this.awaitStreamAttempt(streamPromise, abortController);
                     const completionFailure = completionGuardFailure;
                     if (completionFailure !== null) {
+                        const turnOutcome = this.classifyTurnOutcome(finalDisplayContent, attemptFinishMeta, completionState);
                         const completionSignal = completionFailure.signal;
+                        const recoveryRequest = this.buildRecoveryRequest({
+                            cause: 'completion',
+                            attempt: attemptNumber,
+                            partialContent: fullContent || finalDisplayContent,
+                            completionState,
+                            turnOutcome,
+                            latestUserMessage,
+                            completionRetryCount,
+                            finishMeta: attemptFinishMeta,
+                        });
+                        const { source, assessment } = await this.assessTurnRecovery(recoveryRequest);
+                        this.emitRecoveryTrace('completion', source, assessment, assessment.action === 'stop' ? 'warn' : 'info');
+                        nextRetryContext = this.buildRetryContextMessage('completion', attemptNumber, assessment.modelMessage, source);
+                        this.appendTurnJournalEntry('recovery', assessment.operatorMessage, {
+                            cause: 'completion',
+                            source,
+                            action: assessment.action,
+                            diagnosis: assessment.diagnosis,
+                            nextStep: assessment.nextStep,
+                            completedSteps: assessment.completedSteps,
+                            turnOutcome,
+                            finishReason: attemptFinishMeta?.finishReason,
+                        });
+                        this.recordBoundary(completionState.continuity, {
+                            kind: 'recovery',
+                            action: assessment.action === 'stop' ? 'completion_stop' : 'completion_retry',
+                            summary: assessment.diagnosis,
+                            stateChanging: false,
+                        });
+                        log.info('completion_retry_context_prepared', {
+                            turnId,
+                            attempt: attemptNumber,
+                            conversationId: convId,
+                            source,
+                            action: assessment.action,
+                            finishReason: attemptFinishMeta?.finishReason,
+                            rawFinishReason: attemptFinishMeta?.rawFinishReason,
+                            hasPartialContent: (fullContent || finalDisplayContent).trim().length > 0,
+                            progressEntries: completionState.continuity.progressLedger.length,
+                            taskCheckpoints: completionState.continuity.taskCheckpoints.length,
+                            completedSteps: assessment.completedSteps,
+                            nextStep: assessment.nextStep,
+                            turnOutcome,
+                            lastContentKind: attemptFinishMeta?.lastContentKind,
+                            latestBoundary: completionState.continuity.boundaries.at(-1),
+                            repetitionSignals: recoveryRequest.repetitionSignals,
+                        });
+                        if (assessment.action === 'stop') {
+                            failedAttemptMessageIds.push(...attemptMessageIds);
+                            const diagnosticMessage = this.conversations.appendMessage(convId, 'system', assessment.operatorMessage);
+                            this.emit({ type: 'message:system', message: diagnosticMessage });
+                            this.emitCompletionTrace('retry_failed', assessment.diagnosis, completionSignal, 'error');
+                            this.emit({
+                                type: 'error',
+                                error: new Error(assessment.diagnosis ||
+                                    'Turn ended without a valid completion signal or final answer.'),
+                            });
+                            if (failedAttemptMessageIds.length > 0) {
+                                this.conversations.deleteMessages(convId, failedAttemptMessageIds);
+                            }
+                            loopTerminated = true;
+                            break;
+                        }
                         if (completionRetryCount < this.maxCompletionRetries) {
                             completionRetryCount++;
-                            const systemMessage = this.conversations.appendMessage(convId, 'system', COMPLETION_RETRY_PROMPT);
+                            const systemMessage = this.conversations.appendMessage(convId, 'system', assessment.operatorMessage);
                             attemptMessageIds.push(systemMessage.id);
                             failedAttemptMessageIds.push(...attemptMessageIds);
                             this.emit({ type: 'message:system', message: systemMessage });
@@ -1498,12 +2071,15 @@ export class Orchestrator extends TypedEventEmitter {
                             continue;
                         }
                         failedAttemptMessageIds.push(...attemptMessageIds);
-                        const diagnosticMessage = this.conversations.appendMessage(convId, 'system', '[Cerebellum] The turn ended repeatedly without a valid completion signal or final answer.');
+                        const diagnosticMessage = this.conversations.appendMessage(convId, 'system', source === 'cerebellum'
+                            ? '[Cerebellum] The turn ended repeatedly without a valid completion signal or final answer.'
+                            : '[System fallback] The turn ended repeatedly without a valid completion signal or final answer.');
                         this.emit({ type: 'message:system', message: diagnosticMessage });
-                        this.emitCompletionTrace('retry_failed', `Completion retries exhausted after ${completionRetryCount}/${this.maxCompletionRetries}: ${completionFailure.message}`, completionSignal, 'error');
+                        this.emitCompletionTrace('retry_failed', `Completion retries exhausted after ${completionRetryCount}/${this.maxCompletionRetries}: ${assessment.diagnosis || completionFailure.message}`, completionSignal, 'error');
                         this.emit({
                             type: 'error',
-                            error: new Error('Turn ended without a valid completion signal or final answer.'),
+                            error: new Error(assessment.diagnosis ||
+                                'Turn ended without a valid completion signal or final answer.'),
                         });
                         // Clean up all failed attempt messages on exhaustion
                         if (failedAttemptMessageIds.length > 0) {
@@ -1519,21 +2095,17 @@ export class Orchestrator extends TypedEventEmitter {
                     const failureState = this.getStreamState();
                     this.stopStreamWatchdog();
                     failedAttemptMessageIds.push(...attemptMessageIds);
-                    // Check if this was a nudge-abort (not emergency stop, not a real error)
-                    const isNudgeAbort = abortController.signal.aborted
-                        && this.streamNudgeCount > stallRetryCountAtStart
-                        && this.streamNudgeCount <= this.maxNudgeRetries;
-                    if (isNudgeAbort) {
-                        nextRetryContext = this.buildRetryContextMessage(this.buildStallRetrySnapshot({
-                            attempt: attemptNumber,
-                            phase: failureState.phase,
-                            activeToolName: failureState.activeToolName,
-                            activeToolCallId: failureState.activeToolCallId,
-                            partialContent: fullContent,
-                            completionState,
-                        }));
-                        // Inject nudge message and retry via the loop
-                        const systemMessage = this.conversations.appendMessage(convId, 'system', '[Cerebellum] You stopped mid-response. Continue from where you left off.');
+                    const recoveryDecision = this.pendingRecoveryDecision;
+                    this.pendingRecoveryDecision = null;
+                    const stallRecovery = recoveryDecision;
+                    const isRecoveryRetryAbort = abortController.signal.aborted &&
+                        stallRecovery !== null &&
+                        stallRecovery.assessment.action === 'retry' &&
+                        this.streamNudgeCount > stallRetryCountAtStart &&
+                        this.streamNudgeCount <= this.maxNudgeRetries;
+                    if (isRecoveryRetryAbort && stallRecovery) {
+                        nextRetryContext = this.buildRetryContextMessage('stall', attemptNumber, stallRecovery.assessment.modelMessage, stallRecovery.source);
+                        const systemMessage = this.conversations.appendMessage(convId, 'system', stallRecovery.assessment.operatorMessage);
                         attemptMessageIds.push(systemMessage.id);
                         failedAttemptMessageIds.push(...attemptMessageIds);
                         this.emit({ type: 'message:system', message: systemMessage });
@@ -1541,6 +2113,18 @@ export class Orchestrator extends TypedEventEmitter {
                         nextRetryCause = 'stall';
                         continue; // retry loop
                     }
+                    if (abortController.signal.aborted &&
+                        stallRecovery !== null &&
+                        stallRecovery.assessment.action === 'stop') {
+                        const systemMessage = this.conversations.appendMessage(convId, 'system', stallRecovery.assessment.operatorMessage);
+                        this.emit({ type: 'message:system', message: systemMessage });
+                        this.emit({ type: 'error', error: new Error(stallRecovery.assessment.diagnosis) });
+                        if (failedAttemptMessageIds.length > 0) {
+                            this.conversations.deleteMessages(convId, failedAttemptMessageIds);
+                        }
+                        loopTerminated = true;
+                        break;
+                    }
                     // Check if Cerebellum dropped mid-stream
                     if (this.cerebellum && !this.cerebellum.isConnected() && abortController.signal.aborted) {
                         const err = new Error('Cerebellum disconnected during active response. Restart it with: docker compose up -d cerebellum');
@@ -1553,6 +2137,16 @@ export class Orchestrator extends TypedEventEmitter {
                         break;
                     }
                     const err = error instanceof Error ? error : new Error(String(error));
+                    this.appendTurnJournalEntry('turn_error', `Turn attempt ${attemptNumber} failed: ${err.message}`, {
+                        retryCause,
+                        stallRetryCount: this.streamNudgeCount,
+                        completionRetryCount,
+                        phase: failureState.phase,
+                        activeToolName: failureState.activeToolName,
+                        activeToolCallId: failureState.activeToolCallId,
+                        error: err.message,
+                    });
+                    this.pruneTurnJournals(convId);
                     if (retryCause === 'completion') {
                         this.emitCompletionTrace('retry_failed', `Completion retry attempt ${attemptNumber} failed: ${err.message}`, completionState.signal, 'error');
                     }