@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

package/src/calls/twilio-routes.ts

@@ -55,6 +55,7 @@ import {
   updateCallSession,
 } from "./call-store.js";
 import { getChannelAdmissionPolicy } from "./channel-admission-reader.js";
+import { getPhoneCallerVerdict } from "./inbound-trust-reader.js";
 import { routeSetup } from "./relay-setup-router.js";
 import { resolveCallHints } from "./stt-hints.js";
 import { resolveTelephonySttRouting } from "./telephony-stt-routing.js";
@@ -298,7 +299,7 @@ async function processVoiceWebhook(
       "Inbound voice webhook — creating/reusing session",
     );
 
-    const { session } = createInboundVoiceSession({
+    const { session } = await createInboundVoiceSession({
       callSid,
       fromNumber: callerFrom,
       toNumber: callerTo,
@@ -484,12 +485,21 @@ async function buildVoiceWebhookTwiml(
   // admits the caller.
   const admissionPolicy = await getChannelAdmissionPolicy("phone");
 
+  // Verdict-first caller trust so this preflight matches handleSetup's ACL.
+  // routeSetup uses it when present and not resolutionFailed, else falls back
+  // to local resolution. The reader returns null on failure, keeping the
+  // local path on a gateway blip.
+  const isInbound = sessionContext?.direction !== "outbound";
+  const otherPartyNumber = isInbound ? from : to;
+  const verdict = await getPhoneCallerVerdict(otherPartyNumber);
+
   const { outcome } = routeSetup({
     callSessionId,
     session: session ?? null,
     from,
     to,
     admissionPolicy,
+    verdict,
   });
 
   // The media-stream transport supports normal_call and deny (which speaks
@@ -522,7 +532,7 @@ async function buildVoiceWebhookTwiml(
 /**
  * Build ConversationRelay TwiML for Twilio-native STT providers.
  */
-function buildConversationRelayTwiml(
+async function buildConversationRelayTwiml(
   callSessionId: string,
   profile: ReturnType<typeof resolveVoiceQualityProfile>,
   sessionContext: {
@@ -535,8 +545,8 @@ function buildConversationRelayTwiml(
   } | null,
   verificationSessionId: string | null | undefined,
   sttAttrs: { transcriptionProvider: string; speechModel: string | undefined },
-): string {
-  const rawHints = resolveCallHints(sessionContext, profile.hints);
+): Promise<string> {
+  const rawHints = await resolveCallHints(sessionContext, profile.hints);
 
   const speechConfig: TwilioRelaySpeechConfig = {
     transcriptionProvider: sttAttrs.transcriptionProvider,

package/src/cli/commands/__tests__/cache.test.ts

@@ -88,8 +88,15 @@ mock.module("../../../util/logger.js", () => ({
 }));
 
 mock.module("../../lib/cache-fs.js", () => ({
-  readFileSync: (path: string, encoding?: BufferEncoding) => {
+  readFileSync: (path: string | number, encoding?: BufferEncoding) => {
+    // Stdin must be read via fd 0, not by reopening "/dev/stdin": a spawned
+    // subprocess whose stdin is a pipe (Bun.spawn stdin:"pipe") cannot reopen
+    // its read-end by path — open("/dev/stdin") fails ENXIO. Throwing here on
+    // the path makes any regression to path-based reading fail loudly.
     if (path === "/dev/stdin") {
+      throw new Error("ENXIO: no such device or address, open '/dev/stdin'");
+    }
+    if (path === 0) {
       if (mockStdinContent === null) {
         throw new Error("EAGAIN: resource temporarily unavailable");
       }

package/src/cli/commands/cache.ts

@@ -17,6 +17,9 @@ import { log } from "../logger.js";
 /** Warn (stderr) when a raw payload exceeds this byte count. */
 const MAX_PAYLOAD_BYTES = 1_000_000; // 1 MB
 
+/** Standard input file descriptor. */
+const STDIN_FD = 0;
+
 // ── TTL parsing ───────────────────────────────────────────────────────
 
 const TTL_PATTERN = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h)$/;
@@ -99,6 +102,11 @@ function parseJsonPayload(raw: string, source: string): unknown {
  * Read JSON payload from stdin when piped. Throws when stdin is a TTY
  * (no piped input) or when the input is empty/invalid JSON, so the CLI
  * can surface actionable parse errors.
+ *
+ * Reads file descriptor 0 directly rather than reopening the `/dev/stdin`
+ * path. When the caller is a spawned subprocess whose stdin is a pipe (e.g.
+ * `Bun.spawn(..., { stdin: "pipe" })`), `open("/dev/stdin")` fails with ENXIO
+ * because a pipe read-end cannot be reopened by path; the fd is readable.
  */
 function readPayloadFromStdin(): unknown {
   if (process.stdin.isTTY) {
@@ -111,7 +119,7 @@ function readPayloadFromStdin(): unknown {
 
   let raw: string;
   try {
-    raw = readFileSync("/dev/stdin", "utf-8");
+    raw = readFileSync(STDIN_FD, "utf-8");
   } catch (err) {
     throw new Error(
       `Failed to read stdin: ${err instanceof Error ? err.message : String(err)}.\n` +
@@ -173,10 +181,9 @@ export function registerCacheCommand(program: Command): void {
     transport: "ipc",
     description: "Interact with the assistant's in-memory key/value cache",
     build: (cache) => {
-
-  cache.addHelpText(
-    "after",
-    `
+      cache.addHelpText(
+        "after",
+        `
 The cache is a TTL-aware, LRU-evicting in-memory store managed by the
 running assistant. Data is scoped to the assistant process lifetime and
 is not persisted across restarts.
@@ -190,33 +197,33 @@ Examples:
   $ echo '{"result": [1,2,3]}' | assistant cache set --ttl 5m
   $ assistant cache get my-key
   $ assistant cache delete my-key`,
-  );
-
-  // ── set ───────────────────────────────────────────────────────────
-
-  cache
-    .command("set")
-    .description("Store a JSON value in the cache")
-    .option(
-      "--key <key>",
-      "Cache key for idempotent upsert. Omit to auto-generate.",
-    )
-    .option(
-      "--ttl <duration>",
-      "Time-to-live (minimum 1s). Units: ms, s, m, h (e.g. 1000ms, 30s, 5m, 2h). Defaults to 30m if omitted.",
-    )
-    .option(
-      "--value <json>",
-      "JSON payload to store. Alternative to piping via stdin.",
-    )
-    .option(
-      "--file <path>",
-      "Path to a file containing the JSON payload. Alternative to piping via stdin.",
-    )
-    .option("--json", "Output result as machine-readable JSON.")
-    .addHelpText(
-      "after",
-      `
+      );
+
+      // ── set ───────────────────────────────────────────────────────────
+
+      cache
+        .command("set")
+        .description("Store a JSON value in the cache")
+        .option(
+          "--key <key>",
+          "Cache key for idempotent upsert. Omit to auto-generate.",
+        )
+        .option(
+          "--ttl <duration>",
+          "Time-to-live (minimum 1s). Units: ms, s, m, h (e.g. 1000ms, 30s, 5m, 2h). Defaults to 30m if omitted.",
+        )
+        .option(
+          "--value <json>",
+          "JSON payload to store. Alternative to piping via stdin.",
+        )
+        .option(
+          "--file <path>",
+          "Path to a file containing the JSON payload. Alternative to piping via stdin.",
+        )
+        .option("--json", "Output result as machine-readable JSON.")
+        .addHelpText(
+          "after",
+          `
 Stores a JSON payload in the cache and prints the assigned key. The payload
 can be provided via --value, --file, or piped through stdin. If --key is
 provided, the entry is upserted (created or replaced). If omitted, a new
@@ -240,86 +247,86 @@ Examples:
   $ assistant cache set --file /tmp/payload.json --key scores --ttl 10m
   $ echo '{"scores":[98,85,72]}' | assistant cache set
   $ echo '"simple string"' | assistant cache set --ttl 1h --json`,
-    )
-    .action(
-      async (opts: {
-        key?: string;
-        ttl?: string;
-        value?: string;
-        file?: string;
-        json?: boolean;
-      }) => {
-        let data: unknown;
-        try {
-          data = resolvePayload(opts);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          if (opts.json) {
-            process.stdout.write(
-              JSON.stringify({ ok: false, error: msg }) + "\n",
-            );
-          } else {
-            log.error(msg);
-          }
-          process.exitCode = 1;
-          return;
-        }
-
-        let ttl_ms: number | undefined;
-        try {
-          ttl_ms = parseTtl(opts.ttl);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          if (opts.json) {
-            process.stdout.write(
-              JSON.stringify({ ok: false, error: msg }) + "\n",
-            );
-          } else {
-            log.error(msg);
-          }
-          process.exitCode = 1;
-          return;
-        }
-
-        const params: Record<string, unknown> = { data };
-        if (ttl_ms !== undefined) params.ttl_ms = ttl_ms;
-        if (opts.key) params.key = opts.key;
-
-        const result = await cliIpcCall<{ key: string }>("cache_set", {
-          body: params,
-        });
-
-        if (!result.ok) {
-          if (opts.json) {
-            process.stdout.write(
-              JSON.stringify({ ok: false, error: result.error }) + "\n",
-            );
-          } else {
-            log.error(`Error: ${result.error}`);
-          }
-          process.exitCode = 1;
-          return;
-        }
-
-        if (opts.json) {
-          process.stdout.write(
-            JSON.stringify({ ok: true, key: result.result!.key }) + "\n",
-          );
-        } else {
-          log.info(`Cached with key: ${result.result!.key}`);
-        }
-      },
-    );
+        )
+        .action(
+          async (opts: {
+            key?: string;
+            ttl?: string;
+            value?: string;
+            file?: string;
+            json?: boolean;
+          }) => {
+            let data: unknown;
+            try {
+              data = resolvePayload(opts);
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              if (opts.json) {
+                process.stdout.write(
+                  JSON.stringify({ ok: false, error: msg }) + "\n",
+                );
+              } else {
+                log.error(msg);
+              }
+              process.exitCode = 1;
+              return;
+            }
+
+            let ttl_ms: number | undefined;
+            try {
+              ttl_ms = parseTtl(opts.ttl);
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              if (opts.json) {
+                process.stdout.write(
+                  JSON.stringify({ ok: false, error: msg }) + "\n",
+                );
+              } else {
+                log.error(msg);
+              }
+              process.exitCode = 1;
+              return;
+            }
+
+            const params: Record<string, unknown> = { data };
+            if (ttl_ms !== undefined) params.ttl_ms = ttl_ms;
+            if (opts.key) params.key = opts.key;
+
+            const result = await cliIpcCall<{ key: string }>("cache_set", {
+              body: params,
+            });
+
+            if (!result.ok) {
+              if (opts.json) {
+                process.stdout.write(
+                  JSON.stringify({ ok: false, error: result.error }) + "\n",
+                );
+              } else {
+                log.error(`Error: ${result.error}`);
+              }
+              process.exitCode = 1;
+              return;
+            }
+
+            if (opts.json) {
+              process.stdout.write(
+                JSON.stringify({ ok: true, key: result.result!.key }) + "\n",
+              );
+            } else {
+              log.info(`Cached with key: ${result.result!.key}`);
+            }
+          },
+        );
 
-  // ── get ───────────────────────────────────────────────────────────
+      // ── get ───────────────────────────────────────────────────────────
 
-  cache
-    .command("get <key>")
-    .description("Retrieve a cached value by key")
-    .option("--json", "Output result as machine-readable JSON.")
-    .addHelpText(
-      "after",
-      `
+      cache
+        .command("get <key>")
+        .description("Retrieve a cached value by key")
+        .option("--json", "Output result as machine-readable JSON.")
+        .addHelpText(
+          "after",
+          `
 Arguments:
   key   The cache key to look up. Run 'assistant cache set' to store a
         value and receive its key.
@@ -331,49 +338,52 @@ exist or has expired, reports not-found. In --json mode, a miss returns
 Examples:
   $ assistant cache get my-key
   $ assistant cache get my-key --json`,
-    )
-    .action(async (key: string, opts: { json?: boolean }) => {
-      const result = await cliIpcCall<{ data: unknown } | null>("cache_get", {
-        body: { key },
-      });
-
-      if (!result.ok) {
-        if (opts.json) {
-          process.stdout.write(
-            JSON.stringify({ ok: false, error: result.error }) + "\n",
+        )
+        .action(async (key: string, opts: { json?: boolean }) => {
+          const result = await cliIpcCall<{ data: unknown } | null>(
+            "cache_get",
+            {
+              body: { key },
+            },
           );
-        } else {
-          log.error(`Error: ${result.error}`);
-        }
-        process.exitCode = 1;
-        return;
-      }
-
-      if (opts.json) {
-        process.stdout.write(
-          JSON.stringify({
-            ok: true,
-            data: result.result ? result.result.data : null,
-          }) + "\n",
-        );
-      } else {
-        if (result.result == null) {
-          log.info(`No cache entry found for key "${key}".`);
-        } else {
-          log.info(JSON.stringify(result.result.data, null, 2));
-        }
-      }
-    });
-
-  // ── delete ────────────────────────────────────────────────────────
-
-  cache
-    .command("delete <key>")
-    .description("Remove a cached entry by key")
-    .option("--json", "Output result as machine-readable JSON.")
-    .addHelpText(
-      "after",
-      `
+
+          if (!result.ok) {
+            if (opts.json) {
+              process.stdout.write(
+                JSON.stringify({ ok: false, error: result.error }) + "\n",
+              );
+            } else {
+              log.error(`Error: ${result.error}`);
+            }
+            process.exitCode = 1;
+            return;
+          }
+
+          if (opts.json) {
+            process.stdout.write(
+              JSON.stringify({
+                ok: true,
+                data: result.result ? result.result.data : null,
+              }) + "\n",
+            );
+          } else {
+            if (result.result == null) {
+              log.info(`No cache entry found for key "${key}".`);
+            } else {
+              log.info(JSON.stringify(result.result.data, null, 2));
+            }
+          }
+        });
+
+      // ── delete ────────────────────────────────────────────────────────
+
+      cache
+        .command("delete <key>")
+        .description("Remove a cached entry by key")
+        .option("--json", "Output result as machine-readable JSON.")
+        .addHelpText(
+          "after",
+          `
 Arguments:
   key   The cache key to remove. Run 'assistant cache get <key>' to
         verify a key exists before deleting.
@@ -384,36 +394,39 @@ existed or not, but reports whether an entry was actually removed.
 Examples:
   $ assistant cache delete my-key
   $ assistant cache delete my-key --json`,
-    )
-    .action(async (key: string, opts: { json?: boolean }) => {
-      const result = await cliIpcCall<{ deleted: boolean }>("cache_delete", {
-        body: { key },
-      });
-
-      if (!result.ok) {
-        if (opts.json) {
-          process.stdout.write(
-            JSON.stringify({ ok: false, error: result.error }) + "\n",
+        )
+        .action(async (key: string, opts: { json?: boolean }) => {
+          const result = await cliIpcCall<{ deleted: boolean }>(
+            "cache_delete",
+            {
+              body: { key },
+            },
           );
-        } else {
-          log.error(`Error: ${result.error}`);
-        }
-        process.exitCode = 1;
-        return;
-      }
-
-      const deleted = result.result!.deleted;
-
-      if (opts.json) {
-        process.stdout.write(JSON.stringify({ ok: true, deleted }) + "\n");
-      } else {
-        if (deleted) {
-          log.info(`Deleted cache entry "${key}".`);
-        } else {
-          log.info(`No cache entry "${key}" (nothing to delete).`);
-        }
-      }
-    });
+
+          if (!result.ok) {
+            if (opts.json) {
+              process.stdout.write(
+                JSON.stringify({ ok: false, error: result.error }) + "\n",
+              );
+            } else {
+              log.error(`Error: ${result.error}`);
+            }
+            process.exitCode = 1;
+            return;
+          }
+
+          const deleted = result.result!.deleted;
+
+          if (opts.json) {
+            process.stdout.write(JSON.stringify({ ok: true, deleted }) + "\n");
+          } else {
+            if (deleted) {
+              log.info(`Deleted cache entry "${key}".`);
+            } else {
+              log.info(`No cache entry "${key}" (nothing to delete).`);
+            }
+          }
+        });
     },
   });
 }

package/src/cli/commands/db/__tests__/repair.test.ts

@@ -456,6 +456,9 @@ async function initSchema(): Promise<void> {
   clearStoredDb("memory");
 }
 
+// Every test here runs initSchema(), which replays the full production
+// migration suite, plus at least one repair pass. On a loaded machine that
+// comfortably exceeds bun's 5s per-test default, so each gets a 30s ceiling.
 describe("assistant db repair — conversation-backfill step", () => {
   test("backfills a disk-only conversation into SQLite", async () => {
     await initSchema();
@@ -499,7 +502,7 @@ describe("assistant db repair — conversation-backfill step", () => {
     } finally {
       verify.close();
     }
-  });
+  }, 30_000);
 
   test("skips conversations already present (idempotent)", async () => {
     await initSchema();
@@ -516,8 +519,6 @@ describe("assistant db repair — conversation-backfill step", () => {
     expect(parsed.steps[1].result.data.recovered).toBe(0);
     expect(parsed.steps[1].result.data.skipped).toBe(1);
     expect(parsed.steps[1].result.status).toBe("ok");
-    // Two full repair passes (each walks the DB via integrity-check) exceed
-    // bun's 5s per-test default, so raise the ceiling to keep CI stable.
   }, 30_000);
 
   test("reports nothing-to-backfill on an empty conversations dir", async () => {
@@ -529,7 +530,7 @@ describe("assistant db repair — conversation-backfill step", () => {
     expect(parsed.steps[1].result.status).toBe("ok");
     expect(parsed.steps[1].result.summary).toContain("nothing to backfill");
     expect(parsed.steps[1].result.data.recovered).toBe(0);
-  });
+  }, 30_000);
 
   test("surfaces warnings for malformed meta.json without erroring the step", async () => {
     await initSchema();
@@ -547,5 +548,5 @@ describe("assistant db repair — conversation-backfill step", () => {
         w.includes("malformed meta.json"),
       ),
     ).toBe(true);
-  });
+  }, 30_000);
 });

package/src/cli/commands/db/status.ts

@@ -31,6 +31,7 @@ import type { Command } from "commander";
 import { getLogsDbPath } from "../../../util/logs-db-path.js";
 import { getMemoryDbPath } from "../../../util/memory-db-path.js";
 import { getDbPath } from "../../../util/platform.js";
+import { getTelemetryDbPath } from "../../../util/telemetry-db-path.js";
 import { red } from "../../lib/cli-colors.js";
 import { shouldOutputJson, writeOutput } from "../../output.js";
 import {
@@ -99,6 +100,15 @@ interface StatusReport {
    */
   memoryFile?: FileFacts;
   memoryDb?: DbFacts | null;
+  /**
+   * The dedicated telemetry database (`assistant-telemetry.db`). Like
+   * `logsFile` and `memoryFile`, it is omitted from the report until the file
+   * exists on disk — it is created the first time the daemon opens its
+   * connection, so a fresh install that has never run the daemon won't have
+   * one.
+   */
+  telemetryFile?: FileFacts;
+  telemetryDb?: DbFacts | null;
 }
 
 interface MigrationSummary {
@@ -327,6 +337,13 @@ function renderHuman(report: StatusReport): string {
     out += renderDbBlock(report.memoryFile, report.memoryDb ?? null);
   }
 
+  // The secondary telemetry file is likewise only reported once it exists.
+  if (report.telemetryFile?.exists) {
+    out += "\n";
+    out += "Telemetry database (telemetry event tables)\n";
+    out += renderDbBlock(report.telemetryFile, report.telemetryDb ?? null);
+  }
+
   // Cross-database migration summary — the checkpoint ledger lives only in
   // the main DB, so this is a single block at the end covering all three.
   out += renderSummary(report.migration);
@@ -409,7 +426,13 @@ function readMigrationSummary(mainDbPath: string): MigrationSummary | null {
       // No table yet.
     }
 
-    return { latestKey, latestUpdatedAtMs, appliedSteps, appliedRegistry, crashed };
+    return {
+      latestKey,
+      latestUpdatedAtMs,
+      appliedSteps,
+      appliedRegistry,
+      crashed,
+    };
   } finally {
     db.close();
   }
@@ -519,6 +542,17 @@ export function registerDbStatus(parent: Command): void {
         }
       }
 
+      // Same best-effort probe for the dedicated telemetry DB.
+      const telemetryFile = readFileFacts(getTelemetryDbPath());
+      let telemetryDb: DbFacts | null = null;
+      if (telemetryFile.exists) {
+        try {
+          telemetryDb = readDbFacts(telemetryFile.path);
+        } catch {
+          telemetryDb = null;
+        }
+      }
+
       // Cross-database migration summary from the main DB's checkpoint ledger.
       let migration: MigrationSummary | null = null;
       try {
@@ -535,6 +569,8 @@ export function registerDbStatus(parent: Command): void {
         logsDb,
         memoryFile,
         memoryDb,
+        telemetryFile,
+        telemetryDb,
       };
       if (shouldOutputJson(this)) {
         writeOutput(this, report);