@vellumai/assistant 0.7.0 → 0.7.1

package/src/backup/__tests__/restore.test.ts

@@ -31,6 +31,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
+import { defaultV1Options } from "../../runtime/migrations/__tests__/v1-test-helpers.js";
 import { buildVBundle } from "../../runtime/migrations/vbundle-builder.js";
 import type { PathResolver } from "../../runtime/migrations/vbundle-import-analyzer.js";
 import type {
@@ -78,11 +79,13 @@ const NULL_RESOLVER: PathResolver = {
  * the file path along with the manifest the builder embedded so tests can
  * compare against it.
  */
-function writeTinyPlaintextBundle(
-  fileName: string,
-): { path: string; manifest: ManifestType } {
+function writeTinyPlaintextBundle(fileName: string): {
+  path: string;
+  manifest: ManifestType;
+} {
   const { archive, manifest } = buildVBundle({
     files: [
+      { path: "data/db/assistant.db", data: new Uint8Array() },
       {
         path: "workspace/notes/hello.txt",
         data: new TextEncoder().encode("hello world"),
@@ -92,8 +95,7 @@ function writeTinyPlaintextBundle(
         data: new TextEncoder().encode("a tiny bundle for tests"),
       },
     ],
-    source: "restore-test",
-    description: "tiny bundle for restore.test.ts",
+    ...defaultV1Options(),
   });
 
   const path = join(TEST_DIR, fileName);
@@ -117,21 +119,35 @@ function makeStubCommitImpl(): {
   const calls: RecordedCall[] = [];
   const commitImpl = (options: ImportCommitOptions): ImportCommitResult => {
     calls.push({ options });
-    const manifest =
+    const manifest: ManifestType =
       options.preValidatedManifest ??
       ({
-        schema_version: "1.0",
+        schema_version: 1,
+        bundle_id: "00000000-0000-4000-8000-000000000000",
         created_at: new Date().toISOString(),
-        files: [],
-        manifest_sha256: "stub",
-      } satisfies ManifestType);
+        assistant: { id: "self", name: "Test", runtime_version: "0.0.0-test" },
+        origin: { mode: "self-hosted-local" },
+        compatibility: {
+          min_runtime_version: "0.0.0-test",
+          max_runtime_version: null,
+        },
+        contents: [],
+        checksum:
+          "0000000000000000000000000000000000000000000000000000000000000000",
+        secrets_redacted: false,
+        export_options: {
+          include_logs: false,
+          include_browser_state: false,
+          include_memory_vectors: false,
+        },
+      } as ManifestType);
     return {
       ok: true,
       report: {
         success: true,
         summary: {
-          total_files: manifest.files.length,
-          files_created: manifest.files.length,
+          total_files: manifest.contents.length,
+          files_created: manifest.contents.length,
           files_overwritten: 0,
           files_skipped: 0,
           backups_created: 0,
@@ -178,8 +194,9 @@ describe("verifySnapshot", () => {
     expect(result.valid).toBe(true);
     expect(result.manifest).toBeDefined();
     expect(result.error).toBeUndefined();
-    expect(result.manifest?.manifest_sha256).toBe(manifest.manifest_sha256);
-    expect(result.manifest?.files.length).toBe(2);
+    expect(result.manifest?.checksum).toBe(manifest.checksum);
+    // 3 = synthetic data/db/assistant.db + workspace/notes/hello.txt + workspace/notes/about.txt
+    expect(result.manifest?.contents.length).toBe(3);
   });
 
   test("encrypted: returns valid:true after decrypting first", async () => {
@@ -244,11 +261,13 @@ describe("verifySnapshot", () => {
     // validateVBundle catches the bad manifest.
     const { archive } = buildVBundle({
       files: [
+        { path: "data/db/assistant.db", data: new Uint8Array() },
         {
           path: "workspace/notes/hello.txt",
           data: new TextEncoder().encode("hello"),
         },
       ],
+      ...defaultV1Options(),
     });
 
     // Flip a few bytes in the middle of the gzipped archive — this almost
@@ -292,21 +311,19 @@ describe("restoreFromSnapshot", () => {
     const passed = calls[0].options;
     // The wrapper should pass the pre-validated manifest + entries so
     // commitImport doesn't re-validate.
-    expect(passed.preValidatedManifest?.manifest_sha256).toBe(
-      manifest.manifest_sha256,
-    );
+    expect(passed.preValidatedManifest?.checksum).toBe(manifest.checksum);
     expect(passed.preValidatedEntries).toBeDefined();
     expect(passed.preValidatedEntries?.has("manifest.json")).toBe(true);
-    expect(
-      passed.preValidatedEntries?.has("workspace/notes/hello.txt"),
-    ).toBe(true);
+    expect(passed.preValidatedEntries?.has("workspace/notes/hello.txt")).toBe(
+      true,
+    );
     // archiveData must be the actual bundle bytes.
     expect(passed.archiveData).toBeInstanceOf(Uint8Array);
     expect(passed.archiveData.length).toBeGreaterThan(0);
 
     // Public result is shaped correctly.
-    expect(result.manifest.manifest_sha256).toBe(manifest.manifest_sha256);
-    expect(result.restoredFiles).toBe(2);
+    expect(result.manifest.checksum).toBe(manifest.checksum);
+    expect(result.restoredFiles).toBe(3);
   });
 
   test("encrypted round-trip: decrypts then commits, and cleans up the temp file", async () => {
@@ -327,8 +344,8 @@ describe("restoreFromSnapshot", () => {
     const after = listRestoreTempArtifacts();
 
     expect(calls.length).toBe(1);
-    expect(result.manifest.manifest_sha256).toBe(manifest.manifest_sha256);
-    expect(result.restoredFiles).toBe(2);
+    expect(result.manifest.checksum).toBe(manifest.checksum);
+    expect(result.restoredFiles).toBe(3);
 
     // Decrypted temp file must be cleaned up after the call.
     expect(after.length).toBe(before.length);
@@ -377,6 +394,7 @@ describe("restoreFromSnapshot", () => {
     // the OS keychain / CES and are not part of the backup round trip.
     const { archive, manifest } = buildVBundle({
       files: [
+        { path: "data/db/assistant.db", data: new Uint8Array() },
         {
           path: "workspace/notes/hello.txt",
           data: new TextEncoder().encode("hello"),
@@ -386,6 +404,7 @@ describe("restoreFromSnapshot", () => {
           data: new TextEncoder().encode("sk-test-1234"),
         },
       ],
+      ...defaultV1Options(),
     });
 
     const path = join(TEST_DIR, "with-creds.vbundle");
@@ -399,7 +418,7 @@ describe("restoreFromSnapshot", () => {
 
     // The restore result must not expose a `credentials` field — the public
     // type only has `manifest` and `restoredFiles`.
-    expect(result.manifest.manifest_sha256).toBe(manifest.manifest_sha256);
+    expect(result.manifest.checksum).toBe(manifest.checksum);
     expect("credentials" in result).toBe(false);
   });
 
@@ -468,9 +487,7 @@ describe("restoreFromSnapshot", () => {
 
     // Stub that simulates a write failure (the importer returns this for
     // disk errors like permission denied or partial bundle writes).
-    const failingCommit = (
-      _opts: ImportCommitOptions,
-    ): ImportCommitResult => ({
+    const failingCommit = (_opts: ImportCommitOptions): ImportCommitResult => ({
       ok: false,
       reason: "write_failed",
       message: "disk full",

package/src/backup/backup-worker.ts

@@ -26,18 +26,24 @@
  * surface against temp directories with tiny fake bundles.
  */
 
+import { hostname } from "node:os";
 import { Database } from "bun:sqlite";
 
 import { getConfig } from "../config/loader.js";
 import type { BackupConfig } from "../config/schema.js";
+import { getAssistantName } from "../daemon/identity-helpers.js";
 import {
   getMemoryCheckpoint as realGetMemoryCheckpoint,
   setMemoryCheckpoint as realSetMemoryCheckpoint,
 } from "../memory/checkpoints.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import type { VBundleOriginMode } from "../runtime/migrations/origin-mode.js";
 import type { StreamExportVBundleResult } from "../runtime/migrations/vbundle-builder.js";
 import { streamExportVBundle as realStreamExportVBundle } from "../runtime/migrations/vbundle-builder.js";
+import { getDaemonRuntimeMode } from "../runtime/runtime-mode.js";
 import { getLogger } from "../util/logger.js";
 import { getDbPath, getWorkspaceDir } from "../util/platform.js";
+import { APP_VERSION } from "../version.js";
 import { ensureBackupKey as realEnsureBackupKey } from "./backup-key.js";
 import type { SnapshotEntry } from "./list-snapshots.js";
 import { pruneLocalSnapshots, writeLocalSnapshot } from "./local-writer.js";
@@ -185,10 +191,38 @@ async function performBackup(
   // mirrors the pattern in `handleMigrationExport`: open a fresh Database
   // handle, run PRAGMA wal_checkpoint(TRUNCATE), close it. Any failure is
   // best-effort — the export still proceeds with whatever is on disk.
+  //
+  // The backup worker bundles credentials by design (its purpose is local
+  // recovery), so `secretsRedacted: false`. Backups run locally on the host
+  // machine; managed deployments delegate to the platform. Hardcoding to
+  // self-hosted ensures the resulting bundle satisfies the v1 schema's
+  // refine for managed/secrets_redacted — `getOriginMode()` would return
+  // "managed" in a managed deployment, producing a non-restorable bundle.
+  const originMode: VBundleOriginMode =
+    getDaemonRuntimeMode() === "docker"
+      ? "self-hosted-remote"
+      : "self-hosted-local";
   const result = await streamExport({
     workspaceDir,
-    source: "backup-worker",
-    description: "Automated backup snapshot",
+    assistant: {
+      id: DAEMON_INTERNAL_ASSISTANT_ID,
+      name: getAssistantName() ?? "Assistant",
+      runtime_version: APP_VERSION,
+    },
+    origin: {
+      mode: originMode,
+      hostname: hostname(),
+    },
+    compatibility: {
+      min_runtime_version: APP_VERSION,
+      max_runtime_version: null,
+    },
+    exportOptions: {
+      include_logs: true,
+      include_browser_state: false,
+      include_memory_vectors: false,
+    },
+    secretsRedacted: false,
     checkpoint: () => {
       const dbPath = getDbPath();
       try {

package/src/backup/paths.ts

@@ -6,7 +6,7 @@ import {
   getBackupKeyPathOverride,
 } from "../config/env-registry.js";
 import type { BackupDestination } from "../config/schema.js";
-import { getProtectedDir } from "../util/platform.js";
+import { getWorkspaceDir } from "../util/platform.js";
 
 /**
  * Returns the backup root directory. Respects the `VELLUM_BACKUP_DIR`
@@ -134,13 +134,16 @@ export function resolveOffsiteDestinations(
 }
 
 /**
- * Returns the path to the backup encryption key file. By default this is
- * `~/.vellum/protected/backup.key`, but the `VELLUM_BACKUP_KEY_PATH` env var
- * can override it for containerized deployments where the key must live on a
- * persistent volume.
+ * Returns the path to the backup encryption key file.
+ *
+ * The `VELLUM_BACKUP_KEY_PATH` env var can override this for containerized
+ * deployments where the key must live on a persistent volume.
+ *
+ * TODO: The backup key is a credential and should eventually be managed by the
+ * gateway (behind IPC), not stored on the daemon's filesystem.
  */
 export function getBackupKeyPath(): string {
-  return getBackupKeyPathOverride() ?? join(getProtectedDir(), "backup.key");
+  return getBackupKeyPathOverride() ?? join(getWorkspaceDir(), ".backup.key");
 }
 
 /**

package/src/browser-session/events.ts

@@ -132,15 +132,6 @@ export function isTargetInvalidated(targetId: string): boolean {
   return invalidatedTargetIds.has(targetId);
 }
 
-/**
- * Test-only helper: snapshot the current invalidated set without
- * draining it. Exported so unit tests can assert exact set contents
- * across multiple frames; production code must not rely on this.
- */
-export function __peekInvalidatedTargetIdsForTests(): string[] {
-  return Array.from(invalidatedTargetIds);
-}
-
 /**
  * Atomically remove and return a target id from the invalidated set.
  * Returns `true` when the id was present (and has now been removed),

package/src/calls/call-store.ts

@@ -2,7 +2,7 @@ import { and, desc, eq, notInArray, or } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "../memory/db-connection.js";
-import { rawChanges, rawGet, rawRun } from "../memory/raw-query.js";
+import { rawChanges, rawRun } from "../memory/raw-query.js";
 import {
   callEvents,
   callPendingQuestions,
@@ -379,39 +379,6 @@ export function buildCallbackDedupeKey(
   return `${callSid}:${callStatus}:${discriminator}`;
 }
 
-/**
- * Check whether a callback dedupe key has already been processed (read-only).
- * Returns true if the key already exists, false otherwise.
- */
-export function isCallbackProcessed(dedupeKey: string): boolean {
-  return (
-    rawGet<{ 1: number }>(
-      `SELECT 1 FROM processed_callbacks WHERE dedupe_key = ?`,
-      dedupeKey,
-    ) != null
-  );
-}
-
-/**
- * Record a callback as processed. Should be called AFTER downstream writes
- * (session updates, event recording) have succeeded so that Twilio retries
- * are not silently dropped if those writes fail.
- *
- * Uses INSERT OR IGNORE so concurrent calls for the same key are safe.
- */
-export function recordProcessedCallback(
-  dedupeKey: string,
-  callSessionId: string,
-): void {
-  rawRun(
-    `INSERT OR IGNORE INTO processed_callbacks (id, dedupe_key, call_session_id, created_at) VALUES (?, ?, ?, ?)`,
-    uuid(),
-    dedupeKey,
-    callSessionId,
-    Date.now(),
-  );
-}
-
 /**
  * Atomically claim a callback for processing. Returns a unique claim ID
  * (string) if this caller won the claim, or null if another caller already

package/src/calls/guardian-question-copy.ts

@@ -6,18 +6,7 @@
  * when the provider is unavailable or generation fails/times out.
  */
 
-import {
-  createTimeout,
-  extractText,
-  resolveConfiguredProvider,
-  userMessage,
-} from "../providers/provider-send-message.js";
-import { getLogger } from "../util/logger.js";
-
-const log = getLogger("guardian-question-copy");
-
 /** Timeout for the generative copy call (ms). */
-const GENERATION_TIMEOUT_MS = 5_000;
 
 export interface GuardianCopy {
   conversationTitle: string;
@@ -39,100 +28,3 @@ export function buildFallbackCopy(questionText: string): GuardianCopy {
     ].join("\n"),
   };
 }
-
-/**
- * Generate guardian conversation copy (title + initial message) via the configured
- * LLM provider. Returns deterministic fallback when the provider is unavailable,
- * generation times out, or any error occurs.
- */
-export async function generateGuardianCopy(
-  questionText: string,
-  requestCode?: string,
-): Promise<GuardianCopy> {
-  const fallback = buildFallbackCopy(questionText);
-
-  // If no provider is configured, return fallback immediately
-  const resolved = await resolveConfiguredProvider("guardianQuestionCopy");
-  if (!resolved) {
-    log.debug(
-      "No provider available for guardian copy generation, using fallback",
-    );
-    return fallback;
-  }
-
-  const { signal, cleanup } = createTimeout(GENERATION_TIMEOUT_MS);
-
-  try {
-    const prompt = [
-      "Generate a conversation title and initial message for a guardian question during a live phone call.",
-      "",
-      `Question: ${questionText}`,
-      ...(requestCode ? [`Reference code: ${requestCode}`] : []),
-      "",
-      "Requirements:",
-      '- TITLE: An emoji-prefixed, attention-oriented, concise title (under 80 characters). Do NOT start with "Guardian question:". Use a relevant warning or alert emoji.',
-      "- MESSAGE: A clear initial message that includes the question text, mentions this is a live phone call waiting for the user's input, and asks them to reply with their answer.",
-      "",
-      "Respond in exactly this format (no extra text):",
-      "TITLE: <your title>",
-      "MESSAGE: <your message>",
-    ].join("\n");
-
-    const response = await resolved.provider.sendMessage(
-      [userMessage(prompt)],
-      undefined,
-      undefined,
-      { signal, config: { callSite: "guardianQuestionCopy" } },
-    );
-
-    const text = extractText(response);
-    const parsed = parseGeneratedCopy(text);
-
-    if (parsed) {
-      return parsed;
-    }
-
-    log.warn(
-      { raw: text },
-      "Failed to parse generated guardian copy, using fallback",
-    );
-    return fallback;
-  } catch (err) {
-    if (signal.aborted) {
-      log.warn("Guardian copy generation timed out, using fallback");
-    } else {
-      log.warn({ err }, "Guardian copy generation failed, using fallback");
-    }
-    return fallback;
-  } finally {
-    cleanup();
-  }
-}
-
-/**
- * Parse the structured TITLE/MESSAGE response from the model.
- * Returns null if the format is not matched.
- */
-function parseGeneratedCopy(text: string): GuardianCopy | null {
-  const titleMatch = text.match(/^TITLE:\s*(.+)/m);
-  const messageMatch = text.match(/^MESSAGE:\s*([\s\S]+)/m);
-
-  if (!titleMatch || !messageMatch) {
-    return null;
-  }
-
-  const title = titleMatch[1].trim();
-  const message = messageMatch[1].trim();
-
-  // Sanity checks: title must be non-empty and under 80 chars, message must be non-empty
-  if (!title || title.length > 80 || !message) {
-    return null;
-  }
-
-  // Reject the old static prefix — the model is guided towards better titles but has final say
-  if (/^guardian question:/i.test(title)) {
-    return null;
-  }
-
-  return { conversationTitle: title, initialMessage: message };
-}

package/src/calls/relay-server.ts

@@ -15,8 +15,6 @@ import {
   listGuardianChannels,
 } from "../contacts/contact-store.js";
 import {
-  createGuardianBinding,
-  revokeGuardianBinding,
   touchContactInteraction,
   upsertContactChannel,
 } from "../contacts/contacts-write.js";
@@ -998,28 +996,6 @@ export class RelayConnection {
         "Guardian voice verification succeeded",
       );
 
-      // Create the guardian binding now that verification succeeded.
-      if (result.verificationType === "guardian") {
-        if (result.bindingConflict) {
-          log.warn(
-            {
-              callSessionId: this.callSessionId,
-              existingGuardian: result.bindingConflict.existingGuardian,
-            },
-            "Guardian binding conflict: another user already holds the voice binding",
-          );
-        } else {
-          revokeGuardianBinding("phone");
-          createGuardianBinding({
-            channel: "phone",
-            guardianExternalUserId: fromNumber,
-            guardianDeliveryChatId: fromNumber,
-            guardianPrincipalId: result.canonicalPrincipal!,
-            verifiedVia: "challenge",
-          });
-        }
-      }
-
       if (isOutbound) {
         // Keep the pointer message back to the initiating conversation
         const successSession = getCallSession(this.callSessionId);

package/src/calls/twilio-rest.ts

@@ -210,44 +210,6 @@ export async function provisionPhoneNumber(
   };
 }
 
-/** Fetch the current status of a Twilio message by SID. */
-export async function fetchMessageStatus(
-  accountSid: string,
-  authToken: string,
-  messageSid: string,
-): Promise<{ status: string; errorCode?: string; errorMessage?: string }> {
-  const res = await fetch(
-    `${twilioBaseUrl(accountSid)}/Messages/${encodeURIComponent(
-      messageSid,
-    )}.json`,
-    {
-      method: "GET",
-      headers: { Authorization: twilioAuthHeader(accountSid, authToken) },
-    },
-  );
-
-  if (!res.ok) {
-    const text = await res.text();
-    throw new ProviderError(
-      `Twilio API error ${res.status}: ${text}`,
-      "twilio",
-      res.status,
-    );
-  }
-
-  const data = (await res.json()) as {
-    status?: string;
-    error_code?: number | null;
-    error_message?: string | null;
-  };
-
-  return {
-    status: data.status ?? "unknown",
-    errorCode: data.error_code != null ? String(data.error_code) : undefined,
-    errorMessage: data.error_message ?? undefined,
-  };
-}
-
 export interface WebhookUrls {
   voiceUrl: string;
   statusCallbackUrl: string;

package/src/calls/twilio-routes.ts

@@ -65,7 +65,7 @@ const log = getLogger("twilio-routes");
  * The gateway replaces this with a real JWT before returning TwiML to Twilio.
  * This keeps the signing key out of the daemon for voice webhook responses.
  */
-export const TWILIO_RELAY_TOKEN_PLACEHOLDER = "__VELLUM_RELAY_TOKEN__";
+const TWILIO_RELAY_TOKEN_PLACEHOLDER = "__VELLUM_RELAY_TOKEN__";
 
 // ── Speech config type ───────────────────────────────────────────────
 

package/src/calls/voice-session-bridge.ts

@@ -22,8 +22,7 @@ import type { Conversation } from "../daemon/conversation.js";
 import { resolveChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { TrustContext } from "../daemon/trust-context.js";
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
@@ -418,34 +417,6 @@ export async function startVoiceTurn(
     );
   }
 
-  // Serialized publish chain so hub subscribers observe events in order.
-  let hubChain: Promise<void> = Promise.resolve();
-  const publishToHub = (msg: ServerMessage): void => {
-    // ServerMessage is a large union; conversationId exists on most but not all variants.
-    const msgConversationId =
-      "conversationId" in msg &&
-      typeof (msg as { conversationId?: unknown }).conversationId === "string"
-        ? (msg as { conversationId: string }).conversationId
-        : undefined;
-    const resolvedConversationId = msgConversationId ?? opts.conversationId;
-    const event = buildAssistantEvent(
-      DAEMON_INTERNAL_ASSISTANT_ID,
-      msg,
-      resolvedConversationId,
-    );
-    hubChain = (async () => {
-      await hubChain;
-      try {
-        await assistantEventHub.publish(event);
-      } catch (err) {
-        log.warn(
-          { err },
-          "assistant-events hub subscriber threw during voice turn",
-        );
-      }
-    })();
-  };
-
   // Hook into conversation to intercept confirmation_request and secret_request events.
   // Voice auto-denies/auto-allows/auto-resolves these since there's no interactive UI.
   const autoDeny = !isGuardian;
@@ -455,7 +426,6 @@ export async function startVoiceTurn(
     if (msg.type === "confirmation_request") {
       if (usesLocalInteractiveApprovals) {
         pendingInteractions.register(msg.requestId, {
-          conversation,
           conversationId: opts.conversationId,
           kind: "confirmation",
           confirmationDetails: {
@@ -470,7 +440,7 @@ export async function startVoiceTurn(
             acpOptions: msg.acpOptions,
           },
         });
-        publishToHub(msg);
+        broadcastMessage(msg);
         return;
       }
       if (autoDeny) {
@@ -518,7 +488,7 @@ export async function startVoiceTurn(
               undefined,
               `Permission approved for "${msg.toolName}": guardian pre-approved via scoped grant.`,
             );
-            publishToHub(msg);
+            broadcastMessage(msg);
             return;
           }
         } catch (err) {
@@ -539,7 +509,7 @@ export async function startVoiceTurn(
           undefined,
           `Permission denied for "${msg.toolName}": this voice call does not have interactive approval capabilities. Side-effect tools are not available for non-guardian voice callers. In your next assistant reply, explain briefly that this action requires guardian-level access and cannot be performed during this call.`,
         );
-        publishToHub(msg);
+        broadcastMessage(msg);
         return;
       }
       if (autoAllow) {
@@ -554,7 +524,7 @@ export async function startVoiceTurn(
           undefined,
           `Permission approved for "${msg.toolName}": this is a verified guardian voice call.`,
         );
-        publishToHub(msg);
+        broadcastMessage(msg);
         return;
       }
     } else if (msg.type === "secret_request") {
@@ -564,10 +534,9 @@ export async function startVoiceTurn(
         "Auto-resolving secret request for voice turn (no secret-entry UI)",
       );
       conversation.handleSecretResponse(msg.requestId, undefined, "store");
-      publishToHub(msg);
       return;
     }
-    publishToHub(msg);
+    broadcastMessage(msg);
   });
 
   // Fire-and-forget the agent loop
@@ -596,7 +565,7 @@ export async function startVoiceTurn(
           } else if (msg.type === "conversation_error") {
             lastError = msg.userMessage;
           }
-          publishToHub(msg);
+          broadcastMessage(msg);
 
           // Forward voice-relevant events to the real-time event sink
           if (msg.type === "assistant_text_delta") {