@vellumai/assistant 0.3.5 → 0.3.6

package/src/daemon/session-agent-loop.ts

@@ -8,17 +8,19 @@
  */
 
 import { v4 as uuid } from 'uuid';
-import type { Message, ContentBlock, ImageContent } from '../providers/types.js';
+import type { Message, ContentBlock } from '../providers/types.js';
+import type { ChannelId, TurnChannelContext } from '../channels/types.js';
 import type { ServerMessage, UsageStats, SurfaceType, SurfaceData, DynamicPageSurfaceData } from './ipc-protocol.js';
 import type { AgentLoop, CheckpointDecision, AgentEvent } from '../agent/loop.js';
 import type { Provider } from '../providers/types.js';
 import { createAssistantMessage } from '../agent/message-types.js';
 import * as conversationStore from '../memory/conversation-store.js';
+import { getConversationOriginChannel } from '../memory/conversation-store.js';
 import type { PermissionPrompter } from '../permissions/prompter.js';
 import { getConfig } from '../config/loader.js';
 import { getLogger } from '../util/logger.js';
 import type { TraceEmitter } from './trace-emitter.js';
-import { classifySessionError, isUserCancellation, isContextTooLarge, buildSessionErrorMessage } from './session-error.js';
+import { classifySessionError, isUserCancellation, buildSessionErrorMessage } from './session-error.js';
 import type { ToolProfiler } from '../events/tool-profiling-listener.js';
 import type { ContextWindowManager } from '../context/window-manager.js';
 import { getHookManager } from '../hooks/manager.js';
@@ -34,11 +36,9 @@ import {
   stripInjectedContext,
 } from './session-runtime-assembly.js';
 import { buildTemporalContext } from './date-context.js';
-import type { ActiveSurfaceContext, ChannelCapabilities, GuardianRuntimeContext } from './session-runtime-assembly.js';
+import type { ActiveSurfaceContext, ChannelCapabilities, ChannelTurnContextParams, GuardianRuntimeContext } from './session-runtime-assembly.js';
 import {
   cleanAssistantContent,
-  drainDirectiveDisplayBuffer,
-  type DirectiveRequest,
   type AssistantAttachmentDraft,
 } from './assistant-attachments.js';
 import { prepareMemoryContext } from './session-memory.js';
@@ -49,8 +49,6 @@ import {
 } from './session-attachments.js';
 import { consolidateAssistantMessages } from './session-history.js';
 import { recordUsage } from './session-usage.js';
-import { recordRequestLog } from '../memory/llm-request-log-store.js';
-import { isProviderOrderingError } from './session-slash.js';
 import { repairHistory, deepRepairHistory } from './history-repair.js';
 import { stripMediaPayloadsForRetry, raceWithTimeout } from './session-media-retry.js';
 import { commitTurnChanges } from '../workspace/turn-commit.js';
@@ -58,6 +56,11 @@ import { getWorkspaceGitService } from '../workspace/git-service.js';
 import { commitAppTurnChanges } from '../memory/app-git-service.js';
 import type { UsageActor } from '../usage/actors.js';
 import type { SkillProjectionCache } from './session-skill-tools.js';
+import {
+  createEventHandlerState,
+  dispatchAgentEvent,
+  type EventHandlerDeps,
+} from './session-agent-loop-handlers.js';
 
 const log = getLogger('session-agent-loop');
 
@@ -95,6 +98,7 @@ export interface AgentLoopSessionContext {
   workspaceTopLevelContext: string | null;
   workspaceTopLevelDirty: boolean;
   channelCapabilities?: ChannelCapabilities;
+  commandIntent?: { type: string; payload?: string; languageCode?: string };
   guardianContext?: GuardianRuntimeContext;
 
   readonly coreToolNames: Set<string>;
@@ -112,6 +116,7 @@ export interface AgentLoopSessionContext {
   lastAttachmentWarnings: string[];
 
   hasNoClient: boolean;
+  readonly streamThinking: boolean;
   readonly prompter: PermissionPrompter;
   readonly queue: MessageQueue;
 
@@ -124,6 +129,7 @@ export interface AgentLoopSessionContext {
   hasQueuedMessages(): boolean;
   canHandoffAtCheckpoint(): boolean;
   drainQueue(reason: QueueDrainReason): void;
+  getTurnChannelContext(): TurnChannelContext | null;
 }
 
 // ── runAgentLoop ─────────────────────────────────────────────────────
@@ -143,6 +149,18 @@ export async function runAgentLoopImpl(
   const rlog = log.child({ conversationId: ctx.conversationId, requestId: reqId });
   let yieldedForHandoff = false;
 
+  // Capture the turn channel context *before* any awaits so a second
+  // message from a different channel can't overwrite it mid-flight.
+  // When context is unavailable (e.g. regenerate after daemon restart),
+  // fall back to the conversation's persisted origin channel.
+  const capturedTurnChannelContext: TurnChannelContext = (() => {
+    const live = ctx.getTurnChannelContext();
+    if (live) return live;
+    const origin = getConversationOriginChannel(ctx.conversationId);
+    if (origin) return { userMessageChannel: origin, assistantMessageChannel: origin };
+    return { userMessageChannel: 'macos' as ChannelId, assistantMessageChannel: 'macos' as ChannelId };
+  })();
+
   ctx.lastAssistantAttachments = [];
   ctx.lastAttachmentWarnings = [];
 
@@ -204,19 +222,8 @@ export async function runAgentLoopImpl(
       emitUsage(ctx, compacted.summaryInputTokens, compacted.summaryOutputTokens, compacted.summaryModel, onEvent, 'context_compactor', reqId);
     }
 
-    let firstAssistantText = '';
-    let exchangeInputTokens = 0;
-    let exchangeOutputTokens = 0;
-    let model = '';
+    const state = createEventHandlerState();
     let runMessages = ctx.messages;
-    const pendingToolResults = new Map<string, { content: string; isError: boolean; contentBlocks?: ContentBlock[] }>();
-    const persistedToolUseIds = new Set<string>();
-    const accumulatedDirectives: DirectiveRequest[] = [];
-    const accumulatedToolContentBlocks: ContentBlock[] = [];
-    const directiveWarnings: string[] = [];
-    let pendingDirectiveDisplayBuffer = '';
-    let lastAssistantMessageId: string | undefined;
-    let providerErrorUserMessage: string | null = null;
 
     const memoryResult = await prepareMemoryContext(
       {
@@ -235,11 +242,16 @@ export async function runAgentLoopImpl(
     );
 
     if (memoryResult.conflictClarification) {
+      const loopChannelMeta = {
+        userMessageChannel: capturedTurnChannelContext.userMessageChannel,
+        assistantMessageChannel: capturedTurnChannelContext.assistantMessageChannel,
+      };
       const assistantMessage = createAssistantMessage(memoryResult.conflictClarification);
       conversationStore.addMessage(
         ctx.conversationId,
         'assistant',
         JSON.stringify(assistantMessage.content),
+        loopChannelMeta,
       );
       ctx.messages.push(assistantMessage);
       onEvent({
@@ -292,11 +304,21 @@ export async function runAgentLoopImpl(
       timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
     });
 
+    // Use the channel context captured at the top of this function so it
+    // reflects the channel that originally sent *this* turn's message,
+    // even if a newer message from a different channel arrived since.
+    const channelTurnContext: ChannelTurnContextParams = {
+      turnContext: capturedTurnChannelContext,
+      conversationOriginChannel: getConversationOriginChannel(ctx.conversationId),
+    };
+
     runMessages = applyRuntimeInjections(runMessages, {
       softConflictInstruction,
       activeSurface,
       workspaceTopLevelContext: ctx.workspaceTopLevelContext,
       channelCapabilities: ctx.channelCapabilities ?? null,
+      channelCommandContext: ctx.commandIntent ?? null,
+      channelTurnContext,
       guardianContext: ctx.guardianContext ?? null,
       temporalContext,
     });
@@ -309,235 +331,21 @@ export async function runAgentLoopImpl(
       runMessages = preRunRepair.messages;
     }
 
-    let orderingErrorDetected = false;
-    let deferredOrderingError: string | null = null;
-    let contextTooLargeDetected = false;
     let preRunHistoryLength = runMessages.length;
 
-    let llmCallStartedEmitted = false;
-    const toolUseIdToName = new Map<string, string>();
-    let currentTurnToolNames: string[] = [];
-
-    const buildEventHandler = () => (event: AgentEvent) => {
-      const emitLlmCallStartedIfNeeded = () => {
-        if (llmCallStartedEmitted) return;
-        llmCallStartedEmitted = true;
-        ctx.traceEmitter.emit('llm_call_started', `LLM call to ${ctx.provider.name}`, {
-          requestId: reqId,
-          status: 'info',
-          attributes: { provider: ctx.provider.name, model: model || 'unknown' },
-        });
-      };
-
-      switch (event.type) {
-        case 'text_delta': {
-          emitLlmCallStartedIfNeeded();
-          pendingDirectiveDisplayBuffer += event.text;
-          const drained = drainDirectiveDisplayBuffer(pendingDirectiveDisplayBuffer);
-          pendingDirectiveDisplayBuffer = drained.bufferedRemainder;
-          if (drained.emitText.length > 0) {
-            onEvent({ type: 'assistant_text_delta', text: drained.emitText, sessionId: ctx.conversationId });
-            if (isFirstMessage) firstAssistantText += drained.emitText;
-          }
-          break;
-        }
-        case 'thinking_delta':
-          emitLlmCallStartedIfNeeded();
-          onEvent({ type: 'assistant_thinking_delta', thinking: event.thinking });
-          break;
-        case 'tool_use':
-          toolUseIdToName.set(event.id, event.name);
-          currentTurnToolNames.push(event.name);
-          onEvent({ type: 'tool_use_start', toolName: event.name, input: event.input, sessionId: ctx.conversationId });
-          break;
-        case 'tool_output_chunk': {
-          // Try to parse structured progress fields from the chunk.
-          // Cheap pre-check: only attempt JSON.parse when the chunk looks like an object.
-          let structured: { subType?: 'tool_start' | 'tool_complete' | 'status'; subToolName?: string; subToolInput?: string; subToolIsError?: boolean; subToolId?: string } | undefined;
-          const trimmed = event.chunk.trimStart();
-          if (trimmed.length > 0 && trimmed.length < 4096 && trimmed[0] === '{') {
-            try {
-              const parsed = JSON.parse(event.chunk);
-              const VALID_SUB_TYPES = new Set(['tool_start', 'tool_complete', 'status']);
-              if (parsed && typeof parsed === 'object' && typeof parsed.subType === 'string' && VALID_SUB_TYPES.has(parsed.subType)) {
-                structured = {
-                  subType: parsed.subType as 'tool_start' | 'tool_complete' | 'status',
-                  subToolName: typeof parsed.subToolName === 'string' ? parsed.subToolName : undefined,
-                  subToolInput: typeof parsed.subToolInput === 'string' ? parsed.subToolInput : undefined,
-                  subToolIsError: typeof parsed.subToolIsError === 'boolean' ? parsed.subToolIsError : undefined,
-                  subToolId: typeof parsed.subToolId === 'string' ? parsed.subToolId : undefined,
-                };
-              }
-            } catch {
-              // Not valid JSON — pass through as plain chunk
-            }
-          }
-          if (structured) {
-            onEvent({
-              type: 'tool_output_chunk',
-              chunk: event.chunk,
-              sessionId: ctx.conversationId,
-              subType: structured.subType,
-              subToolName: structured.subToolName,
-              subToolInput: structured.subToolInput,
-              subToolIsError: structured.subToolIsError,
-              subToolId: structured.subToolId,
-            });
-          } else {
-            onEvent({ type: 'tool_output_chunk', chunk: event.chunk, sessionId: ctx.conversationId });
-          }
-          break;
-        }
-        case 'input_json_delta':
-          onEvent({ type: 'tool_input_delta', toolName: event.toolName, content: event.accumulatedJson, sessionId: ctx.conversationId });
-          break;
-        case 'tool_result': {
-          const imageBlock = event.contentBlocks?.find((b): b is ImageContent => b.type === 'image');
-          onEvent({ type: 'tool_result', toolName: '', result: event.content, isError: event.isError, diff: event.diff, status: event.status, sessionId: ctx.conversationId, imageData: imageBlock?.source.data });
-          pendingToolResults.set(event.toolUseId, { content: event.content, isError: event.isError, contentBlocks: event.contentBlocks });
-          {
-            const toolName = toolUseIdToName.get(event.toolUseId);
-            if (toolName === 'file_write' || toolName === 'bash') {
-              ctx.markWorkspaceTopLevelDirty();
-            } else if (toolName === 'file_edit' && !event.isError) {
-              ctx.markWorkspaceTopLevelDirty();
-            }
-          }
-          if (event.contentBlocks) {
-            for (const cb of event.contentBlocks) {
-              if (cb.type === 'image' || cb.type === 'file') {
-                accumulatedToolContentBlocks.push(cb);
-              }
-            }
-          }
-          break;
-        }
-        case 'error':
-          if (isProviderOrderingError(event.error.message)) {
-            orderingErrorDetected = true;
-            deferredOrderingError = event.error.message;
-          } else if (isContextTooLarge(event.error.message)) {
-            contextTooLargeDetected = true;
-          } else {
-            const classified = classifySessionError(event.error, { phase: 'agent_loop' });
-            onEvent(buildSessionErrorMessage(ctx.conversationId, classified));
-            providerErrorUserMessage = classified.userMessage;
-          }
-          break;
-        case 'message_complete': {
-          if (pendingDirectiveDisplayBuffer.length > 0) {
-            onEvent({
-              type: 'assistant_text_delta',
-              text: pendingDirectiveDisplayBuffer,
-              sessionId: ctx.conversationId,
-            });
-            if (isFirstMessage) firstAssistantText += pendingDirectiveDisplayBuffer;
-            pendingDirectiveDisplayBuffer = '';
-          }
-          if (pendingToolResults.size > 0) {
-            const toolResultBlocks = Array.from(pendingToolResults.entries()).map(
-              ([toolUseId, result]) => ({
-                type: 'tool_result',
-                tool_use_id: toolUseId,
-                content: result.content,
-                is_error: result.isError,
-                ...(result.contentBlocks ? { contentBlocks: result.contentBlocks } : {}),
-              }),
-            );
-            conversationStore.addMessage(
-              ctx.conversationId,
-              'user',
-              JSON.stringify(toolResultBlocks),
-            );
-            for (const id of pendingToolResults.keys()) {
-              persistedToolUseIds.add(id);
-            }
-            pendingToolResults.clear();
-          }
-          const { cleanedContent, directives: msgDirectives, warnings: msgWarnings } =
-            cleanAssistantContent(event.message.content);
-          accumulatedDirectives.push(...msgDirectives);
-          directiveWarnings.push(...msgWarnings);
-          if (msgDirectives.length > 0) {
-            rlog.info(
-              { parsedDirectives: msgDirectives.map(d => ({ source: d.source, path: d.path, mimeType: d.mimeType })), totalAccumulated: accumulatedDirectives.length },
-              'Parsed attachment directives from assistant message',
-            );
-          }
-
-          const contentWithSurfaces: ContentBlock[] = [...cleanedContent as ContentBlock[]];
-          for (const surface of ctx.currentTurnSurfaces) {
-            contentWithSurfaces.push({
-              type: 'ui_surface',
-              surfaceId: surface.surfaceId,
-              surfaceType: surface.surfaceType,
-              title: surface.title,
-              data: surface.data,
-              actions: surface.actions,
-              display: surface.display,
-            } as unknown as ContentBlock);
-          }
-
-          const assistantMsg = conversationStore.addMessage(
-            ctx.conversationId,
-            'assistant',
-            JSON.stringify(contentWithSurfaces),
-          );
-          lastAssistantMessageId = assistantMsg.id;
-
-          ctx.currentTurnSurfaces = [];
-
-          const charCount = cleanedContent
-            .filter((b) => (b as Record<string, unknown>).type === 'text')
-            .reduce((sum: number, b) => sum + ((b as { text?: string }).text?.length ?? 0), 0);
-          const toolUseCount = event.message.content
-            .filter((b) => b.type === 'tool_use')
-            .length;
-          ctx.traceEmitter.emit('assistant_message', 'Assistant message complete', {
-            requestId: reqId,
-            status: 'success',
-            attributes: { charCount, toolUseCount },
-          });
-          break;
-        }
-        case 'usage':
-          exchangeInputTokens += event.inputTokens;
-          exchangeOutputTokens += event.outputTokens;
-          model = event.model;
-
-          if (event.rawRequest && event.rawResponse) {
-            try {
-              recordRequestLog(
-                ctx.conversationId,
-                JSON.stringify(event.rawRequest),
-                JSON.stringify(event.rawResponse),
-              );
-            } catch (err) {
-              rlog.warn({ err }, 'Failed to persist LLM request log (non-fatal)');
-            }
-          }
-
-          emitLlmCallStartedIfNeeded();
-
-          ctx.traceEmitter.emit('llm_call_finished', `LLM call to ${ctx.provider.name} finished`, {
-            requestId: reqId,
-            status: 'success',
-            attributes: {
-              provider: ctx.provider.name,
-              model: event.model,
-              inputTokens: event.inputTokens,
-              outputTokens: event.outputTokens,
-              latencyMs: event.providerDurationMs,
-            },
-          });
-          llmCallStartedEmitted = false;
-          break;
-      }
+    const deps: EventHandlerDeps = {
+      ctx,
+      onEvent,
+      reqId,
+      isFirstMessage,
+      rlog,
+      turnChannelContext: capturedTurnChannelContext,
     };
+    const eventHandler = (event: AgentEvent) => dispatchAgentEvent(state, deps, event);
 
     const onCheckpoint = (): CheckpointDecision => {
-      const turnTools = currentTurnToolNames;
-      currentTurnToolNames = [];
+      const turnTools = state.currentTurnToolNames;
+      state.currentTurnToolNames = [];
 
       if (ctx.canHandoffAtCheckpoint()) {
         const inBrowserFlow = turnTools.length > 0
@@ -554,37 +362,37 @@ export async function runAgentLoopImpl(
 
     let updatedHistory = await ctx.agentLoop.run(
       runMessages,
-      buildEventHandler(),
+      eventHandler,
       abortController.signal,
       reqId,
       onCheckpoint,
     );
 
     // One-shot ordering error retry
-    if (orderingErrorDetected && updatedHistory.length === preRunHistoryLength) {
+    if (state.orderingErrorDetected && updatedHistory.length === preRunHistoryLength) {
       rlog.warn({ phase: 'retry' }, 'Provider ordering error detected, attempting one-shot deep-repair retry');
       const retryRepair = deepRepairHistory(runMessages);
       runMessages = retryRepair.messages;
       preRepairMessages = retryRepair.messages;
       preRunHistoryLength = runMessages.length;
-      orderingErrorDetected = false;
-      deferredOrderingError = null;
+      state.orderingErrorDetected = false;
+      state.deferredOrderingError = null;
 
       updatedHistory = await ctx.agentLoop.run(
         runMessages,
-        buildEventHandler(),
+        eventHandler,
         abortController.signal,
         reqId,
         onCheckpoint,
       );
 
-      if (orderingErrorDetected) {
+      if (state.orderingErrorDetected) {
         rlog.error({ phase: 'retry' }, 'Deep-repair retry also failed with ordering error. Consider starting a new conversation if this persists.');
       }
     }
 
     // One-shot context-too-large recovery
-    if (contextTooLargeDetected && updatedHistory.length === preRunHistoryLength) {
+    if (state.contextTooLargeDetected && updatedHistory.length === preRunHistoryLength) {
       rlog.warn({ phase: 'retry' }, 'Context too large — attempting forced compaction and retry');
       const emergencyCompact = await ctx.contextWindowManager.maybeCompact(
         ctx.messages,
@@ -619,23 +427,25 @@ export async function runAgentLoopImpl(
           activeSurface,
           workspaceTopLevelContext: ctx.workspaceTopLevelContext,
           channelCapabilities: ctx.channelCapabilities ?? null,
+          channelCommandContext: ctx.commandIntent ?? null,
+          channelTurnContext,
           guardianContext: ctx.guardianContext ?? null,
           temporalContext,
         });
         preRepairMessages = runMessages;
         preRunHistoryLength = runMessages.length;
-        contextTooLargeDetected = false;
+        state.contextTooLargeDetected = false;
 
         updatedHistory = await ctx.agentLoop.run(
           runMessages,
-          buildEventHandler(),
+          eventHandler,
           abortController.signal,
           reqId,
           onCheckpoint,
         );
       }
 
-      if (contextTooLargeDetected) {
+      if (state.contextTooLargeDetected) {
         const mediaTrimmed = stripMediaPayloadsForRetry(ctx.messages);
         if (mediaTrimmed.modified) {
           rlog.warn(
@@ -652,16 +462,18 @@ export async function runAgentLoopImpl(
             activeSurface,
             workspaceTopLevelContext: ctx.workspaceTopLevelContext,
             channelCapabilities: ctx.channelCapabilities ?? null,
+            channelCommandContext: ctx.commandIntent ?? null,
+            channelTurnContext,
             guardianContext: ctx.guardianContext ?? null,
             temporalContext,
           });
           preRepairMessages = runMessages;
           preRunHistoryLength = runMessages.length;
-          contextTooLargeDetected = false;
+          state.contextTooLargeDetected = false;
 
           updatedHistory = await ctx.agentLoop.run(
             runMessages,
-            buildEventHandler(),
+            eventHandler,
             abortController.signal,
             reqId,
             onCheckpoint,
@@ -669,7 +481,7 @@ export async function runAgentLoopImpl(
         }
       }
 
-      if (contextTooLargeDetected) {
+      if (state.contextTooLargeDetected) {
         const classified = classifySessionError(
           new Error('context_length_exceeded'),
           { phase: 'agent_loop' },
@@ -678,8 +490,8 @@ export async function runAgentLoopImpl(
       }
     }
 
-    if (deferredOrderingError) {
-      const classified = classifySessionError(new Error(deferredOrderingError), { phase: 'agent_loop' });
+    if (state.deferredOrderingError) {
+      const classified = classifySessionError(new Error(state.deferredOrderingError), { phase: 'agent_loop' });
       onEvent(buildSessionErrorMessage(ctx.conversationId, classified));
     }
 
@@ -688,8 +500,8 @@ export async function runAgentLoopImpl(
       const msg = updatedHistory[i];
       if (msg.role === 'user') {
         for (const block of msg.content) {
-          if (block.type === 'tool_result' && !pendingToolResults.has(block.tool_use_id) && !persistedToolUseIds.has(block.tool_use_id)) {
-            pendingToolResults.set(block.tool_use_id, {
+          if (block.type === 'tool_result' && !state.pendingToolResults.has(block.tool_use_id) && !state.persistedToolUseIds.has(block.tool_use_id)) {
+            state.pendingToolResults.set(block.tool_use_id, {
               content: block.content,
               isError: block.is_error ?? false,
             });
@@ -699,8 +511,8 @@ export async function runAgentLoopImpl(
     }
 
     // Flush remaining tool results
-    if (pendingToolResults.size > 0) {
-      const toolResultBlocks = Array.from(pendingToolResults.entries()).map(
+    if (state.pendingToolResults.size > 0) {
+      const toolResultBlocks = Array.from(state.pendingToolResults.entries()).map(
         ([toolUseId, result]) => ({
           type: 'tool_result',
           tool_use_id: toolUseId,
@@ -709,12 +521,17 @@ export async function runAgentLoopImpl(
           ...(result.contentBlocks ? { contentBlocks: result.contentBlocks } : {}),
         }),
       );
+      const toolResultMetadata = {
+        userMessageChannel: capturedTurnChannelContext.userMessageChannel,
+        assistantMessageChannel: capturedTurnChannelContext.assistantMessageChannel,
+      };
       conversationStore.addMessage(
         ctx.conversationId,
         'user',
         JSON.stringify(toolResultBlocks),
+        toolResultMetadata,
       );
-      pendingToolResults.clear();
+      state.pendingToolResults.clear();
     }
 
     // Reconstruct history
@@ -725,17 +542,22 @@ export async function runAgentLoopImpl(
     });
 
     const hasAssistantResponse = newMessages.some((msg) => msg.role === 'assistant');
-    if (!hasAssistantResponse && providerErrorUserMessage && !abortController.signal.aborted && !yieldedForHandoff) {
-      const errorAssistantMessage = createAssistantMessage(providerErrorUserMessage);
+    if (!hasAssistantResponse && state.providerErrorUserMessage && !abortController.signal.aborted && !yieldedForHandoff) {
+      const errChannelMeta = {
+        userMessageChannel: capturedTurnChannelContext.userMessageChannel,
+        assistantMessageChannel: capturedTurnChannelContext.assistantMessageChannel,
+      };
+      const errorAssistantMessage = createAssistantMessage(state.providerErrorUserMessage);
       conversationStore.addMessage(
         ctx.conversationId,
         'assistant',
         JSON.stringify(errorAssistantMessage.content),
+        errChannelMeta,
       );
       newMessages.push(errorAssistantMessage);
       onEvent({
         type: 'assistant_text_delta',
-        text: providerErrorUserMessage,
+        text: state.providerErrorUserMessage,
         sessionId: ctx.conversationId,
       });
     }
@@ -746,7 +568,7 @@ export async function runAgentLoopImpl(
       stripDynamicProfile: (msgs) => stripDynamicProfileMessages(msgs, dynamicProfile.text),
     });
 
-    emitUsage(ctx, exchangeInputTokens, exchangeOutputTokens, model, onEvent, 'main_agent', reqId);
+    emitUsage(ctx, state.exchangeInputTokens, state.exchangeOutputTokens, state.model, onEvent, 'main_agent', reqId);
 
     void getHookManager().trigger('post-message', {
       sessionId: ctx.conversationId,
@@ -754,12 +576,12 @@ export async function runAgentLoopImpl(
 
     // Resolve attachments
     const attachmentResult = await resolveAssistantAttachments(
-      accumulatedDirectives,
-      accumulatedToolContentBlocks,
-      directiveWarnings,
+      state.accumulatedDirectives,
+      state.accumulatedToolContentBlocks,
+      state.directiveWarnings,
       ctx.workingDir,
       async (filePath) => approveHostAttachmentRead(filePath, ctx.workingDir, ctx.prompter, ctx.conversationId, ctx.hasNoClient),
-      lastAssistantMessageId,
+      state.lastAssistantMessageId,
     );
     const { assistantAttachments, emittedAttachments } = attachmentResult;
 
@@ -804,9 +626,10 @@ export async function runAgentLoopImpl(
     }
 
     if (isFirstMessage) {
-      generateTitle(ctx, content, firstAssistantText).catch((err) => {
-        log.warn({ err, conversationId: ctx.conversationId }, 'Failed to generate conversation title (non-fatal, using default title)');
-      });
+      generateTitle(ctx, content, state.firstAssistantText, onEvent, abortController.signal)
+        .catch((err) => {
+          log.warn({ err, conversationId: ctx.conversationId }, 'Failed to generate conversation title (non-fatal, using default title)');
+        });
     }
   } catch (err) {
     const errorCtx = { phase: 'agent_loop' as const, aborted: abortController.signal.aborted };
@@ -868,6 +691,9 @@ export async function runAgentLoopImpl(
     ctx.currentActiveSurfaceId = undefined;
     ctx.allowedToolNames = undefined;
     ctx.preactivatedSkillIds = undefined;
+    // Channel command intents (e.g. Telegram /start) are single-turn metadata.
+    // Clear at turn end so they never leak into subsequent unrelated messages.
+    ctx.commandIntent = undefined;
 
     if (userMessageId) {
       consolidateAssistantMessages(ctx.conversationId, userMessageId);
@@ -883,13 +709,19 @@ async function generateTitle(
   ctx: Pick<AgentLoopSessionContext, 'conversationId' | 'provider'>,
   userMessage: string,
   assistantResponse: string,
+  onEvent: (msg: ServerMessage) => void,
+  sessionSignal?: AbortSignal,
 ): Promise<void> {
+  const config = getConfig();
   const prompt = `Generate a very short title for this conversation. Rules: at most 5 words, at most 40 characters, no quotes.\n\nUser: ${truncate(userMessage, 200, '')}\nAssistant: ${truncate(assistantResponse, 200, '')}`;
+  const signal = sessionSignal
+    ? AbortSignal.any([sessionSignal, AbortSignal.timeout(10_000)])
+    : AbortSignal.timeout(10_000);
   const response = await ctx.provider.sendMessage(
     [{ role: 'user', content: [{ type: 'text', text: prompt }] }],
     [],
     undefined,
-    { config: { max_tokens: 30 } },
+    { config: { max_tokens: config.daemon.titleGenerationMaxTokens }, signal },
   );
 
   const textBlock = response.content.find((b) => b.type === 'text');
@@ -898,7 +730,13 @@ async function generateTitle(
     const words = title.split(/\s+/);
     if (words.length > 5) title = words.slice(0, 5).join(' ');
     if (title.length > 40) title = title.slice(0, 40).trimEnd();
+    if (!title) return;
     conversationStore.updateConversationTitle(ctx.conversationId, title);
+    onEvent({
+      type: 'session_title_updated',
+      sessionId: ctx.conversationId,
+      title,
+    });
     log.info({ conversationId: ctx.conversationId, title }, 'Auto-generated conversation title');
   }
 }

package/src/daemon/session-dynamic-profile.ts

@@ -48,7 +48,7 @@ export function stripDynamicProfileMessages(messages: Message[], profileText: st
     changed = true;
     const stripped = nextText.replace(/\n{3,}/g, '\n\n').trimEnd();
     return stripped.length > 0 ? { ...block, text: stripped } : null;
-  }).filter((block): block is NonNullable<typeof block> => block !== null);
+  }).filter((block): block is NonNullable<typeof block> => block != null);
   if (!changed) return messages;
   // If stripping removed all content blocks, drop the message entirely
   // to avoid sending an empty content array to the provider.

package/src/daemon/session-history.ts

@@ -14,7 +14,7 @@ const log = getLogger('session-history');
 
 function isUndoableUserMessage(message: Message): boolean {
   if (message.role !== 'user') return false;
-  if (getSummaryFromContextMessage(message) !== null) return false;
+  if (getSummaryFromContextMessage(message) != null) return false;
   // A user message is undoable if it contains user-authored content (non-tool_result
   // blocks). Messages that contain ONLY tool_result blocks (e.g. automated tool
   // responses) are not undoable. Messages that have both tool_result and text blocks