@vellumai/assistant 0.4.56 → 0.5.0

package/src/__tests__/tool-executor-shell-integration.test.ts

@@ -35,7 +35,7 @@ const mockConfig = {
       network: "none" as const,
     },
   },
-  rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+  rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: false,
     action: "warn" as const,

package/src/__tests__/tool-executor.test.ts

@@ -44,7 +44,7 @@ const mockConfig = {
       network: "none" as const,
     },
   },
-  rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+  rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: false,
     action: "warn" as const,

package/src/__tests__/trace-emitter.test.ts

@@ -1,5 +1,12 @@
 import { describe, expect, it, mock } from "bun:test";
 
+// Mock the persistence layer so tests are isolated from the database.
+// getMaxSequence returning -1 means "no persisted events" → sequence starts at 0.
+mock.module("../memory/trace-event-store.js", () => ({
+  getMaxSequence: () => -1,
+  persistTraceEvent: () => {},
+}));
+
 import type { ServerMessage, TraceEvent } from "../daemon/message-protocol.js";
 import { TraceEmitter } from "../daemon/trace-emitter.js";
 
@@ -169,6 +176,6 @@ describe("TraceEmitter", () => {
     expect(newSent).toHaveLength(1);
     expect(newSent[0].summary).toBe("after");
     // Sequence continues from where it left off
-    expect(newSent[0].sequence).toBe(1);
+    expect(newSent[0].sequence).toBe(sent[0].sequence + 1);
   });
 });

package/src/__tests__/trust-store.test.ts

@@ -790,6 +790,7 @@ describe("Trust Store", () => {
         "skill_execute",
         "skill_load",
         "ui_dismiss",
+        "ui_show",
         "ui_update",
       ]);
     });
@@ -922,16 +923,14 @@ describe("Trust Store", () => {
       expect(match!.id).toBe("default:allow-bash-rm-bootstrap");
       expect(match!.decision).toBe("allow");
       expect(match!.allowHighRisk).toBe(true);
-      // Outside workspace, the bootstrap rule doesn't match — the global
-      // default:allow-bash-global rule matches instead (not the bootstrap rule).
+      // Outside workspace, the bootstrap rule doesn't match — with sandbox
+      // disabled (the default), there is no catch-all bash allow rule either.
       const other = findHighestPriorityRule(
         "bash",
         ["rm BOOTSTRAP.md"],
         "/tmp/other-project",
       );
-      expect(other).not.toBeNull();
-      expect(other!.id).not.toBe("default:allow-bash-rm-bootstrap");
-      expect(other!.id).toBe("default:allow-bash-global");
+      expect(other).toBeNull();
     });
 
     test("updates delete rule matches only when workingDir is the workspace dir", () => {
@@ -945,14 +944,14 @@ describe("Trust Store", () => {
       expect(match!.id).toBe("default:allow-bash-rm-updates");
       expect(match!.decision).toBe("allow");
       expect(match!.allowHighRisk).toBe(true);
-      // Outside workspace, should NOT match the updates rule
+      // Outside workspace, should NOT match the updates rule — with sandbox
+      // disabled (the default), there is no catch-all bash allow rule either.
       const other = findHighestPriorityRule(
         "bash",
         ["rm UPDATES.md"],
         "/tmp/other-project",
       );
-      expect(other).not.toBeNull();
-      expect(other!.id).not.toBe("default:allow-bash-rm-updates");
+      expect(other).toBeNull();
     });
 
     test("default ask does not affect files outside protected directory", () => {

package/src/__tests__/twilio-routes.test.ts

@@ -121,7 +121,7 @@ const mockConfigObj = {
   model: "test",
   provider: "test",
   memory: { enabled: false },
-  rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+  rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: { enabled: false },
   elevenlabs: { voiceId: DEFAULT_ELEVENLABS_VOICE_ID },
   calls: {
@@ -183,11 +183,8 @@ mock.module("../calls/twilio-config.js", () => ({
 }));
 
 mock.module("../calls/twilio-rest.js", () => ({
-  deleteTollFreeVerification: async () => {},
   fetchMessageStatus: async () => ({ status: "delivered" }),
   getPhoneNumberSid: async () => "PN_test",
-  getTollFreeVerificationBySid: async () => null,
-  getTollFreeVerificationStatus: async () => null,
   getTwilioCredentials: () => ({
     accountSid: readMockTwilioAccountSid() ?? "",
     authToken: readMockTwilioAuthToken() ?? "",
@@ -205,20 +202,6 @@ mock.module("../calls/twilio-rest.js", () => ({
   }),
   releasePhoneNumber: async () => {},
   searchAvailableNumbers: async () => mockAvailableNumbers,
-  submitTollFreeVerification: async () => ({
-    sid: "VF_test",
-    status: "PENDING_REVIEW",
-  }),
-  updateTollFreeVerification: async (
-    _accountSid: string,
-    _authToken: string,
-    verificationSid: string,
-  ) => ({
-    sid: verificationSid,
-    status: "PENDING_REVIEW",
-    editAllowed: true,
-    editExpiration: undefined,
-  }),
   updatePhoneNumberWebhooks: async (
     accountSid: string,
     authToken: string,

package/src/__tests__/user-reference.test.ts

@@ -26,8 +26,12 @@ mock.module("node:fs", () => ({
 }));
 
 // Import after mocks are in place
-const { resolveUserReference, resolveGuardianName, DEFAULT_USER_REFERENCE } =
-  await import("../prompts/user-reference.js");
+const {
+  resolveUserReference,
+  resolveUserPronouns,
+  resolveGuardianName,
+  DEFAULT_USER_REFERENCE,
+} = await import("../prompts/user-reference.js");
 
 describe("resolveUserReference", () => {
   beforeEach(() => {
@@ -71,6 +75,82 @@ describe("resolveUserReference", () => {
   });
 });
 
+describe("resolveUserPronouns", () => {
+  beforeEach(() => {
+    mockFileExists = false;
+    mockFileContent = "";
+  });
+
+  test("returns null when USER.md does not exist", () => {
+    mockFileExists = false;
+    expect(resolveUserPronouns()).toBeNull();
+  });
+
+  test("returns pronouns from flat USER.md (no Onboarding Snapshot)", () => {
+    mockFileExists = true;
+    mockFileContent = [
+      "# USER.md",
+      "",
+      "- Preferred name/reference: Alice",
+      "- Pronouns: she/her",
+      "- Locale: en-US",
+    ].join("\n");
+    expect(resolveUserPronouns()).toBe("she/her");
+  });
+
+  test("returns null when pronouns field is empty in flat format", () => {
+    mockFileExists = true;
+    mockFileContent = [
+      "# USER.md",
+      "",
+      "- Preferred name/reference: Alice",
+      "- Pronouns:",
+      "- Locale: en-US",
+    ].join("\n");
+    expect(resolveUserPronouns()).toBeNull();
+  });
+
+  test("returns pronouns from legacy Onboarding Snapshot section", () => {
+    mockFileExists = true;
+    mockFileContent = [
+      "## Onboarding Snapshot",
+      "",
+      "- Pronouns: they/them",
+    ].join("\n");
+    expect(resolveUserPronouns()).toBe("they/them");
+  });
+
+  test("prefers pronouns above Onboarding Snapshot over inside it", () => {
+    mockFileExists = true;
+    mockFileContent = [
+      "Pronouns: he/him",
+      "",
+      "## Onboarding Snapshot",
+      "",
+      "- Pronouns: she/her",
+    ].join("\n");
+    expect(resolveUserPronouns()).toBe("he/him");
+  });
+
+  test("returns null for declined_by_user", () => {
+    mockFileExists = true;
+    mockFileContent = [
+      "- Preferred name/reference: Alice",
+      "- Pronouns: declined_by_user",
+    ].join("\n");
+    expect(resolveUserPronouns()).toBeNull();
+  });
+
+  test("strips inferred: prefix", () => {
+    mockFileExists = true;
+    mockFileContent = [
+      "- Preferred name/reference: Alice",
+      "- Pronouns: inferred: she/her",
+    ].join("\n");
+    expect(resolveUserPronouns()).toBe("she/her");
+  });
+});
+
 describe("resolveGuardianName", () => {
   beforeEach(() => {
     mockFileExists = false;

package/src/__tests__/vbundle-pax-and-symlink.test.ts

@@ -0,0 +1,196 @@
+/**
+ * Tests for PAX extended header round-trip and symlinked skills directory
+ * handling in the vbundle builder/validator.
+ *
+ * Covers:
+ * - Builder emits PAX headers for paths >100 bytes; validator parses them
+ * - buildExportVBundle follows symlinks when checking skillsDir
+ */
+import {
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, describe, expect, mock, test } from "bun:test";
+
+const testDir = realpathSync(
+  mkdtempSync(join(tmpdir(), "vbundle-pax-symlink-test-")),
+);
+
+mock.module("../util/platform.js", () => ({
+  getRootDir: () => testDir,
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+mock.module("../config/env.js", () => ({
+  isHttpAuthDisabled: () => true,
+  hasUngatedHttpAuthDisabled: () => false,
+  getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
+  getGatewayPort: () => 7830,
+  getRuntimeHttpPort: () => 7821,
+  getRuntimeHttpHost: () => "127.0.0.1",
+  getRuntimeGatewayOriginSecret: () => undefined,
+  getIngressPublicBaseUrl: () => undefined,
+  setIngressPublicBaseUrl: () => {},
+}));
+
+import {
+  buildExportVBundle,
+  buildVBundle,
+} from "../runtime/migrations/vbundle-builder.js";
+import { validateVBundle } from "../runtime/migrations/vbundle-validator.js";
+
+afterAll(() => {
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
+});
+
+// ---------------------------------------------------------------------------
+// PAX header round-trip
+// ---------------------------------------------------------------------------
+
+describe("PAX extended header round-trip", () => {
+  test("builder + validator round-trip for paths >100 bytes", () => {
+    // Create a path that exceeds the 100-byte ustar limit
+    const longPath =
+      "skills/" +
+      "a".repeat(50) +
+      "/" +
+      "b".repeat(50) +
+      "/very-long-skill-name-that-exceeds-limit.md";
+    expect(new TextEncoder().encode(longPath).length).toBeGreaterThan(100);
+
+    const fileData = new TextEncoder().encode("# Long path skill content");
+    const dbData = new Uint8Array([0x53, 0x51, 0x4c, 0x69, 0x74, 0x65]);
+
+    const { archive } = buildVBundle({
+      files: [
+        { path: "data/db/assistant.db", data: dbData },
+        { path: longPath, data: fileData },
+      ],
+    });
+
+    // Validate: should succeed — validator must parse the PAX header
+    const result = validateVBundle(archive);
+    expect(result.errors).toEqual([]);
+    expect(result.is_valid).toBe(true);
+    expect(result.manifest).toBeDefined();
+
+    // The long-path file should appear in the entry map with its full name
+    expect(result.entries?.has(longPath)).toBe(true);
+    const entry = result.entries?.get(longPath);
+    expect(entry?.size).toBe(fileData.length);
+  });
+
+  test("validator rejects long-path file with wrong checksum", () => {
+    const longPath =
+      "skills/" + "x".repeat(60) + "/" + "y".repeat(60) + "/skill.md";
+    expect(new TextEncoder().encode(longPath).length).toBeGreaterThan(100);
+
+    const fileData = new TextEncoder().encode("content");
+    const dbData = new Uint8Array([0x53, 0x51, 0x4c, 0x69, 0x74, 0x65]);
+
+    // Build archive, then re-validate — should pass first
+    const { archive } = buildVBundle({
+      files: [
+        { path: "data/db/assistant.db", data: dbData },
+        { path: longPath, data: fileData },
+      ],
+    });
+
+    const result = validateVBundle(archive);
+    expect(result.is_valid).toBe(true);
+  });
+
+  test("short paths (<= 100 bytes) do not emit PAX headers", () => {
+    const shortPath = "config/settings.json";
+    expect(new TextEncoder().encode(shortPath).length).toBeLessThanOrEqual(100);
+
+    const fileData = new TextEncoder().encode("{}");
+    const dbData = new Uint8Array([0x53, 0x51, 0x4c, 0x69, 0x74, 0x65]);
+
+    const { archive } = buildVBundle({
+      files: [
+        { path: "data/db/assistant.db", data: dbData },
+        { path: shortPath, data: fileData },
+      ],
+    });
+
+    const result = validateVBundle(archive);
+    expect(result.is_valid).toBe(true);
+    expect(result.entries?.has(shortPath)).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Symlinked skills directory
+// ---------------------------------------------------------------------------
+
+describe("buildExportVBundle with symlinked skills directory", () => {
+  test("skips symlinked directory inside workspace", () => {
+    // Set up: workspace with a real skills dir and a symlinked dir
+    const wsDir = join(testDir, "export-workspace");
+    const realSkillsDir = join(testDir, "real-skills");
+    mkdirSync(realSkillsDir, { recursive: true });
+    writeFileSync(join(realSkillsDir, "my-skill.md"), "# Skill");
+
+    // Create workspace with a symlink to the skills dir — walkDirectory
+    // skips symlinks, so the symlinked dir should not appear in the archive.
+    mkdirSync(join(wsDir, "skills"), { recursive: true });
+    writeFileSync(join(wsDir, "skills", "real-skill.md"), "# Real");
+    symlinkSync(realSkillsDir, join(wsDir, "linked-skills"));
+
+    const { archive, manifest } = buildExportVBundle({
+      workspaceDir: wsDir,
+    });
+
+    // Validate archive
+    const result = validateVBundle(archive);
+    expect(result.is_valid).toBe(true);
+
+    // Real skill file is in the manifest under workspace/ prefix
+    const realSkill = manifest.files.find(
+      (f) => f.path === "workspace/skills/real-skill.md",
+    );
+    expect(realSkill).toBeDefined();
+
+    // Symlinked directory is skipped
+    const linkedSkill = manifest.files.find(
+      (f) => f.path === "workspace/linked-skills/my-skill.md",
+    );
+    expect(linkedSkill).toBeUndefined();
+  });
+});

package/src/__tests__/verification-control-plane-policy.test.ts

@@ -37,7 +37,7 @@ const mockConfig = {
       network: "none" as const,
     },
   },
-  rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+  rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: false,
     action: "warn" as const,

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

@@ -399,7 +399,7 @@ const accessRequestResolver: GuardianRequestResolver = {
         void emitNotificationSignal({
           sourceEventName: "ingress.trusted_contact.guardian_decision",
           sourceChannel: channel,
-          sourceSessionId: request.conversationId ?? "",
+          sourceContextId: request.conversationId ?? "",
           attentionHints: {
             requiresAction: false,
             urgency: "medium",
@@ -413,7 +413,7 @@ const accessRequestResolver: GuardianRequestResolver = {
         void emitNotificationSignal({
           sourceEventName: "ingress.trusted_contact.denied",
           sourceChannel: channel,
-          sourceSessionId: request.conversationId ?? "",
+          sourceContextId: request.conversationId ?? "",
           attentionHints: {
             requiresAction: false,
             urgency: "low",
@@ -590,7 +590,7 @@ const accessRequestResolver: GuardianRequestResolver = {
         void emitNotificationSignal({
           sourceEventName: "ingress.trusted_contact.verification_sent",
           sourceChannel: channel,
-          sourceSessionId: request.conversationId ?? "",
+          sourceContextId: request.conversationId ?? "",
           attentionHints: {
             requiresAction: false,
             urgency: "low",

package/src/avatar/ascii-renderer.ts

@@ -1,5 +1,4 @@
-import { Resvg } from "@resvg/resvg-js";
-
+import { getResvg } from "./resvg-lazy.js";
 import { composeSvg } from "./svg-compositor.js";
 
 const RAMP = " .·:;+=xX$&@";
@@ -25,6 +24,7 @@ export function renderCharacterAscii(
 ): string {
   const renderSize = width * 2;
   const svg = composeSvg(bodyShapeId, eyeStyleId, colorId, renderSize);
+  const Resvg = getResvg();
   const resvg = new Resvg(svg, {
     fitTo: { mode: "width", value: renderSize },
   });

package/src/avatar/png-renderer.ts

@@ -1,5 +1,4 @@
-import { Resvg } from "@resvg/resvg-js";
-
+import { getResvg } from "./resvg-lazy.js";
 import { composeSvg } from "./svg-compositor.js";
 
 export function renderCharacterPng(
@@ -9,6 +8,7 @@ export function renderCharacterPng(
   size = 512,
 ): Buffer {
   const svg = composeSvg(bodyShapeId, eyeStyleId, colorId, size);
+  const Resvg = getResvg();
   const resvg = new Resvg(svg, {
     fitTo: { mode: "width", value: size },
   });

package/src/avatar/resvg-lazy.ts

@@ -0,0 +1,21 @@
+import type { Resvg as ResvgType } from "@resvg/resvg-js";
+
+let ResvgClass: typeof ResvgType | undefined;
+
+/**
+ * Returns the Resvg constructor, loading the native module on first call.
+ * Defers the native-addon require so the daemon can start even when the
+ * platform-specific binary is unavailable (e.g. inside a bun --compile
+ * single-file executable).
+ */
+export function getResvg(): typeof ResvgType {
+  if (!ResvgClass) {
+    // Inline require is necessary here: @resvg/resvg-js loads a platform-specific
+    // native .node addon at import time. A top-level import would crash the daemon
+    // on startup inside bun --compile binaries where native addons are unavailable.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const mod = require("@resvg/resvg-js") as typeof import("@resvg/resvg-js");
+    ResvgClass = mod.Resvg;
+  }
+  return ResvgClass;
+}

package/src/calls/guardian-dispatch.ts

@@ -204,7 +204,7 @@ async function dispatchGuardianQuestionInner(
     const signalResult = await emitNotificationSignal({
       sourceEventName: "guardian.question",
       sourceChannel: "phone",
-      sourceSessionId: callSessionId,
+      sourceContextId: callSessionId,
       attentionHints: {
         requiresAction: true,
         urgency: "high",

package/src/calls/relay-access-wait.ts

@@ -271,14 +271,14 @@ export function emitAccessRequestCallbackHandoff(
   }
 
   const dedupeKey = `access-request-callback-handoff:${params.accessRequestId}`;
-  const sourceSessionId =
+  const sourceContextId =
     canonicalRequest?.conversationId ??
     `access-req-callback-${params.accessRequestId}`;
 
   void emitNotificationSignal({
     sourceEventName: "ingress.access_request.callback_handoff",
     sourceChannel: "phone",
-    sourceSessionId,
+    sourceContextId,
     attentionHints: {
       requiresAction: false,
       urgency: "medium",