@vellumai/assistant 0.11.3-dev.202608111523.8a0fdc8 → 0.11.3-dev.202608111821.01ecb1d

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.3-dev.202608111523.8a0fdc8",
+  "version": "0.11.3-dev.202608111821.01ecb1d",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/call-setup-flow-name-capture.test.ts

@@ -360,7 +360,6 @@ describe("CallSetupFlow name capture", () => {
     ).toEqual({ from: PHONE_NUMBER, callerName: CALLER_NAME });
     expect(f.notifyCalls).toEqual([
       {
-        canonicalAssistantId: "self",
         sourceChannel: "phone",
         conversationExternalId: PHONE_NUMBER,
         actorExternalId: PHONE_NUMBER,

package/src/__tests__/non-member-access-request.test.ts

@@ -501,7 +501,6 @@ describe("access-request-helper unit tests", () => {
 
   test("notifyGuardianOfAccessRequest returns no_sender_id when actorExternalId is absent", async () => {
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
       actorExternalId: undefined,
@@ -522,7 +521,6 @@ describe("access-request-helper unit tests", () => {
 
   test("notifyGuardianOfAccessRequest creates request with self-healed principal when no binding exists", async () => {
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
       actorExternalId: "unknown-user",
@@ -565,7 +563,6 @@ describe("access-request-helper unit tests", () => {
     });
 
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "tg-chat",
       actorExternalId: "unknown-tg-user",
@@ -619,7 +616,6 @@ describe("access-request-helper unit tests", () => {
     });
 
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
       actorExternalId: "unknown-user",
@@ -660,7 +656,6 @@ describe("access-request-helper unit tests", () => {
     });
 
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
       actorExternalId: "unknown-user",
@@ -688,7 +683,6 @@ describe("access-request-helper unit tests", () => {
   test("notifyGuardianOfAccessRequest resolves the vellum anchor from the gateway delivery", async () => {
     // Only the vellum anchor (seeded in resetState) is served by the gateway.
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
       actorExternalId: "unknown-user",
@@ -722,7 +716,6 @@ describe("access-request-helper unit tests", () => {
 
     await expect(
       notifyGuardianOfAccessRequest({
-        canonicalAssistantId: "self",
         sourceChannel: "telegram",
         conversationExternalId: "chat-123",
         actorExternalId: "unknown-user",
@@ -739,7 +732,6 @@ describe("access-request-helper unit tests", () => {
 
   test("notifyGuardianOfAccessRequest for voice channel includes actorDisplayName in contextPayload", async () => {
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "phone",
       conversationExternalId: "+15559998888",
       actorExternalId: "+15559998888",
@@ -770,7 +762,6 @@ describe("access-request-helper unit tests", () => {
 
   test("notifyGuardianOfAccessRequest includes requestCode in contextPayload", async () => {
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
       actorExternalId: "unknown-user",
@@ -794,7 +785,6 @@ describe("access-request-helper unit tests", () => {
     // is created and the status is forwarded to the card payload. (A `revoked`
     // status would instead suppress — covered by the keep-out tests.)
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
       actorExternalId: "pending-user",
@@ -834,7 +824,6 @@ describe("access-request-helper unit tests", () => {
     };
 
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "phone",
       conversationExternalId: "+15556667777",
       actorExternalId: "+15556667777",
@@ -897,7 +886,6 @@ describe("access-request-helper unit tests", () => {
     };
 
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-123",
       actorExternalId: "unknown-user",
@@ -929,7 +917,6 @@ describe("access-request-helper unit tests", () => {
     // request row. A revoked/blocked contact is deliberately kept out — no new
     // prompt, signal, or pending request.
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-kept-out",
       actorExternalId: "revoked-user",
@@ -969,7 +956,6 @@ describe("access-request-helper unit tests", () => {
     });
 
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-parked",
       actorExternalId: "parked-user",
@@ -1006,7 +992,6 @@ describe("access-request-helper unit tests", () => {
     });
 
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-approved",
       actorExternalId: "approved-user",
@@ -1047,7 +1032,6 @@ describe("access-request-helper unit tests", () => {
     bridgeState.requests.get(requestId)!.updatedAt = staleUpdatedAt;
 
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-stale",
       actorExternalId: "stale-user",
@@ -1082,7 +1066,6 @@ describe("access-request-helper unit tests", () => {
     });
 
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-flip",
       actorExternalId: "flip-user",
@@ -1101,7 +1084,6 @@ describe("access-request-helper unit tests", () => {
     // Suppression is scoped to the sender via their own contact status, so a
     // kept-out contact never bleeds into a different sender's prompt.
     const keptOut = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-kept",
       actorExternalId: "revoked-user",
@@ -1112,7 +1094,6 @@ describe("access-request-helper unit tests", () => {
 
     // A different sender with no keep-out still gets a fresh prompt.
     const result = await notifyGuardianOfAccessRequest({
-      canonicalAssistantId: "self",
       sourceChannel: "telegram",
       conversationExternalId: "chat-fresh",
       actorExternalId: "fresh-user",
@@ -1141,7 +1122,6 @@ describe("maybeNotifyGuardianOfAdmittedContact", () => {
   });
 
   const baseParams = {
-    canonicalAssistantId: "self",
     sourceChannel: "telegram" as const,
     conversationExternalId: "chat-123",
     actorExternalId: "user-unknown-456",

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

@@ -1,9 +1,32 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
+/**
+ * `runConversationTurn` against the real conversation store, the real agent
+ * loop and the real database. The only thing stood in for is the provider's
+ * HTTP boundary — `resolveProviderFromConnection` hands back a scripted mock
+ * — so everything these tests read back (the `conversations` row, the user
+ * message and the metadata stamped on it, the channel binding) is what
+ * production wrote, not a stub mirroring what production is believed to do.
+ */
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+
+import type { AssistantEvent } from "../api/index.js";
+import { clearAllActiveConversations } from "../daemon/conversation-store.js";
+import {
+  conversationMetadataSyncTag,
+  SYNC_TAGS,
+} from "../daemon/message-types/sync.js";
 import {
   createConversation,
-  ensureConversationExists,
   getConversation,
+  getMessages,
+  parseMessageMetadata,
 } from "../persistence/conversation-crud.js";
 import { getConversationByKey } from "../persistence/conversation-key-store.js";
 import {
@@ -14,97 +37,142 @@ 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";
+import { createConnection } from "../providers/inference/connections.js";
+import * as providerRegistry from "../providers/registry.js";
+import type { Provider, ProviderResponse } from "../providers/types.js";
+import { createMockProvider, textResponse } from "./helpers/mock-provider.js";
+import { setConfig } from "./helpers/set-config.js";
+import { waitFor } from "./helpers/wait-for.js";
 
 await initializeDb();
 
-// Capture the list-invalidation calls `runConversationTurn` fires when it
-// creates a brand-new conversation row, without pulling in the real sync
-// publisher (which reaches for live SSE subscribers).
-const listChangedCalls: Array<{ kind: string; conversationId: string }> = [];
-mock.module("../runtime/sync/resource-sync-events.js", () => ({
-  publishConversationListAndMetadataChanged: (
-    kind: string,
-    conversationId: string,
-  ) => {
-    listChangedCalls.push({ kind, conversationId });
-  },
-}));
-
-// Stub the heavy machinery: the in-memory conversation build (provider wiring,
-// system prompt, history hydration) and the SSE event fan-out. The agent turn
-// itself is a no-op — this test only asserts that the `conversations` row is
-// persisted before the turn runs. The real `getOrCreateConversation` now
-// creates the DB row before hydrating, so the mock mirrors that by calling
-// `ensureConversationExists`. The persistence module is intentionally NOT
-// mocked so the real `ensureConversationExists` runs against the real DB.
-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 (
-    conversationId: string,
-    options?: { conversationType?: string },
-  ) => {
-    if (!getConversation(conversationId)) {
-      if (options?.conversationType) {
-        createConversation({
-          id: conversationId,
-          conversationType: options.conversationType as
-            | "standard"
-            | "background",
-        });
-      } else {
-        ensureConversationExists(conversationId, "vellum");
-      }
-    }
-    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
-        // message — record the id so the FK precondition can be asserted.
-        lastProcessMessageConversationId = conversationId;
-        lastProcessMessageOptions = processOptions;
-        return "user-message-id";
-      },
-      enqueueMessage: (enqueueOptions: Record<string, unknown>) => {
-        lastEnqueueOptions = enqueueOptions;
-        return { rejected: false };
-      },
-    };
+// A conversation is built against the default provider, which resolves from
+// config through a connection row. Both are seeded for real so the store takes
+// the same path it takes in the daemon; only the provider the connection
+// resolves to is scripted.
+setConfig("llm", {
+  profiles: {
+    test: {
+      provider: "anthropic",
+      provider_connection: "test-conn",
+      model: "claude-opus-4-6",
+    },
   },
-}));
+  activeProfile: "test",
+});
+setConfig("memory", { enabled: false, v2: { enabled: false } });
+
+createConnection(getDb(), {
+  name: "test-conn",
+  provider: "anthropic",
+  auth: { type: "api_key", credential: "credential/test/api_key" },
+});
 
-mock.module("../runtime/assistant-event-hub.js", () => ({
-  broadcastMessage: () => {},
-}));
+// The SSE fan-out is the one collaborator with nowhere to write in a test —
+// every publish the turn makes (including the list invalidations asserted
+// below, which reach clients through the real `resource-sync-events`) funnels
+// through here.
+const broadcasts: AssistantEvent[] = [];
+mock.module(
+  "../runtime/assistant-event-hub.js",
+  (): Partial<typeof import("../runtime/assistant-event-hub.js")> => ({
+    broadcastMessage: (msg: AssistantEvent) => {
+      broadcasts.push(msg);
+    },
+  }),
+);
+
+const { provider: scriptedProvider } = createMockProvider([
+  textResponse("scripted reply"),
+]);
+
+let gate: Promise<void> | undefined;
+let releaseGate: (() => void) | undefined;
 
-mock.module("../providers/media-resolve.js", () => ({
-  resolveMediaSourceData: () => null,
-}));
+/**
+ * Park the next turn inside the provider call until released, so a second turn
+ * arrives while the conversation is genuinely processing rather than while a
+ * stub reports that it is.
+ */
+function holdTheTurnOpen(): void {
+  let resolveGate!: () => void;
+  gate = new Promise<void>((resolve) => {
+    resolveGate = resolve;
+  });
+  releaseGate = () => {
+    gate = undefined;
+    releaseGate = undefined;
+    resolveGate();
+  };
+}
+
+// A test that fails before releasing must not leave the next one parked on a
+// gate it never opened.
+afterEach(() => releaseGate?.());
+
+const provider: Provider = {
+  name: "scripted",
+  async sendMessage(messages, options): Promise<ProviderResponse> {
+    await gate;
+    return scriptedProvider.sendMessage(messages, options);
+  },
+};
+
+spyOn(providerRegistry, "resolveProviderFromConnection").mockResolvedValue(
+  provider,
+);
 
-// Import under test AFTER the mocks are registered so its dynamic imports
-// resolve to the stubs above.
 const { runConversationTurn } =
   await import("../plugin-api/conversation-turn.js");
 
+/**
+ * The list-level invalidations a turn published, as the tag sets clients
+ * consume. Only a shape-changing reason carries the list umbrella tag, so a
+ * reason that merely edits an existing row (a generated title) is excluded —
+ * these are the announcements that a conversation appeared or vanished.
+ */
+function listInvalidations(): string[][] {
+  return broadcasts
+    .filter((msg) => msg.type === "sync_changed")
+    .map((msg) => msg.tags)
+    .filter((tags) => tags.includes(SYNC_TAGS.conversationsList));
+}
+
+/** The tag set `publishConversationListAndMetadataChanged` emits for a new row. */
+function creationTags(conversationId: string): string[] {
+  return [
+    SYNC_TAGS.conversationsList,
+    conversationMetadataSyncTag(conversationId),
+  ];
+}
+
+/** User message rows of a conversation, oldest first. */
+function userRows(conversationId: string) {
+  return getMessages(conversationId).filter((row) => row.role === "user");
+}
+
+/** The metadata a turn persisted on a message row, parsed as consumers read it. */
+function metadataOf(
+  row: { metadata: string | null } | undefined,
+): Record<string, unknown> | undefined {
+  return parseMessageMetadata(row?.metadata ?? null);
+}
+
+function resetDb(): void {
+  // In-memory conversations outlive the rows they were hydrated from, and a
+  // reused id would otherwise hand the next test a Conversation whose
+  // `conversations` row this wipe just deleted.
+  clearAllActiveConversations();
+  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");
+  broadcasts.length = 0;
+}
+
 describe("runConversationTurn persistence", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run("DELETE FROM messages");
-    db.run("DELETE FROM conversations");
-    listChangedCalls.length = 0;
-    lastProcessMessageConversationId = undefined;
-    lastProcessMessageOptions = undefined;
-    lastEnqueueOptions = undefined;
-    lastTurnChannelContext = undefined;
-    conversationIsProcessing = false;
-  });
+  beforeEach(resetDb);
 
   test("persists a conversations row for a freshly-minted conversation", async () => {
     const result = await runConversationTurn({
@@ -112,16 +180,20 @@ describe("runConversationTurn persistence", () => {
     });
 
     // The row exists on disk — not just as an in-memory Conversation object —
-    // so the user-message persist inside the turn has its FK target.
-    const row = getConversation(result.conversationId);
-    expect(row?.id).toBe(result.conversationId);
-    expect(lastProcessMessageConversationId).toBe(result.conversationId);
+    // and the user message the turn persisted found its FK target there.
+    expect(getConversation(result.conversationId)?.id).toBe(
+      result.conversationId,
+    );
+    expect(userRows(result.conversationId).map((row) => row.id)).toEqual([
+      result.userMessageId,
+    ]);
 
     // Siblings/sidebars are told about the new conversation, mirroring the
     // send-message route.
-    expect(listChangedCalls).toEqual([
-      { kind: "created", conversationId: result.conversationId },
-    ]);
+    expect(listInvalidations()).toEqual([creationTags(result.conversationId)]);
+    expect(
+      broadcasts.filter((msg) => msg.type === "conversation_list_invalidated"),
+    ).toEqual([{ type: "conversation_list_invalidated", reason: "created" }]);
   });
 
   test("adopts a caller-supplied conversation id verbatim when no row exists", async () => {
@@ -134,12 +206,12 @@ describe("runConversationTurn persistence", () => {
 
     expect(result.conversationId).toBe(conversationId);
     expect(getConversation(conversationId)?.id).toBe(conversationId);
-    expect(listChangedCalls).toEqual([{ kind: "created", conversationId }]);
+    expect(listInvalidations()).toEqual([creationTags(conversationId)]);
   });
 
   test("is a no-op for an already-persisted conversation row", async () => {
     const existing = createConversation({ title: "already here" });
-    listChangedCalls.length = 0;
+    broadcasts.length = 0;
 
     const result = await runConversationTurn({
       conversationId: existing.id,
@@ -149,7 +221,7 @@ describe("runConversationTurn persistence", () => {
     expect(result.conversationId).toBe(existing.id);
     // Row is untouched and no duplicate "created" invalidation fires.
     expect(getConversation(existing.id)?.title).toBe("already here");
-    expect(listChangedCalls).toEqual([]);
+    expect(listInvalidations()).toEqual([]);
   });
 });
 
@@ -159,28 +231,24 @@ describe("runConversationTurn persistence", () => {
 // eligibility predicate's verdict on the stamped metadata, so the marker and
 // the gate that reads it cannot drift apart.
 describe("runConversationTurn provenance", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run("DELETE FROM messages");
-    db.run("DELETE FROM conversations");
-    lastProcessMessageOptions = undefined;
-    lastEnqueueOptions = undefined;
-    conversationIsProcessing = false;
-  });
+  beforeEach(resetDb);
 
   test("stamps the initiating row automated so its reply raises no push", async () => {
     const existing = createConversation({ title: "standard conversation" });
 
-    await runConversationTurn({
+    const result = await runConversationTurn({
       conversationId: existing.id,
       content: [{ type: "text", text: "transcript excerpt" }],
     });
 
-    const metadata = lastProcessMessageOptions?.metadata as Record<
-      string,
-      unknown
-    >;
-    expect(metadata).toEqual({ automated: true });
+    // The scripted reply came back, so the marker below was stamped by a turn
+    // that ran rather than by one that fell over into an error row.
+    expect(result.content).toMatchObject([
+      { type: "text", text: "scripted reply" },
+    ]);
+
+    const metadata = metadataOf(userRows(existing.id)[0]);
+    expect(metadata).toMatchObject({ automated: true });
     expect(isReplyPushIneligibleUserMessage(metadata)).toBe(true);
     // Not an echo-suppression marker: the row still renders in the transcript.
     expect(isEchoSuppressedUserMessage(metadata)).toBe(false);
@@ -188,18 +256,37 @@ describe("runConversationTurn provenance", () => {
 
   test("stamps the same marker on a turn queued behind a busy conversation", async () => {
     const existing = createConversation({ title: "busy conversation" });
-    conversationIsProcessing = true;
+    holdTheTurnOpen();
+
+    const inFlight = runConversationTurn({
+      conversationId: existing.id,
+      content: [{ type: "text", text: "first excerpt" }],
+    });
+    await waitFor(() => userRows(existing.id).length === 1, {
+      timeoutMs: 5_000,
+      message: "the first turn never reached the provider",
+    });
 
     const result = await runConversationTurn({
       conversationId: existing.id,
       content: [{ type: "text", text: "transcript excerpt" }],
     });
-
     expect(result.queued).toBe(true);
-    const metadata = lastEnqueueOptions?.metadata as Record<string, unknown>;
-    expect(metadata).toEqual({ automated: true });
+
+    // The queue drains after the in-flight turn releases, and the marker has
+    // to survive that trip: it is stamped now but read off the persisted row
+    // much later.
+    releaseGate?.();
+    await inFlight;
+    await waitFor(() => userRows(existing.id).length === 2, {
+      timeoutMs: 5_000,
+      message: "the queued turn never drained",
+    });
+
+    const metadata = metadataOf(userRows(existing.id)[1]);
+    expect(metadata).toMatchObject({ automated: true });
     expect(isReplyPushIneligibleUserMessage(metadata)).toBe(true);
-  });
+  }, 20_000);
 });
 
 /**
@@ -219,18 +306,7 @@ describe("runConversationTurn channel binding", () => {
     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;
-  });
+  beforeEach(resetDb);
 
   test("resolves the chat to the conversation inbound would have used", async () => {
     const result = await runConversationTurn({
@@ -262,9 +338,7 @@ describe("runConversationTurn channel binding", () => {
 
     expect(second.conversationId).toBe(first.conversationId);
     // Only the first turn minted a conversation.
-    expect(listChangedCalls).toEqual([
-      { kind: "created", conversationId: first.conversationId },
-    ]);
+    expect(listInvalidations()).toEqual([creationTags(first.conversationId)]);
   });
 
   test("gives a different chat its own conversation", async () => {
@@ -314,18 +388,20 @@ describe("runConversationTurn channel binding", () => {
     // 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
+    // channel for the message rows and for the permission cascade the tools
     // are approved against.
-    await runConversationTurn({
+    const result = await runConversationTurn({
       channel: CHANNEL,
       content: [{ type: "text", text: "hello" }],
     });
 
-    expect(lastTurnChannelContext).toEqual({
+    const rows = getMessages(result.conversationId);
+    expect(metadataOf(rows[0])).toMatchObject({
       userMessageChannel: "plugin",
       assistantMessageChannel: "plugin",
     });
-    expect(lastProcessMessageOptions?.metadata).toMatchObject({
+    expect(rows[1].role).toBe("assistant");
+    expect(metadataOf(rows[1])).toMatchObject({
       userMessageChannel: "plugin",
       assistantMessageChannel: "plugin",
     });
@@ -333,32 +409,63 @@ describe("runConversationTurn channel binding", () => {
 
   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;
+    // queued message, falling back to whichever turn was in flight. Here that
+    // fallback would be `vellum` — someone else's channel on a conversation
+    // shared with another channel.
+    const conversationId = "1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d";
+    holdTheTurnOpen();
+
+    const inFlight = runConversationTurn({
+      conversationId,
+      content: [{ type: "text", text: "native turn" }],
+    });
+    await waitFor(() => userRows(conversationId).length === 1, {
+      timeoutMs: 5_000,
+      message: "the first turn never reached the provider",
+    });
 
     const result = await runConversationTurn({
+      conversationId,
       channel: CHANNEL,
       content: [{ type: "text", text: "hello" }],
     });
-
     expect(result.queued).toBe(true);
-    expect(lastEnqueueOptions?.metadata).toMatchObject({
+
+    releaseGate?.();
+    await inFlight;
+    await waitFor(() => userRows(conversationId).length === 2, {
+      timeoutMs: 5_000,
+      message: "the queued turn never drained",
+    });
+
+    expect(metadataOf(userRows(conversationId)[1])).toMatchObject({
       userMessageChannel: "plugin",
       assistantMessageChannel: "plugin",
     });
-  });
+  }, 20_000);
 
   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({
+      channel: CHANNEL,
       content: [{ type: "text", text: "hello" }],
     });
 
-    expect(lastTurnChannelContext).toBeNull();
-    expect(lastProcessMessageOptions?.metadata).toEqual({ automated: true });
+    const result = await runConversationTurn({
+      content: [{ type: "text", text: "hello" }],
+    });
+
+    const rows = getMessages(result.conversationId);
+    const userMetadata = metadataOf(rows[0]);
+    expect(userMetadata).toMatchObject({ automated: true });
+    expect(userMetadata?.userMessageChannel).toBeUndefined();
+    // The conversation carries no origin either, so the turn falls back to the
+    // native channel rather than to the previous turn's.
+    expect(metadataOf(rows[1])).toMatchObject({
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    });
   });
 
   test("keeps a known sender when a later turn omits it", async () => {

package/src/__tests__/secret-ingress-channel.test.ts

@@ -62,7 +62,6 @@ function makeParams(
       sourceChannel: "slack" as const,
     } as any,
     replyCallbackUrl: undefined,
-    canonicalAssistantId: "self",
     ...overrides,
   };
 }

package/src/calls/call-setup-flow.ts

@@ -1393,7 +1393,6 @@ export class CallSetupFlow {
 
     try {
       const accessResult = await ndeps.notifyGuardianOfAccessRequest({
-        canonicalAssistantId: accessRequest.assistantId,
         sourceChannel: "phone",
         conversationExternalId: accessRequest.fromNumber,
         actorExternalId: accessRequest.fromNumber,

package/src/runtime/access-request-helper.ts

@@ -29,6 +29,7 @@ import { buildVellumCardAffinity } from "../notifications/vellum-card-affinity.j
 import { IntegrityError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import { resolveAnchoredGuardian } from "./anchored-guardian.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "./assistant-scope.js";
 import { CHALLENGE_TTL_MS } from "./channel-verification-service.js";
 import {
   type AccessRequestTrigger,
@@ -46,7 +47,6 @@ const log = getLogger("access-request-helper");
 export type { AccessRequestTrigger } from "./introduction-policy.js";
 
 export interface AccessRequestParams {
-  canonicalAssistantId: string;
   sourceChannel: ChannelId;
   conversationExternalId: string;
   actorExternalId?: string;
@@ -93,15 +93,18 @@ export type AccessRequestResult =
 // ---------------------------------------------------------------------------
 
 /**
- * Assistant-scoped conversation id for an actor's access requests. Stable key
- * that dedupes pending prompts for the same (assistant, channel, actor).
+ * Conversation id for an actor's access requests. Stable key that dedupes
+ * pending prompts for the same (channel, actor).
+ *
+ * The `self` segment is part of a persisted id format: guardian request rows
+ * carry these ids, so the shape is fixed even though the daemon scopes all its
+ * storage to the one assistant (`DAEMON_INTERNAL_ASSISTANT_ID`).
  */
 export function accessRequestConversationId(
-  canonicalAssistantId: string,
   sourceChannel: string,
   actorExternalId: string,
 ): string {
-  return `access-req-${canonicalAssistantId}-${sourceChannel}-${actorExternalId}`;
+  return `access-req-${DAEMON_INTERNAL_ASSISTANT_ID}-${sourceChannel}-${actorExternalId}`;
 }
 
 /**
@@ -126,7 +129,6 @@ export function accessRequestConversationId(
  * fail-closed.
  */
 export async function isApprovalHandshakeInProgress(params: {
-  canonicalAssistantId: string;
   sourceChannel: string;
   actorExternalId: string;
 }): Promise<boolean> {
@@ -134,7 +136,6 @@ export async function isApprovalHandshakeInProgress(params: {
     return false;
   }
   const conversationId = accessRequestConversationId(
-    params.canonicalAssistantId,
     params.sourceChannel,
     params.actorExternalId,
   );
@@ -171,7 +172,6 @@ export async function notifyGuardianOfAccessRequest(
   params: AccessRequestParams,
 ): Promise<AccessRequestResult> {
   const {
-    canonicalAssistantId,
     sourceChannel,
     conversationExternalId,
     actorExternalId,
@@ -219,7 +219,6 @@ export async function notifyGuardianOfAccessRequest(
   // from assistant A could be returned for assistant B, allowing the caller
   // to piggyback on A's guardian approval.
   const conversationId = accessRequestConversationId(
-    canonicalAssistantId,
     sourceChannel,
     actorExternalId,
   );
@@ -270,7 +269,6 @@ export async function notifyGuardianOfAccessRequest(
   // re-prompting is allowed again.
   if (
     await isApprovalHandshakeInProgress({
-      canonicalAssistantId,
       sourceChannel,
       actorExternalId,
     })
@@ -283,7 +281,7 @@ export async function notifyGuardianOfAccessRequest(
   }
 
   const senderIdentifier = actorDisplayName || actorUsername || actorExternalId;
-  const requestId = `access-req-${canonicalAssistantId}-${sourceChannel}-${actorExternalId}-${Date.now()}`;
+  const requestId = `access-req-${DAEMON_INTERNAL_ASSISTANT_ID}-${sourceChannel}-${actorExternalId}-${Date.now()}`;
 
   // Access requests are decisionable: without a bound principal nobody could
   // ever decide them (mirrors the gateway create's integrity guard).
@@ -461,7 +459,6 @@ export async function maybeNotifyGuardianOfAdmittedContact(
   }
 
   const conversationId = accessRequestConversationId(
-    params.canonicalAssistantId,
     params.sourceChannel,
     params.actorExternalId,
   );

package/src/runtime/routes/channel-route-shared.ts

@@ -2,7 +2,6 @@
  * Shared types, constants, and utilities used across channel route modules.
  */
 import type { ChannelId } from "../../channels/types.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import {
   type ApprovalAction,
   type ApprovalDecisionResult,
@@ -10,11 +9,6 @@ import {
   isApprovalAction,
 } from "../channel-approval-types.js";
 
-/** Canonicalize assistantId for channel ingress paths. */
-export function canonicalChannelAssistantId(_assistantId: string): string {
-  return DAEMON_INTERNAL_ASSISTANT_ID;
-}
-
 // ---------------------------------------------------------------------------
 // Actor role
 // ---------------------------------------------------------------------------

package/src/runtime/routes/inbound-message-handler.ts

@@ -101,7 +101,6 @@ import {
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import { deliverChannelReply } from "../gateway-client.js";
 import { trustContextFromVerdict } from "../trust-verdict-consumer.js";
-import { canonicalChannelAssistantId } from "./channel-route-shared.js";
 import { BadRequestError } from "./errors.js";
 import { handleApprovalInterception } from "./guardian-approval-interception.js";
 import {
@@ -371,16 +370,6 @@ export async function handleChannelInbound({
     throw new BadRequestError("content or attachmentIds is required");
   }
 
-  // Canonicalize the assistant ID so all DB-facing operations use the
-  // consistent 'self' key regardless of what the gateway sent.
-  const canonicalAssistantId = canonicalChannelAssistantId(assistantId);
-  if (canonicalAssistantId !== assistantId) {
-    log.debug(
-      { raw: assistantId, canonical: canonicalAssistantId },
-      "Canonicalized channel assistant ID",
-    );
-  }
-
   // Coerce actorExternalId to a string at the boundary — the field
   // comes from unvalidated JSON and may be a number, object, or other
   // non-string type. Non-string truthy values would throw inside
@@ -438,7 +427,6 @@ export async function handleChannelInbound({
       sourceInterface,
       conversationExternalId,
       externalMessageId,
-      canonicalAssistantId,
       rawSenderId,
       canonicalSenderId,
       actorDisplayName: body.actorDisplayName,
@@ -486,7 +474,6 @@ export async function handleChannelInbound({
     rawSenderId,
     sourceChannel,
     conversationExternalId,
-    canonicalAssistantId,
     trimmedContent,
     sourceMetadata: body.sourceMetadata,
     actorDisplayName: body.actorDisplayName,
@@ -839,7 +826,6 @@ export async function handleChannelInbound({
     if (isCallbackInteraction) {
       if (floorSenderId) {
         handshakeInProgress = await isApprovalHandshakeInProgress({
-          canonicalAssistantId,
           sourceChannel,
           actorExternalId: floorSenderId,
         });
@@ -847,7 +833,6 @@ export async function handleChannelInbound({
     } else {
       try {
         const accessResult = await notifyGuardianOfAccessRequest({
-          canonicalAssistantId,
           sourceChannel,
           conversationExternalId,
           actorExternalId: floorSenderId,
@@ -920,7 +905,7 @@ export async function handleChannelInbound({
       const replyPayload: Parameters<typeof deliverChannelReply>[1] = {
         chatId: conversationExternalId,
         text: replyText,
-        assistantId: canonicalAssistantId,
+        assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
       };
       if (sourceChannel === "slack" && (canonicalSenderId ?? rawSenderId)) {
         replyPayload.ephemeral = true;
@@ -982,7 +967,7 @@ export async function handleChannelInbound({
       const replyPayload: Parameters<typeof deliverChannelReply>[1] = {
         chatId: conversationExternalId,
         text: DISK_PRESSURE_REMOTE_BLOCK_REPLY,
-        assistantId: canonicalAssistantId,
+        assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
       };
       if (sourceChannel === "slack" && (canonicalSenderId ?? rawSenderId)) {
         replyPayload.ephemeral = true;
@@ -1054,7 +1039,6 @@ export async function handleChannelInbound({
     isDuplicate: result.duplicate,
     commandIntent,
     rawSenderId,
-    canonicalAssistantId,
     sourceChannel,
     conversationExternalId,
     eventId: result.eventId,
@@ -1076,7 +1060,6 @@ export async function handleChannelInbound({
     callbackData: body.callbackData,
     rawSenderId,
     canonicalSenderId,
-    canonicalAssistantId,
     sourceChannel,
     conversationExternalId,
     conversationId: result.conversationId,
@@ -1118,7 +1101,7 @@ export async function handleChannelInbound({
       actorExternalId: canonicalSenderId ?? rawSenderId,
       replyCallbackUrl,
       trustCtx,
-      assistantId: canonicalAssistantId,
+      assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
       approvalCopyGenerator,
       approvalConversationGenerator,
       approvalMessageTs,
@@ -1214,7 +1197,7 @@ export async function handleChannelInbound({
           chatId: conversationExternalId,
           text: "This approval request has been resolved.",
           messageTs: approvalMessageTs,
-          assistantId: canonicalAssistantId,
+          assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
         }).catch((err) => {
           log.error(
             { err, conversationId: result.conversationId },
@@ -1250,7 +1233,6 @@ export async function handleChannelInbound({
       actorUsername: body.actorUsername,
       trustCtx,
       replyCallbackUrl,
-      canonicalAssistantId,
     });
 
     if (ingressResult.blocked) {
@@ -1291,7 +1273,6 @@ export async function handleChannelInbound({
         const admittedSenderId = canonicalSenderId ?? rawSenderId;
         if (admittedSenderId) {
           void maybeNotifyGuardianOfAdmittedContact({
-            canonicalAssistantId,
             sourceChannel,
             conversationExternalId,
             actorExternalId: admittedSenderId,
@@ -1492,7 +1473,7 @@ export async function handleChannelInbound({
         commandIntent,
         sourceLanguageCode,
         replyCallbackUrl,
-        assistantId: canonicalAssistantId,
+        assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
         approvalCopyGenerator,
         chatType: sourceChatType,
         clientTimezone: inboundClientTimezone,

package/src/runtime/routes/inbound-stages/acl-enforcement.test.ts

@@ -98,7 +98,6 @@ function makeParams(
     rawSenderId: "sender-1",
     sourceChannel: "telegram",
     conversationExternalId: "chat-1",
-    canonicalAssistantId: "assistant-1",
     trimmedContent: "hello",
     sourceMetadata: undefined,
     actorDisplayName: "Sender One",

package/src/runtime/routes/inbound-stages/acl-enforcement.ts

@@ -90,7 +90,6 @@ export interface AclEnforcementParams {
   rawSenderId: string | undefined;
   sourceChannel: ChannelId;
   conversationExternalId: string;
-  canonicalAssistantId: string;
   trimmedContent: string;
   sourceMetadata: SourceMetadata | undefined;
   actorDisplayName: string | undefined;
@@ -190,7 +189,6 @@ export async function enforceIngressAcl(
     rawSenderId,
     sourceChannel,
     conversationExternalId,
-    canonicalAssistantId,
     trimmedContent,
     sourceMetadata,
     actorDisplayName,
@@ -426,7 +424,6 @@ export async function enforceIngressAcl(
             // Still notify the guardian about the access attempt
             try {
               await notifyGuardianOfAccessRequest({
-                canonicalAssistantId,
                 sourceChannel,
                 conversationExternalId,
                 actorExternalId: canonicalSenderId ?? rawSenderId,
@@ -509,7 +506,6 @@ export async function enforceIngressAcl(
           if (emailVerifyResult.initiated) {
             try {
               await notifyGuardianOfAccessRequest({
-                canonicalAssistantId,
                 sourceChannel,
                 conversationExternalId,
                 actorExternalId: canonicalSenderId ?? rawSenderId,
@@ -554,14 +550,12 @@ export async function enforceIngressAcl(
         let handshakeInProgress = false;
         if (isCallbackInteraction) {
           handshakeInProgress = await isApprovalHandshakeInProgress({
-            canonicalAssistantId,
             sourceChannel,
             actorExternalId: (canonicalSenderId ?? rawSenderId)!,
           });
         } else {
           try {
             const accessResult = await notifyGuardianOfAccessRequest({
-              canonicalAssistantId,
               sourceChannel,
               conversationExternalId,
               actorExternalId: canonicalSenderId ?? rawSenderId,
@@ -730,7 +724,6 @@ export async function enforceIngressAcl(
             if (slackVerifyResult.initiated) {
               try {
                 await notifyGuardianOfAccessRequest({
-                  canonicalAssistantId,
                   sourceChannel,
                   conversationExternalId,
                   actorExternalId: canonicalSenderId ?? rawSenderId,
@@ -803,14 +796,12 @@ export async function enforceIngressAcl(
           if (!terminallyKeptOut) {
             if (isCallbackInteraction) {
               handshakeInProgress = await isApprovalHandshakeInProgress({
-                canonicalAssistantId,
                 sourceChannel,
                 actorExternalId: (canonicalSenderId ?? rawSenderId)!,
               });
             } else {
               try {
                 const accessResult = await notifyGuardianOfAccessRequest({
-                  canonicalAssistantId,
                   sourceChannel,
                   conversationExternalId,
                   actorExternalId: canonicalSenderId ?? rawSenderId,

package/src/runtime/routes/inbound-stages/bootstrap-intercept.test.ts

@@ -54,7 +54,6 @@ function makeParams(
     isDuplicate: false,
     commandIntent: { type: "start", payload: "gv_token123" },
     rawSenderId: "user-42",
-    canonicalAssistantId: "self",
     sourceChannel: "telegram",
     conversationExternalId: "chat-123",
     eventId: "event-1",

package/src/runtime/routes/inbound-stages/bootstrap-intercept.ts

@@ -24,6 +24,7 @@ import {
 import type { ChannelId } from "../../../channels/types.js";
 import { sendTelegramReply } from "../../../messaging/providers/telegram-bot/send.js";
 import { getLogger } from "../../../util/logger.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../assistant-scope.js";
 import { RESEND_COOLDOWN_MS } from "../../verification-outbound-actions.js";
 import {
   composeVerificationText,
@@ -40,7 +41,6 @@ export interface BootstrapInterceptParams {
   isDuplicate: boolean;
   commandIntent: Record<string, unknown> | undefined;
   rawSenderId: string | undefined;
-  canonicalAssistantId: string;
   sourceChannel: ChannelId;
   conversationExternalId: string;
   eventId: string;
@@ -96,7 +96,6 @@ export async function handleBootstrapIntercept(
     isDuplicate,
     commandIntent,
     rawSenderId,
-    canonicalAssistantId,
     sourceChannel,
     conversationExternalId,
     eventId,
@@ -208,7 +207,7 @@ export async function handleBootstrapIntercept(
   deliverBootstrapVerificationTelegram(
     conversationExternalId,
     telegramBody,
-    canonicalAssistantId,
+    DAEMON_INTERNAL_ASSISTANT_ID,
   );
 
   // Update delivery tracking (best-effort — the code is already on its way)

package/src/runtime/routes/inbound-stages/guardian-reply-intercept.test.ts

@@ -51,7 +51,6 @@ function makeParams(
     callbackData: undefined,
     rawSenderId: "user-42",
     canonicalSenderId: "user-42",
-    canonicalAssistantId: "self",
     sourceChannel: "slack" as const,
     conversationExternalId: "chat-123",
     conversationId: "conv-abc",

package/src/runtime/routes/inbound-stages/guardian-reply-intercept.ts

@@ -15,6 +15,7 @@ import {
 } from "../../../channels/gateway-guardian-requests.js";
 import type { ChannelId } from "../../../channels/types.js";
 import { getLogger } from "../../../util/logger.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../assistant-scope.js";
 import { deliverChannelReply } from "../../gateway-client.js";
 import {
   type GuardianPendingScope,
@@ -41,7 +42,6 @@ export interface GuardianReplyInterceptParams {
   reactedMessageTs?: string;
   rawSenderId: string | undefined;
   canonicalSenderId: string | null;
-  canonicalAssistantId: string;
   sourceChannel: ChannelId;
   conversationExternalId: string;
   conversationId: string;
@@ -77,7 +77,6 @@ export async function handleGuardianReplyIntercept(
     reactedMessageTs,
     rawSenderId,
     canonicalSenderId,
-    canonicalAssistantId,
     sourceChannel,
     conversationExternalId,
     conversationId,
@@ -178,7 +177,7 @@ export async function handleGuardianReplyIntercept(
     channelDeliveryContext: {
       replyCallbackUrl,
       guardianChatId: conversationExternalId,
-      assistantId: canonicalAssistantId,
+      assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
     },
   });
 
@@ -188,7 +187,7 @@ export async function handleGuardianReplyIntercept(
       const routerReplyPayload: Parameters<typeof deliverChannelReply>[1] = {
         chatId: conversationExternalId,
         text: routerResult.replyText,
-        assistantId: canonicalAssistantId,
+        assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
       };
       // On Slack, send guardian management replies (disambiguation, pending
       // request lists, etc.) as ephemeral so only the guardian sees them.

package/src/runtime/routes/inbound-stages/reaction-intercept.test.ts

@@ -172,7 +172,6 @@ function buildParams(overrides: {
     sourceInterface: "slack" as const,
     conversationExternalId: SLACK_CHANNEL_ID,
     externalMessageId: `${SLACK_CHANNEL_ID}:1700000000.1:${msgCounter}`,
-    canonicalAssistantId: "assistant-1",
     rawSenderId: overrides.rawSenderId,
     canonicalSenderId: overrides.rawSenderId,
     actorDisplayName: "Reactor",

package/src/runtime/routes/inbound-stages/reaction-intercept.ts

@@ -35,7 +35,6 @@ import {
 import { markProcessed } from "../../../persistence/delivery-status.js";
 import { upsertBinding } from "../../../persistence/external-conversation-store.js";
 import { getLogger } from "../../../util/logger.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../assistant-scope.js";
 import type { ApprovalConversationGenerator } from "../../http-types.js";
 import {
   actorTrustContextFromVerdict,
@@ -100,7 +99,6 @@ export interface ReactionInterceptParams {
   sourceInterface: InterfaceId | undefined;
   conversationExternalId: string;
   externalMessageId: string;
-  canonicalAssistantId: string;
   rawSenderId: string | undefined;
   canonicalSenderId: string | null;
   actorDisplayName: string | undefined;
@@ -126,7 +124,6 @@ export async function handleSlackReactionIntercept(
     sourceInterface,
     conversationExternalId,
     externalMessageId,
-    canonicalAssistantId,
     rawSenderId,
     canonicalSenderId,
     actorDisplayName,
@@ -215,21 +212,17 @@ export async function handleSlackReactionIntercept(
     };
   }
 
-  // Maintain the conversation binding, matching the message pipeline. Scoped to
-  // the daemon's own assistant so assistant-scoped legacy routes don't clobber
-  // each other's binding metadata.
-  if (canonicalAssistantId === DAEMON_INTERNAL_ASSISTANT_ID) {
-    upsertBinding({
-      conversationId: result.conversationId,
-      sourceChannel,
-      externalChatId: conversationExternalId,
-      externalChatName: slackChannelName,
-      externalThreadId: threadTs ?? null,
-      externalUserId: canonicalSenderId ?? rawSenderId ?? null,
-      displayName: actorDisplayName ?? null,
-      username: actorUsername ?? null,
-    });
-  }
+  // Maintain the conversation binding, matching the message pipeline.
+  upsertBinding({
+    conversationId: result.conversationId,
+    sourceChannel,
+    externalChatId: conversationExternalId,
+    externalChatName: slackChannelName,
+    externalThreadId: threadTs ?? null,
+    externalUserId: canonicalSenderId ?? rawSenderId ?? null,
+    displayName: actorDisplayName ?? null,
+    username: actorUsername ?? null,
+  });
 
   // Guardian approval-by-reaction → guardian decision pipeline, exactly like
   // buttons and text replies. Only `reaction:` (added) expresses intent;
@@ -246,7 +239,6 @@ export async function handleSlackReactionIntercept(
       reactedMessageTs,
       rawSenderId,
       canonicalSenderId,
-      canonicalAssistantId,
       sourceChannel,
       conversationExternalId,
       conversationId: result.conversationId,

package/src/runtime/routes/inbound-stages/secret-ingress-check.ts

@@ -14,6 +14,7 @@ import {
 } from "../../../persistence/delivery-crud.js";
 import { checkIngressForSecrets } from "../../../security/secret-ingress.js";
 import { getLogger } from "../../../util/logger.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../assistant-scope.js";
 
 const log = getLogger("runtime-http");
 
@@ -36,7 +37,6 @@ export interface SecretIngressCheckParams {
   actorUsername: string | undefined;
   trustCtx: TrustContext;
   replyCallbackUrl: string | undefined;
-  canonicalAssistantId: string;
 }
 
 export interface SecretIngressCheckResult {
@@ -69,7 +69,6 @@ export function runSecretIngressCheck(
     actorUsername,
     trustCtx,
     replyCallbackUrl,
-    canonicalAssistantId,
   } = params;
 
   // Persist the raw payload so dead-lettered events can always be replayed.
@@ -85,7 +84,7 @@ export function runSecretIngressCheck(
     senderUsername: actorUsername,
     trustCtx,
     replyCallbackUrl,
-    assistantId: canonicalAssistantId,
+    assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
   });
 
   // ── Secret ingress scan ──