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

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/admission-policy.ts

@@ -27,6 +27,7 @@ import {
   ADMISSION_FLOOR,
   type AdmissionPolicy,
   isAdmissionPolicyExemptChannel,
+  TRUST_CLASS_RANK,
 } from "@vellumai/gateway-client";
 
 import type { ChannelId } from "../../../channels/types.js";
@@ -73,23 +74,6 @@ export type AdmissionPolicyResult =
 // Public API
 // ---------------------------------------------------------------------------
 
-/**
- * Trust-class ordinal compared against {@link ADMISSION_FLOOR} to make the
- * admission decision (`rank >= floor`). Higher rank = more trusted.
- * Blocked/revoked never reach this comparison — they short-circuit to deny on
- * member status above — so they carry no rank here.
- *
- * The two halves of the floor check: this table is keyed by `TrustClass`,
- * `ADMISSION_FLOOR` (from `@vellumai/gateway-client`) by `AdmissionPolicy`.
- * They are only ever read together, here, so they live next to their use.
- */
-const TRUST_CLASS_RANK: Record<TrustClass, number> = {
-  guardian: 4,
-  trusted_contact: 3,
-  unverified_contact: 2,
-  unknown: 1,
-};
-
 /**
  * Policies under which completing verification could lift the sender past
  * the floor. Used to decide whether to fire the upgrade UX on deny.

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/edit-intercept.ts

@@ -11,20 +11,23 @@
  * the message's metadata via a single transactional content+metadata update,
  * so downstream renderers can surface the edited marker.
  *
- * Extracted from inbound-message-handler.ts to keep the top-level handler
- * focused on orchestration.
+ * An edit belongs to the conversation of the message it changes, so the stage
+ * resolves that message before it records anything, and an edit with no
+ * resolvable target is dropped.
  */
 import type { ChannelId } from "../../../channels/types.js";
 import {
   mergeSlackMetadata,
   readSlackMetadata,
 } from "../../../messaging/providers/slack/message-metadata.js";
+import type { MessageRow } from "../../../persistence/conversation-crud.js";
 import {
   getMessageById,
   updateMessageContent,
   updateMessageContentAndMetadata,
 } from "../../../persistence/conversation-crud.js";
 import {
+  findInboundEvent,
   findMessageBySourceId,
   recordInbound,
 } from "../../../persistence/delivery-crud.js";
@@ -45,7 +48,6 @@ export interface EditInterceptParams {
   externalMessageId: string;
   sourceMessageId: string;
   sourceThreadId?: string;
-  canonicalAssistantId: string;
   assistantId: string;
   content: string | undefined;
   /** Channel ID for channel-level interaction tracking. */
@@ -68,24 +70,23 @@ export async function handleEditIntercept(
     externalMessageId,
     sourceMessageId,
     sourceThreadId,
-    canonicalAssistantId,
     assistantId,
     content,
   } = params;
 
-  // Dedup the edit event itself (retried edited_message webhooks)
-  const editResult = recordInbound(
+  // Dedup the edit event itself (retried edited_message webhooks) before the
+  // lookup below, so a redelivery answers immediately instead of waiting out
+  // the retry window a second time.
+  const alreadyRecorded = findInboundEvent(
     sourceChannel,
     conversationExternalId,
     externalMessageId,
-    { sourceMessageId, sourceThreadId, assistantId: canonicalAssistantId },
   );
-
-  if (editResult.duplicate) {
+  if (alreadyRecorded) {
     return {
       accepted: true,
       duplicate: true,
-      eventId: editResult.eventId,
+      eventId: alreadyRecorded.eventId,
     };
   }
 
@@ -119,81 +120,100 @@ export async function handleEditIntercept(
     }
   }
 
-  if (original) {
-    const newContent = content ?? "";
-    // Short-circuit no-op edits: Slack fires `message_changed` for link
-    // unfurls and other decorations where the text is identical to the
-    // previous revision. Skipping the DB write here covers that case and
-    // also drops trivially-redundant edit webhooks. We only have the
-    // authoritative previous text once the original row is located, so
-    // this check lives after the lookup.
-    const existingRow = getMessageById(original.messageId);
-    if (
-      existingRow &&
-      stringifyMessageContent(existingRow.content) === newContent
-    ) {
-      log.debug(
-        {
-          assistantId,
-          sourceChannel,
-          sourceMessageId,
-          messageId: original.messageId,
-        },
-        "Edit text unchanged; skipping update",
-      );
-      return {
-        accepted: true,
-        duplicate: false,
-        noop: true,
-        eventId: editResult.eventId,
-      };
-    }
-    if (sourceChannel === "slack") {
-      // Slack edits stamp `slackMeta.editedAt` so the chronological
-      // transcript renderer can surface the edited marker. The merge
-      // tolerates rows that lack slackMeta enrichment by synthesizing
-      // the minimum-required fields from the lookup data.
-      applySlackEditMetadata({
-        messageId: original.messageId,
-        conversationExternalId,
-        sourceMessageId,
-        sourceThreadId,
-        newContent,
-      });
-    } else {
-      updateMessageContent(original.messageId, newContent);
-    }
-    // The edit changed searchable text (the no-op guard above already returned
-    // for identical content) and this path bypasses the `addMessage` persist
-    // path, so reindex the message into the lexical index — the idempotent
-    // upsert replaces the stale Qdrant point with the edited content.
-    enqueueLexicalIndexForMessage(original.messageId);
-    log.info(
-      { assistantId, sourceMessageId, messageId: original.messageId },
-      "Updated message content from edited_message",
-    );
-  } else {
-    // For Slack, treat missing-target edits as `debug` (the row may have
-    // been compacted, never stored, or pre-date this upgrade); for other
-    // channels, retain the louder `warn` since their edit pipelines
-    // historically expect the row to exist.
+  if (!original) {
+    // Nothing to edit, and nothing to record it against: recording it anyway
+    // would resolve a conversation from the edit's own address and create one
+    // there.
+    //
+    // Slack keeps this at `debug`, since the row may have been compacted or
+    // never stored. Other channels keep the louder `warn`, since their edit
+    // pipelines expect the row to exist.
+    const missingTarget = {
+      assistantId,
+      sourceChannel,
+      conversationExternalId,
+      sourceMessageId,
+    };
     if (sourceChannel === "slack") {
-      log.debug(
-        {
-          assistantId,
-          sourceChannel,
-          channelId: conversationExternalId,
-          externalMessageId: sourceMessageId,
-        },
-        "Slack edit target not found, ignoring",
-      );
+      log.debug(missingTarget, "Slack edit target not found, ignoring");
     } else {
       log.warn(
-        { assistantId, sourceChannel, conversationExternalId, sourceMessageId },
+        missingTarget,
         "Could not find original message for edit after retries, ignoring",
       );
     }
+    return { accepted: true, duplicate: false, edited: false };
+  }
+
+  // The edit belongs to the conversation of the message it changes. Resolving
+  // one from the edit's own address would key it on the edited message's
+  // timestamp and create a conversation there.
+  const editResult = recordInbound(
+    sourceChannel,
+    conversationExternalId,
+    externalMessageId,
+    { sourceMessageId, conversationId: original.conversationId },
+  );
+  if (editResult.duplicate) {
+    // Two deliveries of one edit raced through the probe above while neither
+    // had recorded yet. The first owns the write; applying it twice would
+    // re-enqueue lexical indexing for no change.
+    return { accepted: true, duplicate: true, eventId: editResult.eventId };
+  }
+
+  const newContent = content ?? "";
+  // Short-circuit no-op edits: Slack fires `message_changed` for link
+  // unfurls and other decorations where the text is identical to the
+  // previous revision. Skipping the DB write here covers that case and
+  // also drops trivially-redundant edit webhooks. We only have the
+  // authoritative previous text once the original row is located, so
+  // this check lives after the lookup.
+  const existingRow = getMessageById(original.messageId);
+  if (
+    existingRow &&
+    stringifyMessageContent(existingRow.content) === newContent
+  ) {
+    log.debug(
+      {
+        assistantId,
+        sourceChannel,
+        sourceMessageId,
+        messageId: original.messageId,
+      },
+      "Edit text unchanged; skipping update",
+    );
+    return {
+      accepted: true,
+      duplicate: false,
+      noop: true,
+      eventId: editResult.eventId,
+    };
+  }
+  if (sourceChannel === "slack") {
+    // Slack edits stamp `slackMeta.editedAt` so the chronological
+    // transcript renderer can surface the edited marker. The merge
+    // tolerates rows that lack slackMeta enrichment by synthesizing
+    // the minimum-required fields from the lookup data.
+    applySlackEditMetadata({
+      messageId: original.messageId,
+      existingRow,
+      conversationExternalId,
+      sourceMessageId,
+      sourceThreadId,
+      newContent,
+    });
+  } else {
+    updateMessageContent(original.messageId, newContent);
   }
+  // The edit changed searchable text (the no-op guard above already returned
+  // for identical content) and this path bypasses the `addMessage` persist
+  // path, so reindex the message into the lexical index — the idempotent
+  // upsert replaces the stale Qdrant point with the edited content.
+  enqueueLexicalIndexForMessage(original.messageId);
+  log.info(
+    { assistantId, sourceMessageId, messageId: original.messageId },
+    "Updated message content from edited_message",
+  );
 
   return {
     accepted: true,
@@ -219,6 +239,8 @@ export async function handleEditIntercept(
  */
 function applySlackEditMetadata(params: {
   messageId: string;
+  /** The stored row, already read by the caller's no-op guard. */
+  existingRow: MessageRow | null;
   conversationExternalId: string;
   sourceMessageId: string;
   sourceThreadId?: string;
@@ -226,13 +248,13 @@ function applySlackEditMetadata(params: {
 }): void {
   const {
     messageId,
+    existingRow: row,
     conversationExternalId,
     sourceMessageId,
     sourceThreadId,
     newContent,
   } = params;
 
-  const row = getMessageById(messageId);
   const outerMetadata: Record<string, unknown> =
     row?.metadata != null ? safeParseRecord(row.metadata) : {};
   const existingSlackMeta =

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,11 +42,16 @@ export interface GuardianReplyInterceptParams {
   reactedMessageTs?: string;
   rawSenderId: string | undefined;
   canonicalSenderId: string | null;
-  canonicalAssistantId: string;
   sourceChannel: ChannelId;
   conversationExternalId: string;
-  conversationId: string;
-  eventId: string;
+  /**
+   * Conversation the message arrived in. Reactions resolve their target by the
+   * reacted card's own address and are routed before any conversation is
+   * known, so they pass none.
+   */
+  conversationId?: string;
+  /** Inbound event id, echoed on the consumed response when the caller has one. */
+  eventId?: string;
   replyCallbackUrl: string | undefined;
   trustClass: string;
   guardianPrincipalId: string | null | undefined;
@@ -77,7 +83,6 @@ export async function handleGuardianReplyIntercept(
     reactedMessageTs,
     rawSenderId,
     canonicalSenderId,
-    canonicalAssistantId,
     sourceChannel,
     conversationExternalId,
     conversationId,
@@ -178,7 +183,7 @@ export async function handleGuardianReplyIntercept(
     channelDeliveryContext: {
       replyCallbackUrl,
       guardianChatId: conversationExternalId,
-      assistantId: canonicalAssistantId,
+      assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
     },
   });
 
@@ -188,7 +193,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.
@@ -210,7 +215,7 @@ export async function handleGuardianReplyIntercept(
       response: {
         accepted: true,
         duplicate: false,
-        eventId,
+        ...(eventId ? { eventId } : {}),
         canonicalRouter: routerResult.type,
         requestId: routerResult.requestId,
       },

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

@@ -69,17 +69,28 @@ mock.module("../../../contacts/contact-store.js", () => ({
 // Downstream side-effect stubs
 // ---------------------------------------------------------------------------
 
-let recordInboundCalls = 0;
+let recordInboundCalls: Array<{ conversationId?: string }> = [];
+let recordedEvent: { eventId: string; conversationId: string } | null = null;
+let outboundTargetConversationId: string | null = null;
+let storedTarget: { messageId: string; conversationId: string } | null = null;
 mock.module("../../../persistence/delivery-crud.js", () => ({
-  recordInbound: () => {
-    recordInboundCalls++;
+  recordInbound: (
+    _channel: string,
+    _chat: string,
+    _externalMessageId: string,
+    options?: { conversationId?: string },
+  ) => {
+    recordInboundCalls.push({ conversationId: options?.conversationId });
     return {
       eventId: "evt-1",
-      conversationId: "conv-1",
+      conversationId: options?.conversationId ?? "conv-minted",
       accepted: true,
       duplicate: false,
     };
   },
+  findMessageBySourceId: () => storedTarget,
+  findSlackConversationByMessageTs: () => outboundTargetConversationId,
+  findInboundEvent: () => recordedEvent,
   clearPayload: () => {},
   linkMessage: () => {},
 }));
@@ -172,7 +183,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",
@@ -185,7 +195,6 @@ function buildParams(overrides: {
         ? { trustVerdict: overrides.trustVerdict }
         : {}),
     } as never,
-    slackChannelName: "general",
     approvalConversationGenerator: undefined,
   };
 }
@@ -194,7 +203,7 @@ function expectDropped(result: Record<string, unknown>): void {
   expect(result.reaction).toBe("dropped_unknown_actor");
   // Dropped before any write or routing: no dedup record, no transcript row,
   // no approval-pipeline dispatch.
-  expect(recordInboundCalls).toBe(0);
+  expect(recordInboundCalls.length).toBe(0);
   expect(addMessageCalls).toBe(0);
   expect(guardianReplyCalls.length).toBe(0);
 }
@@ -205,10 +214,13 @@ describe("reaction intercept consumes the stamped verdict directly", () => {
     guardianDeliveryReads = 0;
     setMemberVerdictCalls = 0;
     contactLookups = 0;
-    recordInboundCalls = 0;
+    recordInboundCalls = [];
+    recordedEvent = null;
+    outboundTargetConversationId = null;
     addMessageCalls = 0;
     guardianReplyCalls = [];
     guardianReplyResponse = undefined;
+    storedTarget = { messageId: "msg-target", conversationId: "conv-target" };
   });
 
   test("guardian verdict routes the reaction into the approval decision pipeline", async () => {
@@ -245,6 +257,77 @@ describe("reaction intercept consumes the stamped verdict directly", () => {
     expect(result.accepted).toBe(true);
     expect(result.reaction).toBeUndefined();
     expect(addMessageCalls).toBe(1);
+    // Recorded into the reacted message's conversation, never a fresh one.
+    expect(recordInboundCalls).toEqual([{ conversationId: "conv-target" }]);
+  });
+
+  test("a reaction on the assistant's own post resolves through slackMeta", async () => {
+    // Outbound posts open no inbound event, so the ts is only on the row.
+    storedTarget = null;
+    outboundTargetConversationId = "conv-assistant-post";
+
+    const result = await handleSlackReactionIntercept(
+      buildParams({
+        rawSenderId: MEMBER_USER_ID,
+        trustVerdict: MEMBER_VERDICT,
+      }),
+    );
+
+    expect(recordInboundCalls).toEqual([
+      { conversationId: "conv-assistant-post" },
+    ]);
+    expect(addMessageCalls).toBe(1);
+    expect(result).toMatchObject({ accepted: true, duplicate: false });
+  });
+
+  test("a reaction on a message that is not stored is dropped without minting", async () => {
+    storedTarget = null;
+
+    const result = await handleSlackReactionIntercept(
+      buildParams({
+        rawSenderId: MEMBER_USER_ID,
+        trustVerdict: MEMBER_VERDICT,
+      }),
+    );
+
+    expect(result.reaction).toBe("dropped_unknown_target");
+    expect(recordInboundCalls.length).toBe(0);
+    expect(addMessageCalls).toBe(0);
+  });
+
+  test("a redelivered reaction never reaches the guardian rail twice", async () => {
+    recordedEvent = { eventId: "evt-1", conversationId: "conv-target" };
+
+    const result = await handleSlackReactionIntercept(
+      buildParams({
+        rawSenderId: GUARDIAN_USER_ID,
+        trustVerdict: GUARDIAN_VERDICT,
+      }),
+    );
+
+    expect(result).toEqual({
+      accepted: true,
+      duplicate: true,
+      eventId: "evt-1",
+    });
+    expect(guardianReplyCalls.length).toBe(0);
+    expect(addMessageCalls).toBe(0);
+    expect(recordInboundCalls.length).toBe(0);
+  });
+
+  test("a guardian card reaction still applies when the card is not a stored message", async () => {
+    storedTarget = null;
+    guardianReplyResponse = { accepted: true, canonicalRouter: "applied" };
+
+    const result = await handleSlackReactionIntercept(
+      buildParams({
+        rawSenderId: GUARDIAN_USER_ID,
+        trustVerdict: GUARDIAN_VERDICT,
+      }),
+    );
+
+    expect(result).toEqual(guardianReplyResponse);
+    expect(recordInboundCalls.length).toBe(0);
   });
 
   test("unknown verdict is dropped before any write", async () => {