@vellumai/assistant 0.4.56 → 0.5.0

package/src/__tests__/memory-regressions.test.ts

@@ -67,8 +67,8 @@ import { and, eq } from "drizzle-orm";
 import { DEFAULT_CONFIG } from "../config/defaults.js";
 import { vectorToBlob } from "../memory/job-utils.js";
 
-// Disable LLM extraction in tests to avoid real API calls and ensure
-// deterministic pattern-based extraction.
+// Disable LLM extraction and summarization in tests to avoid real API calls
+// and ensure deterministic pattern-based extraction / fallback summaries.
 const TEST_CONFIG = {
   ...DEFAULT_CONFIG,
   memory: {
@@ -77,6 +77,10 @@ const TEST_CONFIG = {
       ...DEFAULT_CONFIG.memory.extraction,
       useLLM: false,
     },
+    summarization: {
+      ...DEFAULT_CONFIG.memory.summarization,
+      useLLM: false,
+    },
   },
 };
 
@@ -86,6 +90,7 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
 }));
 import { estimateTextTokens } from "../context/token-estimator.js";
+import { stripUserTextBlocksByPrefix } from "../daemon/conversation-runtime-assembly.js";
 import {
   getMemorySystemStatus,
   requestMemoryBackfill,
@@ -120,8 +125,7 @@ import {
   escapeXmlTags,
   formatAbsoluteTime,
   formatRelativeTime,
-  injectMemoryRecallAsSeparateMessage,
-  stripMemoryRecallMessages,
+  injectMemoryRecallAsUserBlock,
 } from "../memory/retriever.js";
 import {
   conversations,
@@ -133,6 +137,7 @@ import {
   messages,
 } from "../memory/schema.js";
 import { buildCoreIdentityContext } from "../prompts/system-prompt.js";
+import type { Message } from "../providers/types.js";
 
 describe("Memory regressions", () => {
   beforeAll(() => {
@@ -308,133 +313,124 @@ describe("Memory regressions", () => {
     expect(recall.enabled).toBe(true);
   });
 
-  test("memory recall injection via separate message and stripped from runtime history", () => {
+  test("memory recall injection as user block and stripped from runtime history", () => {
     const memoryRecallText =
-      "<memory_context>\n\n<relevant_context>\nuser prefers concise answers\n</relevant_context>\n\n</memory_context>";
-    const originalMessages = [
+      "<memory_context __injected>\n\n<relevant_context>\nuser prefers concise answers\n</relevant_context>\n\n</memory_context>";
+    const originalMessages: Message[] = [
       {
-        role: "user" as const,
-        content: [{ type: "text", text: "Actual user request" }],
+        role: "user",
+        content: [{ type: "text" as const, text: "Actual user request" }],
       },
     ];
-    const injected = injectMemoryRecallAsSeparateMessage(
+    const injected = injectMemoryRecallAsUserBlock(
       originalMessages,
       memoryRecallText,
     );
 
-    expect(injected).toHaveLength(3);
+    // Memory context prepended to last user message as content block
+    expect(injected).toHaveLength(1);
     expect(injected[0].role).toBe("user");
-    expect(injected[0].content[0].text).toBe(memoryRecallText);
-    expect(injected[1].role as string).toBe("assistant");
-    expect(injected[2].role).toBe("user");
-    expect(injected[2].content[0].text).toBe("Actual user request");
-
-    const cleaned = stripMemoryRecallMessages(injected, memoryRecallText);
+    expect(injected[0].content).toHaveLength(2);
+    const b0 = injected[0].content[0];
+    const b1 = injected[0].content[1];
+    expect(b0.type === "text" && b0.text).toBe(memoryRecallText);
+    expect(b1.type === "text" && b1.text).toBe("Actual user request");
+
+    // Stripped by prefix-based stripping
+    const cleaned = stripUserTextBlocksByPrefix(injected, [
+      "<memory_context __injected>",
+    ]);
     expect(cleaned).toHaveLength(1);
-    expect(cleaned[0].content[0].text).toBe("Actual user request");
+    expect(cleaned[0].content).toHaveLength(1);
+    const cb0 = cleaned[0].content[0];
+    expect(cb0.type === "text" && cb0.text).toBe("Actual user request");
   });
 
-  test("recall stripping removes last matching block in merged content after deep-repair", () => {
+  test("prefix-based stripping removes all <memory_context> blocks from merged content", () => {
     const memoryRecallText =
-      "[Memory Recall v1]\n- [item:abc] user prefers concise answers";
-    // Simulate deep-repair merging two consecutive user messages where both
-    // contain the recall text. The injected (active) recall block is the last one.
-    const mergedUserMessage = {
-      role: "user" as const,
+      "<memory_context __injected>\n\n<relevant_context>\nuser prefers concise answers\n</relevant_context>\n\n</memory_context>";
+    // Simulate deep-repair merging where multiple memory context blocks exist.
+    // Prefix-based stripping removes all blocks starting with <memory_context __injected>.
+    const mergedUserMessage: Message = {
+      role: "user",
       content: [
-        { type: "text", text: memoryRecallText },
-        { type: "text", text: "Earlier user request" },
-        { type: "text", text: memoryRecallText },
-        { type: "text", text: "Latest user request" },
+        { type: "text" as const, text: memoryRecallText },
+        { type: "text" as const, text: "Earlier user request" },
+        { type: "text" as const, text: memoryRecallText },
+        { type: "text" as const, text: "Latest user request" },
       ],
     };
 
-    const cleaned = stripMemoryRecallMessages(
+    const cleaned = stripUserTextBlocksByPrefix(
       [mergedUserMessage],
-      memoryRecallText,
+      ["<memory_context __injected>"],
     );
     expect(cleaned).toHaveLength(1);
-    // The last (active) recall block should be stripped, the first (leaked) one preserved
     expect(cleaned[0].content).toEqual([
-      { type: "text", text: memoryRecallText },
       { type: "text", text: "Earlier user request" },
       { type: "text", text: "Latest user request" },
     ]);
   });
 
-  test("separate_context_message injects memory as user+assistant pair before last user message", () => {
-    const history = [
-      { role: "user" as const, content: [{ type: "text", text: "Hello" }] },
-      { role: "assistant" as const, content: [{ type: "text", text: "Hi!" }] },
+  test("injectMemoryRecallAsUserBlock prepends memory to last user message", () => {
+    const history: Message[] = [
+      { role: "user", content: [{ type: "text" as const, text: "Hello" }] },
+      { role: "assistant", content: [{ type: "text" as const, text: "Hi!" }] },
       {
-        role: "user" as const,
-        content: [{ type: "text", text: "Tell me about X" }],
+        role: "user",
+        content: [{ type: "text" as const, text: "Tell me about X" }],
       },
     ];
-    const recallText = "<memory>Some recalled fact</memory>";
-    const result = injectMemoryRecallAsSeparateMessage(history, recallText);
-    // Should have 5 messages: original 2 + injected user + injected assistant ack + original last user
-    expect(result).toHaveLength(5);
+    const recallText =
+      "<memory_context __injected>\n\n<relevant_context>\nSome recalled fact\n</relevant_context>\n\n</memory_context>";
+    const result = injectMemoryRecallAsUserBlock(history, recallText);
+    // Same number of messages — no synthetic pair
+    expect(result).toHaveLength(3);
     expect(result[0]).toBe(history[0]);
     expect(result[1]).toBe(history[1]);
-    // Injected context message
-    expect(result[2].role).toBe("user");
-    expect(result[2].content).toEqual([{ type: "text", text: recallText }]);
-    // Assistant acknowledgment
-    expect(result[3].role).toBe("assistant");
-    expect(result[3].content).toEqual([
-      { type: "text", text: "[Memory context loaded.]" },
-    ]);
-    // Original user message preserved unchanged
-    expect(result[4]).toBe(history[2]);
+    // Last user message has memory prepended
+    const r0 = result[2].content[0];
+    const r1 = result[2].content[1];
+    expect(r0.type === "text" && r0.text).toBe(recallText);
+    expect(r1.type === "text" && r1.text).toBe("Tell me about X");
   });
 
-  test("separate_context_message with empty text is a no-op", () => {
-    const history = [
-      { role: "user" as const, content: [{ type: "text", text: "Hello" }] },
+  test("injectMemoryRecallAsUserBlock with empty text is a no-op", () => {
+    const history: Message[] = [
+      { role: "user", content: [{ type: "text" as const, text: "Hello" }] },
     ];
-    const result = injectMemoryRecallAsSeparateMessage(history, "  ");
+    const result = injectMemoryRecallAsUserBlock(history, "  ");
     expect(result).toBe(history);
   });
 
-  test("stripMemoryRecallMessages removes separate_context_message pair", () => {
-    const recallText = "<memory>Some recalled fact</memory>";
-    const messages = [
-      { role: "user" as const, content: [{ type: "text", text: "Hello" }] },
-      { role: "assistant" as const, content: [{ type: "text", text: "Hi!" }] },
-      // Injected context message pair
-      { role: "user" as const, content: [{ type: "text", text: recallText }] },
+  test("stripUserTextBlocksByPrefix removes memory_context block from user message", () => {
+    const recallText =
+      "<memory_context __injected>\n\n<relevant_context>\nSome recalled fact\n</relevant_context>\n\n</memory_context>";
+    const msgs: Message[] = [
+      { role: "user", content: [{ type: "text" as const, text: "Hello" }] },
       {
-        role: "assistant" as const,
-        content: [{ type: "text", text: "[Memory context loaded.]" }],
-      },
-      // Real user message
-      {
-        role: "user" as const,
-        content: [{ type: "text", text: "Tell me about X" }],
+        role: "assistant",
+        content: [{ type: "text" as const, text: "Hi!" }],
       },
-    ];
-    const cleaned = stripMemoryRecallMessages(messages, recallText);
-    expect(cleaned).toHaveLength(3);
-    expect(cleaned[0].content[0].text).toBe("Hello");
-    expect(cleaned[1].content[0].text).toBe("Hi!");
-    expect(cleaned[2].content[0].text).toBe("Tell me about X");
-  });
-
-  test("stripMemoryRecallMessages falls back to prepend_user_block when no separate pair found", () => {
-    const recallText = "<memory>Fact</memory>";
-    const messages = [
       {
-        role: "user" as const,
+        role: "user",
         content: [
-          { type: "text", text: recallText },
-          { type: "text", text: "User query" },
+          { type: "text" as const, text: recallText },
+          { type: "text" as const, text: "Tell me about X" },
         ],
       },
     ];
-    const cleaned = stripMemoryRecallMessages(messages, recallText);
-    expect(cleaned).toHaveLength(1);
-    expect(cleaned[0].content).toEqual([{ type: "text", text: "User query" }]);
+    const cleaned = stripUserTextBlocksByPrefix(msgs, [
+      "<memory_context __injected>",
+    ]);
+    expect(cleaned).toHaveLength(3);
+    const c0 = cleaned[0].content[0];
+    const c1 = cleaned[1].content[0];
+    const c2 = cleaned[2].content[0];
+    expect(c0.type === "text" && c0.text).toBe("Hello");
+    expect(c1.type === "text" && c1.text).toBe("Hi!");
+    expect(cleaned[2].content).toHaveLength(1);
+    expect(c2.type === "text" && c2.text).toBe("Tell me about X");
   });
 
   test("aborting memory recall embedding returns a non-degraded aborted recall result", async () => {
@@ -1819,7 +1815,7 @@ describe("Memory regressions", () => {
         totalOutputTokens: 0,
         totalEstimatedCost: 0,
         contextSummary: null,
-        contextCompactedMessageCount: 0,
+        contextCompactedMessageCount: 1,
         contextCompactedAt: null,
       })
       .run();
@@ -2064,7 +2060,7 @@ describe("Memory regressions", () => {
         totalOutputTokens: 0,
         totalEstimatedCost: 0,
         contextSummary: null,
-        contextCompactedMessageCount: 0,
+        contextCompactedMessageCount: 1,
         contextCompactedAt: null,
       })
       .run();
@@ -2138,7 +2134,7 @@ describe("Memory regressions", () => {
         totalOutputTokens: 0,
         totalEstimatedCost: 0,
         contextSummary: null,
-        contextCompactedMessageCount: 0,
+        contextCompactedMessageCount: 1,
         contextCompactedAt: null,
       })
       .run();

package/src/__tests__/migration-cross-version-compatibility.test.ts

@@ -53,13 +53,14 @@ function toArrayBuffer(data: Uint8Array): ArrayBuffer {
 const testDir = realpathSync(
   mkdtempSync(join(tmpdir(), "migration-cross-version-test-")),
 );
-const testDbDir = join(testDir, "db");
+const testDbDir = join(testDir, "data", "db");
 const testDbPath = join(testDbDir, "assistant.db");
 const testConfigPath = join(testDir, "config.json");
 
 mock.module("../util/platform.js", () => ({
   getRootDir: () => testDir,
-  getDataDir: () => testDir,
+  getDataDir: () => join(testDir, "data"),
+  getWorkspaceDir: () => testDir,
   getWorkspaceConfigPath: () => testConfigPath,
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
@@ -83,9 +84,8 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
-    sandbox: { enabled: false },
   }),
 }));
 
@@ -445,7 +445,7 @@ describe("schema version compatibility", () => {
       { schema_version: "3.0" },
     );
 
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const result = commitImport({
       archiveData: vbundle,
       pathResolver: resolver,
@@ -463,7 +463,7 @@ describe("schema version compatibility", () => {
       schema_version: "5.0-beta",
     });
 
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const validationResult = validateVBundle(vbundle);
     expect(validationResult.manifest).toBeDefined();
 
@@ -774,9 +774,10 @@ describe("round-trip: export -> validate -> preflight -> import", () => {
     expect(preflightBody.files).toBeDefined();
     expect(preflightBody.manifest).toBeDefined();
 
-    // The files should show "unchanged" since we exported from the same disk
+    // The files should show "unchanged" since we exported from the same disk.
+    // New format uses workspace/ prefix for archive paths.
     const dbFile = preflightBody.files!.find(
-      (f) => f.path === "data/db/assistant.db",
+      (f) => f.path === "workspace/data/db/assistant.db",
     );
     expect(dbFile).toBeDefined();
     expect(dbFile!.action).toBe("unchanged");
@@ -829,7 +830,7 @@ describe("round-trip: export -> validate -> preflight -> import", () => {
     );
 
     // Step 3: Analyze (preflight)
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const report = analyzeImport({
       manifest: validationResult.manifest!,
       pathResolver: resolver,
@@ -888,13 +889,14 @@ describe("partial failure scenarios", () => {
       { path: "data/db/assistant.db", data: newDbData },
     ]);
 
-    // Point to a path that cannot be written (a non-existent deeply nested
-    // directory whose parent is a regular file, not a directory)
-    const blockerPath = join(testDir, "blocker-file");
-    writeFileSync(blockerPath, "I am a file, not a directory");
-    const impossibleDbPath = join(blockerPath, "nested", "deep", "db.db");
+    // Point to a workspace path where data/db cannot be created
+    // (a regular file blocks directory creation)
+    const blockerWorkspace = join(testDir, "blocker-workspace");
+    mkdirSync(blockerWorkspace, { recursive: true });
+    // Create "data" as a regular file — mkdirSync("data/db") will fail
+    writeFileSync(join(blockerWorkspace, "data"), "I am a file, not a directory");
 
-    const resolver = new DefaultPathResolver(impossibleDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, blockerWorkspace);
     const result = commitImport({
       archiveData: vbundle,
       pathResolver: resolver,
@@ -908,11 +910,11 @@ describe("partial failure scenarios", () => {
     }
 
     // Clean up
-    rmSync(blockerPath, { force: true });
+    rmSync(blockerWorkspace, { recursive: true, force: true });
   });
 
   test("commitImport with invalid archive returns validation_failed", () => {
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const result = commitImport({
       archiveData: new Uint8Array([0xba, 0xad, 0xf0, 0x0d]),
       pathResolver: resolver,
@@ -1000,7 +1002,7 @@ describe("partial failure scenarios", () => {
     ]);
     const corruptVBundle = gzipSync(tar);
 
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const result = commitImport({
       archiveData: corruptVBundle,
       pathResolver: resolver,
@@ -1032,7 +1034,7 @@ describe("edge cases", () => {
     expect(result.manifest?.files[0].size).toBe(0);
 
     // Import should also succeed
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const importResult = commitImport({
       archiveData: vbundle,
       pathResolver: resolver,
@@ -1186,7 +1188,10 @@ describe("edge cases", () => {
     expect(missingError!.message).toContain("data/extra/ghost.bin");
   });
 
-  test("bundle with only manifest (no required db) fails validation", () => {
+  test("bundle with only manifest (no data files) is valid", () => {
+    // After the workspace walk refactor, only manifest.json is required.
+    // A bundle with no data files is structurally valid — it just won't
+    // restore anything meaningful.
     const manifestWithoutChecksum = {
       schema_version: "1.0",
       created_at: new Date().toISOString(),
@@ -1205,12 +1210,7 @@ describe("edge cases", () => {
     const vbundle = gzipSync(tar);
     const result = validateVBundle(vbundle);
 
-    expect(result.is_valid).toBe(false);
-    expect(
-      result.errors.some(
-        (e) => e.code === "MISSING_ENTRY" && e.path === "data/db/assistant.db",
-      ),
-    ).toBe(true);
+    expect(result.is_valid).toBe(true);
   });
 
   test("completely empty gzip content (no tar entries) fails gracefully", () => {
@@ -1424,7 +1424,7 @@ describe("diagnostic quality", () => {
   });
 
   test("import commit validation_failed response includes error codes and messages", () => {
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const result = commitImport({
       archiveData: new Uint8Array([0x00]),
       pathResolver: resolver,
@@ -1633,7 +1633,7 @@ describe("builder -> validator consistency", () => {
 
 describe("import analyzer edge cases", () => {
   test("all-unchanged files produce correct summary", () => {
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const existingConfig = new Uint8Array(readFileSync(testConfigPath));
 
     const report = analyzeImport({
@@ -1666,8 +1666,8 @@ describe("import analyzer edge cases", () => {
 
   test("all-create scenario (fresh install) produces correct summary", () => {
     const resolver = new DefaultPathResolver(
-      join(testDir, "nonexistent-dir", "db.db"),
-      join(testDir, "nonexistent-dir", "config.json"),
+      undefined,
+      join(testDir, "nonexistent-workspace"),
     );
 
     const report = analyzeImport({
@@ -1698,7 +1698,7 @@ describe("import analyzer edge cases", () => {
   });
 
   test("mixed create/overwrite/unchanged produces accurate counts", () => {
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
 
     // db: different from disk -> overwrite
     // config: same as disk -> unchanged
@@ -1731,7 +1731,7 @@ describe("import analyzer edge cases", () => {
   });
 
   test("unknown archive path produces UNKNOWN_ARCHIVE_PATH conflict", () => {
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
 
     const report = analyzeImport({
       manifest: {

package/src/__tests__/migration-export-http.test.ts

@@ -27,13 +27,14 @@ import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test";
 const testDir = realpathSync(
   mkdtempSync(join(tmpdir(), "migration-export-http-test-")),
 );
-const testDbDir = join(testDir, "db");
+const testDbDir = join(testDir, "data", "db");
 const testDbPath = join(testDbDir, "assistant.db");
 const testConfigPath = join(testDir, "config.json");
 
 mock.module("../util/platform.js", () => ({
   getRootDir: () => testDir,
-  getDataDir: () => testDir,
+  getDataDir: () => join(testDir, "data"),
+  getWorkspaceDir: () => testDir,
   getWorkspaceConfigPath: () => testConfigPath,
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
@@ -57,9 +58,8 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
-    sandbox: { enabled: false },
   }),
 }));
 
@@ -206,10 +206,10 @@ describe("handleMigrationExport", () => {
     expect(manifest.created_at).toBeDefined();
     expect(manifest.manifest_sha256).toBeDefined();
 
-    // Verify file entries
+    // Verify file entries — workspace walk uses workspace/ prefix
     const filePaths = manifest.files.map((f) => f.path);
-    expect(filePaths).toContain("data/db/assistant.db");
-    expect(filePaths).toContain("config/settings.json");
+    expect(filePaths).toContain("workspace/data/db/assistant.db");
+    expect(filePaths).toContain("workspace/config.json");
 
     // Verify each file entry has proper sha256 and size
     for (const file of manifest.files) {
@@ -299,7 +299,7 @@ describe("export data population", () => {
     const archiveData = new Uint8Array(await res.arrayBuffer());
     const entries = parseTarEntries(archiveData);
 
-    const dbEntry = entries.find((e) => e.name === "data/db/assistant.db");
+    const dbEntry = entries.find((e) => e.name === "workspace/data/db/assistant.db");
     expect(dbEntry).toBeDefined();
     expect(dbEntry!.data.length).toBe(SQLITE_HEADER.length);
     // Verify the exported data matches the test fixture exactly
@@ -315,7 +315,7 @@ describe("export data population", () => {
     const archiveData = new Uint8Array(await res.arrayBuffer());
     const entries = parseTarEntries(archiveData);
 
-    const configEntry = entries.find((e) => e.name === "config/settings.json");
+    const configEntry = entries.find((e) => e.name === "workspace/config.json");
     expect(configEntry).toBeDefined();
 
     const configContent = new TextDecoder().decode(configEntry!.data);
@@ -336,13 +336,13 @@ describe("export data population", () => {
     const manifest = validationResult.manifest!;
 
     const dbFile = manifest.files.find(
-      (f) => f.path === "data/db/assistant.db",
+      (f) => f.path === "workspace/data/db/assistant.db",
     );
     expect(dbFile).toBeDefined();
     expect(dbFile!.size).toBe(SQLITE_HEADER.length);
 
     const configFile = manifest.files.find(
-      (f) => f.path === "config/settings.json",
+      (f) => f.path === "workspace/config.json",
     );
     expect(configFile).toBeDefined();
     const expectedConfigSize = Buffer.byteLength(
@@ -382,7 +382,7 @@ describe("export data population", () => {
     const manifest = validationResult.manifest!;
 
     const dbFile = manifest.files.find(
-      (f) => f.path === "data/db/assistant.db",
+      (f) => f.path === "workspace/data/db/assistant.db",
     );
     expect(dbFile).toBeDefined();
     // The skeleton used size 0 — real export should have actual content
@@ -398,7 +398,7 @@ describe("export data population", () => {
     const archiveData = new Uint8Array(await res.arrayBuffer());
     const entries = parseTarEntries(archiveData);
 
-    const configEntry = entries.find((e) => e.name === "config/settings.json");
+    const configEntry = entries.find((e) => e.name === "workspace/config.json");
     expect(configEntry).toBeDefined();
 
     const configContent = new TextDecoder().decode(configEntry!.data);
@@ -413,42 +413,41 @@ describe("export data population", () => {
 // ---------------------------------------------------------------------------
 
 describe("export graceful fallback", () => {
-  test("missing database produces valid archive with empty db entry", async () => {
+  test("nonexistent workspace produces valid archive with no files", async () => {
     const { buildExportVBundle } =
       await import("../runtime/migrations/vbundle-builder.js");
 
     const result = buildExportVBundle({
-      dbPath: join(testDir, "nonexistent.db"),
-      configPath: testConfigPath,
+      workspaceDir: join(testDir, "nonexistent-workspace"),
     });
 
     const validationResult = validateVBundle(result.archive);
     expect(validationResult.is_valid).toBe(true);
-
-    const dbFile = result.manifest.files.find(
-      (f) => f.path === "data/db/assistant.db",
-    );
-    expect(dbFile).toBeDefined();
-    expect(dbFile!.size).toBe(0);
+    expect(result.manifest.files).toHaveLength(0);
   });
 
-  test("missing config produces valid archive with empty JSON config", async () => {
+  test("workspace walk includes db and config under workspace/ prefix", async () => {
     const { buildExportVBundle } =
       await import("../runtime/migrations/vbundle-builder.js");
 
     const result = buildExportVBundle({
-      dbPath: testDbPath,
-      configPath: join(testDir, "nonexistent-config.json"),
+      workspaceDir: testDir,
     });
 
     const validationResult = validateVBundle(result.archive);
     expect(validationResult.is_valid).toBe(true);
 
+    const dbFile = result.manifest.files.find(
+      (f) => f.path === "workspace/data/db/assistant.db",
+    );
+    expect(dbFile).toBeDefined();
+    expect(dbFile!.size).toBeGreaterThan(0);
+
     const configFile = result.manifest.files.find(
-      (f) => f.path === "config/settings.json",
+      (f) => f.path === "workspace/config.json",
     );
     expect(configFile).toBeDefined();
-    expect(configFile!.size).toBe(2); // "{}" is 2 bytes
+    expect(configFile!.size).toBeGreaterThan(0);
   });
 });