@vellumai/assistant 0.7.2 → 0.7.3

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

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

@@ -0,0 +1,241 @@
+import { describe, expect, test } from "bun:test";
+
+import type { DiskPressureStatus } from "../daemon/disk-pressure-guard.js";
+import {
+  classifyDiskPressureTurnPolicy,
+  type DiskPressureTurnMetadata,
+  type DiskPressureTurnPolicyDecision,
+} from "../daemon/disk-pressure-policy.js";
+
+const LOCKED_STATUS = {
+  enabled: true,
+  state: "critical",
+  locked: true,
+  acknowledged: true,
+  overrideActive: false,
+  effectivelyLocked: true,
+  lockId: "disk-pressure-test",
+  usagePercent: 98,
+  thresholdPercent: 95,
+  path: "/",
+  lastCheckedAt: "2026-05-05T00:00:00.000Z",
+  blockedCapabilities: ["agent-turns", "background-work", "remote-ingress"],
+  error: null,
+} satisfies DiskPressureStatus;
+
+function status(
+  overrides: Partial<DiskPressureStatus> = {},
+): DiskPressureStatus {
+  return {
+    ...LOCKED_STATUS,
+    ...overrides,
+    blockedCapabilities:
+      overrides.blockedCapabilities ?? LOCKED_STATUS.blockedCapabilities,
+  };
+}
+
+const localOwnerTurn = {
+  conversationType: "standard",
+  callSite: "mainAgent",
+  isInteractive: true,
+  sourceChannel: "vellum",
+  sourceInterface: "macos",
+} satisfies DiskPressureTurnMetadata;
+
+const guardianTurn = {
+  ...localOwnerTurn,
+  sourceChannel: "telegram",
+  sourceInterface: "telegram",
+  trustContext: {
+    sourceChannel: "telegram",
+    trustClass: "guardian",
+  },
+} satisfies DiskPressureTurnMetadata;
+
+describe("classifyDiskPressureTurnPolicy", () => {
+  test.each([
+    {
+      name: "flag disabled allows normal turns",
+      status: status({
+        enabled: false,
+        state: "disabled",
+        locked: false,
+        effectivelyLocked: false,
+        blockedCapabilities: [],
+      }),
+      metadata: guardianTurn,
+      expected: { action: "allow-normal" },
+    },
+    {
+      name: "unlocked allows normal turns",
+      status: status({ locked: false, effectivelyLocked: false }),
+      metadata: guardianTurn,
+      expected: { action: "allow-normal" },
+    },
+    {
+      name: "override active allows normal turns",
+      status: status({ overrideActive: true, effectivelyLocked: false }),
+      metadata: guardianTurn,
+      expected: { action: "allow-normal" },
+    },
+    {
+      name: "locked acknowledged local owner without trust enters cleanup mode",
+      status: status({ acknowledged: true }),
+      metadata: localOwnerTurn,
+      expected: { action: "allow-cleanup-mode", reason: "local-owner" },
+    },
+    {
+      name: "locked unacknowledged local owner without trust enters cleanup mode",
+      status: status({ acknowledged: false }),
+      metadata: localOwnerTurn,
+      expected: { action: "allow-cleanup-mode", reason: "local-owner" },
+    },
+    {
+      name: "locked guardian enters cleanup mode",
+      status: status(),
+      metadata: guardianTurn,
+      expected: { action: "allow-cleanup-mode", reason: "guardian" },
+    },
+    {
+      name: "trusted contact is blocked",
+      status: status(),
+      metadata: {
+        ...guardianTurn,
+        trustContext: {
+          sourceChannel: "telegram",
+          trustClass: "trusted_contact",
+        },
+      },
+      expected: { action: "block", reason: "trusted-contact" },
+    },
+    {
+      name: "non-guardian contact is blocked",
+      status: status(),
+      metadata: {
+        ...guardianTurn,
+        trustContext: {
+          sourceChannel: "telegram",
+          trustClass: "non_guardian",
+        },
+      },
+      expected: { action: "block", reason: "non-guardian" },
+    },
+    {
+      name: "future non-guardian trust class is blocked",
+      status: status(),
+      metadata: {
+        ...guardianTurn,
+        trustContext: {
+          sourceChannel: "telegram",
+          trustClass: "member",
+        },
+      },
+      expected: { action: "block", reason: "non-guardian" },
+    },
+    {
+      name: "unknown remote sender is blocked",
+      status: status(),
+      metadata: {
+        ...guardianTurn,
+        trustContext: {
+          sourceChannel: "telegram",
+          trustClass: "unknown",
+        },
+      },
+      expected: { action: "block", reason: "unknown-remote" },
+    },
+    {
+      name: "remote turn without trust context is blocked",
+      status: status(),
+      metadata: {
+        conversationType: "standard",
+        callSite: "mainAgent",
+        isInteractive: true,
+        sourceChannel: "telegram",
+        sourceInterface: "telegram",
+      },
+      expected: { action: "block", reason: "unknown-remote" },
+    },
+    {
+      name: "background conversation is blocked",
+      status: status(),
+      metadata: {
+        ...guardianTurn,
+        conversationType: "background",
+      },
+      expected: { action: "block", reason: "background" },
+    },
+    {
+      name: "scheduled background group is blocked",
+      status: status(),
+      metadata: {
+        ...guardianTurn,
+        conversationGroupId: "system:scheduled",
+      },
+      expected: { action: "block", reason: "background" },
+    },
+    {
+      name: "background source is blocked",
+      status: status(),
+      metadata: {
+        ...guardianTurn,
+        conversationSource: "heartbeat",
+      },
+      expected: { action: "block", reason: "background" },
+    },
+    {
+      name: "non-main call site is blocked",
+      status: status(),
+      metadata: {
+        ...guardianTurn,
+        callSite: "memoryConsolidation",
+      },
+      expected: { action: "block", reason: "background" },
+    },
+    {
+      name: "direct wake metadata is blocked",
+      status: status(),
+      metadata: {
+        ...guardianTurn,
+        isDirectWake: true,
+      },
+      expected: { action: "block", reason: "background" },
+    },
+    {
+      name: "direct wake source is blocked",
+      status: status(),
+      metadata: {
+        ...guardianTurn,
+        conversationSource: "direct",
+      },
+      expected: { action: "block", reason: "background" },
+    },
+    {
+      name: "local-owner background turn without direct wake is blocked",
+      status: status(),
+      metadata: {
+        ...localOwnerTurn,
+        conversationType: "background",
+        conversationSource: "heartbeat",
+      },
+      expected: { action: "block", reason: "background" },
+    },
+    {
+      name: "explicit local-owner direct wake can enter cleanup mode",
+      status: status(),
+      metadata: {
+        ...localOwnerTurn,
+        conversationSource: "local-cleanup",
+        isDirectWake: true,
+      },
+      expected: { action: "allow-cleanup-mode", reason: "local-owner" },
+    },
+  ] satisfies Array<{
+    name: string;
+    status: DiskPressureStatus;
+    metadata: DiskPressureTurnMetadata;
+    expected: DiskPressureTurnPolicyDecision;
+  }>)("$name", ({ status, metadata, expected }) => {
+    expect(classifyDiskPressureTurnPolicy(status, metadata)).toEqual(expected);
+  });
+});