@vellumai/assistant 0.8.5 → 0.8.6

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 };
   }
 

package/src/skills/validate-input.ts

@@ -0,0 +1,177 @@
+/**
+ * Pure JSON-schema input validator for skill tool calls.
+ *
+ * Deliberate strict subset of JSON Schema: it covers only the keywords
+ * actually used by `assistant/src/config/bundled-skills/**\/TOOLS.json`
+ * (required / type / enum / items.type) plus unknown-key detection. Anything
+ * else (`$ref`, `oneOf`, `anyOf`, `allOf`, `format`, `pattern`, `minimum`,
+ * `maximum`, object-shape `additionalProperties`, etc.) is silently skipped so
+ * a richer schema can never cause us to reject a legitimate call.
+ *
+ * Each error message is written to be agent-readable and self-correcting
+ * (e.g. `surface_id is required`, `mode must be one of "replace", "append"`).
+ */
+
+import { isPlainObject } from "../util/object.js";
+
+export interface InputValidationSuccess {
+  ok: true;
+}
+
+export interface InputValidationFailure {
+  ok: false;
+  /** Human-readable messages, one per problem. */
+  errors: string[];
+}
+
+export type InputValidationResult =
+  | InputValidationSuccess
+  | InputValidationFailure;
+
+type SupportedType =
+  | "string"
+  | "number"
+  | "integer"
+  | "boolean"
+  | "array"
+  | "object";
+
+const SUPPORTED_TYPES: ReadonlySet<string> = new Set([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "array",
+  "object",
+]);
+
+function matchesType(value: unknown, type: SupportedType): boolean {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return isPlainObject(value);
+  }
+}
+
+function quoteList(values: readonly string[]): string {
+  return values.map((v) => `"${v}"`).join(", ");
+}
+
+/**
+ * Validate a tool input object against the (optional) JSON-schema definition
+ * declared on the tool entry. Returns `{ ok: true }` if the input is valid (or
+ * if there is nothing actionable to validate); otherwise returns a list of
+ * human-readable error strings.
+ *
+ * Pure: never mutates `input` or `schema`, no I/O.
+ */
+export function validateInputAgainstSchema(
+  _toolName: string,
+  input: Record<string, unknown>,
+  schema: Record<string, unknown> | undefined,
+): InputValidationResult {
+  // Skip when there's no schema or no properties block — matches today's
+  // lenient behaviour for tools that declare only `{ type: "object" }`.
+  if (!schema) return { ok: true };
+  const properties = schema.properties;
+  if (!isPlainObject(properties)) return { ok: true };
+
+  const errors: string[] = [];
+  const knownKeys = Object.keys(properties);
+  const knownKeySet = new Set(knownKeys);
+
+  // 1. Required fields — presence-only check per JSON Schema spec.
+  // `required` only requires the property to be present; `null` is a valid
+  // value when the schema allows it (e.g. `type: ["string", "null"]`).
+  const required = schema.required;
+  if (Array.isArray(required)) {
+    for (const key of required) {
+      if (typeof key !== "string") continue;
+      if (!(key in input)) {
+        errors.push(`${key} is required`);
+      }
+    }
+  }
+
+  // 2. Per-property checks: type, enum, items.type.
+  for (const [key, rawSubSchema] of Object.entries(properties)) {
+    if (!(key in input)) continue;
+    const value = input[key];
+    // Skip type-checking for absent values; presence is enforced by the
+    // `required` check above. Note: `null` IS a present value and is
+    // type-checked below — only schemas that explicitly opt in to null via
+    // a union type (`type: ["string","null"]`) bypass the check, handled
+    // by the `Array.isArray(declaredType)` skip immediately below.
+    if (value === undefined) continue;
+    if (!isPlainObject(rawSubSchema)) continue;
+
+    const declaredType = rawSubSchema.type;
+    // Skip union types (e.g. `["string", "null"]`) — same lenient treatment
+    // we give `oneOf`/`anyOf`/`$ref`. We only validate single-type schemas.
+    if (Array.isArray(declaredType)) continue;
+    if (typeof declaredType === "string" && SUPPORTED_TYPES.has(declaredType)) {
+      const type = declaredType as SupportedType;
+      if (!matchesType(value, type)) {
+        errors.push(`${key} must be ${typeArticle(type)} ${type}`);
+        // No point checking enum/items if the base type is wrong.
+        continue;
+      }
+
+      // 2a. Enum (string enums are the only shape used today).
+      const enumValues = rawSubSchema.enum;
+      if (Array.isArray(enumValues) && enumValues.length > 0) {
+        if (!enumValues.includes(value)) {
+          errors.push(
+            `${key} must be one of ${quoteList(enumValues.map(String))}`,
+          );
+        }
+      }
+
+      // 2b. Array items.type — per-element check.
+      if (type === "array" && isPlainObject(rawSubSchema.items)) {
+        const itemType = rawSubSchema.items.type;
+        if (
+          typeof itemType === "string" &&
+          SUPPORTED_TYPES.has(itemType) &&
+          Array.isArray(value)
+        ) {
+          const itemTypeName = itemType as SupportedType;
+          value.forEach((element, index) => {
+            if (!matchesType(element, itemTypeName)) {
+              errors.push(
+                `${key}[${index}] must be ${typeArticle(itemTypeName)} ${itemTypeName}`,
+              );
+            }
+          });
+        }
+      }
+    }
+  }
+
+  // 3. Unknown keys — parity with the previous `validateNoUnknownParams`.
+  const unknownKeys = Object.keys(input).filter((k) => !knownKeySet.has(k));
+  for (const key of unknownKeys) {
+    errors.push(
+      `Unknown parameter "${key}". Supported: ${quoteList(knownKeys)}`,
+    );
+  }
+
+  if (errors.length === 0) return { ok: true };
+  return { ok: false, errors };
+}
+
+function typeArticle(type: SupportedType): "a" | "an" {
+  // `integer`, `array`, `object` start with a vowel sound.
+  return type === "integer" || type === "array" || type === "object"
+    ? "an"
+    : "a";
+}

package/src/subagent/manager.ts

@@ -365,6 +365,7 @@ export class SubagentManager {
       label: config.label,
       objective: config.objective,
       isFork: config.fork ?? false,
+      parentToolUseId: config.parentToolUseId,
     } as ServerMessage);
 
     log.info(
@@ -435,7 +436,9 @@ export class SubagentManager {
             "⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯",
           ].join("\n")
         : objective;
-      const messageId = await conversation.persistUserMessage(message, []);
+      const { id: messageId } = await conversation.persistUserMessage({
+        content: message,
+      });
       await conversation.runAgentLoop(message, messageId, undefined, {
         callSite: "subagentSpawn",
         ...(managed.state.config.overrideProfile
@@ -609,7 +612,7 @@ export class SubagentManager {
       return "terminal";
 
     // If the conversation is busy, queue the message; otherwise process immediately.
-    const result = managed.conversation.enqueueMessage(trimmed, []);
+    const result = managed.conversation.enqueueMessage({ content: trimmed });
     if (result.rejected) {
       return "sent"; // error event already delivered via sendToClient
     }
@@ -620,7 +623,9 @@ export class SubagentManager {
       // Capture conversation before the await — managed.conversation may be
       // nulled by an external dispose() while persistUserMessage is awaited.
       const conversation = managed.conversation;
-      const messageId = await conversation.persistUserMessage(trimmed, []);
+      const { id: messageId } = await conversation.persistUserMessage({
+        content: trimmed,
+      });
       conversation
         .runAgentLoop(trimmed, messageId, undefined, {
           callSite: "subagentSpawn",
@@ -984,19 +989,14 @@ export class SubagentManager {
       );
       return;
     }
-    const enqueueResult = parentConversation.enqueueMessage(
-      message,
-      [],
-      undefined,
-      undefined,
-      undefined,
-      undefined,
+    const enqueueResult = parentConversation.enqueueMessage({
+      content: message,
       metadata,
-    );
+    });
     if (!enqueueResult.queued && !enqueueResult.rejected) {
       parentConversation
-        .persistUserMessage(message, [], undefined, metadata)
-        .then((messageId) =>
+        .persistUserMessage({ content: message, metadata })
+        .then(({ id: messageId }) =>
           parentConversation.runAgentLoop(message, messageId),
         )
         .catch((err) => {