@cereworker/core 26.403.2 → 26.404.2

package/dist/orchestrator.js

@@ -12,10 +12,18 @@ 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.';
@@ -89,6 +97,7 @@ export class Orchestrator extends TypedEventEmitter {
     streamPhase = 'idle';
     activeToolCall = null;
     currentStreamTurn = null;
+    currentQuerySession = null;
     currentAttemptCompletionState = null;
     currentPartialContent = '';
     currentLastContentKind = 'empty';
@@ -377,6 +386,8 @@ export class Orchestrator extends TypedEventEmitter {
             conversationId: options?.conversationId,
             sessionKey: options?.sessionKey,
             scopeKey: options?.scopeKey,
+            turnId: options?.turnId,
+            attempt: options?.attempt,
         });
     }
     unregisterTool(name) {
@@ -613,6 +624,67 @@ export class Orchestrator extends TypedEventEmitter {
             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;
@@ -749,6 +821,105 @@ export class Orchestrator extends TypedEventEmitter {
         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;
@@ -761,6 +932,70 @@ export class Orchestrator extends TypedEventEmitter {
             ...(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 {
@@ -817,6 +1052,14 @@ export class Orchestrator extends TypedEventEmitter {
             evidence: summary.evidence,
             browserState: summary.browserState,
         });
+        if (this.currentQuerySession) {
+            this.currentQuerySession = {
+                ...this.currentQuerySession,
+                latestBoundary: summary,
+                updatedAt: Date.now(),
+            };
+            this.saveCurrentQuerySession();
+        }
         return summary;
     }
     deriveRepetitionSignals(continuity) {
@@ -1606,7 +1849,7 @@ export class Orchestrator extends TypedEventEmitter {
         }
         this.resetStreamState();
     }
-    async sendMessage(content, conversationId) {
+    async sendMessage(content, conversationId, options) {
         if (!this.cerebrum)
             throw new Error('Cerebrum not connected');
         if (this.cerebellum && !this.cerebellum.isConnected()) {
@@ -1629,7 +1872,7 @@ export class Orchestrator extends TypedEventEmitter {
         let nextRetryContext = null;
         // Track message IDs from failed attempts so they can be excluded from retries and cleaned up.
         const failedAttemptMessageIds = [];
-        const turnId = nanoid(10);
+        const turnId = options?.turnId ?? nanoid(10);
         const maxTotalAttempts = 1 + this.maxNudgeRetries + this.maxCompletionRetries;
         let loopTerminated = false;
         let nextRetryCause = null;
@@ -1647,11 +1890,29 @@ export class Orchestrator extends TypedEventEmitter {
                 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;
@@ -1670,7 +1931,13 @@ export class Orchestrator extends TypedEventEmitter {
                     stallRetryCount: this.streamNudgeCount,
                     completionRetryCount,
                 });
-                this.emit({ type: 'message:cerebrum:start', conversationId: convId });
+                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.
@@ -1774,6 +2041,7 @@ export class Orchestrator extends TypedEventEmitter {
                                 args: toolCall.args,
                             });
                             const isInternalTaskSignal = this.isInternalTaskSignalTool(normalizedToolName);
+                            const toolIngress = isInternalTaskSignal ? options?.ingress : undefined;
                             if (isInternalTaskSignal) {
                                 completionState.internalToolCallCount++;
                             }
@@ -1795,8 +2063,11 @@ export class Orchestrator extends TypedEventEmitter {
                                 toolCall,
                                 tools: allTools,
                                 conversationId: convId,
-                                sessionKey: 'agent:main',
+                                sessionKey: turnId,
                                 scopeKey: convId,
+                                turnId,
+                                attempt: attemptNumber,
+                                ingress: toolIngress,
                                 abortSignal: abortController.signal,
                             });
                             this.logStreamDebug('tool_callback_finished', this.buildToolDebugPayload(toolCall, result, toolName));
@@ -1839,6 +2110,16 @@ export class Orchestrator extends TypedEventEmitter {
                                         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,
@@ -1846,7 +2127,12 @@ export class Orchestrator extends TypedEventEmitter {
                                             toolCallId: toolCall.id,
                                             toolName,
                                         };
-                                        this.emit({ type: 'verification:end', result: vResult });
+                                        this.emit({
+                                            type: 'verification:end',
+                                            result: vResult,
+                                            conversationId: convId,
+                                            sessionId: turnId,
+                                        });
                                     }
                                 }
                                 catch {
@@ -1965,7 +2251,14 @@ export class Orchestrator extends TypedEventEmitter {
                                 }
                             }
                             const cerebrumMessage = this.conversations.appendMessage(convId, 'cerebrum', displayContent, visibleToolCalls?.length ? { toolCalls: visibleToolCalls } : undefined);
-                            this.emit({ type: 'message:cerebrum:end', message: cerebrumMessage });
+                            this.emit({
+                                type: 'message:cerebrum:end',
+                                conversationId: convId,
+                                turnId,
+                                sessionId: turnId,
+                                source: sessionSource,
+                                message: cerebrumMessage,
+                            });
                             log.info('stream_finished', {
                                 turnId,
                                 attempt: attemptNumber,
@@ -2049,6 +2342,12 @@ export class Orchestrator extends TypedEventEmitter {
                             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 ||
@@ -2076,6 +2375,12 @@ export class Orchestrator extends TypedEventEmitter {
                             : '[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 ||
@@ -2118,6 +2423,12 @@ export class Orchestrator extends TypedEventEmitter {
                         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);
@@ -2129,6 +2440,13 @@ export class Orchestrator extends TypedEventEmitter {
                     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);
@@ -2191,6 +2509,7 @@ export class Orchestrator extends TypedEventEmitter {
             }
         }
         finally {
+            this.currentQuerySession = null;
             this.currentStreamTurn = null;
         }
     }