@cereworker/core 26.330.3 → 26.403.2

package/dist/orchestrator.js

@@ -12,7 +12,11 @@ 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 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;
@@ -51,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';
@@ -71,11 +82,17 @@ export class Orchestrator extends TypedEventEmitter {
     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();
@@ -102,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;
@@ -181,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,
@@ -220,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.',
@@ -246,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');
@@ -269,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.',
@@ -460,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
@@ -499,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') {
@@ -540,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() {
@@ -644,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,
@@ -665,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 = {
@@ -688,6 +746,121 @@ export class Orchestrator extends TypedEventEmitter {
         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 {
@@ -700,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)
@@ -793,11 +962,13 @@ export class Orchestrator extends TypedEventEmitter {
             progressLedger: [],
             taskCheckpoints: [],
             browserState: {},
+            boundaries: [],
         };
     }
     buildRecoveryRequest(params) {
         const partialContent = this.truncateResumeText(params.partialContent, 600);
         const continuity = params.completionState.continuity;
+        const latestBoundary = continuity.boundaries.at(-1);
         return {
             conversationId: this.currentStreamTurn?.conversationId ?? '',
             turnId: this.currentStreamTurn?.turnId ?? '',
@@ -809,12 +980,31 @@ export class Orchestrator extends TypedEventEmitter {
             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,
-            latestUserMessage: params.latestUserMessage ? this.truncateResumeText(params.latestUserMessage, 600) : undefined,
+            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),
         };
     }
     emitRecoveryTrace(cause, source, assessment, level = 'info') {
@@ -864,12 +1054,19 @@ export class Orchestrator extends TypedEventEmitter {
             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) : '',
+            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 {
@@ -905,6 +1102,14 @@ export class Orchestrator extends TypedEventEmitter {
     }
     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);
+            }
+        }
         for (const checkpoint of request.taskCheckpoints) {
             if (checkpoint.status === 'done') {
                 completed.add(checkpoint.summary);
@@ -924,10 +1129,10 @@ export class Orchestrator extends TypedEventEmitter {
             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'
+        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.finishReason ?? 'no final answer'}.`);
+                : `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.';
@@ -946,6 +1151,14 @@ export class Orchestrator extends TypedEventEmitter {
             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 (request.partialContent) {
             lines.push('', 'Partial assistant text from the failed attempt:', request.partialContent);
         }
@@ -977,9 +1190,7 @@ export class Orchestrator extends TypedEventEmitter {
         };
     }
     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();
@@ -988,9 +1199,7 @@ export class Orchestrator extends TypedEventEmitter {
         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);
+        const raw = typeof value === 'string' ? value : (JSON.stringify(value, null, 2) ?? String(value));
         if (raw.length <= maxChars) {
             return { value: raw, truncated: false };
         }
@@ -1031,7 +1240,10 @@ export class Orchestrator extends TypedEventEmitter {
             isError: result.isError,
             warnings: result.warnings ?? [],
             truncated: result.truncated ?? false,
-            debugPayloadTruncated: argsPreview.truncated || outputPreview.truncated || Boolean(detailsPreview?.truncated) || Boolean(resumePreview?.truncated),
+            debugPayloadTruncated: argsPreview.truncated ||
+                outputPreview.truncated ||
+                Boolean(detailsPreview?.truncated) ||
+                Boolean(resumePreview?.truncated),
         };
     }
     recordCheckpoint(continuity, step, status, evidence) {
@@ -1056,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) {
@@ -1065,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);
@@ -1094,15 +1329,15 @@ 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);
@@ -1124,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;
@@ -1155,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.',
@@ -1259,26 +1503,52 @@ export class Orchestrator extends TypedEventEmitter {
                         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);
+                        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.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();
                 }
@@ -1288,6 +1558,7 @@ export class Orchestrator extends TypedEventEmitter {
                         attempt: this.currentStreamTurn.attempt,
                         partialContent: this.currentPartialContent,
                         completionState: this.currentAttemptCompletionState,
+                        turnOutcome: 'stalled',
                         latestUserMessage,
                         elapsedSeconds,
                     });
@@ -1296,9 +1567,28 @@ export class Orchestrator extends TypedEventEmitter {
                     });
                     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.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();
                 }
@@ -1329,9 +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
-            || '';
+        const latestUserMessage = content ||
+            [...this.conversations.getMessages(convId)]
+                .reverse()
+                .find((message) => message.role === 'user')?.content ||
+            '';
         this.streamNudgeCount = 0;
         let completionRetryCount = 0;
         let nextRetryContext = null;
@@ -1361,6 +1653,8 @@ export class Orchestrator extends TypedEventEmitter {
                     conversationId: convId,
                 };
                 this.currentPartialContent = '';
+                this.currentLastContentKind = 'empty';
+                this.currentJournaledContentLength = 0;
                 this.pendingRecoveryDecision = null;
                 log.info('stream_started', {
                     turnId,
@@ -1370,6 +1664,12 @@ 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(latestUserMessage);
                 let messages = this.conversations.getMessages(convId);
@@ -1455,22 +1755,34 @@ export class Orchestrator extends TypedEventEmitter {
                                 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', 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: 'message:cerebrum:toolcall',
+                                    toolCall: { ...toolCall, name: normalizedToolName },
+                                });
                                 this.emit({
                                     type: 'tool:start',
                                     callId: toolCall.id,
@@ -1490,6 +1802,7 @@ export class Orchestrator extends TypedEventEmitter {
                             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',
@@ -1504,7 +1817,9 @@ export class Orchestrator extends TypedEventEmitter {
                                 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 });
@@ -1539,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, {
@@ -1559,18 +1886,25 @@ export class Orchestrator extends TypedEventEmitter {
                             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>')) {
@@ -1586,6 +1920,17 @@ export class Orchestrator extends TypedEventEmitter {
                                     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;
@@ -1597,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;
                             }
@@ -1610,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);
@@ -1644,12 +1995,14 @@ 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,
@@ -1657,6 +2010,22 @@ export class Orchestrator extends TypedEventEmitter {
                         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,
@@ -1670,6 +2039,10 @@ export class Orchestrator extends TypedEventEmitter {
                             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);
@@ -1678,7 +2051,8 @@ export class Orchestrator extends TypedEventEmitter {
                             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.'),
+                                error: new Error(assessment.diagnosis ||
+                                    'Turn ended without a valid completion signal or final answer.'),
                             });
                             if (failedAttemptMessageIds.length > 0) {
                                 this.conversations.deleteMessages(convId, failedAttemptMessageIds);
@@ -1704,7 +2078,8 @@ export class Orchestrator extends TypedEventEmitter {
                         this.emitCompletionTrace('retry_failed', `Completion retries exhausted after ${completionRetryCount}/${this.maxCompletionRetries}: ${assessment.diagnosis || completionFailure.message}`, completionSignal, 'error');
                         this.emit({
                             type: 'error',
-                            error: new Error(assessment.diagnosis || '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) {
@@ -1723,11 +2098,11 @@ export class Orchestrator extends TypedEventEmitter {
                     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;
+                    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);
@@ -1738,9 +2113,9 @@ export class Orchestrator extends TypedEventEmitter {
                         nextRetryCause = 'stall';
                         continue; // retry loop
                     }
-                    if (abortController.signal.aborted
-                        && stallRecovery !== null
-                        && stallRecovery.assessment.action === 'stop') {
+                    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) });
@@ -1762,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');
                     }