@vellumai/assistant 0.7.1 → 0.7.3

package/src/schedule/schedule-store.ts

@@ -33,6 +33,8 @@ export interface ScheduleJob {
   lastRunAt: number | null;
   lastStatus: string | null;
   retryCount: number;
+  maxRetries: number;
+  retryBackoffMs: number;
   createdBy: string;
   mode: ScheduleMode;
   routingIntent: RoutingIntent;
@@ -83,6 +85,8 @@ export function createSchedule(params: {
   routingHints?: Record<string, unknown>;
   quiet?: boolean;
   reuseConversation?: boolean;
+  maxRetries?: number;
+  retryBackoffMs?: number;
 }): ScheduleJob {
   const expression = params.expression ?? params.cronExpression ?? null;
   const isOneShot = expression == null;
@@ -116,6 +120,8 @@ export function createSchedule(params: {
   const routingHints = params.routingHints ?? {};
   const quiet = params.quiet ?? false;
   const reuseConversation = params.reuseConversation ?? false;
+  const maxRetries = params.maxRetries ?? 3;
+  const retryBackoffMs = params.retryBackoffMs ?? 60000;
 
   let nextRunAt: number;
   if (isOneShot) {
@@ -140,6 +146,8 @@ export function createSchedule(params: {
     lastRunAt: null as number | null,
     lastStatus: null as string | null,
     retryCount: 0,
+    maxRetries,
+    retryBackoffMs,
     createdBy: params.createdBy ?? "agent",
     mode,
     routingIntent,
@@ -235,6 +243,8 @@ export function updateSchedule(
     quiet?: boolean;
     reuseConversation?: boolean;
     wakeConversationId?: string | null;
+    maxRetries?: number;
+    retryBackoffMs?: number;
   },
 ): ScheduleJob | null {
   const db = getDb();
@@ -257,12 +267,13 @@ export function updateSchedule(
 
   const isOneShot = newExpr == null;
 
-  // Validate if expression or syntax changed (only for recurring schedules)
+  // Validate if expression, syntax, or timezone changed (only for recurring schedules)
   if (
     !isOneShot &&
     (updates.expression !== undefined ||
       updates.cronExpression !== undefined ||
-      updates.syntax !== undefined)
+      updates.syntax !== undefined ||
+      updates.timezone !== undefined)
   ) {
     const spec = {
       syntax: newSyntax,
@@ -295,6 +306,9 @@ export function updateSchedule(
     set.reuseConversation = updates.reuseConversation;
   if (updates.wakeConversationId !== undefined)
     set.wakeConversationId = updates.wakeConversationId;
+  if (updates.maxRetries !== undefined) set.maxRetries = updates.maxRetries;
+  if (updates.retryBackoffMs !== undefined)
+    set.retryBackoffMs = updates.retryBackoffMs;
 
   // Recompute nextRunAt if schedule timing may have changed (only for recurring)
   if (
@@ -817,6 +831,94 @@ export function describeCronExpression(expr: string | null): string {
   }
 }
 
+/**
+ * Set the next retry time for a schedule and revert one-shot status from
+ * "firing" to "active" so the scheduler will claim it again when nextRetryAt
+ * arrives. No-op for recurring schedules (they stay in their current status).
+ */
+export function scheduleRetry(id: string, nextRetryAt: number): void {
+  const db = getDb();
+  const now = Date.now();
+  db.update(scheduleJobs)
+    .set({ nextRunAt: nextRetryAt, updatedAt: now })
+    .where(eq(scheduleJobs.id, id))
+    .run();
+  // Revert one-shot status from "firing" to "active" so the scheduler
+  // will claim it again when nextRetryAt arrives. No-op for recurring.
+  db.update(scheduleJobs)
+    .set({ status: "active", updatedAt: now })
+    .where(and(eq(scheduleJobs.id, id), eq(scheduleJobs.status, "firing")))
+    .run();
+}
+
+/**
+ * Reset the retry count for a schedule back to zero (e.g. after a successful run).
+ */
+export function resetRetryCount(id: string): void {
+  const db = getDb();
+  db.update(scheduleJobs)
+    .set({ retryCount: 0, updatedAt: Date.now() })
+    .where(eq(scheduleJobs.id, id))
+    .run();
+}
+
+/**
+ * Find schedules stuck in an in-flight state (one-shots in "firing",
+ * cron runs in "running"). Used at daemon startup to recover from
+ * a prior process crash.
+ *
+ * @param staleThresholdMs If >0, only consider rows whose lastRunAt
+ *   (for one-shots) or startedAt (for runs) is older than `now - staleThresholdMs`.
+ *   Pass 0 at startup (the previous process is definitely dead).
+ */
+export function findStaleInFlightJobs(staleThresholdMs: number = 0): Array<{
+  jobId: string;
+  staleRunId: string | null;
+}> {
+  const db = getDb();
+  const cutoff = Date.now() - staleThresholdMs;
+
+  // One-shots stuck in "firing" where lastRunAt is older than cutoff
+  const staleOneShots = db
+    .select({ id: scheduleJobs.id })
+    .from(scheduleJobs)
+    .where(
+      and(
+        isNull(scheduleJobs.cronExpression),
+        eq(scheduleJobs.status, "firing"),
+        eq(scheduleJobs.enabled, true),
+        staleThresholdMs > 0 ? lte(scheduleJobs.lastRunAt, cutoff) : undefined,
+      ),
+    )
+    .all();
+
+  // Cron runs stuck in "running" where startedAt is older than cutoff
+  const staleRuns = db
+    .select({ id: scheduleRuns.id, jobId: scheduleRuns.jobId })
+    .from(scheduleRuns)
+    .where(
+      and(
+        eq(scheduleRuns.status, "running"),
+        staleThresholdMs > 0 ? lte(scheduleRuns.startedAt, cutoff) : undefined,
+      ),
+    )
+    .all();
+
+  const result: Array<{ jobId: string; staleRunId: string | null }> = [];
+  const seenJobIds = new Set<string>();
+
+  for (const run of staleRuns) {
+    result.push({ jobId: run.jobId, staleRunId: run.id });
+    seenJobIds.add(run.jobId);
+  }
+  for (const job of staleOneShots) {
+    if (!seenJobIds.has(job.id)) {
+      result.push({ jobId: job.id, staleRunId: null });
+    }
+  }
+  return result;
+}
+
 function parseJobRow(row: typeof scheduleJobs.$inferSelect): ScheduleJob {
   return {
     id: row.id,
@@ -833,6 +935,8 @@ function parseJobRow(row: typeof scheduleJobs.$inferSelect): ScheduleJob {
     lastRunAt: row.lastRunAt,
     lastStatus: row.lastStatus,
     retryCount: row.retryCount,
+    maxRetries: row.maxRetries ?? 3,
+    retryBackoffMs: row.retryBackoffMs ?? 60000,
     createdBy: row.createdBy,
     mode: (row.mode ?? "execute") as ScheduleMode,
     routingIntent: (row.routingIntent ?? "all_channels") as RoutingIntent,

package/src/schedule/scheduler-types.ts

@@ -0,0 +1,25 @@
+/**
+ * Types extracted from scheduler.ts to break the scheduler ↔ engine cycle.
+ * `sequence/engine.ts` needs `ScheduleMessageProcessor` but scheduler.ts
+ * imports from engine — extracting the type here breaks the back-edge.
+ */
+
+import type { LLMCallSite } from "../config/schemas/llm.js";
+
+export interface ScheduleMessageOptions {
+  trustClass?: "guardian" | "trusted_contact" | "unknown";
+  taskRunId?: string;
+  /**
+   * Optional LLM call-site identifier propagated to the per-call provider
+   * config. Schedule and sequence callers will start passing their own call-site
+   * (e.g. for a future scheduled-agent profile) once PRs 7-11 migrate them off
+   * the default `mainAgent` route.
+   */
+  callSite?: LLMCallSite;
+}
+
+export type ScheduleMessageProcessor = (
+  conversationId: string,
+  message: string,
+  options?: ScheduleMessageOptions,
+) => Promise<unknown>;

package/src/schedule/scheduler.ts

@@ -1,4 +1,8 @@
-import type { LLMCallSite } from "../config/schemas/llm.js";
+import {
+  checkDiskPressureBackgroundGate,
+  diskPressureBackgroundSkipLogFields,
+  shouldLogDiskPressureBackgroundSkip,
+} from "../daemon/disk-pressure-background-gate.js";
 import { emitFeedEvent } from "../home/emit-feed-event.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { getConversation } from "../memory/conversation-crud.js";
@@ -12,40 +16,26 @@ import {
   type WatcherNotifier,
 } from "../watcher/engine.js";
 import { hasSetConstructs } from "./recurrence-engine.js";
+import { applyRetryDecision, decideRetry } from "./retry-policy.js";
 import { runScript, type ScriptResult } from "./run-script.js";
 import {
   claimDueSchedules,
   completeOneShot,
   completeScheduleRun,
   createScheduleRun,
-  failOneShot,
   failOneShotPermanently,
   getLastScheduleConversationId,
+  resetRetryCount,
   retryOneShot,
   type RoutingIntent,
+  type ScheduleJob,
+  scheduleRetry,
 } from "./schedule-store.js";
 
 const log = getLogger("scheduler");
 
-export interface ScheduleMessageOptions {
-  trustClass?: "guardian" | "trusted_contact" | "unknown";
-  taskRunId?: string;
-  /**
-   * Optional LLM call-site identifier propagated to the per-call provider
-   * config. Schedule and sequence callers will start passing their own call-site
-   * (e.g. for a future scheduled-agent profile) once PRs 7-11 migrate them off
-   * the default `mainAgent` route.
-   */
-  callSite?: LLMCallSite;
-}
-
-export type ScheduleMessageProcessor = (
-  conversationId: string,
-  message: string,
-  options?: ScheduleMessageOptions,
-) => Promise<unknown>;
-
-export type ScheduleNotifyModeNotifier = (payload: {
+import type { ScheduleMessageProcessor } from "./scheduler-types.js";
+type ScheduleNotifyModeNotifier = (payload: {
   id: string;
   label: string;
   message: string;
@@ -53,7 +43,7 @@ export type ScheduleNotifyModeNotifier = (payload: {
   routingHints: Record<string, unknown>;
 }) => void | Promise<void>;
 
-export type ScheduleConversationCreatedNotifier = (info: {
+type ScheduleConversationCreatedNotifier = (info: {
   conversationId: string;
   scheduleJobId: string;
   title: string;
@@ -73,6 +63,26 @@ const TICK_INTERVAL_MS = 15_000;
  */
 const WAKE_MAX_RETRIES = 20;
 
+function handleExecutionFailure(params: {
+  job: ScheduleJob;
+  errorMsg: string;
+  isOneShot: boolean;
+}): void {
+  const decision = decideRetry(params.job);
+  applyRetryDecision({
+    job: params.job,
+    isOneShot: params.isOneShot,
+    errorMsg: params.errorMsg,
+    decision,
+    scheduleRetry,
+    failOneShotPermanently,
+    resetRetryCount,
+    emitAlert: (title, summary, dedupKey) =>
+      emitScheduleFeedEvent({ title, summary, dedupKey }),
+    log,
+  });
+}
+
 export function startScheduler(
   processMessage: ScheduleMessageProcessor,
   notifyScheduleOneShot: ScheduleNotifyModeNotifier,
@@ -124,7 +134,7 @@ export function startScheduler(
   };
 }
 
-async function runScheduleOnce(
+export async function runScheduleOnce(
   processMessage: ScheduleMessageProcessor,
   notifyScheduleOneShot: ScheduleNotifyModeNotifier,
   watcherNotifier?: WatcherNotifier,
@@ -134,6 +144,20 @@ async function runScheduleOnce(
   const now = Date.now();
   let processed = 0;
 
+  const diskPressureGate = checkDiskPressureBackgroundGate("background-work");
+  if (diskPressureGate.action === "skip") {
+    if (shouldLogDiskPressureBackgroundSkip("scheduler")) {
+      log.warn(
+        {
+          source: "schedule",
+          ...diskPressureBackgroundSkipLogFields(diskPressureGate),
+        },
+        "Schedule tick skipped during disk pressure cleanup mode",
+      );
+    }
+    return 0;
+  }
+
   // ── Schedules (recurring cron/RRULE + one-shot) ─────────────────────
   const jobs = claimDueSchedules(now);
   for (const job of jobs) {
@@ -154,6 +178,8 @@ async function runScheduleOnce(
           routingHints: job.routingHints,
         });
         if (isOneShot) {
+          const successRunId = createScheduleRun(job.id, `notify-ok:${job.id}`);
+          completeScheduleRun(successRunId, { status: "ok" });
           completeOneShot(job.id);
           emitScheduleFeedEvent({
             title: job.name,
@@ -176,15 +202,10 @@ async function runScheduleOnce(
           { err, jobId: job.id, name: job.name, isOneShot },
           "Schedule notification failed",
         );
-        if (isOneShot) {
-          failOneShot(job.id);
-        } else {
-          // Track recurring notify-mode failures via a schedule run so the
-          // occurrence isn't silently lost and lastStatus/retryCount update.
-          const errorMsg = err instanceof Error ? err.message : String(err);
-          const runId = createScheduleRun(job.id, `notify-error:${job.id}`);
-          completeScheduleRun(runId, { status: "error", error: errorMsg });
-        }
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        const errorRunId = createScheduleRun(job.id, `notify-error:${job.id}`);
+        completeScheduleRun(errorRunId, { status: "error", error: errorMsg });
+        handleExecutionFailure({ job, errorMsg, isOneShot });
       }
       processed += 1;
       continue;
@@ -222,7 +243,9 @@ async function runScheduleOnce(
           }
           if (isOneShot) completeOneShot(job.id);
         } else {
-          if (isOneShot) failOneShot(job.id);
+          const errorMsg =
+            result.stderr || "Script exited with non-zero status";
+          handleExecutionFailure({ job, errorMsg, isOneShot });
         }
       } catch (err) {
         const errorMsg = err instanceof Error ? err.message : String(err);
@@ -231,7 +254,7 @@ async function runScheduleOnce(
           "Script schedule execution failed",
         );
         completeScheduleRun(runId, { status: "error", error: errorMsg });
-        if (isOneShot) failOneShot(job.id);
+        handleExecutionFailure({ job, errorMsg, isOneShot });
       }
       processed += 1;
       continue;
@@ -309,7 +332,11 @@ async function runScheduleOnce(
           continue;
         }
 
-        if (isOneShot) completeOneShot(job.id);
+        if (isOneShot) {
+          const successRunId = createScheduleRun(job.id, `wake-ok:${job.id}`);
+          completeScheduleRun(successRunId, { status: "ok" });
+          completeOneShot(job.id);
+        }
         if (!job.quiet) {
           emitScheduleFeedEvent({
             title: job.name,
@@ -322,7 +349,16 @@ async function runScheduleOnce(
           { err, jobId: job.id, name: job.name, wakeConversationId, isOneShot },
           "Wake schedule execution failed",
         );
-        if (isOneShot) failOneShot(job.id);
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        const wakeErrorRunId = createScheduleRun(
+          job.id,
+          `wake-error:${job.id}`,
+        );
+        completeScheduleRun(wakeErrorRunId, {
+          status: "error",
+          error: errorMsg,
+        });
+        handleExecutionFailure({ job, errorMsg, isOneShot });
       }
       processed += 1;
       continue;
@@ -380,7 +416,11 @@ async function runScheduleOnce(
             status: "error",
             error: result.error ?? "Task run failed",
           });
-          if (isOneShot) failOneShot(job.id);
+          handleExecutionFailure({
+            job,
+            errorMsg: result.error ?? "Task run failed",
+            isOneShot,
+          });
         } else {
           completeScheduleRun(runId, { status: "ok" });
           if (!job.quiet) {
@@ -424,7 +464,11 @@ async function runScheduleOnce(
         });
         const runId = createScheduleRun(job.id, fallbackConversation.id);
         completeScheduleRun(runId, { status: "error", error: message });
-        if (isOneShot) failOneShot(job.id);
+        handleExecutionFailure({
+          job,
+          errorMsg: message,
+          isOneShot,
+        });
       }
       continue;
     }
@@ -507,7 +551,7 @@ async function runScheduleOnce(
           : "Schedule execution failed",
       );
       completeScheduleRun(runId, { status: "error", error: message });
-      if (isOneShot) failOneShot(job.id);
+      handleExecutionFailure({ job, errorMsg: message, isOneShot });
 
       // Only skip invalidation when the conversation was *actually* reused,
       // i.e. it contains prior successful context worth preserving. When

package/src/security/encrypted-store.ts

@@ -108,6 +108,8 @@ function getStoreKeyPath(): string {
   );
 }
 
+
+
 /**
  * Read the store.key file. Returns the raw 32-byte key buffer, or null
  * if the file is missing, wrong size, or unreadable.

package/src/security/oauth-callback-registry.ts

@@ -4,6 +4,14 @@
  * back to the runtime code that initiated the OAuth handshake.
  */
 
+/**
+ * Sibling: `assistant/src/mcp/mcp-auth-state.ts`. The MCP auth state map sits
+ * one layer up from this registry — it tracks polling-visible status per
+ * MCP server, while this registry resolves the OAuth code-arrival promise
+ * keyed by OAuth `state`. The callback registry is shared by all
+ * gateway-transport OAuth flows (MCP and otherwise); the MCP state map is
+ * MCP-specific.
+ */
 interface PendingCallback {
   resolve: (code: string) => void;
   reject: (error: Error) => void;

package/src/security/secure-keys.ts

@@ -18,6 +18,8 @@
  */
 
 import { AsyncLocalStorage } from "node:async_hooks";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 
 import type {
   SecureKeyBackend,
@@ -28,6 +30,7 @@ import { getIsContainerized } from "../config/env-registry.js";
 import type { CesClient } from "../credential-execution/client.js";
 import { getAnyProviderEnvVar } from "../providers/provider-env-vars.js";
 import { getLogger } from "../util/logger.js";
+import { getProtectedDir } from "../util/platform.js";
 import { createCesCredentialBackend } from "./ces-credential-client.js";
 import { CesRpcCredentialBackend } from "./ces-rpc-credential-backend.js";
 import type {
@@ -584,6 +587,58 @@ export function getActiveBackendName(): string {
   return _resolvedBackend?.name ?? "none";
 }
 
+// ---------------------------------------------------------------------------
+// Backend introspection
+// ---------------------------------------------------------------------------
+
+export type BackendInfo =
+  | {
+      backend: "encrypted-store";
+      storePath: string;
+      storeKeyPath: string;
+      storeExists: boolean;
+      storeKeyExists: boolean;
+    }
+  | { backend: "ces-rpc"; ready: boolean }
+  | { backend: "ces-http"; url: string }
+  | { backend: "none" };
+
+/**
+ * Resolve the active credential backend (triggering resolution if not yet
+ * done) and return introspection details specific to that backend.
+ *
+ * Useful for `credentials status` — shows which store this process is talking
+ * to, so path/socket mismatches between the CLI and daemon are immediately
+ * visible.
+ */
+export function getActiveBackendInfoAsync(): Promise<BackendInfo> {
+  return withCredentialTimeout(async () => {
+    const backend = await resolveBackendAsync();
+    if (backend.name === "encrypted-store") {
+      const protectedDir = getProtectedDir();
+      const storePath = join(protectedDir, "keys.enc");
+      const storeKeyPath = join(protectedDir, "store.key");
+      return {
+        backend: "encrypted-store" as const,
+        storePath,
+        storeKeyPath,
+        storeExists: existsSync(storePath),
+        storeKeyExists: existsSync(storeKeyPath),
+      };
+    }
+    if (backend.name === "ces-rpc") {
+      return { backend: "ces-rpc" as const, ready: backend.isAvailable() };
+    }
+    if (backend.name === "ces-http") {
+      return {
+        backend: "ces-http" as const,
+        url: process.env.CES_CREDENTIAL_URL ?? "",
+      };
+    }
+    return { backend: "none" as const };
+  }, { backend: "none" as const });
+}
+
 /** @internal Test-only: reset the cached backends so they're re-created. */
 export function _resetBackend(): void {
   _cesClient = undefined;

package/src/sequence/analytics.ts

@@ -15,7 +15,7 @@ import type { Sequence } from "./types.js";
 
 // ── Event tracking ──────────────────────────────────────────────────
 
-export type SequenceEventType =
+type SequenceEventType =
   | "send"
   | "reply"
   | "complete"
@@ -24,7 +24,7 @@ export type SequenceEventType =
   | "pause"
   | "resume";
 
-export interface SequenceEvent {
+interface SequenceEvent {
   id: string;
   sequenceId: string;
   enrollmentId: string;
@@ -74,7 +74,7 @@ function getRecentEvents(limit = 20): SequenceEvent[] {
 
 // ── Metrics ─────────────────────────────────────────────────────────
 
-export interface SequenceMetrics {
+interface SequenceMetrics {
   sequenceId: string;
   sequenceName: string;
   status: string;
@@ -90,7 +90,7 @@ export interface SequenceMetrics {
   avgTimeToReplyMs: number | null;
 }
 
-export interface StepMetrics {
+interface StepMetrics {
   stepIndex: number;
   subject: string;
   sends: number;
@@ -98,7 +98,7 @@ export interface StepMetrics {
   dropOff: number;
 }
 
-export interface DashboardData {
+interface DashboardData {
   summary: {
     totalSequences: number;
     activeSequences: number;

package/src/sequence/engine.ts

@@ -9,7 +9,7 @@
 import { emitFeedEvent } from "../home/emit-feed-event.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { getMessages } from "../memory/conversation-crud.js";
-import type { ScheduleMessageProcessor } from "../schedule/scheduler.js";
+import type { ScheduleMessageProcessor } from "../schedule/scheduler-types.js";
 import { getLogger } from "../util/logger.js";
 import { recordEvent } from "./analytics.js";
 import { checkAllPreSend, recordSend } from "./guardrails.js";

package/src/skills/catalog-files.ts

@@ -64,14 +64,8 @@ function classifyByName(name: string): boolean {
  * depends on `catalog-cache.ts`, which would otherwise be reachable via
  * the handler module.
  */
-export interface SkillFileEntry {
-  path: string; // relative to skill directory root (e.g. "SKILL.md", "tools/foo.ts")
-  name: string; // basename
-  size: number;
-  mimeType: string;
-  isBinary: boolean;
-  content: string | null; // inline text if ≤ 2 MB and text MIME, else null
-}
+import type { SkillFileEntry } from "./skill-file-types.js";
+export type { SkillFileEntry } from "./skill-file-types.js";
 
 // ─── Platform response contracts ─────────────────────────────────────────────
 //

package/src/skills/include-graph.ts

@@ -1,6 +1,6 @@
 import type { SkillSummary } from "../config/skills.js";
 
-export interface IncludeGraphResult {
+interface IncludeGraphResult {
   /** Ordered list of all skill IDs visited during traversal (including the root). */
   visited: string[];
 }
@@ -37,12 +37,12 @@ export function getImmediateChildren(
   return children;
 }
 
-export interface IncludeValidationSuccess {
+interface IncludeValidationSuccess {
   ok: true;
   visited: string[];
 }
 
-export interface IncludeValidationError {
+interface IncludeValidationError {
   ok: false;
   error: "missing";
   missingChildId: string;
@@ -50,13 +50,13 @@ export interface IncludeValidationError {
   path: string[]; // full path from root to the parent that referenced the missing child
 }
 
-export interface IncludeValidationCycleError {
+interface IncludeValidationCycleError {
   ok: false;
   error: "cycle";
   cyclePath: string[]; // the IDs forming the cycle, e.g. ['a', 'b', 'c', 'a']
 }
 
-export type IncludeValidationResult =
+type IncludeValidationResult =
   | IncludeValidationSuccess
   | IncludeValidationError
   | IncludeValidationCycleError;