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

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/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,

package/src/plugin-api/webhook-url.ts

@@ -90,22 +90,24 @@ function registrationType(plugin: string, route: string): string {
 }
 
 /**
- * Drop a trailing slash from a resolved callback URL.
+ * Keep a trailing slash on a resolved callback URL.
  *
- * The platform appends one to the callback URLs it hands back, and a provider
- * given `.../events-comms/` delivers to that spelling verbatim. The gateway
- * matches a plugin route against its declared path, which may never end in a
- * slash (see `IngressRouteSchema`), so the slash comes off once here rather
- * than at each plugin that registers a URL.
+ * Django in front of managed callbacks canonicalizes onto `/`. A vendor given
+ * the slashless spelling is 301'd, and clients that follow a 301 on POST
+ * typically retry as GET and drop the body. The gateway serves both spellings
+ * of a plugin webhook, so the slashed URL is the one to hand out.
  *
- * Only the path is ever trimmed: this resolver passes no query parameters, and
- * a URL carrying one is left alone rather than truncated.
+ * Query-bearing URLs are left alone: this resolver passes no query
+ * parameters, and appending there would cut into the query rather than the
+ * path. The callback path registered with the platform stays slashless. The
+ * platform strips slashes on store, and Django's path converter typically
+ * does not include the final `/` in the lookup key.
  */
-function withoutTrailingSlash(url: string): string {
+function withTrailingSlash(url: string): string {
   if (url.includes("?") || url.includes("#")) {
     return url;
   }
-  return url.replace(/\/+$/, "");
+  return url.endsWith("/") ? url : `${url}/`;
 }
 
 /**
@@ -147,5 +149,5 @@ export async function resolveWebhookUrl(
     undefined,
     sourceIdentifier,
   );
-  return withoutTrailingSlash(resolved);
+  return withTrailingSlash(resolved);
 }

package/src/plugins/defaults/main.ts

@@ -1,6 +1,8 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 
+import { resolveBundledDir } from "../../util/bundled-asset.js";
+
 /**
  * Filesystem-backed access to the first-party default plugins. This module
  * will eventually replace `defaults/index.ts`.
@@ -13,12 +15,10 @@ import { dirname, join, resolve } from "node:path";
  * that carries a `package.json` is one plugin, named by that manifest — the
  * same `package.json` the barrel imports for its `manifest.name`.
  *
- * Relying on the directory layout is safe because the assistant ships its
- * source hierarchy as-is (`bun --compile` is not supported), so the tree this
- * module reads in production is the tree the plugins are loaded from.
+ * Compiled builds ship this metadata tree beside the executable.
  */
 
-const DEFAULTS_DIR = import.meta.dir;
+const DEFAULTS_DIR = resolveBundledDir(import.meta.dir, ".", "default-plugins");
 
 /**
  * Route-namespace prefix for default plugins. A default plugin's route
@@ -105,9 +105,8 @@ export function getDefaultPluginManifestName(dirName: string): string | null {
  * `default-` prefix is stripped to recover the source directory, so a name
  * without the prefix (e.g. the bare directory name) resolves to `null`. The
  * containment guard rejects any `..`/nested segment taken from a URL path so it
- * can never escape the defaults tree. The path is derived from this module's
- * own location (`import.meta.dir`), so it resolves relative to the app source,
- * which the assistant always ships and runs un-bundled.
+ * can never escape the defaults tree. `DEFAULTS_DIR` resolves either the source
+ * tree or the externally packaged compiled metadata tree.
  */
 export function getDefaultPluginRoutesDir(name: string): string | null {
   if (!name.startsWith(DEFAULT_PLUGIN_NAMESPACE_PREFIX)) {

package/src/plugins/defaults/memory/graph/__tests__/conversation-graph-memory-v2-routing.test.ts

@@ -371,6 +371,38 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     expect(result.runMessages).toEqual(messages);
   });
 
+  test("separate routing history directs v1 retrieval without replacing model history", async () => {
+    const memory = makeMemory();
+    const config = makeConfig(false);
+    const callerText = "What is my preferred editor?";
+    const continuationText = "Continue the answer.";
+    const routingMessages = makeMessages(callerText);
+    const messages: Message[] = [
+      ...routingMessages,
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Let me check that." }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: continuationText }],
+      },
+    ];
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+      routingMessages,
+    );
+
+    expect(retrieveForTurnMock).toHaveBeenCalledWith(
+      expect.objectContaining({ userLastMessage: callerText }),
+    );
+    expect(result.runMessages).toEqual(messages);
+  });
+
   test("config on → v2 block prepended, mode is per-turn", async () => {
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
@@ -498,6 +530,51 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     ).toBe(false);
   });
 
+  test("separate routing history directs v2 retrieval while injection stays on model history", async () => {
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(true);
+    const callerText = "What is my preferred editor?";
+    const continuationText = "Continue the answer.";
+    const routingMessages = makeMessages(callerText);
+    const messages: Message[] = [
+      ...routingMessages,
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Let me check that." }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: continuationText }],
+      },
+    ];
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+      routingMessages,
+    );
+
+    expect(generateSparseEmbeddingMock.mock.calls).toContainEqual([callerText]);
+    expect(generateSparseEmbeddingMock.mock.calls).not.toContainEqual([
+      continuationText,
+    ]);
+    const tail = result.runMessages[result.runMessages.length - 1];
+    expect(tail?.role).toBe("user");
+    expect(tail?.content).toContainEqual({
+      type: "text",
+      text: continuationText,
+    });
+    expect(tail?.content[0]).toEqual(expect.objectContaining({ type: "text" }));
+    if (tail?.content[0]?.type !== "text") {
+      throw new Error("unexpected block type");
+    }
+    expect(tail.content[0].text).toContain("# memory/concepts/alice-vscode.md");
+  });
+
   test("config on with empty Qdrant hits → no retrieved concepts in the v2 block, v1 fallback skipped", async () => {
     // No `stageTurn` call — every channel returns `{ points: [] }` so the
     // candidate set is empty and retrieval contributes nothing. Always-candidate