@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/notifications/conversation-pairing.ts

@@ -23,11 +23,13 @@
 import type { ConversationStrategy } from "../channels/config.js";
 import { getConversationStrategy } from "../channels/config.js";
 import type { ChannelId } from "../channels/types.js";
+import { isAssistantInitiatedThreadsEnabled } from "../config/assistant-initiated-threads-gate.js";
 import {
   addMessage,
   createConversation,
   getConversation,
 } from "../persistence/conversation-crud.js";
+import { ASSISTANT_INITIATED_SOURCE } from "../persistence/conversation-types.js";
 import {
   getBindingByChannelChat,
   upsertOutboundBinding,
@@ -106,13 +108,77 @@ export interface PairingOptions {
  * Errors are caught and logged — this function never throws so the
  * notification pipeline is not disrupted by pairing failures.
  */
-export async function pairDeliveryWithConversation(
+/**
+ * The event the assistant emits when it has a thought worth the user's time
+ * ("assistant.share" - the notifications skill's default), as opposed to a
+ * transactional request or a system alert.
+ */
+const ASSISTANT_SHARE_EVENT = "assistant.share";
+
+/**
+ * Promote a background share into an assistant-initiated thread, under the
+ * `assistant-initiated-threads` flag.
+ *
+ * The heartbeat's "have a thought, share it" path emits an assistant.share
+ * signal from its own background conversation, and the passive-vellum rule
+ * below would append the body there - a row the sidebar never shows. When the
+ * section exists, that share is exactly what it is for, so the signal is
+ * rewritten to materialize a fresh standard conversation stamped
+ * {@link ASSISTANT_INITIATED_SOURCE}, which is the section's membership mark.
+ *
+ * Deliberately narrow, in every direction it can be:
+ * - vellum channel only: other channels deliver the share as a native
+ *   message and need no in-app thread;
+ * - assistant.share only: transactional events keep their own pairing
+ *   rules, and their threads stay out of the section by source;
+ * - only when the producing conversation is a background/scheduled run (or
+ *   nothing resolvable): a share emitted from inside a user-facing thread
+ *   keeps the append, since the user is already looking at that thread;
+ * - never over an explicit `conversationMetadata.source` or an existing
+ *   `requiresConversation`: a producer that declared its own filing wins.
+ *
+ * Flag off, the signal passes through untouched and shares keep the passive
+ * append: nothing changes for anyone outside the rollout.
+ */
+function withAssistantInitiatedThread(
   signal: NotificationSignal,
   channel: NotificationChannel,
+): NotificationSignal {
+  if (
+    channel !== "vellum" ||
+    signal.sourceEventName !== ASSISTANT_SHARE_EVENT ||
+    signal.requiresConversation === true ||
+    signal.conversationMetadata?.source !== undefined ||
+    !isAssistantInitiatedThreadsEnabled()
+  ) {
+    return signal;
+  }
+  const producing = getConversation(signal.sourceContextId);
+  if (
+    producing &&
+    producing.conversationType !== "background" &&
+    producing.conversationType !== "scheduled"
+  ) {
+    return signal;
+  }
+  return {
+    ...signal,
+    requiresConversation: true,
+    conversationMetadata: {
+      ...signal.conversationMetadata,
+      source: ASSISTANT_INITIATED_SOURCE,
+    },
+  };
+}
+
+export async function pairDeliveryWithConversation(
+  rawSignal: NotificationSignal,
+  channel: NotificationChannel,
   copy: RenderedChannelCopy,
   options?: PairingOptions,
 ): Promise<PairingResult> {
   try {
+    const signal = withAssistantInitiatedThread(rawSignal, channel);
     const strategy = getConversationStrategy(channel as ChannelId);
 
     if (strategy === "not_deliverable" || strategy === "push_only") {
@@ -490,7 +556,7 @@ export async function pairDeliveryWithConversation(
     };
   } catch (err) {
     log.error(
-      { err, signalId: signal.signalId, channel },
+      { err, signalId: rawSignal.signalId, channel },
       "Failed to pair notification delivery with conversation — continuing without pairing",
     );
     const fallbackStrategy = (() => {

package/src/notifications/copy-composer.ts

@@ -13,7 +13,7 @@ import { normalizeTitle } from "../util/short-title.js";
 import { truncate } from "../util/truncate.js";
 import {
   accessRequestCardTitle,
-  buildAccessRequestContractText,
+  buildAccessRequestContextText,
   isAdmittedIntroduction,
 } from "./access-request-copy.js";
 import {
@@ -21,10 +21,8 @@ import {
   buildToolApprovalSeedContentBlocks,
 } from "./approval-card-data.js";
 import {
-  buildGuardianRequestCodeInstruction,
+  applyGuardianReplyMechanics,
   parseGuardianQuestionPayload,
-  resolveGuardianInstructionModeFromPayload,
-  resolveGuardianQuestionInstructionMode,
 } from "./guardian-question-mode.js";
 import {
   nonEmpty,
@@ -231,34 +229,12 @@ const TEMPLATES: Partial<Record<NotificationSourceEventName, CopyTemplate>> = {
         ? buildToolApprovalSeedContentBlocks(parsed)
         : buildToolApprovalSeedContentBlocks(payload)) ?? undefined;
 
-    const requestCode = parsed
-      ? nonEmpty(parsed.requestCode)
-      : nonEmpty(
-          typeof payload.requestCode === "string"
-            ? payload.requestCode
-            : undefined,
-        );
-
-    if (!requestCode) {
-      return {
-        title: "Guardian Question",
-        body: question,
-        conversationSeedMessage,
-        seedContentBlocks,
-      };
-    }
-
-    const normalizedCode = requestCode.toUpperCase();
-    const modeResolution = parsed
-      ? resolveGuardianInstructionModeFromPayload(parsed)
-      : resolveGuardianQuestionInstructionMode(payload);
-    const instruction = buildGuardianRequestCodeInstruction(
-      normalizedCode,
-      modeResolution.mode,
-    );
+    // The request-code reply instruction is not part of the template: whether
+    // a channel's copy carries it is decided per channel by
+    // `applyGuardianReplyMechanics` when the copy is composed.
     return {
       title: "Guardian Question",
-      body: `${question}\n\n${instruction}`,
+      body: question,
       conversationSeedMessage,
       seedContentBlocks,
     };
@@ -275,7 +251,7 @@ const TEMPLATES: Partial<Record<NotificationSourceEventName, CopyTemplate>> = {
 
   "ingress.access_request": (payload) => ({
     title: accessRequestCardTitle(isAdmittedIntroduction(payload)),
-    body: buildAccessRequestContractText(payload),
+    body: buildAccessRequestContextText(payload),
     seedContentBlocks: buildAccessRequestSeedContentBlocks(payload),
   }),
 
@@ -438,7 +414,12 @@ export function composeFallbackCopy(
 
   const result: Partial<Record<NotificationChannel, RenderedChannelCopy>> = {};
   for (const ch of channels) {
-    result[ch] = applyChannelDefaults(ch, baseCopy);
+    // Mechanics first, so a chat channel's derived deliveryText inherits the
+    // instruction the rule adds to the body.
+    result[ch] = applyChannelDefaults(
+      ch,
+      applyGuardianReplyMechanics(baseCopy, ch, signal),
+    );
   }
   return result;
 }

package/src/notifications/decision-engine.ts

@@ -28,12 +28,8 @@ import type { Provider } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
 import { truncate } from "../util/truncate.js";
 import {
-  buildAccessRequestContractText,
-  buildAccessRequestInviteDirective,
-  hasAccessRequestInstructions,
-  hasInviteFlowDirective,
-  isHandshakeOfferedForPayload,
-  parseAccessRequestPayload,
+  ensureAccessRequestInviteDirectiveInCopy,
+  stripAccessRequestReplyMechanicsFromCopy,
 } from "./access-request-copy.js";
 import {
   buildAccessRequestSeedContentBlocks,
@@ -47,15 +43,10 @@ import {
 import { composeFallbackCopy, resolveTitle } from "./copy-composer.js";
 import { createDecision } from "./decisions-store.js";
 import {
-  buildGuardianRequestCodeInstruction,
+  applyGuardianReplyMechanics,
   buildQuestionDeliveryText,
-  hasGuardianRequestCodeInstruction,
   parseGuardianQuestionPayload,
-  parseInteractiveApprovalPayload,
   resolveGuardianInstructionModeFromPayload,
-  resolveGuardianQuestionInstructionMode,
-  stripConflictingGuardianRequestInstructions,
-  stripGuardianRequestCodeInstructions,
 } from "./guardian-question-mode.js";
 import {
   nonEmpty,
@@ -165,6 +156,7 @@ function buildSystemPrompt(
     `  - Avoid intermediary-instruction phrasing like "consider telling the guardian", "ask the recipient to", or "the assistant should remind them". Rewrite it as final copy the recipient can act on directly.`,
     `  - For telegram: 1-2 concise sentences.`,
     `  - For slack approval requests: the message renders inside an interactive card with Approve/Reject buttons. Describe only what needs approval — never include approval/reference codes, code-reply instructions, or directions to respond in another app.`,
+    `  - For vellum and platform guardian requests: the copy is read in the notification bell, the banner, and the push, which act through the request card. Never include reference codes, code-reply instructions, or directions to respond elsewhere.`,
     `- \`conversationSeedMessage\` is the opening message in the internal notification conversation and also the expanded detail shown in the home feed. It should be richer and more contextual than the popup body.`,
     `  - For vellum (desktop): use structured markdown for readability. Break content into bullet points, numbered lists, or short sections with **bold** labels. Avoid long unbroken paragraphs — scan-friendly formatting is preferred.`,
     `  - Never dump raw JSON. Include only human-readable context.`,
@@ -600,77 +592,14 @@ export function validateConversationActions(
   return result;
 }
 
-function ensureGuardianRequestCodeInCopy(
-  copy: RenderedChannelCopy,
-  requestCode: string,
-  mode: "approval" | "answer",
-): RenderedChannelCopy {
-  const instruction = buildGuardianRequestCodeInstruction(requestCode, mode);
-
-  const ensureText = (text: string | undefined): string => {
-    const base = typeof text === "string" ? text.trim() : "";
-    const sanitized = stripConflictingGuardianRequestInstructions(
-      base,
-      requestCode,
-      mode,
-    );
-    if (hasGuardianRequestCodeInstruction(sanitized, requestCode, mode)) {
-      return sanitized;
-    }
-    return sanitized.length > 0
-      ? `${sanitized}\n\n${instruction}`
-      : instruction;
-  };
-
-  return {
-    ...copy,
-    body: ensureText(copy.body),
-    deliveryText: copy.deliveryText
-      ? ensureText(copy.deliveryText)
-      : copy.deliveryText,
-    conversationSeedMessage: copy.conversationSeedMessage
-      ? ensureText(copy.conversationSeedMessage)
-      : copy.conversationSeedMessage,
-  };
-}
-
-/**
- * Remove request-code reply instructions from copy for a channel whose
- * approval UI makes them redundant. Instruction-only fields keep their
- * original text rather than becoming empty — downstream treats an empty
- * body as missing copy.
- */
-function stripGuardianRequestCodeInCopy(
-  copy: RenderedChannelCopy,
-  requestCode: string,
-): RenderedChannelCopy {
-  const strip = (text: string): string => {
-    const stripped = stripGuardianRequestCodeInstructions(text, requestCode);
-    return stripped.length > 0 ? stripped : text;
-  };
-
-  return {
-    ...copy,
-    body: strip(copy.body),
-    deliveryText: copy.deliveryText
-      ? strip(copy.deliveryText)
-      : copy.deliveryText,
-    conversationSeedMessage: copy.conversationSeedMessage
-      ? strip(copy.conversationSeedMessage)
-      : copy.conversationSeedMessage,
-  };
-}
-
 /**
  * Guardian questions that share a conversation require explicit request-code
- * targeting. Enforce request-code instructions in rendered copy so guardians
- * can always disambiguate replies even when model copy omits them.
- *
- * Slack is the exception for approval-mode questions: the Slack adapter
- * renders those as an interactive card with Approve/Reject buttons (see
- * `resolveApprovalContext` in broadcaster.ts, gated on the same
- * `parseInteractiveApprovalPayload`), so code-reply instructions are
- * redundant noise there and are stripped instead of enforced in.
+ * targeting, so the reply-mechanics rule runs on every decision path: a
+ * channel the guardian answers by typing gets the instruction enforced into
+ * its copy even when the model left it out, and a channel that acts through
+ * a card (the vellum bell and banner, the platform push, Slack approval
+ * cards) gets it stripped, model-authored code phrasing included. The
+ * per-channel rule is `guardianCopyCarriesReplyMechanics`.
  */
 function enforceGuardianRequestCode(
   decision: NotificationDecision,
@@ -679,17 +608,6 @@ function enforceGuardianRequestCode(
   if (signal.sourceEventName !== "guardian.question") {
     return decision;
   }
-  const rawCode = signal.contextPayload.requestCode;
-  if (typeof rawCode !== "string" || rawCode.trim().length === 0) {
-    return decision;
-  }
-
-  const requestCode = rawCode.trim().toUpperCase();
-  const modeResolution = resolveGuardianQuestionInstructionMode(
-    signal.contextPayload,
-  );
-  const slackRendersApprovalButtons =
-    parseInteractiveApprovalPayload(signal.contextPayload) != null;
   const nextCopy: Partial<Record<NotificationChannel, RenderedChannelCopy>> = {
     ...decision.renderedCopy,
   };
@@ -699,14 +617,7 @@ function enforceGuardianRequestCode(
     if (!copy) {
       continue;
     }
-    nextCopy[channel] =
-      channel === "slack" && slackRendersApprovalButtons
-        ? stripGuardianRequestCodeInCopy(copy, requestCode)
-        : ensureGuardianRequestCodeInCopy(
-            copy,
-            requestCode,
-            modeResolution.mode,
-          );
+    nextCopy[channel] = applyGuardianReplyMechanics(copy, channel, signal);
   }
 
   return {
@@ -759,6 +670,10 @@ function ensureSeedContentBlocks(
  *
  * Scoped to answer mode. A `pending_question` carrying a tool name is a voice
  * tool approval, where composed copy is the right thing.
+ *
+ * The pinned text carries the reference-code instruction; the
+ * reply-mechanics pass runs after this one and keeps or strips it per
+ * channel, so this pin never has to know which surfaces take a typed reply.
  */
 function pinQuestionDeliveryCopy(
   decision: NotificationDecision,
@@ -814,131 +729,38 @@ function enforceToolApprovalSeedBlocks(
 }
 
 /**
- * Access-request notifications require deterministic instruction elements:
- * - Request-code approve/reject directive (when requestCode is present)
- * - Exact "open invite flow" phrase (always required)
- *
- * When requestCode IS present: use the full hasAccessRequestInstructions
- * check (approve+reject+invite) and append the complete contract text if
- * any element is missing.
- *
- * When requestCode is NOT present: still check for the invite-flow
- * directive and append it if missing. Per the documented contract, the
- * invite directive should always be present in access-request copy.
+ * Access-request copy never carries the request-code directive: that is the
+ * card's `plainTextFallback`, appended by a transport only when it sends
+ * text without buttons. A model's echo of it comes out on every channel.
+ * The invite-flow directive is the opposite case, context rather than
+ * mechanics (no surface has an invite button, so the sentence is the only
+ * way to start the flow), and model-composed copy that leaves it out gets
+ * it appended. The Surface card is ensured on every decision path, the
+ * same way tool approvals are.
  */
-function enforceAccessRequestInstructions(
+function enforceAccessRequestCopy(
   decision: NotificationDecision,
   signal: NotificationSignal,
 ): NotificationDecision {
   if (signal.sourceEventName !== "ingress.access_request") {
     return decision;
   }
-
-  const rawCode = signal.contextPayload.requestCode;
-  const hasRequestCode =
-    typeof rawCode === "string" && rawCode.trim().length > 0;
-
   const nextCopy: Partial<Record<NotificationChannel, RenderedChannelCopy>> = {
     ...decision.renderedCopy,
   };
-
-  if (hasRequestCode) {
-    const requestCode = rawCode.trim().toUpperCase();
-    const contractText = buildAccessRequestContractText(signal.contextPayload);
-    const handshakeOffered = isHandshakeOfferedForPayload(
-      parseAccessRequestPayload(signal.contextPayload),
-    );
-
-    for (const channel of Object.keys(nextCopy) as NotificationChannel[]) {
-      const copy = nextCopy[channel];
-      if (!copy) {
-        continue;
-      }
-      nextCopy[channel] = ensureAccessRequestInstructionsInCopy(
-        copy,
-        requestCode,
-        contractText,
-        handshakeOffered,
-      );
-    }
-  } else {
-    // No requestCode — still enforce the invite-flow directive.
-    const inviteDirective = buildAccessRequestInviteDirective();
-
-    for (const channel of Object.keys(nextCopy) as NotificationChannel[]) {
-      const copy = nextCopy[channel];
-      if (!copy) {
-        continue;
-      }
-      nextCopy[channel] = ensureInviteFlowDirectiveInCopy(
-        copy,
-        inviteDirective,
-      );
+  for (const channel of Object.keys(nextCopy) as NotificationChannel[]) {
+    const copy = nextCopy[channel];
+    if (!copy) {
+      continue;
     }
+    nextCopy[channel] = ensureAccessRequestInviteDirectiveInCopy(
+      stripAccessRequestReplyMechanicsFromCopy(copy, signal.contextPayload),
+    );
   }
-
-  let result: NotificationDecision = {
-    ...decision,
-    renderedCopy: nextCopy,
-  };
-
-  // Ensure seedContentBlocks on all paths (LLM, assistant_tool, fallback).
-  result = ensureSeedContentBlocks(
-    result,
+  return ensureSeedContentBlocks(
+    { ...decision, renderedCopy: nextCopy },
     buildAccessRequestSeedContentBlocks(signal.contextPayload),
   );
-
-  return result;
-}
-
-function ensureAccessRequestInstructionsInCopy(
-  copy: RenderedChannelCopy,
-  requestCode: string,
-  contractText: string,
-  handshakeOffered: boolean,
-): RenderedChannelCopy {
-  const ensureText = (text: string | undefined): string => {
-    const base = typeof text === "string" ? text.trim() : "";
-    if (hasAccessRequestInstructions(base, requestCode, { handshakeOffered })) {
-      return base;
-    }
-    return base.length > 0 ? `${base}\n\n${contractText}` : contractText;
-  };
-
-  return {
-    ...copy,
-    body: ensureText(copy.body),
-    deliveryText: copy.deliveryText
-      ? ensureText(copy.deliveryText)
-      : copy.deliveryText,
-    conversationSeedMessage: copy.conversationSeedMessage
-      ? ensureText(copy.conversationSeedMessage)
-      : copy.conversationSeedMessage,
-  };
-}
-
-function ensureInviteFlowDirectiveInCopy(
-  copy: RenderedChannelCopy,
-  inviteDirective: string,
-): RenderedChannelCopy {
-  const ensureText = (text: string | undefined): string => {
-    const base = typeof text === "string" ? text.trim() : "";
-    if (hasInviteFlowDirective(base)) {
-      return base;
-    }
-    return base.length > 0 ? `${base}\n\n${inviteDirective}` : inviteDirective;
-  };
-
-  return {
-    ...copy,
-    body: ensureText(copy.body),
-    deliveryText: copy.deliveryText
-      ? ensureText(copy.deliveryText)
-      : copy.deliveryText,
-    conversationSeedMessage: copy.conversationSeedMessage
-      ? ensureText(copy.conversationSeedMessage)
-      : copy.conversationSeedMessage,
-  };
 }
 
 // ── Producer pass-through decisions ────────────────────────────────────
@@ -993,17 +815,28 @@ function buildPassThroughDecision(params: {
     verbatimCopy: true,
     ...(deepLinkTarget ? { deepLinkTarget } : {}),
   };
+  decision = applyDecisionGuards(decision, signal);
+  decision.persistedDecisionId = persistDecision(signal, decision);
+  return decision;
+}
+
+/**
+ * The deterministic guards every decision passes through once the model,
+ * the assistant-tool pass-through, or the fallback has rendered copy. In
+ * dependency order: the question pin writes the copy the reply-mechanics
+ * pass then settles per channel, and the seed-block guard is independent
+ * of both.
+ */
+function applyDecisionGuards(
+  decision: NotificationDecision,
+  signal: NotificationSignal,
+): NotificationDecision {
+  decision = pinQuestionDeliveryCopy(decision, signal);
   decision = enforceGuardianRequestCode(decision, signal);
   decision = enforceToolApprovalSeedBlocks(decision, signal);
-  decision = pinQuestionDeliveryCopy(decision, signal);
-  decision = enforceAccessRequestInstructions(decision, signal);
+  decision = enforceAccessRequestCopy(decision, signal);
   decision = enforceGuardianRequestConversationAffinity(decision, signal);
-  decision = enforceConversationAffinity(
-    decision,
-    signal.conversationAffinityHint,
-  );
-  decision.persistedDecisionId = persistDecision(signal, decision);
-  return decision;
+  return enforceConversationAffinity(decision, signal.conversationAffinityHint);
 }
 
 // ── Core evaluation function ───────────────────────────────────────────
@@ -1118,15 +951,9 @@ export async function evaluateSignal(
     log.warn(
       "Configured provider unavailable for notification decision, using fallback",
     );
-    let decision = buildFallbackDecision(signal, availableChannels);
-    decision = enforceGuardianRequestCode(decision, signal);
-    decision = enforceToolApprovalSeedBlocks(decision, signal);
-    decision = pinQuestionDeliveryCopy(decision, signal);
-    decision = enforceAccessRequestInstructions(decision, signal);
-    decision = enforceGuardianRequestConversationAffinity(decision, signal);
-    decision = enforceConversationAffinity(
-      decision,
-      signal.conversationAffinityHint,
+    const decision = applyDecisionGuards(
+      buildFallbackDecision(signal, availableChannels),
+      signal,
     );
     decision.persistedDecisionId = persistDecision(signal, decision);
     return decision;
@@ -1150,15 +977,7 @@ export async function evaluateSignal(
     decision = buildFallbackDecision(signal, availableChannels);
   }
 
-  decision = enforceGuardianRequestCode(decision, signal);
-  decision = enforceToolApprovalSeedBlocks(decision, signal);
-  decision = pinQuestionDeliveryCopy(decision, signal);
-  decision = enforceAccessRequestInstructions(decision, signal);
-  decision = enforceGuardianRequestConversationAffinity(decision, signal);
-  decision = enforceConversationAffinity(
-    decision,
-    signal.conversationAffinityHint,
-  );
+  decision = applyDecisionGuards(decision, signal);
   decision.persistedDecisionId = persistDecision(signal, decision);
 
   return decision;

package/src/notifications/guardian-delivery-recorder.ts

@@ -8,12 +8,8 @@
  * reached. Capturing the surface address here — the conversation id for the
  * in-app vellum card, or the channel-native message id (e.g. Slack `ts`) for a
  * channel card — is what lets a delivered card be addressed back to its request
- * later:
- *
- *   - to withdraw it in place when the request resolves
- *     (`approvals/guardian-card-withdrawal.ts`), and
- *   - to resolve an emoji reaction on the card to the right request when several
- *     are pending in the same chat (the by-destination-message lookup).
+ * later, to withdraw it in place when the request resolves
+ * (`approvals/guardian-card-withdrawal.ts`).
  *
  * Every producer records through here so the addressing convention lives in one
  * place and cannot drift between the path that writes the row and the paths that
@@ -48,7 +44,7 @@ export interface ApprovalCardDeliveryAddress {
   conversationId?: string;
   /** Channel addressing: the chat the card was delivered to. */
   chatId?: string;
-  /** Channel-native message id (e.g. Slack `ts`) — the reaction/withdrawal key. */
+  /** Channel-native message id (e.g. Slack `ts`): the withdrawal key. */
   messageId?: string;
   /** Initial delivery status (defaults to `DELIVERY_STATUS.pending`). */
   status?: string;
@@ -78,7 +74,7 @@ export async function recordApprovalCardDelivery(
   } catch (err) {
     log.error(
       { err, requestId: address.requestId, channel: address.channel },
-      "Failed to record approval card delivery; reaction/withdrawal on this card will not resolve",
+      "Failed to record approval card delivery; withdrawal of this card will not resolve",
     );
     return null;
   }
@@ -100,7 +96,7 @@ export async function recordApprovalCardDelivery(
  * `conversationId`. Platform push results are skipped entirely: a push
  * has no channel-native card surface to address back to.
  * Channel results additionally carry the chat (`destination`) and channel-native
- * id (`messageId`) used to match inbound replies/reactions; a blank `destination`
+ * id (`messageId`) used to match inbound replies; a blank `destination`
  * is recorded as unknown rather than persisting the literal channel name as a
  * chat id. Status has two readers: the voice guardian-action sweep acts only
  * on `sent`/`pending` rows, and card withdrawal skips rows already marked

package/src/notifications/guardian-feed-projection.ts

@@ -13,13 +13,11 @@
  * daemon updates it wherever `withdrawGuardianRequestCards` settles the
  * other surfaces.
  */
-import { z } from "zod";
 
 import {
   type FeedItem,
   type FeedItemGuardianIntent,
   type FeedItemGuardianRequest,
-  FeedItemGuardianStatusSchema,
   isPendingGuardianFeedItem,
 } from "../api/responses/home.js";
 import {
@@ -47,19 +45,6 @@ import { readPayloadString } from "./notification-utils.js";
 
 const log = getLogger("guardian-feed-projection");
 
-// The wire enum in `api/responses/home.ts` cannot import the gateway
-// contract (the api directory is copied verbatim into client packages),
-// so it mirrors `GuardianRequestStatusSchema` by value. This assignment
-// fails to compile if the enums ever diverge in either direction.
-type FeedStatus = z.infer<typeof FeedItemGuardianStatusSchema>;
-type StatusEnumsAligned = [GuardianRequestStatus] extends [FeedStatus]
-  ? [FeedStatus] extends [GuardianRequestStatus]
-    ? true
-    : never
-  : never;
-const _statusEnumsAligned: StatusEnumsAligned = true;
-void _statusEnumsAligned;
-
 /**
  * The signal events that carry a guardian request. `guardian.question`
  * covers tool approvals, tool grants, and questions; access requests