@vellumai/assistant 0.3.4 → 0.3.6

package/src/daemon/session-runtime-assembly.ts

@@ -5,6 +5,7 @@
  * before it is sent to the provider.  They are pure (no side effects).
  */
 
+import type { ChannelId, TurnChannelContext } from '../channels/types.js';
 import type { Message } from '../providers/types.js';
 import { listAppFiles, getAppsDir } from '../memory/app-store.js';
 import { statSync } from 'node:fs';
@@ -15,7 +16,7 @@ import { join } from 'node:path';
  * interacting.  Used to gate UI-specific references and permission asks.
  */
 export interface ChannelCapabilities {
-  /** The raw channel identifier (e.g. "dashboard", "telegram", "http-api"). */
+  /** The raw channel identifier (e.g. "macos", "telegram", "sms"). */
   channel: string;
   /** Whether this channel can render the dashboard UI (apps, dynamic pages). */
   dashboardCapable: boolean;
@@ -25,16 +26,49 @@ export interface ChannelCapabilities {
   supportsVoiceInput: boolean;
 }
 
+/** Guardian identity/trust context for external chat channels. */
+export interface GuardianRuntimeContext {
+  sourceChannel: ChannelId;
+  actorRole: 'guardian' | 'non-guardian' | 'unverified_channel';
+  guardianChatId?: string;
+  guardianExternalUserId?: string;
+  requesterIdentifier?: string;
+  requesterExternalUserId?: string;
+  requesterChatId?: string;
+  denialReason?: 'no_binding' | 'no_identity';
+}
+
 /** Derive channel capabilities from a raw source channel identifier. */
 export function resolveChannelCapabilities(sourceChannel?: string | null): ChannelCapabilities {
-  const channel = sourceChannel ?? 'dashboard';
-  const isDashboard = channel === 'dashboard';
-  return {
-    channel,
-    dashboardCapable: isDashboard,
-    supportsDynamicUi: isDashboard,
-    supportsVoiceInput: isDashboard,
-  };
+  // Normalise legacy pseudo-channel IDs to canonical ChannelId values.
+  let channel: string;
+  switch (sourceChannel) {
+    case null:
+    case undefined:
+    case 'dashboard':
+    case 'http-api':
+    case 'mac':
+      channel = 'macos';
+      break;
+    default:
+      channel = sourceChannel;
+  }
+
+  switch (channel) {
+    case 'macos':
+      return { channel, dashboardCapable: true, supportsDynamicUi: true, supportsVoiceInput: true };
+    case 'ios':
+      return { channel, dashboardCapable: false, supportsDynamicUi: false, supportsVoiceInput: true };
+    case 'telegram':
+    case 'sms':
+    case 'voice':
+    case 'whatsapp':
+    case 'slack':
+    case 'email':
+      return { channel, dashboardCapable: false, supportsDynamicUi: false, supportsVoiceInput: false };
+    default:
+      return { channel, dashboardCapable: false, supportsDynamicUi: false, supportsVoiceInput: false };
+  }
 }
 
 /** Context about the active workspace surface, passed to applyRuntimeInjections. */
@@ -264,6 +298,110 @@ export function injectChannelCapabilityContext(message: Message, caps: ChannelCa
   };
 }
 
+/** Channel command intent metadata (e.g. Telegram /start). */
+export interface ChannelCommandContext {
+  type: string;
+  payload?: string;
+  languageCode?: string;
+}
+
+/**
+ * Prepend channel command context to the last user message so the
+ * model knows this turn was triggered by a channel command (e.g. /start).
+ */
+export function injectChannelCommandContext(message: Message, ctx: ChannelCommandContext): Message {
+  const lines: string[] = ['<channel_command_context>'];
+  lines.push(`command_type: ${ctx.type}`);
+  if (ctx.payload) {
+    lines.push(`payload: ${ctx.payload}`);
+  }
+  if (ctx.languageCode) {
+    lines.push(`language_code: ${ctx.languageCode}`);
+  }
+  lines.push('</channel_command_context>');
+
+  const block = lines.join('\n');
+  return {
+    ...message,
+    content: [
+      { type: 'text', text: block },
+      ...message.content,
+    ],
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Channel turn context injection
+// ---------------------------------------------------------------------------
+
+/** Parameters for building the channel turn context block. */
+export interface ChannelTurnContextParams {
+  turnContext: TurnChannelContext;
+  conversationOriginChannel: ChannelId | null;
+}
+
+/**
+ * Build the `<channel_turn_context>` text block that informs the model
+ * which channels are active for the current turn and the conversation's
+ * origin channel.
+ */
+export function buildChannelTurnContextBlock(params: ChannelTurnContextParams): string {
+  const { turnContext, conversationOriginChannel } = params;
+  const lines: string[] = ['<channel_turn_context>'];
+  lines.push(`user_message_channel: ${turnContext.userMessageChannel}`);
+  lines.push(`assistant_message_channel: ${turnContext.assistantMessageChannel}`);
+  lines.push(`conversation_origin_channel: ${conversationOriginChannel ?? 'unknown'}`);
+  lines.push('</channel_turn_context>');
+  return lines.join('\n');
+}
+
+/**
+ * Prepend channel turn context to the last user message so the model
+ * knows which channels are involved in this turn.
+ */
+export function injectChannelTurnContext(message: Message, params: ChannelTurnContextParams): Message {
+  const block = buildChannelTurnContextBlock(params);
+  return {
+    ...message,
+    content: [
+      { type: 'text', text: block },
+      ...message.content,
+    ],
+  };
+}
+
+/**
+ * Build the `<guardian_context>` text block used for model grounding.
+ */
+export function buildGuardianContextBlock(ctx: GuardianRuntimeContext): string {
+  const lines: string[] = ['<guardian_context>'];
+  lines.push(`source_channel: ${ctx.sourceChannel}`);
+  lines.push(`actor_role: ${ctx.actorRole}`);
+  lines.push(`guardian_external_user_id: ${ctx.guardianExternalUserId ?? 'unknown'}`);
+  lines.push(`guardian_chat_id: ${ctx.guardianChatId ?? 'unknown'}`);
+  lines.push(`requester_identifier: ${ctx.requesterIdentifier ?? 'unknown'}`);
+  lines.push(`requester_external_user_id: ${ctx.requesterExternalUserId ?? 'unknown'}`);
+  lines.push(`requester_chat_id: ${ctx.requesterChatId ?? 'unknown'}`);
+  lines.push(`denial_reason: ${ctx.denialReason ?? 'none'}`);
+  lines.push('</guardian_context>');
+  return lines.join('\n');
+}
+
+/**
+ * Prepend guardian trust/identity facts to the last user message so the
+ * model can reason about guardian status from deterministic runtime facts.
+ */
+export function injectGuardianContext(message: Message, ctx: GuardianRuntimeContext): Message {
+  const block = buildGuardianContextBlock(ctx);
+  return {
+    ...message,
+    content: [
+      { type: 'text', text: block },
+      ...message.content,
+    ],
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Prefix-based stripping primitive
 // ---------------------------------------------------------------------------
@@ -286,7 +424,7 @@ export function stripUserTextBlocksByPrefix(messages: Message[], prefixes: strin
     if (nextContent.length === message.content.length) return message;
     if (nextContent.length === 0) return null;
     return { ...message, content: nextContent };
-  }).filter((message): message is NonNullable<typeof message> => message !== null);
+  }).filter((message): message is NonNullable<typeof message> => message != null);
 }
 
 // ---------------------------------------------------------------------------
@@ -298,6 +436,11 @@ export function stripChannelCapabilityContext(messages: Message[]): Message[] {
   return stripUserTextBlocksByPrefix(messages, ['<channel_capabilities>']);
 }
 
+/** Strip `<guardian_context>` blocks injected by `injectGuardianContext`. */
+export function stripGuardianContext(messages: Message[]): Message[] {
+  return stripUserTextBlocksByPrefix(messages, ['<guardian_context>']);
+}
+
 /**
  * Prepend workspace top-level directory context to a user message.
  */
@@ -355,9 +498,22 @@ export function stripActiveSurfaceContext(messages: Message[]): Message[] {
 // Declarative strip pipeline
 // ---------------------------------------------------------------------------
 
+/** Strip `<channel_command_context>` blocks injected by `injectChannelCommandContext`. */
+export function stripChannelCommandContext(messages: Message[]): Message[] {
+  return stripUserTextBlocksByPrefix(messages, ['<channel_command_context>']);
+}
+
+/** Strip `<channel_turn_context>` blocks injected by `injectChannelTurnContext`. */
+export function stripChannelTurnContext(messages: Message[]): Message[] {
+  return stripUserTextBlocksByPrefix(messages, ['<channel_turn_context>']);
+}
+
 /** Prefixes stripped by the pipeline (order doesn't matter — single pass). */
 const RUNTIME_INJECTION_PREFIXES = [
   '<channel_capabilities>',
+  '<channel_command_context>',
+  '<channel_turn_context>',
+  '<guardian_context>',
   '<workspace_top_level>',
   TEMPORAL_INJECTED_PREFIX,
   '<active_workspace>',
@@ -398,6 +554,9 @@ export function applyRuntimeInjections(
     activeSurface?: ActiveSurfaceContext | null;
     workspaceTopLevelContext?: string | null;
     channelCapabilities?: ChannelCapabilities | null;
+    channelCommandContext?: ChannelCommandContext | null;
+    channelTurnContext?: ChannelTurnContextParams | null;
+    guardianContext?: GuardianRuntimeContext | null;
     temporalContext?: string | null;
   },
 ): Message[] {
@@ -433,6 +592,36 @@ export function applyRuntimeInjections(
     }
   }
 
+  if (options.channelCommandContext) {
+    const userTail = result[result.length - 1];
+    if (userTail && userTail.role === 'user') {
+      result = [
+        ...result.slice(0, -1),
+        injectChannelCommandContext(userTail, options.channelCommandContext),
+      ];
+    }
+  }
+
+  if (options.channelTurnContext) {
+    const userTail = result[result.length - 1];
+    if (userTail && userTail.role === 'user') {
+      result = [
+        ...result.slice(0, -1),
+        injectChannelTurnContext(userTail, options.channelTurnContext),
+      ];
+    }
+  }
+
+  if (options.guardianContext) {
+    const userTail = result[result.length - 1];
+    if (userTail && userTail.role === 'user') {
+      result = [
+        ...result.slice(0, -1),
+        injectGuardianContext(userTail, options.guardianContext),
+      ];
+    }
+  }
+
   // Temporal context is injected before workspace top-level so it
   // appears after workspace context in the final message content
   // (both are prepended, so later injections appear first).

package/src/daemon/session-surfaces.ts

@@ -17,16 +17,13 @@ import {
   getPrebuiltHomeBasePreview,
   findSeededHomeBaseApp,
 } from '../home-base/prebuilt/seed.js';
+import { isPlainObject } from '../util/object.js';
 
 const log = getLogger('session-surfaces');
 
 const MAX_UNDO_DEPTH = 10;
 const TASK_PROGRESS_TEMPLATE_FIELDS = ['title', 'status', 'steps'] as const;
 
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
 function normalizeCardShowData(input: Record<string, unknown>, rawData: Record<string, unknown>): CardSurfaceData {
   const normalized: Record<string, unknown> = { ...rawData };
 
@@ -128,6 +125,24 @@ export interface SurfaceSessionContext {
     onEvent: (msg: ServerMessage) => void,
     requestId?: string,
   ): Promise<string>;
+  /** Serialize operations on a given surface to prevent read-modify-write races. */
+  withSurface<T>(surfaceId: string, fn: () => T | Promise<T>): Promise<T>;
+}
+
+/**
+ * Per-surface async mutex using Promise chaining.
+ * Operations on the same surfaceId are serialized; different surfaces run concurrently.
+ */
+export function createSurfaceMutex(): <T>(surfaceId: string, fn: () => T | Promise<T>) => Promise<T> {
+  const chains = new Map<string, Promise<void>>();
+
+  return <T>(surfaceId: string, fn: () => T | Promise<T>): Promise<T> => {
+    const prev = chains.get(surfaceId) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    // Keep the chain alive but swallow errors so one failure doesn't block subsequent ops
+    chains.set(surfaceId, next.then(() => {}, () => {}));
+    return next;
+  };
 }
 
 /**

package/src/daemon/session-tool-setup.ts

@@ -15,6 +15,7 @@ import type { SecretPrompter } from '../permissions/secret-prompter.js';
 import { addRule, findHighestPriorityRule } from '../permissions/trust-store.js';
 import { generateAllowlistOptions, generateScopeOptions, normalizeWebFetchUrl } from '../permissions/checker.js';
 import { getLogger } from '../util/logger.js';
+import { isPlainObject } from '../util/object.js';
 
 const log = getLogger('session-tool-setup');
 import { getAllToolDefinitions } from '../tools/registry.js';
@@ -41,6 +42,7 @@ import { projectSkillTools, type SkillProjectionCache } from './session-skill-to
  */
 export interface ToolSetupContext extends SurfaceSessionContext {
   readonly conversationId: string;
+  assistantId?: string;
   currentRequestId?: string;
   workingDir: string;
   sandboxOverride?: boolean;
@@ -76,22 +78,21 @@ export function buildToolDefinitions(): ToolDefinition[] {
 
 // ── DoorDash task_progress auto-update ────────────────────────────────
 
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
 interface DoordashStep { label: string; status: string; detail?: string }
 
 /**
- * Map a `vellum doordash <subcommand>` to the step label it corresponds to.
+ * Map a `doordash <subcommand>` (or `vellum doordash <subcommand>`) to the
+ * step label it corresponds to.
  */
 function doordashCommandToStep(cmd: string): string | null {
-  if (/vellum doordash status\b/.test(cmd) || /vellum doordash refresh\b/.test(cmd) || /vellum doordash login\b/.test(cmd)) return 'Check session';
-  if (/vellum doordash search\b/.test(cmd) || /vellum doordash search-items\b/.test(cmd)) return 'Search restaurants';
-  if (/vellum doordash menu\b/.test(cmd) || /vellum doordash item\b/.test(cmd) || /vellum doordash store-search\b/.test(cmd)) return 'Browse menu';
-  if (/vellum doordash cart\b/.test(cmd)) return 'Add to cart';
-  if (/vellum doordash checkout\b/.test(cmd) || /vellum doordash payment-methods\b/.test(cmd)) return 'Add to cart';
-  if (/vellum doordash order\b/.test(cmd)) return 'Place order';
+  // Match both standalone `doordash` and legacy `vellum doordash` prefixes
+  const dd = /(?:vellum )?doordash /;
+  if (new RegExp(dd.source + 'status\\b').test(cmd) || new RegExp(dd.source + 'refresh\\b').test(cmd) || new RegExp(dd.source + 'login\\b').test(cmd)) return 'Check session';
+  if (new RegExp(dd.source + 'search\\b').test(cmd) || new RegExp(dd.source + 'search-items\\b').test(cmd)) return 'Search restaurants';
+  if (new RegExp(dd.source + 'menu\\b').test(cmd) || new RegExp(dd.source + 'item\\b').test(cmd) || new RegExp(dd.source + 'store-search\\b').test(cmd)) return 'Browse menu';
+  if (new RegExp(dd.source + 'cart\\b').test(cmd)) return 'Add to cart';
+  if (new RegExp(dd.source + 'checkout\\b').test(cmd) || new RegExp(dd.source + 'payment-methods\\b').test(cmd)) return 'Add to cart';
+  if (new RegExp(dd.source + 'order\\b').test(cmd)) return 'Place order';
   return null;
 }
 
@@ -150,7 +151,8 @@ export function createToolExecutor(
     // Pre-execution: mark the current DoorDash step as in_progress when command starts
     if (name === 'bash' || name === 'host_bash') {
       const preCmd = input.command as string | undefined;
-      if (preCmd?.includes('vellum doordash')) {
+      const preStepLabel = preCmd ? doordashCommandToStep(preCmd) : null;
+      if (preStepLabel) {
         const surfaceId = 'doordash-progress';
         const stored = ctx.surfaceState.get(surfaceId);
         if (stored && stored.surfaceType === 'card') {
@@ -158,23 +160,20 @@ export function createToolExecutor(
           if (card.template === 'task_progress' && isPlainObject(card.templateData)) {
             const steps = (card.templateData as Record<string, unknown>).steps;
             if (Array.isArray(steps)) {
-              const stepLabel = doordashCommandToStep(preCmd);
-              if (stepLabel) {
-                const stepIndex = (steps as DoordashStep[]).findIndex(s => s.label === stepLabel);
-                if (stepIndex >= 0 && (steps as DoordashStep[])[stepIndex].status !== 'in_progress') {
-                  const updatedSteps = (steps as DoordashStep[]).map((s, i) =>
-                    i === stepIndex ? { ...s, status: 'in_progress' } : s
-                  );
-                  const updatedTemplateData = { ...card.templateData as Record<string, unknown>, steps: updatedSteps };
-                  const updatedData = { ...card, templateData: updatedTemplateData };
-                  stored.data = updatedData as import('./ipc-contract.js').CardSurfaceData;
-                  ctx.sendToClient({
-                    type: 'ui_surface_update',
-                    sessionId: ctx.conversationId,
-                    surfaceId,
-                    data: updatedData,
-                  });
-                }
+              const stepIndex = (steps as DoordashStep[]).findIndex(s => s.label === preStepLabel);
+              if (stepIndex >= 0 && (steps as DoordashStep[])[stepIndex].status !== 'in_progress') {
+                const updatedSteps = (steps as DoordashStep[]).map((s, i) =>
+                  i === stepIndex ? { ...s, status: 'in_progress' } : s
+                );
+                const updatedTemplateData = { ...card.templateData as Record<string, unknown>, steps: updatedSteps };
+                const updatedData = { ...card, templateData: updatedTemplateData };
+                stored.data = updatedData as import('./ipc-contract.js').CardSurfaceData;
+                ctx.sendToClient({
+                  type: 'ui_surface_update',
+                  sessionId: ctx.conversationId,
+                  surfaceId,
+                  data: updatedData,
+                });
               }
             }
           }
@@ -186,6 +185,7 @@ export function createToolExecutor(
       workingDir: ctx.workingDir,
       sessionId: ctx.conversationId,
       conversationId: ctx.conversationId,
+      assistantId: ctx.assistantId,
       requestId: ctx.currentRequestId,
       taskRunId: ctx.taskRunId,
       onOutput,
@@ -310,7 +310,7 @@ export function createToolExecutor(
     // Auto-emit task_progress card on first DoorDash CLI command
     if (name === 'bash' || name === 'host_bash') {
       const cmd = input.command as string | undefined;
-      if (cmd?.includes('vellum doordash')) {
+      if (cmd && doordashCommandToStep(cmd)) {
         const surfaceId = 'doordash-progress';
 
         if (!ctx.surfaceState.has(surfaceId)) {

package/src/daemon/session-workspace.ts

@@ -12,7 +12,7 @@ export interface WorkspaceSessionContext {
 
 /** Refresh workspace top-level directory context if needed. */
 export function refreshWorkspaceTopLevelContextIfNeeded(ctx: WorkspaceSessionContext): void {
-  if (!ctx.workspaceTopLevelDirty && ctx.workspaceTopLevelContext !== null) return;
+  if (!ctx.workspaceTopLevelDirty && ctx.workspaceTopLevelContext != null) return;
   const snapshot = scanTopLevelDirectories(ctx.workingDir);
   ctx.workspaceTopLevelContext = renderWorkspaceTopLevelContext(snapshot);
   ctx.workspaceTopLevelDirty = false;

package/src/daemon/session.ts

@@ -16,6 +16,7 @@
  */
 
 import type { Message } from '../providers/types.js';
+import type { TurnChannelContext } from '../channels/types.js';
 import type { ServerMessage, UsageStats, UserMessageAttachment, SurfaceType, SurfaceData } from './ipc-protocol.js';
 import { AgentLoop } from '../agent/loop.js';
 import type { Provider } from '../providers/types.js';
@@ -37,12 +38,13 @@ import { ContextWindowManager } from '../context/window-manager.js';
 import { getHookManager } from '../hooks/manager.js';
 import { ConflictGate } from './session-conflict-gate.js';
 import { MessageQueue } from './session-queue-manager.js';
-import type { QueueDrainReason } from './session-queue-manager.js';
-import type { ChannelCapabilities } from './session-runtime-assembly.js';
+import type { QueueDrainReason, QueueMetrics } from './session-queue-manager.js';
+import type { ChannelCapabilities, GuardianRuntimeContext } from './session-runtime-assembly.js';
 import type { AssistantAttachmentDraft } from './assistant-attachments.js';
 import {
   handleSurfaceAction as handleSurfaceActionImpl,
   handleSurfaceUndo as handleSurfaceUndoImpl,
+  createSurfaceMutex,
 } from './session-surfaces.js';
 import {
   undo as undoImpl,
@@ -127,19 +129,25 @@ export class Session {
   /** @internal */ currentActiveSurfaceId?: string;
   /** @internal */ currentPage?: string;
   /** @internal */ channelCapabilities?: ChannelCapabilities;
+  /** @internal */ guardianContext?: GuardianRuntimeContext;
+  /** @internal */ assistantId?: string;
+  /** @internal */ commandIntent?: { type: string; payload?: string; languageCode?: string };
   /** @internal */ pendingSurfaceActions = new Map<string, { surfaceType: SurfaceType }>();
   /** @internal */ lastSurfaceAction = new Map<string, { actionId: string; data?: Record<string, unknown> }>();
   /** @internal */ surfaceState = new Map<string, { surfaceType: SurfaceType; data: SurfaceData }>();
   /** @internal */ surfaceUndoStacks = new Map<string, string[]>();
+  /** @internal */ withSurface = createSurfaceMutex();
   /** @internal */ currentTurnSurfaces: Array<{ surfaceId: string; surfaceType: SurfaceType; title?: string; data: SurfaceData; actions?: Array<{ id: string; label: string; style?: string }>; display?: string }> = [];
   /** @internal */ onEscalateToComputerUse?: (task: string, sourceSessionId: string) => boolean;
   /** @internal */ workspaceTopLevelContext: string | null = null;
   /** @internal */ workspaceTopLevelDirty = true;
   public readonly traceEmitter: TraceEmitter;
   public memoryPolicy: SessionMemoryPolicy;
+  /** @internal */ streamThinking: boolean;
   /** @internal */ turnCount = 0;
   public lastAssistantAttachments: AssistantAttachmentDraft[] = [];
   public lastAttachmentWarnings: string[] = [];
+  /** @internal */ currentTurnChannelContext: TurnChannelContext | null = null;
 
   constructor(
     conversationId: string,
@@ -190,6 +198,7 @@ export class Session {
     );
 
     const config = getConfig();
+    this.streamThinking = config.thinking.streamThinking ?? false;
     const resolveTools = createResolveToolsCallback(toolDefs, this);
 
     this.agentLoop = new AgentLoop(
@@ -283,6 +292,10 @@ export class Session {
     return this.queue.length;
   }
 
+  getQueueMetrics(): QueueMetrics {
+    return this.queue.getMetrics();
+  }
+
   hasQueuedMessages(): boolean {
     return !this.queue.isEmpty;
   }
@@ -327,6 +340,26 @@ export class Session {
     this.channelCapabilities = caps ?? undefined;
   }
 
+  setGuardianContext(ctx: GuardianRuntimeContext | null): void {
+    this.guardianContext = ctx ?? undefined;
+  }
+
+  setAssistantId(assistantId: string | null): void {
+    this.assistantId = assistantId ?? undefined;
+  }
+
+  setCommandIntent(intent: { type: string; payload?: string; languageCode?: string } | null): void {
+    this.commandIntent = intent ?? undefined;
+  }
+
+  setTurnChannelContext(ctx: TurnChannelContext): void {
+    this.currentTurnChannelContext = ctx;
+  }
+
+  getTurnChannelContext(): TurnChannelContext | null {
+    return this.currentTurnChannelContext;
+  }
+
   persistUserMessage(
     content: string,
     attachments: UserMessageAttachment[],

package/src/daemon/shutdown-handlers.ts

@@ -0,0 +1,122 @@
+import * as Sentry from '@sentry/node';
+import { getSqlite, resetDb } from '../memory/db.js';
+import { browserManager } from '../tools/browser/browser-manager.js';
+import { getEnrichmentService } from '../workspace/commit-message-enrichment-service.js';
+import { getLogger } from '../util/logger.js';
+import type { DaemonServer } from './server.js';
+import type { RuntimeHttpServer } from '../runtime/http-server.js';
+import type { HeartbeatService } from '../workspace/heartbeat-service.js';
+import type { AgentHeartbeatService } from '../agent-heartbeat/agent-heartbeat-service.js';
+import type { QdrantManager } from '../memory/qdrant-manager.js';
+import type { HookManager } from '../hooks/manager.js';
+
+const log = getLogger('lifecycle');
+
+export interface ShutdownDeps {
+  server: DaemonServer;
+  heartbeat: HeartbeatService;
+  agentHeartbeat: AgentHeartbeatService;
+  hookManager: HookManager;
+  runtimeHttp: RuntimeHttpServer | null;
+  scheduler: { stop(): void };
+  memoryWorker: { stop(): void };
+  qdrantManager: QdrantManager;
+  cleanupPidFile: () => void;
+}
+
+export function installShutdownHandlers(deps: ShutdownDeps): void {
+  let shuttingDown = false;
+
+  const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    log.info('Shutting down daemon...');
+
+    deps.hookManager.stopWatching();
+
+    // Force exit if graceful shutdown takes too long.
+    // Set this BEFORE awaiting heartbeat stop and triggering daemon-stop hooks
+    // so it covers all potentially-blocking async shutdown work.
+    const forceTimer = setTimeout(() => {
+      log.warn('Graceful shutdown timed out, forcing exit');
+      deps.cleanupPidFile();
+      process.exit(1);
+    }, 10_000);
+    forceTimer.unref();
+
+    await deps.heartbeat.stop();
+    await deps.agentHeartbeat.stop();
+
+    try {
+      await deps.hookManager.trigger('daemon-stop', { pid: process.pid });
+    } catch {
+      // Don't let hook failures block shutdown
+    }
+
+    // Commit any uncommitted workspace changes before stopping the server.
+    // This ensures no workspace state is lost during graceful shutdown.
+    try {
+      log.info({ phase: 'pre_stop' }, 'Committing pending workspace changes');
+      await deps.heartbeat.commitAllPending();
+    } catch (err) {
+      log.warn({ err, phase: 'pre_stop' }, 'Shutdown workspace commit failed');
+    }
+
+    await deps.server.stop();
+
+    // Final commit sweep: catch any writes that occurred during server.stop()
+    // (e.g. in-flight tool executions completing during drain).
+    try {
+      log.info({ phase: 'post_stop' }, 'Final workspace commit sweep');
+      await deps.heartbeat.commitAllPending();
+    } catch (err) {
+      log.warn({ err, phase: 'post_stop' }, 'Post-stop workspace commit failed');
+    }
+
+    // Flush in-flight enrichment jobs so shutdown commit notes are not dropped.
+    // The enrichment service's shutdown() drains active jobs and discards pending ones.
+    try {
+      await getEnrichmentService().shutdown();
+    } catch (err) {
+      log.warn({ err }, 'Enrichment service shutdown failed (non-fatal)');
+    }
+
+    if (deps.runtimeHttp) await deps.runtimeHttp.stop();
+    await browserManager.closeAllPages();
+    deps.scheduler.stop();
+    deps.memoryWorker.stop();
+    await deps.qdrantManager.stop();
+
+    // Checkpoint WAL and close SQLite so no writes are lost on exit.
+    // Checkpoint and close are in separate try blocks so that close()
+    // always runs even if checkpointing throws (e.g. SQLITE_BUSY).
+    try {
+      getSqlite().exec('PRAGMA wal_checkpoint(TRUNCATE)');
+    } catch (err) {
+      log.warn({ err }, 'WAL checkpoint failed (non-fatal)');
+    }
+    try {
+      resetDb();
+    } catch (err) {
+      log.warn({ err }, 'Database close failed (non-fatal)');
+    }
+
+    await Sentry.flush(2000);
+    clearTimeout(forceTimer);
+    deps.cleanupPidFile();
+    process.exit(0);
+  };
+
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+
+  process.on('unhandledRejection', (reason) => {
+    log.error({ err: reason }, 'Unhandled promise rejection');
+    Sentry.captureException(reason);
+  });
+
+  process.on('uncaughtException', (err) => {
+    log.error({ err }, 'Uncaught exception');
+    Sentry.captureException(err);
+  });
+}

package/src/daemon/trace-emitter.ts

@@ -69,7 +69,7 @@ function normalizeAttributes(
 }
 
 function normalizeValue(value: unknown): string | number | boolean | null {
-  if (value === null || value === undefined) return null;
+  if (value == null) return null;
   if (typeof value === 'boolean' || typeof value === 'number') return value;
   if (typeof value === 'string') return truncate(value, ATTRIBUTE_VALUE_MAX_LENGTH);
   // Coerce non-primitives to string