@vellumai/assistant 0.11.8 → 0.11.9-staging.1

package/src/__tests__/guardian-card-withdrawal.test.ts

@@ -686,28 +686,6 @@ describe("recordApprovalCardDelivery", () => {
     expect(delivery?.destinationChatId).toBeNull();
     expect(delivery?.status).toBe("pending");
   });
-
-  test("lets a Slack reaction resolve back to its request (LUM-2502)", async () => {
-    // A delivered Slack approval card must be addressable by (channel, chat, ts)
-    // so an emoji reaction on it resolves to the right request rather than
-    // silently falling through to transcript persistence.
-    const req = makeRequest();
-    await recordApprovalCardDelivery({
-      requestId: req.id,
-      channel: "slack",
-      chatId: "C-guardian",
-      messageId: "1700000000.5678",
-      status: "sent",
-    });
-
-    const resolved =
-      await bridgeState.module.getPendingRequestByDestinationMessageOrNull(
-        "slack",
-        "C-guardian",
-        "1700000000.5678",
-      );
-    expect(resolved?.id).toBe(req.id);
-  });
 });
 
 describe("recordGuardianRequestDeliveries", () => {

package/src/__tests__/guardian-gateway-sim.ts

@@ -454,25 +454,6 @@ export function createGuardianGatewaySim() {
       .map((d) => ({ ...d }));
   }
 
-  async function getPendingRequestByDestinationMessage(
-    channel: string,
-    chatId: string,
-    messageId: string,
-  ): Promise<SimGuardianRequest | null> {
-    throwIfReadError();
-    const delivery = deliveries.find(
-      (d) =>
-        d.destinationChannel === channel &&
-        d.destinationChatId === chatId &&
-        d.destinationMessageId === messageId,
-    );
-    if (!delivery) {
-      return null;
-    }
-    const request = requests.get(delivery.requestId);
-    return request?.status === "pending" ? { ...request } : null;
-  }
-
   async function listPendingRequestsByDestination(params: {
     channel?: string;
     chatId?: string;
@@ -624,10 +605,6 @@ export function createGuardianGatewaySim() {
       listGuardianRequestDeliveries,
       [],
     ),
-    getPendingRequestByDestinationMessageOrNull: degrade(
-      getPendingRequestByDestinationMessage,
-      null,
-    ),
     listPendingRequestsByDestinationOrEmpty: degrade(
       listPendingRequestsByDestination,
       [],

package/src/__tests__/guardian-question-mode.test.ts

@@ -1,12 +1,14 @@
 import { describe, expect, test } from "bun:test";
 
 import {
+  applyGuardianReplyMechanics,
   buildGuardianCodeOnlyClarification,
   buildGuardianDisambiguationExample,
   buildGuardianDisambiguationLabel,
   buildGuardianInvalidActionReply,
   buildGuardianReplyDirective,
   buildGuardianRequestCodeInstruction,
+  guardianCopyCarriesReplyMechanics,
   hasGuardianRequestCodeInstruction,
   parseGuardianQuestionPayload,
   parseInteractiveApprovalPayload,
@@ -286,6 +288,112 @@ describe("guardian-question-mode", () => {
     ).not.toBeNull();
   });
 
+  test("guardianCopyCarriesReplyMechanics: chat channels carry them, card surfaces do not", () => {
+    const approval = {
+      requestId: "req-1",
+      requestCode: "A1B2C3",
+      requestKind: "tool_grant_request",
+      questionText: "Allow bash?",
+      toolName: "bash",
+    };
+    const question = {
+      requestId: "req-2",
+      requestCode: "A1B2C3",
+      requestKind: "pending_question",
+      questionText: "Which one?",
+    };
+    // The bell, the banner, and the push act through the card whatever the mode.
+    expect(guardianCopyCarriesReplyMechanics("vellum", approval)).toBe(false);
+    expect(guardianCopyCarriesReplyMechanics("vellum", question)).toBe(false);
+    expect(guardianCopyCarriesReplyMechanics("platform", question)).toBe(false);
+    // Slack draws buttons for approvals only; a question is answered by text.
+    expect(guardianCopyCarriesReplyMechanics("slack", approval)).toBe(false);
+    expect(guardianCopyCarriesReplyMechanics("slack", question)).toBe(true);
+    expect(guardianCopyCarriesReplyMechanics("telegram", approval)).toBe(true);
+    expect(guardianCopyCarriesReplyMechanics("telegram", question)).toBe(true);
+  });
+
+  test("applyGuardianReplyMechanics enforces into chat copy, strips from card-surface copy, and is idempotent", () => {
+    const signal = {
+      sourceEventName: "guardian.question",
+      contextPayload: {
+        requestId: "req-2",
+        requestCode: "a1b2c3",
+        requestKind: "pending_question",
+        questionText: "Which one?",
+      },
+    } as const;
+    const copy = {
+      title: "Question",
+      body: "Which one?\n\n1. Left\n2. Right",
+      conversationSeedMessage: "Which one?\n\n1. Left\n2. Right",
+    };
+    const instruction = 'Reference code: A1B2C3. Reply "A1B2C3 <your answer>".';
+
+    const telegram = applyGuardianReplyMechanics(copy, "telegram", signal);
+    expect(telegram.body).toBe(`${copy.body}\n\n${instruction}`);
+    expect(telegram.conversationSeedMessage).toBe(
+      `${copy.body}\n\n${instruction}`,
+    );
+    expect(applyGuardianReplyMechanics(telegram, "telegram", signal)).toEqual(
+      telegram,
+    );
+
+    const vellum = applyGuardianReplyMechanics(telegram, "vellum", signal);
+    expect(vellum).toEqual(copy);
+    expect(applyGuardianReplyMechanics(copy, "vellum", signal)).toEqual(copy);
+
+    // Any other signal passes through untouched.
+    expect(
+      applyGuardianReplyMechanics(copy, "telegram", {
+        ...signal,
+        sourceEventName: "schedule.notify",
+      }),
+    ).toEqual(copy);
+  });
+
+  test("applyGuardianReplyMechanics replaces an instruction-only field with the question text on a card surface", () => {
+    const signal = {
+      sourceEventName: "guardian.question",
+      contextPayload: {
+        requestId: "req-3",
+        requestCode: "A1B2C3",
+        requestKind: "tool_grant_request",
+        questionText: "Allow bash to run ls /tmp?",
+        toolName: "bash",
+      },
+    } as const;
+    const instructionOnly = {
+      title: "Tool Grant Request. Approval code: A1B2C3",
+      body: 'Reference code: A1B2C3. Reply "A1B2C3 approve" or "A1B2C3 reject".',
+      deliveryText: "Approval code: A1B2C3",
+    };
+    const vellum = applyGuardianReplyMechanics(
+      instructionOnly,
+      "vellum",
+      signal,
+    );
+    expect(vellum.title).toBe("Tool Grant Request.");
+    expect(vellum.body).toBe("Allow bash to run ls /tmp?");
+    expect(vellum.deliveryText).toBe("Allow bash to run ls /tmp?");
+    // A title is a headline, so a code-only one keeps its text.
+    expect(
+      applyGuardianReplyMechanics(
+        { ...instructionOnly, title: "Approval code: A1B2C3" },
+        "vellum",
+        signal,
+      ).title,
+    ).toBe("Approval code: A1B2C3");
+
+    // With no question text to fall back on, the field keeps its text rather
+    // than becoming empty copy the broadcaster would skip.
+    const bare = applyGuardianReplyMechanics(instructionOnly, "vellum", {
+      ...signal,
+      contextPayload: { ...signal.contextPayload, questionText: "" },
+    });
+    expect(bare.body).toBe(instructionOnly.body);
+  });
+
   test("parseInteractiveApprovalPayload rejects answer-mode and unparseable payloads", () => {
     // Answer mode: free-text questions get no Approve/Reject buttons.
     expect(

package/src/__tests__/guardian-reply-router-answer-mode.test.ts

@@ -44,7 +44,6 @@ mock.module("../channels/gateway-guardian-requests.js", () => ({
   getGuardianRequestOrNull: (id: string) =>
     Promise.resolve(requestsById.get(id) ?? null),
   getGuardianRequestByCodeOrNull: () => Promise.resolve(null),
-  getPendingRequestByDestinationMessageOrNull: () => Promise.resolve(null),
   listGuardianRequestsOrEmpty: () => Promise.resolve(pendingList),
 }));
 
@@ -91,7 +90,6 @@ function makeRequest(
 function makeContext(overrides: Record<string, unknown> = {}) {
   return {
     messageText: "",
-    channel: "telegram",
     actor: {
       actorPrincipalId: "prin-guardian",
       actorExternalUserId: "tg-guardian",

package/src/__tests__/guardian-routing-invariants.test.ts

@@ -106,7 +106,6 @@ function replyCtx(
 ): GuardianReplyContext {
   return {
     messageText: "",
-    channel: "telegram",
     actor: guardianActor(),
     conversationId: "conv-test",
     ...overrides,
@@ -1509,7 +1508,6 @@ describe("routing invariant: destination hints do not bypass tool_approval princ
     const result = await routeGuardianReply(
       replyCtx({
         messageText: "approve",
-        channel: "telegram",
         actor: guardianActor({ guardianPrincipalId: "different-principal" }),
         conversationId: "conv-guardian-chat",
         pendingScope: { mode: "scoped", requestIds: [req.id] },
@@ -1544,7 +1542,6 @@ describe("routing invariant: destination hints do not bypass tool_approval princ
     const result = await routeGuardianReply(
       replyCtx({
         messageText: "approve",
-        channel: "telegram",
         actor: guardianActor({ actorExternalUserId: "guardian-tg-user" }),
         conversationId: "conv-guardian-chat",
         // pendingScope omitted — no delivery hints
@@ -1704,7 +1701,6 @@ describe("routing invariant: invite handoff bypass for access requests", () => {
 
     const result = await routeGuardianReply({
       messageText: "C0D3A5 approve",
-      channel: "vellum",
       actor: trustedActor({ channel: "vellum" }),
       conversationId: "conv-guardian-conversation",
       pendingScope: { mode: "scoped", requestIds: [req.id] },
@@ -1743,7 +1739,6 @@ describe("routing invariant: invite handoff bypass for access requests", () => {
 
     const result = await routeGuardianReply({
       messageText: "please approve this request",
-      channel: "vellum",
       actor: trustedActor({ channel: "vellum" }),
       conversationId: "conv-guardian-conversation",
       pendingScope: { mode: "scoped", requestIds: [req.id] },
@@ -1907,16 +1902,35 @@ describe("routing invariant: kind-specific action sets in prompt mapping", () =>
     expect(actions[1].action).toBe("reject");
   });
 
-  test("source-code invariant: guardian-action-routes.ts contains kind guard", () => {
-    const srcRoot = resolve(__dirname, "..");
-    const fullPath = join(srcRoot, "runtime/routes/guardian-action-routes.ts");
-    const source = readFileSync(fullPath, "utf-8");
-    expect(source).toContain('req.kind === "access_request"');
-  });
-
   // Integration tests: verify listGuardianDecisionPrompts returns correct
   // action sets for each guardian request kind.
 
+  test("access_request prompt text carries the invite-flow sentence and no decision directive", async () => {
+    const convId = "conv-kind-access-request";
+    sim.seedRequest({
+      kind: "access_request",
+      sourceType: "channel",
+      sourceConversationId: convId,
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "ingress_access_request",
+      questionText: "Alice is requesting access to the assistant.",
+      requestCode: "A1B2C3",
+      expiresAt: Date.now() + 60_000,
+    });
+
+    const prompts = await listGuardianDecisionPrompts({
+      conversationId: convId,
+    });
+    expect(prompts).toHaveLength(1);
+    // The actions carry the decision; the invite flow has no action anywhere,
+    // so its sentence rides in the text.
+    expect(prompts[0]!.questionText).toBe(
+      'Alice is requesting access to the assistant.\nReply "open invite flow" to start Trusted Contacts invite flow.',
+    );
+    expect(prompts[0]!.questionText).not.toContain("A1B2C3");
+  });
+
   test("tool_approval prompt uses approve_once + reject only (one-time decision pattern)", async () => {
     const convId = "conv-kind-tool-approval";
     sim.seedRequest({

package/src/__tests__/host-proxy-interface.test.ts

@@ -17,6 +17,7 @@ describe("supportsHostProxy (runtime)", () => {
   test("no-arg form returns true for host-proxy interfaces", () => {
     expect(supportsHostProxy("macos")).toBe(true);
     expect(supportsHostProxy("windows")).toBe(true);
+    expect(supportsHostProxy("linux")).toBe(true);
   });
 
   test("no-arg form returns false for interfaces without host-proxy support", () => {
@@ -59,6 +60,15 @@ describe("supportsHostProxy (runtime)", () => {
     expect(supportsHostProxy("windows", "host_app_control")).toBe(false);
   });
 
+  test("capability form withholds unimplemented Linux app control", () => {
+    expect(supportsHostProxy("linux", "host_bash")).toBe(true);
+    expect(supportsHostProxy("linux", "host_file")).toBe(true);
+    expect(supportsHostProxy("linux", "host_cu")).toBe(true);
+    expect(supportsHostProxy("linux", "host_browser")).toBe(true);
+    expect(supportsHostProxy("linux", "host_ui_snapshot")).toBe(true);
+    expect(supportsHostProxy("linux", "host_app_control")).toBe(false);
+  });
+
   test("capability form rejects everything for non-host-proxy interfaces", () => {
     expect(supportsHostProxy("ios", "host_bash")).toBe(false);
     expect(supportsHostProxy("cli", "host_file")).toBe(false);

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

@@ -103,6 +103,7 @@ function createTestContext(
     : null;
 
   let processing = false;
+  let owner = 0;
   return {
     conversationId: "conv-test",
     messages: [],
@@ -110,6 +111,21 @@ function createTestContext(
     setProcessing: (value: boolean) => {
       processing = value;
     },
+    acquireProcessingFenced: async () => {
+      if (processing) {
+        return null;
+      }
+      processing = true;
+      owner += 1;
+      return owner;
+    },
+    releaseProcessing: (claim: number) => {
+      if (claim !== owner) {
+        return false;
+      }
+      processing = false;
+      return true;
+    },
     abortController: null,
     queue: queueStub,
     getTurnChannelContext: () => turnChannel,

package/src/__tests__/injector-v3-suppression.test.ts

@@ -10,10 +10,11 @@
  * pre-cutover v2 blocks both ride the cached prefix); the old whole-layer
  * strip is gone.
  *
- * The ephemeral `<memory_spotlight>` block is strip-and-replaced every turn:
- * stale spotlights are removed from every user message unconditionally (a
- * scoped, single-id strip), and the spotlight injector's `append-user-tail`
- * block lands at the tail.
+ * Leftover `<memory_spotlight>` blocks are stripped from the TAIL user
+ * message only (mid-turn re-entry / post-compact must not double-stack).
+ * Historical user messages keep the spotlight they were sent with. The
+ * spotlight injector's `after-memory-prefix` block is spliced onto the
+ * current tail and captured on `blocks`.
  *
  * v2 suppression stays keyed off whether v3 produced a block, NOT off the
  * gate alone: a v3 failure (`produce()` → null) leaves v2's block intact
@@ -128,7 +129,7 @@ function v3Injector(inner: string | null, commit?: () => void): Injector {
   };
 }
 
-/** A fake v3 spotlight injector mirroring the real id + tail placement. */
+/** A fake v3 spotlight injector mirroring the real id + placement. */
 function spotlightInjector(inner: string): Injector {
   return {
     name: "memory-v3-spotlight",
@@ -137,7 +138,7 @@ function spotlightInjector(inner: string): Injector {
       return {
         id: "memory-v3-spotlight",
         text: wrapMemorySpotlightBlock(inner),
-        placement: "append-user-tail",
+        placement: "after-memory-prefix",
       };
     },
   };
@@ -242,7 +243,7 @@ describe("memory-v3-live v2 suppression", () => {
     expect(result.blocks.memoryV3Active).toBe(true);
   });
 
-  test("stale spotlight blocks are stripped from EVERY user message; the new spotlight lands at the tail", async () => {
+  test("historical leftover spotlight stays; the fresh spotlight splices onto the tail", async () => {
     memoryV3LiveSlot = true;
     injectorChainSlot.push(v3Injector(""), spotlightInjector("fresh sections"));
 
@@ -266,16 +267,49 @@ describe("memory-v3-live v2 suppression", () => {
       ...makeTurnContext(),
     });
 
-    // The stale spotlight is gone from the historical turn…
+    // Historical turn keeps the spotlight it was sent with.
     expect(result.messages[0].content).toEqual([
       { type: "text", text: "earlier question" },
+      staleSpotlight,
     ]);
-    // …and exactly one fresh spotlight sits at the tail.
+    // Fresh spotlight splices onto the tail (no memory prefix, so index 0)
+    // and is captured for metadata persist.
     const texts = tailTexts(result.messages);
     expect(texts).toEqual([
+      wrapMemorySpotlightBlock("fresh sections"),
       "current question",
+    ]);
+    expect(result.blocks.memoryV3SpotlightBlock).toBe(
       wrapMemorySpotlightBlock("fresh sections"),
+    );
+  });
+
+  test("tail leftover spotlight is stripped before the fresh spotlight splices", async () => {
+    memoryV3LiveSlot = true;
+    injectorChainSlot.push(v3Injector(""), spotlightInjector("fresh sections"));
+
+    const staleOnTail = wrapMemorySpotlightBlock("stale sections");
+    const runMessages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: staleOnTail },
+          { type: "text", text: "current question" },
+        ],
+      },
+    ];
+
+    const result = await applyRuntimeInjections(runMessages, {
+      ...makeTurnContext(),
+    });
+
+    expect(tailTexts(result.messages)).toEqual([
+      wrapMemorySpotlightBlock("fresh sections"),
+      "current question",
     ]);
+    expect(result.blocks.memoryV3SpotlightBlock).toBe(
+      wrapMemorySpotlightBlock("fresh sections"),
+    );
   });
 
   test("convergence re-entry: a tail leading with this turn's frozen v3 cards (and <info>) is NOT stripped", async () => {

package/src/__tests__/list-messages-page-latest.test.ts

@@ -491,6 +491,133 @@ describe("handleListMessages page=latest", () => {
     });
   });
 
+  test("an assistant row still carrying the partial pre-send envelope projects no slackMessage", async () => {
+    // The row an outbound Slack reply is reserved with names no id of its own:
+    // `channelTs` is back-filled by the post-send reconciliation. Until that
+    // lands, the strict reader rejects the envelope and the row projects
+    // nothing, so a client cannot attribute it to Slack. This is the silent
+    // half of the reconciliation gap, pinned so a reader that starts
+    // tolerating the partial form has to justify it here.
+    const conv = createConversation();
+    const db = getDb();
+    db.insert(messages)
+      .values({
+        id: "msg-slack-partial",
+        conversationId: conv.id,
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Posted to Slack" }]),
+        metadata: JSON.stringify({
+          userMessageChannel: "slack",
+          assistantMessageChannel: "slack",
+          slackMeta: JSON.stringify({
+            source: "slack",
+            eventKind: "message",
+            channelId: "C123ABCDEF",
+            threadTs: "1710000000.000100",
+            timestampTimezone: "America/New_York",
+            timestampTimezoneLabel: "ET",
+          }),
+        }),
+        createdAt: 1,
+      })
+      .run();
+
+    const body = await callList({ conversationId: conv.id, page: "latest" });
+
+    expect(body.messages[0].slackMessage).toBeUndefined();
+  });
+
+  test("a reconciled assistant row on the neutral envelope projects the same slackMessage", async () => {
+    // The row a Slack reply is written with today: the neutral envelope,
+    // Slack's own fields on its passthrough, `messageId` back-filled by the
+    // post-send reconciliation. The wire projection reads it through the
+    // envelope's Slack view, so the client sees exactly what a legacy
+    // `slackMeta` row projects.
+    const conv = createConversation();
+    const db = getDb();
+    db.insert(messages)
+      .values({
+        id: "msg-slack-neutral",
+        conversationId: conv.id,
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Posted to Slack" }]),
+        metadata: JSON.stringify({
+          userMessageChannel: "slack",
+          assistantMessageChannel: "slack",
+          providerMeta: JSON.stringify({
+            source: "slack",
+            conversationExternalId: "C123ABCDEF",
+            messageId: "1710000000.000200",
+            threadId: "1710000000.000100",
+            eventKind: "message",
+            timestampTimezone: "America/New_York",
+            timestampTimezoneLabel: "ET",
+          }),
+        }),
+        createdAt: 1,
+      })
+      .run();
+
+    const body = await callList({ conversationId: conv.id, page: "latest" });
+
+    const slackMessage = body.messages[0].slackMessage;
+    expect(slackMessage).toBeDefined();
+    expect(slackMessage?.channelId).toBe("C123ABCDEF");
+    expect(slackMessage?.channelTs).toBe("1710000000.000200");
+    expect(slackMessage?.threadTs).toBe("1710000000.000100");
+    expect(slackMessage?.eventKind).toBe("message");
+    expect(slackMessage?.messageLink).toBeDefined();
+  });
+
+  test("the reconciled assistant row projects slackMessage with the post's own ts", async () => {
+    // The other half of the same chain: once reconciliation stamps the ts the
+    // transport returned, the identical row projects a full envelope. Built by
+    // running the production reconciliation merge over the partial form rather
+    // than hand-writing the result, so the two stay in step.
+    const conv = createConversation();
+    const partial = {
+      source: "slack",
+      eventKind: "message" as const,
+      channelId: "C123ABCDEF",
+      threadTs: "1710000000.000100",
+      timestampTimezone: "America/New_York",
+      timestampTimezoneLabel: "ET",
+    };
+    const reconciled = JSON.stringify({
+      ...partial,
+      channelTs: "1710000000.000200",
+      source: "slack",
+    });
+
+    const db = getDb();
+    db.insert(messages)
+      .values({
+        id: "msg-slack-reconciled",
+        conversationId: conv.id,
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Posted to Slack" }]),
+        metadata: JSON.stringify({
+          userMessageChannel: "slack",
+          assistantMessageChannel: "slack",
+          slackMeta: reconciled,
+        }),
+        createdAt: 1,
+      })
+      .run();
+
+    const body = await callList({ conversationId: conv.id, page: "latest" });
+
+    const slackMessage = body.messages[0].slackMessage;
+    expect(slackMessage).toBeDefined();
+    expect(slackMessage?.channelId).toBe("C123ABCDEF");
+    expect(slackMessage?.channelTs).toBe("1710000000.000200");
+    expect(slackMessage?.threadTs).toBe("1710000000.000100");
+    expect(slackMessage?.eventKind).toBe("message");
+    // The deep link is what the drawer's "open the source" action needs, and
+    // it is derivable only from the reconciled ts.
+    expect(slackMessage?.messageLink).toBeDefined();
+  });
+
   test("top-level Slack messages with matching threadTs use plain permalinks", async () => {
     const conv = createConversation();
     const db = getDb();