@vellumai/assistant 0.8.4 → 0.8.6

package/src/runtime/verification-outbound-actions.ts

@@ -234,12 +234,20 @@ export async function startOutbound(
       params.rebind,
       originConversationId,
     );
+  } else if (channel === "email") {
+    return startOutboundEmail(
+      params.destination,
+      assistantId,
+      channel,
+      params.rebind,
+      originConversationId,
+    );
   }
 
   return {
     success: false,
     error: "unsupported_channel",
-    message: `Outbound verification is only supported for Telegram, phone, and Slack. Got: ${channel}`,
+    message: `Outbound verification is not supported for ${channel}. Supported channels: Telegram, phone, Slack, email.`,
     channel,
   };
 }
@@ -582,6 +590,70 @@ function startOutboundSlack(
   };
 }
 
+function startOutboundEmail(
+  destination: string | undefined,
+  assistantId: string,
+  channel: ChannelId,
+  rebind?: boolean,
+  originConversationId?: string,
+): OutboundActionResult {
+  if (!destination) {
+    return {
+      success: false,
+      error: "missing_destination",
+      message:
+        "An email address is required for outbound email verification.",
+      channel,
+    };
+  }
+
+  const normalizedEmail = destination.trim().toLowerCase();
+
+  const existingBinding = getGuardianBinding(assistantId, channel);
+  if (existingBinding && !rebind) {
+    return {
+      success: false,
+      error: "already_bound",
+      message:
+        "A guardian is already bound for this channel. Set rebind: true to replace.",
+      channel,
+    };
+  }
+
+  const recentSendCount = countRecentSendsToDestination(
+    channel,
+    normalizedEmail,
+    DESTINATION_RATE_WINDOW_MS,
+  );
+  if (recentSendCount >= MAX_SENDS_PER_DESTINATION_WINDOW) {
+    return {
+      success: false,
+      error: "rate_limited",
+      message:
+        "Too many verification attempts to this email address. Please try again later.",
+      channel,
+    };
+  }
+
+  const sessionResult = createOutboundSession({
+    channel,
+    expectedExternalUserId: normalizedEmail,
+    expectedChatId: normalizedEmail,
+    identityBindingStatus: "bound",
+    destinationAddress: normalizedEmail,
+    verificationPurpose: "guardian",
+  });
+
+  return {
+    success: true,
+    verificationSessionId: sessionResult.sessionId,
+    secret: sessionResult.secret,
+    expiresAt: sessionResult.expiresAt,
+    channel,
+    originConversationId,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Resend outbound
 // ---------------------------------------------------------------------------

package/src/schedule/schedule-store.ts

@@ -17,6 +17,13 @@ const logger = getLogger("schedule-store");
 
 function notifySchedulesChanged(): void {
   publishSchedulesChanged();
+  void import("../background-wake/publisher.js")
+    .then(({ refreshBackgroundWakeIntent }) =>
+      refreshBackgroundWakeIntent("schedule-changed"),
+    )
+    .catch((err) =>
+      logger.warn({ err }, "Failed to queue background wake refresh"),
+    );
 }
 
 export type ScheduleMode = "notify" | "execute" | "script" | "wake";
@@ -124,7 +131,7 @@ export function createSchedule(params: {
   const routingIntent = params.routingIntent ?? "all_channels";
   const routingHints = params.routingHints ?? {};
   const quiet = params.quiet ?? false;
-  const reuseConversation = params.reuseConversation ?? false;
+  const reuseConversation = params.reuseConversation ?? !isOneShot;
   const maxRetries = params.maxRetries ?? 3;
   const retryBackoffMs = params.retryBackoffMs ?? 60000;
 

package/src/schedule/scheduler.ts

@@ -22,6 +22,7 @@ import {
   createScheduleRun,
   failOneShotPermanently,
   getLastScheduleConversationId,
+  listSchedules,
   resetRetryCount,
   retryOneShot,
   type RoutingIntent,
@@ -48,9 +49,27 @@ type ScheduleConversationCreatedNotifier = (info: {
 
 export interface SchedulerHandle {
   runOnce(): Promise<number>;
+  runDueWorkOnce(
+    options?: SchedulerRunDueWorkOptions,
+  ): Promise<SchedulerDueWorkResult>;
   stop(): void;
 }
 
+export interface SchedulerRunDueWorkOptions {
+  now?: number;
+  deadlineAt?: number;
+  minStartBudgetMs?: number;
+  includeStillPending?: boolean;
+}
+
+export interface SchedulerDueWorkResult {
+  claimed: number;
+  completed: number;
+  failed: number;
+  skipped: number;
+  stillPending: number;
+}
+
 const TICK_INTERVAL_MS = 15_000;
 
 /**
@@ -140,6 +159,17 @@ export function startScheduler(
         onScheduleConversationCreated,
       );
     },
+    async runDueWorkOnce(
+      options?: SchedulerRunDueWorkOptions,
+    ): Promise<SchedulerDueWorkResult> {
+      return runScheduleDueWorkOnce(
+        processMessage,
+        notifyScheduleOneShot,
+        watcherNotifier,
+        onScheduleConversationCreated,
+        options,
+      );
+    },
     stop(): void {
       stopped = true;
       clearInterval(timer);
@@ -153,8 +183,45 @@ export async function runScheduleOnce(
   watcherNotifier?: WatcherNotifier,
   onScheduleConversationCreated?: ScheduleConversationCreatedNotifier,
 ): Promise<number> {
-  const now = Date.now();
-  let processed = 0;
+  const result = await runScheduleDueWorkOnce(
+    processMessage,
+    notifyScheduleOneShot,
+    watcherNotifier,
+    onScheduleConversationCreated,
+  );
+  return result.completed + result.failed + result.skipped;
+}
+
+export async function runScheduleDueWorkOnce(
+  processMessage: ScheduleMessageProcessor,
+  notifyScheduleOneShot: ScheduleNotifyModeNotifier,
+  watcherNotifier?: WatcherNotifier,
+  onScheduleConversationCreated?: ScheduleConversationCreatedNotifier,
+  options: SchedulerRunDueWorkOptions = {},
+): Promise<SchedulerDueWorkResult> {
+  const now = options.now ?? Date.now();
+  const minStartBudgetMs = options.minStartBudgetMs ?? 0;
+  const result: SchedulerDueWorkResult = {
+    claimed: 0,
+    completed: 0,
+    failed: 0,
+    skipped: 0,
+    stillPending: 0,
+  };
+  const mark = (status: "completed" | "failed" | "skipped") => {
+    result[status] += 1;
+  };
+
+  if (
+    options.deadlineAt != null &&
+    options.deadlineAt - Date.now() < minStartBudgetMs
+  ) {
+    result.stillPending = options.includeStillPending
+      ? countDueScheduleJobs(now)
+      : 0;
+    result.skipped = result.stillPending;
+    return result;
+  }
 
   const diskPressureGate = checkDiskPressureBackgroundGate("background-work");
   if (diskPressureGate.action === "skip") {
@@ -167,16 +234,21 @@ export async function runScheduleOnce(
         "Schedule tick skipped during disk pressure cleanup mode",
       );
     }
-    return 0;
+    result.stillPending = options.includeStillPending
+      ? countDueScheduleJobs(now)
+      : 0;
+    return result;
   }
 
   // ── Schedules (recurring cron/RRULE + one-shot) ─────────────────────
   const jobs = claimDueSchedules(now);
+  result.claimed = jobs.length;
   for (const job of jobs) {
     const isOneShot = job.expression == null;
 
     // ── Notify mode (one-shot or recurring) ─────────────────────────
     if (job.mode === "notify") {
+      let failed = false;
       try {
         log.info(
           { jobId: job.id, name: job.name, isOneShot },
@@ -208,8 +280,9 @@ export async function runScheduleOnce(
         const errorRunId = createScheduleRun(job.id, `notify-error:${job.id}`);
         completeScheduleRun(errorRunId, { status: "error", error: errorMsg });
         handleExecutionFailure({ job, errorMsg, isOneShot });
+        failed = true;
       }
-      processed += 1;
+      mark(failed ? "failed" : "completed");
       continue;
     }
 
@@ -220,10 +293,11 @@ export async function runScheduleOnce(
           { jobId: job.id, name: job.name },
           "Script schedule has no script command — skipping",
         );
-        processed += 1;
+        mark("skipped");
         continue;
       }
       const runId = createScheduleRun(job.id, `script:${job.id}`);
+      let failed = false;
       try {
         log.info(
           { jobId: job.id, name: job.name, isOneShot },
@@ -241,6 +315,7 @@ export async function runScheduleOnce(
           const errorMsg =
             result.stderr || "Script exited with non-zero status";
           handleExecutionFailure({ job, errorMsg, isOneShot });
+          failed = true;
         }
       } catch (err) {
         const errorMsg = err instanceof Error ? err.message : String(err);
@@ -250,8 +325,9 @@ export async function runScheduleOnce(
         );
         completeScheduleRun(runId, { status: "error", error: errorMsg });
         handleExecutionFailure({ job, errorMsg, isOneShot });
+        failed = true;
       }
-      processed += 1;
+      mark(failed ? "failed" : "completed");
       continue;
     }
 
@@ -264,10 +340,11 @@ export async function runScheduleOnce(
           "Wake schedule missing wakeConversationId — completing as no-op",
         );
         if (isOneShot) completeOneShot(job.id);
-        processed += 1;
+        mark("skipped");
         continue;
       }
 
+      let failed = false;
       try {
         log.info(
           { jobId: job.id, name: job.name, wakeConversationId, isOneShot },
@@ -305,7 +382,7 @@ export async function runScheduleOnce(
             );
             retryOneShot(job.id);
           }
-          processed += 1;
+          mark("skipped");
           continue;
         }
 
@@ -323,7 +400,7 @@ export async function runScheduleOnce(
             "Wake not invoked; skipping feed event",
           );
           if (isOneShot) completeOneShot(job.id);
-          processed += 1;
+          mark("skipped");
           continue;
         }
 
@@ -347,8 +424,9 @@ export async function runScheduleOnce(
           error: errorMsg,
         });
         handleExecutionFailure({ job, errorMsg, isOneShot });
+        failed = true;
       }
-      processed += 1;
+      mark(failed ? "failed" : "completed");
       continue;
     }
 
@@ -362,6 +440,7 @@ export async function runScheduleOnce(
         job.syntax === "rrule" &&
         job.expression != null &&
         hasSetConstructs(job.expression);
+      let failed = false;
       try {
         log.info(
           {
@@ -415,11 +494,11 @@ export async function runScheduleOnce(
             errorMsg: errorMessage,
             isOneShot,
           });
+          failed = true;
         } else {
           completeScheduleRun(runId, { status: "ok" });
           if (isOneShot) completeOneShot(job.id);
         }
-        processed += 1;
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         log.warn(
@@ -461,7 +540,9 @@ export async function runScheduleOnce(
           errorMsg: message,
           isOneShot,
         });
+        failed = true;
       }
+      mark(failed ? "failed" : "completed");
       continue;
     }
 
@@ -567,7 +648,7 @@ export async function runScheduleOnce(
     if (ok) {
       completeScheduleRun(runId, { status: "ok" });
       if (isOneShot) completeOneShot(job.id);
-      processed += 1;
+      mark("completed");
     } else {
       log.warn(
         {
@@ -605,6 +686,7 @@ export async function runScheduleOnce(
           );
         }
       }
+      mark("failed");
     }
   }
 
@@ -612,7 +694,7 @@ export async function runScheduleOnce(
   if (watcherNotifier) {
     try {
       const watcherProcessed = await runWatchersOnce(watcherNotifier);
-      processed += watcherProcessed;
+      result.completed += watcherProcessed;
     } catch (err) {
       log.error({ err }, "Watcher tick failed");
     }
@@ -621,15 +703,29 @@ export async function runScheduleOnce(
   // ── Sequences (multi-step outreach) ──────────────────────────────
   try {
     const sequenceProcessed = await runSequencesOnce();
-    processed += sequenceProcessed;
+    result.completed += sequenceProcessed;
   } catch (err) {
     log.error({ err }, "Sequence engine tick failed");
   }
 
+  if (options.includeStillPending) {
+    result.stillPending = countDueScheduleJobs(Date.now());
+  }
+  const processed = result.completed + result.failed + result.skipped;
   if (processed > 0) {
     log.info({ processed }, "Schedule tick complete");
   }
-  return processed;
+  return result;
+}
+
+function countDueScheduleJobs(now: number): number {
+  return listSchedules({ enabledOnly: true }).filter(
+    (job) =>
+      job.status === "active" &&
+      Number.isFinite(job.nextRunAt) &&
+      job.nextRunAt > 0 &&
+      job.nextRunAt <= now,
+  ).length;
 }
 
 /**

package/src/security/__tests__/provider-key-env-fallback.test.ts

@@ -27,7 +27,7 @@ mock.module("../../util/logger.js", () => ({
 // Imports under test
 // ---------------------------------------------------------------------------
 
-import { _setStorePath } from "../encrypted-store.js";
+import { setStorePathForTesting } from "../../__tests__/encrypted-store-test-helpers.js";
 import { _resetBackend, getProviderKeyAsync } from "../secure-keys.js";
 
 const TEST_DIR = join(
@@ -61,7 +61,7 @@ describe("getProviderKeyAsync env-var fallback (regression #27126)", () => {
     // Fresh encrypted store (no saved credentials → forces env-var fallback).
     if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
     mkdirSync(TEST_DIR, { recursive: true });
-    _setStorePath(STORE_PATH);
+    setStorePathForTesting(STORE_PATH);
     _resetBackend();
 
     // Snapshot env so each test starts clean.
@@ -72,7 +72,7 @@ describe("getProviderKeyAsync env-var fallback (regression #27126)", () => {
   });
 
   afterEach(() => {
-    _setStorePath(null);
+    setStorePathForTesting(null);
     _resetBackend();
     for (const name of MANAGED_VARS) {
       const saved = SAVED_ENV[name];

package/src/security/encrypted-store.ts

@@ -31,6 +31,10 @@ import { getIsContainerized } from "../config/env-registry.js";
 import { ensureDir, pathExists } from "../util/fs.js";
 import { getLogger } from "../util/logger.js";
 import { getPlatformName, getProtectedDir } from "../util/platform.js";
+import {
+  getStoreKeyPathOverride,
+  getStorePathOverride,
+} from "./store-path-override.js";
 
 const log = getLogger("encrypted-store");
 
@@ -77,15 +81,8 @@ interface EncryptedEntry {
 // Paths
 // ---------------------------------------------------------------------------
 
-let storePathOverride: string | null = null;
-
 function getStorePath(): string {
-  return storePathOverride ?? join(getProtectedDir(), "keys.enc");
-}
-
-/** @internal Test-only: override the store file path. Pass `null` to reset. */
-export function _setStorePath(path: string | null): void {
-  storePathOverride = path;
+  return getStorePathOverride() ?? join(getProtectedDir(), "keys.enc");
 }
 
 // ---------------------------------------------------------------------------
@@ -95,16 +92,10 @@ export function _setStorePath(path: string | null): void {
 const STORE_KEY_FILENAME = "store.key";
 const STORE_KEY_LENGTH = 32; // bytes
 
-let storeKeyPathOverride: string | null = null;
-
-/** @internal Test-only: override the store key file path. Pass `null` to reset. */
-export function _setStoreKeyPath(path: string | null): void {
-  storeKeyPathOverride = path;
-}
-
 function getStoreKeyPath(): string {
   return (
-    storeKeyPathOverride ?? join(dirname(getStorePath()), STORE_KEY_FILENAME)
+    getStoreKeyPathOverride() ??
+    join(dirname(getStorePath()), STORE_KEY_FILENAME)
   );
 }
 

package/src/security/store-path-override.ts

@@ -0,0 +1,61 @@
+/**
+ * Holds optional path overrides for the encrypted credential store.
+ *
+ * Lives in its own module (rather than alongside the crypto code in
+ * `encrypted-store.ts`) so test code can install/clear overrides without
+ * importing `encrypted-store.ts` — which transitively pulls
+ * `util/logger.js` (pino). Stdlib-only by design: this file must remain
+ * safe to import from the test preload's load-time chain, where a broken
+ * `node_modules` symlink has historically tripped the env override
+ * (see DB ghost #3, /workspace/journal/2026-05-25-db-ghost-3-recovery.md).
+ *
+ * State is held on `globalThis.vellumAssistant.storePathOverride` so
+ * test helpers in `__tests__/` can read/write it WITHOUT importing this
+ * module — they declare the same slot shape locally and access the
+ * globalThis namespace directly. See
+ * `__tests__/encrypted-store-test-helpers.ts` for the test-side mirror;
+ * the slot shape MUST stay in sync between the two.
+ *
+ * Note: the new test preload places `VELLUM_WORKSPACE_DIR` at
+ * `<tmpRoot>/workspace`, so `getProtectedDir()` resolves to
+ * `<tmpRoot>/protected` naturally — most tests no longer need an explicit
+ * override. The setters here exist for the small set of tests that
+ * exercise specific path scenarios (env-var fallbacks, migration, etc.).
+ *
+ * Consumers:
+ *   - `encrypted-store.ts` (reads the override when computing paths)
+ *   - `__tests__/encrypted-store-test-helpers.ts` (writes for tests, via globalThis)
+ */
+
+type PathSlot = {
+  storePath: string | null;
+  storeKeyPath: string | null;
+};
+
+type VellumAssistantNamespace = {
+  storePathOverride?: PathSlot;
+};
+
+function slot(): PathSlot {
+  const g = globalThis as { vellumAssistant?: VellumAssistantNamespace };
+  const ns = (g.vellumAssistant ??= {});
+  return (ns.storePathOverride ??= { storePath: null, storeKeyPath: null });
+}
+
+export function getStorePathOverride(): string | null {
+  return slot().storePath;
+}
+
+/** Pass `null` to reset to the default (`<protectedDir>/keys.enc`). */
+export function setStorePathOverride(path: string | null): void {
+  slot().storePath = path;
+}
+
+export function getStoreKeyPathOverride(): string | null {
+  return slot().storeKeyPath;
+}
+
+/** Pass `null` to reset to the default (`<dirname(storePath)>/store.key`). */
+export function setStoreKeyPathOverride(path: string | null): void {
+  slot().storeKeyPath = path;
+}

package/src/signals/user-message.ts

@@ -120,20 +120,17 @@ async function dispatchUserMessage(params: {
     const requestId = crypto.randomUUID();
     const resolvedChannel = resolveTurnChannel(params.sourceChannel);
     const resolvedInterface = resolveTurnInterface(params.sourceInterface);
-    const result = conversation.enqueueMessage(
-      params.content,
-      resolvedAttachments,
-      undefined,
+    const result = conversation.enqueueMessage({
+      content: params.content,
+      attachments: resolvedAttachments,
       requestId,
-      undefined,
-      undefined,
-      {
+      metadata: {
         userMessageChannel: resolvedChannel,
         assistantMessageChannel: resolvedChannel,
         userMessageInterface: resolvedInterface,
         assistantMessageInterface: resolvedInterface,
       },
-    );
+    });
     return { accepted: !result.rejected };
   }