@vellumai/assistant 0.7.2 → 0.8.0

package/src/__tests__/workspace-migration-071-remove-safe-storage-release-note.test.ts

@@ -0,0 +1,206 @@
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "bun:test";
+
+import { removeSafeStorageReleaseNoteMigration } from "../workspace/migrations/071-remove-safe-storage-release-note.js";
+
+const MIGRATION_ID = "071-remove-safe-storage-release-note";
+const SAFE_STORAGE_MARKER =
+  "<!-- release-note-id:067-release-notes-safe-storage-limits -->";
+const LATER_MARKER =
+  "<!-- release-note-id:068-release-notes-local-timezone -->";
+
+const SAFE_STORAGE_RELEASE_NOTE = `${SAFE_STORAGE_MARKER}
+## Safe storage limits
+
+A new storage protection mode is available behind the safe-storage-limits
+rollout flag. When enabled, the assistant watches workspace disk usage and
+enters cleanup mode if the volume reaches the critical 95% threshold.
+
+In cleanup mode, background processes pause and remote messages, including
+trusted-contact messages, are blocked until the guardian frees enough space or
+explicitly overrides the lock. The macOS app now shows a storage cleanup banner
+that must be acknowledged before cleanup chat continues, then keeps a status
+banner visible while cleanup mode is active.
+`;
+
+let testRoot: string;
+let workspaceDir: string;
+
+beforeAll(() => {
+  testRoot = mkdtempSync(join(tmpdir(), "migration-071-remove-safe-storage-"));
+});
+
+afterAll(() => {
+  rmSync(testRoot, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(testRoot, "ws-"));
+});
+
+afterEach(() => {
+  rmSync(workspaceDir, { recursive: true, force: true });
+});
+
+function updatesPath(): string {
+  return join(workspaceDir, "UPDATES.md");
+}
+
+describe("workspace migration 071-remove-safe-storage-release-note", () => {
+  test("has the correct id and description", () => {
+    expect(removeSafeStorageReleaseNoteMigration.id).toBe(MIGRATION_ID);
+    expect(removeSafeStorageReleaseNoteMigration.description).toContain(
+      "safe storage release note",
+    );
+  });
+
+  test("missing UPDATES.md is a no-op", () => {
+    expect(existsSync(updatesPath())).toBe(false);
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    expect(existsSync(updatesPath())).toBe(false);
+  });
+
+  test("removes UPDATES.md when it only contains the safe-storage bulletin", () => {
+    writeFileSync(updatesPath(), SAFE_STORAGE_RELEASE_NOTE, "utf-8");
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    expect(existsSync(updatesPath())).toBe(false);
+  });
+
+  test("preserves prior unrelated release notes when removing the safe-storage block", () => {
+    const prior = `<!-- release-note-id:066-earlier-note -->
+## Earlier note
+
+This note should stay.
+`;
+    writeFileSync(
+      updatesPath(),
+      `${prior}\n${SAFE_STORAGE_RELEASE_NOTE}`,
+      "utf-8",
+    );
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content).toContain("## Earlier note");
+    expect(content).toContain("This note should stay.");
+    expect(content).not.toContain(SAFE_STORAGE_MARKER);
+    expect(content).not.toContain("Safe storage limits");
+  });
+
+  test("preserves a later release-note block after safe storage", () => {
+    const later = `${LATER_MARKER}
+## Local timezone grounding
+
+This later note should stay.
+`;
+    writeFileSync(
+      updatesPath(),
+      `${SAFE_STORAGE_RELEASE_NOTE}\n${later}`,
+      "utf-8",
+    );
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(LATER_MARKER)).toBe(true);
+    expect(content).toContain("## Local timezone grounding");
+    expect(content).toContain("This later note should stay.");
+    expect(content).not.toContain(SAFE_STORAGE_MARKER);
+    expect(content).not.toContain("Safe storage limits");
+  });
+
+  test("fallback preserves a later release-note block after a partial safe-storage block", () => {
+    const partialSafeStorage = `${SAFE_STORAGE_MARKER}
+## Safe storage limits
+
+Partially written note.
+`;
+    const later = `${LATER_MARKER}
+## Local timezone grounding
+
+This later note should stay.
+`;
+    writeFileSync(updatesPath(), `${partialSafeStorage}\n${later}`, "utf-8");
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(LATER_MARKER)).toBe(true);
+    expect(content).toContain("## Local timezone grounding");
+    expect(content).not.toContain(SAFE_STORAGE_MARKER);
+    expect(content).not.toContain("Partially written note.");
+  });
+
+  test("content without the safe-storage marker is byte-identical", () => {
+    const original =
+      "## Existing note\r\n\r\nNo safe storage marker appears here.\r\n";
+    writeFileSync(updatesPath(), original, "utf-8");
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(original);
+  });
+
+  test("preserves CRLF in unrelated content when removing the safe-storage block", () => {
+    const prior =
+      "<!-- release-note-id:066-earlier-note -->\r\n## Earlier note\r\n\r\nThis note should keep CRLF.\r\n";
+    writeFileSync(
+      updatesPath(),
+      `${prior}\r\n${SAFE_STORAGE_RELEASE_NOTE}`,
+      "utf-8",
+    );
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(prior);
+  });
+
+  test("running twice is idempotent", () => {
+    const prior = `<!-- release-note-id:066-earlier-note -->
+## Earlier note
+
+This note should stay.
+`;
+    const later = `${LATER_MARKER}
+## Local timezone grounding
+
+This later note should stay.
+`;
+    writeFileSync(
+      updatesPath(),
+      `${prior}\n${SAFE_STORAGE_RELEASE_NOTE}\n${later}`,
+      "utf-8",
+    );
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+    const afterFirst = readFileSync(updatesPath(), "utf-8");
+
+    removeSafeStorageReleaseNoteMigration.run(workspaceDir);
+    const afterSecond = readFileSync(updatesPath(), "utf-8");
+
+    expect(afterSecond).toBe(afterFirst);
+    expect(afterSecond).toContain("## Earlier note");
+    expect(afterSecond).toContain("## Local timezone grounding");
+    expect(afterSecond).not.toContain(SAFE_STORAGE_MARKER);
+  });
+});

package/src/__tests__/workspace-migration-safe-storage-limits-release.test.ts

@@ -0,0 +1,78 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { releaseNotesSafeStorageLimitsMigration } from "../workspace/migrations/067-release-notes-safe-storage-limits.js";
+
+const MIGRATION_ID = "067-release-notes-safe-storage-limits";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-067-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function updatesPath(): string {
+  return join(workspaceDir, "UPDATES.md");
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("workspace migration 067-release-notes-safe-storage-limits", () => {
+  test("has the correct id", () => {
+    expect(releaseNotesSafeStorageLimitsMigration.id).toBe(MIGRATION_ID);
+  });
+
+  test("does not create UPDATES.md when file is absent", () => {
+    expect(existsSync(updatesPath())).toBe(false);
+
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+
+    expect(existsSync(updatesPath())).toBe(false);
+  });
+
+  test("leaves existing UPDATES.md byte-identical", () => {
+    const existing = "## Prior\n\nExisting release note.\n";
+    writeFileSync(updatesPath(), existing, "utf-8");
+
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(existing);
+  });
+
+  test("is idempotent when run twice in an empty workspace", () => {
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+
+    expect(existsSync(updatesPath())).toBe(false);
+  });
+
+  test("is idempotent when run twice with existing UPDATES.md", () => {
+    const existing = "## Prior\n\nExisting release note.\n";
+    writeFileSync(updatesPath(), existing, "utf-8");
+
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+    releaseNotesSafeStorageLimitsMigration.run(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(existing);
+  });
+});

package/src/agent/loop.ts

@@ -96,6 +96,11 @@ export type AgentEvent =
       matchedTrustRuleId?: string;
       isContainerized?: boolean;
       riskScopeOptions?: Array<{ pattern: string; label: string }>;
+      riskAllowlistOptions?: Array<{
+        label: string;
+        description: string;
+        pattern: string;
+      }>;
       riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
       approvalMode?: string;
       approvalReason?: string;
@@ -282,6 +287,11 @@ export type LoopToolExecutor = (
   matchedTrustRuleId?: string;
   isContainerized?: boolean;
   riskScopeOptions?: Array<{ pattern: string; label: string }>;
+  riskAllowlistOptions?: Array<{
+    label: string;
+    description: string;
+    pattern: string;
+  }>;
   riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
   approvalMode?: string;
   approvalReason?: string;
@@ -1001,6 +1011,7 @@ export class AgentLoop {
             matchedTrustRuleId: result.matchedTrustRuleId,
             isContainerized: result.isContainerized,
             riskScopeOptions: result.riskScopeOptions,
+            riskAllowlistOptions: result.riskAllowlistOptions,
             riskDirectoryScopeOptions: result.riskDirectoryScopeOptions,
             approvalMode: result.approvalMode,
             approvalReason: result.approvalReason,

package/src/approvals/guardian-request-resolvers.ts

@@ -13,7 +13,6 @@
 
 import { answerCall } from "../calls/call-domain.js";
 import { findContactChannel } from "../contacts/contact-store.js";
-import { upsertContactChannel } from "../contacts/contacts-write.js";
 import { findConversation } from "../daemon/conversation-store.js";
 import { emitFeedEvent } from "../home/emit-feed-event.js";
 import {
@@ -187,28 +186,15 @@ const pendingInteractionResolver: GuardianRequestResolver = {
       return { ok: false, reason: "pending_interaction_not_found" };
     }
 
-    // Resolve the interaction: remove from tracker and get the session.
-    const resolved = pendingInteractions.resolve(request.id);
-    if (!resolved) {
-      // Race condition: interaction was consumed between get() and resolve().
-      log.warn(
-        {
-          event: "resolver_tool_approval_resolve_race",
-          requestId: request.id,
-        },
-        "Tool approval resolver: pending interaction consumed between lookup and resolve",
-      );
-      return { ok: false, reason: "pending_interaction_race" };
-    }
-
     // Map action to the permission system's UserDecision type and notify session.
+    // resolveConfirmation() owns pendingInteractions deregistration.
     const userDecision: UserDecision =
       decision.action === "reject" ? "deny" : "allow";
-    const conversation = findConversation(resolved.conversationId);
+    const conversation = findConversation(interaction.conversationId);
     if (!conversation) {
       return {
         ok: false,
-        reason: `conversation_not_found: ${resolved.conversationId}`,
+        reason: `conversation_not_found: ${interaction.conversationId}`,
       };
     }
     conversation.handleConfirmationResponse(
@@ -510,21 +496,6 @@ const accessRequestResolver: GuardianRequestResolver = {
     // a verification session. The caller is already on the line and the
     // relay server's in-call wait loop will detect the approved status.
     if (channel === "phone") {
-      try {
-        upsertContactChannel({
-          sourceChannel: "phone",
-          externalUserId: requesterExternalUserId,
-          externalChatId: requesterChatId,
-          status: "active",
-          policy: "allow",
-        });
-      } catch (err) {
-        log.error(
-          { err, requesterExternalUserId },
-          "Access request resolver: failed to activate voice caller as trusted contact",
-        );
-      }
-
       log.info(
         {
           event: "resolver_access_request_voice_approved",

package/src/backup/snapshot-lock.ts

@@ -32,10 +32,10 @@ import {
   writeSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
-import { kill } from "node:process";
 import { setTimeout as sleep } from "node:timers/promises";
 
 import { getLogger } from "../util/logger.js";
+import { isProcessAlive } from "../util/process-liveness.js";
 import { getLocalBackupsDir } from "./paths.js";
 
 const log = getLogger("snapshot-lock");
@@ -88,29 +88,6 @@ export function getSnapshotLockPath(): string {
   return join(dirname(getLocalBackupsDir()), ".snapshot.lock");
 }
 
-/**
- * Check whether a PID refers to a live process. Uses `kill(pid, 0)`, which
- * does not send any signal — it just probes for existence and permission.
- *
- * Returns `false` for obviously invalid PIDs (<= 0) and for any error that
- * indicates the process is gone. Returns `true` for ESRCH-negative results
- * (meaning a process exists) and for EPERM (process exists but is owned by
- * another user — still a live process, still should not be taken over).
- */
-function isProcessAlive(pid: number): boolean {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    kill(pid, 0);
-    return true;
-  } catch (err) {
-    const code = (err as NodeJS.ErrnoException).code;
-    // EPERM means the PID exists but we cannot signal it — treat as alive so
-    // we don't accidentally take over another user's lock.
-    if (code === "EPERM") return true;
-    return false;
-  }
-}
-
 /**
  * Try to atomically create the lock file with mode `0o600` and the current
  * PID as its contents. Returns `true` on success, `false` if the file
@@ -348,9 +325,7 @@ export async function acquireSnapshotLock(
     }
 
     if (isProcessAlive(holder.pid)) {
-      throw new Error(
-        `snapshot in progress (locked by pid ${holder.pid})`,
-      );
+      throw new Error(`snapshot in progress (locked by pid ${holder.pid})`);
     }
 
     // --- Step 3: stale takeover via rename-aside ---

package/src/bundler/compiler-tools.ts

@@ -15,10 +15,11 @@ import {
   rmSync,
   writeFileSync,
 } from "node:fs";
-import { arch, homedir, platform } from "node:os";
+import { arch, platform } from "node:os";
 import { join } from "node:path";
 
 import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir } from "../util/platform.js";
 import { PromiseGuard } from "../util/promise-guard.js";
 
 const log = getLogger("compiler-tools");
@@ -44,7 +45,7 @@ interface VersionManifest {
 }
 
 function getToolsDir(): string {
-  return join(homedir(), ".vellum", "workspace", "compiler-tools");
+  return join(getWorkspaceDir(), "compiler-tools");
 }
 
 const installGuard = new PromiseGuard<void>();

package/src/calls/call-constants.ts

@@ -1,14 +1,7 @@
 import { getConfig } from "../config/loader.js";
 
 // Emergency/high-risk numbers that should never be called
-const DENIED_NUMBERS = new Set([
-  "911",
-  "112",
-  "999",
-  "000",
-  "110",
-  "119",
-]);
+const DENIED_NUMBERS = new Set(["911", "112", "999", "000", "110", "119"]);
 
 /**
  * Check whether a phone number is a denied emergency number.
@@ -75,3 +68,7 @@ export function getGuardianWaitUpdateSteadyMaxIntervalMs(): number {
 export function getSilenceTimeoutMs(): number {
   return 30 * 1000; // 30 seconds
 }
+
+export function getEndCallListenWindowMs(): number {
+  return 15 * 1000;
+}