@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/daemon/host-bash-proxy.ts

@@ -1,9 +1,9 @@
 import { getConfig } from "../config/loader.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import {
+  ambiguousSameUserError,
   enforceSameActorOrErrorResult,
-  pickMostRecentSameUserClient,
-  unavailableSameUserClientError,
+  pickSameUserAutoResolve,
 } from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { formatShellOutput } from "../tools/shared/shell-output.js";
@@ -93,17 +93,21 @@ export class HostBashProxy extends HostProxyBase<
       }
       resolvedTargetClientId = input.targetClientId;
     } else {
-      resolvedTargetClientId = pickMostRecentSameUserClient({
+      // Auto-resolve to the unique same-user client. Reject (rather than
+      // broadcast) when multiple same-user clients are connected so that
+      // a single targeted-style request cannot fan out across every one
+      // of the user's machines. Zero same-user matches falls through to
+      // the existing untargeted code path.
+      const resolved = pickSameUserAutoResolve({
         hub: assistantEventHub,
         capability: "host_bash",
         sourceActorPrincipalId,
       });
-      if (
-        resolvedTargetClientId === undefined &&
-        sourceActorPrincipalId !== undefined
-      ) {
-        return unavailableSameUserClientError("host_bash");
+      if (resolved.kind === "ambiguous") {
+        return ambiguousSameUserError("host_bash");
       }
+      resolvedTargetClientId =
+        resolved.kind === "match" ? resolved.clientId : undefined;
     }
 
     // Targeted requests must be bound to the same authenticated user as the

package/src/daemon/host-browser-proxy.ts

@@ -5,10 +5,7 @@ import {
   assistantEventHub,
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
-import {
-  enforceSameActorOrErrorResult,
-  unavailableSameUserClientError,
-} from "../runtime/auth/same-actor.js";
+import { enforceSameActorOrErrorResult } from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
@@ -287,17 +284,6 @@ export class HostBrowserProxy {
       targetClientId,
     );
 
-    if (
-      preferredClient === undefined &&
-      sourceActorPrincipalId !== undefined &&
-      targetClientId === undefined
-    ) {
-      if (isExtensionOnlyMethod(input.cdpMethod)) {
-        return Promise.resolve(extensionRequiredResult(input.cdpMethod));
-      }
-      return Promise.resolve(unavailableSameUserClientError("host_browser"));
-    }
-
     // Same-user enforcement: when the caller's actor is known, refuse to
     // dispatch to a client owned by a different actor. This covers the
     // cross-client exposure case where a web/iOS turn for actor A would

package/src/daemon/host-file-proxy.ts

@@ -6,10 +6,10 @@ import {
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
 import {
+  ambiguousSameUserError,
   enforceSameActorOrErrorResult,
-  pickMostRecentSameUserClient,
+  pickSameUserAutoResolve,
   snapshotHostProxyActorPrincipalId,
-  unavailableSameUserClientError,
 } from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { readAudioBase64 } from "../tools/shared/filesystem/audio-read.js";
@@ -102,17 +102,19 @@ export class HostFileProxy {
         });
       }
     } else {
-      resolvedTargetClientId = pickMostRecentSameUserClient({
+      // Auto-resolve to the unique same-user client. Reject ambiguous
+      // (multi-machine) cases so a single targeted-style request cannot
+      // fan out across the user's machines.
+      const resolved = pickSameUserAutoResolve({
         hub: assistantEventHub,
         capability: "host_file",
         sourceActorPrincipalId,
       });
-      if (
-        resolvedTargetClientId === undefined &&
-        sourceActorPrincipalId !== undefined
-      ) {
-        return Promise.resolve(unavailableSameUserClientError("host_file"));
+      if (resolved.kind === "ambiguous") {
+        return Promise.resolve(ambiguousSameUserError("host_file"));
       }
+      resolvedTargetClientId =
+        resolved.kind === "match" ? resolved.clientId : undefined;
     }
 
     // Same-user check: targeted host_file requests must be bound to the same

package/src/daemon/host-transfer-proxy.ts

@@ -10,10 +10,10 @@ import {
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
 import {
+  ambiguousSameUserError,
   enforceSameActorOrErrorResult,
-  pickMostRecentSameUserClient,
+  pickSameUserAutoResolve,
   snapshotHostProxyActorPrincipalId,
-  unavailableSameUserClientError,
 } from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import type { ToolExecutionResult } from "../tools/types.js";
@@ -162,17 +162,19 @@ export class HostTransferProxy {
         });
       }
     } else {
-      resolvedTargetClientId = pickMostRecentSameUserClient({
+      // Auto-resolve to the unique same-user client; reject ambiguous
+      // (multi-machine) cases so a single targeted-style transfer cannot
+      // fan out across the user's machines.
+      const resolved = pickSameUserAutoResolve({
         hub: assistantEventHub,
         capability: "host_file",
         sourceActorPrincipalId,
       });
-      if (
-        resolvedTargetClientId === undefined &&
-        sourceActorPrincipalId !== undefined
-      ) {
-        return Promise.resolve(unavailableSameUserClientError("host_file"));
+      if (resolved.kind === "ambiguous") {
+        return Promise.resolve(ambiguousSameUserError("host_file"));
       }
+      resolvedTargetClientId =
+        resolved.kind === "match" ? resolved.clientId : undefined;
     }
 
     if (resolvedTargetClientId != null) {
@@ -362,17 +364,19 @@ export class HostTransferProxy {
         });
       }
     } else {
-      resolvedTargetClientId = pickMostRecentSameUserClient({
+      // Auto-resolve to the unique same-user client; reject ambiguous
+      // (multi-machine) cases so a single targeted-style transfer cannot
+      // fan out across the user's machines.
+      const resolved = pickSameUserAutoResolve({
         hub: assistantEventHub,
         capability: "host_file",
         sourceActorPrincipalId,
       });
-      if (
-        resolvedTargetClientId === undefined &&
-        sourceActorPrincipalId !== undefined
-      ) {
-        return Promise.resolve(unavailableSameUserClientError("host_file"));
+      if (resolved.kind === "ambiguous") {
+        return Promise.resolve(ambiguousSameUserError("host_file"));
       }
+      resolvedTargetClientId =
+        resolved.kind === "match" ? resolved.clientId : undefined;
     }
 
     if (resolvedTargetClientId != null) {

package/src/daemon/lifecycle.ts

@@ -71,6 +71,7 @@ import { ensureCompleteCustomProfiles } from "../workspace/custom-profile-ensure
 import { ensureDefaultProvider } from "../workspace/default-provider-ensure.js";
 import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
 import { runWorkspaceMigrations } from "../workspace/migrations/runner.js";
+import { startAppSourceWatcher } from "./app-source-watcher.js";
 import { startConfigWatcher } from "./config-watcher.js";
 import { startConversationEvictor } from "./conversation-evictor.js";
 import { writePid } from "./daemon-control.js";
@@ -705,6 +706,10 @@ export async function runDaemon(): Promise<void> {
   // config, and broadcast the relevant resource-changed events to clients.
   startConfigWatcher();
 
+  // Watch app source directories so edits recompile + refresh surfaces across
+  // all conversations.
+  startAppSourceWatcher();
+
   // Start the CLI IPC server. Throws on EADDRINUSE to abort startup when another
   // daemon already holds the socket, so this process never runs background jobs
   // against the shared database as an unmanageable duplicate.

package/src/daemon/mcp-reload-service.ts

@@ -1,11 +1,11 @@
 /**
  * Shared MCP reload business logic.
  *
- * Called by the ConfigWatcher when mcp.json changes or a reload signal
+ * Called by the ConfigWatcher when config.json changes or a reload signal
  * file is detected, so the daemon automatically reconnects MCP servers.
  */
 
-import { invalidateConfigCache } from "../config/loader.js";
+import { getConfig, invalidateConfigCache } from "../config/loader.js";
 import {
   buildEffectiveMcpConfig,
   pluginMcpServersChangedSinceLastBuild,
@@ -13,7 +13,6 @@ import {
 import { getMcpServerManager } from "../mcp/manager.js";
 import { migrateLegacyMcpHeaders } from "../mcp/mcp-header-store.js";
 import { signalMcpReloaded } from "../mcp/reload-signal.js";
-import { loadWorkspaceMcpConfig } from "../mcp/workspace-mcp-config.js";
 import { createMcpToolsFromServer } from "../tools/mcp/mcp-tool-factory.js";
 import { registerMcpTools, unregisterAllMcpTools } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
@@ -96,15 +95,16 @@ async function doReload(): Promise<McpReloadResult> {
     //    If the config is broken we abort early, preserving the current
     //    working MCP setup instead of leaving zero servers.
     invalidateConfigCache();
+    const config = getConfig();
 
     // 2. Stop existing MCP servers + unregister their tools
     await manager.stop();
     unregisterAllMcpTools();
 
     // Plugins are re-read here too: installing or removing one changes the
-    // server set exactly like editing mcp.json does, and both arrive
+    // server set exactly like editing config.json does, and both arrive
     // through this same reload.
-    const mcpConfig = buildEffectiveMcpConfig(loadWorkspaceMcpConfig());
+    const mcpConfig = buildEffectiveMcpConfig(config.mcp);
     const serverIds = Object.keys(mcpConfig.servers);
 
     // 3. Restart MCP servers

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

@@ -13,7 +13,6 @@ export const SYNC_TAGS = {
   assistantConfig: "assistant:self:config",
   assistantSounds: "assistant:self:sounds",
   assistantSchedules: "assistant:self:schedules",
-  assistantDesktop: "assistant:self:desktop",
   assistantTheme: "assistant:self:theme",
   appsList: "apps:list",
   documentsList: "documents:list",

package/src/daemon/orphan-reaper.ts

@@ -3,7 +3,7 @@
  *
  * Tools run commands in their own process group (`detached: true`) and, on
  * timeout/abort, group-kill with `process.kill(-pgid, SIGKILL)` (the bash and
- * host_bash tools, and the skill sandbox runner). The
+ * host_bash tools, the skill sandbox runner, and the debug-bash route). The
  * immediate child is reaped by Bun/libuv, but its descendants — e.g. git's
  * transport helpers or a skill runner's `bun` process — were never spawned by
  * the daemon, so when the group dies they reparent to PID 1. When the daemon

package/src/daemon/providers-setup.ts

@@ -63,7 +63,7 @@ export async function initializeProvidersAndTools(
   // Start MCP servers — workspace-configured and plugin-declared alike —
   // and register their tools. Shared with the schedule worker, which hosts
   // agent turns in its own process and so needs its own connections.
-  await startConfiguredMcpServers();
+  await startConfiguredMcpServers(config.mcp);
 
   log.info("Daemon startup: providers and tools initialized");
 }

package/src/daemon/shutdown-handlers.ts

@@ -24,7 +24,11 @@ import { browserManager } from "../tools/browser/browser-manager.js";
 import { getLogger } from "../util/logger.js";
 import { APP_VERSION } from "../version.js";
 import { getEnrichmentService } from "../workspace/commit-message-enrichment-service.js";
-import { commitAllPendingWorkspaceChanges } from "../workspace/heartbeat-service.js";
+import {
+  commitAllPendingWorkspaceChanges,
+  stopWorkspaceHeartbeatService,
+} from "../workspace/heartbeat-service.js";
+import { stopAppSourceWatcher } from "./app-source-watcher.js";
 import { stopConfigWatcher } from "./config-watcher.js";
 import { stopConversationEvictor } from "./conversation-evictor.js";
 import { stopConversations } from "./conversation-store.js";
@@ -94,6 +98,9 @@ async function shutdown(): Promise<void> {
   }, 30_000);
   forceTimer.unref();
 
+  // Workspace git heartbeat timer lives in the monitor process. This
+  // in-process stop is a no-op unless the singleton was started here.
+  await stopWorkspaceHeartbeatService();
   await stopHeartbeatService();
 
   // Stop the periodic consent-cache refresh (a daemon-owned interval).
@@ -127,6 +134,7 @@ async function shutdown(): Promise<void> {
   disposeAcpSessionManager();
   stopConversationEvictor();
   stopConfigWatcher();
+  stopAppSourceWatcher();
   stopCliIpcServer();
   stopConversations();
   await stopCes();

package/src/daemon/skill-memory-refresh.ts

@@ -8,24 +8,16 @@ import {
   maybeSeedCapabilitySkills,
   maybeSeedCliCommandCards,
 } from "../plugins/defaults/memory/substrate/boot-maintenance.js";
-import { readWorkspaceSkillMdSignature } from "../skills/workspace-skill-md-signature.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("skill-memory-refresh");
 
-/** Poll interval for workspace `SKILL.md` mtimes. Stats only, no tree walk. */
-export const SKILL_MD_MTIME_POLL_MS = 1_500;
-
-let lastSignature: string | undefined;
-let pollTimer: ReturnType<typeof setInterval> | undefined;
-
 export function refreshSkillCapabilityMemories(
   config: AssistantConfig = getConfig(),
 ): void {
   seedSkillGraphNodes();
   maybeSeedCapabilitySkills(config);
   maybeSeedCliCommandCards(config);
-  lastSignature = readWorkspaceSkillMdSignature();
   void seedUninstalledCatalogSkillMemories()
     .then(() => {
       // Re-run after the async catalog fetch populates the cache so stale
@@ -39,59 +31,3 @@ export function refreshSkillCapabilityMemories(
       ),
     );
 }
-
-/**
- * Reseed skill capability memories when the workspace `SKILL.md` set or
- * mtimes have changed since the last refresh in this process. No-op when the
- * signature is unchanged. First call in a process always reseeds so the
- * memory worker, whose in-process skill cache starts empty, picks up the
- * catalog without waiting for an install path.
- */
-export function maybeRefreshSkillCapabilityMemoriesFromMtime(): boolean {
-  const signature = readWorkspaceSkillMdSignature();
-  if (lastSignature !== undefined && signature === lastSignature) {
-    return false;
-  }
-  if (lastSignature !== undefined) {
-    log.info("Workspace SKILL.md set changed, reseeding capability memories");
-  }
-  refreshSkillCapabilityMemories();
-  return true;
-}
-
-function pollOnce(): void {
-  try {
-    maybeRefreshSkillCapabilityMemoriesFromMtime();
-  } catch (err) {
-    log.warn({ err }, "SKILL.md mtime poll failed");
-  }
-}
-
-/**
- * Start a per-process poll of workspace `SKILL.md` mtimes. Idempotent.
- * The memory worker and the assistant each run this against their own
- * in-process skill caches. Runs once immediately so a worker that has never
- * seeded picks up the catalog without waiting a tick.
- */
-export function startWorkspaceSkillMdMtimePoll(): void {
-  if (pollTimer !== undefined) {
-    return;
-  }
-  pollOnce();
-  pollTimer = setInterval(pollOnce, SKILL_MD_MTIME_POLL_MS);
-  pollTimer.unref?.();
-}
-
-export function stopWorkspaceSkillMdMtimePoll(): void {
-  if (pollTimer === undefined) {
-    return;
-  }
-  clearInterval(pollTimer);
-  pollTimer = undefined;
-}
-
-/** @internal Test-only: clear the in-process signature and poll timer. */
-export function _resetSkillMdMtimeStateForTests(): void {
-  lastSignature = undefined;
-  stopWorkspaceSkillMdMtimePoll();
-}

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

@@ -18,15 +18,17 @@ import { invalidateEdgeIndex } from "../plugins/defaults/memory/substrate/edge-i
 import { invalidatePageIndex } from "../plugins/defaults/memory/substrate/page-index.js";
 import { getConceptsDir } from "../plugins/defaults/memory/substrate/page-store.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
-import { publishDocumentsChanged } from "../runtime/sync/resource-sync-events.js";
+import {
+  publishAppsChanged,
+  publishDocumentsChanged,
+} from "../runtime/sync/resource-sync-events.js";
+import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
-import {
-  broadcastAppFilesChanged,
-  notifyAppSurfacesChanged,
-} from "./app-change-notify.js";
+import { ensureAppSourceWatcher } from "./app-source-watcher.js";
 import type { Conversation } from "./conversation.js";
+import { refreshSurfacesForApp } from "./conversation-surfaces.js";
 import { isDoordashCommand, updateDoordashProgress } from "./doordash-steps.js";
 
 const log = getLogger("tool-side-effects");
@@ -52,7 +54,7 @@ export type PostExecutionHook = (
  * Compilation is the responsibility of the tool executor (see
  * `executeAppCreate`, `executeAppRefresh`): executors own the source→dist
  * transform and surface `compile_errors` in their result when it fails.
- * Post-execution hooks only observe the outcome and notify. They must
+ * Post-execution hooks only observe the outcome and notify — they must
  * not re-run a compile because `compileApp()` begins with `rm -rf dist/`
  * and would race with the executor's own output (LUM-1153).
  */
@@ -61,7 +63,14 @@ function notifyAppChanged(
   appId: string,
   opts?: { fileChange?: boolean; status?: string },
 ): void {
-  notifyAppSurfacesChanged(appId, opts, ctx);
+  refreshSurfacesForApp(ctx, appId, opts);
+  broadcastAppFilesChanged(appId);
+  void updatePublishedAppDeployment(appId);
+}
+
+function broadcastAppFilesChanged(appId: string): void {
+  broadcastMessage({ type: "app_files_changed", appId });
+  publishAppsChanged();
 }
 
 /**
@@ -119,6 +128,8 @@ registerHook("app_create", (_name, _input, result, { ctx }) => {
     log.warn({ err, appId }, "Failed to track conversation ID on app_create");
   }
 
+  ensureAppSourceWatcher();
+
   notifyAppChanged(ctx, appId);
 
   // Seed background icon generation from the created app's canonical record

package/src/home/__tests__/feed-writer.test.ts

@@ -459,28 +459,6 @@ describe("feed-writer", () => {
       expect(result!.summary).toBe("Fresh summary");
     });
 
-    test("a status value replaces, and a status updater reads write-time state", async () => {
-      await appendFeedItem(makeItem({ id: "item-1" }));
-
-      const replaced = await patchFeedItemContent("item-1", {
-        status: "acted_on",
-      });
-      expect(replaced!.status).toBe("acted_on");
-
-      // The updater sees the status as of the write, so a conditional
-      // transition cannot overwrite what another writer just set.
-      const observed: string[] = [];
-      const conditional = await patchFeedItemContent("item-1", {
-        status: (existing) => {
-          observed.push(existing.status);
-          return existing.status === "new" ? "seen" : existing.status;
-        },
-      });
-      expect(observed).toEqual(["acted_on"]);
-      expect(conditional!.status).toBe("acted_on");
-      expect(readFileJson().items[0]!.status).toBe("acted_on");
-    });
-
     test("returns null for an unknown id", async () => {
       await appendFeedItem(makeItem({ id: "known" }));
       expect(await patchFeedItemContent("unknown", { title: "x" })).toBeNull();

package/src/home/feed-writer.ts

@@ -185,13 +185,7 @@ export interface FeedItemContentPatch {
   title?: string;
   summary?: string;
   urgency?: FeedItemUrgency;
-  /**
-   * New status, or an updater applied inside the coalescing queue so it
-   * reads the item as of write time. Use the updater for a conditional
-   * transition: a plain value would overwrite a status another writer
-   * set while the patch sat in the queue.
-   */
-  status?: FeedItemStatus | ((existing: FeedItem) => FeedItemStatus);
+  status?: FeedItemStatus;
   /**
    * Updater for the item's guardian projection, applied inside the
    * coalescing queue so it reads the projection as of write time (a
@@ -405,10 +399,7 @@ async function runWrite(): Promise<void> {
       updated.urgency = patch.urgency;
     }
     if (patch.status !== undefined) {
-      updated.status =
-        typeof patch.status === "function"
-          ? patch.status(existing)
-          : patch.status;
+      updated.status = patch.status;
     }
     if (patch.guardianRequest !== undefined && existing.guardianRequest) {
       updated.guardianRequest = patch.guardianRequest(existing.guardianRequest);

package/src/hooks/types.ts

@@ -679,36 +679,3 @@ export interface ConversationDeletedContext
  * {@link BaseHookContext}.
  */
 export type ConversationsClearedContext = BaseHookContext;
-
-// ─── Message-deleted hook context ────────────────────────────────────────────
-
-/**
- * Context passed to the `message-deleted` hook. Fires once per deleted
- * message row, from the shared single-message delete primitive, after the row
- * is removed. Whole-conversation deletes dispatch `conversation-deleted`
- * instead.
- *
- * Fire-and-forget like `conversation-deleted`: the primitive is synchronous
- * and does not wait for the chain. The row is gone by the time a hook runs,
- * so the context carries the row's `createdAt` alongside its id. Together
- * they are the `(createdAt, id)` position the row held, which is what a hook
- * keeping a cursor on that row needs to record once the row can no longer be
- * looked up. The default memory plugin contributes a hook here that stamps
- * its retrospective cursor.
- */
-export interface MessageDeletedInputContext {
-  /** ID of the conversation that owned the row. */
-  readonly conversationId: string;
-  /** ID of the deleted message row. */
-  readonly messageId: string;
-  /** The deleted row's `createdAt`. */
-  readonly createdAt: number;
-}
-
-/**
- * The full `message-deleted` context a hook receives: the dispatching call
- * site's {@link MessageDeletedInputContext} plus the pipeline-stamped
- * {@link BaseHookContext} capabilities.
- */
-export interface MessageDeletedContext
-  extends MessageDeletedInputContext, BaseHookContext {}

package/src/inbound/platform-callback-registration.ts

@@ -18,10 +18,9 @@
  * the platform can register a route that points at this instance.
  */
 
-import { getPlatformBaseUrl } from "../config/env.js";
+import { getPlatformAssistantId, getPlatformBaseUrl } from "../config/env.js";
 import { getIsPlatform } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
-import { resolvePlatformAssistantId } from "../config/platform-identity.js";
 import { ipcRegisterWebhookRoute } from "../ipc/gateway-client.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
@@ -46,11 +45,11 @@ export interface PlatformCallbackRegistrationContext {
 
 export async function resolvePlatformCallbackRegistrationContext(): Promise<PlatformCallbackRegistrationContext> {
   const platform = getIsPlatform();
-  const [storedBaseUrlRaw, storedAssistantApiKeyRaw, assistantId] =
+  const [storedBaseUrlRaw, storedAssistantIdRaw, storedAssistantApiKeyRaw] =
     await Promise.all([
       getSecureKeyAsync(credentialKey("vellum", "platform_base_url")),
+      getSecureKeyAsync(credentialKey("vellum", "platform_assistant_id")),
       getSecureKeyAsync(credentialKey("vellum", "assistant_api_key")),
-      resolvePlatformAssistantId(),
     ]);
 
   const storedBaseUrl = storedBaseUrlRaw?.trim();
@@ -58,6 +57,8 @@ export async function resolvePlatformCallbackRegistrationContext(): Promise<Plat
     /\/+$/,
     "",
   );
+  const assistantId =
+    getPlatformAssistantId().trim() || storedAssistantIdRaw?.trim() || "";
   const envAssistantCredential = process.env.ASSISTANT_API_KEY?.trim();
   const assistantCredential =
     storedAssistantApiKeyRaw?.trim() || envAssistantCredential || undefined;

package/src/live-voice/__tests__/live-voice-metrics.test.ts

@@ -329,6 +329,7 @@ describe("LiveVoiceMetricsCollector", () => {
       endpointHoldCount: 0,
       endpointDecisionMaxLatencyMs: 95,
     });
+    expect(completed).not.toHaveProperty("ackSpoken");
   });
 
   test("decisions without a source are attributed to the front door", () => {
@@ -434,6 +435,7 @@ describe("LiveVoiceMetricsCollector", () => {
     expect(completed).not.toHaveProperty("endpointHoldCount");
     expect(completed).not.toHaveProperty("endpointDecisionMaxLatencyMs");
     expect(completed).not.toHaveProperty("endpointDecisionSource");
+    expect(completed).not.toHaveProperty("ackSpoken");
     expect(completed).not.toHaveProperty("progressUpdatesSpoken");
 
     const aggregateFields = getLiveVoiceMetricsAggregateFields(
@@ -444,6 +446,7 @@ describe("LiveVoiceMetricsCollector", () => {
     expect(aggregateFields).not.toHaveProperty("endpointHoldCount");
     expect(aggregateFields).not.toHaveProperty("endpointDecisionMaxLatencyMs");
     expect(aggregateFields).not.toHaveProperty("endpointDecisionSource");
+    expect(aggregateFields).not.toHaveProperty("ackSpoken");
     expect(aggregateFields).not.toHaveProperty("progressUpdatesSpoken");
   });
 

package/src/live-voice/__tests__/live-voice-progress.test.ts

@@ -1,14 +1,5 @@
 import { describe, expect, mock, test } from "bun:test";
 
-import type {
-  VoiceProgressNarrator,
-  VoiceProgressTextInput,
-} from "../../calls/progress-narration.js";
-import {
-  pickProgressPhrase,
-  PROGRESS_FALLBACK_PHRASES,
-  PROGRESS_FALLBACK_PHRASES_BY_LANGUAGE,
-} from "../../calls/progress-phrases.js";
 import { sanitizeForTts } from "../../calls/tts-text-sanitizer.js";
 import type {
   VoiceTurnCallbacks,
@@ -16,9 +7,9 @@ import type {
 } from "../../calls/voice-session-bridge.js";
 import { loadRawConfig, saveRawConfig } from "../../config/loader.js";
 import type {
-  VoiceFrontModelConfig,
-  VoiceProgressConfig,
-} from "../../config/schemas/voice.js";
+  LiveVoiceFrontModelConfig,
+  LiveVoiceProgressConfig,
+} from "../../config/schemas/live-voice.js";
 import type {
   StreamingTranscriber,
   SttStreamServerEvent,
@@ -30,6 +21,15 @@ import {
 } from "../live-voice-session.js";
 import type { LiveVoiceSessionFactoryContext } from "../live-voice-session-manager.js";
 import type { LiveVoiceTtsOptions } from "../live-voice-tts.js";
+import type {
+  VoiceProgressNarrator,
+  VoiceProgressTextInput,
+} from "../progress-narration.js";
+import {
+  pickProgressPhrase,
+  PROGRESS_FALLBACK_PHRASES,
+  PROGRESS_FALLBACK_PHRASES_BY_LANGUAGE,
+} from "../progress-phrases.js";
 import {
   createLiveVoiceServerFrameSequencer,
   type LiveVoiceClientStartFrame,
@@ -142,8 +142,8 @@ function makeProgressNarrator(
 }
 
 function progressConfig(
-  overrides: Partial<VoiceProgressConfig> = {},
-): Partial<VoiceFrontModelConfig> {
+  overrides: Partial<LiveVoiceProgressConfig> = {},
+): Partial<LiveVoiceFrontModelConfig> {
   const idleIntervalMs = overrides.idleIntervalMs ?? 60_000;
   return {
     progress: {
@@ -163,7 +163,7 @@ function progressConfig(
 }
 
 function createProgressHarness(options: {
-  frontModelConfig: Partial<VoiceFrontModelConfig>;
+  frontModelConfig: Partial<LiveVoiceFrontModelConfig>;
   progressNarrator: VoiceProgressNarrator;
   emitMetrics?: boolean;
   gateTtsText?: (text: string) => Promise<void> | null;