@vellumai/assistant 0.11.7 → 0.11.8-staging.1

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

@@ -1,8 +1,8 @@
 /**
- * Tests for Slack message_deleted propagation into stored messages.
+ * Tests for delete propagation into stored messages.
  *
- * The gateway forwards delete events with `callbackData = "message_deleted"`
- * and `sourceMetadata.messageId` set to the deleted message's ts. The daemon
+ * The gateway forwards delete events with `eventKind: "delete"` and
+ * `sourceMetadata.messageId` set to the deleted message's ts. The daemon
  * marks the corresponding stored row's `slackMeta.deletedAt` while leaving
  * the `content` column untouched (audit retention; the renderer elides based
  * on the deletedAt marker).
@@ -154,6 +154,104 @@ function buildSlackDeleteRequest(opts: {
   });
 }
 
+describe("Discord delete propagation (unattributed)", () => {
+  beforeEach(() => {
+    resetState();
+    _setDeleteLookupConfigForTests(2, 20);
+  });
+
+  test("an unattributed delete applies only to an ingested row, without ACL identity", async () => {
+    // Discord's MESSAGE_DELETE names no actor, so the gateway forwards the
+    // synthetic discord-system id with actorUnattributed stated. No member
+    // exists for that id and no trust verdict rides the event; the delete
+    // still applies, because the original's author cleared the ACL when the
+    // message arrived and the stamp touches only that ingested row.
+    const chatId = "999888777666555444";
+    const originalId = "111222333444555001";
+    const inbound = recordInbound("discord", chatId, originalId, {
+      sourceMessageId: originalId,
+    });
+    const messageId = `msg-${originalId}`;
+    getDb()
+      .insert(messages)
+      .values({
+        id: messageId,
+        conversationId: inbound.conversationId,
+        role: "user",
+        content: "A message someone later deleted",
+        metadata: JSON.stringify({ userMessageChannel: "discord" }),
+        createdAt: Date.now(),
+      })
+      .run();
+    linkMessage(inbound.eventId, messageId);
+
+    const req = new Request("http://localhost:8080/channels/inbound", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Gateway-Origin": TEST_BEARER_TOKEN,
+      },
+      body: JSON.stringify({
+        sourceChannel: "discord",
+        interface: "discord",
+        conversationExternalId: chatId,
+        externalMessageId: `${originalId}:delete`,
+        eventKind: "delete",
+        content: "",
+        actorExternalId: "discord-system",
+        sourceMetadata: {
+          messageId: originalId,
+          actorUnattributed: true,
+        },
+      }),
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(true);
+
+    const row = getDb()
+      .select()
+      .from(messages)
+      .where(eq(messages.id, messageId))
+      .get();
+    expect(row!.content).toBe("A message someone later deleted");
+    const neutral = readProviderMetadata(row!.metadata);
+    expect(neutral).not.toBeNull();
+    expect(neutral!.source).toBe("discord");
+    expect(neutral!.deletedAt).toBeDefined();
+  });
+
+  test("an unattributed delete for a never-ingested message is a no-op", async () => {
+    const req = new Request("http://localhost:8080/channels/inbound", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Gateway-Origin": TEST_BEARER_TOKEN,
+      },
+      body: JSON.stringify({
+        sourceChannel: "discord",
+        interface: "discord",
+        conversationExternalId: "999888777666555444",
+        externalMessageId: "111222333444555002:delete",
+        eventKind: "delete",
+        content: "",
+        actorExternalId: "discord-system",
+        sourceMetadata: {
+          messageId: "111222333444555002",
+          actorUnattributed: true,
+        },
+      }),
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(false);
+  });
+});
+
 describe("Slack delete propagation", () => {
   beforeEach(() => {
     resetState();
@@ -251,6 +349,26 @@ describe("Slack delete propagation", () => {
     expect(slackMeta!.deletedAt).toBeUndefined();
   });
 
+  test("a never-ingested delete returns without paying the retry window", async () => {
+    // The retry loop exists for one race: an inbound-event row written
+    // before its message link lands. No row at all means nothing can appear
+    // by waiting, and the wait would hold the conversation's serialized
+    // forward lane for every unrelated delete a busy room produces.
+    _setDeleteLookupConfigForTests(2, 500);
+    const started = Date.now();
+    const req = buildSlackDeleteRequest({
+      externalChatId: "C0123CHANNEL",
+      deletedTs: "0000.0000",
+    });
+    const resp = await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    expect(json.accepted).toBe(true);
+    expect(json.deleted).toBe(false);
+    // Far under a single 500ms retry delay: the loop short-circuited.
+    expect(Date.now() - started).toBeLessThan(400);
+  });
+
   test("delete for row without slackMeta stamps the neutral metadata", async () => {
     // A legacy pre-enrichment row still gets its delete marked: the neutral
     // envelope is synthesized so readProviderMetadata serves the stamp to

package/src/__tests__/evict-conversations-for-reload.test.ts

@@ -7,8 +7,9 @@
  * releasing and its queued successor being dispatched.
  *
  * In-flight subagents are the other non-idle case: an async spawn leaves the
- * parent idle between its own tool calls while children are still running, and
- * reload must not abort those children.
+ * parent idle between its own tool calls while children are still running.
+ * Reload marks that parent stale without aborting the children, then
+ * `getOrCreateConversation` rebuilds it once every child is terminal.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -32,7 +33,10 @@ import {
   findConversation,
   setConversation,
 } from "../daemon/conversation-registry.js";
-import { evictConversationsForReload } from "../daemon/conversation-store.js";
+import {
+  evictConversationsForReload,
+  getOrCreateConversation,
+} from "../daemon/conversation-store.js";
 
 interface FakeConversation {
   disposed: boolean;
@@ -41,7 +45,7 @@ interface FakeConversation {
 
 function register(
   id: string,
-  state: { processing: boolean; queued: boolean },
+  state: { processing: boolean; queued: boolean; stale?: boolean },
 ): FakeConversation {
   const fake: FakeConversation & Record<string, unknown> = {
     disposed: false,
@@ -49,6 +53,9 @@ function register(
     conversationId: id,
     isProcessing: () => state.processing,
     hasQueuedMessages: () => state.queued,
+    isStale: () => state.stale === true || fake.markedStale,
+    hasInFlightWork: () =>
+      state.processing || state.queued || activeParents.has(id),
     dispose() {
       fake.disposed = true;
     },
@@ -103,7 +110,7 @@ describe("evictConversationsForReload", () => {
     expect(abortedParents).toEqual([]);
   });
 
-  test("skips an idle parent with in-flight subagents", () => {
+  test("marks an idle parent with in-flight subagents stale", () => {
     const parent = register("reload-with-children", {
       processing: false,
       queued: false,
@@ -113,7 +120,7 @@ describe("evictConversationsForReload", () => {
     evictConversationsForReload();
 
     expect(parent.disposed).toBe(false);
-    expect(parent.markedStale).toBe(false);
+    expect(parent.markedStale).toBe(true);
     expect(findConversation("reload-with-children")).toBeDefined();
     expect(abortedParents).toEqual([]);
   });
@@ -132,9 +139,42 @@ describe("evictConversationsForReload", () => {
     evictConversationsForReload();
 
     expect(protectedParent.disposed).toBe(false);
+    expect(protectedParent.markedStale).toBe(true);
     expect(findConversation("reload-protected")).toBeDefined();
     expect(idle.disposed).toBe(true);
     expect(findConversation("reload-unprotected")).toBeUndefined();
     expect(abortedParents).toEqual(["reload-unprotected"]);
   });
+
+  test("defers stale rebuild while subagents are in flight", async () => {
+    const parent = register("stale-parent", {
+      processing: false,
+      queued: false,
+      stale: true,
+    });
+    activeParents.add("stale-parent");
+
+    const result = await getOrCreateConversation("stale-parent");
+
+    expect(result as unknown).toBe(parent);
+    expect(parent.disposed).toBe(false);
+    expect(abortedParents).toEqual([]);
+  });
+
+  test("rebuilds a stale parent once every child is terminal", async () => {
+    const parent = register("stale-parent", {
+      processing: false,
+      queued: false,
+      stale: true,
+    });
+
+    try {
+      await getOrCreateConversation("stale-parent");
+    } catch {
+      // Isolated test has no provider wiring; rebuild intent is abort + dispose.
+    }
+
+    expect(parent.disposed).toBe(true);
+    expect(abortedParents).toEqual(["stale-parent"]);
+  });
 });

package/src/__tests__/file-ops-service.test.ts

@@ -10,7 +10,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, test } from "bun:test";
 
-import { THRESHOLD_CHARS } from "../context/post-turn-tool-result-truncation.js";
+import { FILE_READ_TOOL_NAMES } from "../context/post-turn-tool-result-truncation.js";
+import { RESULT_TIME_SPOOL_EXEMPT_TOOLS } from "../context/tool-result-spool.js";
 import {
   FileSystemOps,
   type PathPolicy,
@@ -330,8 +331,12 @@ describe("FileSystemOps.readFileSafe", () => {
     expect(body).toBe("abcd");
   });
 
-  test("the read budget stays under the tool-result spool threshold", () => {
-    expect(READ_CHAR_BUDGET).toBeLessThan(THRESHOLD_CHARS);
+  test("file reads are result-time spool-exempt so a full window survives its turn", () => {
+    // The budget exceeds the spool threshold, so without the exemption a
+    // default read of a large file would be stubbed before the model saw it.
+    for (const name of FILE_READ_TOOL_NAMES) {
+      expect(RESULT_TIME_SPOOL_EXEMPT_TOOLS.has(name)).toBe(true);
+    }
   });
 });
 

package/src/__tests__/gemini-provider.test.ts

@@ -403,6 +403,70 @@ describe("GeminiProvider", () => {
     });
   });
 
+  test("3.7 Flash: disabled maps to the LOW floor, not MINIMAL", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    const flash37Provider = new GeminiProvider(
+      "test-api-key",
+      "gemini-3.7-flash",
+    );
+    await flash37Provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      { config: { thinking: { type: "disabled" } } },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toEqual({
+      thinkingLevel: "LOW",
+      includeThoughts: false,
+    });
+  });
+
+  test("3.7 Flash: an explicit minimal level is clamped up to LOW", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    const flash37Provider = new GeminiProvider(
+      "test-api-key",
+      "models/gemini-3.7-flash",
+    );
+    await flash37Provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      {
+        config: {
+          thinking: {
+            type: "adaptive",
+            level: "minimal",
+            streamThinking: false,
+          },
+        },
+      },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toEqual({
+      thinkingLevel: "LOW",
+      includeThoughts: false,
+    });
+  });
+
+  test("3.7 Flash: adaptive with no level keeps Google's default", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    const flash37Provider = new GeminiProvider(
+      "test-api-key",
+      "gemini-3.7-flash",
+    );
+    await flash37Provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      { config: { thinking: { type: "adaptive", streamThinking: true } } },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toEqual({
+      includeThoughts: true,
+    });
+  });
+
   test("Pro: a supported explicit level passes through unchanged", async () => {
     fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
 

package/src/__tests__/guardian-action-service-scope.test.ts

@@ -0,0 +1,118 @@
+/**
+ * Conversation scoping for in-app guardian decisions
+ * (`processGuardianDecision` step 2).
+ *
+ * A guardian request projects an actionable card into every conversation a
+ * delivery was paired with: the vellum card's pinned conversation AND each
+ * channel card's paired conversation (the decision engine injects the same
+ * seed blocks into every channel's copy). Taps from any of those
+ * conversations are legitimate; taps from unrelated conversations are not.
+ * The scope check must therefore accept any recorded delivery destination
+ * conversation regardless of the delivery's channel: narrowing to vellum
+ * rows silently no-opped every tap on a channel card's in-app projection
+ * (LUM-3489's "one request, two independent tasks" confusion).
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import {
+  bridgeState,
+  gatewayGuardianRequestsStoreBridge,
+} from "./helpers/gateway-guardian-requests-store-bridge.js";
+
+mock.module(
+  "../channels/gateway-guardian-requests.js",
+  () => gatewayGuardianRequestsStoreBridge,
+);
+
+const applyGuardianDecision = mock(async () => ({
+  applied: true as const,
+  requestId: "req",
+  grantMinted: false,
+}));
+const actualPrimitive =
+  await import("../approvals/guardian-decision-primitive.js");
+mock.module("../approvals/guardian-decision-primitive.js", () => ({
+  ...actualPrimitive,
+  applyGuardianDecision,
+}));
+
+import { processGuardianDecision } from "../runtime/guardian-action-service.js";
+
+const PRINCIPAL_ID = "scope-test-principal";
+
+function seedRequestWithProjections() {
+  const req = bridgeState.seedRequest({
+    kind: "tool_approval",
+    sourceType: "channel",
+    sourceChannel: "slack",
+    sourceConversationId: "conv-thread",
+    toolName: "shell",
+    guardianPrincipalId: PRINCIPAL_ID,
+  });
+  bridgeState.seedDelivery({
+    requestId: req.id,
+    destinationChannel: "vellum",
+    destinationConversationId: "conv-thread",
+  });
+  bridgeState.seedDelivery({
+    requestId: req.id,
+    destinationChannel: "slack",
+    destinationChatId: "C1",
+    destinationMessageId: "1.0",
+    destinationConversationId: "conv-dm",
+  });
+  return req;
+}
+
+async function decideFrom(requestId: string, conversationId: string) {
+  return processGuardianDecision({
+    requestId,
+    action: "approve_once",
+    conversationId,
+    channel: "vellum",
+    actorContext: {
+      actorPrincipalId: PRINCIPAL_ID,
+      guardianPrincipalId: PRINCIPAL_ID,
+    },
+  });
+}
+
+describe("processGuardianDecision conversation scoping", () => {
+  beforeEach(() => {
+    bridgeState.reset();
+    applyGuardianDecision.mockClear();
+  });
+
+  test("accepts a tap from the request's source conversation", async () => {
+    const req = seedRequestWithProjections();
+    const result = await decideFrom(req.id, "conv-thread");
+    expect(result).toMatchObject({ ok: true, applied: true });
+    expect(applyGuardianDecision).toHaveBeenCalledTimes(1);
+  });
+
+  test("accepts a tap from a channel card's paired conversation", async () => {
+    const req = seedRequestWithProjections();
+    const result = await decideFrom(req.id, "conv-dm");
+    expect(result).toMatchObject({ ok: true, applied: true });
+    expect(applyGuardianDecision).toHaveBeenCalledTimes(1);
+  });
+
+  test("rejects a tap from a conversation holding no projection", async () => {
+    const req = seedRequestWithProjections();
+    const result = await decideFrom(req.id, "conv-unrelated");
+    expect(result).toMatchObject({
+      ok: true,
+      applied: false,
+      reason: "not_found",
+    });
+    expect(applyGuardianDecision).not.toHaveBeenCalled();
+  });
+
+  test("threads the acting conversation to the primitive for broadcast suppression", async () => {
+    const req = seedRequestWithProjections();
+    await decideFrom(req.id, "conv-dm");
+    expect(applyGuardianDecision).toHaveBeenCalledWith(
+      expect.objectContaining({ originConversationId: "conv-dm" }),
+    );
+  });
+});