@vellumai/assistant 0.7.1 → 0.7.3

package/src/__tests__/date-context.test.ts

@@ -1,8 +1,11 @@
 import { describe, expect, test } from "bun:test";
 
+import { UiConfigSchema } from "../config/schemas/platform.js";
 import {
+  canonicalizeTimeZone,
   extractUserTimeZoneFromRecall,
   formatTurnTimestamp,
+  resolveTurnTimezoneContext,
 } from "../daemon/date-context.js";
 
 // ---------------------------------------------------------------------------
@@ -85,6 +88,156 @@ describe("extractUserTimeZoneFromRecall", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// UiConfigSchema timezone fields
+// ---------------------------------------------------------------------------
+
+describe("UiConfigSchema timezone fields", () => {
+  test("accepts canonicalizable IANA timezone identifiers", () => {
+    const result = UiConfigSchema.parse({
+      userTimezone: "america/new_york",
+      detectedTimezone: "america/los_angeles",
+    });
+
+    expect(result.userTimezone).toBe("America/New_York");
+    expect(result.detectedTimezone).toBe("America/Los_Angeles");
+    expect(UiConfigSchema.parse({ userTimezone: "UTC" }).userTimezone).toBe(
+      "UTC",
+    );
+  });
+
+  test("accepts empty-string clearing sentinels", () => {
+    const result = UiConfigSchema.parse({
+      userTimezone: "",
+      detectedTimezone: "",
+    });
+
+    expect(result.userTimezone).toBe("");
+    expect(result.detectedTimezone).toBe("");
+  });
+
+  test("rejects invalid non-empty userTimezone and detectedTimezone values", () => {
+    expect(() =>
+      UiConfigSchema.parse({ userTimezone: "not-a-timezone" }),
+    ).toThrow("ui.userTimezone must be a valid IANA timezone identifier");
+    expect(() =>
+      UiConfigSchema.parse({ detectedTimezone: "Mars/Olympus_Mons" }),
+    ).toThrow("ui.detectedTimezone must be a valid IANA timezone identifier");
+    expect(() => UiConfigSchema.parse({ userTimezone: "+05:30" })).toThrow(
+      "ui.userTimezone must be a valid IANA timezone identifier",
+    );
+  });
+
+  test("rejects ambiguous abbreviations and offset strings", () => {
+    for (const value of ["EST", "PST", "UTC+5:30", "GMT-0800", "+05:30"]) {
+      expect(() => UiConfigSchema.parse({ userTimezone: value })).toThrow(
+        "ui.userTimezone must be a valid IANA timezone identifier",
+      );
+      expect(() => UiConfigSchema.parse({ detectedTimezone: value })).toThrow(
+        "ui.detectedTimezone must be a valid IANA timezone identifier",
+      );
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// canonicalizeTimeZone
+// ---------------------------------------------------------------------------
+
+describe("canonicalizeTimeZone", () => {
+  test("returns canonical timezone identifiers and ignores empty values", () => {
+    expect(canonicalizeTimeZone("america/new_york")).toBe("America/New_York");
+    expect(canonicalizeTimeZone("")).toBeNull();
+    expect(canonicalizeTimeZone(null)).toBeNull();
+    expect(canonicalizeTimeZone("not-a-timezone")).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveTurnTimezoneContext
+// ---------------------------------------------------------------------------
+
+describe("resolveTurnTimezoneContext", () => {
+  test("prefers configured user timezone over automatic sources", () => {
+    const context = resolveTurnTimezoneContext({
+      configuredUserTimeZone: "America/New_York",
+      clientTimezone: "America/Chicago",
+      detectedTimezone: "Asia/Tokyo",
+      hostTimeZone: "Europe/London",
+    });
+
+    expect(context.effectiveTimezone).toBe("America/New_York");
+    expect(context.source).toBe("configuredUserTimezone");
+  });
+
+  test("prefers client timezone over detected and host timezones", () => {
+    const context = resolveTurnTimezoneContext({
+      clientTimezone: "America/Chicago",
+      detectedTimezone: "Asia/Tokyo",
+      hostTimeZone: "Europe/London",
+    });
+
+    expect(context.effectiveTimezone).toBe("America/Chicago");
+    expect(context.source).toBe("clientTimezone");
+  });
+
+  test("prefers detected timezone over host timezone", () => {
+    const context = resolveTurnTimezoneContext({
+      detectedTimezone: "Asia/Tokyo",
+      hostTimeZone: "Europe/London",
+    });
+
+    expect(context.effectiveTimezone).toBe("Asia/Tokyo");
+    expect(context.source).toBe("detectedTimezone");
+  });
+
+  test("uses host timezone before UTC fallback", () => {
+    const context = resolveTurnTimezoneContext({
+      hostTimeZone: "Europe/London",
+    });
+
+    expect(context.effectiveTimezone).toBe("Europe/London");
+    expect(context.source).toBe("hostTimezone");
+  });
+
+  test("falls back to UTC when no timezone resolves", () => {
+    const context = resolveTurnTimezoneContext({
+      configuredUserTimeZone: "not-a-timezone",
+      clientTimezone: "also-invalid",
+      detectedTimezone: "",
+      hostTimeZone: "still-invalid",
+    });
+
+    expect(context.effectiveTimezone).toBe("UTC");
+    expect(context.source).toBe("utcFallback");
+  });
+
+  test("ignores empty strings during runtime resolution", () => {
+    const context = resolveTurnTimezoneContext({
+      configuredUserTimeZone: "",
+      clientTimezone: "",
+      detectedTimezone: "",
+      hostTimeZone: "UTC",
+    });
+
+    expect(context.configuredUserTimezone).toBeNull();
+    expect(context.clientTimezone).toBeNull();
+    expect(context.detectedTimezone).toBeNull();
+    expect(context.effectiveTimezone).toBe("UTC");
+    expect(context.source).toBe("hostTimezone");
+  });
+
+  test("does not use recalled profile timezone in normal turn precedence", () => {
+    const context = resolveTurnTimezoneContext({
+      userTimeZone: "Asia/Tokyo",
+      hostTimeZone: "UTC",
+    });
+
+    expect(context.effectiveTimezone).toBe("UTC");
+    expect(context.source).toBe("hostTimezone");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // formatTurnTimestamp
 // ---------------------------------------------------------------------------
@@ -127,11 +280,20 @@ describe("formatTurnTimestamp", () => {
     expect(result).toBe("2026-04-02 (Thursday) 06:52:33 +00:00 (UTC)");
   });
 
-  test("handles user timezone override", () => {
+  test("handles configured user timezone override", () => {
     const result = formatTurnTimestamp({
       nowMs: THU_APR_02_0652,
       hostTimeZone: "UTC",
-      userTimeZone: "Asia/Tokyo",
+      configuredUserTimeZone: "Asia/Tokyo",
+    });
+    expect(result).toBe("2026-04-02 (Thursday) 15:52:33 +09:00 (Asia/Tokyo)");
+  });
+
+  test("uses client timezone when no configured override exists", () => {
+    const result = formatTurnTimestamp({
+      nowMs: THU_APR_02_0652,
+      hostTimeZone: "UTC",
+      clientTimezone: "Asia/Tokyo",
     });
     expect(result).toBe("2026-04-02 (Thursday) 15:52:33 +09:00 (Asia/Tokyo)");
   });

package/src/__tests__/db-schedule-syntax-migration.test.ts

@@ -36,6 +36,8 @@ describe("schedule_syntax column migration", () => {
         last_run_at INTEGER,
         last_status TEXT,
         retry_count INTEGER NOT NULL DEFAULT 0,
+        max_retries INTEGER NOT NULL DEFAULT 3,
+        retry_backoff_ms INTEGER NOT NULL DEFAULT 60000,
         created_by TEXT NOT NULL,
         mode TEXT NOT NULL DEFAULT 'execute',
         routing_intent TEXT NOT NULL DEFAULT 'all_channels',

package/src/__tests__/disk-pressure-guard.test.ts

@@ -0,0 +1,262 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { DiskPressureTransitionResult } from "../daemon/disk-pressure-guard.js";
+import type { DiskUsageInfo } from "../util/disk-usage.js";
+
+let diskSample: DiskUsageInfo | null = null;
+let diskSampleError: unknown = null;
+let diskSampleCalls = 0;
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({}),
+}));
+
+mock.module("../util/disk-usage.js", () => ({
+  getDiskUsageInfo: () => {
+    diskSampleCalls += 1;
+    if (diskSampleError) throw diskSampleError;
+    return diskSample;
+  },
+}));
+
+mock.module("../runtime/assistant-event.js", () => ({
+  buildAssistantEvent: (message: unknown, conversationId?: string) => ({
+    id: "event-test",
+    type: "message",
+    timestamp: new Date().toISOString(),
+    conversationId,
+    message,
+  }),
+}));
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  AssistantEventHub: class {},
+  broadcastMessage: () => {},
+  capabilityForMessageType: () => undefined,
+  assistantEventHub: {
+    publish: async () => {},
+  },
+}));
+
+const { _setOverridesForTesting } =
+  await import("../config/assistant-feature-flags.js");
+const {
+  DISK_PRESSURE_OVERRIDE_CONFIRMATION,
+  DISK_PRESSURE_THRESHOLD_PERCENT,
+  __getDiskPressureGuardTimerForTests,
+  __resetDiskPressureGuardForTests,
+  acknowledgeDiskPressureLock,
+  evaluateDiskPressureNow,
+  getDiskPressureStatus,
+  overrideDiskPressureLock,
+  startDiskPressureGuard,
+  stopDiskPressureGuard,
+} = await import("../daemon/disk-pressure-guard.js");
+
+function setFeatureFlag(enabled: boolean): void {
+  _setOverridesForTesting({ "safe-storage-limits": enabled });
+}
+
+function setDiskUsage(usedMb: number, totalMb = 100): void {
+  diskSample = {
+    path: "/workspace",
+    totalMb,
+    usedMb,
+    freeMb: Math.max(0, totalMb - usedMb),
+  };
+  diskSampleError = null;
+}
+
+function expectRejected(
+  result: DiskPressureTransitionResult,
+  reason: Exclude<DiskPressureTransitionResult, { ok: true }>["reason"],
+): asserts result is Exclude<DiskPressureTransitionResult, { ok: true }> {
+  expect(result.ok).toBe(false);
+  if (result.ok) {
+    throw new Error("Expected disk pressure transition to be rejected");
+  }
+  expect(result.reason).toBe(reason);
+}
+
+beforeEach(() => {
+  __resetDiskPressureGuardForTests();
+  setFeatureFlag(true);
+  setDiskUsage(10);
+  diskSampleCalls = 0;
+});
+
+afterEach(() => {
+  __resetDiskPressureGuardForTests();
+  _setOverridesForTesting({});
+  diskSample = null;
+  diskSampleError = null;
+  diskSampleCalls = 0;
+});
+
+describe("disk pressure guard", () => {
+  test("returns a stable disabled status without sampling when the flag is disabled", () => {
+    setDiskUsage(99);
+    setFeatureFlag(false);
+
+    const status = evaluateDiskPressureNow();
+
+    expect(status.enabled).toBe(false);
+    expect(status.state).toBe("disabled");
+    expect(status.locked).toBe(false);
+    expect(status.effectivelyLocked).toBe(false);
+    expect(status.usagePercent).toBeNull();
+    expect(diskSampleCalls).toBe(0);
+    expect(getDiskPressureStatus()).toEqual(status);
+  });
+
+  test("locks when sampled usage reaches the threshold", () => {
+    setDiskUsage(DISK_PRESSURE_THRESHOLD_PERCENT);
+
+    const status = evaluateDiskPressureNow();
+
+    expect(status.enabled).toBe(true);
+    expect(status.state).toBe("critical");
+    expect(status.locked).toBe(true);
+    expect(status.acknowledged).toBe(false);
+    expect(status.overrideActive).toBe(false);
+    expect(status.effectivelyLocked).toBe(true);
+    expect(status.lockId).toBeTruthy();
+    expect(status.usagePercent).toBe(DISK_PRESSURE_THRESHOLD_PERCENT);
+    expect(status.thresholdPercent).toBe(DISK_PRESSURE_THRESHOLD_PERCENT);
+    expect(status.path).toBe("/workspace");
+    expect(status.lastCheckedAt).toBeTruthy();
+    expect(status.blockedCapabilities.length).toBeGreaterThan(0);
+  });
+
+  test("acknowledges an active lock without overriding it", () => {
+    setDiskUsage(99);
+    evaluateDiskPressureNow();
+
+    const result = acknowledgeDiskPressureLock();
+
+    expect(result.ok).toBe(true);
+    expect(result.status.acknowledged).toBe(true);
+    expect(result.status.overrideActive).toBe(false);
+    expect(result.status.effectivelyLocked).toBe(true);
+  });
+
+  test("unlocks and clears acknowledgement and override when usage falls below threshold", () => {
+    setDiskUsage(99);
+    evaluateDiskPressureNow();
+    acknowledgeDiskPressureLock();
+    overrideDiskPressureLock(DISK_PRESSURE_OVERRIDE_CONFIRMATION);
+
+    setDiskUsage(20);
+    const status = evaluateDiskPressureNow();
+
+    expect(status.state).toBe("ok");
+    expect(status.locked).toBe(false);
+    expect(status.acknowledged).toBe(false);
+    expect(status.overrideActive).toBe(false);
+    expect(status.effectivelyLocked).toBe(false);
+    expect(status.lockId).toBeNull();
+    expect(status.blockedCapabilities).toEqual([]);
+  });
+
+  test("overrides an active lock only with the exact confirmation after trimming whitespace", () => {
+    setDiskUsage(99);
+    evaluateDiskPressureNow();
+
+    const invalid = overrideDiskPressureLock("I accept the risks");
+    expectRejected(invalid, "invalid_confirmation");
+    expect(invalid.status.effectivelyLocked).toBe(true);
+
+    const valid = overrideDiskPressureLock(
+      `  ${DISK_PRESSURE_OVERRIDE_CONFIRMATION}  `,
+    );
+
+    expect(valid.ok).toBe(true);
+    expect(valid.status.locked).toBe(true);
+    expect(valid.status.overrideActive).toBe(true);
+    expect(valid.status.effectivelyLocked).toBe(false);
+  });
+
+  test("rejects acknowledgement when no lock is active", () => {
+    setDiskUsage(10);
+    evaluateDiskPressureNow();
+
+    const result = acknowledgeDiskPressureLock();
+
+    expectRejected(result, "not_locked");
+    expect(result.status.locked).toBe(false);
+  });
+
+  test("rejects override when no lock is active", () => {
+    setDiskUsage(10);
+    evaluateDiskPressureNow();
+
+    const result = overrideDiskPressureLock(
+      DISK_PRESSURE_OVERRIDE_CONFIRMATION,
+    );
+
+    expectRejected(result, "not_locked");
+    expect(result.status.locked).toBe(false);
+  });
+
+  test("rejects repeated override while preserving the existing override", () => {
+    setDiskUsage(99);
+    evaluateDiskPressureNow();
+    const first = overrideDiskPressureLock(DISK_PRESSURE_OVERRIDE_CONFIRMATION);
+    expect(first.ok).toBe(true);
+
+    const second = overrideDiskPressureLock(
+      DISK_PRESSURE_OVERRIDE_CONFIRMATION,
+    );
+
+    expectRejected(second, "already_overridden");
+    expect(second.status.overrideActive).toBe(true);
+    expect(second.status.effectivelyLocked).toBe(false);
+  });
+
+  test("sample failures degrade open and do not preserve a prior lock", () => {
+    setDiskUsage(99);
+    evaluateDiskPressureNow();
+    expect(getDiskPressureStatus().locked).toBe(true);
+
+    diskSampleError = new Error("sample failed");
+    const status = evaluateDiskPressureNow();
+
+    expect(status.enabled).toBe(true);
+    expect(status.state).toBe("unknown");
+    expect(status.locked).toBe(false);
+    expect(status.effectivelyLocked).toBe(false);
+    expect(status.error).toBe("sample failed");
+    expect(status.lastCheckedAt).toBeTruthy();
+  });
+
+  test("timer start and stop are idempotent", () => {
+    expect(__getDiskPressureGuardTimerForTests()).toBeNull();
+
+    startDiskPressureGuard();
+    const firstTimer = __getDiskPressureGuardTimerForTests();
+    expect(firstTimer).toBeTruthy();
+
+    startDiskPressureGuard();
+    expect(__getDiskPressureGuardTimerForTests()).toBe(firstTimer);
+
+    stopDiskPressureGuard();
+    expect(__getDiskPressureGuardTimerForTests()).toBeNull();
+
+    stopDiskPressureGuard();
+    expect(__getDiskPressureGuardTimerForTests()).toBeNull();
+  });
+
+  test("disabling the flag clears an active timer and lock", () => {
+    setDiskUsage(99);
+    evaluateDiskPressureNow();
+    startDiskPressureGuard();
+    expect(__getDiskPressureGuardTimerForTests()).toBeTruthy();
+
+    setFeatureFlag(false);
+    const status = evaluateDiskPressureNow();
+
+    expect(status.enabled).toBe(false);
+    expect(status.locked).toBe(false);
+    expect(__getDiskPressureGuardTimerForTests()).toBeNull();
+  });
+});

package/src/__tests__/disk-pressure-lifecycle.test.ts

@@ -0,0 +1,168 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const warnCalls: unknown[] = [];
+let guardEnabled = true;
+let startCalls = 0;
+let stopCalls = 0;
+let evaluateCalls = 0;
+let evaluateError: string | null = null;
+
+function makeOpenStatus() {
+  return {
+    enabled: true,
+    state: "ok",
+    locked: false,
+    acknowledged: false,
+    overrideActive: false,
+    effectivelyLocked: false,
+    lockId: null,
+    usagePercent: 10,
+    thresholdPercent: 95,
+    path: "/workspace",
+    lastCheckedAt: new Date().toISOString(),
+    blockedCapabilities: [],
+    error: null,
+  };
+}
+
+mock.module("../daemon/disk-pressure-guard.js", () => ({
+  startDiskPressureGuard: () => {
+    startCalls += 1;
+    return {
+      enabled: guardEnabled,
+      state: guardEnabled ? "ok" : "disabled",
+      locked: false,
+      acknowledged: false,
+      overrideActive: false,
+      effectivelyLocked: false,
+      lockId: null,
+      usagePercent: null,
+      thresholdPercent: 95,
+      path: null,
+      lastCheckedAt: null,
+      blockedCapabilities: [],
+      error: null,
+    };
+  },
+  stopDiskPressureGuard: () => {
+    stopCalls += 1;
+  },
+  evaluateDiskPressureNow: () => {
+    evaluateCalls += 1;
+    return {
+      enabled: true,
+      state: evaluateError ? "unknown" : "ok",
+      locked: false,
+      acknowledged: false,
+      overrideActive: false,
+      effectivelyLocked: false,
+      lockId: null,
+      usagePercent: evaluateError ? null : 10,
+      thresholdPercent: 95,
+      path: evaluateError ? null : "/workspace",
+      lastCheckedAt: new Date().toISOString(),
+      blockedCapabilities: [],
+      error: evaluateError,
+    };
+  },
+  getDiskPressureStatus: () => makeOpenStatus(),
+  acknowledgeDiskPressureLock: () => ({
+    ok: false,
+    reason: "not_locked",
+    message: "No disk pressure lock is active for this assistant.",
+    status: makeOpenStatus(),
+  }),
+  overrideDiskPressureLock: () => ({
+    ok: false,
+    reason: "not_locked",
+    message: "No disk pressure lock is active for this assistant.",
+    status: makeOpenStatus(),
+  }),
+  DISK_PRESSURE_OVERRIDE_CONFIRMATION: "I understand the risks",
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    debug: () => {},
+    error: () => {},
+    info: () => {},
+    warn: (...args: unknown[]) => {
+      warnCalls.push(args);
+    },
+  }),
+  initLogger: () => {},
+}));
+
+const {
+  startDiskPressureGuardForLifecycle,
+  stopDiskPressureGuardForLifecycle,
+} = await import("../daemon/lifecycle.js");
+
+async function flushStartupSample(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+beforeEach(() => {
+  guardEnabled = true;
+  startCalls = 0;
+  stopCalls = 0;
+  evaluateCalls = 0;
+  evaluateError = null;
+  warnCalls.length = 0;
+});
+
+afterEach(() => {
+  stopDiskPressureGuardForLifecycle();
+  guardEnabled = true;
+  evaluateError = null;
+  warnCalls.length = 0;
+});
+
+describe("disk pressure guard lifecycle", () => {
+  test("starts once and evaluates off the startup path when enabled", async () => {
+    startDiskPressureGuardForLifecycle();
+
+    expect(startCalls).toBe(1);
+    expect(evaluateCalls).toBe(0);
+
+    startDiskPressureGuardForLifecycle();
+    expect(startCalls).toBe(2);
+    expect(evaluateCalls).toBe(0);
+
+    await flushStartupSample();
+
+    expect(evaluateCalls).toBe(1);
+  });
+
+  test("stays inert when the feature flag is disabled", async () => {
+    guardEnabled = false;
+
+    startDiskPressureGuardForLifecycle();
+    await flushStartupSample();
+
+    expect(startCalls).toBe(1);
+    expect(evaluateCalls).toBe(0);
+  });
+
+  test("logs sample failures and leaves startup unlocked", async () => {
+    evaluateError = "sample failed";
+
+    expect(() => startDiskPressureGuardForLifecycle()).not.toThrow();
+    expect(evaluateCalls).toBe(0);
+
+    await flushStartupSample();
+
+    expect(evaluateCalls).toBe(1);
+    expect(warnCalls.length).toBe(1);
+  });
+
+  test("stop clears pending startup sample and stops the guard", async () => {
+    startDiskPressureGuardForLifecycle();
+
+    stopDiskPressureGuardForLifecycle();
+    await flushStartupSample();
+
+    expect(evaluateCalls).toBe(0);
+    expect(stopCalls).toBe(1);
+  });
+});