@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -148,7 +148,7 @@ mock.module(
 // agent loop's compaction path consumes, mirroring the real manager's
 // `overflowStepToResult` so the loop sees the rung's reduced history, injection
 // mode, terminal auto-compress flag, and exhaustion.
-function makeOverflowLadderStub(): {
+function makeOverflowLadderStub(stubOpts: { maxInputTokens?: number } = {}): {
   resetOverflowRecovery: () => void;
   reduceOverflowOneRung: (
     msgs: Message[],
@@ -161,6 +161,7 @@ function makeOverflowLadderStub(): {
     signal?: AbortSignal,
   ) => Promise<unknown>;
 } {
+  const maxInputTokens = stubOpts.maxInputTokens ?? 200_000;
   let state: unknown;
   const reduceOverflowOneRung = async (msgs: Message[], opts: unknown) => {
     if (!state) {
@@ -178,7 +179,26 @@ function makeOverflowLadderStub(): {
     },
     reduceOverflowOneRung,
     recoverContextOverflow: async (msgs: Message[], opts: unknown) => {
-      const step = (await reduceOverflowOneRung(msgs, opts)) as {
+      const options = opts as {
+        actualTokens: number | null;
+        isInteractive: boolean;
+      };
+      // Mirror ContextWindowManager.deriveOverflowTurnTarget: compute the
+      // estimation-error-corrected target and include it in the opts the
+      // mock reducer receives, so tests can assert on targetTokens.
+      const estimatedInputTokens = estimatePromptTokens(msgs);
+      const preflightBudget = Math.floor(maxInputTokens * 0.95);
+      const { targetTokens } = computeCorrectedOverflowTarget({
+        preflightBudget,
+        actualTokens: options.actualTokens,
+        estimatedTokens: estimatedInputTokens,
+      });
+      const enrichedOpts = {
+        ...options,
+        targetTokens,
+        estimatedInputTokens,
+      };
+      const step = (await reduceOverflowOneRung(msgs, enrichedOpts)) as {
         messages: Message[];
         estimatedTokens?: number;
         state: {
@@ -460,9 +480,11 @@ mock.module("../memory/archive-store.js", () => ({
 // ── Imports (after mocks) ────────────────────────────────────────────
 
 import { AgentLoop } from "../agent/loop.js";
+import { estimatePromptTokens } from "../context/token-estimator.js";
 import type { Conversation } from "../daemon/conversation.js";
 import { runAgentLoopImpl } from "../daemon/conversation-agent-loop.js";
 import type { QueueDrainReason } from "../daemon/conversation-queue-manager.js";
+import { computeCorrectedOverflowTarget } from "../plugins/defaults/compaction/corrected-target.js";
 import { asConversation } from "./helpers/mock-conversation.js";
 import {
   createMockProvider,
@@ -748,96 +770,83 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
   });
 
   // ── Test 1 ────────────────────────────────────────────────────────
-  // BUG: When the agent loop makes progress (adds messages to history)
-  // before hitting context_too_large, the convergence loop's progress
-  // check must recognize that the loop appended messages. If it fails to,
-  // the reducer is never invoked — the error is surfaced immediately
-  // without any compaction attempt.
-  //
-  // Expected behavior (PR 2 fix): After progress + context_too_large,
-  // the system should still attempt compaction before surfacing error.
-  test.todo(
-    "context too large after progress triggers compaction retry instead of immediate failure",
-    async () => {
-      const events: AssistantEvent[] = [];
-      let reducerCalled = false;
+  // Verifies overflow recovery fires even when the agent made tool-use progress
+  // before hitting context_too_large. The convergence path must not skip
+  // compaction just because messages were appended earlier in the turn.
+  test("context too large after progress triggers compaction retry instead of immediate failure", async () => {
+    const events: AssistantEvent[] = [];
+    let reducerCalled = false;
 
-      mockReducerStepFn = (msgs: Message[]) => {
-        reducerCalled = true;
-        return {
+    mockReducerStepFn = (msgs: Message[]) => {
+      reducerCalled = true;
+      return {
+        messages: msgs,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: ["forced_compaction"],
+          injectionMode: "full",
+          exhausted: false,
+        },
+        estimatedTokens: 50_000,
+        compactionResult: {
+          compacted: true,
           messages: msgs,
-          tier: "forced_compaction",
-          state: {
-            appliedTiers: ["forced_compaction"],
-            injectionMode: "full",
-            exhausted: false,
-          },
-          estimatedTokens: 50_000,
-          compactionResult: {
-            compacted: true,
-            messages: msgs,
-            compactedPersistedMessages: 5,
-            summaryText: "Summary",
-            previousEstimatedInputTokens: 190_000,
-            estimatedInputTokens: 50_000,
-            maxInputTokens: 200_000,
-            thresholdTokens: 160_000,
-            compactedMessages: 10,
-            summaryCalls: 1,
-            summaryInputTokens: 500,
-            summaryOutputTokens: 200,
-            summaryModel: "mock-model",
-          },
-        };
+          compactedPersistedMessages: 5,
+          summaryText: "Summary",
+          previousEstimatedInputTokens: 190_000,
+          estimatedInputTokens: 50_000,
+          maxInputTokens: 200_000,
+          thresholdTokens: 160_000,
+          compactedMessages: 10,
+          summaryCalls: 1,
+          summaryInputTokens: 500,
+          summaryOutputTokens: 200,
+          summaryModel: "mock-model",
+        },
       };
+    };
 
-      // Run 1 makes progress (a tool turn) then the following provider call
-      // rejects with a context_too_large error; after the convergence reducer
-      // compacts, the rerun recovers with plain text.
-      const { provider } = createMockProvider([
-        toolUseResponse("tu-progress", "bash", { command: "ls" }),
-        new Error("prompt is too long: 242201 tokens > 200000 maximum"),
-        textResponse("recovered after compaction"),
-      ]);
+    // Run 1 makes progress (a tool turn) then the following provider call
+    // rejects with a context_too_large error; after the convergence reducer
+    // compacts, the rerun recovers with plain text.
+    const { provider } = createMockProvider([
+      toolUseResponse("tu-progress", "bash", { command: "ls" }),
+      new Error("prompt is too long: 242201 tokens > 200000 maximum"),
+      textResponse("recovered after compaction"),
+    ]);
 
-      const ctx = makeCtx({
-        loopProvider: provider,
-        loopTools: [
-          {
-            name: "bash",
-            description: "Run a shell command",
-            input_schema: {
-              type: "object",
-              properties: { command: { type: "string" } },
-            },
+    const ctx = makeCtx({
+      loopProvider: provider,
+      loopTools: [
+        {
+          name: "bash",
+          description: "Run a shell command",
+          input_schema: {
+            type: "object",
+            properties: { command: { type: "string" } },
           },
-        ],
-        toolExecutor: async () => ({
-          content: "file1.ts\nfile2.ts",
-          isError: false,
-        }),
-        contextWindowManager: {
-          updateConfig: () => {},
-          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-          maybeCompact: async () => ({ compacted: false }),
-        } as unknown as Conversation["contextWindowManager"],
-      });
+        },
+      ],
+      toolExecutor: async () => ({
+        content: "file1.ts\nfile2.ts",
+        isError: false,
+      }),
+      contextWindowManager: {
+        updateConfig: () => {},
+        shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
+        maybeCompact: async () => ({ compacted: false }),
+      } as unknown as Conversation["contextWindowManager"],
+    });
 
-      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+    await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-      // BUG: Currently the reducer is NOT called when progress was made before
-      // context_too_large. The error is surfaced immediately.
-      // After PR 2 fix, the reducer SHOULD be called to attempt compaction.
-      expect(reducerCalled).toBe(true);
+    expect(reducerCalled).toBe(true);
 
-      // BUG: Currently a conversation_error IS emitted instead of retrying.
-      // After PR 2 fix, there should be no conversation_error.
-      const conversationError = events.find(
-        (e) => e.type === "conversation_error",
-      );
-      expect(conversationError).toBeUndefined();
-    },
-  );
+    const conversationError = events.find(
+      (e) => e.type === "conversation_error",
+    );
+    expect(conversationError).toBeUndefined();
+  });
 
   // ── Test 2 ────────────────────────────────────────────────────────
   // When estimation says we're within budget but the provider rejects, the
@@ -922,88 +931,85 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
   // of 242k (1.31x the estimate of 185k), the target is adjusted downward
   // based on the observed mismatch (190k / 1.31 ≈ 145k) so the reducer
   // converges toward the real ceiling rather than the optimistic estimate.
-  test.todo(
-    "forced compaction targets a lower budget when estimation has been inaccurate",
-    async () => {
-      const events: AssistantEvent[] = [];
-      let capturedTargetTokens: number | undefined;
+  test("forced compaction targets a lower budget when estimation has been inaccurate", async () => {
+    const events: AssistantEvent[] = [];
+    let capturedTargetTokens: number | undefined;
 
-      // Estimator says 185k (below 190k budget = 200k * 0.95)
-      mockEstimateTokens = 185_000;
+    // Estimator says 185k (below 190k budget = 200k * 0.95)
+    mockEstimateTokens = 185_000;
 
-      // Reducer captures the targetTokens from the config
-      mockReducerStepFn = (msgs: Message[], cfg: unknown) => {
-        capturedTargetTokens = (cfg as { targetTokens: number }).targetTokens;
-        return {
+    // Reducer captures the targetTokens from the config
+    mockReducerStepFn = (msgs: Message[], cfg: unknown) => {
+      capturedTargetTokens = (cfg as { targetTokens: number }).targetTokens;
+      return {
+        messages: msgs,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: ["forced_compaction"],
+          injectionMode: "full",
+          exhausted: false,
+        },
+        estimatedTokens: 100_000,
+        compactionResult: {
+          compacted: true,
           messages: msgs,
-          tier: "forced_compaction",
-          state: {
-            appliedTiers: ["forced_compaction"],
-            injectionMode: "full",
-            exhausted: false,
-          },
-          estimatedTokens: 100_000,
-          compactionResult: {
-            compacted: true,
-            messages: msgs,
-            compactedPersistedMessages: 10,
-            summaryText: "Summary",
-            previousEstimatedInputTokens: 185_000,
-            estimatedInputTokens: 100_000,
-            maxInputTokens: 200_000,
-            thresholdTokens: 160_000,
-            compactedMessages: 20,
-            summaryCalls: 1,
-            summaryInputTokens: 800,
-            summaryOutputTokens: 300,
-            summaryModel: "mock-model",
-          },
-        };
+          compactedPersistedMessages: 10,
+          summaryText: "Summary",
+          previousEstimatedInputTokens: 185_000,
+          estimatedInputTokens: 100_000,
+          maxInputTokens: 200_000,
+          thresholdTokens: 160_000,
+          compactedMessages: 20,
+          summaryCalls: 1,
+          summaryInputTokens: 800,
+          summaryOutputTokens: 300,
+          summaryModel: "mock-model",
+        },
       };
+    };
 
-      // The provider rejects the first call with a context_too_large error
-      // (actual tokens 242201, far above the 185k estimate); after forced
-      // compaction re-targets a lower budget, the rerun recovers with text.
-      const { provider, calls } = createMockProvider([
-        new Error("prompt is too long: 242201 tokens > 200000 maximum"),
-        textResponse("recovered"),
-      ]);
+    // The provider rejects the first call with a context_too_large error
+    // (actual tokens 242201, far above the 185k estimate); after forced
+    // compaction re-targets a lower budget, the rerun recovers with text.
+    const { provider, calls } = createMockProvider([
+      new Error("prompt is too long: 242201 tokens > 200000 maximum"),
+      textResponse("recovered"),
+    ]);
 
-      const ctx = makeCtx({
-        loopProvider: provider,
-        contextWindowManager: {
-          updateConfig: () => {},
-          shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-          maybeCompact: async () => ({ compacted: false }),
-        } as unknown as Conversation["contextWindowManager"],
-      });
+    const ctx = makeCtx({
+      loopProvider: provider,
+      contextWindowManager: {
+        updateConfig: () => {},
+        shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
+        maybeCompact: async () => ({ compacted: false }),
+      } as unknown as Conversation["contextWindowManager"],
+    });
 
-      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+    await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-      // The reducer should have been called with a corrected target
-      expect(capturedTargetTokens).toBeDefined();
+    // The reducer should have been called with a corrected target
+    expect(capturedTargetTokens).toBeDefined();
 
-      // preflightBudget = 200_000 * 0.95 = 190_000
-      // estimationErrorRatio = 242201 / 185000 ≈ 1.309
-      // correctedTarget = floor(190000 / 1.309) ≈ 145_130
-      // The corrected target must be LESS than the uncorrected preflightBudget
-      const preflightBudget = 190_000;
-      expect(capturedTargetTokens!).toBeLessThan(preflightBudget);
+    // preflightBudget = 200_000 * 0.95 = 190_000
+    // estimationErrorRatio = 242201 / 185000 ≈ 1.309
+    // correctedTarget = floor(190000 / 1.309) ≈ 145_130
+    // The corrected target must be LESS than the uncorrected preflightBudget
+    const preflightBudget = 190_000;
+    expect(capturedTargetTokens!).toBeLessThan(preflightBudget);
 
-      // Verify the approximate corrected value (190000 / (242201/185000))
-      const expectedCorrectedTarget = Math.floor(
-        preflightBudget / (242201 / 185_000),
-      );
-      expect(capturedTargetTokens!).toBe(expectedCorrectedTarget);
+    // Verify the approximate corrected value (190000 / (242201/185000))
+    const expectedCorrectedTarget = Math.floor(
+      preflightBudget / (242201 / 185_000),
+    );
+    expect(capturedTargetTokens!).toBe(expectedCorrectedTarget);
 
-      // Should recover without conversation_error
-      const conversationError = events.find(
-        (e) => e.type === "conversation_error",
-      );
-      expect(conversationError).toBeUndefined();
-      expect(calls.length).toBe(2);
-    },
-  );
+    // Should recover without conversation_error
+    const conversationError = events.find(
+      (e) => e.type === "conversation_error",
+    );
+    expect(conversationError).toBeUndefined();
+    expect(calls.length).toBe(2);
+  });
 
   // ── Test 4 ────────────────────────────────────────────────────────
   // A realistic 75+ message conversation with many tool calls where

package/src/__tests__/conversation-evictor.test.ts

@@ -12,6 +12,7 @@ mock.module("../subagent/index.js", () => ({
 
 import {
   ConversationEvictor,
+  defaultMemoryThresholdBytes,
   type EvictableConversation,
 } from "../daemon/conversation-evictor.js";
 
@@ -268,6 +269,46 @@ describe("ConversationEvictor", () => {
       expect(resident.disposed).toBe(false);
       expect(idle.disposed).toBe(true);
     });
+
+    test("evicts a bounded batch per sweep, least recently used first", () => {
+      for (let i = 0; i < 15; i++) {
+        sessions.set(`conv-${i}`, createMockSession());
+      }
+      evictor = new ConversationEvictor(sessions, {
+        ttlMs: Number.MAX_SAFE_INTEGER,
+        maxConversations: Number.MAX_SAFE_INTEGER,
+        memoryThresholdBytes: 0,
+      });
+      for (let i = 0; i < 15; i++) {
+        evictor.touch(`conv-${i}`);
+      }
+
+      expect(evictor.sweep().memoryEvicted).toBe(10);
+      expect(sessions.has("conv-0")).toBe(false);
+      expect(sessions.has("conv-10")).toBe(true);
+      expect(evictor.sweep().memoryEvicted).toBe(5);
+      expect(sessions.size).toBe(0);
+    });
+
+    test("derives the threshold from the container limit at first sweep, not construction", () => {
+      const previous = process.env.VELLUM_MEMORY_LIMIT;
+      sessions.set("idle", createMockSession());
+      evictor = new ConversationEvictor(sessions, {
+        ttlMs: Number.MAX_SAFE_INTEGER,
+        maxConversations: Number.MAX_SAFE_INTEGER,
+      });
+      // Half of 1 MiB is far below any live RSS, so the phase must fire.
+      process.env.VELLUM_MEMORY_LIMIT = "1Mi";
+      try {
+        expect(evictor.sweep().memoryEvicted).toBe(1);
+      } finally {
+        if (previous === undefined) {
+          delete process.env.VELLUM_MEMORY_LIMIT;
+        } else {
+          process.env.VELLUM_MEMORY_LIMIT = previous;
+        }
+      }
+    });
   });
 
   describe("onEvict", () => {
@@ -326,3 +367,16 @@ describe("ConversationEvictor", () => {
     });
   });
 });
+
+describe("defaultMemoryThresholdBytes", () => {
+  const GIB = 1024 * 1024 * 1024;
+
+  test("is half the container limit", () => {
+    expect(defaultMemoryThresholdBytes(3 * GIB)).toBe(1.5 * GIB);
+    expect(defaultMemoryThresholdBytes(8 * GIB)).toBe(4 * GIB);
+  });
+
+  test("falls back to 3 GiB without a limit", () => {
+    expect(defaultMemoryThresholdBytes(null)).toBe(3 * GIB);
+  });
+});

package/src/__tests__/conversation-pairing.test.ts

@@ -116,6 +116,7 @@ mock.module("../config/assistant-initiated-threads-gate.js", () => ({
   isAssistantInitiatedThreadsEnabled: () => assistantInitiatedThreadsEnabled,
 }));
 
+import { resolveAssistantInitiatedThread } from "../notifications/assistant-initiated-thread.js";
 import { pairDeliveryWithConversation } from "../notifications/conversation-pairing.js";
 import type { NotificationSignal } from "../notifications/signal.js";
 import type {
@@ -1478,6 +1479,117 @@ describe("pairDeliveryWithConversation", () => {
         ...overrides,
       });
 
+    test("a prepared resolution is reused even if the source changes before pairing", async () => {
+      assistantInitiatedThreadsEnabled = true;
+      const signal = share({
+        conversationMetadata: { groupId: "group-123" },
+      });
+      const original = structuredClone(signal);
+      const assistantInitiatedThread = resolveAssistantInitiatedThread(signal);
+      getConversationMock.mockClear();
+      mockExistingConversations[signal.sourceContextId] = {
+        id: signal.sourceContextId,
+        source: "user",
+        title: null,
+        conversationType: "standard",
+      };
+
+      const result = await pairDeliveryWithConversation(
+        signal,
+        "vellum",
+        makeCopy(),
+        { assistantInitiatedThread },
+      );
+
+      expect(result.createdNewConversation).toBe(true);
+      expect(result.messageId).toBe("msg-001");
+      expect(createConversationMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          source: "assistant_initiated",
+          groupId: "group-123",
+        }),
+      );
+      expect(getConversationMock).not.toHaveBeenCalled();
+      expect(signal).toEqual(original);
+    });
+
+    test("an ineligible prepared resolution retains passive pairing when the flag changes", async () => {
+      const signal = share();
+      const assistantInitiatedThread = resolveAssistantInitiatedThread(signal);
+      assistantInitiatedThreadsEnabled = true;
+      mockExistingConversations[signal.sourceContextId] = {
+        id: signal.sourceContextId,
+        source: "heartbeat",
+        title: null,
+        conversationType: "background",
+      };
+
+      const result = await pairDeliveryWithConversation(
+        signal,
+        "vellum",
+        makeCopy(),
+        { assistantInitiatedThread },
+      );
+
+      expect(result.createdNewConversation).toBe(false);
+      expect(result.conversationId).toBe(signal.sourceContextId);
+      expect(createConversationMock).not.toHaveBeenCalled();
+      expect(addMessageMock).toHaveBeenCalledTimes(1);
+    });
+
+    test.each(["slack", "telegram", "discord"] as const)(
+      "%s retains the producer metadata despite a prepared vellum resolution",
+      async (channel) => {
+        assistantInitiatedThreadsEnabled = true;
+        const signal = share({
+          conversationMetadata: { groupId: "group-123" },
+        });
+        const original = structuredClone(signal);
+        const assistantInitiatedThread =
+          resolveAssistantInitiatedThread(signal);
+        getConversationMock.mockClear();
+
+        const result = await pairDeliveryWithConversation(
+          signal,
+          channel,
+          makeCopy(),
+          { assistantInitiatedThread },
+        );
+
+        expect(result.createdNewConversation).toBe(true);
+        expect(result.strategy).toBe("continue_existing_conversation");
+        expect(createConversationMock).toHaveBeenCalledWith(
+          expect.objectContaining({
+            conversationType: "background",
+            source: "notification",
+            groupId: "group-123",
+          }),
+        );
+        expect(addMessageMock).not.toHaveBeenCalled();
+        expect(getConversationMock).not.toHaveBeenCalled();
+        expect(signal).toEqual(original);
+      },
+    );
+
+    test("platform delivery does not pair a prepared vellum resolution", async () => {
+      assistantInitiatedThreadsEnabled = true;
+      const signal = share();
+      const assistantInitiatedThread = resolveAssistantInitiatedThread(signal);
+
+      const result = await pairDeliveryWithConversation(
+        signal,
+        "platform",
+        makeCopy(),
+        { assistantInitiatedThread },
+      );
+
+      expect(result.strategy).toBe("push_only");
+      expect(result.createdNewConversation).toBe(false);
+      expect(result.conversationId).toBeNull();
+      expect(createConversationMock).not.toHaveBeenCalled();
+      expect(addMessageMock).not.toHaveBeenCalled();
+    });
+
     test("flag on: a share from a background run materializes a section thread", async () => {
       assistantInitiatedThreadsEnabled = true;
       mockExistingConversations["conv-heartbeat"] = {

package/src/__tests__/document-append-idempotency.test.ts

@@ -35,6 +35,7 @@ function bootstrapDocumentTables(): void {
   const raw = getSqlite();
   raw.exec(/*sql*/ `
     DROP TABLE IF EXISTS document_conversations;
+    DROP TABLE IF EXISTS document_revisions;
     DROP TABLE IF EXISTS documents;
     DROP TABLE IF EXISTS conversations;
 
@@ -51,9 +52,21 @@ function bootstrapDocumentTables(): void {
       word_count INTEGER NOT NULL DEFAULT 0,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL,
+      revision INTEGER NOT NULL DEFAULT 0,
       workspace_path TEXT
     );
 
+    CREATE TABLE document_revisions (
+      surface_id TEXT NOT NULL REFERENCES documents(surface_id) ON DELETE CASCADE,
+      revision INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      word_count INTEGER NOT NULL DEFAULT 0,
+      author TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (surface_id, revision)
+    );
+
     CREATE TABLE document_conversations (
       surface_id TEXT NOT NULL,
       conversation_id TEXT NOT NULL,

package/src/__tests__/document-create-dedupe.test.ts

@@ -29,6 +29,7 @@ function bootstrapDocumentTables(): void {
   const raw = getSqlite();
   raw.exec(/*sql*/ `
     DROP TABLE IF EXISTS document_conversations;
+    DROP TABLE IF EXISTS document_revisions;
     DROP TABLE IF EXISTS documents;
     DROP TABLE IF EXISTS conversations;
 
@@ -45,9 +46,21 @@ function bootstrapDocumentTables(): void {
       word_count INTEGER NOT NULL DEFAULT 0,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL,
+      revision INTEGER NOT NULL DEFAULT 0,
       workspace_path TEXT
     );
 
+    CREATE TABLE document_revisions (
+      surface_id TEXT NOT NULL REFERENCES documents(surface_id) ON DELETE CASCADE,
+      revision INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      word_count INTEGER NOT NULL DEFAULT 0,
+      author TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (surface_id, revision)
+    );
+
     CREATE TABLE document_conversations (
       surface_id TEXT NOT NULL,
       conversation_id TEXT NOT NULL,

package/src/__tests__/document-find-replace.test.ts

@@ -28,6 +28,7 @@ function bootstrapDocumentTables(): void {
   const raw = getSqlite();
   raw.exec(/*sql*/ `
     DROP TABLE IF EXISTS document_conversations;
+    DROP TABLE IF EXISTS document_revisions;
     DROP TABLE IF EXISTS documents;
     DROP TABLE IF EXISTS conversations;
 
@@ -44,9 +45,21 @@ function bootstrapDocumentTables(): void {
       word_count INTEGER NOT NULL DEFAULT 0,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL,
+      revision INTEGER NOT NULL DEFAULT 0,
       workspace_path TEXT
     );
 
+    CREATE TABLE document_revisions (
+      surface_id TEXT NOT NULL REFERENCES documents(surface_id) ON DELETE CASCADE,
+      revision INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      word_count INTEGER NOT NULL DEFAULT 0,
+      author TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (surface_id, revision)
+    );
+
     CREATE TABLE document_conversations (
       surface_id TEXT NOT NULL,
       conversation_id TEXT NOT NULL,