@vellumai/assistant 0.11.2 → 0.11.3-dev.202608080427.92f668a

package/src/__tests__/skills-install-staging.test.ts

@@ -11,10 +11,22 @@ import { join } from "node:path";
 import { gzipSync } from "node:zlib";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-const mockExecSync = mock(() => {});
+// Emits `error` on the returned child so the dependency install's spawn
+// promise rejects with the injected failure.
+const mockSpawn = mock(() => {
+  const child = {
+    on(event: string, cb: (arg: unknown) => void) {
+      if (event === "error") {
+        queueMicrotask(() => cb(new Error("dependency install failed")));
+      }
+      return child;
+    },
+  };
+  return child;
+});
 
 mock.module("node:child_process", () => ({
-  execSync: mockExecSync,
+  spawn: mockSpawn,
 }));
 
 import { loadSkillCatalog } from "../config/skills.js";
@@ -48,10 +60,7 @@ beforeEach(() => {
   workspaceDir = mkdtempSync(join(tmpdir(), "skills-install-staging-"));
   process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
   mkdirSync(join(workspaceDir, "skills"), { recursive: true });
-  mockExecSync.mockReset();
-  mockExecSync.mockImplementation(() => {
-    throw new Error("dependency install failed");
-  });
+  mockSpawn.mockClear();
 });
 
 afterEach(() => {

package/src/__tests__/skills.test.ts

@@ -825,6 +825,38 @@ describe("always-candidate frontmatter parsing", () => {
       .map(({ id, chars }) => `${id}: ${chars}`);
     expect(overrun).toEqual([]);
   });
+
+  test("the bundled acp skill's card fits the default budget", async () => {
+    // `acp` owns Claude Code and Codex setup, sign-in, and delegation, and the
+    // terms that route those turns to it live in this card. The card is
+    // hard-truncated at the default budget, so an overrun drops the trailing
+    // hints and the whole avoid-when list from what the selector sees.
+    const { DEFAULT_CARD_CHARS, buildSkillContent } =
+      await import("../plugins/defaults/memory/substrate/skill-content.js");
+    const acp = loadSkillCatalog().find((skill) => skill.id === "acp");
+    expect(acp).toBeDefined();
+
+    // A card that overran is cut to exactly the budget, so staying under it is
+    // what proves nothing was dropped. `avoid-when` is appended last and is
+    // therefore the first content a truncation eats.
+    const card = buildSkillContent(acp!);
+    expect(card.length).toBeLessThan(DEFAULT_CARD_CHARS);
+    expect(card).toContain("Avoid when:");
+  });
+
+  test("the bundled acp card carries its setup and sign-in vocabulary", async () => {
+    // A "configure Claude Code" or "let's do the auth" turn only reaches this
+    // skill if the card actually says it covers setup and authentication;
+    // delegation-only wording routes those turns to a terminal skill instead.
+    const { buildSkillContent } =
+      await import("../plugins/defaults/memory/substrate/skill-content.js");
+    const acp = loadSkillCatalog().find((skill) => skill.id === "acp");
+    const card = buildSkillContent(acp!).toLowerCase();
+
+    for (const term of ["set up", "install", "authenticate", "connect"]) {
+      expect(card).toContain(term);
+    }
+  });
 });
 
 describe("bundled skill categories", () => {

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

@@ -0,0 +1,103 @@
+/**
+ * Characterization: Slack edits are applied in ARRIVAL order with no
+ * comparison against the edit's Slack `edited.ts`. Two distinct edits
+ * delivered out of order therefore leave the OLDER text persisted. This is
+ * a pre-existing gap; it becomes load-bearing for LUM-3023 because mention
+ * source data must be replaced atomically with content, so a stale edit
+ * that wins would also resurrect stale mention data.
+ *
+ * The first test pins today's behavior so the future guard's PR flips it
+ * consciously; the `test.todo` entries specify the intended semantics.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { setConfig } from "./helpers/set-config.js";
+
+setConfig("memory", { enabled: false });
+
+import {
+  addMessage,
+  getMessageById,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { linkMessage, recordInbound } from "../persistence/delivery-crud.js";
+import { stringifyMessageContent } from "../persistence/message-content.js";
+import { handleEditIntercept } from "../runtime/routes/inbound-stages/edit-intercept.js";
+
+await initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM channel_inbound_events");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM conversations");
+}
+
+const CHANNEL = "C0123CHANNEL";
+const ORIGINAL_TS = "1700000000.000100";
+
+async function seedMessage(): Promise<string> {
+  const inbound = recordInbound("slack", CHANNEL, ORIGINAL_TS, {
+    sourceMessageId: ORIGINAL_TS,
+  });
+  const inserted = await addMessage(
+    inbound.conversationId,
+    "user",
+    JSON.stringify([{ type: "text", text: "original text" }]),
+    { metadata: { userMessageChannel: "slack" }, skipIndexing: true },
+  );
+  linkMessage(inbound.eventId, inserted.id);
+  return inserted.id;
+}
+
+async function applyEdit(eventId: string, content: string): Promise<void> {
+  await handleEditIntercept({
+    sourceChannel: "slack",
+    conversationExternalId: CHANNEL,
+    externalMessageId: eventId,
+    sourceMessageId: ORIGINAL_TS,
+    canonicalAssistantId: "self",
+    assistantId: "self",
+    content,
+  });
+}
+
+describe("Slack edit ordering (characterization)", () => {
+  beforeEach(resetTables);
+
+  test("CURRENT BEHAVIOR: a later-arriving older edit overwrites the newer text", async () => {
+    const messageId = await seedMessage();
+
+    // The user's second (newer) edit arrives first…
+    await applyEdit("edit-event-newer", "second revision");
+    // …then the first (older) edit arrives late and wins by arrival order.
+    await applyEdit("edit-event-older", "first revision");
+
+    const row = getMessageById(messageId);
+    expect(stringifyMessageContent(row!.content)).toBe("first revision");
+  });
+
+  test("duplicate delivery of the same edit event is a no-op", async () => {
+    const messageId = await seedMessage();
+
+    await applyEdit("edit-event-dup", "revised text");
+    // Same eventId again: recordInbound dedups it before any content write.
+    await applyEdit("edit-event-dup", "should never apply");
+
+    const row = getMessageById(messageId);
+    expect(stringifyMessageContent(row!.content)).toBe("revised text");
+  });
+
+  test.todo(
+    "GUARD (future PR): an edit whose Slack edited.ts is older than the stored one is ignored",
+    () => {},
+  );
+
+  test.todo(
+    "GUARD (future PR): content and mention source data are replaced in the same transaction on every applied edit",
+    () => {},
+  );
+});

package/src/__tests__/slack-inbound-verification.test.ts

@@ -104,7 +104,10 @@ mock.module("../channels/gateway-verification-sessions.js", () => ({
     params: Parameters<typeof createOutboundSessionGuarded>[0],
   ) => createOutboundSessionGuarded(params),
   getPendingSession: async (channel: string) => getPendingSession(channel),
-  findActiveSession: async (channel: string) => findActiveSession(channel),
+  findActiveSession: async (
+    channel: string,
+    filter?: Parameters<typeof findActiveSession>[1],
+  ) => findActiveSession(channel, filter),
 }));
 
 await initializeDb();

package/src/__tests__/slack-mention-binding-invariance.test.ts

@@ -0,0 +1,103 @@
+/**
+ * Characterization: conversation binding is derived from the message's
+ * source channel (`conversationExternalId`) and is invariant to any channel
+ * mentioned inline in the message text (LUM-3023's canonical regression: a
+ * message received in source channel A that mentions destination channel B
+ * must keep the conversation, its keys, and its slackMeta bound to A; B is
+ * presentation data only).
+ *
+ * These tests pin current behavior; nothing here changes it.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { setConfig } from "./helpers/set-config.js";
+
+setConfig("memory", { enabled: false });
+
+import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
+import { addMessage, getMessages } from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { recordInbound } from "../persistence/delivery-crud.js";
+import { conversationKeys } from "../persistence/schema/conversations.js";
+
+await initializeDb();
+
+const SOURCE_CHANNEL_A = "C0111SRCA";
+const MENTIONED_CHANNEL_B = "C0222DESTB";
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM channel_inbound_events");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM conversations");
+}
+
+describe("Slack mention binding invariance", () => {
+  beforeEach(resetTables);
+
+  test("a message in channel A mentioning channel B binds to A, and B mints no binding", async () => {
+    // Inbound in source channel A whose text mentions destination channel B.
+    const first = recordInbound("slack", SOURCE_CHANNEL_A, "1700000000.000100");
+    await addMessage(
+      first.conversationId,
+      "user",
+      JSON.stringify([
+        {
+          type: "text",
+          text: "please post updates in #dest-channel going forward",
+        },
+      ]),
+      {
+        metadata: {
+          slackMeta: writeSlackMetadata({
+            source: "slack",
+            channelId: SOURCE_CHANNEL_A,
+            channelTs: "1700000000.000100",
+            eventKind: "message",
+          }),
+        },
+        skipIndexing: true,
+      },
+    );
+
+    // A later message in the same source channel resolves to the SAME
+    // conversation: the binding key is the source channel, nothing else.
+    const second = recordInbound(
+      "slack",
+      SOURCE_CHANNEL_A,
+      "1700000001.000200",
+    );
+    expect(second.conversationId).toBe(first.conversationId);
+
+    // The mentioned channel B resolves to a DIFFERENT conversation if
+    // anything ever arrives from it; mentioning it created no binding.
+    const fromB = recordInbound(
+      "slack",
+      MENTIONED_CHANNEL_B,
+      "1700000002.000300",
+    );
+    expect(fromB.conversationId).not.toBe(first.conversationId);
+
+    // The persisted row's slackMeta records the source channel, and B
+    // appears nowhere in persisted metadata, only in message text.
+    const rows = getMessages(first.conversationId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0].metadata).toContain(SOURCE_CHANNEL_A);
+    expect(rows[0].metadata).not.toContain(MENTIONED_CHANNEL_B);
+  });
+
+  test("no conversation key exists for a channel that was only ever mentioned", () => {
+    recordInbound("slack", SOURCE_CHANNEL_A, "1700000003.000400");
+
+    const keys = getDb()
+      .select({ conversationKey: conversationKeys.conversationKey })
+      .from(conversationKeys)
+      .all();
+    const keyBlob = JSON.stringify(keys);
+    expect(keyBlob).toContain(SOURCE_CHANNEL_A);
+    expect(keyBlob).not.toContain(MENTIONED_CHANNEL_B);
+  });
+});

package/src/__tests__/slack-mention-provider-leak-audit.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Characterization: the provider send boundary is a field-by-field
+ * reconstruction whitelist, so persisted-block metadata that future mention
+ * work might attach (rider fields on text blocks, custom block types) can
+ * never leak to the provider wire. Pins the guarantees LUM-3023's projection
+ * design relies on:
+ *  - extra fields on a known block type are dropped (text rebuilt as
+ *    `{type, text}` only),
+ *  - unknown block types are dropped entirely rather than serialized,
+ *  - the failure mode is silent omission, never a provider-rejected payload.
+ *
+ * These tests pin current behavior; nothing here changes it.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+import type { ContentBlock, Message } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Mock Anthropic SDK; must be registered before importing the provider.
+// Mirrors the harness shape in native-web-search.test.ts.
+// ---------------------------------------------------------------------------
+
+let lastStreamParams: Record<string, unknown> | null = null;
+
+const fakeResponse = {
+  content: [{ type: "text", text: "ok" }],
+  model: "claude-sonnet-4-6",
+  usage: {
+    input_tokens: 10,
+    output_tokens: 2,
+    cache_creation_input_tokens: 0,
+    cache_read_input_tokens: 0,
+  },
+  stop_reason: "end_turn",
+};
+
+class FakeAPIError extends Error {
+  status: number;
+  constructor(status: number, message: string) {
+    super(message);
+    this.status = status;
+    this.name = "APIError";
+  }
+}
+
+mock.module("@anthropic-ai/sdk", () => ({
+  default: class MockAnthropic {
+    static APIError = FakeAPIError;
+    constructor(_args: Record<string, unknown>) {}
+    beta = {
+      messages: {
+        stream: (params: Record<string, unknown>) => {
+          lastStreamParams = JSON.parse(JSON.stringify(params));
+          return {
+            on() {
+              return this;
+            },
+            async finalMessage() {
+              return fakeResponse;
+            },
+          };
+        },
+      },
+    };
+  },
+}));
+
+import { AnthropicProvider } from "../providers/anthropic/client.js";
+
+async function sendAndCapture(
+  blocks: ContentBlock[],
+): Promise<Array<{ role: string; content: Array<Record<string, unknown>> }>> {
+  lastStreamParams = null;
+  const provider = new AnthropicProvider("test-key", "claude-sonnet-4-6");
+  const messages: Message[] = [{ role: "user", content: blocks }];
+  await provider.sendMessage(messages);
+  return lastStreamParams!.messages as Array<{
+    role: string;
+    content: Array<Record<string, unknown>>;
+  }>;
+}
+
+describe("provider serializer leak audit", () => {
+  test("rider fields on a text block never reach the wire", async () => {
+    const sent = await sendAndCapture([
+      {
+        type: "text",
+        text: "transcribed words",
+        _ingressAugmentation: "transcription",
+      } as unknown as ContentBlock,
+      { type: "text", text: "caption body" },
+    ]);
+
+    const userMsg = sent.find((m) => m.role === "user");
+    expect(userMsg).toBeDefined();
+    for (const block of userMsg!.content) {
+      expect(block).not.toHaveProperty("_ingressAugmentation");
+    }
+    // The rider-bearing block still ships as plain text: silent field drop,
+    // not block loss.
+    const texts = userMsg!.content
+      .filter((b) => b.type === "text")
+      .map((b) => b.text);
+    expect(texts).toContain("transcribed words");
+    expect(texts).toContain("caption body");
+    expect(JSON.stringify(lastStreamParams)).not.toContain(
+      "_ingressAugmentation",
+    );
+  });
+
+  test("unknown block types are dropped, not serialized", async () => {
+    const sent = await sendAndCapture([
+      {
+        type: "slack_mention_source",
+        rawText: "<#C0123DEST>",
+      } as unknown as ContentBlock,
+      { type: "text", text: "visible text" },
+    ]);
+
+    const userMsg = sent.find((m) => m.role === "user");
+    expect(userMsg).toBeDefined();
+    expect(
+      userMsg!.content.some((b) => b.type === "slack_mention_source"),
+    ).toBe(false);
+    expect(JSON.stringify(lastStreamParams)).not.toContain(
+      "slack_mention_source",
+    );
+    expect(
+      userMsg!.content.some(
+        (b) => b.type === "text" && b.text === "visible text",
+      ),
+    ).toBe(true);
+  });
+});

package/src/__tests__/starter-task-flow.test.ts

@@ -31,15 +31,16 @@ mock.module("../apps/app-store.js", () => ({
   },
 }));
 
+import type { Conversation } from "../daemon/conversation.js";
 import {
   createSurfaceMutex,
   handleSurfaceAction,
-  type SurfaceConversationContext,
   surfaceProxyResolver,
 } from "../daemon/conversation-surfaces.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
-function makeContext(): SurfaceConversationContext {
-  return {
+function makeContext(): Conversation {
+  return asConversation({
     conversationId: "session-1",
     sendToClient: () => {},
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
@@ -57,7 +58,7 @@ function makeContext(): SurfaceConversationContext {
     getQueueDepth: () => 0,
     processMessage: async () => "ok",
     withSurface: createSurfaceMutex(),
-  };
+  });
 }
 
 describe("starter task surface actions", () => {

package/src/__tests__/steer-on-enqueue-question.test.ts

@@ -30,14 +30,15 @@ interface ParkedTurn {
 /**
  * Register a fake conversation whose in-flight turn is parked. The fake exposes
  * just the surface `steerToMessage` touches: a processing flag, a queue whose
- * head can be promoted, an abort controller that records aborts, and the
- * confirmation-deny hook.
+ * messages can be looked up and promoted, an abort controller that records
+ * aborts, and the confirmation-deny hook.
  */
 function registerParkedTurn(id: string): ParkedTurn {
   let abortCount = 0;
   const fake = {
     isProcessing: () => true,
     queue: {
+      findByRequestId: (requestId: string) => ({ requestId }),
       promoteToHead: (requestId: string) => ({ requestId }),
     },
     pendingSteerRepair: false,

package/src/__tests__/stt-language-catalog-parity.test.ts

@@ -129,3 +129,41 @@ describe("web STT language catalog stays in sync with the daemon roster", () =>
     expect(nonExtended).toEqual(expected);
   });
 });
+
+/**
+ * The settings skill accepts plain language names ("tamil", "hindi") and its
+ * tool description advertises that, so a roster code with no English-name
+ * alias is reachable only by someone who knows the raw BCP-47 code. Adding a
+ * language to the roster without its alias is the easy half-step, so pin the
+ * two together the same way the catalog copies are pinned.
+ */
+const SETTINGS_TOOL_SOURCE = readFileSync(
+  join(
+    REPO_ROOT,
+    "assistant/src/config/bundled-skills/settings/tools/voice-config-update.ts",
+  ),
+  "utf-8",
+);
+
+describe("settings-skill language aliases", () => {
+  test("every roster language is reachable by an English name", () => {
+    const aliasBlockStart = SETTINGS_TOOL_SOURCE.indexOf(
+      "const STT_LANGUAGE_ALIASES",
+    );
+    expect(aliasBlockStart).toBeGreaterThan(-1);
+    const aliasBlockEnd = SETTINGS_TOOL_SOURCE.indexOf("};", aliasBlockStart);
+    const aliasBlock = SETTINGS_TOOL_SOURCE.slice(
+      aliasBlockStart,
+      aliasBlockEnd,
+    );
+    // Every value in the alias map, i.e. the codes a plain name can reach.
+    const aliasedCodes = new Set(
+      [...aliasBlock.matchAll(/:\s*"([a-z-]+)"/g)].map((match) => match[1]),
+    );
+
+    const unreachable = DEEPGRAM_NOVA3_MONOLINGUAL_CODES.filter(
+      (code) => !aliasedCodes.has(code),
+    );
+    expect(unreachable).toEqual([]);
+  });
+});

package/src/__tests__/subagent-allowlist-validation.test.ts

@@ -2,6 +2,8 @@ import { describe, expect, test } from "bun:test";
 
 import { SUBAGENT_ROLE_REGISTRY } from "../subagent/index.js";
 import { findUnknownAllowlistTools } from "../subagent/validate-allowlists.js";
+import { notifyParentTool } from "../tools/subagent/notify-parent.js";
+import { explicitTools } from "../tools/tool-manifest.js";
 
 /** Union of every tool name referenced by any role allowlist. */
 function allReferencedToolNames(): Set<string> {
@@ -40,10 +42,30 @@ describe("findUnknownAllowlistTools", () => {
     expect(flaggedRoles).toEqual(expectedRoles);
   });
 
-  test("skips roles with no allowlist (general imposes no filter)", () => {
-    // `general` has allowedTools: undefined, so even against an empty registry
-    // it contributes no entries.
+  test("a role that imposes no filter contributes no entries", () => {
+    // The builder declares no allowlist, so even against an empty registry it
+    // has nothing that could fail to resolve.
     const unknown = findUnknownAllowlistTools(new Set());
-    expect(unknown.some((u) => u.role === "general")).toBe(false);
+    expect(unknown.some((u) => u.role === "builder")).toBe(false);
+    // Every allowlisted role's entries are all flagged against an empty registry.
+    expect(unknown.length).toBeGreaterThan(0);
+    expect(unknown.some((u) => u.role === "advisor")).toBe(true);
+  });
+
+  test("every allowlisted core tool name is a real registered tool", () => {
+    // What the boot-time check does, minus standing up the registry: a name
+    // that resolves to nothing costs the role that tool in silence. In
+    // particular `skill_execute` has to exist, or a role's preactivated
+    // skills project tools it can never call.
+    const registeredNames = new Set([
+      ...explicitTools.map((tool) => tool.name),
+      // Registered with the subagent skill rather than the core manifest.
+      notifyParentTool.name,
+    ]);
+    expect(registeredNames.has("skill_execute")).toBe(true);
+    const unresolved = [...allReferencedToolNames()].filter(
+      (name) => !registeredNames.has(name),
+    );
+    expect(unresolved).toEqual([]);
   });
 });