@vellumai/assistant 0.3.18 → 0.3.20

package/src/memory/scoped-approval-grants.ts

@@ -0,0 +1,518 @@
+/**
+ * CRUD and atomic consume for scoped approval grants.
+ *
+ * Grants authorise exactly one tool execution.  Two scope modes exist:
+ *   - `request_id`      — grant is bound to a specific pending request
+ *   - `tool_signature`  — grant is bound to a tool name + input digest
+ *
+ * Invariants:
+ *   - At most one successful consume per grant (CAS: active -> consumed).
+ *   - Matching requires all non-null scope fields to match exactly.
+ *   - Expired and revoked grants cannot be consumed.
+ */
+
+import { and, eq, sql } from 'drizzle-orm';
+import { v4 as uuid } from 'uuid';
+
+import { getLogger } from '../util/logger.js';
+import { getDb, rawChanges } from './db.js';
+import { scopedApprovalGrants } from './schema.js';
+
+const log = getLogger('scoped-approval-grants');
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type ScopeMode = 'request_id' | 'tool_signature';
+export type GrantStatus = 'active' | 'consumed' | 'expired' | 'revoked';
+
+export interface ScopedApprovalGrant {
+  id: string;
+  assistantId: string;
+  scopeMode: ScopeMode;
+  requestId: string | null;
+  toolName: string | null;
+  inputDigest: string | null;
+  requestChannel: string;
+  decisionChannel: string;
+  executionChannel: string | null;
+  conversationId: string | null;
+  callSessionId: string | null;
+  requesterExternalUserId: string | null;
+  guardianExternalUserId: string | null;
+  status: GrantStatus;
+  expiresAt: string;
+  consumedAt: string | null;
+  consumedByRequestId: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** Max CAS retry attempts when a concurrent consumer steals the selected candidate. */
+const MAX_CAS_RETRIES = 3;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function rowToGrant(row: typeof scopedApprovalGrants.$inferSelect): ScopedApprovalGrant {
+  return {
+    id: row.id,
+    assistantId: row.assistantId,
+    scopeMode: row.scopeMode as ScopeMode,
+    requestId: row.requestId,
+    toolName: row.toolName,
+    inputDigest: row.inputDigest,
+    requestChannel: row.requestChannel,
+    decisionChannel: row.decisionChannel,
+    executionChannel: row.executionChannel,
+    conversationId: row.conversationId,
+    callSessionId: row.callSessionId,
+    requesterExternalUserId: row.requesterExternalUserId,
+    guardianExternalUserId: row.guardianExternalUserId,
+    status: row.status as GrantStatus,
+    expiresAt: row.expiresAt,
+    consumedAt: row.consumedAt,
+    consumedByRequestId: row.consumedByRequestId,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Create
+// ---------------------------------------------------------------------------
+
+export interface CreateScopedApprovalGrantParams {
+  assistantId: string;
+  scopeMode: ScopeMode;
+  requestId?: string | null;
+  toolName?: string | null;
+  inputDigest?: string | null;
+  requestChannel: string;
+  decisionChannel: string;
+  executionChannel?: string | null;
+  conversationId?: string | null;
+  callSessionId?: string | null;
+  requesterExternalUserId?: string | null;
+  guardianExternalUserId?: string | null;
+  expiresAt: string;
+}
+
+function createScopedApprovalGrant(params: CreateScopedApprovalGrantParams): ScopedApprovalGrant {
+  const db = getDb();
+  const now = new Date().toISOString();
+  const id = uuid();
+
+  const row = {
+    id,
+    assistantId: params.assistantId,
+    scopeMode: params.scopeMode,
+    requestId: params.requestId ?? null,
+    toolName: params.toolName ?? null,
+    inputDigest: params.inputDigest ?? null,
+    requestChannel: params.requestChannel,
+    decisionChannel: params.decisionChannel,
+    executionChannel: params.executionChannel ?? null,
+    conversationId: params.conversationId ?? null,
+    callSessionId: params.callSessionId ?? null,
+    requesterExternalUserId: params.requesterExternalUserId ?? null,
+    guardianExternalUserId: params.guardianExternalUserId ?? null,
+    status: 'active' as const,
+    expiresAt: params.expiresAt,
+    consumedAt: null,
+    consumedByRequestId: null,
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  db.insert(scopedApprovalGrants).values(row).run();
+
+  log.info(
+    {
+      event: 'scoped_grant_created',
+      grantId: id,
+      scopeMode: params.scopeMode,
+      toolName: params.toolName ?? null,
+      assistantId: params.assistantId,
+      requestChannel: params.requestChannel,
+      decisionChannel: params.decisionChannel,
+      executionChannel: params.executionChannel ?? null,
+      expiresAt: params.expiresAt,
+    },
+    'Scoped approval grant created',
+  );
+
+  return rowToGrant(row);
+}
+
+// ---------------------------------------------------------------------------
+// Consume by request ID (CAS: active -> consumed)
+// ---------------------------------------------------------------------------
+
+export interface ConsumeByRequestIdResult {
+  ok: boolean;
+  grant: ScopedApprovalGrant | null;
+}
+
+/**
+ * Atomically consume a grant by request ID.
+ *
+ * Only succeeds when exactly one active, non-expired grant matches the
+ * given `requestId` and `assistantId`.  Uses compare-and-swap on the
+ * `status` column so concurrent consumers race safely — at most one wins.
+ */
+function consumeScopedApprovalGrantByRequestId(
+  requestId: string,
+  consumingRequestId: string,
+  assistantId: string,
+  now?: string,
+): ConsumeByRequestIdResult {
+  const db = getDb();
+  const currentTime = now ?? new Date().toISOString();
+
+  // Two-step select-then-update with LIMIT 1 to consume exactly one grant
+  // even if duplicate rows exist (the index on request_id is non-unique).
+  for (let attempt = 0; attempt <= MAX_CAS_RETRIES; attempt++) {
+    const candidate = db
+      .select({ id: scopedApprovalGrants.id })
+      .from(scopedApprovalGrants)
+      .where(
+        and(
+          eq(scopedApprovalGrants.requestId, requestId),
+          eq(scopedApprovalGrants.assistantId, assistantId),
+          eq(scopedApprovalGrants.scopeMode, 'request_id'),
+          eq(scopedApprovalGrants.status, 'active'),
+          sql`${scopedApprovalGrants.expiresAt} > ${currentTime}`,
+        ),
+      )
+      .limit(1)
+      .get();
+
+    if (!candidate) {
+      log.info(
+        { event: 'scoped_grant_consume_miss', requestId, consumingRequestId, assistantId, scopeMode: 'request_id', attempt },
+        'No matching active grant found for request ID',
+      );
+      return { ok: false, grant: null };
+    }
+
+    db.update(scopedApprovalGrants)
+      .set({
+        status: 'consumed',
+        consumedAt: currentTime,
+        consumedByRequestId: consumingRequestId,
+        updatedAt: currentTime,
+      })
+      .where(
+        and(
+          eq(scopedApprovalGrants.id, candidate.id),
+          eq(scopedApprovalGrants.status, 'active'),
+        ),
+      )
+      .run();
+
+    if (rawChanges() === 0) {
+      // CAS failed — another consumer raced and won this candidate; retry with next match
+      continue;
+    }
+
+    // Fetch the consumed grant to return to the caller
+    const row = db
+      .select()
+      .from(scopedApprovalGrants)
+      .where(eq(scopedApprovalGrants.id, candidate.id))
+      .get();
+
+    const grant = row ? rowToGrant(row) : null;
+    log.info(
+      { event: 'scoped_grant_consume_success', grantId: grant?.id, requestId, consumingRequestId, assistantId, scopeMode: 'request_id' },
+      'Scoped approval grant consumed by request ID',
+    );
+
+    return { ok: true, grant };
+  }
+
+  // All retry attempts exhausted — every candidate was stolen by concurrent consumers
+  log.info(
+    { event: 'scoped_grant_consume_miss', requestId, consumingRequestId, assistantId, scopeMode: 'request_id', reason: 'cas_exhausted' },
+    'All CAS retry attempts exhausted for request ID consume',
+  );
+  return { ok: false, grant: null };
+}
+
+// ---------------------------------------------------------------------------
+// Consume by tool signature (CAS: active -> consumed)
+// ---------------------------------------------------------------------------
+
+export interface ConsumeByToolSignatureParams {
+  toolName: string;
+  inputDigest: string;
+  consumingRequestId: string;
+  /** Optional context constraints — only matched when the grant has a non-null value */
+  assistantId?: string;
+  executionChannel?: string;
+  conversationId?: string;
+  callSessionId?: string;
+  requesterExternalUserId?: string;
+  now?: string;
+}
+
+export interface ConsumeByToolSignatureResult {
+  ok: boolean;
+  grant: ScopedApprovalGrant | null;
+}
+
+/**
+ * Atomically consume a grant by tool name + input digest.
+ *
+ * All non-null scope fields on the grant must match the provided context.
+ * This is enforced via SQL conditions that check: either the grant field is
+ * NULL (wildcard), or it equals the provided value.
+ *
+ * If a CAS contention miss occurs (another consumer races and wins the
+ * selected candidate), re-selects and retries up to {@link MAX_CAS_RETRIES}
+ * times before giving up. This prevents false denials when multiple matching
+ * grants exist but a concurrent consumer steals the first pick.
+ */
+function consumeScopedApprovalGrantByToolSignature(
+  params: ConsumeByToolSignatureParams,
+): ConsumeByToolSignatureResult {
+  const db = getDb();
+  const currentTime = params.now ?? new Date().toISOString();
+
+  const conditions = [
+    eq(scopedApprovalGrants.toolName, params.toolName),
+    eq(scopedApprovalGrants.inputDigest, params.inputDigest),
+    eq(scopedApprovalGrants.scopeMode, 'tool_signature'),
+    eq(scopedApprovalGrants.status, 'active'),
+    sql`${scopedApprovalGrants.expiresAt} > ${currentTime}`,
+  ];
+
+  // assistantId is always set on grants — scope consumption to the current
+  // assistant so grants minted for one assistant cannot be consumed by another.
+  if (params.assistantId !== undefined) {
+    conditions.push(eq(scopedApprovalGrants.assistantId, params.assistantId));
+  }
+
+  // Context constraints: grant field must be NULL (any) or match exactly
+  if (params.executionChannel !== undefined) {
+    conditions.push(
+      sql`(${scopedApprovalGrants.executionChannel} IS NULL OR ${scopedApprovalGrants.executionChannel} = ${params.executionChannel})`,
+    );
+  } else {
+    // If caller provides no execution channel, only match grants with NULL (any)
+    conditions.push(sql`${scopedApprovalGrants.executionChannel} IS NULL`);
+  }
+
+  if (params.conversationId !== undefined) {
+    conditions.push(
+      sql`(${scopedApprovalGrants.conversationId} IS NULL OR ${scopedApprovalGrants.conversationId} = ${params.conversationId})`,
+    );
+  } else {
+    conditions.push(sql`${scopedApprovalGrants.conversationId} IS NULL`);
+  }
+
+  if (params.callSessionId !== undefined) {
+    conditions.push(
+      sql`(${scopedApprovalGrants.callSessionId} IS NULL OR ${scopedApprovalGrants.callSessionId} = ${params.callSessionId})`,
+    );
+  } else {
+    conditions.push(sql`${scopedApprovalGrants.callSessionId} IS NULL`);
+  }
+
+  if (params.requesterExternalUserId !== undefined) {
+    conditions.push(
+      sql`(${scopedApprovalGrants.requesterExternalUserId} IS NULL OR ${scopedApprovalGrants.requesterExternalUserId} = ${params.requesterExternalUserId})`,
+    );
+  } else {
+    conditions.push(sql`${scopedApprovalGrants.requesterExternalUserId} IS NULL`);
+  }
+
+  const specificityOrder = sql`(CASE WHEN ${scopedApprovalGrants.executionChannel} IS NOT NULL THEN 1 ELSE 0 END
+         + CASE WHEN ${scopedApprovalGrants.conversationId} IS NOT NULL THEN 1 ELSE 0 END
+         + CASE WHEN ${scopedApprovalGrants.callSessionId} IS NOT NULL THEN 1 ELSE 0 END
+         + CASE WHEN ${scopedApprovalGrants.requesterExternalUserId} IS NOT NULL THEN 1 ELSE 0 END) DESC`;
+
+  // Retry loop: if CAS fails because another consumer stole our candidate,
+  // re-select and try again — another matching active grant may still exist.
+  for (let attempt = 0; attempt <= MAX_CAS_RETRIES; attempt++) {
+    // Select a single matching grant to consume (prefer most specific: fewest NULL scope fields).
+    // This avoids burning multiple grants when a wildcard grant and a specific grant both match.
+    const candidate = db
+      .select({ id: scopedApprovalGrants.id })
+      .from(scopedApprovalGrants)
+      .where(and(...conditions))
+      .orderBy(specificityOrder)
+      .limit(1)
+      .get();
+
+    if (!candidate) {
+      log.info(
+        { event: 'scoped_grant_consume_miss', toolName: params.toolName, scopeMode: 'tool_signature', attempt },
+        'No matching active grant found for tool signature',
+      );
+      return { ok: false, grant: null };
+    }
+
+    db.update(scopedApprovalGrants)
+      .set({
+        status: 'consumed',
+        consumedAt: currentTime,
+        consumedByRequestId: params.consumingRequestId,
+        updatedAt: currentTime,
+      })
+      .where(
+        and(
+          eq(scopedApprovalGrants.id, candidate.id),
+          eq(scopedApprovalGrants.status, 'active'),
+        ),
+      )
+      .run();
+
+    if (rawChanges() === 0) {
+      // CAS failed — another consumer raced and won this candidate; retry with next match
+      continue;
+    }
+
+    // Fetch the consumed grant
+    const row = db
+      .select()
+      .from(scopedApprovalGrants)
+      .where(eq(scopedApprovalGrants.id, candidate.id))
+      .get();
+
+    const grant = row ? rowToGrant(row) : null;
+    log.info(
+      { event: 'scoped_grant_consume_success', grantId: grant?.id, toolName: params.toolName, consumingRequestId: params.consumingRequestId, scopeMode: 'tool_signature' },
+      'Scoped approval grant consumed by tool signature',
+    );
+
+    return { ok: true, grant };
+  }
+
+  // All retry attempts exhausted — every candidate was stolen by concurrent consumers
+  log.info(
+    { event: 'scoped_grant_consume_miss', toolName: params.toolName, scopeMode: 'tool_signature', reason: 'cas_exhausted' },
+    'All CAS retry attempts exhausted for tool signature consume',
+  );
+  return { ok: false, grant: null };
+}
+
+// ---------------------------------------------------------------------------
+// Expire grants past their TTL
+// ---------------------------------------------------------------------------
+
+/**
+ * Bulk-expire all active grants whose `expiresAt` is at or before `now`.
+ * Returns the number of grants expired.
+ */
+export function expireScopedApprovalGrants(now?: string): number {
+  const db = getDb();
+  const currentTime = now ?? new Date().toISOString();
+
+  db.update(scopedApprovalGrants)
+    .set({
+      status: 'expired',
+      updatedAt: currentTime,
+    })
+    .where(
+      and(
+        eq(scopedApprovalGrants.status, 'active'),
+        sql`${scopedApprovalGrants.expiresAt} <= ${currentTime}`,
+      ),
+    )
+    .run();
+
+  const count = rawChanges();
+  if (count > 0) {
+    log.info(
+      { event: 'scoped_grant_expired', count },
+      `Expired ${count} scoped approval grant(s)`,
+    );
+  }
+
+  return count;
+}
+
+// ---------------------------------------------------------------------------
+// Revoke active grants for a context
+// ---------------------------------------------------------------------------
+
+export interface RevokeContextParams {
+  assistantId?: string;
+  conversationId?: string;
+  callSessionId?: string;
+  requestChannel?: string;
+}
+
+/**
+ * Revoke all active grants matching the given context filters.
+ * At least one filter must be provided.  Returns the number of
+ * grants revoked.
+ *
+ * Typical use: revoke all grants for a call session when the call ends.
+ */
+export function revokeScopedApprovalGrantsForContext(params: RevokeContextParams, now?: string): number {
+  const db = getDb();
+  const currentTime = now ?? new Date().toISOString();
+
+  const conditions = [eq(scopedApprovalGrants.status, 'active')];
+
+  if (params.assistantId !== undefined) {
+    conditions.push(eq(scopedApprovalGrants.assistantId, params.assistantId));
+  }
+  if (params.conversationId !== undefined) {
+    conditions.push(eq(scopedApprovalGrants.conversationId, params.conversationId));
+  }
+  if (params.callSessionId !== undefined) {
+    conditions.push(eq(scopedApprovalGrants.callSessionId, params.callSessionId));
+  }
+  if (params.requestChannel !== undefined) {
+    conditions.push(eq(scopedApprovalGrants.requestChannel, params.requestChannel));
+  }
+
+  // Guard: at least one context filter must be provided to avoid revoking ALL active grants
+  if (conditions.length === 1) {
+    throw new Error('revokeScopedApprovalGrantsForContext requires at least one context filter');
+  }
+
+  db.update(scopedApprovalGrants)
+    .set({
+      status: 'revoked',
+      updatedAt: currentTime,
+    })
+    .where(and(...conditions))
+    .run();
+
+  const count = rawChanges();
+  if (count > 0) {
+    log.info(
+      {
+        event: 'scoped_grant_revoked',
+        count,
+        assistantId: params.assistantId,
+        conversationId: params.conversationId,
+        callSessionId: params.callSessionId,
+        requestChannel: params.requestChannel,
+      },
+      `Revoked ${count} scoped approval grant(s) for context`,
+    );
+  }
+
+  return count;
+}
+
+// @internal — exposed for tests and the approval-primitive wrapper only.
+// Do not import these from production code outside this package; use the
+// approval-primitive API instead.
+export const _internal = {
+  createScopedApprovalGrant,
+  consumeScopedApprovalGrantByRequestId,
+  consumeScopedApprovalGrantByToolSignature,
+};

package/src/messaging/providers/slack/client.ts

@@ -8,6 +8,7 @@
 import type {
   SlackApiResponse,
   SlackAuthTestResponse,
+  SlackChatDeleteResponse,
   SlackConversationHistoryResponse,
   SlackConversationLeaveResponse,
   SlackConversationMarkResponse,
@@ -188,6 +189,17 @@ export async function addReaction(
   });
 }
 
+export async function deleteMessage(
+  token: string,
+  channel: string,
+  ts: string,
+): Promise<SlackChatDeleteResponse> {
+  return request<SlackChatDeleteResponse>(token, 'chat.delete', undefined, {
+    channel,
+    ts,
+  });
+}
+
 export async function leaveConversation(
   token: string,
   channel: string,

package/src/messaging/providers/slack/types.ts

@@ -116,4 +116,9 @@ export type SlackReactionAddResponse = SlackApiResponse;
 
 export type SlackConversationLeaveResponse = SlackApiResponse;
 
+export interface SlackChatDeleteResponse extends SlackApiResponse {
+  channel: string;
+  ts: string;
+}
+
 export type SlackConversationMarkResponse = SlackApiResponse;

package/src/notifications/decision-engine.ts

@@ -16,6 +16,7 @@ import { getConfig } from '../config/loader.js';
 import { createTimeout, extractToolUse, getConfiguredProvider, userMessage } from '../providers/provider-send-message.js';
 import type { ModelIntent } from '../providers/types.js';
 import { getLogger } from '../util/logger.js';
+import { composeFallbackCopy } from './copy-composer.js';
 import { createDecision } from './decisions-store.js';
 import { getPreferenceSummary } from './preference-summary.js';
 import type { NotificationSignal, RoutingIntent } from './signal.js';
@@ -251,17 +252,7 @@ function buildFallbackDecision(
     };
   }
 
-  const copy: Partial<Record<NotificationChannel, RenderedChannelCopy>> = {};
-  for (const ch of selectedChannels) {
-    const fallbackBody = isHighUrgencyAction
-      ? `Action required: ${signal.sourceEventName}`
-      : signal.sourceEventName;
-    copy[ch] = {
-      title: signal.sourceEventName,
-      body: fallbackBody,
-      ...(ch === 'telegram' ? { deliveryText: fallbackBody } : {}),
-    };
-  }
+  const copy = composeFallbackCopy(signal, selectedChannels);
 
   return {
     shouldNotify: true,
@@ -452,7 +443,8 @@ export async function evaluateSignal(
   const provider = getConfiguredProvider();
   if (!provider) {
     log.warn('Configured provider unavailable for notification decision, using fallback');
-    const decision = buildFallbackDecision(signal, availableChannels);
+    let decision = buildFallbackDecision(signal, availableChannels);
+    decision = enforceConversationAffinity(decision, signal.conversationAffinityHint);
     decision.persistedDecisionId = persistDecision(signal, decision);
     return decision;
   }
@@ -466,6 +458,7 @@ export async function evaluateSignal(
     decision = buildFallbackDecision(signal, availableChannels);
   }
 
+  decision = enforceConversationAffinity(decision, signal.conversationAffinityHint);
   decision.persistedDecisionId = persistDecision(signal, decision);
 
   return decision;
@@ -600,6 +593,50 @@ export function enforceRoutingIntent(
   return decision;
 }
 
+// ── Conversation affinity enforcement ───────────────────────────────────
+
+/**
+ * Enforce conversation affinity on a decision.
+ *
+ * When the signal carries a conversationAffinityHint (per-channel map of
+ * conversationId), override the decision's threadActions for those channels
+ * to `reuse_existing` with the hinted conversationId. This is a
+ * deterministic post-decision guard that prevents the LLM from routing
+ * guardian questions for the same call session to different conversations.
+ */
+export function enforceConversationAffinity(
+  decision: NotificationDecision,
+  affinityHint: Partial<Record<string, string>> | undefined,
+): NotificationDecision {
+  if (!affinityHint) return decision;
+
+  const entries = Object.entries(affinityHint).filter(
+    ([, conversationId]) => typeof conversationId === 'string' && conversationId.length > 0,
+  );
+  if (entries.length === 0) return decision;
+
+  const enforced = { ...decision };
+  const threadActions: Partial<Record<NotificationChannel, ThreadAction>> = {
+    ...(decision.threadActions ?? {}),
+  };
+
+  for (const [channel, conversationId] of entries) {
+    threadActions[channel as NotificationChannel] = {
+      action: 'reuse_existing',
+      conversationId: conversationId!,
+    };
+  }
+
+  enforced.threadActions = threadActions;
+
+  log.info(
+    { affinityHint },
+    'Conversation affinity enforcement: overrode threadActions for hinted channels',
+  );
+
+  return enforced;
+}
+
 // ── Persistence ────────────────────────────────────────────────────────
 
 function persistDecision(signal: NotificationSignal, decision: NotificationDecision): string | undefined {

package/src/notifications/emit-signal.ts

@@ -133,6 +133,12 @@ export interface EmitSignalParams {
   routingIntent?: RoutingIntent;
   /** Free-form hints from the source for the decision engine. */
   routingHints?: Record<string, unknown>;
+  /**
+   * Per-channel conversation affinity hint. Forces the decision engine to
+   * reuse the specified conversation for the given channel(s), bypassing
+   * LLM thread-routing judgment. Keyed by channel name, value is conversationId.
+   */
+  conversationAffinityHint?: Partial<Record<string, string>>;
   /** Optional deduplication key. */
   dedupeKey?: string;
   /**
@@ -177,6 +183,7 @@ export async function emitNotificationSignal(params: EmitSignalParams): Promise<
     attentionHints: params.attentionHints,
     routingIntent: params.routingIntent,
     routingHints: params.routingHints,
+    conversationAffinityHint: params.conversationAffinityHint,
   };
 
   try {

package/src/notifications/signal.ts

@@ -27,4 +27,11 @@ export interface NotificationSignal {
   routingIntent?: RoutingIntent;
   /** Free-form hints from the source for the decision engine (e.g. preferred channels). */
   routingHints?: Record<string, unknown>;
+  /**
+   * Per-channel conversation affinity hint. When set, the decision engine
+   * must force thread reuse to the specified conversation for that channel,
+   * bypassing LLM judgment. Used to enforce deterministic guardian thread
+   * affinity within a call session.
+   */
+  conversationAffinityHint?: Partial<Record<string, string>>;
 }

package/src/notifications/thread-seed-composer.ts

@@ -140,7 +140,8 @@ export function composeThreadSeed(
     const parts: string[] = [];
     if (copy.title && copy.title !== 'Notification') parts.push(copy.title);
     if (copy.body) parts.push(copy.body);
-    if (signal.attentionHints.requiresAction && parts.length > 0) {
+    const alreadyMentionsAction = parts.some((part) => /\baction required\b/i.test(part));
+    if (signal.attentionHints.requiresAction && parts.length > 0 && !alreadyMentionsAction) {
       parts.push('Action required.');
     }
     if (parts.length > 0) {