@vellumai/assistant 0.6.0 → 0.6.2

package/src/__tests__/llm-request-log-turn-query.test.ts

@@ -301,6 +301,168 @@ describe("getRequestLogsByMessageId — turn-aware query", () => {
     expect(logs[2]?.id).toBe("log-surviving");
   });
 
+  test("recovers unlinked logs (messageId IS NULL) within the turn time range", () => {
+    // Simulate the race: logs recorded with NULL messageId, backfill hasn't run yet.
+    const T = 1_700_000_000_000;
+    const db = getDb();
+    const conv = createConversation("unlinked-test");
+
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('u1-ul', ${conv.id}, 'user', '"Do the task"', ${T})`,
+    );
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('a1-ul', ${conv.id}, 'assistant', '"Done!"', ${T + 30000})`,
+    );
+
+    // Unlinked log: messageId is NULL (backfill hasn't run yet)
+    db.insert(llmRequestLogs)
+      .values({
+        id: "log-unlinked-1",
+        conversationId: conv.id,
+        messageId: null,
+        provider: "anthropic",
+        requestPayload: '{"step":1}',
+        responsePayload: '{"tool":"bash"}',
+        createdAt: T + 5000,
+      })
+      .run();
+
+    // Linked log: already backfilled to the assistant message
+    db.insert(llmRequestLogs)
+      .values({
+        id: "log-linked-1",
+        conversationId: conv.id,
+        messageId: "a1-ul",
+        provider: "anthropic",
+        requestPayload: '{"step":2}',
+        responsePayload: '{"text":"Done!"}',
+        createdAt: T + 29_000,
+      })
+      .run();
+
+    const logs = getRequestLogsByMessageId("a1-ul");
+    expect(logs).toHaveLength(2);
+    expect(logs[0]?.id).toBe("log-unlinked-1");
+    expect(logs[1]?.id).toBe("log-linked-1");
+
+    // Verify opportunistic backfill ran: the unlinked log should now have a messageId
+    const backfilledLog = db
+      .select({ messageId: llmRequestLogs.messageId })
+      .from(llmRequestLogs)
+      .where(sql`${llmRequestLogs.id} = 'log-unlinked-1'`)
+      .get();
+    expect(backfilledLog?.messageId).toBe("a1-ul");
+  });
+
+  test("unlinked logs from different conversations don't bleed", () => {
+    const T = 1_700_000_000_000;
+    const db = getDb();
+    const convA = createConversation("conv-a");
+    const convB = createConversation("conv-b");
+
+    // Conversation A: user + assistant + unlinked log
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('u1-a', ${convA.id}, 'user', '"Hello A"', ${T})`,
+    );
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('a1-a', ${convA.id}, 'assistant', '"Hi A"', ${T + 10000})`,
+    );
+    db.insert(llmRequestLogs)
+      .values({
+        id: "log-conv-a",
+        conversationId: convA.id,
+        messageId: null,
+        provider: "anthropic",
+        requestPayload: '{"conv":"A"}',
+        responsePayload: '{"r":"A"}',
+        createdAt: T + 5000,
+      })
+      .run();
+
+    // Conversation B: user + assistant + unlinked log (overlapping timestamps)
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('u1-b', ${convB.id}, 'user', '"Hello B"', ${T})`,
+    );
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('a1-b', ${convB.id}, 'assistant', '"Hi B"', ${T + 10000})`,
+    );
+    db.insert(llmRequestLogs)
+      .values({
+        id: "log-conv-b",
+        conversationId: convB.id,
+        messageId: null,
+        provider: "anthropic",
+        requestPayload: '{"conv":"B"}',
+        responsePayload: '{"r":"B"}',
+        createdAt: T + 5000,
+      })
+      .run();
+
+    // Query from conv A → should only find conv A's log
+    const logsA = getRequestLogsByMessageId("a1-a");
+    expect(logsA).toHaveLength(1);
+    expect(logsA[0]?.id).toBe("log-conv-a");
+
+    // Query from conv B → should only find conv B's log
+    const logsB = getRequestLogsByMessageId("a1-b");
+    expect(logsB).toHaveLength(1);
+    expect(logsB[0]?.id).toBe("log-conv-b");
+  });
+
+  test("unlinked logs from different turns don't bleed", () => {
+    const T = 1_700_000_000_000;
+    const db = getDb();
+    const conv = createConversation("two-turn-unlinked");
+
+    // Turn 1: user → assistant (with linked log)
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('u1-t', ${conv.id}, 'user', '"Turn 1"', ${T})`,
+    );
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('a1-t', ${conv.id}, 'assistant', '"Answer 1"', ${T + 10000})`,
+    );
+    db.insert(llmRequestLogs)
+      .values({
+        id: "log-turn1-unlinked",
+        conversationId: conv.id,
+        messageId: null,
+        provider: "anthropic",
+        requestPayload: '{"turn":1}',
+        responsePayload: '{"r":1}',
+        createdAt: T + 5000,
+      })
+      .run();
+
+    // Turn 2: user → assistant (with unlinked log)
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('u2-t', ${conv.id}, 'user', '"Turn 2"', ${T + 60000})`,
+    );
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('a2-t', ${conv.id}, 'assistant', '"Answer 2"', ${T + 70000})`,
+    );
+    db.insert(llmRequestLogs)
+      .values({
+        id: "log-turn2-unlinked",
+        conversationId: conv.id,
+        messageId: null,
+        provider: "anthropic",
+        requestPayload: '{"turn":2}',
+        responsePayload: '{"r":2}',
+        createdAt: T + 65000,
+      })
+      .run();
+
+    // Query turn 2 → should only find turn 2's unlinked log
+    const turn2Logs = getRequestLogsByMessageId("a2-t");
+    expect(turn2Logs).toHaveLength(1);
+    expect(turn2Logs[0]?.id).toBe("log-turn2-unlinked");
+
+    // Query turn 1 → should only find turn 1's unlinked log
+    const turn1Logs = getRequestLogsByMessageId("a1-t");
+    expect(turn1Logs).toHaveLength(1);
+    expect(turn1Logs[0]?.id).toBe("log-turn1-unlinked");
+  });
+
   test("relinkLlmRequestLogs moves logs from deleted messages to consolidated message", async () => {
     const conv = createConversation("relink-test");
 

package/src/__tests__/log-export-workspace.test.ts

@@ -5,8 +5,6 @@
  * - audit-data.json with tool invocation records
  * - daemon-logs/ with log file contents
  * - config-snapshot.json with sanitized config
- * - workspace/ with text files, SQL dumps for .db files, and proper
- *   filtering (excluded directories, binary files, symlinks).
  */
 
 import { spawnSync } from "node:child_process";
@@ -16,7 +14,6 @@ import {
   readdirSync,
   readFileSync,
   rmSync,
-  symlinkSync,
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
@@ -24,8 +21,7 @@ import { join } from "node:path";
 import { describe, expect, mock, test } from "bun:test";
 
 // Set up temp directories before mocking
-const testDir = process.env.VELLUM_WORKSPACE_DIR!;
-const testWorkspaceDir = testDir;
+const testWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
 mkdirSync(testWorkspaceDir, { recursive: true });
 
 mock.module("../util/logger.js", () => ({
@@ -52,11 +48,13 @@ initializeDb();
 const routes = logExportRouteDefinitions();
 const exportRoute = routes.find((r) => r.endpoint === "export")!;
 
-async function callExport(): Promise<Response> {
+async function callExport(
+  body: Record<string, unknown> = {},
+): Promise<Response> {
   const req = new Request("http://localhost/v1/export", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({}),
+    body: JSON.stringify(body),
   });
   const url = new URL(req.url);
   return exportRoute.handler({
@@ -85,73 +83,66 @@ async function extractArchive(res: Response): Promise<string> {
   return extractDir;
 }
 
-/** Recursively lists all files under a directory as relative paths. */
-function listFiles(dir: string, base = dir): string[] {
-  const result: string[] = [];
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      result.push(...listFiles(full, base));
-    } else {
-      result.push(full.slice(base.length + 1));
-    }
-  }
-  return result;
-}
-
 // ---------------------------------------------------------------------------
-// Seed workspace files
+// Seed test data
 // ---------------------------------------------------------------------------
 
-// Text files — should be included
-writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), "# My Identity\nHello");
-mkdirSync(join(testWorkspaceDir, "notes"), { recursive: true });
-writeFileSync(join(testWorkspaceDir, "notes", "daily.txt"), "Some daily notes");
-
-// SQLite DB file — should be dumped as .sql
-mkdirSync(join(testWorkspaceDir, "data", "db"), { recursive: true });
-// Create a real sqlite db with a table
-import { Database } from "bun:sqlite";
-const wsDbPath = join(testWorkspaceDir, "data", "db", "assistant.db");
-const wsDb = new Database(wsDbPath);
-wsDb.run("CREATE TABLE test_table (id INTEGER PRIMARY KEY, name TEXT)");
-wsDb.run("INSERT INTO test_table (name) VALUES ('hello')");
-wsDb.close();
-
-// Excluded directory: embedding-models/
-mkdirSync(join(testWorkspaceDir, "embedding-models"), { recursive: true });
+// config.json at workspace root — needed for config-snapshot test
 writeFileSync(
-  join(testWorkspaceDir, "embedding-models", "model.bin"),
-  "large binary model data",
+  join(testWorkspaceDir, "config.json"),
+  JSON.stringify({ provider: "anthropic" }),
 );
 
-// Excluded directory: data/qdrant/
-mkdirSync(join(testWorkspaceDir, "data", "qdrant"), { recursive: true });
-writeFileSync(
-  join(testWorkspaceDir, "data", "qdrant", "index.bin"),
-  "vector index data",
+// Conversation directories — used for workspace allowlist tests
+const conversationsDir = join(testWorkspaceDir, "conversations");
+mkdirSync(conversationsDir, { recursive: true });
+
+function seedConversation(name: string, body: string) {
+  const dir = join(conversationsDir, name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "meta.json"), "{}\n");
+  writeFileSync(join(dir, "messages.jsonl"), body);
+}
+
+seedConversation(
+  "2025-01-10T00-00-00.000Z_conv-jan10",
+  '{"role":"user","content":"jan 10"}\n',
+);
+seedConversation(
+  "2025-01-15T00-00-00.000Z_conv-jan15",
+  '{"role":"user","content":"jan 15"}\n',
 );
+seedConversation(
+  "2025-01-20T00-00-00.000Z_conv-jan20",
+  '{"role":"user","content":"jan 20"}\n',
+);
+seedConversation(
+  "2025-01-25T00-00-00.000Z_conv-jan25",
+  '{"role":"user","content":"jan 25"}\n',
+);
+seedConversation("malformed-name", '{"role":"user","content":"x"}\n');
 
-// Binary file — should be skipped
+// Daemon log files — used for date filtering tests
+const logsDir = join(testWorkspaceDir, "data", "logs");
+mkdirSync(logsDir, { recursive: true });
 writeFileSync(
-  join(testWorkspaceDir, "binary-file.dat"),
-  Buffer.from([0x48, 0x65, 0x6c, 0x00, 0x6f]), // contains null byte
+  join(logsDir, "assistant-2025-01-10.log"),
+  "log entry from Jan 10\n",
 );
-
-// config.json at workspace root — should be skipped (already in configSnapshot)
 writeFileSync(
-  join(testWorkspaceDir, "config.json"),
-  JSON.stringify({ provider: "anthropic" }),
+  join(logsDir, "assistant-2025-01-15.log"),
+  "log entry from Jan 15\n",
 );
-
-// Symlink pointing outside workspace — should be skipped
-const outsideFile = join(testDir, "outside-secret.txt");
-writeFileSync(outsideFile, "sensitive data outside workspace");
-try {
-  symlinkSync(outsideFile, join(testWorkspaceDir, "sneaky-link.txt"));
-} catch {
-  // Symlink creation may fail on some platforms; tests will still pass
-}
+writeFileSync(
+  join(logsDir, "assistant-2025-01-20.log"),
+  "log entry from Jan 20\n",
+);
+writeFileSync(
+  join(logsDir, "assistant-2025-01-25.log"),
+  "log entry from Jan 25\n",
+);
+// Non-dated log file — should always be included regardless of time filter
+writeFileSync(join(logsDir, "vellum.log"), "non-dated log content\n");
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -185,90 +176,256 @@ describe("POST /v1/export — tar.gz archive", () => {
     }
   });
 
-  test("archive contains workspace text files", async () => {
+  test("archive contains config-snapshot.json when config exists", async () => {
     const res = await callExport();
     const dir = await extractArchive(res);
     try {
-      const identity = readFileSync(
-        join(dir, "workspace", "IDENTITY.md"),
+      const configContent = readFileSync(
+        join(dir, "config-snapshot.json"),
         "utf-8",
       );
-      expect(identity).toBe("# My Identity\nHello");
+      const parsed = JSON.parse(configContent);
+      expect(parsed.provider).toBe("anthropic");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
 
-      const daily = readFileSync(
-        join(dir, "workspace", "notes", "daily.txt"),
-        "utf-8",
-      );
-      expect(daily).toBe("Some daily notes");
+describe("POST /v1/export — daemon log date filtering", () => {
+  test("excludes log files before startTime", async () => {
+    // startTime = Jan 14 — should exclude assistant-2025-01-10.log
+    const startTime = new Date("2025-01-14T00:00:00.000Z").getTime();
+    const res = await callExport({ startTime });
+    const dir = await extractArchive(res);
+    try {
+      const logFiles = readdirSync(join(dir, "daemon-logs"));
+      expect(logFiles).not.toContain("assistant-2025-01-10.log");
+      expect(logFiles).toContain("assistant-2025-01-15.log");
+      expect(logFiles).toContain("assistant-2025-01-20.log");
+      expect(logFiles).toContain("assistant-2025-01-25.log");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  test("archive contains SQLite DB dumps as .sql files", async () => {
-    const res = await callExport();
+  test("excludes log files after endTime", async () => {
+    // endTime = Jan 22 — should exclude assistant-2025-01-25.log
+    const endTime = new Date("2025-01-22T00:00:00.000Z").getTime();
+    const res = await callExport({ endTime });
     const dir = await extractArchive(res);
     try {
-      const sqlContent = readFileSync(
-        join(dir, "workspace", "data", "db", "assistant.db.sql"),
-        "utf-8",
-      );
-      expect(sqlContent).toContain("CREATE TABLE");
-      expect(sqlContent).toContain("test_table");
+      const logFiles = readdirSync(join(dir, "daemon-logs"));
+      expect(logFiles).toContain("assistant-2025-01-10.log");
+      expect(logFiles).toContain("assistant-2025-01-15.log");
+      expect(logFiles).toContain("assistant-2025-01-20.log");
+      expect(logFiles).not.toContain("assistant-2025-01-25.log");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  test("archive excludes embedding-models/ and data/qdrant/", async () => {
+  test("filters log files by both startTime and endTime", async () => {
+    // startTime = Jan 14, endTime = Jan 22 — should only include Jan 15 and Jan 20
+    const startTime = new Date("2025-01-14T00:00:00.000Z").getTime();
+    const endTime = new Date("2025-01-22T00:00:00.000Z").getTime();
+    const res = await callExport({ startTime, endTime });
+    const dir = await extractArchive(res);
+    try {
+      const logFiles = readdirSync(join(dir, "daemon-logs"));
+      expect(logFiles).not.toContain("assistant-2025-01-10.log");
+      expect(logFiles).toContain("assistant-2025-01-15.log");
+      expect(logFiles).toContain("assistant-2025-01-20.log");
+      expect(logFiles).not.toContain("assistant-2025-01-25.log");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("always includes non-dated log files regardless of time filter", async () => {
+    const startTime = new Date("2025-01-14T00:00:00.000Z").getTime();
+    const endTime = new Date("2025-01-22T00:00:00.000Z").getTime();
+    const res = await callExport({ startTime, endTime });
+    const dir = await extractArchive(res);
+    try {
+      const logFiles = readdirSync(join(dir, "daemon-logs"));
+      expect(logFiles).toContain("vellum.log");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("includes all log files when no time filter is specified", async () => {
     const res = await callExport();
     const dir = await extractArchive(res);
     try {
-      const files = listFiles(join(dir, "workspace"));
-      const embeddingFiles = files.filter((f) =>
-        f.startsWith("embedding-models/"),
-      );
-      const qdrantFiles = files.filter((f) => f.startsWith("data/qdrant/"));
-      expect(embeddingFiles).toHaveLength(0);
-      expect(qdrantFiles).toHaveLength(0);
+      const logFiles = readdirSync(join(dir, "daemon-logs"));
+      expect(logFiles).toContain("assistant-2025-01-10.log");
+      expect(logFiles).toContain("assistant-2025-01-15.log");
+      expect(logFiles).toContain("assistant-2025-01-20.log");
+      expect(logFiles).toContain("assistant-2025-01-25.log");
+      expect(logFiles).toContain("vellum.log");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
+});
 
-  test("archive excludes binary files and config.json at workspace root", async () => {
+describe("POST /v1/export — workspace allowlist", () => {
+  test("includes all valid conversation dirs by default", async () => {
     const res = await callExport();
     const dir = await extractArchive(res);
     try {
-      const files = listFiles(join(dir, "workspace"));
-      expect(files).not.toContain("binary-file.dat");
-      expect(files).not.toContain("config.json");
+      const convs = readdirSync(join(dir, "workspace", "conversations"));
+      expect(convs).toContain("2025-01-10T00-00-00.000Z_conv-jan10");
+      expect(convs).toContain("2025-01-15T00-00-00.000Z_conv-jan15");
+      expect(convs).toContain("2025-01-20T00-00-00.000Z_conv-jan20");
+      expect(convs).toContain("2025-01-25T00-00-00.000Z_conv-jan25");
+      expect(convs).not.toContain("malformed-name");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  test("archive excludes symlinks", async () => {
+  test("skips malformed conversation dir names", async () => {
     const res = await callExport();
     const dir = await extractArchive(res);
     try {
-      const files = listFiles(join(dir, "workspace"));
-      expect(files).not.toContain("sneaky-link.txt");
+      const convs = readdirSync(join(dir, "workspace", "conversations"));
+      expect(convs).not.toContain("malformed-name");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  test("archive contains config-snapshot.json when config exists", async () => {
+  test("filters conversation dirs by startTime", async () => {
+    const startTime = Date.parse("2025-01-14T00:00:00Z");
+    const res = await callExport({ startTime });
+    const dir = await extractArchive(res);
+    try {
+      const convs = readdirSync(join(dir, "workspace", "conversations"));
+      expect(convs).not.toContain("2025-01-10T00-00-00.000Z_conv-jan10");
+      expect(convs).toContain("2025-01-15T00-00-00.000Z_conv-jan15");
+      expect(convs).toContain("2025-01-20T00-00-00.000Z_conv-jan20");
+      expect(convs).toContain("2025-01-25T00-00-00.000Z_conv-jan25");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("filters conversation dirs by endTime", async () => {
+    const endTime = Date.parse("2025-01-22T00:00:00Z");
+    const res = await callExport({ endTime });
+    const dir = await extractArchive(res);
+    try {
+      const convs = readdirSync(join(dir, "workspace", "conversations"));
+      expect(convs).toContain("2025-01-10T00-00-00.000Z_conv-jan10");
+      expect(convs).toContain("2025-01-15T00-00-00.000Z_conv-jan15");
+      expect(convs).toContain("2025-01-20T00-00-00.000Z_conv-jan20");
+      expect(convs).not.toContain("2025-01-25T00-00-00.000Z_conv-jan25");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("filters conversation dirs by both startTime and endTime", async () => {
+    const startTime = Date.parse("2025-01-14T00:00:00Z");
+    const endTime = Date.parse("2025-01-22T00:00:00Z");
+    const res = await callExport({ startTime, endTime });
+    const dir = await extractArchive(res);
+    try {
+      const convs = readdirSync(join(dir, "workspace", "conversations"));
+      expect(convs).not.toContain("2025-01-10T00-00-00.000Z_conv-jan10");
+      expect(convs).toContain("2025-01-15T00-00-00.000Z_conv-jan15");
+      expect(convs).toContain("2025-01-20T00-00-00.000Z_conv-jan20");
+      expect(convs).not.toContain("2025-01-25T00-00-00.000Z_conv-jan25");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("filters conversation dirs by conversationId", async () => {
+    const res = await callExport({ conversationId: "conv-jan15" });
+    const dir = await extractArchive(res);
+    try {
+      const convs = readdirSync(join(dir, "workspace", "conversations"));
+      expect(convs).toContain("2025-01-15T00-00-00.000Z_conv-jan15");
+      expect(convs).not.toContain("2025-01-10T00-00-00.000Z_conv-jan10");
+      expect(convs).not.toContain("2025-01-20T00-00-00.000Z_conv-jan20");
+      expect(convs).not.toContain("2025-01-25T00-00-00.000Z_conv-jan25");
+      expect(convs).not.toContain("malformed-name");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("conversationId + time filter intersect", async () => {
+    const res = await callExport({
+      conversationId: "conv-jan15",
+      startTime: Date.parse("2025-02-01T00:00:00Z"),
+    });
+    const dir = await extractArchive(res);
+    try {
+      const conversationsPath = join(dir, "workspace", "conversations");
+      let convs: string[] = [];
+      try {
+        convs = readdirSync(conversationsPath);
+      } catch {
+        // Directory does not exist — acceptable per the test contract.
+      }
+      expect(convs).toEqual([]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("conversation dir contents survive the round trip", async () => {
     const res = await callExport();
     const dir = await extractArchive(res);
     try {
-      const configContent = readFileSync(
-        join(dir, "config-snapshot.json"),
-        "utf-8",
+      const messagesPath = join(
+        dir,
+        "workspace",
+        "conversations",
+        "2025-01-15T00-00-00.000Z_conv-jan15",
+        "messages.jsonl",
       );
-      const parsed = JSON.parse(configContent);
-      expect(parsed.provider).toBe("anthropic");
+      const content = readFileSync(messagesPath, "utf-8");
+      expect(content).toBe('{"role":"user","content":"jan 15"}\n');
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("treats empty-string conversationId as no filter", async () => {
+    const res = await callExport({ conversationId: "" });
+    const dir = await extractArchive(res);
+    try {
+      // With conversationId === "" (which the rest of handleExport treats as
+      // unfiltered), workspace conversations should also be unfiltered. All
+      // four canonical conversation dirs should be present.
+      const conversationsDir = join(dir, "workspace", "conversations");
+      const entries = readdirSync(conversationsDir);
+      expect(entries).toContain("2025-01-10T00-00-00.000Z_conv-jan10");
+      expect(entries).toContain("2025-01-15T00-00-00.000Z_conv-jan15");
+      expect(entries).toContain("2025-01-20T00-00-00.000Z_conv-jan20");
+      expect(entries).toContain("2025-01-25T00-00-00.000Z_conv-jan25");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("treats startTime=0 and endTime=0 as no filter", async () => {
+    const res = await callExport({ startTime: 0, endTime: 0 });
+    const dir = await extractArchive(res);
+    try {
+      const conversationsDir = join(dir, "workspace", "conversations");
+      const entries = readdirSync(conversationsDir);
+      // All four canonical conversation dirs should be present (no filtering).
+      expect(entries).toContain("2025-01-10T00-00-00.000Z_conv-jan10");
+      expect(entries).toContain("2025-01-15T00-00-00.000Z_conv-jan15");
+      expect(entries).toContain("2025-01-20T00-00-00.000Z_conv-jan20");
+      expect(entries).toContain("2025-01-25T00-00-00.000Z_conv-jan25");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }