@vellumai/assistant 0.11.3-dev.202608110527.eba8e13 → 0.11.3-dev.202608111429.ed4a99b

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.3-dev.202608110527.eba8e13",
+  "version": "0.11.3-dev.202608111429.ed4a99b",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/channel-delivery-store.test.ts

@@ -504,23 +504,23 @@ describe("channel-delivery-store", () => {
     expect(r1.conversationId).not.toBe(r2.conversationId);
   });
 
-  test("same chat/channel but different assistantId uses different conversations", () => {
-    const r1 = recordInbound("telegram", "chat-1", "msg-1", {
-      assistantId: "asst-A",
-    });
-    const r2 = recordInbound("telegram", "chat-1", "msg-2", {
-      assistantId: "asst-B",
-    });
+  test("the same chat keeps the same conversation", () => {
+    const r1 = recordInbound("telegram", "chat-1", "msg-1");
+    const r2 = recordInbound("telegram", "chat-1", "msg-2");
 
-    expect(r1.conversationId).not.toBe(r2.conversationId);
+    expect(r1.conversationId).toBe(r2.conversationId);
   });
 
-  test("no assistantId defaults to self-scoped key", () => {
-    const r1 = recordInbound("telegram", "chat-1", "msg-1");
-    const r2 = recordInbound("telegram", "chat-1", "msg-2", {
-      assistantId: "self",
-    });
-    expect(r1.conversationId).toBe(r2.conversationId);
+  test("binds under the self-scoped key", () => {
+    // The prefix is a stored format, not an internal detail. It reads like a
+    // leftover of the assistant id that used to be interpolated into it, so
+    // pin it: rows already written under `asst:self:` stop resolving if a
+    // later tidy-up drops it.
+    const { conversationId } = recordInbound("telegram", "chat-1", "msg-1");
+
+    expect(
+      getConversationByKey("asst:self:telegram:chat-1")?.conversationId,
+    ).toBe(conversationId);
   });
 
   test("external bindings allow multiple Slack thread anchors per channel", () => {

package/src/__tests__/edit-propagation.test.ts

@@ -145,7 +145,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "new text",
     });
@@ -187,7 +186,6 @@ describe("Slack edit propagation", () => {
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
       sourceThreadId: threadTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "new text",
     });
@@ -216,7 +214,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "first edit",
     });
@@ -239,7 +236,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "second edit",
     });
@@ -272,7 +268,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       // Same text as stored -- simulates a Slack unfurl `message_changed`
       // where only attachments changed.
@@ -313,7 +308,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "edited searchable text",
     });
@@ -341,7 +335,6 @@ describe("Slack edit propagation", () => {
       // sourceMessageId points at a ts that was never stored.
       externalMessageId: nextEditEventId(),
       sourceMessageId: "9999.0000",
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "new text",
     });

package/src/__tests__/mcp-list-plugin-servers.test.ts

@@ -204,12 +204,12 @@ describe("internal_mcp_list, plugin-declared servers", () => {
     expect(workspace.hasStaticAuth).toBe(true);
   });
 
-  test("plugin servers default to high risk", async () => {
+  test("plugin servers default to low risk", async () => {
     writePlugin("unabyss", unabyssManifest());
 
     const servers = await listServers();
     expect(servers.find((s) => s.id === "unabyss")!.defaultRiskLevel).toEqual(
-      "high",
+      "low",
     );
   });
 

package/src/__tests__/run-conversation-turn-persistence.test.ts

@@ -5,12 +5,15 @@ import {
   ensureConversationExists,
   getConversation,
 } from "../persistence/conversation-crud.js";
+import { getConversationByKey } from "../persistence/conversation-key-store.js";
 import {
   isEchoSuppressedUserMessage,
   isReplyPushIneligibleUserMessage,
 } from "../persistence/conversation-types.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { buildScopedConversationKey } from "../persistence/delivery-crud.js";
+import { getBindingByConversation } from "../persistence/external-conversation-store.js";
 
 await initializeDb();
 
@@ -37,6 +40,7 @@ mock.module("../runtime/sync/resource-sync-events.js", () => ({
 let lastProcessMessageConversationId: string | undefined;
 let lastProcessMessageOptions: Record<string, unknown> | undefined;
 let lastEnqueueOptions: Record<string, unknown> | undefined;
+let lastTurnChannelContext: unknown;
 let conversationIsProcessing = false;
 mock.module("../daemon/conversation-store.js", () => ({
   getOrCreateConversation: async (
@@ -57,6 +61,9 @@ mock.module("../daemon/conversation-store.js", () => ({
     }
     return {
       abortController: undefined,
+      setTurnChannelContext: (ctx: unknown) => {
+        lastTurnChannelContext = ctx;
+      },
       isProcessing: () => conversationIsProcessing,
       async processMessage(processOptions: Record<string, unknown>) {
         // The row must already exist by the time the turn persists its user
@@ -95,6 +102,7 @@ describe("runConversationTurn persistence", () => {
     lastProcessMessageConversationId = undefined;
     lastProcessMessageOptions = undefined;
     lastEnqueueOptions = undefined;
+    lastTurnChannelContext = undefined;
     conversationIsProcessing = false;
   });
 
@@ -193,3 +201,217 @@ describe("runConversationTurn provenance", () => {
     expect(isReplyPushIneligibleUserMessage(metadata)).toBe(true);
   });
 });
+
+/**
+ * Addressing a turn by chat rather than by conversation id.
+ *
+ * The point of these is not that the turn runs (that is the same code path
+ * either way) but that the conversation it runs in is the one the rest of
+ * the assistant already addresses by those coordinates. A caller keeping its
+ * own chat-to-conversation map would pass every test above and still be
+ * invisible to conversation reset, to the deny lanes, and to the channel
+ * metadata the conversation list renders.
+ */
+describe("runConversationTurn channel binding", () => {
+  const CHANNEL = {
+    sourceChannel: "plugin" as const,
+    externalChatId: "imessage:+12025550142",
+    displayName: "Ada",
+  };
+
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM messages");
+    db.run("DELETE FROM external_conversation_bindings");
+    db.run("DELETE FROM conversation_keys");
+    db.run("DELETE FROM conversations");
+    listChangedCalls.length = 0;
+    lastProcessMessageOptions = undefined;
+    lastEnqueueOptions = undefined;
+    lastTurnChannelContext = undefined;
+    conversationIsProcessing = false;
+  });
+
+  test("resolves the chat to the conversation inbound would have used", async () => {
+    const result = await runConversationTurn({
+      channel: CHANNEL,
+      content: [{ type: "text", text: "hello" }],
+    });
+
+    // The public name for this conversation, which is what reset and the deny
+    // lanes address it by.
+    expect(
+      getConversationByKey(
+        buildScopedConversationKey(
+          CHANNEL.sourceChannel,
+          CHANNEL.externalChatId,
+        ),
+      )?.conversationId,
+    ).toBe(result.conversationId);
+  });
+
+  test("keeps the same chat in the same conversation across turns", async () => {
+    const first = await runConversationTurn({
+      channel: CHANNEL,
+      content: [{ type: "text", text: "hello" }],
+    });
+    const second = await runConversationTurn({
+      channel: CHANNEL,
+      content: [{ type: "text", text: "still me" }],
+    });
+
+    expect(second.conversationId).toBe(first.conversationId);
+    // Only the first turn minted a conversation.
+    expect(listChangedCalls).toEqual([
+      { kind: "created", conversationId: first.conversationId },
+    ]);
+  });
+
+  test("gives a different chat its own conversation", async () => {
+    const ada = await runConversationTurn({
+      channel: CHANNEL,
+      content: [{ type: "text", text: "hello" }],
+    });
+    const grace = await runConversationTurn({
+      channel: { ...CHANNEL, externalChatId: "imessage:+12025550188" },
+      content: [{ type: "text", text: "hello" }],
+    });
+
+    expect(grace.conversationId).not.toBe(ada.conversationId);
+  });
+
+  test("records the channel metadata the conversation list reads", async () => {
+    const result = await runConversationTurn({
+      channel: { ...CHANNEL, externalUserId: "+12025550142" },
+      content: [{ type: "text", text: "hello" }],
+    });
+
+    const binding = getBindingByConversation(result.conversationId);
+    expect(binding).toMatchObject({
+      sourceChannel: "plugin",
+      externalChatId: CHANNEL.externalChatId,
+      externalUserId: "+12025550142",
+      displayName: "Ada",
+    });
+  });
+
+  test("follows the vendor when a display name changes", async () => {
+    await runConversationTurn({
+      channel: CHANNEL,
+      content: [{ type: "text", text: "hello" }],
+    });
+    const result = await runConversationTurn({
+      channel: { ...CHANNEL, displayName: "Ada L." },
+      content: [{ type: "text", text: "renamed" }],
+    });
+
+    expect(getBindingByConversation(result.conversationId)?.displayName).toBe(
+      "Ada L.",
+    );
+  });
+
+  test("runs the turn on the channel it was addressed by", async () => {
+    // Runtime assembly reads the per-turn channel first and only then the
+    // conversation's origin, so a turn into a conversation whose origin was
+    // never recorded would otherwise run as `vellum`. That is the wrong
+    // channel for the message row and for the permission cascade the tools
+    // are approved against.
+    await runConversationTurn({
+      channel: CHANNEL,
+      content: [{ type: "text", text: "hello" }],
+    });
+
+    expect(lastTurnChannelContext).toEqual({
+      userMessageChannel: "plugin",
+      assistantMessageChannel: "plugin",
+    });
+    expect(lastProcessMessageOptions?.metadata).toMatchObject({
+      userMessageChannel: "plugin",
+      assistantMessageChannel: "plugin",
+    });
+  });
+
+  test("a queued turn carries its own channel rather than inheriting one", async () => {
+    // The drain happens after this call returns and reads the channel off the
+    // queued message, falling back to whichever turn was in flight. On a
+    // conversation shared with another channel that fallback is someone
+    // else's channel.
+    conversationIsProcessing = true;
+
+    const result = await runConversationTurn({
+      channel: CHANNEL,
+      content: [{ type: "text", text: "hello" }],
+    });
+
+    expect(result.queued).toBe(true);
+    expect(lastEnqueueOptions?.metadata).toMatchObject({
+      userMessageChannel: "plugin",
+      assistantMessageChannel: "plugin",
+    });
+  });
+
+  test("leaves the channel unset when the turn names none", async () => {
+    // Clearing rather than leaving whatever the last turn set: a stale
+    // context would report this turn on a channel it has nothing to do with.
+    await runConversationTurn({
+      content: [{ type: "text", text: "hello" }],
+    });
+
+    expect(lastTurnChannelContext).toBeNull();
+    expect(lastProcessMessageOptions?.metadata).toEqual({ automated: true });
+  });
+
+  test("keeps a known sender when a later turn omits it", async () => {
+    // A plugin that knows only the chat coordinates this time is silent about
+    // the sender, not asserting it has none. Erasing the stored name on that
+    // silence drops it from the conversation and session APIs.
+    await runConversationTurn({
+      channel: { ...CHANNEL, externalUserId: "+12025550142" },
+      content: [{ type: "text", text: "hello" }],
+    });
+
+    const result = await runConversationTurn({
+      channel: {
+        sourceChannel: CHANNEL.sourceChannel,
+        externalChatId: CHANNEL.externalChatId,
+      },
+      content: [{ type: "text", text: "still me" }],
+    });
+
+    expect(getBindingByConversation(result.conversationId)).toMatchObject({
+      externalUserId: "+12025550142",
+      displayName: "Ada",
+    });
+  });
+
+  test("clears a sender the caller explicitly says is gone", async () => {
+    await runConversationTurn({
+      channel: CHANNEL,
+      content: [{ type: "text", text: "hello" }],
+    });
+
+    const result = await runConversationTurn({
+      channel: { ...CHANNEL, displayName: null },
+      content: [{ type: "text", text: "anonymous now" }],
+    });
+
+    expect(
+      getBindingByConversation(result.conversationId)?.displayName,
+    ).toBeNull();
+  });
+
+  test("an explicit conversation id wins over the address", async () => {
+    // Two different conversations were named. Re-resolving would overrule the
+    // caller, so the explicit one is honoured and nothing is bound behind it.
+    const existing = createConversation({ title: "chosen" });
+
+    const result = await runConversationTurn({
+      conversationId: existing.id,
+      channel: CHANNEL,
+      content: [{ type: "text", text: "hello" }],
+    });
+
+    expect(result.conversationId).toBe(existing.id);
+    expect(getBindingByConversation(existing.id)).toBeNull();
+  });
+});

package/src/__tests__/slack-edit-ordering-characterization.test.ts

@@ -59,7 +59,6 @@ async function applyEdit(eventId: string, content: string): Promise<void> {
     conversationExternalId: CHANNEL,
     externalMessageId: eventId,
     sourceMessageId: ORIGINAL_TS,
-    canonicalAssistantId: "self",
     assistantId: "self",
     content,
   });

package/src/cli/commands/memory/__tests__/memory-v3.test.ts

@@ -2,12 +2,13 @@
  * Tests for the `assistant memory v3` CLI subgroup (section-lane model).
  *
  * Validates:
- *   - Subcommand registration (rebuild-index, backfill-sections) under
- *     `memory v3`.
- *   - Each subcommand maps to the right `cliIpcCall` method.
+ *   - Subcommand registration (rebuild-index, backfill-sections, gate-stats)
+ *     under `memory v3`.
+ *   - `rebuild-index` and `backfill-sections` route through IPC to the daemon.
  *   - `backfill-sections` passes a long IPC timeout (the one-time full-corpus
- *     embed easily outlasts the default 60s), while `rebuild-index` does not.
- *   - IPC error paths return a non-zero exit code without throwing.
+ *     embed easily outlasts the default 60s).
+ *   - `gate-stats` calls handleMemoryV3GateStats directly — no daemon required.
+ *   - Error paths return a non-zero exit code without throwing.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -39,6 +40,47 @@ let mockIpcResult: {
 /** Captured log output for assertion. */
 let logOutput: string[] = [];
 
+/** Shared fake gate-stats payload used across gate-stats tests. */
+const fakeGateStats = {
+  lookbackDays: 30,
+  totalRuns: 10,
+  buckets: [
+    {
+      pageCountRange: "0–9",
+      total: 2,
+      scored: 1,
+      passed: 2,
+      scoredPassRate: 1,
+      reasons: { dense_pass: 1, dense_disabled: 1 },
+    },
+    {
+      pageCountRange: "10–49",
+      total: 5,
+      scored: 4,
+      passed: 3,
+      scoredPassRate: 0.75,
+      reasons: { dense_pass: 3, fail_no_signal: 1 },
+    },
+    {
+      pageCountRange: "50–199",
+      total: 2,
+      scored: 2,
+      passed: 1,
+      scoredPassRate: 0.5,
+      reasons: { dense_pass: 1, fail_no_signal: 1 },
+    },
+    {
+      pageCountRange: "200+",
+      total: 1,
+      scored: 1,
+      passed: 0,
+      scoredPassRate: 0,
+      reasons: { fail_no_signal: 1 },
+    },
+  ],
+  unknownPageCount: { total: 0, passed: 0, reasons: {} },
+};
+
 // ---------------------------------------------------------------------------
 // Mocks
 // ---------------------------------------------------------------------------
@@ -68,6 +110,33 @@ mock.module("../../../../util/logger.js", () => ({
   getCliLogger: () => fakeLogger,
 }));
 
+// ---------------------------------------------------------------------------
+// gate-stats direct-invocation mocks
+// ---------------------------------------------------------------------------
+
+/** Args captured from the last handleMemoryV3GateStats call. */
+let lastGateStatsArgs: { lookbackDays: number; db: unknown } | null = null;
+
+/** What handleMemoryV3GateStats returns, or an error to throw. */
+let gateStatsImpl: (() => unknown) | null = null;
+
+mock.module(
+  "../../../../plugins/defaults/memory/src/memory-v3-routes.js",
+  () => ({
+    handleMemoryV3GateStats: (lookbackDays: number, db: unknown) => {
+      lastGateStatsArgs = { lookbackDays, db };
+      if (gateStatsImpl) {
+        return gateStatsImpl();
+      }
+      return fakeGateStats;
+    },
+  }),
+);
+
+mock.module("../../../../persistence/db-connection.js", () => ({
+  getTelemetrySqlite: () => ({}),
+}));
+
 // ---------------------------------------------------------------------------
 // Import modules under test (after mocks)
 // ---------------------------------------------------------------------------
@@ -135,6 +204,8 @@ beforeEach(() => {
     ok: true,
     result: { articles: 3, sections: 12, failures: 0 },
   };
+  lastGateStatsArgs = null;
+  gateStatsImpl = null;
   logOutput = [];
   process.exitCode = 0;
 });
@@ -155,6 +226,7 @@ describe("subcommand registration", () => {
       "backfill-sections",
       "eval",
       "eval-tally",
+      "gate-stats",
       "rebuild-index",
     ]);
   });
@@ -236,3 +308,54 @@ describe("memory v3 backfill-sections", () => {
     expect(exitCode).toBe(1);
   });
 });
+
+// ---------------------------------------------------------------------------
+// gate-stats (direct invocation — no daemon required)
+// ---------------------------------------------------------------------------
+
+describe("memory v3 gate-stats", () => {
+  test("calls handleMemoryV3GateStats directly with default lookback (no IPC)", async () => {
+    const { exitCode } = await runCommand(["memory", "v3", "gate-stats"]);
+
+    expect(exitCode).toBe(0);
+    // Must NOT have gone through IPC.
+    expect(lastIpcCall).toBeNull();
+    // Must have called the handler directly with the default lookback.
+    expect(lastGateStatsArgs!.lookbackDays).toBe(30);
+  });
+
+  test("forwards --lookback-days directly to handleMemoryV3GateStats", async () => {
+    await runCommand(["memory", "v3", "gate-stats", "--lookback-days", "7"]);
+
+    expect(lastIpcCall).toBeNull();
+    expect(lastGateStatsArgs!.lookbackDays).toBe(7);
+  });
+
+  test("prints formatted table on success (no --json)", async () => {
+    await runCommand(["memory", "v3", "gate-stats"]);
+
+    expect(logOutput.some((l) => l.includes("Gate-stats"))).toBe(true);
+    expect(logOutput.some((l) => l.includes("10–49"))).toBe(true);
+    expect(logOutput.some((l) => l.includes("75.0%"))).toBe(true);
+  });
+
+  test("emits raw JSON with --json", async () => {
+    await runCommand(["memory", "v3", "gate-stats", "--json"]);
+
+    const raw = logOutput.join("");
+    const parsed = JSON.parse(raw) as typeof fakeGateStats;
+    expect(parsed.totalRuns).toBe(10);
+    expect(parsed.buckets).toHaveLength(4);
+  });
+
+  test("exits with code 1 when handleMemoryV3GateStats throws", async () => {
+    gateStatsImpl = () => {
+      throw new Error("telemetry DB locked");
+    };
+
+    const { exitCode } = await runCommand(["memory", "v3", "gate-stats"]);
+
+    expect(exitCode).toBe(1);
+    expect(logOutput.some((l) => l.includes("telemetry DB locked"))).toBe(true);
+  });
+});

package/src/cli/commands/memory/index.help.ts

@@ -606,7 +606,9 @@ that live state safely.
 
 Examples:
   $ assistant memory v3 rebuild-index
-  $ assistant memory v3 backfill-sections`,
+  $ assistant memory v3 backfill-sections
+  $ assistant memory v3 gate-stats
+  $ assistant memory v3 gate-stats --lookback-days 7 --json`,
       subcommands: [
         {
           name: "rebuild-index",
@@ -716,6 +718,46 @@ Examples:
   $ assistant memory v3 eval --snapshot .mv3/snapshot/concepts --staging .mv3/staging --out .mv3/eval
   $ assistant memory v3 eval --snapshot .mv3/snapshot/concepts --staging .mv3/staging --out .mv3/eval --turns-file .mv3/eval/key.json
   $ assistant memory v3 eval --snapshot .mv3/snapshot/concepts --staging .mv3/staging --out .mv3/eval --exclude-conversation <migration-conv-id>`,
+        },
+        {
+          name: "gate-stats",
+          description:
+            "Show injection gate pass rates bucketed by corpus size (read-only)",
+          options: [
+            {
+              flags: "--lookback-days <n>",
+              description: "Days of telemetry to aggregate (1–90, default 30)",
+              defaultValue: "30",
+            },
+            {
+              flags: "--json",
+              description: "Emit raw JSON instead of a formatted table",
+            },
+          ],
+          helpText: `
+Reads the memory v3 injection gate telemetry outbox and prints pass rates
+and reason distributions grouped by concept page count bucket
+(0–9 / 10–49 / 50–199 / 200+). Scored runs (dense lane was available and
+actually weighed scores) are reported separately from pass-open shortcuts
+(dense disabled / unavailable / gate threw) so scoredPassRate reflects
+only contested gate decisions — the signal relevant for threshold calibration.
+
+Coverage is limited to runs still pending platform flush. In a healthy system
+the outbox holds only the last few minutes to hours of events, so
+--lookback-days is an upper bound, not a guarantee; long-window aggregation
+lives on the platform side on top of flushed watchdog events.
+
+Reads the telemetry database directly — the assistant does not need to be
+running.
+
+Intended use: verify that gate firing rates shift as expected after a
+config or threshold change, and check whether the bm25-auto-calibration
+flag is worth enabling for large corpora.
+
+Examples:
+  $ assistant memory v3 gate-stats
+  $ assistant memory v3 gate-stats --lookback-days 7
+  $ assistant memory v3 gate-stats --json | jq '.buckets[] | select(.pageCountRange == "200+")'`,
         },
         {
           name: "eval-tally",