@vellumai/assistant 0.11.4-staging.2 → 0.11.4-staging.4

package/src/daemon/lifecycle.ts

@@ -4,6 +4,7 @@ import { reconcileCallsOnStartup } from "../calls/call-recovery.js";
 import { TwilioVoiceProvider } from "../calls/twilio-provider.js";
 import { expireInteractionBoundGuardianRequests } from "../channels/gateway-guardian-requests.js";
 import { initFeatureFlagOverrides } from "../config/assistant-feature-flags.js";
+import { getBalancedModelExperimentArm } from "../config/balanced-model-experiment.js";
 import { setIngressPublicBaseUrl, validateEnv } from "../config/env.js";
 import {
   hasPendingDefaultWorkspaceConfig,
@@ -224,9 +225,21 @@ export async function runDaemon(): Promise<void> {
   // a failed fetch leaves the cache unset and resolves `os-beta` to its
   // registry default `false`, which would remove the user's profile and reset
   // their selection.
+  // A balanced-model experiment arm arriving in this same load gets the same
+  // invalidation. HTTP binds before this resolves, so a client that fetched
+  // profiles in that window holds the shipped model; the arm moves nothing on
+  // disk, so the reconcile above would not report a change and the listener's
+  // own comparison sees the arm on both sides of its refresh.
+  const balancedArmBeforeInit = getBalancedModelExperimentArm();
   void initFeatureFlagOverrides()
     .then((loaded) => {
-      if (loaded && reconcileFlagGatedProfiles()) {
+      if (!loaded) {
+        return;
+      }
+      const profilesChanged = reconcileFlagGatedProfiles();
+      const balancedArmChanged =
+        getBalancedModelExperimentArm() !== balancedArmBeforeInit;
+      if (profilesChanged || balancedArmChanged) {
         publishConfigChanged();
       }
     })

package/src/daemon/process-message.ts

@@ -69,7 +69,6 @@ import {
   preactivateHostProxySkills,
   shouldAttachHostProxyForCapability,
 } from "./host-proxy-preactivation.js";
-import { bindInteractiveTurnSender } from "./interactive-turn-sender.js";
 import type { SubagentToolGateMode } from "./tool-setup-types.js";
 import { restingTrust } from "./trust-context-types.js";
 
@@ -709,11 +708,6 @@ export async function processMessage(
     };
   }
 
-  const restoreSender =
-    options?.isInteractive === true
-      ? bindInteractiveTurnSender(conversation)
-      : undefined;
-
   const restoreToolScope = applyTurnToolAllowlist(conversation, options);
   try {
     await conversation.runAgentLoop(resolvedContent, messageId, {
@@ -731,7 +725,6 @@ export async function processMessage(
     });
   } finally {
     restoreToolScope();
-    restoreSender?.();
   }
 
   // Read the just-finished turn's outcome from the stamp `runAgentLoop`'s
@@ -790,11 +783,6 @@ export async function processMessageInBackground(
     return { messageId };
   }
 
-  const restoreSender =
-    options?.isInteractive === true
-      ? bindInteractiveTurnSender(conversation)
-      : undefined;
-
   const restoreToolScope = applyTurnToolAllowlist(conversation, options);
   conversation
     .runAgentLoop(content, messageId, {
@@ -809,7 +797,6 @@ export async function processMessageInBackground(
     })
     .finally(() => {
       restoreToolScope();
-      restoreSender?.();
     })
     .catch((err) => {
       log.error({ err, conversationId }, "Background agent loop failed");

package/src/daemon/windows-compiled-entry.ts

@@ -0,0 +1,4 @@
+import "../windows-compiled-logger.js";
+import "../live-voice/windows-compiled-live-voice.js";
+
+await import("./main.js");

package/src/documents/document-store.ts

@@ -6,7 +6,6 @@
  * without going through the HTTP layer.
  */
 import { rawAll, rawGet, rawRun } from "../persistence/raw-query.js";
-import { writeWorkspaceFile } from "../runtime/routes/workspace-utils.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("document-store");
@@ -24,18 +23,13 @@ export interface DocumentRecord {
   wordCount: number;
   createdAt: number;
   updatedAt: number;
-  /**
-   * Workspace-relative path of the markdown file this document is bound to,
-   * or `null` when the document has no file behind it.
-   */
-  workspacePath: string | null;
 }
 
 /**
- * The listing projection: neither the body nor the file binding, which the
- * list and search queries deliberately leave out of their SELECTs.
+ * The listing projection: everything but the body, which the list and search
+ * queries deliberately leave out of their SELECTs.
  */
-export type DocumentSummary = Omit<DocumentRecord, "content" | "workspacePath">;
+export type DocumentSummary = Omit<DocumentRecord, "content">;
 
 /** Words in a markdown body, the count the `word_count` column stores. */
 function countWords(content: string): number {
@@ -72,10 +66,9 @@ interface DocumentRow {
   word_count: number;
   created_at: number;
   updated_at: number;
-  workspace_path: string | null;
 }
 
-type DocumentListRow = Omit<DocumentRow, "content" | "workspace_path">;
+type DocumentListRow = Omit<DocumentRow, "content">;
 
 function escapeSqlLikePattern(value: string): string {
   return value.replace(/[\\%_]/g, "\\$&");
@@ -90,7 +83,6 @@ function mapRowToRecord(row: DocumentRow): DocumentRecord {
     wordCount: row.word_count,
     createdAt: row.created_at,
     updatedAt: row.updated_at,
-    workspacePath: row.workspace_path,
   };
 }
 
@@ -99,7 +91,7 @@ export function getDocumentById(surfaceId: string): DocumentRecord | null {
   try {
     const row = rawGet<DocumentRow>(
       "documents:getDocumentById",
-      /*sql*/ `SELECT surface_id, conversation_id, title, content, word_count, created_at, updated_at, workspace_path
+      /*sql*/ `SELECT surface_id, conversation_id, title, content, word_count, created_at, updated_at
        FROM documents
        WHERE surface_id = ?`,
       surfaceId,
@@ -118,29 +110,6 @@ export function getDocumentById(surfaceId: string): DocumentRecord | null {
   }
 }
 
-/**
- * Look up the document bound to a workspace file. `workspacePath` must be the
- * normalized workspace-relative path stored on the row. Returns `null` when no
- * document is bound to that file.
- */
-export function getDocumentByWorkspacePath(
-  workspacePath: string,
-): DocumentRecord | null {
-  try {
-    const row = rawGet<DocumentRow>(
-      "documents:getDocumentByWorkspacePath",
-      /*sql*/ `SELECT surface_id, conversation_id, title, content, word_count, created_at, updated_at, workspace_path
-       FROM documents
-       WHERE workspace_path = ?`,
-      workspacePath,
-    );
-    return row ? mapRowToRecord(row) : null;
-  } catch (error) {
-    log.error({ err: error, workspacePath }, "Load-by-workspace-path error");
-    return null;
-  }
-}
-
 /** Return true when a document is associated with a conversation. */
 export function isDocumentAssociatedWithConversation(
   surfaceId: string,
@@ -429,202 +398,6 @@ export function findInDocument(
   }
 }
 
-// ---------------------------------------------------------------------------
-// Workspace file binding
-// ---------------------------------------------------------------------------
-
-/**
- * Mirror `content` onto the workspace file a document is bound to.
- *
- * This is the single write-through choke point: every path that persists
- * document content — {@link saveDocument} (client save and `document_create`),
- * {@link updateDocumentContent} (`document_update`), and
- * {@link replaceInDocument} (`document_replace_text`) — calls it immediately
- * before its own row write, so a file-backed document's markdown on disk always
- * matches the stored row.
- *
- * The file is written first and a failure throws: a rejected write aborts the
- * update before the row changes rather than leaving the two silently diverged.
- * Documents with no file behind them are a no-op.
- */
-function writeThroughToWorkspaceFile(surfaceId: string, content: string): void {
-  const row = rawGet<{ workspace_path: string | null }>(
-    "documents:writeThroughToWorkspaceFile:getPath",
-    /*sql*/ `SELECT workspace_path FROM documents WHERE surface_id = ?`,
-    surfaceId,
-  );
-  const workspacePath = row?.workspace_path;
-  if (!workspacePath) {
-    return;
-  }
-
-  try {
-    writeWorkspaceFile(workspacePath, Buffer.from(content, "utf-8"));
-    log.info({ surfaceId, workspacePath }, "Wrote document through to file");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Failed to write file-backed document to ${workspacePath}: ${message}`,
-    );
-  }
-}
-
-/**
- * Create a document seeded from a workspace markdown file and bind it to that
- * file. The returned surface ID is the file's document identity — comments,
- * assistant iteration, and PDF export all key off it.
- *
- * The partial unique index on `workspace_path` makes a concurrent second
- * create fail rather than produce a duplicate binding; callers re-read by path
- * on failure.
- */
-export function createFileBackedDocument(params: {
-  surfaceId: string;
-  conversationId: string;
-  title: string;
-  content: string;
-  workspacePath: string;
-}): { success: true } | { success: false; error: string } {
-  try {
-    const now = Date.now();
-    rawRun(
-      "documents:createFileBackedDocument",
-      /*sql*/ `INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at, workspace_path)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-      params.surfaceId,
-      params.conversationId,
-      params.title,
-      params.content,
-      countWords(params.content),
-      now,
-      now,
-      params.workspacePath,
-    );
-    addDocumentConversation(params.surfaceId, params.conversationId);
-    log.info(
-      { surfaceId: params.surfaceId, workspacePath: params.workspacePath },
-      "Created file-backed document",
-    );
-    return { success: true };
-  } catch (error) {
-    log.error(
-      { err: error, workspacePath: params.workspacePath },
-      "File-backed document create error",
-    );
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error",
-    };
-  }
-}
-
-/**
- * Move file-backed documents onto the path a workspace rename moved their file
- * to. `oldPath` and `newPath` are canonical workspace-relative paths, the same
- * form {@link createFileBackedDocument} stores.
- *
- * A document bound to `oldPath` itself moves, and so does every document nested
- * under it (`oldPath + "/"` prefix), which is what a directory rename produces.
- *
- * The rename on disk has already happened by the time this runs, so it is best
- * effort and never throws: the caller has no way to undo the rename, and a
- * document left on a stale path is recoverable while a failed rename response
- * is not. Rows move one statement at a time so a single row that cannot move
- * does not strand its siblings.
- *
- * A row whose destination is already taken by another binding is one such case:
- * the partial unique index on `workspace_path` rejects the update, and the
- * losing row keeps pointing at the old path. That is deliberate. Overwriting
- * the winner would drop a binding that a client may have open, whereas the
- * stale binding self-heals: opening the file refreshes the row's content from
- * disk, and a document whose file is gone is reported as gone rather than
- * rewritten from the row.
- */
-export function rebindDocumentsToRenamedPath(params: {
-  oldPath: string;
-  newPath: string;
-}): void {
-  const { oldPath, newPath } = params;
-  if (!oldPath || !newPath || oldPath === newPath) {
-    return;
-  }
-
-  try {
-    const rows = rawAll<{ surface_id: string; workspace_path: string }>(
-      "documents:rebindRenamedPath:select",
-      /*sql*/ `SELECT surface_id, workspace_path
-       FROM documents
-       WHERE workspace_path = ? OR workspace_path LIKE ? ESCAPE '\\'`,
-      oldPath,
-      `${escapeSqlLikePattern(oldPath)}/%`,
-    );
-
-    for (const row of rows) {
-      const rebound =
-        row.workspace_path === oldPath
-          ? newPath
-          : newPath + row.workspace_path.slice(oldPath.length);
-      try {
-        rawRun(
-          "documents:rebindRenamedPath:update",
-          /*sql*/ `UPDATE documents SET workspace_path = ? WHERE surface_id = ?`,
-          rebound,
-          row.surface_id,
-        );
-        log.info(
-          {
-            surfaceId: row.surface_id,
-            from: row.workspace_path,
-            to: rebound,
-          },
-          "Rebound file-backed document to renamed path",
-        );
-      } catch (error) {
-        log.warn(
-          {
-            err: error,
-            surfaceId: row.surface_id,
-            from: row.workspace_path,
-            to: rebound,
-          },
-          "Left file-backed document on its old path after a rename",
-        );
-      }
-    }
-  } catch (error) {
-    log.error({ err: error, oldPath, newPath }, "Path rebind error");
-  }
-}
-
-/**
- * Replace a document's stored content with the current text of the file it is
- * bound to. The file is the source of truth when a document is opened, so this
- * deliberately skips the write-through step — disk and row already agree.
- */
-export function refreshDocumentContentFromFile(
-  surfaceId: string,
-  content: string,
-): { success: true } | { success: false; error: string } {
-  try {
-    rawRun(
-      "documents:refreshDocumentContentFromFile",
-      /*sql*/ `UPDATE documents SET content = ?, word_count = ?, updated_at = ? WHERE surface_id = ?`,
-      content,
-      countWords(content),
-      Date.now(),
-      surfaceId,
-    );
-    log.info({ surfaceId }, "Refreshed document content from file");
-    return { success: true };
-  } catch (error) {
-    log.error({ err: error, surfaceId }, "Document refresh error");
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error",
-    };
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Document persistence
 // ---------------------------------------------------------------------------
@@ -637,7 +410,6 @@ export function saveDocument(params: {
   wordCount: number;
 }): { success: true; surfaceId: string } | { success: false; error: string } {
   try {
-    writeThroughToWorkspaceFile(params.surfaceId, params.content);
     const now = Date.now();
     rawRun(
       "documents:saveDocument",
@@ -773,7 +545,6 @@ export function replaceInDocument(
       replacementsMade = totalMatches;
     }
 
-    writeThroughToWorkspaceFile(surfaceId, newContent);
     const wordCount = countWords(newContent);
     rawRun(
       "documents:replaceInDocument:update",
@@ -940,7 +711,6 @@ export function updateDocumentContent(
     const newContent = appending
       ? existing.content + sep + appliedMarkdown
       : appliedMarkdown;
-    writeThroughToWorkspaceFile(surfaceId, newContent);
     const wordCount = countWords(newContent);
     rawRun(
       "documents:updateDocumentContent:update",

package/src/hooks/types.ts

@@ -173,6 +173,11 @@ export interface UserPromptSubmitInputContext {
    * user speech (e.g. title generation) should skip these turns.
    */
   readonly isHiddenPrompt?: boolean;
+  /**
+   * Daemon-authored kind from the triggering row's `metadata.messageKind`,
+   * when the turn needs a more specific identity than role or visibility.
+   */
+  readonly messageKind?: string;
   /**
    * The user's original message list, immutable for the hook. Plugins
    * may snapshot or compare against this but MUST NOT mutate it.

package/src/ipc/gateway-flag-listener.ts

@@ -1,6 +1,7 @@
 import { connect, type Socket } from "node:net";
 
 import { refreshOverridesFromGateway } from "../config/assistant-feature-flags.js";
+import { getBalancedModelExperimentArm } from "../config/balanced-model-experiment.js";
 import { reconcileFlagGatedProfiles } from "../config/sync-gated-profiles.js";
 import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import { publishConfigChanged } from "../runtime/sync/resource-sync-events.js";
@@ -19,13 +20,26 @@ const log = getLogger("gateway-flag-listener");
  * when the refresh confirmed flags loaded from the gateway — a transient IPC
  * failure leaves the cache unset and resolves `os-beta` to its registry default
  * `false`, which would remove the user's profile and reset their selection.
+ *
+ * A new balanced-model experiment arm gets the same broadcast. It repoints what
+ * the managed Balanced profile resolves to without moving anything on disk, so
+ * the reconcile reports no change and clients would otherwise keep rendering
+ * the previous model beside a profile already running the new one.
  */
 function refreshFlagsAndReconcileProfiles(context: string): void {
+  const balancedArmBefore = getBalancedModelExperimentArm();
   refreshOverridesFromGateway()
     .then((loaded) => {
-      if (loaded && reconcileFlagGatedProfiles()) {
-        // Reuse the config-changed broadcast clients already consume so the
-        // profile picker reflects the added/removed managed profile.
+      if (!loaded) {
+        return;
+      }
+      const profilesChanged = reconcileFlagGatedProfiles();
+      const balancedArmChanged =
+        getBalancedModelExperimentArm() !== balancedArmBefore;
+      if (profilesChanged || balancedArmChanged) {
+        // Reuse the config-changed broadcast clients already consume: web
+        // routes the `assistant:self:config` sync tag to the effective profile
+        // catalog and the call-site catalog, both derived from config.
         publishConfigChanged();
       }
     })

package/src/live-voice/__tests__/live-voice-flux-turn-end.test.ts

@@ -75,11 +75,18 @@ class MockFluxTranscriber implements StreamingTranscriber {
     this.received.push(Buffer.from(chunk));
   }
 
+  // Transcript Flux answers `CloseStream` with, for a turn still in flight
+  // when the caller released. Null models a stop with nothing left to flush.
+  pendingFlushText: string | null = null;
+
   stop(): void {
     if (this.stopped) {
       return;
     }
     this.stopped = true;
+    if (this.pendingFlushText !== null) {
+      this.onEvent?.({ type: "final", text: this.pendingFlushText });
+    }
     this.onEvent?.({ type: "closed" });
   }
 
@@ -929,4 +936,115 @@ describe("LiveVoiceSession Flux end-of-turn during the STT dial", () => {
 
     await session.close("client_end");
   });
+
+  test("keeps one stream across turns when the provider owns the boundary", async () => {
+    const { session, transcribers, turnCalls } = createHarness({
+      fluxConfig: FLUX_ON,
+      // Long enough that only the provider can be closing these turns.
+      silenceThresholdMs: 10_000,
+      startVoiceTurn: autoCompletingTurn(),
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => transcribers.length > 0);
+    transcribers[0]?.startOfTurn(0);
+    transcribers[0]?.endOfTurn("what is the weather", 0);
+    await waitFor(() => turnCalls.length === 1);
+    await flushAsyncCallbacks();
+
+    // Second utterance on the same session. A stream torn down per utterance
+    // would lose the audio arriving while its replacement dials, which is
+    // what eats the opening words of every turn after the first.
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    transcribers[0]?.startOfTurn(1);
+    transcribers[0]?.endOfTurn("and tomorrow", 1);
+    await waitFor(() => turnCalls.length === 2);
+
+    expect(transcribers).toHaveLength(1);
+    expect(transcribers[0]?.stopped).toBe(false);
+    expect(turnCalls[1]?.content).toBe("and tomorrow");
+
+    await session.close("client_end");
+  });
+
+  test("closes the stream when a caller-side boundary releases the turn", async () => {
+    const { session, transcribers, turnCalls } = createHarness({
+      fluxConfig: FLUX_ON,
+      startVoiceTurn: autoCompletingTurn(),
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => transcribers.length > 0);
+    // Flux transcribes but never closes the turn, so the fail-open deadline
+    // releases it. Nothing sealed this cycle provider-side, so the only way
+    // to make Flux answer for the turn still open is to close the stream.
+    transcribers[0]?.emit({ type: "partial", text: "are you still there" });
+
+    await waitFor(
+      () => turnCalls.length === 1,
+      "Flux fallback never replayed the silence boundary",
+    );
+    expect(transcribers[0]?.stopped).toBe(true);
+
+    // The closing stream stays routable: its flush and its close both arrive
+    // after stop(), and the cycle is sealed by that close.
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(
+      () => transcribers.length === 2,
+      "The next utterance never dialed a replacement stream",
+    );
+
+    await session.close("client_end");
+  }, 10_000);
+
+  test("routes a closing stream's flush into the turn it released", async () => {
+    const { session, transcribers, turnCalls } = createHarness({
+      fluxConfig: FLUX_ON,
+      startVoiceTurn: autoCompletingTurn(),
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => transcribers.length > 0);
+    const transcriber = transcribers[0];
+    // Flux transcribes nothing and never closes the turn, so the fail-open
+    // deadline releases a cycle with no transcript: there is no speculative
+    // dispatch to answer this turn, only what the close flushes.
+    if (transcriber) {
+      transcriber.pendingFlushText = "the whole sentence";
+    }
+
+    await waitFor(
+      () => turnCalls.length === 1,
+      "The flushed transcript never reached an assistant turn",
+    );
+    expect(turnCalls[0]?.content).toBe("the whole sentence");
+
+    await session.close("client_end");
+  }, 10_000);
+
+  test("tears the stream down per utterance while the flag is off", async () => {
+    const { session, transcribers, turnCalls } = createHarness({
+      fluxConfig: { turnEnd: { enabled: false } },
+      startVoiceTurn: autoCompletingTurn(),
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await waitFor(() => transcribers.length > 0);
+    transcribers[0]?.emit({ type: "final", text: "hello there" });
+
+    // With provider turn-end disabled the local silence boundary owns the
+    // turn, and a stream the caller can neither flush nor rely on to seal
+    // itself must close for its transcript to land.
+    await waitFor(
+      () => turnCalls.length === 1,
+      "The silence boundary never committed the turn",
+    );
+    expect(transcribers[0]?.stopped).toBe(true);
+
+    await session.close("client_end");
+  }, 10_000);
 });

package/src/live-voice/live-voice-manager.ts

@@ -15,7 +15,17 @@ import { LiveVoiceSessionManager } from "./live-voice-session-manager.js";
 
 const require = createRequire(import.meta.url);
 
+type LiveVoiceSessionFactory =
+  typeof import("./live-voice-session.js").createLiveVoiceSession;
+
 let manager: LiveVoiceSessionManager | null = null;
+let bundledSessionFactory: LiveVoiceSessionFactory | null = null;
+
+export function setBundledLiveVoiceSessionFactory(
+  factory: LiveVoiceSessionFactory | null,
+): void {
+  bundledSessionFactory = factory;
+}
 
 /**
  * The daemon-wide live voice session manager, lazily constructed on first
@@ -32,9 +42,12 @@ export function getLiveVoiceSessionManager(): LiveVoiceSessionManager {
       // module-load time. `require` keeps the factory synchronous, so the
       // manager still claims its single-session slot without an await gap.
       createSession: (context) => {
-        const { createLiveVoiceSession } =
-          require("./live-voice-session.js") as typeof import("./live-voice-session.js");
-        return createLiveVoiceSession(context);
+        const createSession =
+          bundledSessionFactory ??
+          (
+            require("./live-voice-session.js") as typeof import("./live-voice-session.js")
+          ).createLiveVoiceSession;
+        return createSession(context);
       },
     });
   }