@vellumai/assistant 0.12.2-staging.2 → 0.12.2-staging.4

package/src/monitoring/mount-watch.ts

@@ -0,0 +1,348 @@
+/**
+ * Mount-table watcher for the assistant container, polled by the resource
+ * monitor.
+ *
+ * The monitor process shares the assistant container's mount namespace, so
+ * `/proc/self/mountinfo` is exactly that container's mounts (workspace and
+ * data PVC binds, plus any virtiofs handles). Gateway and CES sidecar mounts
+ * are out of scope. The watcher keeps a baseline and logs only when the
+ * watched set actually changes: a virtiofs bind that disappears, a fstype
+ * swap, or a statfs size collapse on `/workspace` or `/data`.
+ *
+ * Windows and macOS have no `/proc/self/mountinfo`; those platforms no-op.
+ */
+
+import { readFileSync, statfsSync } from "node:fs";
+
+import type { MonitoringConfig } from "../config/schemas/monitoring.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("mount-watch");
+
+/** Assistant-container PVC bind targets in the managed pod template. */
+export const ASSISTANT_VOLUME_MOUNT_POINTS = ["/workspace", "/data"] as const;
+
+const VIRTIOFS_TYPES = new Set(["virtiofs", "fuse.virtiofs"]);
+
+export interface MountInfoEntry {
+  mountId: string;
+  parentId: string;
+  majorMinor: string;
+  root: string;
+  mountPoint: string;
+  mountOptions: string;
+  fsType: string;
+  source: string;
+  superOptions: string;
+}
+
+export interface PathFsSnapshot {
+  path: string;
+  /** `statfs.f_type`; null when the path could not be measured. */
+  type: number | null;
+  blockSize: number | null;
+  blocks: number | null;
+  files: number | null;
+  /** Present when the path exists but `statfs` failed. */
+  error?: string;
+}
+
+export interface MountSnapshot {
+  mounts: MountInfoEntry[];
+  paths: PathFsSnapshot[];
+}
+
+export interface MountDiff {
+  added: MountInfoEntry[];
+  removed: MountInfoEntry[];
+  changed: Array<{ previous: MountInfoEntry; current: MountInfoEntry }>;
+  pathChanges: Array<{ previous: PathFsSnapshot; current: PathFsSnapshot }>;
+}
+
+export interface CollectMountSnapshotOptions {
+  platform?: NodeJS.Platform;
+  readMountinfo?: () => string;
+  statPath?: (path: string) => PathFsSnapshot;
+  watchedMountPoints?: readonly string[];
+}
+
+export interface MountWatchHandle {
+  stop: () => void;
+}
+
+/**
+ * Kernel mountinfo encodes space/tab/newline in paths as octal escapes
+ * (`\040`, `\011`, `\012`) and a backslash as `\\`.
+ */
+export function unescapeMountField(value: string): string {
+  return value
+    .replace(/\\([0-7]{3})/g, (_match, oct: string) =>
+      String.fromCharCode(parseInt(oct, 8)),
+    )
+    .replace(/\\\\/g, "\\");
+}
+
+/**
+ * Parse `/proc/self/mountinfo` into structured entries. Malformed lines are
+ * skipped rather than failing the pass.
+ */
+export function parseMountinfo(raw: string): MountInfoEntry[] {
+  const entries: MountInfoEntry[] = [];
+  for (const line of raw.split("\n")) {
+    if (line.length === 0) {
+      continue;
+    }
+    const separator = line.indexOf(" - ");
+    if (separator < 0) {
+      continue;
+    }
+    const left = line.slice(0, separator).split(" ");
+    const right = line.slice(separator + 3).split(" ");
+    if (left.length < 6 || right.length < 3) {
+      continue;
+    }
+    entries.push({
+      mountId: left[0],
+      parentId: left[1],
+      majorMinor: left[2],
+      root: unescapeMountField(left[3]),
+      mountPoint: unescapeMountField(left[4]),
+      mountOptions: left[5],
+      fsType: unescapeMountField(right[0]),
+      source: unescapeMountField(right[1]),
+      superOptions: right.slice(2).join(" "),
+    });
+  }
+  return entries;
+}
+
+export function isWatchedMount(
+  entry: MountInfoEntry,
+  watchedMountPoints: readonly string[] = ASSISTANT_VOLUME_MOUNT_POINTS,
+): boolean {
+  if (VIRTIOFS_TYPES.has(entry.fsType)) {
+    return true;
+  }
+  return watchedMountPoints.some(
+    (point) => entry.mountPoint === point || entry.mountPoint.startsWith(`${point}/`),
+  );
+}
+
+function mountIdentity(entry: MountInfoEntry): string {
+  return entry.mountPoint;
+}
+
+function mountSignature(entry: MountInfoEntry): string {
+  return [
+    entry.fsType,
+    entry.source,
+    entry.majorMinor,
+    entry.root,
+    entry.mountOptions,
+    entry.superOptions,
+  ].join("\0");
+}
+
+function pathSignature(snapshot: PathFsSnapshot): string {
+  return [
+    String(snapshot.type),
+    String(snapshot.blockSize),
+    String(snapshot.blocks),
+    String(snapshot.files),
+    snapshot.error ?? "",
+  ].join("\0");
+}
+
+export function diffMountSnapshots(
+  previous: MountSnapshot,
+  current: MountSnapshot,
+): MountDiff {
+  const prevByPoint = new Map(
+    previous.mounts.map((entry) => [mountIdentity(entry), entry]),
+  );
+  const currentByPoint = new Map(
+    current.mounts.map((entry) => [mountIdentity(entry), entry]),
+  );
+
+  const added: MountInfoEntry[] = [];
+  const removed: MountInfoEntry[] = [];
+  const changed: Array<{ previous: MountInfoEntry; current: MountInfoEntry }> =
+    [];
+
+  for (const [point, entry] of currentByPoint) {
+    const prior = prevByPoint.get(point);
+    if (prior == null) {
+      added.push(entry);
+      continue;
+    }
+    if (mountSignature(prior) !== mountSignature(entry)) {
+      changed.push({ previous: prior, current: entry });
+    }
+  }
+  for (const [point, entry] of prevByPoint) {
+    if (!currentByPoint.has(point)) {
+      removed.push(entry);
+    }
+  }
+
+  const prevPaths = new Map(previous.paths.map((row) => [row.path, row]));
+  const pathChanges: Array<{
+    previous: PathFsSnapshot;
+    current: PathFsSnapshot;
+  }> = [];
+  for (const row of current.paths) {
+    const prior = prevPaths.get(row.path);
+    if (prior != null && pathSignature(prior) !== pathSignature(row)) {
+      pathChanges.push({ previous: prior, current: row });
+    }
+  }
+
+  return { added, removed, changed, pathChanges };
+}
+
+export function mountDiffIsEmpty(diff: MountDiff): boolean {
+  return (
+    diff.added.length === 0 &&
+    diff.removed.length === 0 &&
+    diff.changed.length === 0 &&
+    diff.pathChanges.length === 0
+  );
+}
+
+function defaultReadMountinfo(): string {
+  return readFileSync("/proc/self/mountinfo", "utf8");
+}
+
+function defaultStatPath(path: string): PathFsSnapshot {
+  try {
+    const stats = statfsSync(path);
+    return {
+      path,
+      type: Number(stats.type),
+      blockSize: Number(stats.bsize),
+      blocks: Number(stats.blocks),
+      files: Number(stats.files),
+    };
+  } catch {
+    return {
+      path,
+      type: null,
+      blockSize: null,
+      blocks: null,
+      files: null,
+      error: "statfs-failed",
+    };
+  }
+}
+
+/**
+ * Snapshot the assistant container's watched mounts. Returns null on Windows
+ * and macOS, or when `/proc/self/mountinfo` is unreadable.
+ */
+export function collectMountSnapshot(
+  options: CollectMountSnapshotOptions = {},
+): MountSnapshot | null {
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32" || platform === "darwin") {
+    return null;
+  }
+
+  const watchedMountPoints =
+    options.watchedMountPoints ?? ASSISTANT_VOLUME_MOUNT_POINTS;
+  const readMountinfo = options.readMountinfo ?? defaultReadMountinfo;
+  const statPath = options.statPath ?? defaultStatPath;
+
+  let raw: string;
+  try {
+    raw = readMountinfo();
+  } catch {
+    return null;
+  }
+
+  const mounts = parseMountinfo(raw)
+    .filter((entry) => isWatchedMount(entry, watchedMountPoints))
+    .sort((a, b) => a.mountPoint.localeCompare(b.mountPoint));
+
+  const paths = watchedMountPoints.map((path) => statPath(path));
+
+  return { mounts, paths };
+}
+
+function summarizeEntry(entry: MountInfoEntry): Record<string, string> {
+  return {
+    mountPoint: entry.mountPoint,
+    fsType: entry.fsType,
+    source: entry.source,
+    majorMinor: entry.majorMinor,
+  };
+}
+
+function summarizePath(snapshot: PathFsSnapshot): Record<string, unknown> {
+  return {
+    path: snapshot.path,
+    type: snapshot.type,
+    blockSize: snapshot.blockSize,
+    blocks: snapshot.blocks,
+    files: snapshot.files,
+    ...(snapshot.error != null ? { error: snapshot.error } : {}),
+  };
+}
+
+export function logMountDiff(diff: MountDiff): void {
+  log.warn(
+    {
+      added: diff.added.map(summarizeEntry),
+      removed: diff.removed.map(summarizeEntry),
+      changed: diff.changed.map((row) => ({
+        previous: summarizeEntry(row.previous),
+        current: summarizeEntry(row.current),
+      })),
+      pathChanges: diff.pathChanges.map((row) => ({
+        previous: summarizePath(row.previous),
+        current: summarizePath(row.current),
+      })),
+    },
+    "Assistant container mount table changed",
+  );
+}
+
+/**
+ * Start the mount poller. The first pass establishes a silent baseline so a
+ * healthy boot does not log; later passes warn only when the watched mounts
+ * or `/workspace`/`/data` statfs values change.
+ *
+ * The timer is unref'd: the resource sampler is the monitor process's
+ * keep-alive, and this loop must not extend its life on its own.
+ */
+export function startMountWatch(
+  config: MonitoringConfig,
+  options: CollectMountSnapshotOptions = {},
+): MountWatchHandle {
+  let previous: MountSnapshot | null = null;
+
+  const poll = () => {
+    try {
+      const snapshot = collectMountSnapshot(options);
+      if (snapshot == null) {
+        return;
+      }
+      if (previous != null) {
+        const diff = diffMountSnapshots(previous, snapshot);
+        if (!mountDiffIsEmpty(diff)) {
+          logMountDiff(diff);
+        }
+      }
+      previous = snapshot;
+    } catch (err) {
+      log.warn({ err }, "Mount-watch poll failed");
+    }
+  };
+
+  poll();
+  const timer = setInterval(poll, config.mountWatchIntervalMs);
+  timer.unref?.();
+
+  return {
+    stop: () => clearInterval(timer),
+  };
+}

package/src/monitoring/worker.ts

@@ -49,6 +49,7 @@ import {
   type FileDescriptorMonitorHandle,
   startFileDescriptorMonitor,
 } from "./file-descriptors.js";
+import { type MountWatchHandle, startMountWatch } from "./mount-watch.js";
 import {
   type PluginAutoUpdateHandle,
   startPluginAutoUpdate,
@@ -99,6 +100,7 @@ async function main(): Promise<void> {
 
   let sampler: ResourceSamplerHandle | null = null;
   let fdMonitor: FileDescriptorMonitorHandle | null = null;
+  let mountWatch: MountWatchHandle | null = null;
   let sourceWatch: PluginSourceWatchHandle | null = null;
   let autoUpdate: PluginAutoUpdateHandle | null = null;
   let recovery: RecoveryHandle | null = null;
@@ -125,6 +127,7 @@ async function main(): Promise<void> {
     stopDbIntegritySampler();
     autoUpdate?.stop();
     sourceWatch?.stop();
+    mountWatch?.stop();
     fdMonitor?.stop();
     sampler?.stop();
     // Bounded final telemetry flush, mirroring the daemon's shutdown. This
@@ -170,6 +173,9 @@ async function main(): Promise<void> {
   // Descriptor exhaustion is per-process and slow-moving, so it polls on its
   // own timer rather than riding the memory sampler's 250ms tick.
   fdMonitor = startFileDescriptorMonitor(config.monitoring);
+  // Assistant-container mount table only (this process's mount namespace).
+  // Warns only when /workspace, /data, or a virtiofs bind actually changes.
+  mountWatch = startMountWatch(config.monitoring);
   sourceWatch = startPluginSourceWatch(
     config.monitoring.pluginSourceScanIntervalMs,
   );
@@ -211,6 +217,7 @@ async function main(): Promise<void> {
     recovery?.stop();
     autoUpdate?.stop();
     sourceWatch?.stop();
+    mountWatch?.stop();
     fdMonitor?.stop();
     sampler?.stop();
     stopDbIntegritySampler();
@@ -223,6 +230,7 @@ async function main(): Promise<void> {
     recovery?.stop();
     autoUpdate?.stop();
     sourceWatch?.stop();
+    mountWatch?.stop();
     fdMonitor?.stop();
     sampler?.stop();
     stopDbIntegritySampler();
@@ -234,6 +242,7 @@ async function main(): Promise<void> {
     recovery?.stop();
     autoUpdate?.stop();
     sourceWatch?.stop();
+    mountWatch?.stop();
     fdMonitor?.stop();
     sampler?.stop();
     stopDbIntegritySampler();

package/src/notifications/__tests__/decision-engine.test.ts

@@ -736,3 +736,178 @@ describe("schedule.result pass-through in notification decision engine", () => {
     expect(decision.shouldNotify).toBe(true);
   });
 });
+
+const SCHEDULER_OWNED_REPORT = [
+  "# Daily briefing",
+  "",
+  "## Overnight",
+  "- Calendar is clear until 10:00.",
+  "- Two pull requests are waiting on review.",
+  "",
+  "## Account security",
+  "- Urgent: a sign-in from a new device needs confirmation before the weekly sync.",
+  "",
+  "## This week",
+  "- Project kickoff on Wednesday.",
+  "- Weekly planning on Friday.",
+  "- Follow up on the draft status update.",
+].join("\n");
+
+function makeSchedulerShareSignal(
+  overrides?: Partial<NotificationSignal>,
+): NotificationSignal {
+  return {
+    signalId: "sig-scheduler-share-test-1",
+    createdAt: Date.now(),
+    sourceChannel: "scheduler",
+    sourceContextId: "conv-xyz",
+    sourceEventName: "assistant.share",
+    contextPayload: {
+      requestedMessage: SCHEDULER_OWNED_REPORT,
+      requestedBySource: "scheduler",
+      requestedTitle: "Your day",
+    },
+    attentionHints: {
+      requiresAction: true,
+      urgency: "high",
+      isAsyncBackground: true,
+      visibleInSourceNow: false,
+    },
+    ...overrides,
+  };
+}
+
+describe("scheduler requested-message pass-through in notification decision engine", () => {
+  beforeEach(() => {
+    persistedDecisions = [];
+  });
+
+  test("keeps a scheduler-owned report verbatim on every urgency-selected channel", async () => {
+    const available = [
+      "vellum",
+      "telegram",
+      "platform",
+    ] as NotificationChannel[];
+    const decision = await evaluateSignal(
+      makeSchedulerShareSignal(),
+      available,
+    );
+
+    expect(decision.shouldNotify).toBe(true);
+    expect(decision.selectedChannels).toEqual(available);
+    expect(decision.reasoningSummary).toBe(
+      "scheduler requested-message pass-through",
+    );
+    expect(decision.verbatimCopy).toBe(true);
+    expect(decision.fallbackUsed).toBe(false);
+    for (const ch of available) {
+      expect(decision.renderedCopy[ch]?.title).toBe("Your day");
+      expect(decision.renderedCopy[ch]?.body).toBe(SCHEDULER_OWNED_REPORT);
+      expect(decision.renderedCopy[ch]?.conversationSeedMessage).toBe(
+        SCHEDULER_OWNED_REPORT,
+      );
+    }
+  });
+
+  test("copies the complete report onto the urgency-narrowed channel set", async () => {
+    const available = [
+      "vellum",
+      "telegram",
+      "platform",
+    ] as NotificationChannel[];
+    const decision = await evaluateSignal(
+      makeSchedulerShareSignal({
+        attentionHints: {
+          requiresAction: false,
+          urgency: "medium",
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+      }),
+      available,
+    );
+
+    expect(decision.shouldNotify).toBe(true);
+    expect(decision.selectedChannels).toEqual(["vellum"]);
+    expect(decision.reasoningSummary).toBe(
+      "scheduler requested-message pass-through",
+    );
+    expect(decision.renderedCopy.vellum?.body).toBe(SCHEDULER_OWNED_REPORT);
+    expect(decision.renderedCopy.vellum?.conversationSeedMessage).toBe(
+      SCHEDULER_OWNED_REPORT,
+    );
+    expect(decision.renderedCopy.telegram?.body).toBe(SCHEDULER_OWNED_REPORT);
+    expect(decision.renderedCopy.platform?.body).toBe(SCHEDULER_OWNED_REPORT);
+  });
+
+  test("leaves an unowned scheduler requestedMessage on the model path", async () => {
+    const previousSendMessage = providerSendMessage;
+    let providerCalled = false;
+    providerSendMessage = async () => {
+      providerCalled = true;
+      return {};
+    };
+
+    try {
+      const decision = await evaluateSignal(
+        makeSchedulerShareSignal({
+          contextPayload: {
+            requestedMessage: SCHEDULER_OWNED_REPORT,
+            requestedTitle: "Your day",
+          },
+        }),
+        ["vellum", "telegram", "platform"] as NotificationChannel[],
+      );
+
+      expect(providerCalled).toBe(true);
+      expect(decision.verbatimCopy).toBeUndefined();
+      expect(decision.reasoningSummary).not.toBe(
+        "scheduler requested-message pass-through",
+      );
+    } finally {
+      providerSendMessage = previousSendMessage;
+    }
+  });
+
+  test("leaves scheduler notify-mode without the ownership marker on the model path", async () => {
+    const previousSendMessage = providerSendMessage;
+    let providerCalled = false;
+    providerSendMessage = async () => {
+      providerCalled = true;
+      return {};
+    };
+
+    try {
+      const decision = await evaluateSignal(
+        {
+          signalId: "sig-schedule-notify-test-1",
+          createdAt: Date.now(),
+          sourceChannel: "scheduler",
+          sourceContextId: "sched-notify-1",
+          sourceEventName: "schedule.notify",
+          contextPayload: {
+            scheduleId: "sched-notify-1",
+            label: "Take out the trash",
+            message: "Take out the trash",
+          },
+          attentionHints: {
+            requiresAction: true,
+            urgency: "high",
+            isAsyncBackground: false,
+            visibleInSourceNow: false,
+          },
+        },
+        ["vellum", "telegram", "platform"] as NotificationChannel[],
+      );
+
+      expect(providerCalled).toBe(true);
+      expect(decision.verbatimCopy).toBeUndefined();
+      expect(decision.reasoningSummary).not.toBe(
+        "scheduler requested-message pass-through",
+      );
+      expect(decision.reasoningSummary).not.toBe("schedule_result pass-through");
+    } finally {
+      providerSendMessage = previousSendMessage;
+    }
+  });
+});

package/src/notifications/decision-engine.ts

@@ -833,6 +833,19 @@ function buildPassThroughDecision(params: {
   return decision;
 }
 
+function selectDefaultChannelsByUrgency(
+  urgency: NotificationSignal["attentionHints"]["urgency"],
+  availableChannels: NotificationChannel[],
+): NotificationChannel[] {
+  const isUrgent = urgency === "critical" || urgency === "high";
+  if (isUrgent) {
+    return [...availableChannels];
+  }
+  return availableChannels.includes("vellum")
+    ? ["vellum" as NotificationChannel]
+    : [];
+}
+
 /**
  * The deterministic guards every decision passes through once the model,
  * the assistant-tool pass-through, or the fallback has rendered copy.
@@ -870,14 +883,10 @@ export async function evaluateSignal(
   );
   if (signal.sourceChannel === "assistant_tool" && requestedBody) {
     const payload = signal.contextPayload as Record<string, unknown>;
-    const isUrgent =
-      signal.attentionHints.urgency === "critical" ||
-      signal.attentionHints.urgency === "high";
-    const defaultChannels: NotificationChannel[] = isUrgent
-      ? [...availableChannels]
-      : availableChannels.includes("vellum")
-        ? ["vellum" as NotificationChannel]
-        : [];
+    const defaultChannels = selectDefaultChannelsByUrgency(
+      signal.attentionHints.urgency,
+      availableChannels,
+    );
     // Honor `--preferred-channels` as ADDITIVE push targets on top of
     // the default channel set. The notification center (vellum) is the
     // always-on canonical inbox; preferred channels add push surfaces
@@ -926,6 +935,32 @@ export async function evaluateSignal(
     });
   }
 
+  // Scheduler-owned requested copy: the scheduler already authored the
+  // complete message. Ownership requires both the signal source and the
+  // payload marker so schedule.result (requestedMessage, no
+  // requestedBySource) and notify-mode (message, no requestedBySource)
+  // stay on their existing paths. Urgency still chooses channels; every
+  // selected channel keeps the producer body.
+  const requestedBySource = nonEmpty(
+    readPayloadString(signal.contextPayload, "requestedBySource"),
+  );
+  if (
+    signal.sourceChannel === "scheduler" &&
+    requestedBySource === "scheduler" &&
+    requestedBody
+  ) {
+    return buildPassThroughDecision({
+      signal,
+      availableChannels,
+      selectedChannels: selectDefaultChannelsByUrgency(
+        signal.attentionHints.urgency,
+        availableChannels,
+      ),
+      body: requestedBody,
+      reasoningSummary: "scheduler requested-message pass-through",
+    });
+  }
+
   // Schedule-result pass-through: the body is the run's own reply, which is
   // the whole point of the notification — a briefing, a digest, a report. The
   // classifier rewrites bodies into short alerts, which would throw away the

package/src/oauth/seed-providers.ts

@@ -1403,6 +1403,12 @@ export const PROVIDER_SEED_DATA: Record<
       "read_discounts",
       "write_discounts",
       "read_price_rules",
+      // write_themes covers listing, duplicating, and publishing themes.
+      // Writing theme files (settings, JSON templates, Liquid) also requires
+      // Shopify's theme-code exemption on the app itself, which is granted
+      // per app in the Shopify dashboard rather than through a scope.
+      "read_themes",
+      "write_themes",
     ],
     availableScopes: [
       {
@@ -1455,6 +1461,11 @@ export const PROVIDER_SEED_DATA: Record<
         scope: "write_price_rules",
         description: "Create and update price rules",
       },
+      { scope: "read_themes", description: "Read themes and theme files" },
+      {
+        scope: "write_themes",
+        description: "Create, publish, and edit themes and theme files",
+      },
       { scope: "read_files", description: "Read files uploaded to the store" },
       { scope: "write_files", description: "Upload and update files" },
       { scope: "read_gift_cards", description: "Read gift cards" },

package/src/onboarding/checkin-event.ts

@@ -69,7 +69,8 @@ export function buildCheckinTitle({
  * Google Calendar strips nearly all styling, so the body relies only on the
  * tags that survive (`<p>`, `<strong>`, `<a>`, emoji) and makes the CTA a bold
  * link rather than a styled button. The deep link opens a fresh conversation
- * (`uuid`) pre-seeded with the first-week prompt.
+ * (`uuid`) with the first-week prompt staged in the composer; the user sends
+ * it. A clicked link never auto-sends (`clients/web/src/utils/auto-send-prompt.ts`).
  */
 export function buildCheckinDescription(uuid: string): string {
   // `vref` is an app-owned attribution param, NOT a marketing `utm_*`: the