@oar-sh/oar 0.9.19 → 0.9.20

package/server/services/plan-usage-tokens.mjs

@@ -0,0 +1,248 @@
+'use strict';
+
+/**
+ * The Tokens sections of every Check Usage tab: what the turns on
+ * a provider ran, from the token booking (token-usage-service.mjs,
+ * `readPeriods`), with fresh input, output, cache writes and cache reads
+ * apart.
+ *
+ * Per billing group (the plan, then each own key on Copilot), two sections,
+ * `<provider>-token-usage` and `<provider>-token-usage-by-model` (an own
+ * key's with `-byok-<type>` after; DeepSeek's own `deepseek-tokens-by-model`
+ * stays beside them):
+ * - "Tokens": today, this month and all time, with the share of input the
+ *   cache served as the hint;
+ * - "Tokens by model, this month": one row per model, today and all time in
+ *   the hint.
+ * A field nobody reported is "—", and the note says why; it also says since
+ * when the tab counts, and, on a tab with days copied at the upgrade, that
+ * their input includes cache writes. Values stay within the agent card's
+ * 120 characters (remote-relay-dispatcher.mjs).
+ */
+
+import { buildDetailSection } from './plan-usage-contract.mjs';
+import { partlyReportedFields } from './token-usage-service.mjs';
+
+export const TOKEN_SHOWN_FIELDS = Object.freeze(['inputTokens', 'outputTokens', 'cacheWriteTokens', 'cacheReadTokens']);
+
+const FIELD_SHORT = Object.freeze({
+  inputTokens: 'in',
+  outputTokens: 'out',
+  cacheWriteTokens: 'cache w',
+  cacheReadTokens: 'cache r',
+});
+
+const FIELD_NAME = Object.freeze({
+  inputTokens: 'fresh input',
+  outputTokens: 'output',
+  cacheWriteTokens: 'cache writes',
+  cacheReadTokens: 'cache reads',
+});
+
+const PROVIDER_NAME = Object.freeze({
+  github: 'Copilot',
+  claude: 'Claude',
+  'claude-api': 'The Claude API',
+  'claude-cloud': 'Claude cloud',
+  deepseek: 'DeepSeek',
+  cursor: 'Cursor',
+  grok: 'Grok',
+});
+
+const KEY_NAME = Object.freeze({
+  openai: 'OpenAI',
+  anthropic: 'Anthropic',
+  azure: 'Azure OpenAI',
+});
+
+// Only these tabs carry days copied at the upgrade (migration 0036).
+const BACKFILLED_PROVIDERS = Object.freeze(['claude-api', 'deepseek']);
+
+/**
+ * A token count for a card: "—" for unknown (null), else 999, 1.2k, 3.4M or
+ * 5.6B. Unlike the older card formatters it does not stop at millions and
+ * never shows an unknown count as 0.
+ */
+export function formatTokenCount(value) {
+  if (value === null || value === undefined) return '—';
+  const number = Number(value);
+  if (!Number.isFinite(number) || number < 0) return '—';
+  const scaled = (divisor, unit) => `${(number / divisor).toFixed(1).replace(/\.0$/, '')}${unit}`;
+  if (number < 1000) return String(Math.round(number));
+  if (number < 999_950) return scaled(1000, 'k');
+  if (number < 999_950_000) return scaled(1_000_000, 'M');
+  return scaled(1_000_000_000, 'B');
+}
+
+/** "in 1.2M · out 340k · cache w 1.1M · cache r 45.3M". */
+export function formatTokenSplit(totals) {
+  return TOKEN_SHOWN_FIELDS.map((field) => `${FIELD_SHORT[field]} ${formatTokenCount(totals?.[field])}`).join(' · ');
+}
+
+function totalTokens(totals) {
+  let sum = null;
+  for (const field of TOKEN_SHOWN_FIELDS) {
+    const value = totals?.[field];
+    if (value !== null && value !== undefined) sum = (sum ?? 0) + value;
+  }
+  return sum;
+}
+
+/** "45% of input from the cache", or null when there is nothing to say. */
+function cacheShareHint(totals) {
+  if (totals?.cacheReadTokens === null || totals?.cacheReadTokens === undefined) return null;
+  const input = (totals.inputTokens || 0) + (totals.cacheReadTokens || 0) + (totals.cacheWriteTokens || 0);
+  if (input <= 0) return null;
+  return `${Math.round((totals.cacheReadTokens / input) * 100)}% of input from the cache`;
+}
+
+/** "Oct 1, 2026" for a `YYYY-MM-DD` day (a calendar date, no zone). */
+export function tokenDayLabel(day) {
+  const date = new Date(`${day}T00:00:00.000Z`);
+  if (Number.isNaN(date.getTime())) return String(day || '');
+  return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric', timeZone: 'UTC' });
+}
+
+function keyName(billing) {
+  const type = String(billing || '').replace(/^byok-/, '');
+  return KEY_NAME[type] || (type ? type.charAt(0).toUpperCase() + type.slice(1) : 'Own key');
+}
+
+function capitalize(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+/**
+ * The note under a group's "Tokens" section: why a field is "—", which
+ * fields some turns left out, the copied days, since when it counts.
+ */
+export function tokenSectionNote(group) {
+  const who = group.billing ? keyName(group.billing) : (PROVIDER_NAME[group.provider] || group.provider);
+  const backfill = BACKFILLED_PROVIDERS.includes(group.provider) && group.backfilled?.allTime === true;
+  const allTime = group.periods.allTime;
+  const partly = new Set(partlyReportedFields(allTime));
+  const lines = [];
+  for (const field of TOKEN_SHOWN_FIELDS) {
+    // The copied days never split cache writes out; the backfill line says so.
+    const explainedByBackfill = backfill && field === 'cacheWriteTokens';
+    if (allTime[field] === null && !explainedByBackfill) {
+      lines.push(`${who} does not report ${FIELD_NAME[field]}.`);
+    } else if (partly.has(field) && !explainedByBackfill) {
+      lines.push(`${capitalize(FIELD_NAME[field])} not reported for some turns.`);
+    }
+  }
+  if (backfill) {
+    lines.push(group.firstTurnsDay
+      ? `Before ${tokenDayLabel(group.firstTurnsDay)}, input includes cache writes.`
+      : 'On the days copied from before the upgrade, input includes cache writes.');
+  }
+  if (group.since) lines.push(`Counting since ${tokenDayLabel(group.since)}.`);
+  return lines.join(' ');
+}
+
+// `a` and `b` (a model's totals of one period, emptyTotals() of
+// token-usage-service.mjs) added up as the booking adds its rows: a field
+// nobody reported stays null.
+function addTotals(a, b) {
+  const sum = { ...a, reported: { ...(a.reported || {}) } };
+  for (const field of Object.keys(b || {})) {
+    if (field === 'reported') {
+      for (const [name, count] of Object.entries(b.reported || {})) sum.reported[name] = (sum.reported[name] || 0) + count;
+    } else if (b[field] !== null && b[field] !== undefined) {
+      sum[field] = (sum[field] ?? 0) + b[field];
+    }
+  }
+  return sum;
+}
+
+/**
+ * A group's models by the name the tab shows: ids with one name (a dated and
+ * an undated Claude id) become one entry, with their totals added up and the
+ * ids in `models`; sorted by that name.
+ */
+export function mergeModelsByLabel(models, modelLabel = null) {
+  const byLabel = new Map();
+  for (const entry of models || []) {
+    const label = (typeof modelLabel === 'function' ? String(modelLabel(entry.model) || '').trim() : '') || entry.model;
+    const merged = byLabel.get(label);
+    if (!merged) {
+      byLabel.set(label, { label, models: [entry.model], today: entry.today, month: entry.month, allTime: entry.allTime });
+      continue;
+    }
+    merged.models.push(entry.model);
+    for (const period of ['today', 'month', 'allTime']) merged[period] = addTotals(merged[period], entry[period]);
+  }
+  return [...byLabel.values()]
+    .map((entry) => ({ ...entry, models: [...entry.models].sort() }))
+    .sort((a, b) => a.label.localeCompare(b.label, 'en'));
+}
+
+/**
+ * The two sections of one billing group, open. `modelLabel(model)` names a
+ * model as the tab does elsewhere (the Claude API tab: the Console's display
+ * name); the raw id where it has none. Ids with one name are one row, the ids
+ * in its title.
+ */
+export function buildTokenSections(group, { modelLabel = null } = {}) {
+  if (!group || !group.periods) return [];
+  const suffix = group.billing ? `-${group.billing}` : '';
+  const labelSuffix = group.billing ? ` — own ${keyName(group.billing)} key` : '';
+  const periodRow = (label, totals) => ({
+    label,
+    value: totals.rows ? formatTokenSplit(totals) : 'no turns',
+    hint: totals.rows ? cacheShareHint(totals) : null,
+  });
+  const sections = [
+    buildDetailSection({
+      id: `${group.provider}-token-usage${suffix}`,
+      label: `Tokens${labelSuffix}`,
+      rows: [
+        periodRow('Today', group.periods.today),
+        periodRow('This month', group.periods.month),
+        periodRow('All time', group.periods.allTime),
+      ],
+      note: tokenSectionNote(group),
+      open: true,
+    }),
+    buildDetailSection({
+      id: `${group.provider}-token-usage-by-model${suffix}`,
+      label: `Tokens by model, this month${labelSuffix}`,
+      rows: mergeModelsByLabel(group.models, modelLabel)
+        .filter((entry) => entry.month.rows > 0)
+        .map((entry) => ({
+          label: entry.label,
+          value: formatTokenSplit(entry.month),
+          hint: `today ${entry.today.rows ? formatTokenCount(totalTokens(entry.today)) : 'none'} · all time ${formatTokenCount(totalTokens(entry.allTime))}`,
+          ...(entry.models.length > 1 ? { title: `Model ids: ${entry.models.join(', ')}` } : {}),
+        })),
+      open: true,
+    }),
+  ];
+  return sections.filter(Boolean);
+}
+
+/**
+ * Append the Tokens sections to every provider card the report holds,
+ * from `readPeriods({ provider })`; `modelLabelFor(provider)` may give a
+ * tab its model names. A provider with nothing booked gets
+ * none; the plan's group comes before the own keys'. Cards are changed in
+ * place; a failing read leaves them as they were.
+ */
+export function appendTokenSections(cards, readPeriods, { modelLabelFor = null } = {}) {
+  if (!Array.isArray(cards) || typeof readPeriods !== 'function') return cards;
+  for (const card of cards) {
+    if (!card || !card.provider) continue;
+    let periods = null;
+    try {
+      periods = readPeriods({ provider: card.provider });
+    } catch {
+      periods = null;
+    }
+    const groups = periods?.groups || [];
+    if (!groups.length) continue;
+    const modelLabel = typeof modelLabelFor === 'function' ? modelLabelFor(card.provider) : null;
+    const sections = groups.flatMap((group) => buildTokenSections(group, { modelLabel }));
+    if (sections.length) card.details = [...(Array.isArray(card.details) ? card.details : []), ...sections];
+  }
+  return cards;
+}

package/server/services/push-dispatch-service.mjs

@@ -1,6 +1,8 @@
 'use strict';
 
 import { providerDisplayName } from '../public/app/conversation-provider-indicator.mjs';
+import { DEFAULT_QUESTION_TIMEOUT_MS } from '../../shared/question-timeout.mjs';
+import { REMOTE_RELAY_APPROVAL_VARIANT_LABELS, remoteConversationUrl } from '../../shared/remote-relay-contract.mjs';
 
 /**
  * Web Push dispatch: decides whether a push should go out at all (suppressed
@@ -29,6 +31,17 @@ const MAX_TITLE_CHARS = 120;
 // weight; drop it after this many consecutive failures.
 const FAILURE_PRUNE_THRESHOLD = 8;
 const PUSH_TTL_SECONDS = 12 * 60 * 60;
+// A push service that stops answering fails the send after this long (the
+// request's socket timeout), so no dispatch waits on it for good.
+export const PUSH_SEND_TIMEOUT_MS = 30_000;
+// The notice ledger: whether a question's own push reached a device,
+// kept as long as a question lives. A push still `pending` after this long
+// counts as missed, so a paired relay may push instead. With the send timeout
+// above, every send has settled (sent, or failed and so `missed`) well before
+// this: a late send of this relay's cannot land after a paired relay pushed.
+// The guard is for a dispatch that hangs anywhere else.
+const NOTICE_KEEP_MS = DEFAULT_QUESTION_TIMEOUT_MS;
+const NOTICE_PENDING_MAX_MS = 2 * 60_000;
 
 const EVENT_LABELS = Object.freeze({
   // A question's title names the provider that asks (questionTitle).
@@ -41,7 +54,14 @@ const EVENT_LABELS = Object.freeze({
   relayRestart: { title: 'Relay restart waiting', generic: 'The queued relay restart has waited its maximum time.' },
 });
 
-function eventTitle(type, providerName) {
+// A card on a paired relay: named by its kind and that relay.
+const REMOTE_GENERIC_APPROVAL = 'An Allow / Deny card waits there.';
+
+function eventTitle(type, providerName, { relayName = null, remoteKind = null } = {}) {
+  const relay = String(relayName || '').trim();
+  if (type === 'question' && relay) {
+    return remoteKind === 'approval' ? `Approval waiting on relay "${relay}"` : `A question waits on relay "${relay}"`;
+  }
   const name = String(providerName || '').trim();
   if (type === 'question' && name) return `${name} needs your input`;
   return EVENT_LABELS[type].title;
@@ -88,7 +108,15 @@ export function normalizePushPreferences(raw) {
  * Render the notification payload for one subscription. Pure so every content
  * preference combination is unit-testable.
  *
- * @param {{ type: string, conversationTitle?: string|null, providerName?: string|null, body?: string|null, data?: object }} event
+ * A card on a paired relay (`relayName`, `remoteKind` 'approval' |
+ * 'ask_user') is titled by that relay. Its body follows the preview
+ * preference like any question's: an approval shows its `summary` (kind,
+ * requesting session, reason: no prompt text, but session titles), and with
+ * the preview off only its kind label ("New session · the session waits"),
+ * so no title reaches a lock screen against the device's setting. It never
+ * carries a question id or choices, so it shows no answer buttons.
+ *
+ * @param {{ type: string, conversationTitle?: string|null, providerName?: string|null, relayName?: string|null, remoteKind?: string|null, variant?: string|null, summary?: string|null, body?: string|null, data?: object }} event
  * @param {object} preferences canonical shape from normalizePushPreferences
  */
 export function renderPushNotification(event, preferences) {
@@ -96,7 +124,8 @@ export function renderPushNotification(event, preferences) {
   const prefs = normalizePushPreferences(preferences);
   const labels = EVENT_LABELS[type];
 
-  const baseTitle = eventTitle(type, event?.providerName);
+  const remote = type === 'question' && String(event?.relayName || '').trim() !== '';
+  const baseTitle = eventTitle(type, event?.providerName, { relayName: event?.relayName, remoteKind: event?.remoteKind }).slice(0, MAX_TITLE_CHARS);
   let title = baseTitle;
   const conversationTitle = String(event?.conversationTitle || '').trim();
   if (prefs.content.includeTitle && conversationTitle) {
@@ -104,7 +133,13 @@ export function renderPushNotification(event, preferences) {
   }
 
   let body = labels.generic;
-  const text = String(event?.body || '').trim();
+  if (remote && event?.remoteKind === 'approval') {
+    const variant = String(event?.variant || '');
+    const kindLabel = Object.hasOwn(REMOTE_RELAY_APPROVAL_VARIANT_LABELS, variant) ? REMOTE_RELAY_APPROVAL_VARIANT_LABELS[variant] : '';
+    body = kindLabel ? `${kindLabel} · the session waits` : REMOTE_GENERIC_APPROVAL;
+  }
+  // A remote approval's preview is its summary, never the card's text.
+  const text = String((remote && event?.remoteKind === 'approval' ? event?.summary : event?.body) || '').trim();
   // cliOffline has no conversation text to preview; the generic body is the message.
   if (text && SYSTEM_BODY_TYPES.has(type)) {
     body = text.slice(0, MAX_FULL_PREVIEW_CHARS);
@@ -119,10 +154,14 @@ export function renderPushNotification(event, preferences) {
 
   const data = event?.data && typeof event.data === 'object' ? { ...event.data } : {};
   data.type = type;
+  if (remote) {
+    delete data.questionId;
+    delete data.choices;
+  }
 
   // A distinct tag per event so notifications stack instead of replacing each
   // other (decision: one notification per event, no coalescing).
-  const tagSeed = String(data.questionId || data.boardId || data.messageId || data.conversationId || Date.now());
+  const tagSeed = String(data.tag || data.questionId || data.boardId || data.messageId || data.conversationId || Date.now());
   return {
     title,
     body,
@@ -195,6 +234,7 @@ export function createPushDispatchService({
   recordStatusEvent = () => {},
   uuid,
   logger = console,
+  now = () => Date.now(),
 }) {
   const sql = {
     listAll: db.prepare(`
@@ -374,7 +414,7 @@ export function createPushDispatchService({
       await webpush.sendNotification(
         { endpoint: row.endpoint, keys },
         JSON.stringify(payload),
-        { TTL: PUSH_TTL_SECONDS, urgency: 'high' },
+        { TTL: PUSH_TTL_SECONDS, urgency: 'high', timeout: PUSH_SEND_TIMEOUT_MS },
       );
       sql.markSuccess.run(new Date().toISOString(), row.id);
       return { sent: true };
@@ -409,7 +449,7 @@ export function createPushDispatchService({
    * Fire-and-forget push for one event. Never throws; suppression failures
    * fail closed (no push when the active-device state is unknown).
    */
-  async function dispatch({ type, conversationId = null, body = null, data = {}, providerName = null }) {
+  async function dispatch({ type, conversationId = null, body = null, data = {}, providerName = null, relayName = null, remoteKind = null, variant = null, summary = null, conversationTitle: titleOf = null }) {
     try {
       if (!PUSH_EVENT_TYPES.includes(type)) return { outcome: 'invalid-type' };
 
@@ -434,8 +474,12 @@ export function createPushDispatchService({
 
       const event = {
         type,
-        conversationTitle: conversationTitle(conversationId),
+        conversationTitle: titleOf || conversationTitle(conversationId),
         providerName,
+        relayName,
+        remoteKind,
+        variant,
+        summary,
         body,
         data: { ...data, conversationId: conversationId || undefined },
       };
@@ -458,6 +502,48 @@ export function createPushDispatchService({
     }
   }
 
+  /** True when some device takes question pushes: enabled, with its "questions" toggle on. */
+  function hasQuestionSubscribers() {
+    try {
+      return sql.listAll.all().some((row) => {
+        const preferences = normalizePushPreferences(parseJsonObject(row.preferences_json));
+        return preferences.enabled && preferences.events.question === true;
+      });
+    } catch {
+      return false;
+    }
+  }
+
+  // question id → { state: 'pending' | 'reached' | 'missed', at }. In memory:
+  // after a restart a question has no entry, and a paired relay may push it.
+  const notices = new Map();
+
+  function pruneNotices() {
+    const cutoff = now() - NOTICE_KEEP_MS;
+    for (const [id, entry] of notices) {
+      if (entry.at < cutoff) notices.delete(id);
+    }
+  }
+
+  function noteNotice(id, state) {
+    pruneNotices();
+    notices.set(id, { state, at: now() });
+  }
+
+  /**
+   * Whether this relay's own push of a question reached a device:
+   * `reached` (sent to one, or a device is active here), `missed`, `pending`
+   * while it is not settled, or null when this relay never pushed it (a card
+   * from before a restart). Read by a paired relay's Inbox (`?push=1`).
+   */
+  function questionNotice(questionId) {
+    const id = String(questionId || '').trim();
+    const entry = id ? notices.get(id) : null;
+    if (!entry || entry.at < now() - NOTICE_KEEP_MS) return null;
+    if (entry.state === 'pending' && now() - entry.at > NOTICE_PENDING_MAX_MS) return 'missed';
+    return entry.state;
+  }
+
   // Semantic wrappers so each io.emit call site stays a single line and the
   // payload construction lives in one place.
   function notifyQuestion(question) {
@@ -468,7 +554,9 @@ export function createPushDispatchService({
       .map((choice) => String(choice || '').trim())
       .filter((choice) => choice && choice.length <= 120)
       .slice(0, 3);
-    return dispatch({
+    const id = String(question?.id || '').trim();
+    if (id) noteNotice(id, 'pending');
+    const pushed = dispatch({
       type: 'question',
       conversationId: question?.conversationId || null,
       providerName: conversationProviderName(question?.conversationId),
@@ -478,6 +566,40 @@ export function createPushDispatchService({
         choices: choices.length ? choices : undefined,
       },
     });
+    if (!id) return pushed;
+    return pushed.then((result) => {
+      const reached = result?.outcome === 'suppressed' || (result?.outcome === 'dispatched' && Number(result.sent) > 0);
+      noteNotice(id, reached ? 'reached' : 'missed');
+      return result;
+    });
+  }
+
+  /**
+   * A card a turn on a paired relay waits on, which this relay claimed
+   * (remote-inbox-watch-service.mjs): the "questions" toggle and the
+   * active-device suppression apply as to this relay's own. The tap opens
+   * its session there; no question id, no choices: it is answered there.
+   */
+  function notifyRemoteCard({ relay, item } = {}) {
+    const relayId = String(relay?.id || '').trim();
+    const id = String(item?.id || '').trim();
+    const approval = item?.kind === 'approval';
+    const url = remoteConversationUrl(relay?.url, item?.session?.id);
+    return dispatch({
+      type: 'question',
+      relayName: String(relay?.name || '').trim() || relayId || 'another relay',
+      remoteKind: approval ? 'approval' : 'ask_user',
+      variant: approval ? String(item?.variant || '').trim() || null : null,
+      summary: approval ? String(item?.summary || '').trim() || null : null,
+      // An ask_user card's question, which paired relays already get, goes through the preview preference.
+      body: approval ? null : String(item?.question || '').trim() || null,
+      conversationTitle: String(item?.session?.title || '').trim() || null,
+      data: {
+        url: /^https?:\/\//i.test(url) ? url : undefined,
+        remoteRelayId: relayId || undefined,
+        tag: `remote-${relayId}-${id}`,
+      },
+    });
   }
 
   // `messageId` is the reply; `sourceMessageId` the user message that started
@@ -536,6 +658,9 @@ export function createPushDispatchService({
     deleteDevice,
     dispatch,
     notifyQuestion,
+    questionNotice,
+    hasQuestionSubscribers,
+    notifyRemoteCard,
     notifyTurnComplete,
     notifyTurnFailed,
     notifyBoard,

package/server/services/relay-cli-launcher-service.mjs

@@ -30,6 +30,8 @@ export function createRelayCliLauncherService({
   killWaitMs = 700,
   maxKillAttempts = 10,
   log = () => {},
+  // worker-scope.mjs: a scope of its own under a systemd user service.
+  workerScope = null,
 } = {}) {
   let activeJob = null;
   const processInspector = createSessionWorkerProcessInspector({
@@ -119,6 +121,7 @@ export function createRelayCliLauncherService({
       execFileSyncImpl,
       processInspector,
       log,
+      workerScope,
     });
     return launched;
   }

package/server/services/relay-event-service.mjs

@@ -1775,6 +1775,13 @@ export function createRelayEventService({
     choice: 'text',
     dismissed: 'bool',
     via: 'text',
+    // board_settled
+    boardId: 'text',
+    boardType: 'text',
+    action: 'text',
+    actionLabel: 'text',
+    title: 'text',
+    queuedMessageId: 'text',
     description: 'text',
     summary: 'text',
     taskId: 'text',
@@ -2370,6 +2377,28 @@ export function createRelayEventService({
     return told.size + recorded;
   }
 
+  /**
+   * The user settled a plan card (board) of a session (routes/relay-board-routes.mjs):
+   * the subscriptions on that session that take board_settled are told, as
+   * for any event (paired relays' through their fetch). `queuedMessageId` is
+   * the follow-up message the action queued, null for exit_only. Returns how
+   * many watchers got it.
+   */
+  function noteBoardSettled(conversationId, detail = {}) {
+    if (!available) return 0;
+    const boardId = toText(detail?.boardId);
+    if (!toText(conversationId) || !boardId) return 0;
+    const queuedMessageId = toText(detail.queuedMessageId);
+    return record('board_settled', conversationId, {
+      boardId,
+      boardType: toText(detail.boardType).slice(0, 80) || null,
+      action: toText(detail.action).slice(0, 80),
+      actionLabel: toText(detail.actionLabel).slice(0, 200),
+      title: String(detail.title ?? '').slice(0, 500),
+      queuedMessageId: queuedMessageId || null,
+    });
+  }
+
   /** The tracker's edge: a background task started or ended. */
   function noteTaskEdge({ type, conversationId, task } = {}) {
     if (!available || !task) return;
@@ -2651,6 +2680,7 @@ export function createRelayEventService({
     noteError,
     noteQuestion,
     noteQuestionAnswered,
+    noteBoardSettled,
     noteTaskEdge,
     noteConversationGone,
     noteRestartRequested,

package/server/services/relay-question-context.mjs

@@ -5,6 +5,11 @@
 // dropped, so a new hint the client reads must be added here too (the
 // multi-select flag was once silently stripped this way).
 
+import {
+  REMOTE_RELAY_APPROVAL_SUMMARY_MAX,
+  REMOTE_RELAY_APPROVAL_VARIANTS,
+} from '../../shared/remote-relay-contract.mjs';
+
 /**
  * @param {unknown} rawContext
  * @param {{ normalizeRelayMode?: (mode: string) => string | null, defaultRelayMode?: string }} [options]
@@ -42,5 +47,11 @@ export function sanitizeRelayQuestionContext(rawContext, {
   if (typeof rawContext.header === 'string' && rawContext.header.trim()) {
     context.header = rawContext.header.trim().slice(0, 120);
   }
+  // An approval card's kind and one-line summary, what a paired
+  // relay's Inbox shows of it: a listed variant only, the summary bounded.
+  if (REMOTE_RELAY_APPROVAL_VARIANTS.includes(rawContext.variant)) context.variant = rawContext.variant;
+  if (typeof rawContext.summary === 'string' && rawContext.summary.trim()) {
+    context.summary = rawContext.summary.trim().replace(/\s+/g, ' ').slice(0, REMOTE_RELAY_APPROVAL_SUMMARY_MAX);
+  }
   return Object.keys(context).length ? context : null;
 }