@producible/cereworker-core 26.520.1

package/dist/orchestrator.js

@@ -0,0 +1,2610 @@
+import { nanoid } from 'nanoid';
+import { TypedEventEmitter } from './events.js';
+import { ConversationStore } from './conversation.js';
+import { SubAgentManager } from './sub-agent-manager.js';
+import { createSubAgentTools } from './sub-agent-tools.js';
+import { createLogger } from './logger.js';
+import { buildSystemPrompt } from './system-prompt.js';
+import { estimateMessageTokens, shouldCompact, buildCompactionMessages } from './context.js';
+import { createAbortError, throwIfAborted } from './abort.js';
+import { ToolRuntime, } from './tool-runtime.js';
+const log = createLogger('orchestrator');
+const TASK_COMPLETE_TOOL = 'task_complete';
+const TASK_BLOCKED_TOOL = 'task_blocked';
+const TASK_CHECKPOINT_TOOL = 'task_checkpoint';
+const TASK_UPSERT_TOOL = 'task_upsert';
+const TASK_REMOVE_TOOL = 'task_remove';
+const TASK_LIST_TOOL = 'task_list';
+const TASK_GET_TOOL = 'task_get';
+const INTERNAL_TASK_TOOL_NAMES = new Set([
+    TASK_COMPLETE_TOOL,
+    TASK_BLOCKED_TOOL,
+    TASK_CHECKPOINT_TOOL,
+    TASK_UPSERT_TOOL,
+    TASK_REMOVE_TOOL,
+    TASK_LIST_TOOL,
+    TASK_GET_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',
+    'browserListTabs',
+    'browserWait',
+    'browserEval',
+    'readFile',
+    'listDirectory',
+    'searchFiles',
+    'glob',
+    'memory_read',
+    'webSearch',
+    'httpFetch',
+]);
+export class Orchestrator extends TypedEventEmitter {
+    conversations;
+    cerebrum = null;
+    cerebellum = null;
+    subAgentManager = null;
+    internalTools = new Map();
+    tools = new Map();
+    activeConversationId = null;
+    systemContext = null;
+    verificationEnabled = true;
+    verificationTimeoutMs = 5000;
+    monitorIntervalMs = 30_000;
+    monitorTimer = null;
+    abortController = null;
+    autoMode = false;
+    fineTunePoller = null;
+    fineTuneDataProvider = null;
+    fineTuneMethod = 'auto';
+    fineTuneSchedule = 'auto';
+    fineTuneStatus = {
+        status: 'idle',
+        jobId: '',
+        progress: 0,
+        currentStep: 0,
+        totalSteps: 0,
+        currentLoss: 0,
+        error: '',
+        checkpointPath: '',
+        startedAt: 0,
+        completedAt: 0,
+    };
+    _fineTuneHistory = [];
+    gatewayMode = 'standalone';
+    connectedNodes = 0;
+    gatewayUrl;
+    profile;
+    instanceStore = null;
+    proactiveEnabled = false;
+    discoveryMode = false;
+    onDiscoveryComplete = null;
+    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;
+    currentQuerySession = null;
+    currentAttemptCompletionState = null;
+    currentPartialContent = '';
+    currentLastContentKind = 'empty';
+    currentJournaledContentLength = 0;
+    pendingRecoveryDecision = null;
+    streamAbortGraceMs = 1_000;
+    taskConversations = new Map();
+    taskRunning = new Set();
+    recurringTasks = [];
+    toolRuntime;
+    compactionConfig = {
+        enabled: true,
+        threshold: 0.8,
+        keepRecentMessages: 10,
+        contextWindow: 128000,
+    };
+    constructor(options) {
+        super();
+        this.conversations = options?.conversationStore ?? new ConversationStore();
+        this.toolRuntime = new ToolRuntime(options?.toolRuntime);
+        this.registerInternalTools();
+        if (options?.compaction) {
+            this.compactionConfig = { ...this.compactionConfig, ...options.compaction };
+        }
+        if (options?.streamStallThreshold)
+            this.streamStallThreshold = options.streamStallThreshold * 1000;
+        if (options?.maxNudgeRetries) {
+            this.maxNudgeRetries = options.maxNudgeRetries;
+            this.maxCompletionRetries = options.maxNudgeRetries;
+        }
+        if (options?.turnJournalRetention) {
+            this.turnJournalRetention = {
+                ...this.turnJournalRetention,
+                ...options.turnJournalRetention,
+            };
+        }
+    }
+    setCerebrum(cerebrum) {
+        this.cerebrum = cerebrum;
+    }
+    setCerebellum(cerebellum, options) {
+        this.cerebellum = cerebellum;
+        if (options?.enabled !== undefined)
+            this.verificationEnabled = options.enabled;
+        if (options?.timeoutMs !== undefined)
+            this.verificationTimeoutMs = options.timeoutMs;
+    }
+    /** Set system context (e.g. skills prompt) prepended to every Cerebrum call */
+    setSystemContext(context) {
+        this.systemContext = context;
+        log.info('System context updated', { length: context.length });
+    }
+    getSystemContext() {
+        return this.systemContext;
+    }
+    setupSubAgents(options) {
+        if (!this.cerebrum)
+            return null;
+        if (options?.monitorIntervalMs)
+            this.monitorIntervalMs = options.monitorIntervalMs;
+        this.subAgentManager = new SubAgentManager({
+            cerebrum: this.cerebrum,
+            tools: this.tools,
+            maxConcurrent: options?.maxConcurrent,
+            baseDir: options?.baseDir,
+            toolRuntime: this.toolRuntime,
+            onProgress: (agentId, note, percent) => {
+                this.emit({ type: 'agent:progress', agentId, note, percent });
+            },
+        });
+        // Register sub-agent tools with the orchestrator
+        const agentTools = createSubAgentTools(this.subAgentManager);
+        for (const [name, tool] of Object.entries(agentTools)) {
+            this.tools.set(name, tool);
+        }
+        return this.subAgentManager;
+    }
+    getSubAgentManager() {
+        return this.subAgentManager;
+    }
+    getConversationStore() {
+        return this.conversations;
+    }
+    registerInternalTools() {
+        this.internalTools.set(TASK_COMPLETE_TOOL, {
+            description: 'Record that a tool-driven task is complete. Call this once right before your final answer with a concise summary and concrete evidence.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    summary: { type: 'string', description: 'Short summary of what was completed' },
+                    evidence: { type: 'string', description: 'Concrete evidence proving completion' },
+                },
+                required: ['summary', 'evidence'],
+                additionalProperties: false,
+            },
+            execute: async (args) => this.recordCompletionSignal('complete', args),
+        });
+        this.internalTools.set(TASK_BLOCKED_TOOL, {
+            description: 'Record that you are blocked and cannot finish the task. Call this once right before your final answer with the blocker and evidence.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    blocker: { type: 'string', description: 'Specific blocker preventing completion' },
+                    evidence: { type: 'string', description: 'Concrete evidence showing the blocker' },
+                },
+                required: ['blocker', 'evidence'],
+                additionalProperties: false,
+            },
+            execute: async (args) => this.recordCompletionSignal('blocked', args),
+        });
+        this.internalTools.set(TASK_CHECKPOINT_TOOL, {
+            description: 'Record a completed or in-progress milestone during a multi-step task. Use this after each major verified step so retries can resume from the right place.',
+            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',
+                    },
+                },
+                required: ['step', 'status', 'evidence'],
+                additionalProperties: false,
+            },
+            execute: async (args) => this.recordTaskCheckpoint(args),
+        });
+    }
+    getAllTools() {
+        return new Map([...this.tools, ...this.internalTools]);
+    }
+    isInternalTaskSignalTool(name) {
+        return INTERNAL_TASK_TOOL_NAMES.has(name.trim() || name);
+    }
+    async recordCompletionSignal(signal, args) {
+        const state = this.currentAttemptCompletionState;
+        if (!state) {
+            return {
+                output: 'No active turn is available for task completion tracking.',
+                isError: true,
+            };
+        }
+        const evidence = String(args.evidence ?? '').trim();
+        if (!evidence) {
+            return {
+                output: 'A non-empty evidence field is required.',
+                isError: true,
+            };
+        }
+        if (signal === 'complete') {
+            const summary = String(args.summary ?? '').trim();
+            if (!summary) {
+                return {
+                    output: 'A non-empty summary field is required.',
+                    isError: true,
+                };
+            }
+            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.',
+                    isError: true,
+                };
+            }
+            state.signal = 'complete';
+            state.summary = summary;
+            state.blocker = undefined;
+            state.evidence = evidence;
+        }
+        else {
+            const blocker = String(args.blocker ?? '').trim();
+            if (!blocker) {
+                return {
+                    output: 'A non-empty blocker field is required.',
+                    isError: true,
+                };
+            }
+            state.signal = 'blocked';
+            state.blocker = blocker;
+            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');
+        return {
+            output: signal === 'complete' ? 'Task completion recorded.' : 'Task blocker recorded.',
+            isError: false,
+            metadata: {
+                internal: true,
+                signal,
+            },
+        };
+    }
+    async recordTaskCheckpoint(args) {
+        const state = this.currentAttemptCompletionState;
+        if (!state) {
+            return {
+                output: 'No active turn is available for task checkpoint tracking.',
+                isError: true,
+            };
+        }
+        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;
+        if (!step) {
+            return {
+                output: 'A non-empty step field is required.',
+                isError: true,
+            };
+        }
+        if (!status) {
+            return {
+                output: 'status must be either "done" or "in_progress".',
+                isError: true,
+            };
+        }
+        if (!evidence) {
+            return {
+                output: 'A non-empty evidence field is required.',
+                isError: true,
+            };
+        }
+        const checkpoint = this.recordCheckpoint(state.continuity, step, status, evidence);
+        log.info('task_checkpoint_recorded', {
+            turnId: this.currentStreamTurn?.turnId,
+            attempt: this.currentStreamTurn?.attempt,
+            conversationId: this.currentStreamTurn?.conversationId,
+            step,
+            status,
+            evidence,
+        });
+        return {
+            output: `Checkpoint recorded: ${checkpoint.summary}`,
+            isError: false,
+            metadata: {
+                internal: true,
+                checkpoint,
+            },
+        };
+    }
+    registerTool(name, tool) {
+        if (this.internalTools.has(name)) {
+            throw new Error(`Tool name ${name} is reserved for internal task signaling`);
+        }
+        this.tools.set(name, tool);
+    }
+    registerTools(tools) {
+        for (const [name, tool] of Object.entries(tools)) {
+            this.registerTool(name, tool);
+        }
+    }
+    async executeTool(name, args, options) {
+        return this.toolRuntime.execute({
+            toolCall: {
+                id: options?.callId ?? nanoid(10),
+                name,
+                args,
+            },
+            tools: this.getAllTools(),
+            conversationId: options?.conversationId,
+            sessionKey: options?.sessionKey,
+            scopeKey: options?.scopeKey,
+            turnId: options?.turnId,
+            attempt: options?.attempt,
+        });
+    }
+    unregisterTool(name) {
+        if (this.internalTools.has(name)) {
+            return false;
+        }
+        return this.tools.delete(name);
+    }
+    setProfile(profile) {
+        this.profile = profile;
+    }
+    setInstanceStore(store) {
+        this.instanceStore = store;
+    }
+    getInstanceStore() {
+        return this.instanceStore;
+    }
+    setProactiveEnabled(enabled) {
+        this.proactiveEnabled = enabled;
+    }
+    setDiscoveryMode(enabled) {
+        this.discoveryMode = enabled;
+        log.info('Discovery mode changed', { enabled });
+    }
+    isDiscoveryMode() {
+        return this.discoveryMode;
+    }
+    setDiscoveryCompleteHandler(handler) {
+        this.onDiscoveryComplete = handler;
+    }
+    sendProactiveMessage(content, source) {
+        this.emit({ type: 'message:proactive', content, source });
+    }
+    setAutoMode(enabled) {
+        this.autoMode = enabled;
+        log.info('Auto mode changed', { autoMode: enabled });
+    }
+    getAutoMode() {
+        return this.autoMode;
+    }
+    setGatewayMode(mode, extras) {
+        this.gatewayMode = mode;
+        if (extras?.connectedNodes !== undefined)
+            this.connectedNodes = extras.connectedNodes;
+        if (extras?.gatewayUrl !== undefined)
+            this.gatewayUrl = extras.gatewayUrl;
+    }
+    emergencyStop() {
+        // 1. Abort current stream
+        this.abortController?.abort();
+        this.abortController = null;
+        // 2. Cancel all sub-agents
+        if (this.subAgentManager) {
+            const agents = this.subAgentManager.listAgents();
+            agents
+                .filter((a) => a.status === 'running' || a.status === 'pending')
+                .forEach((a) => this.subAgentManager.cancel(a.id));
+        }
+        // 3. Emit event
+        this.emit({ type: 'emergency:stop' });
+        log.warn('Emergency stop triggered');
+    }
+    /** Set a callback that provides training pairs for fine-tuning (from HippocampusCurator). */
+    setFineTuneDataProvider(provider, method = 'auto') {
+        this.fineTuneDataProvider = provider;
+        this.fineTuneMethod = method;
+    }
+    getFineTuneMethod() {
+        return this.fineTuneMethod;
+    }
+    setFineTuneMethod(method) {
+        this.fineTuneMethod = method;
+    }
+    getFineTuneSchedule() {
+        return this.fineTuneSchedule;
+    }
+    setFineTuneSchedule(schedule) {
+        this.fineTuneSchedule = schedule;
+    }
+    /** Get current fine-tune status from Cerebellum (or cached local state). */
+    async getFineTuneStatus() {
+        if (this.cerebellum?.getFineTuneStatus) {
+            try {
+                const remote = await this.cerebellum.getFineTuneStatus();
+                if (remote) {
+                    this.fineTuneStatus = remote;
+                    return remote;
+                }
+            }
+            catch {
+                // Fall back to local cache
+            }
+        }
+        return this.fineTuneStatus;
+    }
+    getFineTuneHistory() {
+        return this._fineTuneHistory;
+    }
+    /** Minimum training pairs required before starting a fine-tune run. */
+    static MIN_TRAINING_PAIRS = 5;
+    /** Trigger a fine-tuning run: collect training data, send to cerebellum, start training, poll progress. */
+    async triggerFineTune() {
+        if (!this.cerebellum?.ingestTrainingData || !this.cerebellum?.startFineTune) {
+            throw new Error('Cerebellum fine-tuning not available');
+        }
+        // 1. Collect training data
+        let pairs = [];
+        if (this.fineTuneDataProvider) {
+            pairs = await this.fineTuneDataProvider();
+        }
+        // 2. Ingest training data
+        let totalPending = 0;
+        if (pairs.length > 0) {
+            totalPending = await this.cerebellum.ingestTrainingData(pairs);
+            log.info('Training data ingested', { newPairs: pairs.length, totalPending });
+        }
+        // 3. Check minimum threshold
+        if (totalPending < Orchestrator.MIN_TRAINING_PAIRS) {
+            log.info('Not enough training data, deferring fine-tune', {
+                totalPending,
+                threshold: Orchestrator.MIN_TRAINING_PAIRS,
+            });
+            throw new Error(`Not enough training data (${totalPending}/${Orchestrator.MIN_TRAINING_PAIRS} pairs). ` +
+                'Data has been saved — training will start automatically when enough accumulates.');
+        }
+        // 4. Start fine-tuning
+        const result = await this.cerebellum.startFineTune({ method: this.fineTuneMethod });
+        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.emit({ type: 'finetune:start', jobId: result.jobId });
+        log.info('Fine-tuning started', { jobId: result.jobId });
+        // 5. Poll for progress
+        this.stopFineTunePoller();
+        this.fineTunePoller = setInterval(async () => {
+            try {
+                const status = await this.cerebellum.getFineTuneStatus();
+                if (!status)
+                    return;
+                this.fineTuneStatus = status;
+                if (status.status === 'running') {
+                    this.emit({
+                        type: 'finetune:progress',
+                        jobId: status.jobId,
+                        progress: status.progress,
+                        loss: status.currentLoss,
+                    });
+                }
+                else if (status.status === 'completed') {
+                    this._fineTuneHistory.push({
+                        jobId: status.jobId,
+                        status: 'completed',
+                        completedAt: status.completedAt || Date.now(),
+                        loss: status.currentLoss,
+                    });
+                    this.instanceStore?.recordFineTune({
+                        jobId: status.jobId,
+                        method: this.fineTuneMethod,
+                        completedAt: new Date(status.completedAt || Date.now()).toISOString(),
+                        checkpointPath: status.checkpointPath,
+                        loss: status.currentLoss,
+                        trainingPairs: status.totalSteps,
+                    });
+                    this.emit({
+                        type: 'finetune:complete',
+                        jobId: status.jobId,
+                        checkpointPath: status.checkpointPath,
+                    });
+                    log.info('Fine-tuning completed', {
+                        jobId: status.jobId,
+                        checkpoint: status.checkpointPath,
+                    });
+                    this.stopFineTunePoller();
+                }
+                else if (status.status === 'failed') {
+                    this._fineTuneHistory.push({
+                        jobId: status.jobId,
+                        status: 'failed',
+                        completedAt: Date.now(),
+                        loss: status.currentLoss,
+                    });
+                    this.emit({
+                        type: 'finetune:error',
+                        jobId: status.jobId,
+                        error: status.error,
+                    });
+                    log.error('Fine-tuning failed', { jobId: status.jobId, error: status.error });
+                    this.stopFineTunePoller();
+                }
+            }
+            catch {
+                // Polling failure is non-blocking
+            }
+        }, 10_000);
+    }
+    stopFineTunePoller() {
+        if (this.fineTunePoller) {
+            clearInterval(this.fineTunePoller);
+            this.fineTunePoller = null;
+        }
+    }
+    parseDiscoveryCompletion(text) {
+        const match = text.match(/<discovery_complete>\s*([\s\S]*?)\s*<\/discovery_complete>/);
+        if (!match)
+            return null;
+        const block = match[1];
+        const nameMatch = block.match(/name:\s*(.+)/i);
+        const roleMatch = block.match(/role:\s*(.+)/i);
+        const traitsMatch = block.match(/traits:\s*(.+)/i);
+        return {
+            name: nameMatch?.[1]?.trim() || 'Cere',
+            role: roleMatch?.[1]?.trim() || 'general-purpose assistant',
+            traits: traitsMatch?.[1]
+                ?.split(',')
+                .map((t) => t.trim().toLowerCase())
+                .filter(Boolean) ?? [],
+        };
+    }
+    getActiveConversationId() {
+        return this.activeConversationId;
+    }
+    getConversation(id) {
+        return this.conversations.get(id);
+    }
+    getMessages(conversationId) {
+        const id = conversationId ?? this.activeConversationId;
+        if (!id)
+            return [];
+        return this.conversations.getMessages(id);
+    }
+    getQuerySession(conversationId, sessionId) {
+        return this.conversations.getQuerySession(conversationId, sessionId);
+    }
+    getSessionEvents(conversationId, sessionId) {
+        return this.conversations.getSessionEvents(conversationId, sessionId);
+    }
+    recordSessionEvent(conversationId, sessionId, type, summary, data) {
+        const session = this.conversations.getQuerySession(conversationId, sessionId);
+        if (!session)
+            return;
+        const updatedAt = Date.now();
+        const updatedSession = {
+            ...session,
+            updatedAt,
+            summary: this.truncateResumeText(summary, 500),
+        };
+        this.conversations.saveQuerySession(conversationId, updatedSession);
+        const event = {
+            sessionId,
+            conversationId,
+            turnId: session.turnId,
+            attempt: session.attempt,
+            timestamp: updatedAt,
+            type,
+            state: updatedSession.state,
+            summary: this.truncateResumeText(summary, 500),
+            instanceId: updatedSession.instanceId,
+            checkpointPath: updatedSession.checkpointPath ?? null,
+            data,
+        };
+        this.conversations.appendSessionEvent(conversationId, sessionId, event);
+    }
+    recordSessionMemoryUpdate(conversationId, sessionId, snapshot) {
+        const session = this.conversations.getQuerySession(conversationId, sessionId);
+        if (!session)
+            return;
+        const updated = {
+            ...session,
+            memory: snapshot,
+            updatedAt: Date.now(),
+            summary: snapshot.summary || session.summary,
+        };
+        this.conversations.saveQuerySession(conversationId, updated);
+        const event = {
+            sessionId,
+            conversationId,
+            turnId: session.turnId,
+            attempt: session.attempt,
+            timestamp: snapshot.updatedAt,
+            type: 'memory_updated',
+            state: updated.state,
+            summary: this.truncateResumeText(`Session memory updated: ${snapshot.summary}`, 500),
+            instanceId: updated.instanceId,
+            checkpointPath: updated.checkpointPath ?? null,
+            data: {
+                excerpt: snapshot.excerpt,
+            },
+        };
+        this.conversations.appendSessionEvent(conversationId, sessionId, event);
+        this.emit({ type: 'session:memory-updated', conversationId, sessionId, snapshot });
+    }
+    startConversation() {
+        const conversation = this.conversations.create();
+        this.activeConversationId = conversation.id;
+        this.instanceStore?.incrementConversation();
+        log.info('Started conversation', { id: conversation.id });
+        return conversation.id;
+    }
+    /** Resume an existing conversation by ID */
+    resumeConversation(id) {
+        const conversation = this.conversations.get(id);
+        if (!conversation)
+            return false;
+        this.activeConversationId = id;
+        const messages = this.conversations.getMessages(id);
+        this.emit({ type: 'conversation:resumed', conversationId: id, messages });
+        log.info('Resumed conversation', { id, messageCount: messages.length });
+        return true;
+    }
+    // --- Recurring Task Execution ---
+    setRecurringTasks(tasks) {
+        this.recurringTasks = tasks;
+    }
+    setTaskConversation(taskId, conversationId) {
+        this.taskConversations.set(taskId, conversationId);
+    }
+    getTaskConversation(taskId) {
+        return this.taskConversations.get(taskId);
+    }
+    isTaskRunning(taskId) {
+        return this.taskRunning.has(taskId);
+    }
+    async runTask(taskId, goal, options) {
+        if (this.taskRunning.has(taskId)) {
+            return { success: false, error: 'Task already running' };
+        }
+        // Get or create a dedicated conversation for this task
+        let convId = this.taskConversations.get(taskId);
+        if (!convId || !this.conversations.get(convId)) {
+            const conv = this.conversations.create();
+            convId = conv.id;
+            this.taskConversations.set(taskId, convId);
+        }
+        const prevAutoMode = this.autoMode;
+        if (options?.autoMode !== undefined) {
+            this.autoMode = options.autoMode;
+        }
+        this.taskRunning.add(taskId);
+        this.emit({ type: 'task:start', taskId, goal });
+        log.info('Running recurring task', { taskId, conversationId: convId });
+        const timeoutMs = options?.timeoutMs ?? 600_000;
+        try {
+            const now = new Date().toISOString();
+            const taskDef = this.recurringTasks.find((t) => t.id === taskId);
+            const schedule = taskDef?.schedule ?? 'unknown';
+            const prompt = [
+                `[Recurring Task: ${taskId}]`,
+                `Schedule: ${schedule}`,
+                `Current time: ${now}`,
+                `Goal: ${goal}`,
+                '',
+                'Execute this goal using your available tools and skills.',
+                'Review your conversation history for learnings from previous runs.',
+                'If a step fails, try an alternative approach before giving up.',
+                'After completing, use memory_log to record what you did, outcomes, and any issues.',
+            ].join('\n');
+            await Promise.race([
+                this.sendMessage(prompt, convId),
+                new Promise((_, reject) => setTimeout(() => reject(new Error(`Task timed out after ${timeoutMs / 1000}s`)), timeoutMs)),
+            ]);
+            this.emit({ type: 'task:complete', taskId });
+            log.info('Recurring task completed', { taskId });
+            return { success: true };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            this.emit({ type: 'task:error', taskId, error });
+            log.warn('Recurring task failed', { taskId, error });
+            return { success: false, error };
+        }
+        finally {
+            this.taskRunning.delete(taskId);
+            this.autoMode = prevAutoMode;
+        }
+    }
+    getStreamState() {
+        const stallThresholdMs = this.getCurrentStallThresholdMs();
+        return {
+            streaming: this.streamWatchdog !== null,
+            lastActivityAt: this.lastStreamActivityAt,
+            stallDetected: this.streamWatchdog !== null && Date.now() - this.lastStreamActivityAt > stallThresholdMs,
+            nudgeCount: this.streamNudgeCount,
+            phase: this.streamPhase,
+            activeToolName: this.activeToolCall?.name,
+            activeToolCallId: this.activeToolCall?.id,
+            activeToolStartedAt: this.activeToolCall?.startedAt,
+        };
+    }
+    markStreamWaitingModel(activityAt = Date.now()) {
+        const phaseChanged = this.streamPhase !== 'waiting_model' || this.activeToolCall !== null;
+        this.lastStreamActivityAt = activityAt;
+        this.streamPhase = 'waiting_model';
+        this.activeToolCall = null;
+        if (phaseChanged) {
+            this.logStreamDebug('stream_phase_changed', {
+                phase: this.streamPhase,
+            });
+        }
+    }
+    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;
+        this.lastStreamActivityAt = activityAt;
+        this.streamPhase = 'waiting_tool';
+        this.activeToolCall = {
+            id: toolCall.id,
+            name: normalizedToolName,
+            startedAt: activityAt,
+        };
+        if (phaseChanged) {
+            this.logStreamDebug('stream_phase_changed', {
+                phase: this.streamPhase,
+                activeToolName: normalizedToolName,
+                activeToolCallId: toolCall.id,
+            });
+        }
+    }
+    resetStreamState() {
+        this.streamPhase = 'idle';
+        this.activeToolCall = null;
+        this.streamDeferredUntil = 0;
+        this.currentPartialContent = '';
+        this.currentLastContentKind = 'empty';
+        this.currentJournaledContentLength = 0;
+    }
+    createQuerySession(conversationId, turnId, attempt, source, latestUserMessage, stallRetryCount, completionRetryCount, priorSession) {
+        const timestamp = Date.now();
+        const instance = this.instanceStore?.get();
+        return {
+            id: turnId,
+            conversationId,
+            turnId,
+            attempt,
+            source,
+            state: 'ready',
+            startedAt: timestamp,
+            updatedAt: timestamp,
+            summary: `Turn attempt ${attempt} started.`,
+            latestUserMessage: this.truncateResumeText(latestUserMessage, 1200),
+            stallRetryCount,
+            completionRetryCount,
+            instanceId: instance?.id,
+            checkpointPath: instance?.activeCheckpoint ?? null,
+            // Carry forward recovery state from prior attempt for crash recovery
+            ...(priorSession?.latestBoundary ? { latestBoundary: priorSession.latestBoundary } : {}),
+            ...(priorSession?.lastOutcome ? { lastOutcome: priorSession.lastOutcome } : {}),
+            ...(priorSession?.lastError ? { lastError: priorSession.lastError } : {}),
+        };
+    }
+    saveCurrentQuerySession() {
+        if (!this.currentStreamTurn || !this.currentQuerySession)
+            return;
+        this.conversations.saveQuerySession(this.currentStreamTurn.conversationId, this.currentQuerySession);
+    }
+    updateCurrentQuerySession(type, summary, data) {
+        if (!this.currentStreamTurn || !this.currentQuerySession)
+            return;
+        const eventState = this.getQuerySessionState(type, data);
+        const updatedAt = Date.now();
+        const next = {
+            ...this.currentQuerySession,
+            attempt: this.currentStreamTurn.attempt,
+            updatedAt,
+            summary: this.truncateResumeText(summary, 500),
+            state: this.resolveQuerySessionState(type, eventState, data),
+            checkpointPath: this.instanceStore?.get()?.activeCheckpoint ?? this.currentQuerySession.checkpointPath ?? null,
+        };
+        if (type === 'partial_text') {
+            const excerpt = typeof data?.excerpt === 'string' ? data.excerpt : summary;
+            next.latestAssistantMessage = this.truncateResumeText(excerpt, 1200);
+        }
+        if (type === 'tool_start') {
+            next.activeToolName = typeof data?.toolName === 'string' ? data.toolName : undefined;
+            next.activeToolCallId = typeof data?.callId === 'string' ? data.callId : undefined;
+        }
+        else if (type !== 'tool_end') {
+            next.activeToolName = undefined;
+            next.activeToolCallId = undefined;
+        }
+        if (type === 'tool_end') {
+            next.activeToolName = undefined;
+            next.activeToolCallId = undefined;
+        }
+        if (type === 'turn_finished') {
+            const finalContent = typeof data?.finalContent === 'string' ? data.finalContent.trim() : '';
+            if (finalContent) {
+                next.latestAssistantMessage = this.truncateResumeText(finalContent, 1200);
+            }
+            if (typeof data?.turnOutcome === 'string') {
+                next.lastOutcome = data.turnOutcome;
+            }
+        }
+        if (type === 'turn_error') {
+            next.lastError = typeof data?.error === 'string' ? data.error : summary;
+            if (data?.aborted === true) {
+                next.lastOutcome = 'aborted';
+            }
+            else {
+                next.lastOutcome = 'protocol_error';
+            }
+        }
+        if (type === 'completion_signal' && typeof data?.signal === 'string') {
+            next.summary = this.truncateResumeText(summary, 500);
+        }
+        this.currentQuerySession = next;
+        this.saveCurrentQuerySession();
+    }
+    resolveQuerySessionState(type, defaultState, data) {
+        if (type === 'turn_finished') {
+            const turnOutcome = data?.turnOutcome;
+            if (turnOutcome === 'completed' || turnOutcome === 'completed_no_text')
+                return 'completed';
+            if (turnOutcome === 'stalled')
+                return 'stalled';
+            if (turnOutcome === 'aborted')
+                return 'aborted';
+            if (turnOutcome === 'ended_on_tool_calls' || turnOutcome === 'completion_signal_missing') {
+                return 'waiting_followup';
+            }
+            if (turnOutcome === 'protocol_error')
+                return 'failed';
+        }
+        return defaultState;
+    }
+    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);
+        this.appendSessionEvent(type, entry.summary, data);
+    }
+    appendSessionEvent(type, summary, data) {
+        if (!this.currentStreamTurn)
+            return;
+        const instance = this.instanceStore?.get();
+        const event = {
+            sessionId: this.currentStreamTurn.sessionId,
+            conversationId: this.currentStreamTurn.conversationId,
+            turnId: this.currentStreamTurn.turnId,
+            attempt: this.currentStreamTurn.attempt,
+            timestamp: Date.now(),
+            type: this.mapJournalEntryToSessionEvent(type),
+            state: this.getQuerySessionState(type, data),
+            summary: this.truncateResumeText(summary, 500),
+            instanceId: instance?.id,
+            checkpointPath: instance?.activeCheckpoint ?? null,
+            ...(data ? { data } : {}),
+        };
+        this.conversations.appendSessionEvent(this.currentStreamTurn.conversationId, this.currentStreamTurn.sessionId, event);
+        this.updateCurrentQuerySession(type, summary, data);
+    }
+    mapJournalEntryToSessionEvent(type) {
+        switch (type) {
+            case 'tool_start':
+                return 'tool_started';
+            case 'tool_end':
+                return 'tool_finished';
+            case 'checkpoint':
+                return 'checkpoint_recorded';
+            case 'boundary':
+                return 'boundary_committed';
+            case 'completion_signal':
+                return 'completion_signal_recorded';
+            case 'recovery':
+                return 'recovery_assessed';
+            case 'turn_error':
+                return 'turn_failed';
+            default:
+                return type;
+        }
+    }
+    getQuerySessionState(type, data) {
+        switch (type) {
+            case 'turn_started':
+                return 'ready';
+            case 'partial_text':
+                return 'sampling';
+            case 'tool_start':
+                return 'tool_execution';
+            case 'tool_end':
+            case 'checkpoint':
+            case 'boundary':
+            case 'completion_signal':
+                return 'waiting_followup';
+            case 'recovery':
+                return data?.cause === 'stall' ? 'stalled' : 'waiting_followup';
+            case 'turn_finished':
+                return 'completed';
+            case 'turn_error':
+                return data?.aborted ? 'aborted' : 'failed';
+            default:
+                return 'waiting_followup';
+        }
+    }
+    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,
+        });
+        if (this.currentQuerySession) {
+            this.currentQuerySession = {
+                ...this.currentQuerySession,
+                latestBoundary: summary,
+                updatedAt: Date.now(),
+            };
+            this.saveCurrentQuerySession();
+        }
+        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 {
+            elapsedSeconds,
+            phase: this.streamPhase,
+            activeToolName: this.activeToolCall?.name,
+            activeToolCallId: this.activeToolCall?.id,
+            activeToolStartedAt: this.activeToolCall?.startedAt,
+        };
+    }
+    describeStreamLocation(phase = this.streamPhase, activeToolName = this.activeToolCall?.name) {
+        if (phase === '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;
+    }
+    logStreamDebug(msg, data) {
+        if (!this.currentStreamTurn)
+            return;
+        log.debug(msg, {
+            turnId: this.currentStreamTurn.turnId,
+            attempt: this.currentStreamTurn.attempt,
+            conversationId: this.currentStreamTurn.conversationId,
+            ...data,
+        });
+    }
+    emitWatchdog(stage, message, options) {
+        if (!this.currentStreamTurn)
+            return;
+        const payload = {
+            stage,
+            turnId: this.currentStreamTurn.turnId,
+            attempt: this.currentStreamTurn.attempt,
+            conversationId: this.currentStreamTurn.conversationId,
+            message,
+            ...this.getStreamDiagnostics(options?.elapsedSeconds),
+        };
+        const level = options?.level ?? 'info';
+        switch (level) {
+            case 'debug':
+                log.debug(`watchdog_${stage}`, payload);
+                break;
+            case 'warn':
+                log.warn(`watchdog_${stage}`, payload);
+                break;
+            case 'error':
+                log.error(`watchdog_${stage}`, payload);
+                break;
+            default:
+                log.info(`watchdog_${stage}`, payload);
+                break;
+        }
+        this.emit({ type: 'cerebrum:watchdog', ...payload });
+    }
+    emitCompletionTrace(stage, message, signal, level = 'info') {
+        if (!this.currentStreamTurn)
+            return;
+        const payload = {
+            stage,
+            turnId: this.currentStreamTurn.turnId,
+            attempt: this.currentStreamTurn.attempt,
+            conversationId: this.currentStreamTurn.conversationId,
+            signal,
+            message,
+            ...this.getStreamDiagnostics(),
+        };
+        switch (level) {
+            case 'debug':
+                log.debug(`completion_${stage}`, payload);
+                break;
+            case 'warn':
+                log.warn(`completion_${stage}`, payload);
+                break;
+            case 'error':
+                log.error(`completion_${stage}`, payload);
+                break;
+            default:
+                log.info(`completion_${stage}`, payload);
+                break;
+        }
+        this.emit({ type: 'cerebrum:completion', ...payload });
+    }
+    createAttemptCompletionState(continuity) {
+        return {
+            signal: 'none',
+            evidence: '',
+            successfulExternalToolCount: 0,
+            externalToolCallCount: 0,
+            internalToolCallCount: 0,
+            continuity,
+        };
+    }
+    createTurnContinuityState() {
+        return {
+            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 ?? '',
+            attempt: params.attempt,
+            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,
+            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') {
+        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 {
+            source: 'fallback',
+            assessment: this.buildFallbackRecoveryAssessment(request),
+        };
+    }
+    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);
+            }
+        }
+        for (const entry of request.progressEntries) {
+            if (entry.source === 'tool' && entry.stateChanging && !entry.isError) {
+                completed.add(entry.summary);
+            }
+        }
+        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 (request.partialContent) {
+            lines.push('', 'Partial assistant text from the failed attempt:', request.partialContent);
+        }
+        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:${cause}-retry:${attempt}`,
+            role: 'system',
+            content: modelMessage,
+            timestamp: 0,
+            metadata: {
+                transient: true,
+                source: cause === 'stall' ? 'watchdog-resume' : 'completion-resume',
+                recoverySource: source,
+            },
+        };
+    }
+    formatToolOutputPreview(output) {
+        return this.truncateResumeText(output, 180).replace(/\s+/g, ' ').trim();
+    }
+    truncateResumeText(text, maxChars) {
+        const normalized = text.replace(/\r\n/g, '\n').trim();
+        if (normalized.length <= maxChars)
+            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,
+            status,
+            evidence,
+            summary: `${step} (${status}): ${this.truncateResumeText(evidence, 220)}`,
+        };
+        const existingIndex = continuity.taskCheckpoints.findIndex((entry) => entry.step === step);
+        if (existingIndex >= 0) {
+            continuity.taskCheckpoints[existingIndex] = checkpoint;
+        }
+        else {
+            continuity.taskCheckpoints.push(checkpoint);
+        }
+        this.recordProgressEntry(continuity, {
+            source: 'checkpoint',
+            action: 'task_checkpoint',
+            summary: checkpoint.summary,
+            stateChanging: status === 'done',
+            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) {
+        const continuity = completionState.continuity;
+        const entry = this.createProgressEntry(toolName, result);
+        if (!entry)
+            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);
+        if (resume?.summary) {
+            return {
+                source: 'tool',
+                toolName,
+                action: resume.action ?? toolName,
+                summary: this.truncateResumeText(resume.summary, 220),
+                url: resume.url,
+                tabId: resume.tabId ?? resume.activeTabId,
+                stateChanging: resume.stateChanging ?? this.isLikelyStateChangingTool(toolName),
+                isError: result.isError,
+            };
+        }
+        const outputPreview = this.formatToolOutputPreview(result.output);
+        if (!outputPreview)
+            return null;
+        return {
+            source: 'tool',
+            toolName,
+            action: toolName,
+            summary: `${toolName}: ${outputPreview}`,
+            stateChanging: this.isLikelyStateChangingTool(toolName),
+            isError: result.isError,
+        };
+    }
+    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) {
+            return;
+        }
+        continuity.progressLedger.push(entry);
+        while (continuity.progressLedger.length > 50) {
+            const removableIndex = continuity.progressLedger.findIndex((candidate) => candidate.source === 'tool' && !candidate.stateChanging);
+            continuity.progressLedger.splice(removableIndex >= 0 ? removableIndex : 0, 1);
+        }
+    }
+    getBrowserResumeMetadata(result) {
+        const metadata = result.metadata;
+        if (!metadata || typeof metadata !== 'object')
+            return null;
+        const resume = metadata.resume;
+        if (!resume || typeof resume !== 'object')
+            return null;
+        return resume;
+    }
+    updateBrowserState(browserState, result) {
+        const resume = this.getBrowserResumeMetadata(result);
+        if (!resume)
+            return;
+        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 ?? deltaActiveTabId) {
+            browserState.activeTabId = resume.activeTabId ?? deltaActiveTabId;
+        }
+        else if (resume.tabId && resume.stateChanging) {
+            browserState.activeTabId = resume.tabId;
+        }
+        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;
+            }
+        }
+    }
+    cloneBrowserState(browserState) {
+        return {
+            currentUrl: browserState.currentUrl,
+            activeTabId: browserState.activeTabId,
+            tabs: browserState.tabs?.map((tab) => ({ ...tab })),
+        };
+    }
+    isLikelyStateChangingTool(toolName) {
+        return !READ_ONLY_TOOL_NAMES.has(toolName);
+    }
+    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';
+        if (trimmedContent.length === 0 && hadExternalToolActivity) {
+            return {
+                message: 'Turn ended after tool activity without a final answer.',
+                signal: completionState.signal,
+            };
+        }
+        if (endedOnToolCalls) {
+            return {
+                message: 'Turn ended on tool-calls without a final answer.',
+                signal: completionState.signal,
+            };
+        }
+        if (hadExternalToolActivity && completionState.signal === 'none') {
+            return {
+                message: 'Tool-driven turn ended without task_complete or task_blocked.',
+                signal: completionState.signal,
+            };
+        }
+        return null;
+    }
+    async awaitStreamAttempt(streamPromise, abortController) {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            let abortTimer = null;
+            const cleanup = () => {
+                abortController.signal.removeEventListener('abort', onAbort);
+                if (abortTimer) {
+                    clearTimeout(abortTimer);
+                    abortTimer = null;
+                }
+            };
+            const settleResolve = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve();
+            };
+            const settleReject = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(error);
+            };
+            const onAbort = () => {
+                this.logStreamDebug('provider_abort_observed', {
+                    phase: this.streamPhase,
+                    activeToolName: this.activeToolCall?.name,
+                    activeToolCallId: this.activeToolCall?.id,
+                });
+                if (abortTimer)
+                    return;
+                abortTimer = setTimeout(() => {
+                    if (settled)
+                        return;
+                    const elapsedSeconds = Math.max(1, Math.round((Date.now() - this.lastStreamActivityAt) / 1000));
+                    this.emitWatchdog('teardown_timeout', `Provider did not settle within ${this.streamAbortGraceMs}ms after abort; continuing retry.`, { level: 'warn', elapsedSeconds });
+                    settleReject(createAbortError('Stream aborted'));
+                }, this.streamAbortGraceMs);
+            };
+            abortController.signal.addEventListener('abort', onAbort, { once: true });
+            if (abortController.signal.aborted) {
+                onAbort();
+            }
+            streamPromise.then(settleResolve, settleReject);
+        });
+    }
+    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)
+                return;
+            if (this.streamNudgeCount >= this.maxNudgeRetries)
+                return;
+            if (this._nudgeInFlight)
+                return;
+            const elapsedSeconds = Math.round(elapsed / 1000);
+            const diagnostics = this.getStreamDiagnostics(elapsedSeconds);
+            this.emitWatchdog('stalled', `Stalled after ${elapsedSeconds}s while ${this.describeStreamLocation()}.`, { level: 'warn', elapsedSeconds });
+            this.emit({ type: 'cerebrum:stall', ...diagnostics });
+            if (!this.cerebellum?.isConnected()) {
+                this.emitWatchdog('abort_issued', 'Cerebellum disconnected during an active stream; aborting the turn.', { level: 'warn', elapsedSeconds });
+                this.abortController?.abort();
+                return;
+            }
+            this._nudgeInFlight = true;
+            void (async () => {
+                try {
+                    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 {
+                    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;
+                }
+            })();
+        }, 15_000);
+    }
+    _nudgeInFlight = false;
+    stopStreamWatchdog() {
+        if (this.streamWatchdog) {
+            clearInterval(this.streamWatchdog);
+            this.streamWatchdog = null;
+        }
+        this.resetStreamState();
+    }
+    async sendMessage(content, conversationId, options) {
+        if (!this.cerebrum)
+            throw new Error('Cerebrum not connected');
+        if (this.cerebellum && !this.cerebellum.isConnected()) {
+            throw new Error('Cerebellum is offline. Fix the Cerebellum connection before continuing. Run: docker compose up -d cerebellum');
+        }
+        const convId = conversationId ?? this.activeConversationId;
+        if (!convId)
+            throw new Error('No active conversation');
+        if (content) {
+            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;
+        // Track message IDs from failed attempts so they can be excluded from retries and cleaned up.
+        const failedAttemptMessageIds = [];
+        const turnId = options?.turnId ?? nanoid(10);
+        const maxTotalAttempts = 1 + this.maxNudgeRetries + this.maxCompletionRetries;
+        let loopTerminated = false;
+        let nextRetryCause = null;
+        const turnContinuity = this.createTurnContinuityState();
+        try {
+            for (let attempt = 0; attempt < maxTotalAttempts; attempt++) {
+                const abortController = new AbortController();
+                const attemptNumber = attempt + 1;
+                const retryCause = nextRetryCause;
+                nextRetryCause = null;
+                const completionState = this.createAttemptCompletionState(turnContinuity);
+                let completionGuardFailure = null;
+                const stallRetryCountAtStart = this.streamNudgeCount;
+                const attemptMessageIds = [];
+                const isCurrentAttempt = () => this.abortController === abortController;
+                this.abortController = abortController;
+                this.currentAttemptCompletionState = completionState;
+                const sessionSource = options?.source ?? 'local';
+                this.currentStreamTurn = {
+                    turnId,
+                    attempt: attemptNumber,
+                    conversationId: convId,
+                    sessionId: turnId,
+                    source: sessionSource,
+                };
+                const priorSession = this.currentQuerySession;
+                this.currentQuerySession = this.createQuerySession(convId, turnId, attemptNumber, sessionSource, latestUserMessage, this.streamNudgeCount, completionRetryCount, priorSession);
+                this.saveCurrentQuerySession();
+                if (attemptNumber === 1 && sessionSource === 'channel' && options?.ingress) {
+                    this.recordSessionEvent(convId, turnId, 'channel_ingress', `Received channel message from ${options.ingress.senderName || options.ingress.senderId || 'unknown sender'}.`, {
+                        channelId: options.ingress.channelId,
+                        routeTo: options.ingress.routeTo,
+                        senderId: options.ingress.senderId,
+                        senderName: options.ingress.senderName,
+                        sessionId: options.ingress.sessionId,
+                        threadId: options.ingress.threadId,
+                        replyToId: options.ingress.replyToId,
+                        timestamp: options.ingress.timestamp,
+                    });
+                }
+                this.currentPartialContent = '';
+                this.currentLastContentKind = 'empty';
+                this.currentJournaledContentLength = 0;
+                this.pendingRecoveryDecision = null;
+                log.info('stream_started', {
+                    turnId,
+                    attempt: attemptNumber,
+                    conversationId: convId,
+                    stallRetryCount: this.streamNudgeCount,
+                    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,
+                    turnId,
+                    sessionId: turnId,
+                    source: sessionSource,
+                });
+                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
+                // causes the model to repeat the exact same steps instead of continuing.
+                if (failedAttemptMessageIds.length > 0) {
+                    const excludeSet = new Set(failedAttemptMessageIds);
+                    messages = messages.filter((m) => !excludeSet.has(m.id));
+                }
+                // Context window compaction
+                if (this.compactionConfig.enabled &&
+                    this.cerebrum?.summarize &&
+                    shouldCompact(messages, this.compactionConfig.contextWindow, this.compactionConfig.threshold)) {
+                    try {
+                        const keepRecent = this.compactionConfig.keepRecentMessages;
+                        const olderMessages = messages.slice(0, Math.max(0, messages.length - keepRecent));
+                        if (olderMessages.length > 0) {
+                            log.info('Compacting conversation', {
+                                totalMessages: messages.length,
+                                compactingMessages: olderMessages.length,
+                                estimatedTokens: estimateMessageTokens(messages),
+                            });
+                            const summary = await this.cerebrum.summarize(olderMessages);
+                            messages = buildCompactionMessages(messages, summary, keepRecent);
+                        }
+                    }
+                    catch (error) {
+                        log.warn('Compaction failed, continuing with full context', {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
+                // Build system prompt with runtime state + skills context
+                const instance = this.instanceStore?.get();
+                const allTools = this.getAllTools();
+                const basePrompt = buildSystemPrompt({
+                    cerebellumConnected: this.cerebellum?.isConnected() ?? false,
+                    tools: allTools,
+                    autoMode: this.autoMode,
+                    gatewayMode: this.gatewayMode,
+                    connectedNodes: this.connectedNodes,
+                    gatewayUrl: this.gatewayUrl,
+                    profile: this.profile,
+                    finetuneStatus: {
+                        enabled: !!this.fineTuneDataProvider,
+                        status: this.fineTuneStatus.status,
+                        progress: this.fineTuneStatus.progress,
+                        lastJobId: this.fineTuneStatus.jobId || undefined,
+                    },
+                    recurringTasks: this.recurringTasks,
+                    instanceId: instance?.id,
+                    instanceCreatedAt: instance?.createdAt,
+                    finetuneCount: instance?.finetuneLineage.length,
+                    proactiveEnabled: this.proactiveEnabled,
+                    discoveryMode: this.discoveryMode,
+                });
+                const systemParts = [basePrompt];
+                if (this.systemContext)
+                    systemParts.push(this.systemContext);
+                const fullSystemPrompt = systemParts.join('\n\n---\n\n');
+                const transientRetryMessages = nextRetryContext ? [nextRetryContext] : [];
+                nextRetryContext = null;
+                const allMessages = [
+                    { id: 'system', role: 'system', content: fullSystemPrompt, timestamp: 0 },
+                    ...transientRetryMessages,
+                    ...messages,
+                ];
+                const toolDefs = Object.fromEntries(allTools);
+                let fullContent = '';
+                let finalDisplayContent = '';
+                let attemptFinishMeta;
+                const throwIfToolAttemptAborted = () => {
+                    if (!isCurrentAttempt()) {
+                        throw createAbortError('Tool execution aborted');
+                    }
+                    throwIfAborted(abortController.signal, 'Tool execution aborted');
+                };
+                try {
+                    const streamPromise = this.cerebrum.stream(allMessages, toolDefs, {
+                        onChunk: (chunk) => {
+                            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', 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);
+                            const toolIngress = isInternalTaskSignal ? options?.ingress : undefined;
+                            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,
+                                    requestedName: requestedToolName !== normalizedToolName ? requestedToolName : undefined,
+                                    args: toolCall.args,
+                                });
+                            }
+                            const { toolName, result } = await this.toolRuntime.execute({
+                                toolCall,
+                                tools: allTools,
+                                conversationId: convId,
+                                sessionKey: turnId,
+                                scopeKey: convId,
+                                turnId,
+                                attempt: attemptNumber,
+                                ingress: toolIngress,
+                                abortSignal: abortController.signal,
+                            });
+                            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',
+                                    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) {
+                                try {
+                                    throwIfAborted(abortController.signal, 'Tool execution aborted');
+                                    this.emit({ type: 'verification:start', callId: toolCall.id, toolName });
+                                    const toolArgs = {};
+                                    for (const [k, v] of Object.entries(toolCall.args)) {
+                                        toolArgs[k] = String(v);
+                                    }
+                                    const verifyPromise = this.cerebellum.verifyToolResult(toolName, toolArgs, result.output, !result.isError);
+                                    const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(null), this.verificationTimeoutMs));
+                                    const verification = await Promise.race([verifyPromise, timeoutPromise]);
+                                    throwIfAborted(abortController.signal, 'Tool execution aborted');
+                                    if (verification && !verification.passed) {
+                                        const failedChecks = verification.checks
+                                            .filter((c) => !c.passed)
+                                            .map((c) => c.description)
+                                            .join(', ');
+                                        result.output += `\n[Cerebellum warning: ${failedChecks}]`;
+                                    }
+                                    if (verification) {
+                                        result.metadata = {
+                                            ...(result.metadata ?? {}),
+                                            verification: {
+                                                passed: verification.passed,
+                                                modelVerdict: verification.modelVerdict,
+                                                failedChecks: verification.checks
+                                                    .filter((check) => !check.passed)
+                                                    .map((check) => check.description),
+                                            },
+                                        };
+                                        const vResult = {
+                                            passed: verification.passed,
+                                            checks: verification.checks,
+                                            modelVerdict: verification.modelVerdict,
+                                            toolCallId: toolCall.id,
+                                            toolName,
+                                        };
+                                        this.emit({
+                                            type: 'verification:end',
+                                            result: vResult,
+                                            conversationId: convId,
+                                            sessionId: turnId,
+                                        });
+                                    }
+                                }
+                                catch {
+                                    // Verification failure should never block tool execution
+                                }
+                            }
+                            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, {
+                                    toolResult: result,
+                                    metadata: {
+                                        toolName,
+                                        ...(requestedToolName !== toolName ? { requestedToolName } : {}),
+                                    },
+                                });
+                                attemptMessageIds.push(toolMsg.id);
+                            }
+                            return result;
+                        },
+                        onFinish: (content, toolCalls, finishMeta) => {
+                            if (!isCurrentAttempt() || abortController.signal.aborted)
+                                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>')) {
+                                const parsed = this.parseDiscoveryCompletion(content);
+                                // Strip the tag block from the displayed/stored content
+                                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;
+                                finalDisplayContent = displayContent;
+                                this.emitCompletionTrace('guard_triggered', guardFailure.message, guardFailure.signal, 'warn');
+                                log.warn('completion_guard_triggered', {
+                                    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 ?? displayContent.length,
+                                    completionSignal: completionState.signal,
+                                    turnOutcome,
+                                });
+                                return;
+                            }
+                            // Clean up failed attempt messages from conversation store
+                            // so they don't leak into future turns (preserves successful attempt's tool results)
+                            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,
+                                    });
+                                }
+                            }
+                            const cerebrumMessage = this.conversations.appendMessage(convId, 'cerebrum', displayContent, visibleToolCalls?.length ? { toolCalls: visibleToolCalls } : undefined);
+                            this.emit({
+                                type: 'message:cerebrum:end',
+                                conversationId: convId,
+                                turnId,
+                                sessionId: turnId,
+                                source: sessionSource,
+                                message: cerebrumMessage,
+                            });
+                            log.info('stream_finished', {
+                                turnId,
+                                attempt: attemptNumber,
+                                conversationId: convId,
+                                stallRetryCount: this.streamNudgeCount,
+                                completionRetryCount,
+                                retryCause,
+                            });
+                            if (retryCause === 'completion') {
+                                this.emitCompletionTrace('retry_recovered', `Completion retry ${completionRetryCount}/${this.maxCompletionRetries} recovered on attempt ${attemptNumber}.`, completionState.signal, 'info');
+                            }
+                            else if (retryCause === 'stall') {
+                                this.emitWatchdog('retry_recovered', `Stall retry ${this.streamNudgeCount}/${this.maxNudgeRetries} recovered on attempt ${attemptNumber}.`, { level: 'info' });
+                            }
+                        },
+                        onError: (error) => {
+                            if (!isCurrentAttempt())
+                                return;
+                            this.stopStreamWatchdog();
+                            // Don't log/emit if the abort was intentional (nudge or Cerebellum disconnect) — catch block handles it
+                            if (abortController.signal.aborted)
+                                return;
+                            log.error('Cerebrum stream error', { error: error.message });
+                            this.emit({ type: 'error', error });
+                        },
+                    }, { abortSignal: abortController.signal });
+                    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.appendTurnJournalEntry('turn_error', assessment.diagnosis || 'Recovery returned stop.', {
+                                retryCause: 'completion',
+                                completionRetryCount,
+                                stallRetryCount: this.streamNudgeCount,
+                                error: assessment.diagnosis || 'Recovery returned stop.',
+                            });
+                            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', assessment.operatorMessage);
+                            attemptMessageIds.push(systemMessage.id);
+                            failedAttemptMessageIds.push(...attemptMessageIds);
+                            this.emit({ type: 'message:system', message: systemMessage });
+                            this.emitCompletionTrace('retry_started', `Retrying attempt ${attemptNumber + 1} after incomplete completion (${completionRetryCount}/${this.maxCompletionRetries}).`, completionSignal, 'info');
+                            nextRetryCause = 'completion';
+                            continue;
+                        }
+                        failedAttemptMessageIds.push(...attemptMessageIds);
+                        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}: ${assessment.diagnosis || completionFailure.message}`, completionSignal, 'error');
+                        this.appendTurnJournalEntry('turn_error', `Completion retries exhausted (${completionRetryCount}/${this.maxCompletionRetries}).`, {
+                            retryCause: 'completion',
+                            completionRetryCount,
+                            stallRetryCount: this.streamNudgeCount,
+                            error: assessment.diagnosis || 'Completion retries exhausted.',
+                        });
+                        this.emit({
+                            type: 'error',
+                            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) {
+                            this.conversations.deleteMessages(convId, failedAttemptMessageIds);
+                        }
+                        loopTerminated = true;
+                        break;
+                    }
+                    loopTerminated = true;
+                    break; // success — exit retry loop
+                }
+                catch (error) {
+                    const failureState = this.getStreamState();
+                    this.stopStreamWatchdog();
+                    failedAttemptMessageIds.push(...attemptMessageIds);
+                    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 });
+                        this.emitWatchdog('retry_started', `Retrying stalled turn with attempt ${attemptNumber + 1} (stall retry ${this.streamNudgeCount}/${this.maxNudgeRetries}).`, { level: 'info' });
+                        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.appendTurnJournalEntry('turn_error', stallRecovery.assessment.diagnosis || 'Stall recovery returned stop.', {
+                            retryCause: 'stall',
+                            stallRetryCount: this.streamNudgeCount,
+                            completionRetryCount,
+                            error: stallRecovery.assessment.diagnosis || 'Stall recovery returned stop.',
+                        });
+                        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');
+                        log.error('Cerebellum disconnected mid-stream', { error: err.message });
+                        this.appendTurnJournalEntry('turn_error', err.message, {
+                            retryCause,
+                            stallRetryCount: this.streamNudgeCount,
+                            completionRetryCount,
+                            error: err.message,
+                            aborted: true,
+                        });
+                        this.emit({ type: 'error', error: err });
+                        if (failedAttemptMessageIds.length > 0) {
+                            this.conversations.deleteMessages(convId, failedAttemptMessageIds);
+                        }
+                        loopTerminated = true;
+                        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');
+                    }
+                    else if (retryCause === 'stall') {
+                        this.emitWatchdog('retry_failed', `Stall retry attempt ${attemptNumber} failed: ${err.message}`, { level: 'error' });
+                    }
+                    log.error('Send message failed', {
+                        error: err.message,
+                        turnId,
+                        attempt: attemptNumber,
+                        conversationId: convId,
+                        phase: failureState.phase,
+                        activeToolName: failureState.activeToolName,
+                        activeToolCallId: failureState.activeToolCallId,
+                        activeToolStartedAt: failureState.activeToolStartedAt,
+                        stallRetryCount: this.streamNudgeCount,
+                        completionRetryCount,
+                        retryCause,
+                    });
+                    this.emit({ type: 'error', error: err });
+                    // Clean up all failed attempt messages on error
+                    if (failedAttemptMessageIds.length > 0) {
+                        this.conversations.deleteMessages(convId, failedAttemptMessageIds);
+                    }
+                    loopTerminated = true;
+                    break;
+                }
+                finally {
+                    this.currentAttemptCompletionState = null;
+                }
+            }
+            if (!loopTerminated) {
+                const err = new Error(`Retry safety limit reached after ${maxTotalAttempts} attempts.`);
+                log.error('Send message failed', {
+                    error: err.message,
+                    turnId,
+                    conversationId: convId,
+                    stallRetryCount: this.streamNudgeCount,
+                    completionRetryCount,
+                });
+                this.emit({ type: 'error', error: err });
+            }
+        }
+        finally {
+            this.currentQuerySession = null;
+            this.currentStreamTurn = null;
+        }
+    }
+    async start() {
+        if (!this.activeConversationId) {
+            // Resume the most recent conversation, or create a new one
+            const convs = this.conversations.list();
+            if (convs.length > 0) {
+                this.resumeConversation(convs[0].id);
+                log.info('Auto-resumed last conversation', { id: convs[0].id });
+            }
+            else {
+                this.startConversation();
+            }
+        }
+        // Start sub-agent monitoring loop if cerebellum + sub-agents are enabled
+        if (this.subAgentManager && this.cerebellum?.reportAgentStates) {
+            this.startMonitorLoop();
+        }
+        // Recover interrupted sub-agents from disk
+        if (this.subAgentManager) {
+            const recovered = await this.subAgentManager.recoverFromDisk();
+            for (const agentId of recovered) {
+                const agent = this.subAgentManager.getAgent(agentId);
+                if (agent) {
+                    this.emit({ type: 'agent:recovered', agentId, task: agent.task });
+                }
+            }
+            if (recovered.length > 0) {
+                log.info(`Recovered ${recovered.length} interrupted sub-agent(s)`);
+            }
+        }
+    }
+    async stop() {
+        if (this.monitorTimer) {
+            clearInterval(this.monitorTimer);
+            this.monitorTimer = null;
+        }
+        this.stopFineTunePoller();
+        this.removeAllListeners();
+        log.info('Orchestrator stopped');
+    }
+    startMonitorLoop() {
+        if (this.monitorTimer)
+            return;
+        this.monitorTimer = setInterval(async () => {
+            if (!this.subAgentManager || !this.cerebellum?.reportAgentStates)
+                return;
+            const agents = this.subAgentManager.listAgents();
+            const activeAgents = agents.filter((a) => a.status === 'running' || a.status === 'pending');
+            if (activeAgents.length === 0)
+                return;
+            try {
+                const actions = await this.cerebellum.reportAgentStates(activeAgents.map((a) => ({
+                    id: a.id,
+                    task: a.task,
+                    status: a.status,
+                    spawnedAt: a.spawnedAt,
+                    lastActivityAt: a.lastActivityAt,
+                    timeoutMs: a.timeoutMs,
+                    messagesCount: a.messagesCount,
+                    toolCallsCount: a.toolCallsCount,
+                    retryCount: a.retryCount,
+                    progressNote: a.progressNote ?? '',
+                    progressPercent: a.progressPercent ?? -1,
+                    lastProgressAt: a.lastProgressAt ?? 0,
+                    deadlineAt: a.deadlineAt,
+                })));
+                const actionable = actions.filter((a) => a.action !== 'ok');
+                if (actionable.length > 0) {
+                    this.emit({ type: 'agent:health', actions: actionable });
+                }
+                for (const action of actions) {
+                    switch (action.action) {
+                        case 'ping':
+                            this.subAgentManager.ping(action.agentId);
+                            break;
+                        case 'retry':
+                            await this.subAgentManager.retry(action.agentId);
+                            break;
+                        case 'cancel':
+                            this.subAgentManager.cancel(action.agentId);
+                            break;
+                        case 'timeout':
+                            this.subAgentManager.timeout(action.agentId);
+                            break;
+                    }
+                }
+            }
+            catch {
+                // Monitor failure is non-blocking
+            }
+            // Prune old completed agents
+            this.subAgentManager.prune();
+        }, this.monitorIntervalMs);
+    }
+}
+//# sourceMappingURL=orchestrator.js.map