@vellumai/assistant 0.3.7 → 0.3.9

package/src/config/bundled-skills/media-processing/SKILL.md

@@ -34,11 +34,11 @@ Preprocess a video asset: detect dead time via mpdecimate, segment the video int
 
 Parameters:
 - `asset_id` (required) — ID of the media asset.
-- `interval_seconds` — Interval between keyframes (default: 3s).
-- `segment_duration` — Duration of each segment window (default: 20s).
+- `interval_seconds` — Interval between keyframes (default: 1s). Use 0.5s for sports/action content where frame density matters.
+- `segment_duration` — Duration of each segment window (default: 15s).
 - `dead_time_threshold` — Sensitivity for dead-time detection (default: 0.02).
 - `section_config` — Path to a JSON file with manual section boundaries.
-- `skip_dead_time` — Whether to detect and skip dead time (default: true).
+- `skip_dead_time` — Whether to detect and skip dead time (default: false). Dead-time detection can be too aggressive for continuous action video like sports — it may incorrectly skip live play. Enable only for content with clear idle periods (e.g., lectures, surveillance footage).
 - `short_edge` — Short edge resolution for downscaled frames in pixels (default: 480).
 
 ### analyze_keyframes
@@ -74,7 +74,7 @@ Get a diagnostic report for a media asset. Returns:
 - **Processing stats**: total keyframes extracted.
 - **Per-stage status and timing**: which stages (preprocess, map, reduce) have run, how long each took, current progress.
 - **Failure reasons**: last error from any failed stage.
-- **Cost estimation**: based on segment count and Gemini 2.5 Flash pricing, plus a note about Claude reduce costs.
+- **Cost estimation**: based on segment count and current Gemini pricing.
 
 ## Services
 
@@ -110,6 +110,82 @@ Limits concurrent API calls during the Map phase to avoid rate limiting.
 
 Tracks estimated API costs during pipeline execution.
 
+## Best Practices
+
+### Map Prompt Strategy: Go Broad, Not Targeted
+
+The single most important insight: **always use a broad, descriptive map prompt** instead of a targeted one.
+
+A targeted prompt like "find turnovers" locks you into one topic. If the user later wants to ask about defense, formations, or specific players, you'd need to reprocess the entire video. Instead, run a general-purpose descriptive prompt that captures everything visible, creating a rich, reusable dataset. Then all follow-up questions can be handled via `query_media` with no reprocessing.
+
+**One map run, many queries.**
+
+The map output will be larger (more tokens per segment), but Gemini Flash is cheap enough that this is a good tradeoff. Only use a targeted prompt if the user explicitly asks for something narrow.
+
+#### Sample General-Purpose Map Prompt
+
+Use this as a starting point for the `system_prompt` parameter in `analyze_keyframes`:
+
+```
+You are analyzing keyframes from a video. For each segment, describe everything you can observe:
+
+- People visible: count, positions, identifying features (jersey numbers, clothing, names if visible)
+- Actions and movements: what people are doing, direction of movement, interactions
+- Objects of interest: ball location, equipment, vehicles, on-screen graphics
+- Environment: setting, lighting, weather if outdoors
+- Text on screen: scores, captions, titles, signs, timestamps
+- Scene composition: camera angle, zoom level, any transitions between shots
+- Any stoppages, pauses, or changes in activity
+
+Be specific and factual. Describe what you see, not what you infer happened between frames.
+```
+
+#### Sample Output Schema
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "scene_description": { "type": "string" },
+    "people": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "description": { "type": "string" },
+          "position": { "type": "string" },
+          "action": { "type": "string" }
+        }
+      }
+    },
+    "objects_of_interest": { "type": "array", "items": { "type": "string" } },
+    "on_screen_text": { "type": "array", "items": { "type": "string" } },
+    "camera": { "type": "string" },
+    "notable_events": { "type": "array", "items": { "type": "string" } }
+  }
+}
+```
+
+### Clip Delivery
+
+The `generate_clip` tool outputs clips as temporary files. These may not deliver reliably via sandbox attachments. For reliable delivery, use `host_bash` + ffmpeg to save clips to a user-specified location as a fallback.
+
+## Known Limitations — Vision Analysis
+
+Gemini performs well at **spatial/descriptive analysis** from static keyframes:
+- Player positions, formations, and spacing
+- Jersey numbers and identifying features
+- Ball location and which team has possession
+- Score and on-screen text
+- Camera angles and scene composition
+
+Gemini **hallucinates when asked to detect fast temporal events** from static frames, regardless of frame density:
+- Turnovers, steals, fouls, and specific plays
+- Fast transitions and split-second actions
+- Causality between frames (what "happened" vs. what's visible)
+
+The model is good at describing **what is there** but bad at detecting **what happened**. Structure your map prompts and queries accordingly — ask the model to describe scenes, then use `query_media` (Claude) to reason about patterns and events across the descriptive data.
+
 ## Operator Runbook
 
 ### Monitoring Progress
@@ -137,16 +213,7 @@ After fixing the root cause, re-run the failed stage. The pipeline is resumable
 
 ### Cost Expectations
 
-The Map phase (Gemini 2.5 Flash) is the primary cost driver. Cost scales with video duration, keyframe interval, and segment size:
-
-| Video Duration | Interval | Keyframes | Segments (~10 frames each) | Estimated Map Cost |
-|----------------|----------|-----------|----------------------------|--------------------|
-| 30 min         | 3s       | ~600      | ~60                        | ~$0.06             |
-| 60 min         | 3s       | ~1,200    | ~120                       | ~$0.12             |
-| 90 min         | 3s       | ~1,800    | ~180                       | ~$0.18             |
-| 90 min         | 5s       | ~1,080    | ~108                       | ~$0.11             |
-
-The Reduce phase (Claude) adds a small additional cost per query. The `media_diagnostics` tool provides per-asset cost estimates.
+Use `media_diagnostics` to get per-asset cost estimates. The Map phase (Gemini) is the primary cost driver — it scales with video duration and keyframe interval. The Q&A phase (Claude) is negligible per query.
 
 ### Known Limitations
 

package/src/config/bundled-skills/media-processing/TOOLS.json

@@ -67,11 +67,11 @@
           },
           "interval_seconds": {
             "type": "number",
-            "description": "Interval between keyframes in seconds. Default: 3"
+            "description": "Interval between keyframes in seconds. Default: 1. Use 0.5 for sports/action content."
           },
           "segment_duration": {
             "type": "number",
-            "description": "Duration of each segment window in seconds. Default: 20"
+            "description": "Duration of each segment window in seconds. Default: 15"
           },
           "dead_time_threshold": {
             "type": "number",
@@ -83,7 +83,7 @@
           },
           "skip_dead_time": {
             "type": "boolean",
-            "description": "Whether to detect and skip dead time. Default: true"
+            "description": "Whether to detect and skip dead time. Default: false. Can be too aggressive for continuous action video like sports."
           },
           "short_edge": {
             "type": "number",

package/src/config/bundled-skills/media-processing/services/preprocess.ts

@@ -355,13 +355,13 @@ export async function preprocessForAsset(
   onProgress?: (msg: string) => void,
 ): Promise<PreprocessManifest> {
   const config: PreprocessConfig = {
-    intervalSeconds: options.intervalSeconds ?? 3,
-    segmentDuration: options.segmentDuration ?? 20,
+    intervalSeconds: options.intervalSeconds ?? 1,
+    segmentDuration: options.segmentDuration ?? 15,
     deadTimeThreshold: options.deadTimeThreshold ?? 0.02,
     shortEdge: options.shortEdge ?? 480,
   };
 
-  const skipDeadTime = options.skipDeadTime ?? true;
+  const skipDeadTime = options.skipDeadTime ?? false;
 
   const asset = getMediaAssetById(assetId);
   if (!asset) {

package/src/config/defaults.ts

@@ -285,4 +285,9 @@ export const DEFAULT_CONFIG: AssistantConfig = {
     sigkillGracePeriodMs: 2000,
     titleGenerationMaxTokens: 30,
   },
+  notifications: {
+    enabled: false,
+    shadowMode: true,
+    decisionModel: 'claude-haiku-4-5-20251001',
+  },
 };

package/src/config/notifications-schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const NotificationsConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: 'notifications.enabled must be a boolean' })
+    .default(false),
+  shadowMode: z
+    .boolean({ error: 'notifications.shadowMode must be a boolean' })
+    .default(true),
+  decisionModel: z
+    .string({ error: 'notifications.decisionModel must be a string' })
+    .default('claude-haiku-4-5-20251001'),
+});
+
+export type NotificationsConfig = z.infer<typeof NotificationsConfigSchema>;

package/src/config/schema.ts

@@ -90,6 +90,13 @@ export type {
   WorkspaceGitConfig,
 } from './agent-schema.js';
 
+export {
+  NotificationsConfigSchema,
+} from './notifications-schema.js';
+export type {
+  NotificationsConfig,
+} from './notifications-schema.js';
+
 export {
   TimeoutConfigSchema,
   RateLimitConfigSchema,
@@ -129,6 +136,7 @@ import { CallsConfigSchema } from './calls-schema.js';
 import { SandboxConfigSchema } from './sandbox-schema.js';
 import { SkillsConfigSchema } from './skills-schema.js';
 import { AgentHeartbeatConfigSchema, SwarmConfigSchema, WorkspaceGitConfigSchema } from './agent-schema.js';
+import { NotificationsConfigSchema } from './notifications-schema.js';
 import {
   TimeoutConfigSchema,
   RateLimitConfigSchema,
@@ -437,6 +445,11 @@ export const AssistantConfigSchema = z.object({
     sigkillGracePeriodMs: 2000,
     titleGenerationMaxTokens: 30,
   }),
+  notifications: NotificationsConfigSchema.default({
+    enabled: false,
+    shadowMode: true,
+    decisionModel: 'claude-haiku-4-5-20251001',
+  }),
 }).superRefine((config, ctx) => {
   if (config.contextWindow.targetInputTokens >= config.contextWindow.maxInputTokens) {
     ctx.addIssue({

package/src/config/types.ts

@@ -39,5 +39,6 @@ export type {
   CallerIdentityConfig,
   SmsConfig,
   IngressConfig,
+  NotificationsConfig,
   DaemonConfig,
 } from './schema.js';

package/src/daemon/daemon-control.ts

@@ -19,6 +19,10 @@ const DAEMON_TIMEOUT_DEFAULTS = {
   sigkillGracePeriodMs: 2000,
 };
 
+function isPositiveInteger(v: unknown): v is number {
+  return typeof v === 'number' && Number.isInteger(v) && v > 0;
+}
+
 /**
  * Read daemon timeout values directly from the config JSON file, bypassing
  * loadConfig() and its ensureMigratedDataDir()/ensureDataDir() side effects.
@@ -30,18 +34,15 @@ function readDaemonTimeouts(): typeof DAEMON_TIMEOUT_DEFAULTS {
     const raw = JSON.parse(readFileSync(getWorkspaceConfigPath(), 'utf-8'));
     if (raw.daemon && typeof raw.daemon === 'object') {
       return {
-        startupSocketWaitMs:
-          typeof raw.daemon.startupSocketWaitMs === 'number'
-            ? raw.daemon.startupSocketWaitMs
-            : DAEMON_TIMEOUT_DEFAULTS.startupSocketWaitMs,
-        stopTimeoutMs:
-          typeof raw.daemon.stopTimeoutMs === 'number'
-            ? raw.daemon.stopTimeoutMs
-            : DAEMON_TIMEOUT_DEFAULTS.stopTimeoutMs,
-        sigkillGracePeriodMs:
-          typeof raw.daemon.sigkillGracePeriodMs === 'number'
-            ? raw.daemon.sigkillGracePeriodMs
-            : DAEMON_TIMEOUT_DEFAULTS.sigkillGracePeriodMs,
+        startupSocketWaitMs: isPositiveInteger(raw.daemon.startupSocketWaitMs)
+          ? raw.daemon.startupSocketWaitMs
+          : DAEMON_TIMEOUT_DEFAULTS.startupSocketWaitMs,
+        stopTimeoutMs: isPositiveInteger(raw.daemon.stopTimeoutMs)
+          ? raw.daemon.stopTimeoutMs
+          : DAEMON_TIMEOUT_DEFAULTS.stopTimeoutMs,
+        sigkillGracePeriodMs: isPositiveInteger(raw.daemon.sigkillGracePeriodMs)
+          ? raw.daemon.sigkillGracePeriodMs
+          : DAEMON_TIMEOUT_DEFAULTS.sigkillGracePeriodMs,
       };
     }
   } catch {

package/src/daemon/handlers/subagents.ts

@@ -109,10 +109,17 @@ export function handleSubagentMessage(
     return;
   }
 
-  const sent = manager.sendMessage(msg.subagentId, msg.content);
+  const result = manager.sendMessage(msg.subagentId, msg.content);
 
-  if (!sent) {
-    log.warn({ subagentId: msg.subagentId }, 'Client sent message to terminal subagent');
+  if (result === 'queue_full') {
+    log.warn({ subagentId: msg.subagentId }, 'Subagent message rejected — queue full');
+    ctx.send(socket, {
+      type: 'error',
+      message: `Subagent "${msg.subagentId}" message queue is full. Please wait for current messages to be processed.`,
+      category: 'queue_full',
+    });
+  } else if (result !== 'sent') {
+    log.warn({ subagentId: msg.subagentId, reason: result }, 'Client sent message to terminal subagent');
     ctx.send(socket, {
       type: 'error',
       message: `Subagent "${msg.subagentId}" not found or in terminal state.`,

package/src/daemon/ipc-contract/notifications.ts

@@ -0,0 +1,9 @@
+/** Broadcast to connected macOS clients when a notification should be displayed. */
+export interface NotificationIntent {
+  type: 'notification_intent';
+  sourceEventName: string;
+  title: string;
+  body: string;
+  /** Optional deep-link metadata so the client can navigate to the relevant context. */
+  deepLinkMetadata?: Record<string, unknown>;
+}

package/src/daemon/ipc-contract-inventory.json

@@ -201,6 +201,7 @@
     "MessageQueued",
     "MessageQueuedDeleted",
     "ModelInfo",
+    "NotificationIntent",
     "OpenBundleResponse",
     "OpenTasksWindow",
     "OpenUrl",
@@ -486,6 +487,7 @@
     "message_queued",
     "message_queued_deleted",
     "model_info",
+    "notification_intent",
     "open_bundle_response",
     "open_tasks_window",
     "open_url",

package/src/daemon/ipc-contract.ts

@@ -27,6 +27,7 @@ export * from './ipc-contract/diagnostics.js';
 export * from './ipc-contract/parental-control.js';
 export * from './ipc-contract/inbox.js';
 export * from './ipc-contract/pairing.js';
+export * from './ipc-contract/notifications.js';
 
 // Import types needed for aggregate unions and SubagentEvent
 import type { AuthMessage, PingMessage, CancelRequest, DeleteQueuedMessage, ModelGetRequest, ModelSetRequest, ImageGenModelSetRequest, HistoryRequest, UndoRequest, RegenerateRequest, UsageRequest, SandboxSetRequest, SessionListRequest, SessionCreateRequest, SessionSwitchRequest, SessionRenameRequest, SessionsClearRequest, ConversationSearchRequest } from './ipc-contract/sessions.js';
@@ -64,6 +65,7 @@ import type { SchedulesList, ScheduleToggle, ScheduleRemove, ScheduleRunNow, Rem
 import type { ParentalControlGetRequest, ParentalControlVerifyPinRequest, ParentalControlSetPinRequest, ParentalControlUpdateRequest, ParentalControlGetResponse, ParentalControlVerifyPinResponse, ParentalControlSetPinResponse, ParentalControlUpdateResponse } from './ipc-contract/parental-control.js';
 import type { IngressInviteRequest, IngressMemberRequest, AssistantInboxRequest, AssistantInboxEscalationRequest, AssistantInboxReplyRequest, IngressInviteResponse, IngressMemberResponse, AssistantInboxResponse, AssistantInboxEscalationResponse, AssistantInboxReplyResponse } from './ipc-contract/inbox.js';
 import type { PairingApprovalResponse, ApprovedDevicesList, ApprovedDeviceRemove, ApprovedDevicesClear, PairingApprovalRequest, ApprovedDevicesListResponse, ApprovedDeviceRemoveResponse } from './ipc-contract/pairing.js';
+import type { NotificationIntent } from './ipc-contract/notifications.js';
 
 // === SubagentEvent — defined here because it references ServerMessage ===
 
@@ -361,7 +363,8 @@ export type ServerMessage =
   | AssistantInboxReplyResponse
   | PairingApprovalRequest
   | ApprovedDevicesListResponse
-  | ApprovedDeviceRemoveResponse;
+  | ApprovedDeviceRemoveResponse
+  | NotificationIntent;
 
 // === Contract schema ===
 

package/src/daemon/lifecycle.ts

@@ -26,6 +26,7 @@ import { ensurePromptFiles } from '../config/system-prompt.js';
 import { loadPrebuiltHtml } from '../home-base/prebuilt/seed.js';
 import { DaemonServer } from './server.js';
 import { setRelayBroadcast } from '../calls/relay-server.js';
+import { setVoiceBridgeOrchestrator } from '../calls/voice-session-bridge.js';
 import { listWorkItems, updateWorkItem } from '../work-items/work-item-store.js';
 import { getLogger, initLogger } from '../util/logger.js';
 import { initSentry } from '../instrument.js';
@@ -35,6 +36,8 @@ import { QdrantManager } from '../memory/qdrant-manager.js';
 import { initQdrantClient } from '../memory/qdrant-client.js';
 import { startScheduler } from '../schedule/scheduler.js';
 import { RuntimeHttpServer } from '../runtime/http-server.js';
+import { assistantEventHub } from '../runtime/assistant-event-hub.js';
+import * as attachmentsStore from '../memory/attachments-store.js';
 import { getHookManager } from '../hooks/manager.js';
 import { installTemplates } from '../hooks/templates.js';
 import { installCliLaunchers } from './install-cli-launchers.js';
@@ -42,10 +45,12 @@ import { HeartbeatService } from '../workspace/heartbeat-service.js';
 import { AgentHeartbeatService } from '../agent-heartbeat/agent-heartbeat-service.js';
 import { reconcileCallsOnStartup } from '../calls/call-recovery.js';
 import { TwilioConversationRelayProvider } from '../calls/twilio-provider.js';
+import { emitNotificationSignal, registerBroadcastFn } from '../notifications/emit-signal.js';
 import { createApprovalCopyGenerator, createApprovalConversationGenerator } from './approval-generators.js';
 import { initializeProvidersAndTools, registerWatcherProviders, registerMessagingProviders } from './providers-setup.js';
 import { installShutdownHandlers } from './shutdown-handlers.js';
 import { writePid, cleanupPidFile } from './daemon-control.js';
+import { initPairingHandlers } from './handlers/pairing.js';
 
 // Re-export public API so existing consumers don't need to change imports
 export {
@@ -184,38 +189,112 @@ export async function runDaemon(): Promise<void> {
   registerWatcherProviders();
   registerMessagingProviders();
 
+  // Register the IPC broadcast function for the notification signal pipeline's
+  // macOS adapter so it can deliver notification_intent messages to desktop clients.
+  registerBroadcastFn((msg) => server.broadcast(msg));
+
   const scheduler = startScheduler(
     async (conversationId, message) => {
       await server.processMessage(conversationId, message);
     },
     (reminder) => {
+      // Legacy IPC broadcast for backward compatibility with desktop client UI
       server.broadcast({
         type: 'reminder_fired',
         reminderId: reminder.id,
         label: reminder.label,
         message: reminder.message,
       });
+      // Signal pipeline: fire-and-forget
+      void emitNotificationSignal({
+        sourceEventName: 'reminder.fired',
+        sourceChannel: 'scheduler',
+        sourceSessionId: reminder.id,
+        attentionHints: {
+          requiresAction: true,
+          urgency: 'high',
+          isAsyncBackground: false,
+          visibleInSourceNow: false,
+        },
+        contextPayload: {
+          reminderId: reminder.id,
+          label: reminder.label,
+          message: reminder.message,
+        },
+        dedupeKey: `reminder:${reminder.id}`,
+      });
     },
     (schedule) => {
+      // Legacy IPC broadcast for backward compatibility with desktop client UI
       server.broadcast({
         type: 'schedule_complete',
         scheduleId: schedule.id,
         name: schedule.name,
       });
+      // Signal pipeline: fire-and-forget
+      void emitNotificationSignal({
+        sourceEventName: 'schedule.complete',
+        sourceChannel: 'scheduler',
+        sourceSessionId: schedule.id,
+        attentionHints: {
+          requiresAction: false,
+          urgency: 'medium',
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+        contextPayload: {
+          scheduleId: schedule.id,
+          name: schedule.name,
+        },
+      });
     },
     (notification) => {
+      // Legacy IPC broadcast for backward compatibility with desktop client UI
       server.broadcast({
         type: 'watcher_notification',
         title: notification.title,
         body: notification.body,
       });
+      // Signal pipeline: fire-and-forget
+      void emitNotificationSignal({
+        sourceEventName: 'watcher.notification',
+        sourceChannel: 'watcher',
+        sourceSessionId: `watcher-${Date.now()}`,
+        attentionHints: {
+          requiresAction: false,
+          urgency: 'low',
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+        contextPayload: {
+          title: notification.title,
+          body: notification.body,
+        },
+      });
     },
     (params) => {
+      // Legacy IPC broadcast for backward compatibility with desktop client UI
       server.broadcast({
         type: 'watcher_escalation',
         title: params.title,
         body: params.body,
       });
+      // Signal pipeline: fire-and-forget
+      void emitNotificationSignal({
+        sourceEventName: 'watcher.escalation',
+        sourceChannel: 'watcher',
+        sourceSessionId: `watcher-escalation-${Date.now()}`,
+        attentionHints: {
+          requiresAction: true,
+          urgency: 'high',
+          isAsyncBackground: false,
+          visibleInSourceNow: false,
+        },
+        contextPayload: {
+          title: params.title,
+          body: params.body,
+        },
+      });
     },
   );
 
@@ -247,6 +326,8 @@ export async function runDaemon(): Promise<void> {
 
   const hostname = getRuntimeHttpHost();
 
+  const runOrchestrator = server.createRunOrchestrator();
+
   runtimeHttp = new RuntimeHttpServer({
     port: httpPort,
     hostname,
@@ -255,15 +336,33 @@ export async function runDaemon(): Promise<void> {
       server.processMessage(conversationId, content, attachmentIds, options, sourceChannel),
     persistAndProcessMessage: (conversationId, content, attachmentIds, options, sourceChannel) =>
       server.persistAndProcessMessage(conversationId, content, attachmentIds, options, sourceChannel),
-    runOrchestrator: server.createRunOrchestrator(),
+    runOrchestrator,
     interfacesDir: getInterfacesDir(),
     approvalCopyGenerator: createApprovalCopyGenerator(),
     approvalConversationGenerator: createApprovalConversationGenerator(),
+    sendMessageDeps: {
+      getOrCreateSession: (conversationId) =>
+        server.getSessionForMessages(conversationId),
+      assistantEventHub,
+      resolveAttachments: (attachmentIds) =>
+        attachmentsStore.getAttachmentsByIds(attachmentIds).map((a) => ({
+          id: a.id,
+          filename: a.originalFilename,
+          mimeType: a.mimeType,
+          data: a.dataBase64,
+        })),
+    },
   });
+
+  // Inject the voice bridge orchestrator BEFORE attempting to start the HTTP
+  // server. The bridge only needs the RunOrchestrator instance (already created
+  // above) and must be available even when the HTTP server fails to bind.
+  setVoiceBridgeOrchestrator(runOrchestrator);
   try {
     await runtimeHttp.start();
     setRelayBroadcast((msg) => server.broadcast(msg));
     runtimeHttp.setPairingBroadcast((msg) => server.broadcast(msg));
+    initPairingHandlers(runtimeHttp.getPairingStore(), bearerToken);
     server.setHttpPort(httpPort);
     log.info({ port: httpPort, hostname }, 'Daemon startup: runtime HTTP server listening');
   } catch (err) {

package/src/daemon/server.ts

@@ -819,6 +819,14 @@ export class DaemonServer {
     return { messageId };
   }
 
+  /**
+   * Expose session lookup for the POST /v1/messages handler.
+   * The handler manages busy-state checking and queueing itself.
+   */
+  async getSessionForMessages(conversationId: string): Promise<Session> {
+    return this.getOrCreateSession(conversationId, undefined, true);
+  }
+
   createRunOrchestrator(): RunOrchestrator {
     return new RunOrchestrator({
       getOrCreateSession: (conversationId, transport) =>

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

@@ -100,6 +100,7 @@ export interface AgentLoopSessionContext {
   channelCapabilities?: ChannelCapabilities;
   commandIntent?: { type: string; payload?: string; languageCode?: string };
   guardianContext?: GuardianRuntimeContext;
+  voiceCallControlPrompt?: string;
 
   readonly coreToolNames: Set<string>;
   allowedToolNames?: Set<string>;
@@ -321,6 +322,7 @@ export async function runAgentLoopImpl(
       channelTurnContext,
       guardianContext: ctx.guardianContext ?? null,
       temporalContext,
+      voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
     });
 
     // Pre-run repair
@@ -431,6 +433,7 @@ export async function runAgentLoopImpl(
           channelTurnContext,
           guardianContext: ctx.guardianContext ?? null,
           temporalContext,
+          voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
         });
         preRepairMessages = runMessages;
         preRunHistoryLength = runMessages.length;
@@ -466,6 +469,7 @@ export async function runAgentLoopImpl(
             channelTurnContext,
             guardianContext: ctx.guardianContext ?? null,
             temporalContext,
+            voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
           });
           preRepairMessages = runMessages;
           preRunHistoryLength = runMessages.length;

package/src/daemon/session-process.ts

@@ -24,6 +24,8 @@ import {
 import { answerCall } from '../calls/call-domain.js';
 import { resolveSlash, type SlashContext } from './session-slash.js';
 import { getConfig } from '../config/loader.js';
+import { extractPreferences } from '../notifications/preference-extractor.js';
+import { createPreference } from '../notifications/preferences-store.js';
 import { getLogger } from '../util/logger.js';
 
 const log = getLogger('session-process');
@@ -68,6 +70,8 @@ export interface ProcessSessionContext {
   readonly usageStats: UsageStats;
   /** Request-scoped skill IDs preactivated via slash resolution. */
   preactivatedSkillIds?: string[];
+  /** Assistant identity — used for scoping notification preferences. */
+  readonly assistantId?: string;
   persistUserMessage(content: string, attachments: UserMessageAttachment[], requestId?: string, metadata?: Record<string, unknown>): string;
   runAgentLoop(
     content: string,
@@ -231,6 +235,29 @@ export function drainQueue(session: ProcessSessionContext, reason: QueueDrainRea
   session.currentActiveSurfaceId = next.activeSurfaceId;
   session.currentPage = next.currentPage;
 
+  // Fire-and-forget: detect notification preferences in the queued message
+  // and persist any that are found, mirroring the logic in processMessage.
+  if (session.assistantId && getConfig().notifications.enabled) {
+    const aid = session.assistantId;
+    extractPreferences(resolvedContent)
+      .then((result) => {
+        if (!result.detected) return;
+        for (const pref of result.preferences) {
+          createPreference({
+            assistantId: aid,
+            preferenceText: pref.preferenceText,
+            appliesWhen: pref.appliesWhen,
+            priority: pref.priority,
+          });
+        }
+        log.info({ count: result.preferences.length, conversationId: session.conversationId }, 'Persisted extracted notification preferences (queued)');
+      })
+      .catch((err) => {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        log.warn({ err: errMsg, conversationId: session.conversationId }, 'Background preference extraction failed (queued)');
+      });
+  }
+
   // Fire-and-forget: persistUserMessage set session.processing = true
   // so subsequent messages will still be enqueued.
   // runAgentLoop's finally block will call drainQueue when this run completes.
@@ -375,6 +402,30 @@ export async function processMessage(
     return '';
   }
 
+  // Fire-and-forget: detect notification preferences in the user message
+  // and persist any that are found. Runs in the background so it doesn't
+  // block the main conversation flow.
+  if (session.assistantId && getConfig().notifications.enabled) {
+    const aid = session.assistantId;
+    extractPreferences(resolvedContent)
+      .then((result) => {
+        if (!result.detected) return;
+        for (const pref of result.preferences) {
+          createPreference({
+            assistantId: aid,
+            preferenceText: pref.preferenceText,
+            appliesWhen: pref.appliesWhen,
+            priority: pref.priority,
+          });
+        }
+        log.info({ count: result.preferences.length, conversationId: session.conversationId }, 'Persisted extracted notification preferences');
+      })
+      .catch((err) => {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        log.warn({ err: errMsg, conversationId: session.conversationId }, 'Background preference extraction failed');
+      });
+  }
+
   await session.runAgentLoop(resolvedContent, userMessageId, onEvent);
   return userMessageId;
 }