@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/__tests__/credential-prompt-route.test.ts

@@ -209,8 +209,8 @@ describe("credentials/prompt route", () => {
   test("stores a non-slack credential to secure storage and reports the value as received", async () => {
     /**
      * The default delivery persists the value to secure storage and runs the
-     * manual-token connection sync. The message must name the outcome — the
-     * value is in hand — so a bare `ok: true` cannot be misread as "the prompt
+     * manual-token connection sync. The message must name the outcome (the
+     * value is in hand) so a bare `ok: true` cannot be misread as "the prompt
      * opened".
      */
     // GIVEN a standard store-delivery prompt for a non-slack credential
@@ -236,15 +236,12 @@ describe("credentials/prompt route", () => {
 
   test("every successful outcome states that the prompt has closed", async () => {
     /**
-     * The prompt blocks until answered, so a caller reads the result only after
-     * the secure input is gone. Without an explicit close signal a model
-     * follows up with "the prompt is open, paste it there" and the user
-     * re-submits into a surface that never reappears — the loop reported in
-     * the Aug 2026 Claude Code auth feedback. Every success path must say so,
-     * not just the plain vault write.
+     * The prompt blocks until answered, so a caller reads the result only once
+     * the secure input is gone. Every success path states the close, not just
+     * the plain vault write, so the result cannot be read as "the prompt is
+     * open, paste it there".
      */
-    const closed =
-      "The secure prompt has closed — do not ask the user to enter this value again.";
+    const closed = "The secure prompt has closed.";
 
     // GIVEN a plain vault write
     const stored = (await promptRoute!.handler({

package/src/__tests__/credential-security-invariants.test.ts

@@ -238,6 +238,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "workspace/default-provider-ensure.ts", // legacy anthropic echo disambiguation (vault key presence check)
       "providers/inference/connection-availability.ts", // shared (provider, connection) availability status (credential presence check only; value never leaves the helper)
       "plugin-api/resolve-credential.ts", // plugin-facing resolveCredential — reveal-equivalent plaintext read, scoped to the in-context plugin's own field
+      "tools/credentials/store.ts", // shared credential write path (setSecureKeyAsync only; no reads) behind credentials/set and plugin-facing storeCredential
     ]);
 
     const thisDir = dirname(fileURLToPath(import.meta.url));

package/src/__tests__/cu-unified-flow.test.ts

@@ -97,6 +97,7 @@ function buildMockContext(
           } as Conversation["currentTurnAuthContext"])
         : undefined,
     sendToClient: () => {},
+    emit: () => {},
     pendingSurfaceActions: new Map(),
     lastSurfaceAction: new Map(),
     surfaceState: new Map(),

package/src/__tests__/custom-profile-ensure.test.ts

@@ -53,6 +53,10 @@ describe("ensureCompleteCustomProfiles", () => {
     ensureCompleteCustomProfiles(workspaceDir);
     const saved = readProfiles().partial;
     expect(saved.model).toBe("claude-haiku-4-5-20251001");
+    // This workspace has no connection rows, so the binding is unverifiable
+    // and passes through in the legacy field for the collapse migration to
+    // judge; with a verified row it would fold into the provider value (see
+    // profile-materialization.test.ts).
     expect(saved.provider).toBe("anthropic");
     expect(saved.provider_connection).toBe("anthropic-personal");
     expect(saved.maxTokens).toBe(12345);
@@ -91,7 +95,7 @@ describe("ensureCompleteCustomProfiles", () => {
       },
     });
     ensureCompleteCustomProfiles(workspaceDir);
-    expect(readProfiles().gpt.provider_connection).toBe("vellum");
+    expect(readProfiles().gpt.provider_connection).toBeUndefined();
     expect(readProfiles().router.provider_connection).toBeUndefined();
   });
 

package/src/__tests__/default-plugin-names-guard.test.ts

@@ -1,7 +1,10 @@
 import { describe, expect, test } from "bun:test";
 
 import { getAllDefaultPlugins } from "../plugins/defaults/index.js";
-import { getAllDefaultPluginNames } from "../plugins/defaults/main.js";
+import {
+  getAllDefaultPluginNames,
+  isFirstPartyDefaultPlugin,
+} from "../plugins/defaults/main.js";
 
 /**
  * Guard: the filesystem-backed default-plugin registry (`defaults/main.ts`)
@@ -25,4 +28,12 @@ describe("default plugin names", () => {
       expect(name).toMatch(/^default-[a-z0-9-]+$/);
     }
   });
+
+  test("isFirstPartyDefaultPlugin matches the filesystem registry and rejects other names", () => {
+    for (const name of getAllDefaultPluginNames()) {
+      expect(isFirstPartyDefaultPlugin(name)).toBe(true);
+    }
+    expect(isFirstPartyDefaultPlugin("default-a")).toBe(false);
+    expect(isFirstPartyDefaultPlugin("uplug-a")).toBe(false);
+  });
 });

package/src/__tests__/discord-access-request-privacy.test.ts

@@ -342,7 +342,11 @@ describe("Discord access-request decisions stay out of the guild channel", () =>
   test("no Discord delivery is ever addressed to the originating conversation", async () => {
     // The umbrella invariant, swept across every decision this resolver takes,
     // so a newly added action cannot quietly reintroduce the leak.
-    for (const action of ["verify_code", "block", "leave_unverified"] as const) {
+    for (const action of [
+      "verify_code",
+      "block",
+      "leave_unverified",
+    ] as const) {
       resetState();
       const req = makeDiscordAccessRequest();
 

package/src/__tests__/discord-requester-notice-privacy.test.ts

@@ -27,9 +27,9 @@ describe("the dm-marked Discord route", () => {
     // regressed, the notice would fall through to the HTTP proxy, which cannot
     // fetch a base-less URL: the delivery would vanish rather than error, and
     // every behavioural assertion about where it landed would still pass.
-    expect(channelForCallback(resolveDeliverCallbackUrlForChannel("discord")!)).toBe(
-      "discord",
-    );
+    expect(
+      channelForCallback(resolveDeliverCallbackUrlForChannel("discord")!),
+    ).toBe("discord");
   });
 });
 

package/src/__tests__/document-append-idempotency.test.ts

@@ -0,0 +1,233 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getDocumentById } from "../documents/document-store.js";
+import { getSqlite } from "../persistence/db-connection.js";
+import {
+  executeDocumentCreate,
+  executeDocumentUpdate,
+} from "../tools/document/document-tool.js";
+import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
+
+const CONVERSATION_ID = "conv-current";
+
+/** Long enough to clear the store's minimum-duplicate-length floor. */
+const OPENING =
+  "Remote work reshaped the office long before anyone had a name for it.";
+
+function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
+  return {
+    workingDir: "/tmp/project",
+    conversationId: CONVERSATION_ID,
+    trustClass: "trusted_contact",
+    executionChannel: "slack",
+    sendToClient: () => {},
+    ...overrides,
+  };
+}
+
+function parseResult<T>(result: ToolExecutionResult): T {
+  return JSON.parse(result.content) as T;
+}
+
+function bootstrapDocumentTables(): void {
+  resetDbForTesting();
+  const raw = getSqlite();
+  raw.exec(/*sql*/ `
+    DROP TABLE IF EXISTS document_conversations;
+    DROP TABLE IF EXISTS documents;
+    DROP TABLE IF EXISTS conversations;
+
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)
+    );
+
+    CREATE TABLE documents (
+      surface_id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      word_count INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      workspace_path TEXT
+    );
+
+    CREATE TABLE document_conversations (
+      surface_id TEXT NOT NULL,
+      conversation_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (surface_id, conversation_id),
+      FOREIGN KEY (surface_id) REFERENCES documents(surface_id) ON DELETE CASCADE
+    );
+  `);
+  raw
+    .query(`INSERT OR IGNORE INTO conversations (id, created_at) VALUES (?, ?)`)
+    .run(CONVERSATION_ID, Date.now());
+}
+
+function seedDocument(surfaceId: string, content: string): void {
+  const now = Date.now();
+  const raw = getSqlite();
+  raw
+    .query(
+      `INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      surfaceId,
+      CONVERSATION_ID,
+      "Draft",
+      content,
+      content.split(/\s+/).filter(Boolean).length,
+      now,
+      now,
+    );
+  raw
+    .query(
+      `INSERT OR IGNORE INTO document_conversations (surface_id, conversation_id, created_at) VALUES (?, ?, ?)`,
+    )
+    .run(surfaceId, CONVERSATION_ID, now);
+}
+
+describe("document append idempotency", () => {
+  beforeEach(() => {
+    bootstrapDocumentTables();
+  });
+
+  test("an opening passed to both document_create and the first append lands once", () => {
+    const created = executeDocumentCreate(
+      { title: "Draft", initial_content: `# Draft\n\n${OPENING}` },
+      makeContext(),
+    );
+    const surfaceId = parseResult<{ surface_id: string }>(created).surface_id;
+
+    const result = executeDocumentUpdate(
+      {
+        surface_id: surfaceId,
+        content: `# Draft\n\n${OPENING}\n\nThe second paragraph carries the argument forward.`,
+        mode: "append",
+      },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(getDocumentById(surfaceId)?.content).toBe(
+      `# Draft\n\n${OPENING}\n\nThe second paragraph carries the argument forward.`,
+    );
+  });
+
+  test("an append that only restates the tail writes nothing", () => {
+    seedDocument("doc-restate", `# Draft\n\n${OPENING}`);
+
+    const result = executeDocumentUpdate(
+      { surface_id: "doc-restate", content: OPENING, mode: "append" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    const body = parseResult<{ success: boolean; message: string }>(result);
+    expect(body.success).toBe(true);
+    expect(body.message).toBe(
+      "Nothing appended: the content is already at the end of the document",
+    );
+    expect(getDocumentById("doc-restate")?.content).toBe(
+      `# Draft\n\n${OPENING}`,
+    );
+  });
+
+  test("the client is told what landed, not what was submitted", () => {
+    seedDocument("doc-client", OPENING);
+    const sent: { markdown: unknown; mode: unknown }[] = [];
+
+    executeDocumentUpdate(
+      {
+        surface_id: "doc-client",
+        content: `${OPENING}\n\nAnd then the rest.`,
+        mode: "append",
+      },
+      makeContext({
+        sendToClient: (message) => {
+          if (message.type === "document_editor_update") {
+            sent.push({ markdown: message.markdown, mode: message.mode });
+          }
+        },
+      }),
+    );
+
+    expect(sent).toEqual([{ markdown: "And then the rest.", mode: "append" }]);
+  });
+
+  // ── Legitimate repetition the guard must not eat ──────────────────
+
+  test("keeps a short repeated line, even back to back", () => {
+    seedDocument("doc-refrain", "## Checklist\n\nTODO");
+
+    executeDocumentUpdate(
+      { surface_id: "doc-refrain", content: "TODO\n\nTODO", mode: "append" },
+      makeContext(),
+    );
+
+    expect(getDocumentById("doc-refrain")?.content).toBe(
+      "## Checklist\n\nTODO\n\nTODO\n\nTODO",
+    );
+  });
+
+  test("keeps a repeated heading followed by new prose", () => {
+    seedDocument("doc-heading", "# Weekly Notes\n\n## Monday");
+
+    executeDocumentUpdate(
+      {
+        surface_id: "doc-heading",
+        content: "## Monday\n\nShipped the importer.",
+        mode: "append",
+      },
+      makeContext(),
+    );
+
+    expect(getDocumentById("doc-heading")?.content).toBe(
+      "# Weekly Notes\n\n## Monday\n\n## Monday\n\nShipped the importer.",
+    );
+  });
+
+  test("keeps a long paragraph that repeats something other than the tail", () => {
+    seedDocument("doc-midway", `${OPENING}\n\nA later paragraph ends the doc.`);
+
+    executeDocumentUpdate(
+      { surface_id: "doc-midway", content: OPENING, mode: "append" },
+      makeContext(),
+    );
+
+    expect(getDocumentById("doc-midway")?.content).toBe(
+      `${OPENING}\n\nA later paragraph ends the doc.\n\n${OPENING}`,
+    );
+  });
+
+  test("keeps content whose repetition starts partway into the append", () => {
+    seedDocument("doc-partway", `# Draft\n\n${OPENING}`);
+
+    executeDocumentUpdate(
+      {
+        surface_id: "doc-partway",
+        content: `A fresh lead-in.\n\n${OPENING}`,
+        mode: "append",
+      },
+      makeContext(),
+    );
+
+    expect(getDocumentById("doc-partway")?.content).toBe(
+      `# Draft\n\n${OPENING}\n\nA fresh lead-in.\n\n${OPENING}`,
+    );
+  });
+
+  test("replace mode is never deduplicated", () => {
+    seedDocument("doc-replace", OPENING);
+
+    executeDocumentUpdate(
+      { surface_id: "doc-replace", content: OPENING, mode: "replace" },
+      makeContext(),
+    );
+
+    expect(getDocumentById("doc-replace")?.content).toBe(OPENING);
+  });
+});

package/src/__tests__/document-sync-tags.test.ts

@@ -3,8 +3,6 @@
  * the Library and the per-conversation assets list converge on every surface.
  * Read routes and rejected writes must stay silent.
  */
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 
 import type { AssistantEventEnvelope } from "../api/index.js";
@@ -24,9 +22,6 @@ import { resetDbForTesting } from "./db-test-helpers.js";
 
 await initializeDb();
 
-const workspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
-const notesDir = join(workspaceDir, "sync-notes");
-
 const CONVERSATION_ID = "conv-doc-sync";
 const OTHER_CONVERSATION_ID = "conv-doc-sync-other";
 const MISSING_CONVERSATION_ID = "conv-doc-sync-missing";
@@ -110,15 +105,6 @@ async function saveViaRoute(
   });
 }
 
-async function openWorkspaceFile(
-  path: string,
-  conversationId = CONVERSATION_ID,
-): Promise<unknown> {
-  return await invoke("documentForWorkspaceFile", {
-    body: { path, conversationId },
-  });
-}
-
 async function linkViaRoute(
   surfaceId: string,
   conversationId: string,
@@ -136,12 +122,9 @@ beforeEach(() => {
   db.run("DELETE FROM conversations");
   createConversation({ id: CONVERSATION_ID });
   createConversation({ id: OTHER_CONVERSATION_ID });
-  rmSync(notesDir, { recursive: true, force: true });
-  mkdirSync(notesDir, { recursive: true });
 });
 
 afterAll(() => {
-  rmSync(notesDir, { recursive: true, force: true });
   resetDbForTesting();
 });
 
@@ -220,67 +203,9 @@ describe("document write routes publish documents:list", () => {
     expect(events).toHaveLength(1);
     expect("originClientId" in events[0].message).toBe(false);
   });
-
-  test("binding a workspace file publishes without an origin so the caller is not suppressed", async () => {
-    // `viewer-store.loadWorkspaceFileDocument` creates the row and invalidates
-    // nothing, so the client that opened the file is the one that most needs
-    // the invalidation.
-    writeFileSync(join(notesDir, "plan.md"), "# Plan");
-
-    const events = await captureSyncEvents(() =>
-      invoke("documentForWorkspaceFile", {
-        body: { path: "sync-notes/plan.md", conversationId: CONVERSATION_ID },
-        headers: { "x-vellum-client-id": "client-abc" },
-      }),
-    );
-
-    expect(events).toHaveLength(1);
-    expect("originClientId" in events[0].message).toBe(false);
-  });
-
-  test("binding a workspace file to a new document publishes", async () => {
-    writeFileSync(join(notesDir, "plan.md"), "# Plan");
-
-    const events = await captureSyncEvents(() =>
-      openWorkspaceFile("sync-notes/plan.md"),
-    );
-    expectDocumentsChanged(events);
-  });
-
-  test("reopening the file from another conversation publishes the new link", async () => {
-    writeFileSync(join(notesDir, "plan.md"), "# Plan");
-    await openWorkspaceFile("sync-notes/plan.md");
-
-    const events = await captureSyncEvents(() =>
-      openWorkspaceFile("sync-notes/plan.md", OTHER_CONVERSATION_ID),
-    );
-    expectDocumentsChanged(events);
-  });
-
-  test("refreshing a document whose file changed on disk publishes", async () => {
-    const filePath = join(notesDir, "plan.md");
-    writeFileSync(filePath, "# Plan");
-    await openWorkspaceFile("sync-notes/plan.md");
-    writeFileSync(filePath, "# Plan\n\nedited outside the editor");
-
-    const events = await captureSyncEvents(() =>
-      openWorkspaceFile("sync-notes/plan.md"),
-    );
-    expectDocumentsChanged(events);
-  });
 });
 
 describe("document routes that change nothing the list shows stay silent", () => {
-  test("reopening an unchanged, already-linked file publishes nothing", async () => {
-    writeFileSync(join(notesDir, "plan.md"), "# Plan");
-    await openWorkspaceFile("sync-notes/plan.md");
-
-    const events = await captureSyncEvents(() =>
-      openWorkspaceFile("sync-notes/plan.md"),
-    );
-    expect(events).toEqual([]);
-  });
-
   test("a save rejected by validation publishes nothing", async () => {
     const events = await captureSyncEvents(async () => {
       await expect(saveViaRoute({ title: undefined })).rejects.toThrow(

package/src/__tests__/dynamic-skill-background-guard.test.ts

@@ -65,9 +65,7 @@ mock.module("../permissions/checker.js", () => ({
   isDynamicSkillLoadInvocation: () => dynamicSkillLoad,
   classifyRisk: async () => ({ level: "medium" }),
   check: async () => ({ decision: checkDecision, reason: "medium risk" }),
-  generateAllowlistOptions: () => [],
   generateScopeOptions: () => [],
-  getCachedAssessment: () => undefined,
 }));
 
 mock.module("../telemetry/tool-usage-store.js", () => ({

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",
     });
@@ -172,7 +171,100 @@ describe("Slack edit propagation", () => {
     expect(slackMeta!.editedAt!).toBeGreaterThanOrEqual(t0);
   });
 
-  test("threaded Slack edits use the threaded conversation key and preserve thread metadata", async () => {
+  // Times out on the default budget: an unresolvable target pays the full
+  // `EDIT_LOOKUP_RETRIES` window before it is dropped.
+  test("an edit of a message the assistant never stored creates no conversation", async () => {
+    // Keying a conversation off the edit's own address made every edit of an
+    // unseen message mint one, permanently titled with the loading placeholder.
+    const db = getDb();
+    const countRows = (table: string): number =>
+      (
+        db.$client.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get() as {
+          n: number;
+        }
+      ).n;
+
+    const resp = (await handleEditIntercept({
+      sourceChannel: "slack",
+      conversationExternalId: "C0NEVERSEEN",
+      externalMessageId: nextEditEventId(),
+      sourceMessageId: "1999.0001",
+      assistantId: "self",
+      content: "edited text",
+    })) as Record<string, unknown>;
+
+    expect(resp.accepted).toBe(true);
+    expect(resp.edited).toBe(false);
+    expect(countRows("conversations")).toBe(0);
+    expect(countRows("channel_inbound_events")).toBe(0);
+    expect(countRows("messages")).toBe(0);
+  }, 30_000);
+
+  test("an edit records against the edited message's conversation, not a new one", async () => {
+    const seeded = await seedSlackMessage({
+      conversationExternalId: "C0123CHANNEL",
+      channelTs: "1234.5678",
+      initialContent: "original text",
+    });
+    const db = getDb();
+    const conversationsBefore = (
+      db.$client.prepare("SELECT COUNT(*) AS n FROM conversations").get() as {
+        n: number;
+      }
+    ).n;
+
+    await handleEditIntercept({
+      sourceChannel: "slack",
+      conversationExternalId: seeded.conversationExternalId,
+      externalMessageId: nextEditEventId(),
+      sourceMessageId: seeded.channelTs,
+      assistantId: "self",
+      content: "new text",
+    });
+
+    const conversationsAfter = (
+      db.$client.prepare("SELECT COUNT(*) AS n FROM conversations").get() as {
+        n: number;
+      }
+    ).n;
+    expect(conversationsAfter).toBe(conversationsBefore);
+
+    const editEvents = db.$client
+      .prepare(
+        `SELECT conversation_id AS conversationId FROM channel_inbound_events
+         WHERE external_message_id LIKE 'edit-event-%'`,
+      )
+      .all() as Array<{ conversationId: string }>;
+    expect(editEvents).toHaveLength(1);
+    expect(editEvents[0].conversationId).toBe(seeded.conversationId);
+  });
+
+  test("a redelivered edit is answered without repeating the lookup window", async () => {
+    const seeded = await seedSlackMessage({
+      conversationExternalId: "C0123CHANNEL",
+      channelTs: "1234.5678",
+      initialContent: "original text",
+    });
+    const editEventId = nextEditEventId();
+    const send = () =>
+      handleEditIntercept({
+        sourceChannel: "slack",
+        conversationExternalId: seeded.conversationExternalId,
+        externalMessageId: editEventId,
+        sourceMessageId: seeded.channelTs,
+        assistantId: "self",
+        content: "new text",
+      }) as Promise<Record<string, unknown>>;
+
+    const first = await send();
+    const second = await send();
+
+    expect(first.duplicate).toBe(false);
+    expect(second.duplicate).toBe(true);
+    expect(second.eventId).toBe(first.eventId);
+  });
+
+  test("a threaded edit stays in the edited message's conversation and preserves thread metadata", async () => {
     const conversationExternalId = "C0123CHANNEL";
     const threadTs = "1234.0000";
     const seeded = await seedSlackMessage({
@@ -180,6 +272,14 @@ describe("Slack edit propagation", () => {
       channelTs: "1234.5678",
       initialContent: "original text",
     });
+    const db = getDb();
+    const conversationCount = (): number =>
+      (
+        db.$client.prepare("SELECT COUNT(*) AS n FROM conversations").get() as {
+          n: number;
+        }
+      ).n;
+    const before = conversationCount();
 
     const resp = await handleEditIntercept({
       sourceChannel: "slack",
@@ -187,16 +287,17 @@ describe("Slack edit propagation", () => {
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
       sourceThreadId: threadTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "new text",
     });
 
     expect((resp as Record<string, unknown>).accepted).toBe(true);
+
+    // The thread id names where the reply goes, not a conversation of the
+    // edit's own. Keying one off it is what minted a conversation per edit.
     const threadedKey = `asst:self:slack:${conversationExternalId}:thread:${threadTs}`;
-    const editConversation = getConversationByKey(threadedKey);
-    expect(editConversation).not.toBeNull();
-    expect(editConversation!.conversationId).not.toBe(seeded.conversationId);
+    expect(getConversationByKey(threadedKey)).toBeNull();
+    expect(conversationCount()).toBe(before);
 
     const after = readMessageRow(seeded.messageId);
     const outer = JSON.parse(after.metadata!) as Record<string, unknown>;
@@ -216,7 +317,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "first edit",
     });
@@ -239,7 +339,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "second edit",
     });
@@ -272,7 +371,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 +411,6 @@ describe("Slack edit propagation", () => {
       conversationExternalId: seeded.conversationExternalId,
       externalMessageId: nextEditEventId(),
       sourceMessageId: seeded.channelTs,
-      canonicalAssistantId: "self",
       assistantId: "self",
       content: "edited searchable text",
     });
@@ -341,7 +438,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",
     });