@vellumai/assistant 0.7.3 → 0.8.1

package/src/notifications/decision-engine.ts

@@ -35,6 +35,7 @@ import {
   composeFallbackCopy,
   hasAccessRequestInstructions,
   hasInviteFlowDirective,
+  looksLikeIntermediaryInstruction,
 } from "./copy-composer.js";
 import { createDecision } from "./decisions-store.js";
 import {
@@ -127,11 +128,13 @@ function buildSystemPrompt(
     ``,
     `Copy guidelines (three distinct outputs):`,
     `- \`title\` and \`body\` are for native notification popups (e.g. vellum desktop/mobile) — keep them short and glanceable (title ≤ 8 words, body ≤ 2 sentences).`,
+    `  - Write popup copy as final copy for the guardian or recipient. Do not write instructions for the assistant or another intermediary.`,
     `- \`deliveryText\` is the channel-native message for chat channels (e.g. telegram). It must read naturally as a standalone message.`,
     `  - Do not prepend mechanical labels like "Conversation:".`,
     `  - Do not mention channel or transport names (e.g. Telegram, Slack, email) unless the event context explicitly requires it.`,
     `  - Do not repeat title/body verbatim unless that repetition is truly necessary.`,
     `  - Avoid meta-send phrasing (e.g. "I'd like to send a notification", "May I go ahead with that?"). Write the recipient-facing message directly.`,
+    `  - 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.`,
     `- \`conversationSeedMessage\` is the opening message in the internal notification conversation — it can be richer and more contextual.`,
     `  - For vellum (desktop): 2-4 short sentences with useful context and clear next step if action is required.`,
@@ -664,6 +667,47 @@ function enforceAccessRequestInstructions(
   };
 }
 
+function enforceHeartbeatAlertCopy(
+  decision: NotificationDecision,
+  signal: NotificationSignal,
+): NotificationDecision {
+  if (signal.sourceEventName !== "heartbeat.alert") return decision;
+  if (!decision.shouldNotify || decision.selectedChannels.length === 0)
+    return decision;
+
+  const fallbackCopy = composeFallbackCopy(signal, decision.selectedChannels);
+  const nextCopy: Partial<Record<NotificationChannel, RenderedChannelCopy>> = {
+    ...decision.renderedCopy,
+  };
+
+  for (const channel of decision.selectedChannels) {
+    const currentCopy = nextCopy[channel];
+    if (
+      currentCopy &&
+      !heartbeatCopyLooksLikeIntermediaryInstruction(currentCopy)
+    ) {
+      continue;
+    }
+    const safeCopy = fallbackCopy[channel];
+    if (!safeCopy) continue;
+    nextCopy[channel] = safeCopy;
+  }
+
+  return {
+    ...decision,
+    renderedCopy: nextCopy,
+  };
+}
+
+function heartbeatCopyLooksLikeIntermediaryInstruction(
+  copy: RenderedChannelCopy,
+): boolean {
+  return [copy.title, copy.body, copy.deliveryText].some(
+    (value) =>
+      typeof value === "string" && looksLikeIntermediaryInstruction(value),
+  );
+}
+
 function ensureAccessRequestInstructionsInCopy(
   copy: RenderedChannelCopy,
   requestCode: string,
@@ -754,6 +798,7 @@ export async function evaluateSignal(
     let decision = buildFallbackDecision(signal, availableChannels);
     decision = enforceGuardianRequestCode(decision, signal);
     decision = enforceAccessRequestInstructions(decision, signal);
+    decision = enforceHeartbeatAlertCopy(decision, signal);
     decision = enforceGuardianCallConversationAffinity(decision, signal);
     decision = enforceConversationAffinity(
       decision,
@@ -783,6 +828,7 @@ export async function evaluateSignal(
 
   decision = enforceGuardianRequestCode(decision, signal);
   decision = enforceAccessRequestInstructions(decision, signal);
+  decision = enforceHeartbeatAlertCopy(decision, signal);
   decision = enforceGuardianCallConversationAffinity(decision, signal);
   decision = enforceConversationAffinity(
     decision,

package/src/notifications/destination-resolver.ts

@@ -126,6 +126,27 @@ export function resolveDestinations(
         );
         break;
       }
+      case "platform": {
+        // Platform delivery goes through the daemon's VellumPlatformClient —
+        // no external binding needed. Include guardianPrincipalId so the
+        // adapter can scope guardian-sensitive notifications.
+        const platformGuardian = findGuardianForChannel("vellum");
+        const platformMeta: Record<string, unknown> = {};
+        if (platformGuardian) {
+          platformMeta.guardianPrincipalId =
+            platformGuardian.contact.principalId;
+        }
+        result.set("platform", {
+          channel: "platform",
+          metadata:
+            Object.keys(platformMeta).length > 0 ? platformMeta : undefined,
+        });
+        log.debug(
+          { channel: "platform", source: "contacts", hasEndpoint: false },
+          "destination resolved",
+        );
+        break;
+      }
       default: {
         // Future deliverable channels without a resolver — skip silently.
         break;

package/src/notifications/emit-signal.ts

@@ -15,6 +15,7 @@ import { getDeliverableChannels } from "../channels/config.js";
 import { findGuardianForChannel } from "../contacts/contact-store.js";
 import { getLogger } from "../util/logger.js";
 import { type BroadcastFn, VellumAdapter } from "./adapters/macos.js";
+import { PlatformPushAdapter } from "./adapters/platform.js";
 import { SlackAdapter } from "./adapters/slack.js";
 import { TelegramAdapter } from "./adapters/telegram.js";
 import {
@@ -28,6 +29,7 @@ import {
   runDeterministicChecks,
 } from "./deterministic-checks.js";
 import { createEvent, updateEventDedupeKey } from "./events-store.js";
+import { writeHomeFeedItemForSignal } from "./home-feed-side-effect.js";
 import { dispatchDecision } from "./runtime-dispatch.js";
 import type {
   AttentionHints,
@@ -61,7 +63,11 @@ export function registerBroadcastFn(fn: BroadcastFn): void {
 
 function getBroadcaster(): NotificationBroadcaster {
   if (!broadcasterInstance) {
-    const adapters = [new TelegramAdapter(), new SlackAdapter()];
+    const adapters = [
+      new TelegramAdapter(),
+      new SlackAdapter(),
+      new PlatformPushAdapter(),
+    ];
     if (registeredBroadcastFn) {
       adapters.unshift(new VellumAdapter(registeredBroadcastFn));
     }
@@ -110,6 +116,16 @@ function getConnectedChannels(): NotificationChannel[] {
         // always available when the daemon is running).
         channels.push(channel);
         break;
+      case "platform":
+        // Platform push is connected when the daemon has a registered
+        // broadcast function — i.e., full daemon mode where platform
+        // credentials are also available. Mirrors the vellum gate so
+        // the decision engine doesn't route to platform in standalone
+        // CLI contexts where VellumPlatformClient.create() returns null.
+        if (registeredBroadcastFn) {
+          channels.push(channel);
+        }
+        break;
       case "telegram": {
         // A binding-based channel is connected when the guardian has an
         // active channel entry with a valid delivery endpoint. The
@@ -349,6 +365,17 @@ export async function emitNotificationSignal<TEventName extends string>(
         : undefined,
     );
 
+    // Step 5: Mirror background-origin signals into the home activity feed.
+    // The helper itself decides whether to write (background filter); we
+    // catch and log so a feed-write failure cannot poison the dispatch result.
+    await writeHomeFeedItemForSignal(
+      signal,
+      decision,
+      dispatchResult.deliveryResults,
+    ).catch((err) => {
+      log.warn({ err, signalId }, "writeHomeFeedItemForSignal threw");
+    });
+
     log.info(
       {
         signalId,

package/src/notifications/home-feed-side-effect.ts

@@ -0,0 +1,111 @@
+/**
+ * Home-feed side effect for the notification pipeline.
+ *
+ * Writes a `FeedItem` into the home activity feed when a notification
+ * signal originates from a non-interactive (background or scheduled)
+ * conversation, or carries the `isAsyncBackground` attention hint.
+ *
+ * Producer flows like the scheduler, watchers, and background activity
+ * jobs already emit through `emitNotificationSignal()` — this helper
+ * mirrors the high-signal subset of that traffic into the home feed so
+ * the macOS Home page surfaces them alongside other activity.
+ */
+import {
+  type FeedItem,
+  feedItemSchema,
+  type FeedItemUrgency,
+} from "../home/feed-types.js";
+import { appendFeedItem } from "../home/feed-writer.js";
+import { getConversation } from "../memory/conversation-crud.js";
+import { isBackgroundConversationType } from "../memory/conversation-types.js";
+import { getLogger } from "../util/logger.js";
+import type { NotificationSignal } from "./signal.js";
+import type {
+  NotificationDecision,
+  NotificationDeliveryResult,
+} from "./types.js";
+
+const log = getLogger("home-feed-side-effect");
+
+const FEED_ITEM_URGENCIES: ReadonlySet<string> = new Set<FeedItemUrgency>([
+  "low",
+  "medium",
+  "high",
+  "critical",
+]);
+
+/**
+ * Append a `FeedItem` for the given notification signal when the
+ * filter criteria pass.
+ *
+ * Returns the persisted `FeedItem`, or `null` if the signal does not
+ * qualify for home-feed mirroring (non-background origin AND no
+ * `isAsyncBackground` hint) or if schema validation fails.
+ */
+export async function writeHomeFeedItemForSignal(
+  signal: NotificationSignal,
+  decision: NotificationDecision,
+  deliveryResults: NotificationDeliveryResult[],
+): Promise<FeedItem | null> {
+  if (!shouldMirrorToHomeFeed(signal)) return null;
+
+  const renderedCopy = decision.renderedCopy.vellum;
+  const payloadTitle = readPayloadString(signal.contextPayload, "title");
+  const payloadBody = readPayloadString(signal.contextPayload, "body");
+
+  const conversationId = deliveryResults.find(
+    (r) => r.channel === "vellum",
+  )?.conversationId;
+  const urgency = FEED_ITEM_URGENCIES.has(signal.attentionHints.urgency)
+    ? (signal.attentionHints.urgency as FeedItemUrgency)
+    : undefined;
+  const now = new Date().toISOString();
+
+  const item: FeedItem = {
+    id: `notif:${signal.signalId}`,
+    type: "notification",
+    priority: 50,
+    title: renderedCopy?.title ?? payloadTitle ?? signal.sourceEventName,
+    summary: renderedCopy?.body ?? payloadBody ?? signal.sourceEventName,
+    timestamp: now,
+    createdAt: now,
+    status: "new",
+    ...(urgency ? { urgency } : {}),
+    ...(conversationId ? { conversationId } : {}),
+  };
+
+  try {
+    feedItemSchema.parse(item);
+  } catch (err) {
+    log.warn(
+      { err, signalId: signal.signalId },
+      "FeedItem failed schema validation; skipping home-feed write",
+    );
+    return null;
+  }
+
+  await appendFeedItem(item);
+  return item;
+}
+
+/**
+ * `sourceContextId` is best-effort — it may not be a conversation id
+ * (e.g. scheduler job id, watcher event id), so a lookup failure
+ * falls through to "not a background conversation" rather than throwing.
+ */
+function shouldMirrorToHomeFeed(signal: NotificationSignal): boolean {
+  if (signal.attentionHints.isAsyncBackground) return true;
+  if (!signal.sourceContextId) return false;
+  try {
+    const row = getConversation(signal.sourceContextId);
+    return isBackgroundConversationType(row?.conversationType);
+  } catch {
+    return false;
+  }
+}
+
+function readPayloadString(payload: unknown, key: string): string | undefined {
+  if (!payload || typeof payload !== "object") return undefined;
+  const value = (payload as Record<string, unknown>)[key];
+  return typeof value === "string" ? value : undefined;
+}

package/src/notifications/signal.ts

@@ -88,6 +88,11 @@ export const NOTIFICATION_SOURCE_EVENT_NAMES = [
     description: "Tool requires user confirmation before executing",
   },
   { id: "activity.complete", description: "Background activity finished" },
+  {
+    id: "activity.failed",
+    description:
+      "Background job execution failed (model_provider, exception, or timeout)",
+  },
   {
     id: "quick_chat.response_ready",
     description: "Quick chat response ready for review",

package/src/permissions/checker.ts

@@ -289,6 +289,17 @@ function buildClassifyRiskParams(
 ): ClassifyRiskParams {
   // ── Bash/host_bash ──
   if (toolName === "bash" || toolName === "host_bash") {
+    // Count credential references attached to this invocation.
+    let credentialRefCount: number | undefined;
+    if (Array.isArray(input.credential_ids)) {
+      const validIds = (input.credential_ids as unknown[]).filter(
+        (id) => typeof id === "string" && id.length > 0,
+      );
+      if (validIds.length > 0) {
+        credentialRefCount = validIds.length;
+      }
+    }
+
     return {
       tool: toolName,
       command: getStringField(input, "command"),
@@ -297,6 +308,7 @@ function buildClassifyRiskParams(
       isContainerized: getIsContainerized(),
       networkMode:
         typeof input.network_mode === "string" ? input.network_mode : undefined,
+      credentialRefCount,
     };
   }
 

package/src/permissions/gateway-threshold-reader.ts

@@ -44,6 +44,106 @@ const conversationThresholdCache = new Map<
 >();
 const CONVERSATION_CACHE_TTL_MS = 5_000;
 
+// ── Failure-coalescing log helper ────────────────────────────────────────────
+// When the gateway IPC socket is broken (e.g. the path was unlinked from
+// disk), every threshold lookup fails with ENOENT on the hot path. Without
+// coalescing the per-call WARN drowns the actual signal ("Strict-when-
+// Relaxed because the gateway lost its socket") in its own log spam.
+//
+// Each `op` (e.g. "conversation_threshold", "global_thresholds") emits at
+// most one WARN per {@link DEFAULT_FAILURE_WARN_INTERVAL_MS} window. The
+// first failure in a streak WARNs immediately so failures aren't lost. When
+// the IPC starts working again, an INFO records the streak duration and
+// how many calls were swallowed — that's the cue dashboards should alert
+// on.
+
+interface FailureState {
+  consecutiveFailures: number;
+  firstFailureAt: number;
+  lastWarnAt: number;
+}
+
+const DEFAULT_FAILURE_WARN_INTERVAL_MS = 30_000;
+let failureWarnIntervalMs = DEFAULT_FAILURE_WARN_INTERVAL_MS;
+const failureStateByOp = new Map<string, FailureState>();
+
+function noteFailure(
+  op: string,
+  fields: Record<string, unknown>,
+  message: string,
+): void {
+  const now = Date.now();
+  const state = failureStateByOp.get(op);
+  if (!state) {
+    failureStateByOp.set(op, {
+      consecutiveFailures: 1,
+      firstFailureAt: now,
+      lastWarnAt: now,
+    });
+    log.warn(
+      {
+        ...fields,
+        op,
+        consecutiveFailures: 1,
+        event: "ipc_threshold_failure",
+      },
+      message,
+    );
+    return;
+  }
+  state.consecutiveFailures += 1;
+  if (now - state.lastWarnAt >= failureWarnIntervalMs) {
+    log.warn(
+      {
+        ...fields,
+        op,
+        consecutiveFailures: state.consecutiveFailures,
+        streakDurationMs: now - state.firstFailureAt,
+        event: "ipc_threshold_failure",
+      },
+      message,
+    );
+    state.lastWarnAt = now;
+  }
+}
+
+function noteSuccess(op: string): void {
+  const state = failureStateByOp.get(op);
+  if (!state) return;
+  log.info(
+    {
+      op,
+      swallowedFailures: state.consecutiveFailures,
+      streakDurationMs: Date.now() - state.firstFailureAt,
+      event: "ipc_threshold_recovered",
+    },
+    "Gateway IPC threshold call recovered after failure streak",
+  );
+  failureStateByOp.delete(op);
+}
+
+/** Test-only: clear the failure-coalescing state. */
+export function _resetFailureCoalesceForTesting(): void {
+  failureStateByOp.clear();
+  failureWarnIntervalMs = DEFAULT_FAILURE_WARN_INTERVAL_MS;
+}
+
+/**
+ * Test-only: read a snapshot of the failure-coalescing state for a given
+ * op. Returns `undefined` when no streak is in progress.
+ */
+export function _getFailureStateForTesting(
+  op: string,
+): Readonly<FailureState> | undefined {
+  const state = failureStateByOp.get(op);
+  return state ? { ...state } : undefined;
+}
+
+/** Test-only: override the WARN cadence. Pass {@link DEFAULT_FAILURE_WARN_INTERVAL_MS} to reset. */
+export function _setFailureWarnIntervalForTesting(intervalMs: number): void {
+  failureWarnIntervalMs = intervalMs;
+}
+
 /**
  * Clear the global threshold cache. Exported for testing.
  */
@@ -112,18 +212,24 @@ export async function getAutoApproveThreshold(
       })) as ConversationThreshold | null | undefined;
 
       if (result === undefined) {
-        log.warn(
+        noteFailure(
+          "conversation_threshold",
           { conversationId },
           "IPC call failed for conversation threshold override, falling through to global",
         );
         // Fall through to global threshold fetch below.
-      } else if (result && isValidThreshold(result.threshold)) {
-        conversationThresholdCache.set(conversationId, {
-          threshold: result.threshold,
-          timestamp: Date.now(),
-        });
-        return result.threshold;
       } else {
+        // Any defined response (including a null "no override") is a
+        // successful round-trip — clear any in-progress failure streak so
+        // dashboards see the recovery.
+        noteSuccess("conversation_threshold");
+        if (result && isValidThreshold(result.threshold)) {
+          conversationThresholdCache.set(conversationId, {
+            threshold: result.threshold,
+            timestamp: Date.now(),
+          });
+          return result.threshold;
+        }
         // result === null (or an unexpected shape) — cache the negative result
         // and fall through to global defaults.
         conversationThresholdCache.set(conversationId, {
@@ -151,7 +257,8 @@ export async function getAutoApproveThreshold(
   } catch (err) {
     // Gateway unreachable — default to "none" (Strict) so no tools are
     // silently auto-approved when the gateway is down.
-    log.warn(
+    noteFailure(
+      "global_thresholds",
       { error: String(err) },
       "Failed to fetch global thresholds, defaulting to none",
     );
@@ -176,6 +283,7 @@ async function fetchGlobalThresholds(): Promise<GlobalThresholds> {
     throw new Error("Gateway IPC returned no result for global thresholds");
   }
 
+  noteSuccess("global_thresholds");
   cachedGlobalThresholds = result;
   cachedGlobalTimestamp = Date.now();
   return result;

package/src/permissions/ipc-risk-types.ts

@@ -92,4 +92,6 @@ export interface ClassifyRiskParams {
   skillMetadata?: SkillMetadata;
   /** Tool registry default risk level for unknown tools. */
   registryDefaultRisk?: string;
+  /** Number of credential references attached to this tool invocation. */
+  credentialRefCount?: number;
 }