@vellumai/assistant 0.5.13 → 0.5.14

package/src/__tests__/date-context.test.ts

@@ -24,9 +24,9 @@ describe("buildTemporalContext", () => {
     expect(result).toEndWith("</temporal_context>");
   });
 
-  test("includes today date and weekday", () => {
+  test("includes today date, weekday, time and offset on one line", () => {
     const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
-    expect(result).toContain("Today: 2026-02-18 (Wednesday)");
+    expect(result).toContain("Today: 2026-02-18 (Wed) 12:00 +00:00");
   });
 
   test("includes timezone", () => {
@@ -34,22 +34,16 @@ describe("buildTemporalContext", () => {
       nowMs: WED_FEB_18,
       timeZone: "America/New_York",
     });
-    expect(result).toContain("Timezone: America/New_York");
+    expect(result).toContain("TZ: America/New_York");
   });
 
-  test("includes current local time as ISO 8601 with offset", () => {
+  test("does not include UTC time, timezone source, or seconds", () => {
     const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
-    expect(result).toContain("Current local time: 2026-02-18T12:00:00+00:00");
-  });
-
-  test("includes current UTC time from assistant host clock", () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
-    expect(result).toContain("Current UTC time: 2026-02-18T12:00:00.000Z");
-  });
-
-  test("includes timezone source", () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
-    expect(result).toContain("Timezone source:");
+    expect(result).not.toContain("Current UTC time");
+    expect(result).not.toContain("Current local time");
+    expect(result).not.toContain("Timezone source:");
+    // No seconds in the time
+    expect(result).not.toContain("12:00:00");
   });
 
   test("does not include week definitions, next weekend, next work week, or horizon dates", () => {
@@ -60,25 +54,25 @@ describe("buildTemporalContext", () => {
     expect(result).not.toContain("Upcoming dates");
   });
 
-  test("uses user timezone when provided and records source metadata", () => {
+  test("uses user timezone when provided", () => {
     const result = buildTemporalContext({
       nowMs: WED_FEB_18,
       hostTimeZone: "UTC",
       userTimeZone: "America/New_York",
     });
-    expect(result).toContain("Timezone: America/New_York");
-    expect(result).toContain("Current local time: 2026-02-18T07:00:00-05:00");
-    expect(result).toContain("Timezone source: user_profile_memory");
+    expect(result).toContain("TZ: America/New_York");
+    expect(result).toContain("Today: 2026-02-18 (Wed) 07:00 -05:00");
+    expect(result).not.toContain("(host fallback)");
   });
 
-  test("shows user timezone only when different from primary timezone", () => {
+  test("shows user TZ only when different from primary timezone", () => {
     // When user timezone equals the primary timezone, omit it
     const sameResult = buildTemporalContext({
       nowMs: WED_FEB_18,
       hostTimeZone: "UTC",
       configuredUserTimeZone: "UTC",
     });
-    expect(sameResult).not.toContain("User timezone:");
+    expect(sameResult).not.toContain("User TZ:");
 
     // When user timezone differs from host, it becomes the primary timezone
     // and the host timezone is shown as a secondary annotation
@@ -87,19 +81,19 @@ describe("buildTemporalContext", () => {
       hostTimeZone: "UTC",
       userTimeZone: "America/New_York",
     });
-    expect(diffResult).toContain("Timezone: America/New_York");
-    expect(diffResult).toContain("Assistant host timezone: UTC");
-    expect(diffResult).not.toContain("User timezone:");
+    expect(diffResult).toContain("TZ: America/New_York");
+    expect(diffResult).toContain("Host TZ: UTC");
+    expect(diffResult).not.toContain("User TZ:");
   });
 
-  test("shows assistant host timezone only when different from primary timezone", () => {
+  test("shows host TZ only when different from primary timezone", () => {
     // When host timezone equals the primary timezone, omit it
     const sameResult = buildTemporalContext({
       nowMs: WED_FEB_18,
       hostTimeZone: "UTC",
       timeZone: "UTC",
     });
-    expect(sameResult).not.toContain("Assistant host timezone:");
+    expect(sameResult).not.toContain("Host TZ:");
 
     // When different, include it
     const diffResult = buildTemporalContext({
@@ -107,7 +101,7 @@ describe("buildTemporalContext", () => {
       hostTimeZone: "UTC",
       userTimeZone: "America/New_York",
     });
-    expect(diffResult).toContain("Assistant host timezone: UTC");
+    expect(diffResult).toContain("Host TZ: UTC");
   });
 
   test("uses configured user timezone when profile timezone is unavailable", () => {
@@ -117,9 +111,9 @@ describe("buildTemporalContext", () => {
       configuredUserTimeZone: "America/Chicago",
       userTimeZone: null,
     });
-    expect(result).toContain("Timezone: America/Chicago");
-    expect(result).toContain("Current local time: 2026-02-18T06:00:00-06:00");
-    expect(result).toContain("Timezone source: user_settings");
+    expect(result).toContain("TZ: America/Chicago");
+    expect(result).toContain("Today: 2026-02-18 (Wed) 06:00 -06:00");
+    expect(result).not.toContain("(host fallback)");
   });
 
   test("configured user timezone takes precedence over profile timezone", () => {
@@ -129,19 +123,17 @@ describe("buildTemporalContext", () => {
       configuredUserTimeZone: "America/Los_Angeles",
       userTimeZone: "America/New_York",
     });
-    expect(result).toContain("Timezone: America/Los_Angeles");
-    expect(result).toContain("Current local time: 2026-02-18T04:00:00-08:00");
-    expect(result).toContain("Timezone source: user_settings");
+    expect(result).toContain("TZ: America/Los_Angeles");
+    expect(result).toContain("Today: 2026-02-18 (Wed) 04:00 -08:00");
   });
 
-  test("falls back to host timezone when user timezone is unavailable", () => {
+  test("falls back to host timezone with (host fallback) suffix", () => {
     const result = buildTemporalContext({
       nowMs: WED_FEB_18,
       hostTimeZone: "UTC",
       userTimeZone: null,
     });
-    expect(result).toContain("Timezone: UTC");
-    expect(result).toContain("Timezone source: assistant_host_fallback");
+    expect(result).toContain("TZ: UTC (host fallback)");
   });
 
   test("accepts UTC/GMT offset-style user timezone values", () => {
@@ -150,9 +142,9 @@ describe("buildTemporalContext", () => {
       hostTimeZone: "UTC",
       userTimeZone: "UTC+2",
     });
-    expect(result).toContain("Timezone: Etc/GMT-2");
-    expect(result).toContain("Current local time: 2026-02-18T14:00:00+02:00");
-    expect(result).toContain("Timezone source: user_profile_memory");
+    expect(result).toContain("TZ: Etc/GMT-2");
+    expect(result).toContain("Today: 2026-02-18 (Wed) 14:00 +02:00");
+    expect(result).not.toContain("(host fallback)");
   });
 
   test("accepts fractional UTC/GMT offset-style user timezone values", () => {
@@ -161,30 +153,30 @@ describe("buildTemporalContext", () => {
       hostTimeZone: "UTC",
       userTimeZone: "UTC+5:30",
     });
-    expect(result).toContain("Timezone: +05:30");
-    expect(result).toContain("Current local time: 2026-02-18T17:30:00+05:30");
-    expect(result).toContain("Timezone source: user_profile_memory");
+    expect(result).toContain("TZ: +05:30");
+    expect(result).toContain("Today: 2026-02-18 (Wed) 17:30 +05:30");
+    expect(result).not.toContain("(host fallback)");
   });
 
-  test("formats midnight hours as 00 (never 24) in local ISO output", () => {
+  test("formats midnight hours as 00 (never 24)", () => {
     const justAfterMidnight = Date.UTC(2026, 1, 19, 0, 5, 0);
     const result = buildTemporalContext({
       nowMs: justAfterMidnight,
       timeZone: "UTC",
     });
-    expect(result).toContain("Current local time: 2026-02-19T00:05:00+00:00");
-    expect(result).not.toContain("T24:05:00");
+    expect(result).toContain("00:05 +00:00");
+    expect(result).not.toContain("24:05");
   });
 
   test("Today line includes full YYYY-MM-DD format with year", () => {
     const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
-    expect(result).toMatch(/Today: \d{4}-\d{2}-\d{2} \(\w+\)/);
+    expect(result).toMatch(/Today: \d{4}-\d{2}-\d{2} \(\w{3}\) \d{2}:\d{2}/);
     expect(result).toContain("2026-02-18");
   });
 
   test("handles year boundary correctly", () => {
     const result = buildTemporalContext({ nowMs: TUE_DEC_29, timeZone: "UTC" });
-    expect(result).toContain("Today: 2026-12-29 (Tuesday)");
+    expect(result).toContain("Today: 2026-12-29 (Tue)");
   });
 });
 
@@ -198,8 +190,7 @@ describe("DST-safe timezone behavior", () => {
       nowMs: WED_FEB_18,
       timeZone: "America/New_York",
     });
-    expect(result).toContain("Today: 2026-02-18 (Wednesday)");
-    expect(result).toContain("Current local time: 2026-02-18T07:00:00-05:00");
+    expect(result).toContain("Today: 2026-02-18 (Wed) 07:00 -05:00");
   });
 
   test("date labels are correct in timezone ahead of UTC", () => {
@@ -209,7 +200,7 @@ describe("DST-safe timezone behavior", () => {
       nowMs: nearMidnight,
       timeZone: "Asia/Tokyo",
     });
-    expect(result).toContain("Today: 2026-02-19 (Thursday)");
+    expect(result).toContain("Today: 2026-02-19 (Thu) 08:00 +09:00");
   });
 
   test("local offset tracks daylight saving changes", () => {
@@ -219,7 +210,7 @@ describe("DST-safe timezone behavior", () => {
       nowMs: summer,
       timeZone: "America/New_York",
     });
-    expect(result).toContain("Current local time: 2026-07-01T08:00:00-04:00");
+    expect(result).toContain("Today: 2026-07-01 (Wed) 08:00 -04:00");
   });
 });
 
@@ -233,83 +224,72 @@ describe("extractUserTimeZoneFromRecall", () => {
     expect(extractUserTimeZoneFromRecall("  ")).toBeNull();
   });
 
-  test("extracts IANA timezone from user_identity section", () => {
+  test("extracts IANA timezone from identity item", () => {
     const text = `<memory_context __injected>
-
-<user_identity>
-User's timezone is America/New_York
-User works as a software engineer
-</user_identity>
-
+<recalled>
+<item id="item:1" kind="identity" importance="0.90" timestamp="2026-03-01 10:00 PST">User's timezone is America/New_York</item>
+<item id="item:2" kind="identity" importance="0.80" timestamp="2026-03-01 10:00 PST">User works as a software engineer</item>
+</recalled>
 </memory_context>`;
     expect(extractUserTimeZoneFromRecall(text)).toBe("America/New_York");
   });
 
-  test("extracts timezone from 'timezone: ...' line in identity", () => {
+  test("extracts timezone from 'timezone: ...' in identity item", () => {
     const text = `<memory_context __injected>
-
-<user_identity>
-- name: Alice
-- timezone: Europe/London
-- role: designer
-</user_identity>
-
+<recalled>
+<item id="item:1" kind="identity" importance="0.90" timestamp="2026-03-01 10:00 PST">timezone: Europe/London</item>
+<item id="item:2" kind="identity" importance="0.80" timestamp="2026-03-01 10:00 PST">name: Alice</item>
+</recalled>
 </memory_context>`;
     expect(extractUserTimeZoneFromRecall(text)).toBe("Europe/London");
   });
 
   test("extracts UTC offset timezone", () => {
     const text = `<memory_context __injected>
-
-<user_identity>
-User's time zone is UTC+5:30
-</user_identity>
-
+<recalled>
+<item id="item:1" kind="identity" importance="0.90" timestamp="2026-03-01 10:00 PST">User's time zone is UTC+5:30</item>
+</recalled>
 </memory_context>`;
     const result = extractUserTimeZoneFromRecall(text);
     expect(result).not.toBeNull();
     expect(result).toBe("+05:30");
   });
 
-  test("falls back to scanning full text when no identity section", () => {
+  test("falls back to scanning full text when no identity items", () => {
     const text = `<memory_context __injected>
-
-<relevant_context>
-<episode source="Mar 5">
-User mentioned their timezone is Asia/Tokyo
-</episode>
-</relevant_context>
-
+<recalled>
+<segment id="seg:1" timestamp="2026-03-05 10:00 PST">User mentioned their timezone is Asia/Tokyo</segment>
+</recalled>
 </memory_context>`;
     expect(extractUserTimeZoneFromRecall(text)).toBe("Asia/Tokyo");
   });
 
   test("returns null when no timezone info present", () => {
     const text = `<memory_context __injected>
-
-<user_identity>
-User's name is Bob
-User works at Acme Corp
-</user_identity>
-
+<recalled>
+<item id="item:1" kind="identity" importance="0.90" timestamp="2026-03-01 10:00 PST">User's name is Bob</item>
+<item id="item:2" kind="identity" importance="0.80" timestamp="2026-03-01 10:00 PST">User works at Acme Corp</item>
+</recalled>
 </memory_context>`;
     expect(extractUserTimeZoneFromRecall(text)).toBeNull();
   });
 
-  test("prefers identity section over other sections", () => {
+  test("prefers identity items over other recalled content", () => {
     const text = `<memory_context __injected>
-
-<user_identity>
-User's timezone is America/Chicago
-</user_identity>
-
-<relevant_context>
-<episode source="Mar 5">
-Discussed timezone America/Los_Angeles for the deployment
-</episode>
-</relevant_context>
-
+<recalled>
+<item id="item:1" kind="identity" importance="0.90" timestamp="2026-03-01 10:00 PST">User's timezone is America/Chicago</item>
+<segment id="seg:1" timestamp="2026-03-05 10:00 PST">Discussed timezone America/Los_Angeles for the deployment</segment>
+</recalled>
 </memory_context>`;
     expect(extractUserTimeZoneFromRecall(text)).toBe("America/Chicago");
   });
+
+  test("extracts timezone from identity item without timezone keyword via second pass", () => {
+    const text = `<memory_context __injected>
+<recalled>
+<item id="item:1" kind="identity" importance="0.90" timestamp="2026-03-01 10:00 PST">America/Denver</item>
+</recalled>
+</memory_context>`;
+    expect(extractUserTimeZoneFromRecall(text)).toBe("America/Denver");
+  });
 });

package/src/__tests__/db-conversation-fork-lineage-migration.test.ts

@@ -1,26 +1,10 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { rmSync } from "node:fs";
 import { Database } from "bun:sqlite";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
-
-const testDir = mkdtempSync(join(tmpdir(), "conversation-fork-lineage-"));
-const dbPath = join(testDir, "test.db");
 const originalBunTest = process.env.BUN_TEST;
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => dbPath,
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -32,6 +16,7 @@ import { initializeDb, resetDb } from "../memory/db.js";
 import { getSqliteFrom } from "../memory/db-connection.js";
 import { migrateConversationForkLineage } from "../memory/migrations/183-add-conversation-fork-lineage.js";
 import * as schema from "../memory/schema.js";
+import { getDbPath } from "../util/platform.js";
 
 function createTestDb() {
   const sqlite = new Database(":memory:");
@@ -42,7 +27,9 @@ function createTestDb() {
 
 function getColumnNames(raw: Database): string[] {
   return (
-    raw.query(`PRAGMA table_info(conversations)`).all() as Array<{ name: string }>
+    raw.query(`PRAGMA table_info(conversations)`).all() as Array<{
+      name: string;
+    }>
   ).map((column) => column.name);
 }
 
@@ -79,6 +66,7 @@ function bootstrapPreLineageConversations(raw: Database): void {
 
 function removeTestDbFiles(): void {
   resetDb();
+  const dbPath = getDbPath();
   rmSync(dbPath, { force: true });
   rmSync(`${dbPath}-shm`, { force: true });
   rmSync(`${dbPath}-wal`, { force: true });
@@ -93,17 +81,12 @@ describe("conversation fork lineage migration", () => {
   afterAll(() => {
     process.env.BUN_TEST = originalBunTest;
     removeTestDbFiles();
-    try {
-      rmSync(testDir, { recursive: true });
-    } catch {
-      /* best effort */
-    }
   });
 
   test("fresh DB initialization includes nullable lineage columns and parent lookup index", () => {
     initializeDb();
 
-    const raw = new Database(dbPath);
+    const raw = new Database(getDbPath());
     const columns = getColumnNames(raw);
 
     expect(columns).toContain("fork_parent_conversation_id");

package/src/__tests__/db-llm-request-log-provider-migration.test.ts

@@ -1,26 +1,18 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { rmSync } from "node:fs";
 import { Database } from "bun:sqlite";
-import { afterAll, afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
-
-const testDir = mkdtempSync(join(tmpdir(), "llm-request-log-provider-"));
-const dbPath = join(testDir, "test.db");
 const originalBunTest = process.env.BUN_TEST;
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => dbPath,
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -32,6 +24,7 @@ import { initializeDb, resetDb } from "../memory/db.js";
 import { getSqliteFrom } from "../memory/db-connection.js";
 import { migrateLlmRequestLogProvider } from "../memory/migrations/184-llm-request-log-provider.js";
 import * as schema from "../memory/schema.js";
+import { getDbPath } from "../util/platform.js";
 
 function createTestDb() {
   const sqlite = new Database(":memory:");
@@ -40,7 +33,9 @@ function createTestDb() {
   return drizzle(sqlite, { schema });
 }
 
-function getColumnInfo(raw: Database): Array<{ name: string; notnull: number }> {
+function getColumnInfo(
+  raw: Database,
+): Array<{ name: string; notnull: number }> {
   return raw.query(`PRAGMA table_info(llm_request_logs)`).all() as Array<{
     name: string;
     notnull: number;
@@ -61,6 +56,7 @@ function bootstrapPreProviderLlmRequestLogs(raw: Database): void {
 }
 
 function removeTestDbFiles(): void {
+  const dbPath = getDbPath();
   rmSync(dbPath, { force: true });
   rmSync(`${dbPath}-shm`, { force: true });
   rmSync(`${dbPath}-wal`, { force: true });
@@ -86,17 +82,12 @@ describe("llm_request_logs provider migration", () => {
     }
     resetDb();
     removeTestDbFiles();
-    try {
-      rmSync(testDir, { recursive: true });
-    } catch {
-      /* best effort */
-    }
   });
 
   test("fresh DB initialization includes llm_request_logs.provider", () => {
     initializeDb();
 
-    const raw = new Database(dbPath);
+    const raw = new Database(getDbPath());
     const columns = getColumnInfo(raw);
 
     expect(columns.some((column) => column.name === "provider")).toBe(true);
@@ -132,9 +123,9 @@ describe("llm_request_logs provider migration", () => {
 
     migrateLlmRequestLogProvider(db);
 
-    expect(getColumnInfo(raw).some((column) => column.name === "provider")).toBe(
-      true,
-    );
+    expect(
+      getColumnInfo(raw).some((column) => column.name === "provider"),
+    ).toBe(true);
 
     const row = raw
       .query(
@@ -142,17 +133,15 @@ describe("llm_request_logs provider migration", () => {
          FROM llm_request_logs
          WHERE id = 'log-upgrade'`,
       )
-      .get() as
-      | {
-          id: string;
-          conversation_id: string;
-          message_id: string | null;
-          provider: string | null;
-          request_payload: string;
-          response_payload: string;
-          created_at: number;
-        }
-      | null;
+      .get() as {
+      id: string;
+      conversation_id: string;
+      message_id: string | null;
+      provider: string | null;
+      request_payload: string;
+      response_payload: string;
+      created_at: number;
+    } | null;
 
     expect(row).toEqual({
       id: "log-upgrade",
@@ -200,9 +189,7 @@ describe("llm_request_logs provider migration", () => {
     expect(() => migrateLlmRequestLogProvider(db)).not.toThrow();
 
     const row = raw
-      .query(
-        `SELECT provider FROM llm_request_logs WHERE id = 'log-rerun'`,
-      )
+      .query(`SELECT provider FROM llm_request_logs WHERE id = 'log-rerun'`)
       .get() as { provider: string | null } | null;
 
     expect(row).toEqual({

package/src/__tests__/delete-managed-skill-tool.test.ts

@@ -5,17 +5,10 @@ import {
   rmSync,
   writeFileSync,
 } from "node:fs";
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-let TEST_DIR = "";
-
-mock.module("../util/platform.js", () => ({
-  getRootDir: () => TEST_DIR,
-  getWorkspaceSkillsDir: () => join(TEST_DIR, "skills"),
-}));
+const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -51,12 +44,11 @@ function createSkill(id: string): void {
 }
 
 beforeEach(() => {
-  TEST_DIR = mkdtempSync(join(tmpdir(), "delete-tool-test-"));
   mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
 });
 
 afterEach(() => {
-  rmSync(TEST_DIR, { recursive: true, force: true });
+  rmSync(join(TEST_DIR, "skills"), { recursive: true, force: true });
 });
 
 describe("delete_managed_skill tool", () => {

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

@@ -9,29 +9,12 @@
  * 4. Channel verification reply templates are non-empty and deterministic.
  */
 
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Test isolation: in-memory SQLite via temp directory
 // ---------------------------------------------------------------------------
 
-const testDir = mkdtempSync(join(tmpdir(), "deterministic-verify-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>, {
@@ -63,14 +46,6 @@ beforeEach(() => {
   initializeDb();
 });
 
-afterAll(() => {
-  try {
-    rmSync(testDir, { recursive: true, force: true });
-  } catch {
-    /* best effort */
-  }
-});
-
 // ---------------------------------------------------------------------------
 // Template tests: channel verification reply templates are deterministic
 // ---------------------------------------------------------------------------