@vellumai/assistant 0.11.7-dev.202609012016.14eabff → 0.11.7-dev.202609012214.c97412d

package/ARCHITECTURE.md

@@ -120,7 +120,7 @@ Scoped approval grants allow a guardian's approval decision on one channel (e.g.
 
 ### Guardian Decision Primitive
 
-All guardian approval decisions — regardless of how they arrive — route through a single primitive in `src/approvals/guardian-decision-primitive.ts`, which centralizes decision logic for callback button handlers, the conversational approval engine, and channel reactions/text.
+All guardian approval decisions, regardless of how they arrive, route through a single primitive in `src/approvals/guardian-decision-primitive.ts`, which centralizes decision logic for callback button handlers, the conversational approval engine, and channel text replies.
 
 **Core API:**
 

package/docs/guardian-request-flow.md

@@ -28,10 +28,10 @@ anti-pattern was retired in #35642 and again in the ask_question redesign).
   telegram: inline keyboard; slack: blocks;       vellum: conversation card via approval-card-builder)
   card deliveries recorded per channel            (guardian-delivery-recorder.ts → guardian_request_deliveries)
         │
-        ▼ user responds: button tap / emoji reaction / "CODE <reply>" / bare text
+        ▼ user responds: button tap / "CODE <reply>" / bare text
   guardian reply router                          (runtime/guardian-reply-router.ts, invoked from
-  reactions → callbacks → request codes →         routes/inbound-stages/guardian-reply-intercept.ts,
-  bare answer → explicit approve/reject → NL      BEFORE background dispatch — replies to parked
+  callbacks → request codes → bare answer →       routes/inbound-stages/guardian-reply-intercept.ts,
+  explicit approve/reject → NL                    BEFORE background dispatch: replies to parked
         │                                         prompts resolve inline, never deferred)
         ▼ one decision primitive
   applyGuardianDecision                          (approvals/guardian-decision-primitive.ts:
@@ -45,14 +45,14 @@ anti-pattern was retired in #35642 and again in the ask_question redesign).
 
 ## Who owns what
 
-| Concern                                 | Owner                                                    | Never                               |
-| --------------------------------------- | -------------------------------------------------------- | ----------------------------------- |
-| The "what": card text, actions, options | broadcaster context build (once per broadcast)           | built per-adapter                   |
-| The "how": channel-native rendering     | `notifications/adapters/<channel>`                       | domain logic, payload parsing       |
-| Request state                           | gateway `guardian_requests` (+ deliveries)               | daemon-side request tables          |
-| Decisions                               | `applyGuardianDecision` (CAS, atomic ACL outcome)        | inline decision logic at call sites |
-| Kind-specific follow-through            | resolver registry (`kind` → resolver)                    | switch statements in the router     |
-| Reply understanding                     | guardian reply router (codes, buttons, reactions, modes) | per-feature inbound intercepts      |
+| Concern                                 | Owner                                             | Never                               |
+| --------------------------------------- | ------------------------------------------------- | ----------------------------------- |
+| The "what": card text, actions, options | broadcaster context build (once per broadcast)    | built per-adapter                   |
+| The "how": channel-native rendering     | `notifications/adapters/<channel>`                | domain logic, payload parsing       |
+| Request state                           | gateway `guardian_requests` (+ deliveries)        | daemon-side request tables          |
+| Decisions                               | `applyGuardianDecision` (CAS, atomic ACL outcome) | inline decision logic at call sites |
+| Kind-specific follow-through            | resolver registry (`kind` → resolver)             | switch statements in the router     |
+| Reply understanding                     | guardian reply router (codes, buttons, modes)     | per-feature inbound intercepts      |
 
 ## The canonical home-feed projection
 
@@ -186,8 +186,8 @@ chat the turn is running in. On Slack that chat can be a shared room, and the
 card carries the tool, a command preview and live buttons.
 `resolveGuardianPromptDelivery` addresses it to the guardian's bound DM
 instead, by chat id rather than user id because that address is written to the
-delivery row and read back to match reactions, scope plain-text replies and
-edit the decided card. It returns the address and its route together, since
+delivery row and read back to scope plain-text replies and edit the decided
+card. It returns the address and its route together, since
 the turn's own callback carries a `threadTs` naming a thread that does not
 exist in the DM. When no private address resolves it returns nothing and the
 prompt is left to the in-app confirmation, because the room is the disclosure

package/node_modules/@vellumai/gateway-client/src/__tests__/guardian-request-contract.test.ts

@@ -16,7 +16,6 @@ import {
   ExpireGuardianRequestIpcParamsSchema,
   ExpireInteractionBoundIpcResponseSchema,
   GetGuardianRequestByCallSessionIpcParamsSchema,
-  GetGuardianRequestByDestinationMessageIpcParamsSchema,
   GetGuardianRequestByPendingQuestionIpcParamsSchema,
   GUARDIAN_REQUESTS_IPC_METHODS,
   GuardianRequestAclOutcomeSchema,
@@ -482,23 +481,6 @@ describe("delivery + destination IPC schemas", () => {
     );
   });
 
-  test("get_by_destination_message requires all three keys", () => {
-    const params = {
-      channel: "telegram",
-      chatId: "tg-chat-guardian",
-      messageId: "msg-42",
-    };
-    expect(
-      GetGuardianRequestByDestinationMessageIpcParamsSchema.parse(params),
-    ).toEqual(params);
-    expect(() =>
-      GetGuardianRequestByDestinationMessageIpcParamsSchema.parse({
-        channel: "telegram",
-        chatId: "tg-chat-guardian",
-      }),
-    ).toThrow();
-  });
-
   test("list_pending_by_destination accepts either addressing form", () => {
     const byConversation = { conversationId: "conv-1", channel: "telegram" };
     expect(

package/node_modules/@vellumai/gateway-client/src/guardian-request-contract.ts

@@ -15,11 +15,6 @@
  * daemon's client-facing HTTP surface owns the distinct `guardian_actions_*`
  * operationIds (`guardian_actions_pending` / `guardian_actions_decision`),
  * which do not change.
- *
- * Destination lookups are deliberately split into a single-message lookup
- * (`get_by_destination_message`) and a pending-list read
- * (`list_pending_by_destination`) so each response schema has exactly one
- * shape instead of a params-dependent polymorphic result.
  */
 
 import { z } from "zod";
@@ -194,7 +189,6 @@ export const GUARDIAN_REQUESTS_IPC_METHODS = {
   updateDelivery: "guardian_requests_update_delivery",
   listDeliveries: "guardian_requests_list_deliveries",
   listDeliveriesByChat: "guardian_requests_list_deliveries_by_chat",
-  getByDestinationMessage: "guardian_requests_get_by_destination_message",
   listPendingByDestination: "guardian_requests_list_pending_by_destination",
   listPendingByScope: "guardian_requests_list_pending_by_scope",
   inScope: "guardian_requests_in_scope",
@@ -627,21 +621,6 @@ export type GuardianRequestDeliveryListIpcResponse = z.infer<
 // Destination + scope lookups
 // ---------------------------------------------------------------------------
 
-/**
- * Request for `guardian_requests_get_by_destination_message` — reaction
- * routing: recover the pending request whose delivered card is the reacted-to
- * message.
- */
-export const GetGuardianRequestByDestinationMessageIpcParamsSchema = z.object({
-  channel: z.string().min(1),
-  chatId: z.string().min(1),
-  messageId: z.string().min(1),
-});
-
-export type GetGuardianRequestByDestinationMessageIpcParams = z.infer<
-  typeof GetGuardianRequestByDestinationMessageIpcParamsSchema
->;
-
 /**
  * Request for `guardian_requests_list_pending_by_destination`. Two forms:
  * by destination conversation (`conversationId`, optionally narrowed by

package/node_modules/@vellumai/gateway-client/src/index.ts

@@ -245,7 +245,6 @@ export {
   ExpireInteractionBoundIpcResponseSchema,
   GetGuardianRequestByCallSessionIpcParamsSchema,
   GetGuardianRequestByCodeIpcParamsSchema,
-  GetGuardianRequestByDestinationMessageIpcParamsSchema,
   GetGuardianRequestByPendingQuestionIpcParamsSchema,
   GetGuardianRequestIpcParamsSchema,
   GUARDIAN_REQUESTS_IPC_METHODS,
@@ -286,7 +285,6 @@ export type {
   ExpireInteractionBoundIpcResponse,
   GetGuardianRequestByCallSessionIpcParams,
   GetGuardianRequestByCodeIpcParams,
-  GetGuardianRequestByDestinationMessageIpcParams,
   GetGuardianRequestByPendingQuestionIpcParams,
   GetGuardianRequestIpcParams,
   GuardianRequestAclOutcome,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.7-dev.202609012016.14eabff",
+  "version": "0.11.7-dev.202609012214.c97412d",
   "license": "MIT",
   "type": "module",
   "exports": {

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-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] },

package/src/__tests__/reaction-persistence.test.ts

@@ -87,14 +87,12 @@ import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { linkMessage, recordInbound } from "../persistence/delivery-crud.js";
 import { messages } from "../persistence/schema/conversations.js";
-import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { isReactionEvent } from "../runtime/routes/inbound-stages/reaction-intercept.js";
 import {
   handleChannelInbound,
   seedContactChannel,
 } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
-import { bridgeState } from "./helpers/gateway-guardian-requests-store-bridge.js";
 
 await initializeDb();
 
@@ -623,200 +621,6 @@ describe("Slack reaction event persistence", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// Guardian approval-by-reaction integration test
-// ---------------------------------------------------------------------------
-//
-// Verifies that approval interception runs before reaction persistence so a
-// guardian's `reaction:` event on a pending approval prompt applies the
-// decision and no transcript-line row is written for the reaction itself.
-
-const GUARDIAN_USER_ID = "U_GUARDIAN_REACT";
-const GUARDIAN_DISPLAY_NAME = "Guardian Reactor";
-const GUARDIAN_REACTION_TOOL = "execute_shell";
-const GUARDIAN_REACTION_INPUT = { command: "rm -rf /tmp/test" };
-
-function seedGuardianForChannel(): void {
-  seedGatewayGuardian({
-    channelType: "slack",
-    address: GUARDIAN_USER_ID,
-    principalId: GUARDIAN_USER_ID,
-    externalChatId: SLACK_CHANNEL_ID,
-  });
-  createGuardianBinding({
-    channel: "slack",
-    guardianExternalUserId: GUARDIAN_USER_ID,
-    guardianDeliveryChatId: SLACK_CHANNEL_ID,
-    guardianPrincipalId: GUARDIAN_USER_ID,
-  });
-}
-
-function seedPendingGuardianApprovalForReaction(
-  requestId: string,
-  conversationId: string,
-  reactedTs: string,
-): void {
-  // Canonical tool_approval request keyed by the confirmation requestId — the
-  // same record assistant-event-hub creates for every confirmation.
-  bridgeState.seedRequest({
-    id: requestId,
-    kind: "tool_approval",
-    sourceType: "channel",
-    sourceChannel: "slack",
-    sourceConversationId: conversationId,
-    requesterExternalUserId: "requester-user-1",
-    requesterChatId: SLACK_CHANNEL_ID,
-    guardianExternalUserId: GUARDIAN_USER_ID,
-    guardianPrincipalId: GUARDIAN_USER_ID,
-    toolName: GUARDIAN_REACTION_TOOL,
-    status: "pending",
-    expiresAt: Date.now() + 300_000,
-  });
-
-  // The delivered approval card → request mapping the reaction resolves
-  // against (destination message id = the reacted Slack ts).
-  bridgeState.seedDelivery({
-    requestId,
-    destinationChannel: "slack",
-    destinationChatId: SLACK_CHANNEL_ID,
-    destinationMessageId: reactedTs,
-  });
-
-  // Register a pending interaction so the tool_approval resolver finds the
-  // requester-side hook to drive `allow`.
-  const handleConfirmationResponse = mock(() => {});
-  const _mockSession = {
-    handleConfirmationResponse,
-    ensureActorScopedHistory: async () => {},
-  } as unknown as Conversation;
-  _conversationMocks.set(conversationId, _mockSession);
-  pendingInteractions.register(requestId, {
-    conversationId,
-    kind: "confirmation",
-    confirmationDetails: {
-      toolName: GUARDIAN_REACTION_TOOL,
-      input: GUARDIAN_REACTION_INPUT,
-      riskLevel: "high",
-      allowlistOptions: [
-        { label: "test", description: "test", pattern: "test" },
-      ],
-      scopeOptions: [{ label: "everywhere", scope: "everywhere" }],
-    },
-  });
-}
-
-describe("guardian approval-by-reaction integration via handleChannelInbound", () => {
-  beforeEach(() => {
-    const db = getDb();
-    db.run("DELETE FROM messages");
-    db.run("DELETE FROM channel_inbound_events");
-    db.run("DELETE FROM conversations");
-    db.run("DELETE FROM contact_channels");
-    db.run("DELETE FROM contacts");
-    bridgeState.reset();
-    gatewayGuardians = [];
-    pendingInteractions.clear();
-    msgCounter = 0;
-  });
-
-  test("guardian reaction on pending approval applies decision and persists no transcript row", async () => {
-    seedGuardianForChannel();
-    const requestId = "req-guardian-react-1";
-    // Back the guardian request and its pending interaction with a real
-    // conversation row, inserted directly via the DB layer.
-    const db = getDb();
-    const conversationId = "conv-react-test-1";
-    const now = Date.now();
-    db.$client
-      .prepare(
-        `INSERT INTO conversations (
-          id, title, created_at, updated_at, total_input_tokens, total_output_tokens,
-          total_estimated_cost, context_compacted_message_count, conversation_type,
-          source, memory_scope_id, host_access, is_auto_title
-        ) VALUES (?, NULL, ?, ?, 0, 0, 0, 0, 'standard', 'user', 'default', 0, 1)`,
-      )
-      .run(conversationId, now, now);
-
-    const reactedTs = "1700000099.000001";
-    // The approval card was delivered on this ts; its canonical delivery row
-    // is how the guardian reaction is scoped to a known approval message.
-    seedPendingGuardianApprovalForReaction(
-      requestId,
-      conversationId,
-      reactedTs,
-    );
-
-    const body = {
-      sourceChannel: "slack",
-      interface: "slack",
-      conversationExternalId: SLACK_CHANNEL_ID,
-      externalMessageId: `${SLACK_CHANNEL_ID}:${reactedTs}:guardian-react`,
-      content: "reaction:white_check_mark",
-      callbackData: "reaction:white_check_mark",
-      actorExternalId: GUARDIAN_USER_ID,
-      actorDisplayName: GUARDIAN_DISPLAY_NAME,
-      replyCallbackUrl: "http://localhost:7830/deliver/slack",
-      sourceMetadata: {
-        messageId: reactedTs,
-        chatType: "channel",
-      },
-    };
-    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(body),
-    });
-
-    // Wire a non-undefined `approvalConversationGenerator` to mirror the
-    // production configuration. The deterministic reaction handler must
-    // short-circuit before the generator is consulted — if it runs, it
-    // returns `keep_pending` so the assertions below would fail loudly.
-    const approvalConversationGenerator = mock(async () => ({
-      disposition: "keep_pending" as const,
-      replyText: "mock conversational turn should not be invoked for reactions",
-    }));
-
-    const resp = await handleChannelInbound(
-      req,
-      undefined,
-      TEST_BEARER_TOKEN,
-      undefined,
-      approvalConversationGenerator,
-    );
-    const json = (await resp.json()) as Record<string, unknown>;
-
-    expect(resp.status).toBe(200);
-    expect(json.accepted).toBe(true);
-    expect(json.canonicalRouter).toBe("canonical_decision_applied");
-    expect(approvalConversationGenerator).not.toHaveBeenCalled();
-
-    // The guardian request is resolved (no longer pending).
-    expect(bridgeState.getRequest(requestId)?.status).toBe("approved");
-
-    // No transcript row was written for the reaction itself — resolved
-    // guardian approval reactions have no transcript representation.
-    const reactionRows = readPersistedMessages().filter((row) => {
-      if (!row.metadata) {
-        return false;
-      }
-      try {
-        const env = JSON.parse(row.metadata) as Record<string, unknown>;
-        if (typeof env.slackMeta !== "string") {
-          return false;
-        }
-        const meta = readSlackMetadata(env.slackMeta);
-        return meta?.eventKind === "reaction";
-      } catch {
-        return false;
-      }
-    });
-    expect(reactionRows.length).toBe(0);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Reaction access-control regression (LUM-2489)
 // ---------------------------------------------------------------------------
@@ -830,6 +634,7 @@ describe("guardian approval-by-reaction integration via handleChannelInbound", (
 describe("reaction access control (no verification handshake)", () => {
   const STRANGER_USER_ID = "U_REACTION_STRANGER";
   const CONTACT_USER_ID = "U_REACTION_CONTACT";
+  const GUARDIAN_USER_ID = "U_GUARDIAN_REACT";
   // Guardian's approval channel is a DM, distinct from the public channel the
   // reaction lands in (mirroring production). Reusing the public channel id
   // would let a reactor match the guardian's channel via findContactChannel's

package/src/__tests__/skill-load-tool.test.ts

@@ -127,6 +127,14 @@ describe("skill_load tool", () => {
     );
   });
 
+  test("description routes Claude Code and Codex mentions to acp", () => {
+    // skill_load is always in the tool list. Naming the agents here is what
+    // makes a mention load ACP instead of treating Claude Code as a competitor.
+    expect(skillLoadTool.description).toContain("Claude Code");
+    expect(skillLoadTool.description).toContain("Codex");
+    expect(skillLoadTool.description).toContain('skill: "acp"');
+  });
+
   test("routes recurring monitoring and reminders to the schedule skill", () => {
     const description = skillLoadTool.description;
     expect(description).toContain('skill: "schedule"');
@@ -399,6 +407,19 @@ describe("skill_load tool", () => {
     expect(result.content).toContain('<loaded_skill id="app-builder"');
   });
 
+  test("bundled acp skill offers a one-time connect when the user names an agent", async () => {
+    const result = await executeSkillLoad({ skill: "acp" });
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Skill: ACP");
+    expect(result.content).toContain(
+      "When the user names Claude Code or Codex",
+    );
+    expect(result.content).toContain("offer once, in one short sentence");
+    expect(result.content).toContain("Do not spawn unless they accept");
+    expect(result.content).toContain('<loaded_skill id="acp"');
+  });
+
   test("bundled phone-calls loads when setup includes are unavailable", async () => {
     const result = await executeSkillLoad({ skill: "phone-calls" });
 

package/src/__tests__/skills.test.ts

@@ -898,12 +898,20 @@ describe("always-candidate frontmatter parsing", () => {
     // 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.
+    // "names" keeps a mention ("claude code will do it") from falling through
+    // as a competitor reference.
     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"]) {
+    for (const term of [
+      "names",
+      "set up",
+      "install",
+      "authenticate",
+      "connect",
+    ]) {
       expect(card).toContain(term);
     }
   });

package/src/approvals/AGENTS.md

@@ -7,7 +7,7 @@ The end-to-end lifecycle of interactive guardian requests (approvals, questions)
 - **Rich delivery failures must degrade gracefully.** If delivering a rich approval prompt (e.g., Telegram inline buttons) fails, fall back to plain text with instructions (e.g., `Reply "yes" to approve`) — never auto-deny.
 - **Non-rich channels** (http-api) receive plain-text approval prompts. The conversational approval engine handles free-text responses.
 - **Race conditions:** Always check whether a decision has already been resolved before delivering the engine's optimistic reply. If `handleChannelDecision` returns `applied: false`, deliver an "already resolved" notice and return `stale_ignored`.
-- **Unified guardian decision primitive:** All guardian decision paths (callback buttons, conversational engine, channel reactions and text) must route through `applyGuardianDecision()` in `assistant/src/approvals/guardian-decision-primitive.ts`. Do not inline decision logic (CAS resolution, resolver dispatch, grant minting) at individual callsites.
+- **Unified guardian decision primitive:** All guardian decision paths (callback buttons, conversational engine, channel text) must route through `applyGuardianDecision()` in `assistant/src/approvals/guardian-decision-primitive.ts`. Do not inline decision logic (CAS resolution, resolver dispatch, grant minting) at individual callsites.
 
 ## Single-Guardian Invariant
 

package/src/channels/__tests__/gateway-guardian-requests.test.ts

@@ -327,21 +327,6 @@ describe("request lookups", () => {
     });
   });
 
-  test("getPendingRequestByDestinationMessageOrNull maps the destination triple", async () => {
-    ipcResponse = null;
-    expect(
-      await client.getPendingRequestByDestinationMessageOrNull(
-        "telegram",
-        "chat-456",
-        "msg-1",
-      ),
-    ).toBeNull();
-    expect(ipcCalls[0]).toEqual({
-      method: "guardian_requests_get_by_destination_message",
-      params: { channel: "telegram", chatId: "chat-456", messageId: "msg-1" },
-    });
-  });
-
   test("getPendingRequestByCallSession and getRequestByPendingQuestionOrNull map params", async () => {
     const request = makeWireRequest({ callSessionId: "call-1" });
     ipcResponse = request;
@@ -378,18 +363,11 @@ describe("request lookups", () => {
 
     ipcError = new Error("gateway unavailable");
     expect(await client.getGuardianRequestByCodeOrNull("AB12")).toBeNull();
-    expect(
-      await client.getPendingRequestByDestinationMessageOrNull(
-        "telegram",
-        "chat-456",
-        "msg-1",
-      ),
-    ).toBeNull();
     expect(
       await client.getPendingRequestByCallSessionOrNull("call-1"),
     ).toBeNull();
     expect(await client.getRequestByPendingQuestionOrNull("pq-1")).toBeNull();
-    expect(warnCalls).toHaveLength(5);
+    expect(warnCalls).toHaveLength(4);
   });
 
   test("OrNull variants pass successful reads through untouched", async () => {

package/src/channels/gateway-guardian-requests.ts

@@ -301,28 +301,6 @@ export async function listGuardianRequestDeliveriesByChat(
   );
 }
 
-/**
- * Reaction routing: the pending request whose delivered card is the
- * reacted-to message. Throws on transport failure.
- */
-async function getPendingRequestByDestinationMessage(
-  channel: string,
-  chatId: string,
-  messageId: string,
-): Promise<GuardianRequestWire | null> {
-  return callGateway(
-    GUARDIAN_REQUESTS_IPC_METHODS.getByDestinationMessage,
-    { channel, chatId, messageId },
-    GuardianRequestLookupIpcResponseSchema,
-  );
-}
-
-/** `getPendingRequestByDestinationMessage` deny-path variant: degrades to null. */
-export const getPendingRequestByDestinationMessageOrNull = degradeOnFailure(
-  getPendingRequestByDestinationMessage,
-  null,
-);
-
 /**
  * Reply routing: pending requests delivered to a destination conversation
  * (`conversationId`, optionally narrowed by `channel`) or chat