@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

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

@@ -20,7 +20,7 @@ mock.module("../config/loader.js", () => ({
 }));
 
 mock.module("../calls/twilio-provider.js", () => ({
-  TwilioConversationRelayProvider: class {
+  TwilioVoiceProvider: class {
     static getAuthToken() {
       return "test-auth-token";
     }

package/src/__tests__/unified-turn-context-client-os.test.ts

@@ -0,0 +1,45 @@
+/**
+ * Unit tests for the `client_os:` line in the unified-turn-context block.
+ *
+ * `interface` is the transport surface (always "web" for the web/iOS/macOS
+ * apps, which share one renderer); `client_os` is the real OS, carried
+ * separately so the model knows the platform without the OS perturbing
+ * transport/host-proxy capability inference. These pin that both lines render
+ * independently and that `client_os` is omitted when absent.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { buildUnifiedTurnContextBlock } from "../plugins/defaults/turn-context/unified-turn-context.js";
+
+const TS = "2026-06-29T12:00:00.000Z";
+
+describe("unified-turn-context client_os", () => {
+  test("renders a client_os line alongside the transport interface", () => {
+    const block = buildUnifiedTurnContextBlock({
+      timestamp: TS,
+      interfaceName: "web",
+      clientOs: "macos",
+    });
+    expect(block).toContain("interface: web");
+    expect(block).toContain("client_os: macos");
+  });
+
+  test("renders client_os: ios for the iOS app", () => {
+    const block = buildUnifiedTurnContextBlock({
+      timestamp: TS,
+      interfaceName: "web",
+      clientOs: "ios",
+    });
+    expect(block).toContain("client_os: ios");
+  });
+
+  test("omits client_os when not provided", () => {
+    const block = buildUnifiedTurnContextBlock({
+      timestamp: TS,
+      interfaceName: "web",
+    });
+    expect(block).toContain("interface: web");
+    expect(block).not.toContain("client_os:");
+  });
+});

package/src/__tests__/usage-cache-backfill-migration.test.ts

@@ -56,6 +56,7 @@ function insertUsageEvent(args: {
   pricingStatus?: string;
 }): void {
   rawRun(
+    "test:insertUsageEvent",
     /*sql*/ `
     INSERT INTO llm_usage_events (
       id,
@@ -99,6 +100,7 @@ function insertRequestLog(args: {
   // that ordering — the unqualified reads in the migration resolve to `main`
   // when a same-named table is present there.
   rawRun(
+    "test:insertRequestLog",
     /*sql*/ `
     INSERT INTO main.llm_request_logs (
       id,
@@ -260,6 +262,7 @@ describe("migrateBackfillUsageCacheAccounting", () => {
     );
 
     const targetRow = rawGet<UsageEventRow>(
+      "test:fetchTargetUsage",
       `SELECT
          input_tokens,
          output_tokens,
@@ -284,6 +287,7 @@ describe("migrateBackfillUsageCacheAccounting", () => {
     expect(targetRow?.estimated_cost_usd).not.toBe(flattenedHistoricalCost);
 
     const untouchedRow = rawGet<UsageEventRow>(
+      "test:fetchUntouchedUsage",
       `SELECT
          input_tokens,
          output_tokens,
@@ -359,6 +363,7 @@ describe("migrateBackfillUsageCacheAccounting", () => {
     );
 
     const targetRow = rawGet<UsageEventRow>(
+      "test:fetchTargetUsage",
       `SELECT
          input_tokens,
          output_tokens,

package/src/__tests__/voice-approval-resolver-relay.test.ts

@@ -0,0 +1,150 @@
+/**
+ * ATL-463: the daemon's access_request phone resolver relay is the authoritative
+ * grant for voice approvals. These tests pin that relay's contract so no
+ * approved-but-ungranted state is ever silently lost:
+ *
+ *   - happy path: activation lands  → applied, no resolverFailed, status approved
+ *   - relay throws (voice_activation_failed)   → resolverFailed surfaced upstream
+ *   - gateway refuses (voice_activation_refused) → resolverFailed surfaced upstream
+ *
+ * On failure the resolver REOPENS the request to `pending` (via
+ * reopenAccessRequestAfterFailedPersist) with `resolverFailed`/
+ * `resolverFailureReason` set: leaving the row `approved` would suppress
+ * re-prompts for a grant the gateway never persisted. Reopening keeps the
+ * request decidable — the guardian can re-approve and the request code stays
+ * live (the expiry sweep re-enables discovery if no retry comes), so the
+ * failure is neither silent nor a stuck approved-but-ungranted state.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  truncateForLog: (value: string) => value,
+}));
+
+type ActivateOutcome =
+  | { status: "activated"; memberId: string; member: null }
+  | { status: "refused" };
+
+let activateBehavior: () => Promise<ActivateOutcome> | ActivateOutcome = () => ({
+  status: "activated",
+  memberId: "member-1",
+  member: null,
+});
+
+mock.module("../contacts/member-write-relay.js", () => ({
+  activateMemberChannel: () => activateBehavior(),
+  seedUnverifiedMemberChannel: () => {},
+}));
+
+import { applyCanonicalGuardianDecision } from "../approvals/guardian-decision-primitive.js";
+import type { ActorContext } from "../approvals/guardian-request-resolvers.js";
+import {
+  createCanonicalGuardianRequest,
+  getCanonicalGuardianRequest,
+} from "../contacts/canonical-guardian-store.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+
+await initializeDb();
+
+const TEST_PRINCIPAL_ID = "voice-relay-principal";
+
+function guardianActor(): ActorContext {
+  return {
+    actorPrincipalId: TEST_PRINCIPAL_ID,
+    actorExternalUserId: "+15550001111",
+    channel: "phone",
+    guardianPrincipalId: TEST_PRINCIPAL_ID,
+  };
+}
+
+function seedPhoneAccessRequest(): string {
+  const req = createCanonicalGuardianRequest({
+    kind: "access_request",
+    sourceType: "channel",
+    sourceChannel: "phone",
+    conversationId: "voice-conv-1",
+    requesterExternalUserId: "+15559998888",
+    requesterChatId: "+15559998888",
+    guardianExternalUserId: "+15550001111",
+    guardianPrincipalId: TEST_PRINCIPAL_ID,
+    toolName: "ingress_access_request",
+    expiresAt: Date.now() + 60_000,
+  });
+  return req.id;
+}
+
+describe("voice approval resolver relay (ATL-463)", () => {
+  beforeEach(() => {
+    getDb().run("DELETE FROM canonical_guardian_requests");
+    activateBehavior = () => ({
+      status: "activated",
+      memberId: "member-1",
+      member: null,
+    });
+  });
+
+  test("activation lands: applied, no resolver failure, request approved", async () => {
+    const requestId = seedPhoneAccessRequest();
+
+    const result = await applyCanonicalGuardianDecision({
+      requestId,
+      action: "approve_once",
+      actorContext: guardianActor(),
+    });
+
+    expect(result.applied).toBe(true);
+    if (!result.applied) return;
+    expect(result.resolverFailed).toBeUndefined();
+    expect(getCanonicalGuardianRequest(requestId)!.status).toBe("approved");
+  });
+
+  test("relay throws: failure is surfaced (voice_activation_failed), not silent", async () => {
+    activateBehavior = () => {
+      throw new Error("gateway unreachable");
+    };
+    const requestId = seedPhoneAccessRequest();
+
+    const result = await applyCanonicalGuardianDecision({
+      requestId,
+      action: "approve_once",
+      actorContext: guardianActor(),
+    });
+
+    // applied:true reflects the committed CAS status, but the failure is flagged
+    // so callers surface it to the guardian rather than silently dropping it.
+    expect(result.applied).toBe(true);
+    if (!result.applied) return;
+    expect(result.resolverFailed).toBe(true);
+    expect(result.resolverFailureReason).toBe("voice_activation_failed");
+    expect(result.grantMinted).toBe(false);
+    // The failed persist reopens the request to `pending` so the guardian can
+    // re-approve rather than being stuck in an approved-but-ungranted state.
+    expect(getCanonicalGuardianRequest(requestId)!.status).toBe("pending");
+  });
+
+  test("gateway refuses: failure is surfaced (voice_activation_refused), not silent", async () => {
+    activateBehavior = () => ({ status: "refused" });
+    const requestId = seedPhoneAccessRequest();
+
+    const result = await applyCanonicalGuardianDecision({
+      requestId,
+      action: "approve_once",
+      actorContext: guardianActor(),
+    });
+
+    expect(result.applied).toBe(true);
+    if (!result.applied) return;
+    expect(result.resolverFailed).toBe(true);
+    expect(result.resolverFailureReason).toBe("voice_activation_refused");
+    expect(result.grantMinted).toBe(false);
+    // A refused activation also reopens to `pending` — the gateway never
+    // recorded the grant, so the row must not stay terminally approved.
+    expect(getCanonicalGuardianRequest(requestId)!.status).toBe("pending");
+  });
+});

package/src/__tests__/voice-ingress-preflight.test.ts

@@ -2,6 +2,8 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 let mockLoadConfig: () => unknown;
 let mockGetIsPlatform: () => boolean;
+let mockCredentialReadiness: Record<string, unknown>;
+let credentialReadinessCalls = 0;
 
 mock.module("../config/loader.js", () => ({
   loadConfig: () => mockLoadConfig(),
@@ -11,14 +13,36 @@ mock.module("../config/env-registry.js", () => ({
   getIsPlatform: () => mockGetIsPlatform(),
 }));
 
+mock.module("../calls/telephony-credential-preflight.js", () => ({
+  resolveTelephonyCredentialReadiness: async () => {
+    credentialReadinessCalls++;
+    return mockCredentialReadiness;
+  },
+}));
+
 import { preflightVoiceIngress } from "../calls/voice-ingress-preflight.js";
 
+const NOT_READY = {
+  status: "not-ready",
+  missing: [
+    {
+      kind: "stt",
+      providerId: "deepgram",
+      reason: 'No API key configured for credential provider "deepgram"',
+    },
+  ],
+  userMessage:
+    'Phone calls are unavailable because they require an API key for the speech-to-text provider "deepgram".',
+};
+
 describe("voice ingress preflight", () => {
   beforeEach(() => {
     mockLoadConfig = () => ({
       ingress: { enabled: true, publicBaseUrl: "https://example.com" },
     });
     mockGetIsPlatform = () => false;
+    mockCredentialReadiness = { status: "ready" };
+    credentialReadinessCalls = 0;
   });
 
   test("returns success immediately for platform-callback deployments", async () => {
@@ -52,4 +76,41 @@ describe("voice ingress preflight", () => {
       );
     }
   });
+
+  test("fails with the readiness user message when credentials are not ready", async () => {
+    mockCredentialReadiness = NOT_READY;
+
+    const result = await preflightVoiceIngress();
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.status).toBe(503);
+      expect(result.error).toContain('speech-to-text provider "deepgram"');
+    }
+  });
+
+  test("credential readiness gates platform-callback deployments too", async () => {
+    // The platform short-circuit covers only the ingress-URL half — the
+    // daemon still performs STT/TTS on platform deployments.
+    mockGetIsPlatform = () => true;
+    mockLoadConfig = () => ({ ingress: { enabled: false } });
+    mockCredentialReadiness = NOT_READY;
+
+    const result = await preflightVoiceIngress();
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toContain('speech-to-text provider "deepgram"');
+    }
+  });
+
+  test("runs the credential readiness check on the platform success path", async () => {
+    mockGetIsPlatform = () => true;
+    mockLoadConfig = () => ({ ingress: { enabled: false } });
+
+    const result = await preflightVoiceIngress();
+
+    expect(result.ok).toBe(true);
+    expect(credentialReadinessCalls).toBe(1);
+  });
 });

package/src/__tests__/voice-quality.test.ts

@@ -429,8 +429,8 @@ describe("resolveVoiceQualityProfile", () => {
     };
     const profile = resolveVoiceQualityProfile();
     expect(profile.language).toBe("ja-JP");
-    // STT fields (transcriptionProvider, speechModel) are resolved separately
-    // in twilio-routes.ts via resolveTelephonySttRouting() — not on this profile.
+    // STT fields (transcriptionProvider, speechModel) are not part of the
+    // profile — the daemon resolves STT via resolveTelephonySttCapability().
   });
 
   // -- Canonical-only behavior (no legacy fallback) -----------------------

package/src/__tests__/voice-scoped-grant-consumer.test.ts

@@ -95,10 +95,7 @@ import {
   type CreateScopedApprovalGrantParams,
   revokeScopedApprovalGrantsForContext,
 } from "../approvals/scoped-approval-grants.js";
-import {
-  setVoiceBridgeDeps,
-  startVoiceTurn,
-} from "../calls/voice-session-bridge.js";
+import { startVoiceTurn } from "../calls/voice-session-bridge.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
@@ -204,9 +201,6 @@ function setupBridgeDeps(
   sessionFactory: () => ReturnType<typeof createMockSession>["session"],
 ) {
   scopedGrantConversationFactory = () => sessionFactory();
-  setVoiceBridgeDeps({
-    resolveAttachments: () => [],
-  });
 }
 
 // ---------------------------------------------------------------------------

package/src/__tests__/voice-session-bridge-processing-wait.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — declared before importing voice-session-bridge so its module-level
+// imports (logger, config loader) stay side-effect free for this pure helper.
+// ---------------------------------------------------------------------------
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({}),
+}));
+
+import { resolveProcessingWaitMs } from "../calls/voice-session-bridge.js";
+
+describe("resolveProcessingWaitMs", () => {
+  test("sums commit window, abort unwind budget, and fixed margin", () => {
+    expect(resolveProcessingWaitMs(4000, 5000)).toBe(10000);
+    expect(resolveProcessingWaitMs(1000, 5000)).toBe(7000);
+    expect(resolveProcessingWaitMs(4000, 0)).toBe(5000);
+  });
+});

package/src/__tests__/voice-session-bridge.test.ts

@@ -45,10 +45,7 @@ mock.module("../daemon/conversation-store.js", () => ({
   },
 }));
 
-import {
-  setVoiceBridgeDeps,
-  startVoiceTurn,
-} from "../calls/voice-session-bridge.js";
+import { startVoiceTurn } from "../calls/voice-session-bridge.js";
 import {
   createConversation,
   getMessages,
@@ -180,9 +177,6 @@ function parsePersistedMetadata(
  */
 function injectDeps(conversationFactory: () => Conversation): void {
   voiceConversationFactory = conversationFactory;
-  setVoiceBridgeDeps({
-    resolveAttachments: () => [],
-  });
 }
 
 describe("voice-session-bridge", () => {
@@ -518,9 +512,6 @@ describe("voice-session-bridge", () => {
     };
 
     voiceConversationFactory = () => session;
-    setVoiceBridgeDeps({
-      resolveAttachments: () => [],
-    });
 
     const textDeltaEvents: ServerMessage[] = [];
     const completeEvents: ServerMessage[] = [];

package/src/__tests__/workspace-git-service.test.ts

@@ -830,7 +830,7 @@ describe("WorkspaceGitService", () => {
         cwd: testDir,
       });
       const gitignoreContent =
-        "# Runtime state - excluded from git tracking\ndata/db/\ndata/qdrant/\nplugins/*/node_modules/\nlogs/\n*.log\n*.sock\n*.pid\n*.sqlite\n*.sqlite-journal\n*.sqlite-wal\n*.sqlite-shm\n*.db\n*.db-journal\n*.db-wal\n*.db-shm\nvellum.pid\nsession-token\n";
+        "# Runtime state - excluded from git tracking\ndata/db/\ndata/qdrant/\ndata/monitoring/\nplugins/*/node_modules/\nlogs/\n*.log\n*.sock\n*.pid\n*.sqlite\n*.sqlite-journal\n*.sqlite-wal\n*.sqlite-shm\n*.db\n*.db-journal\n*.db-wal\n*.db-shm\nvellum.pid\nsession-token\n";
       writeFileSync(join(testDir, ".gitignore"), gitignoreContent);
       writeFileSync(join(testDir, "file.txt"), "content");
       execFileSync("git", ["add", "-A"], { cwd: testDir });

package/src/__tests__/workspace-migration-013-repair-conversation-disk-view.test.ts

@@ -357,6 +357,7 @@ describe("013-repair-conversation-disk-view migration", () => {
     writeFileSync(stalePath, "stale");
 
     rawRun(
+      "test:setAttachmentFilePath",
       `UPDATE attachments
        SET data_base64 = '', file_path = ?, source_path = NULL
        WHERE id = ?`,

package/src/__tests__/workspace-migration-118-seed-now-md.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Tests for workspace migration `118-seed-now-md`.
+ *
+ * The migration writes a stub `NOW.md` to the workspace root only when the file
+ * is absent (create-only — never clobber an existing NOW.md). Unlike the
+ * onboarding-threads seed (069) it is NOT gated on `isNewWorkspace`: existing
+ * workspaces are exactly the ones missing the file, so the stub is seeded on
+ * upgrade too. The stub is comment-only, so `stripCommentLines` reduces it to
+ * empty and nothing is injected into context — the file's existence is the
+ * point, so `file_edit`/read against NOW.md stop failing with "file not found".
+ */
+
+import {
+  existsSync,
+  mkdtempSync,
+  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 { stripCommentLines } from "../util/strip-comment-lines.js";
+import { seedNowMdMigration } from "../workspace/migrations/118-seed-now-md.js";
+import type { MigrationRunContext } from "../workspace/migrations/types.js";
+
+const NEW_WORKSPACE_CTX: MigrationRunContext = { isNewWorkspace: true };
+const UPGRADE_CTX: MigrationRunContext = { isNewWorkspace: false };
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-118-test-"));
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function nowPath(): string {
+  return join(workspaceDir, "NOW.md");
+}
+
+function readNow(): string {
+  return readFileSync(nowPath(), "utf-8");
+}
+
+describe("118-seed-now-md migration", () => {
+  test("has correct id and description", () => {
+    expect(seedNowMdMigration.id).toBe("118-seed-now-md");
+    expect(seedNowMdMigration.description).toContain("NOW.md");
+  });
+
+  test("creates NOW.md when absent", () => {
+    expect(existsSync(nowPath())).toBe(false);
+
+    seedNowMdMigration.run(workspaceDir);
+
+    expect(existsSync(nowPath())).toBe(true);
+    expect(readNow().length).toBeGreaterThan(0);
+  });
+
+  test("seeds on upgrade too — not gated on isNewWorkspace", () => {
+    // Existing workspaces are the ones missing the file, so an upgrade context
+    // (and a brand-new one) both seed it.
+    seedNowMdMigration.run(workspaceDir, UPGRADE_CTX);
+    expect(existsSync(nowPath())).toBe(true);
+
+    rmSync(nowPath());
+    seedNowMdMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+    expect(existsSync(nowPath())).toBe(true);
+  });
+
+  test("seeded stub strips to empty — injects nothing", () => {
+    seedNowMdMigration.run(workspaceDir);
+    // Every line is a `_` comment, so the scratchpad reader (which runs the
+    // same strip) sees no content and the now-md injector emits nothing.
+    expect(stripCommentLines(readNow())).toBe("");
+  });
+
+  test("does not clobber an existing NOW.md with real content", () => {
+    const existing = "Current focus: shipping the seed migration.\n";
+    writeFileSync(nowPath(), existing, "utf-8");
+
+    seedNowMdMigration.run(workspaceDir);
+
+    expect(readNow()).toBe(existing);
+  });
+
+  test("does not clobber an existing empty NOW.md", () => {
+    writeFileSync(nowPath(), "", "utf-8");
+
+    seedNowMdMigration.run(workspaceDir);
+
+    expect(readNow()).toBe("");
+  });
+
+  test("idempotent — second run does not rewrite the stub", () => {
+    seedNowMdMigration.run(workspaceDir);
+    const afterFirst = readNow();
+
+    seedNowMdMigration.run(workspaceDir);
+    const afterSecond = readNow();
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+
+  test("down() is a no-op — seeded file remains", () => {
+    seedNowMdMigration.run(workspaceDir);
+    const seeded = readNow();
+
+    seedNowMdMigration.down(workspaceDir);
+
+    expect(existsSync(nowPath())).toBe(true);
+    expect(readNow()).toBe(seeded);
+  });
+});