@vellumai/assistant 0.6.0 → 0.6.2

package/src/__tests__/workspace-migration-028-recover-conversations-from-disk-view.test.ts

@@ -0,0 +1,387 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — must come before any imports that depend on them
+// ---------------------------------------------------------------------------
+
+const testDir = process.env.VELLUM_WORKSPACE_DIR!;
+const workspaceDir = testDir;
+const conversationsDir = join(workspaceDir, "conversations");
+mkdirSync(conversationsDir, { recursive: true });
+
+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 },
+  }),
+}));
+
+// ---------------------------------------------------------------------------
+// Imports — after mocks
+// ---------------------------------------------------------------------------
+
+import { getDb, initializeDb } from "../memory/db.js";
+import { conversations, messages } from "../memory/schema.js";
+import { recoverConversationsFromDiskViewMigration } from "../workspace/migrations/028-recover-conversations-from-disk-view.js";
+
+initializeDb();
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+function resetConversationsDir() {
+  rmSync(conversationsDir, { recursive: true, force: true });
+  mkdirSync(conversationsDir, { recursive: true });
+}
+
+function createDiskViewDir(
+  id: string,
+  meta: Record<string, unknown>,
+  messagesJsonl?: string,
+): string {
+  const createdAt =
+    typeof meta.createdAt === "string" ? meta.createdAt : new Date().toISOString();
+  const timestamp = createdAt.replace(/:/g, "-");
+  const dirName = `${timestamp}_${id}`;
+  const dirPath = join(conversationsDir, dirName);
+  mkdirSync(dirPath, { recursive: true });
+  writeFileSync(join(dirPath, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
+  if (messagesJsonl !== undefined) {
+    writeFileSync(join(dirPath, "messages.jsonl"), messagesJsonl);
+  }
+  return dirPath;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("028-recover-conversations-from-disk-view migration", () => {
+  beforeEach(() => {
+    resetTables();
+    resetConversationsDir();
+  });
+
+  test("recovers conversation with messages", () => {
+    const id = "conv-028-basic";
+    const createdAt = "2026-03-18T14:23:00.000Z";
+    const updatedAt = "2026-03-18T14:25:00.000Z";
+
+    const userLine = JSON.stringify({
+      role: "user",
+      ts: "2026-03-18T14:23:30.000Z",
+      content: "Hello, world",
+    });
+    const assistantLine = JSON.stringify({
+      role: "assistant",
+      ts: "2026-03-18T14:24:00.000Z",
+      content: "Hi there!",
+    });
+
+    createDiskViewDir(
+      id,
+      { id, title: "Basic Recovery", type: "standard", channel: "desktop", createdAt, updatedAt },
+      userLine + "\n" + assistantLine + "\n",
+    );
+
+    recoverConversationsFromDiskViewMigration.run(workspaceDir);
+
+    const db = getDb();
+    const convRows = db.select().from(conversations).all();
+    expect(convRows).toHaveLength(1);
+    expect(convRows[0].id).toBe(id);
+    expect(convRows[0].title).toBe("Basic Recovery");
+    expect(convRows[0].conversationType).toBe("standard");
+    expect(convRows[0].createdAt).toBe(Date.parse(createdAt));
+    expect(convRows[0].updatedAt).toBe(Date.parse(updatedAt));
+
+    const msgRows = db.select().from(messages).all();
+    expect(msgRows).toHaveLength(2);
+
+    const userMsg = msgRows.find((m) => m.role === "user")!;
+    expect(userMsg).toBeDefined();
+    const userContent = JSON.parse(userMsg.content);
+    expect(userContent).toEqual([{ type: "text", text: "Hello, world" }]);
+    expect(userMsg.createdAt).toBe(Date.parse("2026-03-18T14:23:30.000Z"));
+
+    const assistantMsg = msgRows.find((m) => m.role === "assistant")!;
+    expect(assistantMsg).toBeDefined();
+    const assistantContent = JSON.parse(assistantMsg.content);
+    expect(assistantContent).toEqual([{ type: "text", text: "Hi there!" }]);
+    expect(assistantMsg.createdAt).toBe(Date.parse("2026-03-18T14:24:00.000Z"));
+  });
+
+  test("handles toolCalls and toolResults", () => {
+    const id = "conv-028-tools";
+    const createdAt = "2026-03-18T15:00:00.000Z";
+
+    const toolCallLine = JSON.stringify({
+      role: "assistant",
+      ts: "2026-03-18T15:00:10.000Z",
+      toolCalls: [{ name: "bash", input: { command: "ls" } }],
+    });
+    const toolResultLine = JSON.stringify({
+      role: "user",
+      ts: "2026-03-18T15:00:20.000Z",
+      toolResults: [{ content: "file.txt" }],
+    });
+
+    createDiskViewDir(
+      id,
+      { id, title: "Tool Test", type: "standard", createdAt, updatedAt: createdAt },
+      toolCallLine + "\n" + toolResultLine + "\n",
+    );
+
+    recoverConversationsFromDiskViewMigration.run(workspaceDir);
+
+    const db = getDb();
+    const msgRows = db.select().from(messages).all();
+    expect(msgRows).toHaveLength(2);
+
+    const assistantMsg = msgRows.find((m) => m.role === "assistant")!;
+    const assistantContent = JSON.parse(assistantMsg.content);
+    expect(assistantContent).toHaveLength(1);
+    expect(assistantContent[0].type).toBe("tool_use");
+    expect(assistantContent[0].name).toBe("bash");
+    expect(assistantContent[0].input).toEqual({ command: "ls" });
+    // tool_use blocks get a random UUID id — just check it's a string
+    expect(typeof assistantContent[0].id).toBe("string");
+
+    const userMsg = msgRows.find((m) => m.role === "user")!;
+    const userContent = JSON.parse(userMsg.content);
+    expect(userContent).toHaveLength(1);
+    expect(userContent[0].type).toBe("tool_result");
+    expect(userContent[0].content).toBe("file.txt");
+    expect(userContent[0].tool_use_id).toBe("");
+  });
+
+  test("handles mixed content + toolCalls on the same message", () => {
+    const id = "conv-028-mixed";
+    const createdAt = "2026-03-18T15:30:00.000Z";
+
+    const mixedLine = JSON.stringify({
+      role: "assistant",
+      ts: "2026-03-18T15:30:10.000Z",
+      content: "Let me check that",
+      toolCalls: [{ name: "bash", input: { command: "ls" } }],
+    });
+
+    createDiskViewDir(
+      id,
+      { id, title: "Mixed Test", type: "standard", createdAt, updatedAt: createdAt },
+      mixedLine + "\n",
+    );
+
+    recoverConversationsFromDiskViewMigration.run(workspaceDir);
+
+    const db = getDb();
+    const msgRows = db.select().from(messages).all();
+    expect(msgRows).toHaveLength(1);
+
+    const assistantMsg = msgRows[0];
+    expect(assistantMsg.role).toBe("assistant");
+
+    const contentBlocks = JSON.parse(assistantMsg.content);
+    expect(contentBlocks).toHaveLength(2);
+
+    expect(contentBlocks[0].type).toBe("text");
+    expect(contentBlocks[0].text).toBe("Let me check that");
+
+    expect(contentBlocks[1].type).toBe("tool_use");
+    expect(contentBlocks[1].name).toBe("bash");
+    expect(contentBlocks[1].input).toEqual({ command: "ls" });
+    expect(typeof contentBlocks[1].id).toBe("string");
+  });
+
+  test("skips existing conversations", () => {
+    const id = "conv-028-existing";
+    const createdAt = "2026-03-18T16:00:00.000Z";
+    const createdAtMs = Date.parse(createdAt);
+
+    // Pre-insert the conversation in the DB
+    const db = getDb();
+    db.insert(conversations)
+      .values({
+        id,
+        title: "Already Here",
+        createdAt: createdAtMs,
+        updatedAt: createdAtMs,
+        conversationType: "standard",
+        source: "user",
+        memoryScopeId: "default",
+      })
+      .run();
+
+    // Create matching disk-view dir with a message
+    createDiskViewDir(
+      id,
+      { id, title: "Already Here", type: "standard", createdAt, updatedAt: createdAt },
+      JSON.stringify({ role: "user", ts: createdAt, content: "Should not be imported" }) + "\n",
+    );
+
+    recoverConversationsFromDiskViewMigration.run(workspaceDir);
+
+    // Verify no duplication: still 1 conversation, 0 messages (the disk-view message was not imported)
+    const convRows = db.select().from(conversations).all();
+    expect(convRows).toHaveLength(1);
+    expect(convRows[0].title).toBe("Already Here");
+
+    const msgRows = db.select().from(messages).all();
+    expect(msgRows).toHaveLength(0);
+  });
+
+  test("idempotent — running twice produces same result", () => {
+    const id = "conv-028-idem";
+    const createdAt = "2026-03-18T17:00:00.000Z";
+
+    createDiskViewDir(
+      id,
+      { id, title: "Idempotency Test", type: "standard", createdAt, updatedAt: createdAt },
+      JSON.stringify({ role: "user", ts: createdAt, content: "First message" }) + "\n" +
+        JSON.stringify({ role: "assistant", ts: "2026-03-18T17:01:00.000Z", content: "Reply" }) + "\n",
+    );
+
+    recoverConversationsFromDiskViewMigration.run(workspaceDir);
+
+    const db = getDb();
+    const convCountAfterFirst = db.select().from(conversations).all().length;
+    const msgCountAfterFirst = db.select().from(messages).all().length;
+    expect(convCountAfterFirst).toBe(1);
+    expect(msgCountAfterFirst).toBe(2);
+
+    // Run again
+    recoverConversationsFromDiskViewMigration.run(workspaceDir);
+
+    const convCountAfterSecond = db.select().from(conversations).all().length;
+    const msgCountAfterSecond = db.select().from(messages).all().length;
+    expect(convCountAfterSecond).toBe(convCountAfterFirst);
+    expect(msgCountAfterSecond).toBe(msgCountAfterFirst);
+  });
+
+  test("handles missing messages.jsonl", () => {
+    const id = "conv-028-no-messages";
+    const createdAt = "2026-03-18T18:00:00.000Z";
+
+    // Create dir with only meta.json — no messages.jsonl
+    createDiskViewDir(
+      id,
+      { id, title: "No Messages", type: "standard", createdAt, updatedAt: createdAt },
+    );
+
+    recoverConversationsFromDiskViewMigration.run(workspaceDir);
+
+    const db = getDb();
+    const convRows = db.select().from(conversations).all();
+    expect(convRows).toHaveLength(1);
+    expect(convRows[0].id).toBe(id);
+    expect(convRows[0].title).toBe("No Messages");
+
+    const msgRows = db.select().from(messages).all();
+    expect(msgRows).toHaveLength(0);
+  });
+
+  test("handles malformed JSONL lines", () => {
+    const id = "conv-028-malformed-jsonl";
+    const createdAt = "2026-03-18T19:00:00.000Z";
+
+    const validLine = JSON.stringify({ role: "user", ts: createdAt, content: "Valid" });
+    const invalidLine = "{ this is not valid json }}}";
+
+    createDiskViewDir(
+      id,
+      { id, title: "Malformed JSONL", type: "standard", createdAt, updatedAt: createdAt },
+      validLine + "\n" + invalidLine + "\n",
+    );
+
+    recoverConversationsFromDiskViewMigration.run(workspaceDir);
+
+    const db = getDb();
+    const convRows = db.select().from(conversations).all();
+    expect(convRows).toHaveLength(1);
+
+    // Only the valid line should produce a message row
+    const msgRows = db.select().from(messages).all();
+    expect(msgRows).toHaveLength(1);
+    expect(msgRows[0].role).toBe("user");
+    const content = JSON.parse(msgRows[0].content);
+    expect(content).toEqual([{ type: "text", text: "Valid" }]);
+  });
+
+  test("handles malformed meta.json", () => {
+    const id = "conv-028-malformed-meta";
+    const createdAt = "2026-03-18T20:00:00.000Z";
+    const timestamp = createdAt.replace(/:/g, "-");
+    const dirName = `${timestamp}_${id}`;
+    const dirPath = join(conversationsDir, dirName);
+    mkdirSync(dirPath, { recursive: true });
+
+    // Write broken JSON directly
+    writeFileSync(join(dirPath, "meta.json"), "{ broken json");
+
+    // Migration should complete without error
+    recoverConversationsFromDiskViewMigration.run(workspaceDir);
+
+    const db = getDb();
+    const convRows = db.select().from(conversations).all();
+    expect(convRows).toHaveLength(0);
+  });
+
+  test("no-op when conversations dir missing", () => {
+    // Remove the conversations dir entirely
+    rmSync(conversationsDir, { recursive: true, force: true });
+    expect(existsSync(conversationsDir)).toBe(false);
+
+    // Migration should complete without error
+    recoverConversationsFromDiskViewMigration.run(workspaceDir);
+
+    // No conversations should exist since we can't access the DB rows through a missing dir
+    const db = getDb();
+    const convRows = db.select().from(conversations).all();
+    expect(convRows).toHaveLength(0);
+  });
+
+  test("processes multiple directories", () => {
+    const ids = ["conv-028-multi-a", "conv-028-multi-b", "conv-028-multi-c"];
+    const baseTime = Date.parse("2026-03-18T21:00:00.000Z");
+
+    for (let i = 0; i < ids.length; i++) {
+      const ts = new Date(baseTime + i * 60_000).toISOString();
+      createDiskViewDir(
+        ids[i],
+        { id: ids[i], title: `Multi ${i + 1}`, type: "standard", createdAt: ts, updatedAt: ts },
+        JSON.stringify({ role: "user", ts, content: `Message ${i + 1}` }) + "\n",
+      );
+    }
+
+    recoverConversationsFromDiskViewMigration.run(workspaceDir);
+
+    const db = getDb();
+    const convRows = db.select().from(conversations).all();
+    expect(convRows).toHaveLength(3);
+
+    const recoveredIds = convRows.map((c) => c.id).sort();
+    expect(recoveredIds).toEqual([...ids].sort());
+
+    const msgRows = db.select().from(messages).all();
+    expect(msgRows).toHaveLength(3);
+  });
+});

package/src/__tests__/workspace-migration-030-seed-pkb-autoinject.test.ts

@@ -0,0 +1,168 @@
+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 { seedPkbAutoinjectMigration } from "../workspace/migrations/030-seed-pkb-autoinject.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let workspaceDir: string;
+let pkbDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-030-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  pkbDir = join(workspaceDir, "pkb");
+  mkdirSync(pkbDir, { recursive: true });
+}
+
+// ---------------------------------------------------------------------------
+// Setup / Teardown
+// ---------------------------------------------------------------------------
+
+const dirs: string[] = [];
+
+beforeEach(() => {
+  freshWorkspace();
+  dirs.push(workspaceDir);
+});
+
+afterEach(() => {
+  for (const dir of dirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("030-seed-pkb-autoinject migration", () => {
+  test("has correct migration id", () => {
+    expect(seedPkbAutoinjectMigration.id).toBe("030-seed-pkb-autoinject");
+  });
+
+  // ─── run() ──────────────────────────────────────────────────────────────
+
+  test("creates _autoinject.md with default content", () => {
+    seedPkbAutoinjectMigration.run(workspaceDir);
+
+    const filePath = join(pkbDir, "_autoinject.md");
+    expect(existsSync(filePath)).toBe(true);
+
+    const content = readFileSync(filePath, "utf-8");
+    expect(content).toContain("INDEX.md");
+    expect(content).toContain("essentials.md");
+    expect(content).toContain("threads.md");
+    expect(content).toContain("buffer.md");
+  });
+
+  test("no-op when pkb/ does not exist", () => {
+    rmSync(pkbDir, { recursive: true, force: true });
+    seedPkbAutoinjectMigration.run(workspaceDir);
+    expect(existsSync(join(pkbDir, "_autoinject.md"))).toBe(false);
+  });
+
+  test("idempotent — does not overwrite existing _autoinject.md", () => {
+    const customContent = "INDEX.md\ncustom-topic.md\n";
+    writeFileSync(join(pkbDir, "_autoinject.md"), customContent, "utf-8");
+
+    seedPkbAutoinjectMigration.run(workspaceDir);
+
+    const content = readFileSync(join(pkbDir, "_autoinject.md"), "utf-8");
+    expect(content).toBe(customContent);
+  });
+
+  test("appends _autoinject.md entry to INDEX.md", () => {
+    const indexContent =
+      "# Knowledge Base\n\n## Always Loaded\n" +
+      "- essentials.md — Core facts\n" +
+      "- threads.md — Active threads\n" +
+      "- buffer.md — Inbox\n\n" +
+      "## Topics\n";
+    writeFileSync(join(pkbDir, "INDEX.md"), indexContent, "utf-8");
+
+    seedPkbAutoinjectMigration.run(workspaceDir);
+
+    const updated = readFileSync(join(pkbDir, "INDEX.md"), "utf-8");
+    expect(updated).toContain("_autoinject.md");
+    // Should appear after buffer.md
+    const bufferIdx = updated.indexOf("buffer.md");
+    const autoinjectIdx = updated.indexOf("_autoinject.md");
+    expect(autoinjectIdx).toBeGreaterThan(bufferIdx);
+  });
+
+  test("does not duplicate _autoinject.md entry in INDEX.md", () => {
+    const indexContent =
+      "# Knowledge Base\n\n## Always Loaded\n" +
+      "- buffer.md — Inbox\n" +
+      "- _autoinject.md — Controls autoinjection\n\n" +
+      "## Topics\n";
+    writeFileSync(join(pkbDir, "INDEX.md"), indexContent, "utf-8");
+
+    seedPkbAutoinjectMigration.run(workspaceDir);
+
+    const updated = readFileSync(join(pkbDir, "INDEX.md"), "utf-8");
+    const matches = updated.match(/_autoinject\.md/g);
+    expect(matches?.length).toBe(1);
+  });
+
+  test("handles missing INDEX.md gracefully", () => {
+    // No INDEX.md — should still create _autoinject.md without error
+    seedPkbAutoinjectMigration.run(workspaceDir);
+    expect(existsSync(join(pkbDir, "_autoinject.md"))).toBe(true);
+  });
+
+  // ─── down() ─────────────────────────────────────────────────────────────
+
+  describe("down()", () => {
+    test("removes _autoinject.md when content matches template", () => {
+      seedPkbAutoinjectMigration.run(workspaceDir);
+      expect(existsSync(join(pkbDir, "_autoinject.md"))).toBe(true);
+
+      seedPkbAutoinjectMigration.down(workspaceDir);
+      expect(existsSync(join(pkbDir, "_autoinject.md"))).toBe(false);
+    });
+
+    test("preserves _autoinject.md when user has customized it", () => {
+      const customContent = "INDEX.md\nmy-custom-file.md\n";
+      writeFileSync(join(pkbDir, "_autoinject.md"), customContent, "utf-8");
+
+      seedPkbAutoinjectMigration.down(workspaceDir);
+
+      expect(existsSync(join(pkbDir, "_autoinject.md"))).toBe(true);
+      expect(readFileSync(join(pkbDir, "_autoinject.md"), "utf-8")).toBe(
+        customContent,
+      );
+    });
+
+    test("no-op when _autoinject.md does not exist", () => {
+      seedPkbAutoinjectMigration.down(workspaceDir);
+      // Should not throw
+    });
+
+    test("no-op when pkb/ does not exist", () => {
+      rmSync(pkbDir, { recursive: true, force: true });
+      seedPkbAutoinjectMigration.down(workspaceDir);
+      // Should not throw
+    });
+
+    test("idempotent — calling down() twice is safe", () => {
+      seedPkbAutoinjectMigration.run(workspaceDir);
+      seedPkbAutoinjectMigration.down(workspaceDir);
+      seedPkbAutoinjectMigration.down(workspaceDir);
+      // Should not throw
+    });
+  });
+});

package/src/__tests__/workspace-policy.test.ts

@@ -198,7 +198,7 @@ describe("isWorkspaceScopedInvocation", () => {
   // ── Bash ───────────────────────────────────────────────────────────
 
   describe("bash", () => {
-    test("returns true (sandbox handles isolation)", () => {
+    test("returns true (container handles isolation)", () => {
       expect(
         isWorkspaceScopedInvocation(
           "bash",
@@ -255,12 +255,7 @@ describe("isWorkspaceScopedInvocation", () => {
   // ── Always-scoped safe tools ───────────────────────────────────────
 
   describe("always-scoped tools", () => {
-    const safeTools = [
-      "skill_load",
-      "recall",
-      "ui_update",
-      "ui_dismiss",
-    ];
+    const safeTools = ["skill_load", "recall", "ui_update", "ui_dismiss"];
 
     for (const tool of safeTools) {
       test(`${tool} is workspace-scoped`, () => {

package/src/agent/loop.ts

@@ -31,6 +31,8 @@ export interface AgentLoopConfig {
     | { type: "tool"; name: string };
   /** Minimum interval (ms) between consecutive LLM calls to prevent spin when tools return instantly */
   minTurnIntervalMs?: number;
+  /** Override the default prompt cache TTL sent to the provider (e.g. "5m" for short-lived subagents). */
+  cacheTtl?: "5m" | "1h";
 }
 
 export interface CheckpointInfo {
@@ -199,7 +201,6 @@ export class AgentLoop {
   ): Promise<Message[]> {
     const history = [...messages];
     let toolUseTurns = 0;
-    let nudgedForEmptyResponse = false;
     let consecutiveErrorTurns = 0;
     let lastLlmCallTime = 0;
     const rlog = requestId ? log.child({ requestId }) : log;
@@ -252,6 +253,10 @@ export class AgentLoop {
           providerConfig.tool_choice = this.config.toolChoice;
         }
 
+        if (this.config.cacheTtl) {
+          providerConfig.cacheTtl = this.config.cacheTtl;
+        }
+
         const preLlmResult = await getHookManager().trigger("pre-llm-call", {
           systemPrompt: turnSystemPrompt,
           messages: history,
@@ -397,35 +402,7 @@ export class AgentLoop {
             block.type === "tool_use",
         );
 
-        // Check if the assistant turn contained any visible text (used for
-        // the empty-response nudge).
-        const hasTextBlock = response.content.some(
-          (block) => block.type === "text" && block.text.trim().length > 0,
-        );
-
         if (toolUseBlocks.length === 0 || !this.toolExecutor) {
-          // Check if the LLM returned no text after tool results — nudge it to respond
-          const lastUserMsg =
-            history.length >= 2 ? history[history.length - 2] : undefined;
-          const lastWasToolResult =
-            lastUserMsg?.role === "user" &&
-            lastUserMsg.content.some((block) => block.type === "tool_result");
-
-          if (!hasTextBlock && lastWasToolResult && !nudgedForEmptyResponse) {
-            nudgedForEmptyResponse = true;
-            history.push({
-              role: "user",
-              content: [
-                {
-                  type: "text",
-                  text: "<system_notice>You executed tools but didn't tell the user what happened. Provide a brief, conversational summary of the results.</system_notice>",
-                },
-              ],
-            });
-            continue;
-          }
-
-          // No tool calls or no executor — done
           break;
         }
 

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

@@ -13,6 +13,7 @@
 
 import { answerCall } from "../calls/call-domain.js";
 import { getGatewayInternalBaseUrl } from "../config/env.js";
+import { findContactChannel } from "../contacts/contact-store.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
 import {
   type CanonicalGuardianRequest,
@@ -396,6 +397,25 @@ const accessRequestResolver: GuardianRequestResolver = {
     const desktopDeliverUrl = resolveDeliverCallbackUrlForChannel(channel);
     const desktopBearerToken = mintDaemonDeliveryToken();
 
+    // Resolve display names from the contacts database for enriched payloads
+    const requesterContactResult = requesterExternalUserId
+      ? findContactChannel({
+          channelType: channel,
+          externalUserId: requesterExternalUserId,
+        })
+      : null;
+    const requesterDisplayName =
+      requesterContactResult?.contact.displayName ?? null;
+
+    const decidedByContactResult = decidedByExternalUserId
+      ? findContactChannel({
+          channelType: channel,
+          externalUserId: decidedByExternalUserId,
+        })
+      : null;
+    const decidedByDisplayName =
+      decidedByContactResult?.contact.displayName ?? null;
+
     if (decision.action === "reject") {
       log.info(
         { event: "resolver_access_request_denied", requestId: request.id },
@@ -435,6 +455,8 @@ const accessRequestResolver: GuardianRequestResolver = {
           requesterExternalUserId,
           requesterChatId,
           decidedByExternalUserId,
+          requesterDisplayName,
+          decidedByDisplayName,
           decision: "denied" as const,
         };
 
@@ -726,6 +748,8 @@ const accessRequestResolver: GuardianRequestResolver = {
             sourceChannel: channel,
             requesterExternalUserId,
             requesterChatId,
+            requesterDisplayName,
+            decidedByDisplayName,
             verificationSessionId: session.sessionId,
           },
           dedupeKey: `trusted-contact:verification-sent:${session.sessionId}`,