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

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

package/src/monitoring/db-integrity-sample.ts

@@ -17,12 +17,12 @@
 
 import { existsSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 
 import { getRawShareAnalytics } from "../platform/consent-cache.js";
 import { recordWatchdogEvent } from "../telemetry/watchdog-events-store.js";
 import { getLogger } from "../util/logger.js";
 import { getDbPath, getMonitoringDataDir } from "../util/platform.js";
+import { resolveWorkerCommand } from "../util/worker-process.js";
 import type { IntegritySampleResult } from "./db-integrity-check.js";
 
 const log = getLogger("db-integrity-sample");
@@ -60,13 +60,12 @@ let activeChild: ReturnType<typeof Bun.spawn> | null = null;
 async function runCheckSubprocess(
   dbPath: string,
 ): Promise<IntegritySampleResult | null> {
-  // `fileURLToPath`, not `.pathname`: the latter percent-encodes, and an
-  // install path with a space in it would not resolve. See worker-process.ts.
-  const entry = fileURLToPath(
+  const command = resolveWorkerCommand(
     new URL("./db-integrity-check.ts", import.meta.url),
+    "db-integrity",
   );
   const child = Bun.spawn({
-    cmd: ["bun", "--smol", "run", entry, dbPath],
+    cmd: [...command, dbPath],
     stdio: ["ignore", "pipe", "ignore"],
   });
   activeChild = child;

package/src/notifications/AGENTS.md

@@ -9,3 +9,5 @@ When a notification flow creates a server-side conversation (e.g. guardian quest
 Guardian-request producers (access requests, tool approvals, tool-grant escalations, voice questions, trusted-contact confirmations) **MUST** record approval-card deliveries through `recordApprovalCardDelivery` / `recordGuardianRequestDeliveries` in `guardian-delivery-recorder.ts` -- never by calling the gateway client's `createGuardianRequestDelivery` directly. That sink is the single place the card-to-request addressing convention lives (conversation id for the in-app card; chat + channel-native `ts` for channel cards), so the path that writes a delivery row cannot drift from the paths that read it back to withdraw a card or resolve an emoji reaction -- the drift that previously fanned this logic into four divergent copies. (Tests may seed delivery rows directly for fixtures.)
 
 Approval-card **source references** (the link back to the channel message that triggered a request) resolve only through `resolveApprovalSourceReference()` in `runtime/approval-source-link.ts` -- producers spread the result into the `guardian.question` context payload and never hand-build links. Channel-format knowledge (id shapes, permalinks, mrkdwn) lives only in `messaging/providers/<channel>/` and `notifications/adapters/<channel>`; the four-layer ownership map is documented at the top of `approval-source-link.ts`. Exception: access-request cards predate the registry and still derive their Slack permalink from payload `messageTs` in `access-request-copy.ts` -- converge them onto the registry rather than adding a third resolution path.
+
+Guardian-request card rows are **not conversation history**. `pairDeliveryWithConversation` persists a message row per delivery, and for a guardian card that row is addressed to a conversation the request is _about_ (the vellum card is pinned to the originating conversation; a channel card lands in whatever conversation the guardian's chat binds to). `isGuardianCardRow` in `approval-card-data.ts` is the single definition of which rows those are, derived from the card's own `ui_surface` id rather than a stored marker so old rows need no backfill. **Both** history assemblers must consult it -- `Conversation.loadFromDb` and `loadSlackChronologicalContext`, which re-reads rows rather than using `this.messages` -- or the unfiltered one replays the card between a parked turn's `tool_use` and its `tool_result` and history repair destroys the real result. Surface state is exempt on purpose: the card's buttons must still route after a restart. Full rationale in [docs/guardian-request-flow.md](../../docs/guardian-request-flow.md).

package/src/notifications/approval-card-data.ts

@@ -75,6 +75,39 @@ export function approvalCardSurfaceId(
   }
 }
 
+/**
+ * Whether a persisted message row is a guardian card rather than the
+ * conversation's own speech.
+ *
+ * Read off the card's own `ui_surface` id, using the prefixes above. The card
+ * builder writes that block on every path (`ensureSeedContentBlocks`), and the
+ * withdrawal path already recomputes the same id from the same constants, so
+ * the identity is structural rather than sniffed. Deriving it means rows
+ * written before this rule existed are recognized on the same terms as new
+ * ones, with no marker to backfill.
+ *
+ * Only a row that LEADS with an approval-card surface counts. A real assistant
+ * turn can carry a `ui_surface` block too (a wake card is unshifted onto the
+ * turn's own content), and those surfaces do not use these prefixes; requiring
+ * the lead position keeps the rule from ever swallowing a turn that has speech
+ * in it.
+ */
+export function isGuardianCardRow(
+  content: readonly unknown[] | string | null | undefined,
+): boolean {
+  if (!Array.isArray(content) || content.length === 0) {
+    return false;
+  }
+  const lead = content[0] as { type?: unknown; surfaceId?: unknown };
+  if (lead?.type !== "ui_surface" || typeof lead.surfaceId !== "string") {
+    return false;
+  }
+  return (
+    lead.surfaceId.startsWith(`${ACCESS_REQUEST_SURFACE_PREFIX}-`) ||
+    lead.surfaceId.startsWith(`${TOOL_APPROVAL_SURFACE_PREFIX}-`)
+  );
+}
+
 // ── Typed card data ─────────────────────────────────────────────────────────
 
 /** Resolved card data for an access-request notification. */

package/src/permissions/prompter.ts

@@ -36,7 +36,7 @@ export class PermissionPrompter {
    * pendingInteractions, matching the host proxy pattern.
    */
   private ownedIds = new Set<string>();
-  private sendToClient: (msg: AssistantEvent) => void;
+  private readonly sendToClient: (msg: AssistantEvent) => void;
   private onStateChanged?: ConfirmationStateCallback;
 
   constructor(sendToClient: (msg: AssistantEvent) => void) {
@@ -47,10 +47,6 @@ export class PermissionPrompter {
     this.onStateChanged = cb;
   }
 
-  updateSender(sendToClient: (msg: AssistantEvent) => void): void {
-    this.sendToClient = sendToClient;
-  }
-
   async prompt(
     toolName: string,
     input: Record<string, unknown>,

package/src/persistence/conversation-queries.ts

@@ -1,4 +1,14 @@
-import { and, count, desc, eq, isNull, lt, sql } from "drizzle-orm";
+import {
+  and,
+  count,
+  desc,
+  eq,
+  getTableColumns,
+  isNull,
+  lt,
+  sql,
+} from "drizzle-orm";
+import type { SQLiteSelect } from "drizzle-orm/sqlite-core";
 
 import {
   parseExternalContentEnvelope,
@@ -263,6 +273,15 @@ export interface ConversationListFilter {
    * section, and a UUID one custom group. Omit to span every group.
    */
   groupId?: string;
+  /**
+   * Restrict to conversations whose latest assistant message the user has
+   * not seen: the same "unseen" predicate the unread count and the section
+   * index apply ({@link unseenAttentionStateConditions}), so every reader
+   * of "needs attention" agrees. Only `true` narrows; omit to span every
+   * conversation. A client that keeps no complete list can ask for exactly
+   * the rows its attention surfaces need instead of scanning for them.
+   */
+  needsAttention?: true;
 }
 
 export interface ConversationListQuery extends ConversationListFilter {
@@ -327,21 +346,55 @@ function originChannelClause(originChannel: string) {
   return eq(conversations.originChannel, originChannel);
 }
 
+/**
+ * The join between a conversation and its attention projection, one row per
+ * conversation in `conversation_assistant_attention_state`. Every reader of
+ * "unseen" joins on this: the list and count filters, the unread count, and
+ * the section index.
+ */
+const attentionJoin = eq(
+  conversationAssistantAttentionState.conversationId,
+  conversations.id,
+);
+
 function conversationListWhere(filter: ConversationListFilter) {
   const {
     conversationType = "standard",
     archiveStatus = "active",
     originChannel,
     groupId,
+    needsAttention,
   } = filter;
   return and(
     conversationTypeClause(conversationType),
     archiveStatusClause(archiveStatus) ?? undefined,
     originChannel ? originChannelClause(originChannel) : undefined,
     groupId ? groupIdClause(groupId) : undefined,
+    ...(needsAttention ? unseenAttentionStateConditions() : []),
   );
 }
 
+/**
+ * The joins {@link conversationListWhere}'s predicates need, applied to a
+ * list or count query over `conversations`. The attention predicate lives on
+ * `conversation_assistant_attention_state`, so `needsAttention` joins it.
+ * Inner, not left: a conversation with no
+ * attention row has no unseen message by definition. Joined only when the
+ * filter asks, so a query without the filter runs without the join and
+ * lists every conversation the predicates admit. One place for both
+ * {@link listConversations} and {@link countConversations}, so a page and
+ * its total always describe the same set.
+ */
+function withListFilterJoins<T extends SQLiteSelect>(
+  query: T,
+  filter: ConversationListFilter,
+) {
+  if (!filter.needsAttention) {
+    return query;
+  }
+  return query.innerJoin(conversationAssistantAttentionState, attentionJoin);
+}
+
 export function listConversations(
   query: ConversationListQuery = {},
 ): ConversationRow[] {
@@ -362,9 +415,13 @@ export function listConversations(
   // distinguish a total order from a lucky one. The guarantee becomes
   // observable, and gets its test, with the keyset pagination work.
   const tiebreak = desc(conversations.id);
-  return db
-    .select()
-    .from(conversations)
+  // Selecting the conversation columns explicitly keeps the row shape
+  // `parseConversation` maps identical whether or not the attention join is
+  // present.
+  return withListFilterJoins(
+    db.select(getTableColumns(conversations)).from(conversations).$dynamic(),
+    filter,
+  )
     .where(conversationListWhere(filter))
     .orderBy(recency, tiebreak)
     .limit(limit ?? 100)
@@ -542,9 +599,10 @@ export function countConversations(
 ): number {
   ensureGroupMigration();
   const db = getDb();
-  const [{ total }] = db
-    .select({ total: count() })
-    .from(conversations)
+  const [{ total }] = withListFilterJoins(
+    db.select({ total: count() }).from(conversations).$dynamic(),
+    filter,
+  )
     .where(conversationListWhere(filter))
     .all();
   return total;
@@ -582,10 +640,7 @@ export function countUnreadConversations(): number {
   const [{ total }] = db
     .select({ total: count() })
     .from(conversations)
-    .innerJoin(
-      conversationAssistantAttentionState,
-      eq(conversationAssistantAttentionState.conversationId, conversations.id),
-    )
+    .innerJoin(conversationAssistantAttentionState, attentionJoin)
     .where(
       and(
         conversationTypeClause("standard"),
@@ -647,11 +702,6 @@ export function countConversationSections(): ConversationSectionCounts {
     ...unseenAttentionStateConditions(),
   )} THEN 1 ELSE 0 END)`;
 
-  const attentionJoin = eq(
-    conversationAssistantAttentionState.conversationId,
-    conversations.id,
-  );
-
   const groups = db
     .select({
       groupId: sql<string>`group_id`,

package/src/persistence/embeddings/qdrant-manager.ts

@@ -33,6 +33,45 @@ const SHUTDOWN_GRACE_MS = 5_000;
 const STDOUT_CAPTURE_LIMIT = 16_384;
 const STDERR_CAPTURE_LIMIT = 4_096;
 
+export function resolveQdrantReleaseAsset(
+  os: NodeJS.Platform,
+  cpu: string,
+): {
+  binaryName: string;
+  filename: string;
+  format: "tar.gz" | "zip";
+  sha256?: string;
+} {
+  let target: string;
+  if (os === "darwin" && cpu === "arm64") {
+    target = "aarch64-apple-darwin";
+  } else if (os === "darwin" && cpu === "x64") {
+    target = "x86_64-apple-darwin";
+  } else if (os === "linux" && cpu === "x64") {
+    target = "x86_64-unknown-linux-musl";
+  } else if (os === "linux" && cpu === "arm64") {
+    target = "aarch64-unknown-linux-musl";
+  } else if (os === "win32" && cpu === "x64") {
+    return {
+      binaryName: "qdrant.exe",
+      filename: "qdrant-x86_64-pc-windows-msvc.zip",
+      format: "zip",
+      sha256:
+        "9d3b1d1fa58566bc71709347c4c9b83a0111d23a550daa93c3ee48e3150c4470",
+    };
+  } else {
+    throw new Error(
+      `Unsupported platform: ${os}/${cpu}. ` +
+        "Set QDRANT_URL to use an external Qdrant instance.",
+    );
+  }
+  return {
+    binaryName: "qdrant",
+    filename: `qdrant-${target}.tar.gz`,
+    format: "tar.gz",
+  };
+}
+
 export interface QdrantManagerConfig {
   url: string;
   storagePath?: string;
@@ -181,34 +220,18 @@ export class QdrantManager {
   private async installBinary(binaryPath: string): Promise<void> {
     const os = platform();
     const cpu = arch();
-
-    let target: string;
-    if (os === "darwin" && cpu === "arm64") {
-      target = "aarch64-apple-darwin";
-    } else if (os === "darwin" && cpu === "x64") {
-      target = "x86_64-apple-darwin";
-    } else if (os === "linux" && cpu === "x64") {
-      target = "x86_64-unknown-linux-musl";
-    } else if (os === "linux" && cpu === "arm64") {
-      target = "aarch64-unknown-linux-musl";
-    } else {
-      throw new Error(
-        `Unsupported platform: ${os}/${cpu}. ` +
-          "Set QDRANT_URL to use an external Qdrant instance.",
-      );
-    }
-
-    const filename = `qdrant-${target}.tar.gz`;
+    const release = resolveQdrantReleaseAsset(os, cpu);
+    const { filename } = release;
     const baseUrl = `https://github.com/qdrant/qdrant/releases/download/v${QDRANT_VERSION}`;
     const url = `${baseUrl}/${filename}`;
     const checksumUrl = `${baseUrl}/${filename}.sha256`;
 
     log.info({ url, binaryPath }, "Downloading Qdrant binary");
 
-    // Fetch the tarball and its SHA-256 checksum in parallel
+    // Fetch the archive and its SHA-256 checksum in parallel
     const [response, checksumResponse] = await Promise.all([
       fetch(url),
-      fetch(checksumUrl),
+      release.sha256 ? Promise.resolve(null) : fetch(checksumUrl),
     ]);
 
     if (!response.ok) {
@@ -217,15 +240,17 @@ export class QdrantManager {
       );
     }
 
-    const tarball = await response.arrayBuffer();
+    const archive = await response.arrayBuffer();
 
-    // Verify SHA-256 integrity if the checksum file is available
-    if (checksumResponse.ok) {
-      const checksumText = (await checksumResponse.text()).trim();
+    // Verify SHA-256 integrity if a pinned or published checksum is available
+    if (release.sha256 || checksumResponse?.ok) {
+      const checksumText = release.sha256
+        ? release.sha256
+        : (await checksumResponse!.text()).trim();
       // Checksum files contain "<hex>  <filename>" or just "<hex>"
       const expectedHash = checksumText.split(/\s+/)[0].toLowerCase();
       const actualHash = createHash("sha256")
-        .update(Buffer.from(tarball))
+        .update(Buffer.from(archive))
         .digest("hex");
 
       if (actualHash !== expectedHash) {
@@ -237,39 +262,45 @@ export class QdrantManager {
       log.info({ hash: actualHash }, "Qdrant binary checksum verified");
     } else {
       log.warn(
-        { checksumUrl, status: checksumResponse.status },
-        "Could not fetch Qdrant checksum — skipping integrity check",
+        { checksumUrl, status: checksumResponse?.status },
+        "Could not fetch Qdrant checksum; skipping integrity check",
       );
     }
 
-    // Extract the qdrant binary from the tarball
     const binDir = dirname(binaryPath);
     mkdirSync(binDir, { recursive: true });
-
-    // Write tarball to temp file, extract with tar
-    const tmpTar = join(binDir, `qdrant-download-${Date.now()}.tar.gz`);
-    writeFileSync(tmpTar, Buffer.from(tarball));
-
-    try {
-      const proc = Bun.spawn({
-        cmd: ["tar", "xzf", tmpTar, "-C", binDir, "qdrant"],
-        stdout: "ignore",
-        stderr: "pipe",
-      });
-      await proc.exited;
-      if (proc.exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text();
-        throw new Error(`Failed to extract Qdrant binary: ${stderr}`);
+    if (release.format === "zip") {
+      const { default: JSZip } = await import("jszip");
+      const zip = await JSZip.loadAsync(archive);
+      const entry = zip.file(release.binaryName);
+      if (!entry) {
+        throw new Error(`${filename} does not contain ${release.binaryName}.`);
       }
-    } finally {
+      writeFileSync(binaryPath, await entry.async("nodebuffer"));
+    } else {
+      const tmpTar = join(binDir, `qdrant-download-${Date.now()}.tar.gz`);
+      writeFileSync(tmpTar, Buffer.from(archive));
       try {
-        unlinkSync(tmpTar);
-      } catch {
-        /* ignore */
+        const proc = Bun.spawn({
+          cmd: ["tar", "xzf", tmpTar, "-C", binDir, release.binaryName],
+          stdout: "ignore",
+          stderr: "pipe",
+        });
+        await proc.exited;
+        if (proc.exitCode !== 0) {
+          const stderr = await new Response(proc.stderr).text();
+          throw new Error(`Failed to extract Qdrant binary: ${stderr}`);
+        }
+      } finally {
+        try {
+          unlinkSync(tmpTar);
+        } catch {}
       }
     }
 
-    chmodSync(binaryPath, 0o755);
+    if (os !== "win32") {
+      chmodSync(binaryPath, 0o755);
+    }
     log.info(
       { binaryPath, version: QDRANT_VERSION },
       "Qdrant binary installed",
@@ -395,7 +426,8 @@ export class QdrantManager {
   }
 
   private getBinaryPath(): string {
-    return join(getDataDir(), "qdrant", "bin", "qdrant");
+    const binaryName = platform() === "win32" ? "qdrant.exe" : "qdrant";
+    return join(getDataDir(), "qdrant", "bin", binaryName);
   }
 
   private cleanupStaleProcess(): void {
@@ -447,6 +479,9 @@ export class QdrantManager {
    * discoverable by tools that scan for "vellum" in process names.
    */
   private ensureVellumSymlink(binaryPath: string): string {
+    if (platform() === "win32") {
+      return binaryPath;
+    }
     const symlinkPath = join(dirname(binaryPath), "vellum-qdrant");
     const expectedTarget = realpathSync(binaryPath);
 

package/src/persistence/migrations/360-add-document-workspace-path.ts

@@ -7,20 +7,11 @@ const COLUMN_DEFINITION = "workspace_path TEXT";
 /**
  * Add `workspace_path` to `documents` and enforce one document per file.
  *
- * The column holds the workspace-relative path of the markdown file a document
- * is bound to. It is set when a client opens a workspace `.md` file through
- * `POST /v1/documents/for-workspace-file`, which gives the file a document
- * identity so comments, assistant iteration, and PDF export — all keyed off a
- * document id — work on it. Documents that have no file behind them (assistant
- * drafts, client-created surfaces) stay NULL.
- *
- * The unique index is partial (`WHERE workspace_path IS NOT NULL`) so the many
- * NULL rows stay unconstrained while a given file resolves to exactly one
- * document. The find-or-create route depends on that uniqueness for its
- * idempotency.
- *
- * Nullable with no backfill: nothing recorded a file binding before this
- * column existed, so pre-existing rows correctly stay NULL.
+ * The column and its partial unique index are unused by the daemon: no code
+ * reads or writes them. Some rows carry a non-NULL path; new rows stay NULL.
+ * The migration stays in the chain because migrations are append-only, and the
+ * drizzle model in `schema/documents.ts` carries the column so it keeps
+ * describing the physical table.
  *
  * Idempotent: the column add is guarded with `tableHasColumn` and the index
  * with `IF NOT EXISTS`, so a crash between the two does not break the next

package/src/persistence/schema/documents.ts

@@ -22,13 +22,13 @@ export const documents = sqliteTable(
     wordCount: integer("word_count").notNull().default(0),
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
-    // Workspace-relative path of the markdown file this document is bound to.
-    // NULL for documents with no file behind them.
+    // Unused by the daemon: no code reads or writes the column, and some rows
+    // carry a non-NULL path. It stays in the model because migration 360 puts
+    // it in the physical table and the model must keep describing that table.
     workspacePath: text("workspace_path"),
   },
   (table) => [
-    // Partial so the many file-less documents stay unconstrained while a given
-    // file resolves to exactly one document.
+    // Partial, so the NULL rows stay unconstrained.
     uniqueIndex("idx_documents_workspace_path")
       .on(table.workspacePath)
       .where(sql`workspace_path IS NOT NULL`),

package/src/plugin-api/constants.ts

@@ -39,6 +39,14 @@ export const HOOKS = {
 /** Union of every hook name declared in {@link HOOKS}. */
 export type HookName = (typeof HOOKS)[keyof typeof HOOKS];
 
+/**
+ * Message kind for the hidden user row that starts a voice escalation leg.
+ * Hooks use this marker to distinguish the continuation instruction from
+ * other transcript-suppressed prompts without depending on host voice code.
+ */
+export const VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND =
+  "voice_escalation_continuation";
+
 /**
  * Appended (inside the `<system_notice>` wrapper) to the internal continuation /
  * completion nudge strings that re-query the model. Those notices are injected

package/src/plugin-api/index.ts

@@ -67,7 +67,11 @@
  */
 
 export type { HookName } from "./constants.js";
-export { HOOKS, INTERNAL_NUDGE_OUTPUT_SUPPRESSION } from "./constants.js";
+export {
+  HOOKS,
+  INTERNAL_NUDGE_OUTPUT_SUPPRESSION,
+  VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
+} from "./constants.js";
 // Conversation message/content shapes. A hook receives the live message
 // history (e.g. `PostToolUseContext.latestMessages: Message[]`), so plugins
 // that inspect or narrow content blocks — reading a `tool_use` block's input,