@vellumai/assistant 0.3.14 → 0.3.16

package/src/daemon/handlers/sessions.ts

@@ -4,13 +4,13 @@ import { v4 as uuid } from 'uuid';
 
 import { type InterfaceId,isChannelId, parseChannelId, parseInterfaceId } from '../../channels/types.js';
 import { getConfig } from '../../config/loader.js';
-import { getAttachmentsForMessage, setAttachmentThumbnail } from '../../memory/attachments-store.js';
+import { getAttachmentsForMessage, getFilePathForAttachment, setAttachmentThumbnail } from '../../memory/attachments-store.js';
 import { getAttentionStateByConversationIds } from '../../memory/conversation-attention-store.js';
 import * as conversationStore from '../../memory/conversation-store.js';
 import { GENERATING_TITLE, queueGenerateConversationTitle, UNTITLED_FALLBACK } from '../../memory/conversation-title-service.js';
 import * as externalConversationStore from '../../memory/external-conversation-store.js';
 import { checkIngressForSecrets } from '../../security/secret-ingress.js';
-import { redactSecrets } from '../../security/secret-scanner.js';
+import { compileCustomPatterns, redactSecrets } from '../../security/secret-scanner.js';
 import { getSubagentManager } from '../../subagent/index.js';
 import { silentlyWithLog } from '../../util/silently.js';
 import { truncate } from '../../util/truncate.js';
@@ -36,8 +36,9 @@ import type {
 } from '../ipc-protocol.js';
 import { normalizeThreadType } from '../ipc-protocol.js';
 import { executeRecordingIntent } from '../recording-executor.js';
-import { classifyRecordingIntentFallback, containsRecordingKeywords } from '../recording-intent-fallback.js';
 import { resolveRecordingIntent } from '../recording-intent.js';
+import { classifyRecordingIntentFallback, containsRecordingKeywords } from '../recording-intent-fallback.js';
+import { resolveChannelCapabilities } from '../session-runtime-assembly.js';
 import { buildSessionErrorMessage,classifySessionError } from '../session-error.js';
 import { generateVideoThumbnail } from '../video-thumbnail.js';
 import { handleRecordingPause, handleRecordingRestart, handleRecordingResume, handleRecordingStart, handleRecordingStop } from './recording.js';
@@ -88,6 +89,13 @@ export async function handleUserMessage(
       assistantMessageInterface: ipcInterface,
     };
 
+    // Update channel capabilities eagerly so both immediate and queued paths
+    // reflect the latest PTT / microphone state from the client.
+    session.setChannelCapabilities(resolveChannelCapabilities(ipcChannel, ipcInterface, {
+      pttActivationKey: msg.pttActivationKey,
+      microphonePermissionGranted: msg.microphonePermissionGranted,
+    }));
+
     const dispatchUserMessage = (
       content: string,
       attachments: UserMessageAttachment[],
@@ -95,6 +103,7 @@ export async function handleUserMessage(
       source: 'user_message' | 'secure_redirect_resume',
       activeSurfaceId?: string,
       currentPage?: string,
+      displayContent?: string,
     ): void => {
       const receivedDescription = source === 'user_message'
         ? 'User message received'
@@ -117,6 +126,8 @@ export async function handleUserMessage(
         activeSurfaceId,
         currentPage,
         queuedChannelMetadata,
+        undefined,
+        displayContent,
       );
       if (result.rejected) {
         rlog.warn({ source }, 'Message rejected — queue is full');
@@ -167,7 +178,7 @@ export async function handleUserMessage(
       // Fire-and-forget: don't block the IPC handler so the connection can
       // continue receiving messages (e.g. cancel, confirmations, or
       // additional user_message that will be queued by the session).
-      session.processMessage(content, attachments, sendEvent, dispatchRequestId, activeSurfaceId, currentPage).catch((err) => {
+      session.processMessage(content, attachments, sendEvent, dispatchRequestId, activeSurfaceId, currentPage, undefined, displayContent).catch((err) => {
         const message = err instanceof Error ? err.message : String(err);
         rlog.error({ err, source }, 'Error processing user message (session or provider failure)');
         ctx.send(socket, { type: 'error', message: `Failed to process message: ${message}` });
@@ -190,10 +201,13 @@ export async function handleUserMessage(
           category: 'secret_blocked',
         });
 
+        const compiledCustom = config.secretDetection.customPatterns?.length
+          ? compileCustomPatterns(config.secretDetection.customPatterns)
+          : undefined;
         const redactedMessageText = redactSecrets(messageText, {
           enabled: true,
           base64Threshold: config.secretDetection.entropyThreshold,
-        }).trim();
+        }, compiledCustom).trim();
 
         // Redirect: trigger a secure prompt so the user can enter the secret safely.
         // After save, continue the same request with redacted text so the model keeps
@@ -235,21 +249,38 @@ export async function handleUserMessage(
       rlog.info({ action, source: 'commandIntent' }, 'Recording command intent received in user_message');
       if (action === 'start') {
         const recordingId = handleRecordingStart(msg.sessionId, { promptForSource: true }, socket, ctx);
+        const responseText = recordingId ? 'Starting screen recording.' : 'A recording is already active.';
         ctx.send(socket, {
           type: 'assistant_text_delta',
-          text: recordingId ? 'Starting screen recording.' : 'A recording is already active.',
+          text: responseText,
           sessionId: msg.sessionId,
         });
         ctx.send(socket, { type: 'message_complete', sessionId: msg.sessionId });
+        await conversationStore.addMessage(msg.sessionId, 'user', JSON.stringify([{ type: 'text', text: messageText }]));
+        await conversationStore.addMessage(msg.sessionId, 'assistant', JSON.stringify([{ type: 'text', text: responseText }]));
+        // Keep in-memory session history aligned with DB so regenerate() and
+        // other history operations that rely on session.messages stay consistent.
+        // Only push when agent loop is NOT active to avoid corrupting role alternation.
+        if (!session.isProcessing()) {
+          session.messages.push({ role: 'user', content: [{ type: 'text', text: messageText }] });
+          session.messages.push({ role: 'assistant', content: [{ type: 'text', text: responseText }] });
+        }
         return;
       } else if (action === 'stop') {
         const stopped = handleRecordingStop(msg.sessionId, ctx) !== undefined;
+        const responseText = stopped ? 'Stopping the recording.' : 'No active recording to stop.';
         ctx.send(socket, {
           type: 'assistant_text_delta',
-          text: stopped ? 'Stopping the recording.' : 'No active recording to stop.',
+          text: responseText,
           sessionId: msg.sessionId,
         });
         ctx.send(socket, { type: 'message_complete', sessionId: msg.sessionId });
+        await conversationStore.addMessage(msg.sessionId, 'user', JSON.stringify([{ type: 'text', text: messageText }]));
+        await conversationStore.addMessage(msg.sessionId, 'assistant', JSON.stringify([{ type: 'text', text: responseText }]));
+        if (!session.isProcessing()) {
+          session.messages.push({ role: 'user', content: [{ type: 'text', text: messageText }] });
+          session.messages.push({ role: 'assistant', content: [{ type: 'text', text: responseText }] });
+        }
         return;
       } else if (action === 'restart') {
         const restartResult = handleRecordingRestart(msg.sessionId, socket, ctx);
@@ -259,24 +290,44 @@ export async function handleUserMessage(
           sessionId: msg.sessionId,
         });
         ctx.send(socket, { type: 'message_complete', sessionId: msg.sessionId });
+        await conversationStore.addMessage(msg.sessionId, 'user', JSON.stringify([{ type: 'text', text: messageText }]));
+        await conversationStore.addMessage(msg.sessionId, 'assistant', JSON.stringify([{ type: 'text', text: restartResult.responseText }]));
+        if (!session.isProcessing()) {
+          session.messages.push({ role: 'user', content: [{ type: 'text', text: messageText }] });
+          session.messages.push({ role: 'assistant', content: [{ type: 'text', text: restartResult.responseText }] });
+        }
         return;
       } else if (action === 'pause') {
         const paused = handleRecordingPause(msg.sessionId, ctx) !== undefined;
+        const responseText = paused ? 'Pausing the recording.' : 'No active recording to pause.';
         ctx.send(socket, {
           type: 'assistant_text_delta',
-          text: paused ? 'Pausing the recording.' : 'No active recording to pause.',
+          text: responseText,
           sessionId: msg.sessionId,
         });
         ctx.send(socket, { type: 'message_complete', sessionId: msg.sessionId });
+        await conversationStore.addMessage(msg.sessionId, 'user', JSON.stringify([{ type: 'text', text: messageText }]));
+        await conversationStore.addMessage(msg.sessionId, 'assistant', JSON.stringify([{ type: 'text', text: responseText }]));
+        if (!session.isProcessing()) {
+          session.messages.push({ role: 'user', content: [{ type: 'text', text: messageText }] });
+          session.messages.push({ role: 'assistant', content: [{ type: 'text', text: responseText }] });
+        }
         return;
       } else if (action === 'resume') {
         const resumed = handleRecordingResume(msg.sessionId, ctx) !== undefined;
+        const responseText = resumed ? 'Resuming the recording.' : 'No active recording to resume.';
         ctx.send(socket, {
           type: 'assistant_text_delta',
-          text: resumed ? 'Resuming the recording.' : 'No active recording to resume.',
+          text: responseText,
           sessionId: msg.sessionId,
         });
         ctx.send(socket, { type: 'message_complete', sessionId: msg.sessionId });
+        await conversationStore.addMessage(msg.sessionId, 'user', JSON.stringify([{ type: 'text', text: messageText }]));
+        await conversationStore.addMessage(msg.sessionId, 'assistant', JSON.stringify([{ type: 'text', text: responseText }]));
+        if (!session.isProcessing()) {
+          session.messages.push({ role: 'user', content: [{ type: 'text', text: messageText }] });
+          session.messages.push({ role: 'assistant', content: [{ type: 'text', text: responseText }] });
+        }
         return;
       } else {
         // Unrecognized action — fall through to normal text handling
@@ -285,6 +336,7 @@ export async function handleUserMessage(
     }
 
     // ── Standalone recording intent interception ──────────────────────────
+    let originalContentBeforeStrip: string | undefined;
     if (config.daemon.standaloneRecording && messageText) {
       const name = getAssistantName();
       const dynamicNames = [name].filter(Boolean) as string[];
@@ -308,6 +360,12 @@ export async function handleUserMessage(
             sessionId: msg.sessionId,
           });
           ctx.send(socket, { type: 'message_complete', sessionId: msg.sessionId });
+          await conversationStore.addMessage(msg.sessionId, 'user', JSON.stringify([{ type: 'text', text: messageText }]));
+          await conversationStore.addMessage(msg.sessionId, 'assistant', JSON.stringify([{ type: 'text', text: execResult.responseText! }]));
+          if (!session.isProcessing()) {
+            session.messages.push({ role: 'user', content: [{ type: 'text', text: messageText }] });
+            session.messages.push({ role: 'assistant', content: [{ type: 'text', text: execResult.responseText! }] });
+          }
           return;
         }
       }
@@ -320,6 +378,9 @@ export async function handleUserMessage(
           ctx,
         });
 
+        // Preserve the original text so the DB stores the full message
+        originalContentBeforeStrip = messageText;
+
         // Continue with stripped text for downstream processing
         msg.content = execResult.remainderText ?? messageText;
         messageText = msg.content;
@@ -376,6 +437,12 @@ export async function handleUserMessage(
                 sessionId: msg.sessionId,
               });
               ctx.send(socket, { type: 'message_complete', sessionId: msg.sessionId });
+              await conversationStore.addMessage(msg.sessionId, 'user', JSON.stringify([{ type: 'text', text: messageText }]));
+              await conversationStore.addMessage(msg.sessionId, 'assistant', JSON.stringify([{ type: 'text', text: execResult.responseText! }]));
+              if (!session.isProcessing()) {
+                session.messages.push({ role: 'user', content: [{ type: 'text', text: messageText }] });
+                session.messages.push({ role: 'assistant', content: [{ type: 'text', text: execResult.responseText! }] });
+              }
               return;
             }
           }
@@ -383,6 +450,14 @@ export async function handleUserMessage(
       }
     }
 
+    // If the session has a pending tool confirmation, auto-deny it so the
+    // agent can process the user's follow-up message instead.  The agent
+    // will see the denial and can re-request the tool if still needed.
+    if (session.hasAnyPendingConfirmation()) {
+      rlog.info('Auto-denying pending confirmation(s) due to new user message');
+      session.denyAllPendingConfirmations();
+    }
+
     dispatchUserMessage(
       messageText,
       msg.attachments ?? [],
@@ -390,6 +465,7 @@ export async function handleUserMessage(
       'user_message',
       msg.activeSurfaceId,
       msg.currentPage,
+      originalContentBeforeStrip,
     );
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -479,16 +555,17 @@ export function handleSessionList(socket: net.Socket, ctx: HandlerContext, offse
       const originInterface = parseInterfaceId(c.originInterface);
       const attn = attentionStates.get(c.id);
       const assistantAttention = attn ? {
-        hasUnseenLatestAssistantMessage: attn.latestAssistantMessageAt !== null &&
-          (attn.lastSeenAssistantMessageAt === null || attn.lastSeenAssistantMessageAt < attn.latestAssistantMessageAt),
-        ...(attn.latestAssistantMessageAt !== null ? { latestAssistantMessageAt: attn.latestAssistantMessageAt } : {}),
-        ...(attn.lastSeenAssistantMessageAt !== null ? { lastSeenAssistantMessageAt: attn.lastSeenAssistantMessageAt } : {}),
-        ...(attn.lastSeenConfidence !== null ? { lastSeenConfidence: attn.lastSeenConfidence } : {}),
-        ...(attn.lastSeenSignalType !== null ? { lastSeenSignalType: attn.lastSeenSignalType } : {}),
+        hasUnseenLatestAssistantMessage: attn.latestAssistantMessageAt != null &&
+          (attn.lastSeenAssistantMessageAt == null || attn.lastSeenAssistantMessageAt < attn.latestAssistantMessageAt),
+        ...(attn.latestAssistantMessageAt != null ? { latestAssistantMessageAt: attn.latestAssistantMessageAt } : {}),
+        ...(attn.lastSeenAssistantMessageAt != null ? { lastSeenAssistantMessageAt: attn.lastSeenAssistantMessageAt } : {}),
+        ...(attn.lastSeenConfidence != null ? { lastSeenConfidence: attn.lastSeenConfidence } : {}),
+        ...(attn.lastSeenSignalType != null ? { lastSeenSignalType: attn.lastSeenSignalType } : {}),
       } : undefined;
       return {
         id: c.id,
         title: c.title ?? 'Untitled',
+        createdAt: c.createdAt,
         updatedAt: c.updatedAt,
         threadType: normalizeThreadType(c.threadType),
         source: c.source ?? 'user',
@@ -626,7 +703,7 @@ export async function handleSessionSwitch(
   // If the target session is headless-locked (actively executing a task run),
   // skip rebinding the socket so tool confirmations stay suppressed.
   const existingSession = ctx.sessions.get(msg.sessionId);
-  const isHeadlessLocked = existingSession && (existingSession as unknown as { headlessLock?: boolean }).headlessLock;
+  const isHeadlessLocked = existingSession?.headlessLock;
 
   ctx.socketToSession.set(socket, msg.sessionId);
 
@@ -773,6 +850,7 @@ export function handleHistoryRequest(
               );
             }
 
+            const fp = getFilePathForAttachment(a.id);
             return {
               id: a.id,
               filename: a.originalFilename,
@@ -780,18 +858,23 @@ export function handleHistoryRequest(
               data: omit ? '' : a.dataBase64,
               ...(omit ? { sizeBytes: a.sizeBytes } : {}),
               ...(a.thumbnailBase64 ? { thumbnailData: a.thumbnailBase64 } : {}),
+              ...(fp ? { filePath: fp } : {}),
             };
           });
         } else {
           // Light mode: metadata only, strip base64 data
-          attachments = linked.map((a) => ({
-            id: a.id,
-            filename: a.originalFilename,
-            mimeType: a.mimeType,
-            data: '',
-            sizeBytes: a.sizeBytes,
-            ...(a.thumbnailBase64 ? { thumbnailData: a.thumbnailBase64 } : {}),
-          }));
+          attachments = linked.map((a) => {
+            const fp = getFilePathForAttachment(a.id);
+            return {
+              id: a.id,
+              filename: a.originalFilename,
+              mimeType: a.mimeType,
+              data: '',
+              sizeBytes: a.sizeBytes,
+              ...(a.thumbnailBase64 ? { thumbnailData: a.thumbnailBase64 } : {}),
+              ...(fp ? { filePath: fp } : {}),
+            };
+          });
         }
       }
     }

package/src/daemon/handlers/subagents.ts

@@ -80,11 +80,11 @@ export function handleSubagentStatus(
   }
 }
 
-export function handleSubagentMessage(
+export async function handleSubagentMessage(
   msg: SubagentMessageRequest,
   socket: net.Socket,
   ctx: HandlerContext,
-): void {
+): Promise<void> {
   const callerSessionId = ctx.socketToSession.get(socket);
   if (!callerSessionId) {
     log.warn({ subagentId: msg.subagentId }, 'Message rejected: socket has no bound session');
@@ -110,7 +110,7 @@ export function handleSubagentMessage(
     return;
   }
 
-  const result = manager.sendMessage(msg.subagentId, msg.content);
+  const result = await manager.sendMessage(msg.subagentId, msg.content);
 
   if (result === 'queue_full') {
     log.warn({ subagentId: msg.subagentId }, 'Subagent message rejected — queue full');

package/src/daemon/handlers/work-items.ts

@@ -454,9 +454,9 @@ export async function handleWorkItemRunTask(
             title: workItem.title,
           });
           // Wire the taskRunId so the executor can retrieve ephemeral permission rules
-          (session as unknown as { taskRunId?: string }).taskRunId = taskRunId;
+          session.taskRunId = taskRunId;
           // Prevent interactive clients from rebinding to this session mid-run
-          (session as unknown as { headlessLock: boolean }).headlessLock = true;
+          session.headlessLock = true;
         }
         await session.processMessage(message, [], (event) => {
           ctx.broadcast(event);
@@ -465,8 +465,10 @@ export async function handleWorkItemRunTask(
     );
 
     // Release the headless lock now that the task run is done
-    if (session) {
-      (session as unknown as { headlessLock: boolean }).headlessLock = false;
+    // (TS can't track that session is mutated inside the closure above)
+    const doneSession = session as { headlessLock: boolean } | null;
+    if (doneSession) {
+      doneSession.headlessLock = false;
     }
 
     // Don't overwrite cancelled status — the cancel handler already set it
@@ -485,8 +487,9 @@ export async function handleWorkItemRunTask(
     ctx.broadcast({ type: 'tasks_changed' });
   } catch (err) {
     // Release the headless lock on failure
-    if (session) {
-      (session as unknown as { headlessLock: boolean }).headlessLock = false;
+    const errSession = session as { headlessLock: boolean } | null;
+    if (errSession) {
+      errSession.headlessLock = false;
     }
     log.error({ err, workItemId: msg.id }, 'work_item_run_task failed');
     updateWorkItem(msg.id, {
@@ -610,7 +613,7 @@ export function handleWorkItemCancel(
   if (conversationId) {
     const session = ctx.sessions.get(conversationId);
     if (session) {
-      (session as unknown as { headlessLock: boolean }).headlessLock = false;
+      session.headlessLock = false;
       session.abort();
       getSubagentManager().abortAllForParent(conversationId);
     }

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

@@ -91,6 +91,8 @@ export interface GuardianVerificationRequest {
   rebind?: boolean;  // When true, allows creating a challenge even if a binding already exists
   /** E.164 phone number for SMS/voice, Telegram handle/chat-id. Used by outbound actions. */
   destination?: string;
+  /** Origin conversation ID so completion/failure pointers can route back. */
+  originConversationId?: string;
 }
 
 export interface TwitterAuthStartRequest {
@@ -332,6 +334,11 @@ export interface OpenUrl {
   title?: string;
 }
 
+export interface NavigateSettings {
+  type: 'navigate_settings';
+  tab: string;
+}
+
 // --- Domain-level union aliases (consumed by the barrel file) ---
 
 export type _IntegrationsClientMessages =
@@ -367,4 +374,5 @@ export type _IntegrationsServerMessages =
   | IntegrationListResponse
   | IntegrationConnectResult
   | OAuthConnectResultResponse
-  | OpenUrl;
+  | OpenUrl
+  | NavigateSettings;

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

@@ -19,6 +19,10 @@ export interface UserMessage {
   channel?: ChannelId;
   /** Originating interface identifier (e.g. 'macos'). */
   interface: InterfaceId;
+  /** Push-to-talk activation key configured on the client (e.g. 'fn', 'ctrl', 'fn_shift', 'none'). */
+  pttActivationKey?: string;
+  /** Whether the client has been granted microphone permission by the OS. */
+  microphonePermissionGranted?: boolean;
   /** Structured command intent — bypasses text parsing when present. */
   commandIntent?: CommandIntent;
 }

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

@@ -213,7 +213,7 @@ export interface AssistantAttention {
 
 export interface SessionListResponse {
   type: 'session_list_response';
-  sessions: Array<{ id: string; title: string; updatedAt: number; threadType?: ThreadType; source?: string; channelBinding?: ChannelBinding; conversationOriginChannel?: ChannelId; conversationOriginInterface?: InterfaceId; assistantAttention?: AssistantAttention }>;
+  sessions: Array<{ id: string; title: string; createdAt: number; updatedAt: number; threadType?: ThreadType; source?: string; channelBinding?: ChannelBinding; conversationOriginChannel?: ChannelId; conversationOriginInterface?: InterfaceId; assistantAttention?: AssistantAttention }>;
   /** Whether more sessions exist beyond the returned page. */
   hasMore?: boolean;
 }

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

@@ -0,0 +1,26 @@
+// Client settings: daemon-pushed configuration updates to connected clients.
+
+// === Client → Server ===
+
+/** Request from a session or IPC client to change the voice activation key. */
+export interface VoiceConfigUpdateRequest {
+  type: 'voice_config_update';
+  /** The desired activation key (enum value or natural-language name). */
+  activationKey: string;
+}
+
+// === Server → Client ===
+
+/** Sent by the daemon to update a client-side setting (e.g. activation key). */
+export interface ClientSettingsUpdate {
+  type: 'client_settings_update';
+  /** The setting key to update (e.g. "activationKey"). */
+  key: string;
+  /** The new value for the setting. */
+  value: string;
+}
+
+// --- Domain-level union aliases (consumed by the barrel file) ---
+
+export type _SettingsClientMessages = VoiceConfigUpdateRequest;
+export type _SettingsServerMessages = ClientSettingsUpdate;

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

@@ -45,4 +45,6 @@ export interface UserMessageAttachment {
   sizeBytes?: number;
   /** Base64-encoded JPEG thumbnail. Generated server-side for video attachments. */
   thumbnailData?: string;
+  /** Absolute path to the local file on disk. Present for file-backed attachments (e.g. recordings). */
+  filePath?: string;
 }

package/src/daemon/ipc-contract/work-items.ts

@@ -181,11 +181,6 @@ export interface WorkItemCancelResponse {
   error?: string;
 }
 
-/** Server push — tells the client to open/focus the tasks window. */
-export interface OpenTasksWindow {
-  type: 'open_tasks_window';
-}
-
 /** Server push — lightweight invalidation signal: the task queue has been mutated, refetch your list. */
 export interface TasksChanged {
   type: 'tasks_changed';
@@ -240,5 +235,4 @@ export type _WorkItemsServerMessages =
   | WorkItemCancelResponse
   | WorkItemStatusChanged
   | TaskRunThreadCreated
-  | TasksChanged
-  | OpenTasksWindow;
+  | TasksChanged;

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

@@ -13,6 +13,7 @@
     "_ParentalControlClientMessages",
     "_SchedulesClientMessages",
     "_SessionsClientMessages",
+    "_SettingsClientMessages",
     "_SkillsClientMessages",
     "_SubagentsClientMessages",
     "_SurfacesClientMessages",
@@ -36,6 +37,7 @@
     "_ParentalControlServerMessages",
     "_SchedulesServerMessages",
     "_SessionsServerMessages",
+    "_SettingsServerMessages",
     "_SkillsServerMessages",
     "_SubagentsServerMessages",
     "_SurfacesServerMessages",
@@ -176,6 +178,7 @@
     "usage_request",
     "user_message",
     "vercel_api_config",
+    "voice_config_update",
     "watch_observation",
     "work_item_approve_permissions",
     "work_item_cancel",
@@ -213,6 +216,7 @@
     "browser_interactive_mode_changed",
     "bundle_app_response",
     "channel_readiness_response",
+    "client_settings_update",
     "confirmation_request",
     "context_compacted",
     "conversation_search_response",
@@ -259,11 +263,11 @@
     "message_queued",
     "message_queued_deleted",
     "model_info",
+    "navigate_settings",
     "notification_intent",
     "notification_thread_created",
     "oauth_connect_result",
     "open_bundle_response",
-    "open_tasks_window",
     "open_url",
     "pairing_approval_request",
     "parental_control_get_response",

package/src/daemon/ipc-contract.ts

@@ -27,6 +27,7 @@ export * from './ipc-contract/pairing.js';
 export * from './ipc-contract/parental-control.js';
 export * from './ipc-contract/schedules.js';
 export * from './ipc-contract/sessions.js';
+export * from './ipc-contract/settings.js';
 export * from './ipc-contract/shared.js';
 export * from './ipc-contract/skills.js';
 export * from './ipc-contract/subagents.js';
@@ -50,6 +51,7 @@ import type { _PairingClientMessages, _PairingServerMessages } from './ipc-contr
 import type { _ParentalControlClientMessages, _ParentalControlServerMessages } from './ipc-contract/parental-control.js';
 import type { _SchedulesClientMessages, _SchedulesServerMessages } from './ipc-contract/schedules.js';
 import type { _SessionsClientMessages, _SessionsServerMessages } from './ipc-contract/sessions.js';
+import type { _SettingsClientMessages, _SettingsServerMessages } from './ipc-contract/settings.js';
 import type { _SkillsClientMessages, _SkillsServerMessages } from './ipc-contract/skills.js';
 import type { _SubagentsClientMessages, _SubagentsServerMessages } from './ipc-contract/subagents.js';
 import type { _SurfacesClientMessages, _SurfacesServerMessages } from './ipc-contract/surfaces.js';
@@ -87,7 +89,8 @@ export type ClientMessage =
   | _ParentalControlClientMessages
   | _InboxClientMessages
   | _PairingClientMessages
-  | _NotificationsClientMessages;
+  | _NotificationsClientMessages
+  | _SettingsClientMessages;
 
 // === Server -> Client aggregate union ===
 
@@ -107,6 +110,7 @@ export type ServerMessage =
   | _MemoryServerMessages
   | _WorkspaceServerMessages
   | _SchedulesServerMessages
+  | _SettingsServerMessages
   | _DiagnosticsServerMessages
   | _ParentalControlServerMessages
   | _InboxServerMessages