@vellumai/assistant 0.6.3 → 0.6.4

package/src/daemon/message-types/skills.ts

@@ -1,5 +1,10 @@
 // Skill management types.
 
+import type { PartnerAudit } from "../../skills/skillssh-registry.js";
+
+// Re-export so consumers can access the audit types from this module.
+export type { PartnerAudit } from "../../skills/skillssh-registry.js";
+
 // === Client → Server ===
 
 export interface SkillsListRequest {
@@ -98,6 +103,7 @@ interface ClawhubSlimSkill extends SlimSkillBase {
   installs: number;
   reports: number;
   publishedAt?: string;
+  version: string;
 }
 
 interface SkillsshSlimSkill extends SlimSkillBase {
@@ -105,6 +111,7 @@ interface SkillsshSlimSkill extends SlimSkillBase {
   slug: string;
   sourceRepo: string;
   installs: number;
+  audit?: Record<string, PartnerAudit>;
 }
 
 interface CustomSlimSkill extends SlimSkillBase {
@@ -122,6 +129,13 @@ export interface SkillsListResponse {
   skills: SlimSkillResponse[];
 }
 
+export interface SkillsListFilteredResponse {
+  type: "skills_list_response";
+  skills: SlimSkillResponse[];
+  categoryCounts: Record<string, number>;
+  totalCount: number;
+}
+
 export interface SkillStateChanged {
   type: "skills_state_changed";
   name: string;
@@ -159,6 +173,7 @@ interface ClawhubSkillDetail extends SkillDetailBase {
   installs: number;
   reports: number;
   publishedAt?: string;
+  version: string;
   // Enrichment fields (from clawhubInspect):
   owner?: { handle: string; displayName: string; image?: string } | null;
   stats?: {
@@ -177,6 +192,7 @@ interface SkillsshSkillDetail extends SkillDetailBase {
   slug: string;
   sourceRepo: string;
   installs: number;
+  audit?: Record<string, PartnerAudit>;
 }
 
 interface CustomSkillDetail extends SkillDetailBase {

package/src/daemon/message-types/surfaces.ts

@@ -184,6 +184,8 @@ interface UiSurfaceShowBase {
   display?: "inline" | "panel";
   /** The message ID that this surface belongs to (for history loading). */
   messageId?: string;
+  /** When `true`, clicking an action does not dismiss the surface — the client keeps the card visible and only marks the clicked `actionId` as spent so siblings remain clickable. */
+  persistent?: boolean;
 }
 
 export interface UiSurfaceShowCard extends UiSurfaceShowBase {

package/src/daemon/server.ts

@@ -7,6 +7,7 @@ import {
   setBroadcastToAllClients,
 } from "../acp/index.js";
 import { enrichMessageWithSourcePaths } from "../agent/attachments.js";
+import type { AgentEvent } from "../agent/loop.js";
 import {
   createAssistantMessage,
   createUserMessage,
@@ -23,7 +24,9 @@ import { getConfig } from "../config/loader.js";
 import { onContactChange } from "../contacts/contact-events.js";
 import type { CesClient } from "../credential-execution/client.js";
 import type { CesProcessManager } from "../credential-execution/process-manager.js";
+import type { FilingService } from "../filing/filing-service.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
+import { CliIpcServer } from "../ipc/cli-server.js";
 import { getApp, getAppDirPath, isMultifileApp } from "../memory/app-store.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
 import {
@@ -39,11 +42,19 @@ import {
   setConversationOriginChannelIfUnset,
   setConversationOriginInterfaceIfUnset,
 } from "../memory/conversation-crud.js";
-import { updateMetaFile } from "../memory/conversation-disk-view.js";
+import {
+  syncMessageToDisk,
+  updateMetaFile,
+} from "../memory/conversation-disk-view.js";
 import { getOrCreateConversation } from "../memory/conversation-key-store.js";
+import { syncIdentityNameToPlatform } from "../platform/sync-identity.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
 import { getProvider, initializeProviders } from "../providers/registry.js";
+import {
+  registerDefaultWakeResolver,
+  type WakeTarget,
+} from "../runtime/agent-wake.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
@@ -59,6 +70,7 @@ import { appendEventToStream } from "../signals/event-stream.js";
 import { registerUserMessageCallback } from "../signals/user-message.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { summarizeToolInput } from "../tools/tool-input-summary.js";
+import { createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import {
   getAvatarImagePath,
@@ -77,6 +89,7 @@ import {
   DEFAULT_MEMORY_POLICY,
 } from "./conversation.js";
 import { ConversationEvictor } from "./conversation-evictor.js";
+import { registerLaunchConversationDeps } from "./conversation-launch.js";
 import { formatCompactResult } from "./conversation-process.js";
 import { resolveChannelCapabilities } from "./conversation-runtime-assembly.js";
 import { resolveSlash, type SlashContext } from "./conversation-slash.js";
@@ -288,6 +301,7 @@ export class DaemonServer {
   // Composed subsystems
   private configWatcher = new ConfigWatcher();
   private appSourceWatcher = new AppSourceWatcher();
+  private cliIpc = new CliIpcServer();
 
   // CES (Credential Execution Service) — process-level singleton.
   // Lifecycle is managed by startCesProcess() in lifecycle.ts; the server
@@ -364,6 +378,17 @@ export class DaemonServer {
     return this._heartbeatService;
   }
 
+  /** Optional filing service reference for "Run Now" from the UI. */
+  private _filingService?: FilingService;
+
+  setFilingService(service: FilingService): void {
+    this._filingService = service;
+  }
+
+  getFilingService(): FilingService | undefined {
+    return this._filingService;
+  }
+
   private deriveMemoryPolicy(conversationId: string): ConversationMemoryPolicy {
     const conversationType = getConversationType(conversationId);
     if (conversationType === "private") {
@@ -545,11 +570,32 @@ export class DaemonServer {
         emoji: fields.emoji,
         home: fields.home,
       });
+
+      // Best-effort sync of the assistant name to the platform record.
+      if (fields.name) {
+        syncIdentityNameToPlatform(fields.name);
+      }
     } catch (err) {
       log.error({ err }, "Failed to broadcast identity change");
     }
   }
 
+  /** Best-effort sync of the IDENTITY.md name to the platform record. */
+  private syncIdentityToPlatform(): void {
+    try {
+      const identityPath = getWorkspacePromptPath("IDENTITY.md");
+      const content = existsSync(identityPath)
+        ? readFileSync(identityPath, "utf-8")
+        : "";
+      const fields = parseIdentityFields(content);
+      if (fields.name) {
+        syncIdentityNameToPlatform(fields.name);
+      }
+    } catch (err) {
+      log.error({ err }, "Failed to sync identity to platform at startup");
+    }
+  }
+
   private broadcastConfigChanged(): void {
     this.broadcast({ type: "config_changed" });
   }
@@ -626,7 +672,13 @@ export class DaemonServer {
       const conversation = this.conversations.get(conversationId);
       if (!conversation) return false;
       this.evictor.touch(conversationId);
-      conversation.abort();
+      conversation.abort(
+        createAbortReason(
+          "signal_cancel",
+          "registerCancelCallback",
+          conversationId,
+        ),
+      );
       getSubagentManager().abortAllForParent(conversationId);
       return true;
     });
@@ -753,6 +805,56 @@ export class DaemonServer {
       return { accepted: true };
     });
 
+    // Install the default resolver for `wakeAgentForOpportunity()` so
+    // internal subsystems (e.g. the Meet chat-opportunity detector wired
+    // up in `MeetSessionManager`) can invoke it without having to build
+    // a `WakeTarget` adapter themselves. The adapter wraps a live
+    // `Conversation` fetched from the in-memory map / hydrated from the
+    // DB, exposing only the narrow surface the wake helper needs.
+    registerDefaultWakeResolver(async (conversationId) => {
+      try {
+        const conversation = await this.getOrCreateConversation(conversationId);
+        return conversationToWakeTarget(conversation);
+      } catch (err) {
+        log.warn(
+          { err, conversationId },
+          "agent-wake default resolver: failed to hydrate conversation",
+        );
+        return null;
+      }
+    });
+
+    // Start the CLI IPC server. Built-in methods (wake_conversation) are
+    // registered by the constructor; CLI commands connect to this socket to
+    // invoke daemon-side operations that require in-process state.
+    this.cliIpc.start();
+
+    // Wire the launchConversation helper to daemon-side state so
+    // handleSurfaceAction can spawn conversations through it.
+    registerLaunchConversationDeps({
+      getOrCreateConversation: (id, options) =>
+        this.getOrCreateConversation(id, options),
+      persistAndProcessMessage: (
+        conversationId,
+        content,
+        attachmentIds,
+        options,
+        sourceChannel,
+        sourceInterface,
+      ) =>
+        this.persistAndProcessMessage(
+          conversationId,
+          content,
+          attachmentIds,
+          options,
+          sourceChannel,
+          sourceInterface,
+        ),
+      publishAssistantEvent: (msg, conversationId) =>
+        this.publishAssistantEvent(msg, conversationId),
+      getAssistantId: () => this.assistantId,
+    });
+
     this.configWatcher.start(
       () => this.evictConversationsForReload(),
       () => this.broadcastIdentityChanged(),
@@ -762,6 +864,8 @@ export class DaemonServer {
       () => this.broadcastFeatureFlagsChanged(),
     );
 
+    this.syncIdentityToPlatform();
+
     this.appSourceWatcher.start((appId) => this.handleAppSourceChange(appId));
 
     // Broadcast contacts_changed to all clients when any contact mutation occurs.
@@ -778,6 +882,7 @@ export class DaemonServer {
     this.evictor.stop();
     this.configWatcher.stop();
     this.appSourceWatcher.stop();
+    this.cliIpc.stop();
     if (this.unsubscribeContactChange) {
       this.unsubscribeContactChange();
       this.unsubscribeContactChange = null;
@@ -959,6 +1064,9 @@ export class DaemonServer {
           memoryPolicy,
           sharedCesClient,
           storedOptions?.speed,
+          undefined,
+          storedOptions?.modelIntent,
+          storedOptions?.modelOverride,
         );
         newConversation.updateClient(sendToClient, true);
         await newConversation.loadFromDb();
@@ -997,6 +1105,15 @@ export class DaemonServer {
       // overwrite the in-flight conversation's transportHints.
       if (!conversation.isProcessing()) {
         this.applyTransportMetadata(conversation, options);
+        // trustContext is reapplied here only when the conversation is idle,
+        // so concurrent requests cannot overwrite an in-flight turn's guardian
+        // scope. Direct callers (e.g. schedule-routes run-now) that invoke
+        // processMessage without going through prepareConversationForMessage
+        // rely on this to pick up the trustContext passed in options.
+        // prepareConversationForMessage also reapplies after its own idle check.
+        if (options?.trustContext !== undefined) {
+          conversation.setTrustContext(options.trustContext);
+        }
       }
       this.evictor.touch(conversationId);
     }
@@ -1584,3 +1701,231 @@ function extractConversationId(msg: ServerMessage): string | undefined {
   }
   return undefined;
 }
+
+/**
+ * Translate a raw {@link AgentEvent} from the agent loop into the
+ * corresponding {@link ServerMessage} wire frame. The normal user-turn
+ * path does this via the full state-aware handler in
+ * `conversation-agent-loop-handlers.ts`; the wake path has no tool
+ * accounting, title generation, or activity-state tracking to worry
+ * about, so we only need the subset that produces client-visible
+ * frames. Events that have no client-visible wire shape (usage, error,
+ * preview/input-json deltas, etc.) are dropped — they produce no UI.
+ *
+ * Keeping this translator co-located with the wake adapter preserves
+ * the runtime/daemon layering: `runtime/agent-wake.ts` never imports
+ * `message-protocol.ts` or wire shapes, and the daemon owns all
+ * translation from agent-loop semantics to client frames.
+ */
+function translateAgentEventToServerMessage(
+  event: AgentEvent,
+  conversationId: string,
+): ServerMessage | null {
+  switch (event.type) {
+    case "text_delta":
+      return {
+        type: "assistant_text_delta",
+        text: event.text,
+        conversationId,
+      };
+    case "thinking_delta":
+      return {
+        type: "assistant_thinking_delta",
+        thinking: event.thinking,
+        conversationId,
+      };
+    case "tool_use":
+      return {
+        type: "tool_use_start",
+        toolName: event.name,
+        input: event.input,
+        conversationId,
+        toolUseId: event.id,
+      };
+    case "tool_use_preview_start":
+      return {
+        type: "tool_use_preview_start",
+        toolUseId: event.toolUseId,
+        toolName: event.toolName,
+        conversationId,
+      };
+    case "tool_output_chunk":
+      return {
+        type: "tool_output_chunk",
+        chunk: event.chunk,
+        conversationId,
+        toolUseId: event.toolUseId,
+      };
+    case "tool_result": {
+      const imageBlocks = event.contentBlocks?.filter(
+        (b): b is Extract<typeof b, { type: "image" }> => b.type === "image",
+      );
+      const imageDataList = imageBlocks?.length
+        ? imageBlocks.map((b) => b.source.data)
+        : undefined;
+      return {
+        type: "tool_result",
+        toolName: "",
+        result: event.content,
+        isError: event.isError,
+        diff: event.diff,
+        status: event.status,
+        conversationId,
+        imageData: imageDataList?.[0],
+        imageDataList,
+        toolUseId: event.toolUseId,
+      };
+    }
+    case "server_tool_start":
+      return {
+        type: "tool_use_start",
+        toolName: event.name,
+        input: event.input,
+        conversationId,
+        toolUseId: event.toolUseId,
+      };
+    case "server_tool_complete": {
+      let resultText = "";
+      if (Array.isArray(event.content) && event.content.length > 0) {
+        resultText = (event.content as unknown[])
+          .filter(
+            (r): r is { type: string; title: string; url: string } =>
+              typeof r === "object" &&
+              r != null &&
+              (r as { type?: string }).type === "web_search_result",
+          )
+          .map((r) => `${r.title}\n${r.url}`)
+          .join("\n\n");
+      }
+      return {
+        type: "tool_result",
+        toolName: "web_search",
+        result: resultText,
+        isError: event.isError,
+        conversationId,
+        toolUseId: event.toolUseId,
+      };
+    }
+    case "message_complete":
+      return {
+        type: "message_complete",
+        conversationId,
+      };
+    // No wire frame for these — usage/error/input_json_delta are either
+    // server-internal (accounting/classification) or app-only debug
+    // streams the client doesn't surface for wake-originated turns.
+    case "input_json_delta":
+    case "usage":
+    case "error":
+      return null;
+  }
+}
+
+/**
+ * Adapt a live {@link Conversation} to the narrow {@link WakeTarget}
+ * surface expected by `wakeAgentForOpportunity()`. Kept here so the
+ * runtime-level wake helper stays decoupled from the heavyweight
+ * conversation class (see `registerDefaultWakeResolver` above).
+ *
+ * Routing notes:
+ *   - `emitAgentEvent` dispatches via `broadcastToAllClients` rather
+ *     than `sendToClient`. Several signal-injected paths reset
+ *     `sendToClient` to a no-op in their `finally` blocks (see the
+ *     `updateClient(() => {}, true)` calls in `persistAndProcessMessage`
+ *     / `processMessage`), so a wake fired on such a conversation would
+ *     find a silent sink. `broadcastToAllClients` is wired to
+ *     `this.broadcast(msg)` at construction time and always reaches the
+ *     hub, regardless of which sender the most-recent user turn left
+ *     behind.
+ *   - `persistTailMessage` mirrors the canonical user-turn handlers
+ *     (`handleMessageComplete` / the tool-result block in
+ *     `conversation-agent-loop-handlers.ts`): builds channel/interface
+ *     metadata via `provenanceFromTrustContext` plus the live turn
+ *     channel/interface contexts, persists with metadata, and syncs the
+ *     resulting row to the disk view so wake-produced messages appear
+ *     in the on-disk transcript and carry provenance tags.
+ *   - `drainQueue` delegates to the conversation so any user messages
+ *     queued while the wake was running are processed. The wake helper
+ *     calls this in its finally AFTER `markProcessing(false)`; the
+ *     order matters because `enqueueMessage` only queues when
+ *     `processing === true`.
+ */
+function conversationToWakeTarget(conversation: Conversation): WakeTarget {
+  return {
+    conversationId: conversation.conversationId,
+    agentLoop: conversation.agentLoop,
+    getMessages: () => conversation.getMessages(),
+    pushMessage: (msg) => {
+      conversation.messages.push(msg);
+    },
+    emitAgentEvent: (event) => {
+      const frame = translateAgentEventToServerMessage(
+        event,
+        conversation.conversationId,
+      );
+      if (!frame) return;
+      // Prefer `broadcastToAllClients` (wired to the hub at construction
+      // time and always live) over `sendToClient` (which several
+      // signal-injected paths reset to `() => {}` in their finally
+      // blocks). Fall back to `sendToClient` when the broadcaster is
+      // missing (e.g. in tests that construct a Conversation directly).
+      if (conversation.broadcastToAllClients) {
+        conversation.broadcastToAllClients(frame);
+      } else {
+        conversation.sendToClient(frame);
+      }
+    },
+    isProcessing: () => conversation.isProcessing(),
+    markProcessing: (on) => {
+      conversation.processing = on;
+    },
+    persistTailMessage: async (message) => {
+      // Build metadata that mirrors the canonical handlers in
+      // `conversation-agent-loop-handlers.ts`. If the live turn channel
+      // / interface contexts are missing (a wake can fire on a
+      // conversation that has never run a user turn), fall back to the
+      // conversation's origin channel/interface defaults (`"vellum"`)
+      // so persisted rows still carry valid channel/interface ids.
+      const turnChannelCtx = conversation.getTurnChannelContext();
+      const turnInterfaceCtx = conversation.getTurnInterfaceContext();
+      const metadata: Record<string, unknown> = {
+        ...provenanceFromTrustContext(conversation.trustContext),
+        userMessageChannel: turnChannelCtx?.userMessageChannel ?? "vellum",
+        assistantMessageChannel:
+          turnChannelCtx?.assistantMessageChannel ?? "vellum",
+        userMessageInterface:
+          turnInterfaceCtx?.userMessageInterface ?? "vellum",
+        assistantMessageInterface:
+          turnInterfaceCtx?.assistantMessageInterface ?? "vellum",
+      };
+      const persisted = await addMessage(
+        conversation.conversationId,
+        message.role,
+        JSON.stringify(message.content),
+        metadata,
+      );
+      // Sync the persisted row to the disk view so wake-produced
+      // messages appear in the on-disk transcript and tools that read
+      // from disk (e.g. `messages.jsonl`-based diagnostics) see them.
+      // Mirrors the `syncMessageToDisk(...)` calls in the canonical
+      // handlers — best-effort because a sync failure must not strand
+      // the in-memory tail.
+      try {
+        const convRow = getConversation(conversation.conversationId);
+        if (convRow) {
+          syncMessageToDisk(
+            conversation.conversationId,
+            persisted.id,
+            convRow.createdAt,
+          );
+        }
+      } catch (err) {
+        log.warn(
+          { err, conversationId: conversation.conversationId },
+          "wake adapter: syncMessageToDisk failed (non-fatal)",
+        );
+      }
+    },
+    drainQueue: () => conversation.drainQueue(),
+  };
+}

package/src/daemon/shutdown-handlers.ts

@@ -1,5 +1,6 @@
 import * as Sentry from "@sentry/node";
 
+import type { BackupWorkerHandle } from "../backup/backup-worker.js";
 import type { FilingService } from "../filing/filing-service.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import type { HookManager } from "../hooks/manager.js";
@@ -13,6 +14,7 @@ import { getLogger } from "../util/logger.js";
 import { getEnrichmentService } from "../workspace/commit-message-enrichment-service.js";
 import type { WorkspaceHeartbeatService } from "../workspace/heartbeat-service.js";
 import type { DaemonServer } from "./server.js";
+import { runShutdownHooks } from "./shutdown-registry.js";
 
 const log = getLogger("lifecycle");
 
@@ -24,7 +26,9 @@ export interface ShutdownDeps {
   hookManager: HookManager;
   runtimeHttp: RuntimeHttpServer | null;
   scheduler: { stop(): void };
+  feedScheduler: { stop(): void } | null;
   getMemoryWorker: () => { stop(): void } | null;
+  getBackupWorker: () => BackupWorkerHandle | null;
   getQdrantManager: () => QdrantManager | null;
   mcpManager: McpServerManager | null;
   telemetryReporter: { stop(): Promise<void> } | null;
@@ -45,11 +49,18 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     // 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.
+    //
+    // 20s budget: 15s reserved for Meet session teardown
+    // (`MeetSessionManager.shutdownAll`), plus ~5s for the remaining
+    // daemon work (workspace commits, server drain, enrichment, telemetry,
+    // mcp, qdrant, sqlite checkpoint). Without a live Meet session the
+    // rest of the shutdown routinely completes in under a second, so this
+    // bump only changes behavior for the stuck-shutdown path.
     const forceTimer = setTimeout(() => {
       log.warn("Graceful shutdown timed out, forcing exit");
       deps.cleanupPidFile();
       process.exit(1);
-    }, 10_000);
+    }, 20_000);
     forceTimer.unref();
 
     await deps.workspaceHeartbeat.stop();
@@ -62,6 +73,15 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
       // Don't let hook failures block shutdown
     }
 
+    // Run registered skill shutdown hooks (e.g. meet-join session teardown)
+    // before stopping the server so any HTTP round-trips and SSE emissions
+    // still have live transports.
+    try {
+      await runShutdownHooks("daemon-shutdown");
+    } catch (err) {
+      log.warn({ err }, "Skill shutdown hooks failed (non-fatal)");
+    }
+
     // Commit any uncommitted workspace changes before stopping the server.
     // This ensures no workspace state is lost during graceful shutdown.
     try {
@@ -111,7 +131,9 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     await browserManager.closeAllPages();
     cleanupShellOutputTempFiles();
     deps.scheduler.stop();
+    deps.feedScheduler?.stop();
     deps.getMemoryWorker()?.stop();
+    deps.getBackupWorker()?.stop();
 
     if (deps.mcpManager) {
       try {
@@ -123,9 +145,15 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
 
     await deps.getQdrantManager()?.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).
+    // Optimize query planner statistics before closing so they persist for
+    // the next session. Checkpoint WAL and close SQLite so no writes are
+    // lost on exit. Each step is in its own try block so later steps still
+    // run if an earlier one throws (e.g. SQLITE_BUSY).
+    try {
+      getSqlite().exec("PRAGMA optimize");
+    } catch (err) {
+      log.warn({ err }, "PRAGMA optimize at shutdown failed (non-fatal)");
+    }
     try {
       getSqlite().exec("PRAGMA wal_checkpoint(TRUNCATE)");
     } catch (err) {

package/src/daemon/shutdown-registry.ts

@@ -0,0 +1,40 @@
+/**
+ * Registry for skill shutdown hooks.
+ *
+ * Skills register async shutdown callbacks at initialization time. The daemon
+ * calls {@link runShutdownHooks} during graceful shutdown so skill-owned
+ * resources (containers, sockets, etc.) are torn down before the process exits.
+ */
+
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("shutdown-registry");
+
+type ShutdownHook = (reason: string) => Promise<void>;
+
+const hooks = new Map<string, ShutdownHook>();
+
+/**
+ * Register a named shutdown hook. Called by skills at initialization time.
+ * If a hook with the same name already exists it is silently replaced (supports
+ * hot-reload).
+ */
+export function registerShutdownHook(name: string, hook: ShutdownHook): void {
+  hooks.set(name, hook);
+  log.info({ name }, "Shutdown hook registered");
+}
+
+/**
+ * Run all registered shutdown hooks. Each hook receives a human-readable
+ * `reason` string (e.g. "daemon-shutdown"). Failures are logged but do not
+ * prevent other hooks from running.
+ */
+export async function runShutdownHooks(reason: string): Promise<void> {
+  for (const [name, hook] of hooks) {
+    try {
+      await hook(reason);
+    } catch (err) {
+      log.warn({ err, name }, `Shutdown hook "${name}" failed (non-fatal)`);
+    }
+  }
+}

package/src/daemon/tool-side-effects.ts

@@ -215,7 +215,9 @@ registerHook(
     const SETTING_TO_KEY: Record<string, string> = {
       activation_key: "pttActivationKey",
       tts_voice_id: "ttsVoiceId",
+      tts_provider: "ttsProvider",
       conversation_timeout: "voiceConversationTimeoutSeconds",
+      fish_audio_reference_id: "fishAudioReferenceId",
     };
     const key = SETTING_TO_KEY[setting];
     if (!key) return;
@@ -228,6 +230,13 @@ registerHook(
       coerced = typeof raw === "number" ? raw : Number(raw);
     } else if (setting === "tts_voice_id" && typeof raw === "string") {
       coerced = raw.trim();
+    } else if (
+      setting === "fish_audio_reference_id" &&
+      typeof raw === "string"
+    ) {
+      coerced = raw.trim();
+    } else if (setting === "tts_provider" && typeof raw === "string") {
+      coerced = raw.trim();
     }
     broadcastToAllClients?.({
       type: "client_settings_update",