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

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);
       },
     });
   }

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

@@ -447,6 +447,13 @@ interface UtteranceCycle {
   // to the silence-boundary path and stays there: a late event must not
   // commit a boundary the fallback already owns.
   providerTurnEndTimedOut: boolean;
+  // The provider's own end-of-turn released this cycle, so its transcript is
+  // already complete. A provider that decides turn ends commits the transcript
+  // in the same event, so such a release needs no caller-side flush and must
+  // not tear the stream down. False on every caller-side release (the fail-open
+  // deadline, a max-duration force-end, barge-in), where a turn may still be
+  // open provider-side and only a stream close can make it answer.
+  providerClosedTurn: boolean;
   // `vadSpeechGeneration` as of the local silence boundary that handed this
   // cycle to the provider, or null while no boundary has fired yet (a turn
   // model routinely beats the trailing-silence countdown, and that fast commit
@@ -948,6 +955,7 @@ function createUtteranceCycle(): UtteranceCycle {
     latestPartialText: null,
     endpointExtensionCount: 0,
     providerTurnEndTimedOut: false,
+    providerClosedTurn: false,
     turnBoundaryGeneration: null,
     openProviderTurnIndex: null,
     heldSpeculativeContent: null,
@@ -1216,12 +1224,14 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   // replayed once the parked speech flushes into the next armed utterance.
   private vadPendingTurnEnd: "silence" | "max-duration" | null = null;
   private readonly metricsClock: LiveVoiceMetricsClock;
-  // Persistent mode: server-VAD sessions with a finalize-capable provider
-  // keep one streaming transcriber for the whole session. Utterance release
-  // flushes via finalizeUtterance() instead of tearing the stream down, and
-  // re-arm reuses this instance synchronously. Null in manual mode, for
-  // providers without finalizeUtterance, and after an unexpected stream
-  // close (the next arm resolves a fresh transcriber).
+  // Persistent mode: a server-VAD session keeps one streaming transcriber for
+  // the whole session when the stream can be sealed per utterance without
+  // closing it. Either the provider is finalize-capable (release flushes via
+  // finalizeUtterance()) or the provider decides turn ends itself (release is
+  // already sealed by the end-of-turn that triggered it). Re-arm reuses this
+  // instance synchronously. Null in manual mode, for a stream that offers
+  // neither seal, and after an unexpected stream close (the next arm resolves
+  // a fresh transcriber).
   private sharedTranscriber: StreamingTranscriber | null = null;
   // The `services.stt.language` value the shared stream was dialed with.
   // Providers pin the language per connection, so the persistent re-arm
@@ -1635,7 +1645,15 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       );
       if (
         this.turnDetector &&
-        typeof transcriber.finalizeUtterance === "function"
+        (typeof transcriber.finalizeUtterance === "function" ||
+          // A provider that owns the turn boundary needs no caller-side flush
+          // on the normal path: its end-of-turn IS the flush, and it commits
+          // the transcript in the same event. Gating persistence on
+          // `finalizeUtterance` alone asks "can the caller flush this stream"
+          // when the question is "will the caller ever have to", and answering
+          // it wrong costs a socket per utterance, which drops the audio that
+          // arrives while the next one dials.
+          this.providerTurnEndActive)
       ) {
         // Adopt persistent mode: this stream serves the whole session, so
         // its events route by cycle ownership instead of binding to this
@@ -3455,6 +3473,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       "provider",
     );
     await this.sendFrame({ type: "utterance_end", reason: "silence" });
+    // The provider committed this cycle's transcript in the event being
+    // handled, so the release below seals it in place instead of flushing or
+    // closing the stream.
+    utterance.providerClosedTurn = true;
     await this.releaseUtterance();
     // Leave the local detector idle, which is where every other commit path
     // leaves it. A provider can close a turn while the trailing-silence
@@ -3723,8 +3745,24 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   ): Promise<void> {
     const shared = this.sharedTranscriber;
     if (shared && utterance.transcriber === shared) {
-      await this.finalizeUtteranceForRelease(utterance);
-      return;
+      if (typeof shared.finalizeUtterance === "function") {
+        await this.finalizeUtteranceForRelease(utterance);
+        return;
+      }
+      if (utterance.providerClosedTurn) {
+        await this.sealProviderClosedUtterance(utterance);
+        return;
+      }
+      // A caller-side boundary on a stream with no flush: only closing it can
+      // make the provider answer for a turn still open, so this one release
+      // costs the stream. The stream stays installed as the shared one across
+      // the close: its flush `final` and its `closed` both arrive after
+      // `stop()`, and the shared router drops events from a stream it no
+      // longer recognizes. `closed` is what retires it, seals this cycle and
+      // dispatches the turn, so clearing the reference here would strand the
+      // cycle in `released` with the flushed transcript discarded. Nothing can
+      // re-arm onto the closing stream in the meantime: the next arm waits on
+      // the assistant turn, which waits on that same `closed`.
     }
 
     utterance.phase = "released";
@@ -3744,6 +3782,22 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     await this.drainOutboundFrames();
   }
 
+  // Persistent-mode release for a provider-decided turn end: the event that
+  // released this cycle already carried its final transcript, so there is
+  // nothing to flush and no reason to close the stream. Sealing the phase is
+  // the whole of the teardown: the same "transcript complete, stream open"
+  // state the `finalized` path reaches, arrived at without a round trip.
+  private async sealProviderClosedUtterance(
+    utterance: UtteranceCycle,
+  ): Promise<void> {
+    if (utterance.phase === "transcriber_closed") {
+      return;
+    }
+    utterance.phase = "transcriber_closed";
+    await this.startAssistantTurnIfReady();
+    await this.drainOutboundFrames();
+  }
+
   // Persistent-mode release: flush the shared stream's buffered audio with
   // finalizeUtterance() instead of tearing the stream down. The assistant
   // turn starts on the `finalized` event; the grace timer bounds a flush

package/src/live-voice/windows-compiled-live-voice.ts

@@ -0,0 +1,4 @@
+import { setBundledLiveVoiceSessionFactory } from "./live-voice-manager.js";
+import { createLiveVoiceSession } from "./live-voice-session.js";
+
+setBundledLiveVoiceSessionFactory(createLiveVoiceSession);

package/src/monitoring/control.ts

@@ -45,6 +45,7 @@ export async function spawnMonitoringWorkerProcess(
     return await spawnWorkerProcess({
       pidPath: getMonitoringPidPath(),
       entry: new URL("./worker.ts", import.meta.url),
+      packagedEntry: "monitoring",
       workerLabel: "Resource monitor",
       options: opts,
     });