@vellumai/assistant 0.6.5 → 0.6.6

package/src/memory/conversation-crud.ts

@@ -107,6 +107,9 @@ export const messageMetadataSchema = z
     memoryInjectedBlock: z.string().optional(),
     turnContextBlock: z.string().optional(),
     pkbSystemReminderBlock: z.string().optional(),
+    workspaceBlock: z.string().optional(),
+    nowScratchpadBlock: z.string().optional(),
+    pkbContextBlock: z.string().optional(),
   })
   .passthrough();
 
@@ -1048,20 +1051,26 @@ export function getMessages(conversationId: string): MessageRow[] {
 }
 
 /**
- * Count messages whose metadata JSON contains a `slackMeta` envelope, capped
- * at `limit`. Pushes the cap into SQL (`LIKE` + `LIMIT`) so warm Slack DM
- * conversations don't require a full-table scan + JSON parse on every
- * inbound message to confirm the cold-start threshold has been cleared.
- * Returns the number of matching rows up to `limit`; callers compare against
- * the cold-start threshold to decide whether to backfill.
+ * Return raw `metadata` strings for messages whose metadata contains the
+ * literal substring `"slackMeta"`, capped at `limit` and skipping the first
+ * `offset` matches. Pushes `LIKE` + `LIMIT`/`OFFSET` into SQL so warm Slack
+ * DM conversations don't require a full-table scan on the webhook critical
+ * path. The substring match is an indexable prefilter only — callers must
+ * parse and validate each returned string against the Slack metadata schema,
+ * because a malformed row (partial write, legacy format, unrelated key
+ * accidentally containing the literal) can still slip through the substring
+ * match. Callers that need a fixed number of *valid* rows should iterate
+ * with increasing offsets until the target is reached (capped at a
+ * reasonable maximum to bound scan cost).
  */
-export function countMessagesWithSlackMeta(
+export function selectSlackMetaCandidateMetadata(
   conversationId: string,
   limit: number,
-): number {
+  offset = 0,
+): string[] {
   const db = getDb();
   const rows = db
-    .select({ one: sql`1` })
+    .select({ metadata: messages.metadata })
     .from(messages)
     .where(
       and(
@@ -1069,9 +1078,17 @@ export function countMessagesWithSlackMeta(
         like(messages.metadata, '%"slackMeta"%'),
       ),
     )
+    .orderBy(asc(messages.createdAt))
     .limit(limit)
+    .offset(offset)
     .all();
-  return rows.length;
+  const out: string[] = [];
+  for (const r of rows) {
+    if (typeof r.metadata === "string" && r.metadata.length > 0) {
+      out.push(r.metadata);
+    }
+  }
+  return out;
 }
 
 /**
@@ -1503,22 +1520,35 @@ export function updateMessageMetadata(
 }
 
 /**
- * Bulk-remove the `pkbSystemReminderBlock` field from every user-message
- * metadata row in a conversation. Called from compaction-strip sites so
- * post-restart rehydration stays consistent with the in-memory state
- * produced by `stripInjectionsForCompaction` (which removes
- * `<system_reminder>` from live messages but cannot touch the DB).
+ * Bulk-remove the metadata fields that back the blocks stripped by
+ * `stripInjectionsForCompaction` — currently `pkbSystemReminderBlock`
+ * (`<system_reminder>`), `nowScratchpadBlock` (`<NOW.md …>`), and
+ * `pkbContextBlock` (`<knowledge_base>`). Called from compaction-strip
+ * sites so post-restart rehydration stays consistent with the in-memory
+ * state produced by `stripInjectionsForCompaction` (which removes those
+ * tags from live messages but cannot touch the DB). Fields backing
+ * blocks that are intentionally NOT stripped (`turnContextBlock`,
+ * `workspaceBlock`, `memoryInjectedBlock`) are preserved.
  */
-export function clearPkbSystemReminderMetadataForConversation(
+export function clearStrippedInjectionMetadataForConversation(
   conversationId: string,
 ): void {
   rawRun(
     `UPDATE messages
-        SET metadata = json_remove(metadata, '$.pkbSystemReminderBlock')
+        SET metadata = json_remove(
+          metadata,
+          '$.pkbSystemReminderBlock',
+          '$.nowScratchpadBlock',
+          '$.pkbContextBlock'
+        )
       WHERE conversation_id = ?
         AND role = 'user'
         AND metadata IS NOT NULL
-        AND json_extract(metadata, '$.pkbSystemReminderBlock') IS NOT NULL`,
+        AND (
+          json_extract(metadata, '$.pkbSystemReminderBlock') IS NOT NULL
+          OR json_extract(metadata, '$.nowScratchpadBlock') IS NOT NULL
+          OR json_extract(metadata, '$.pkbContextBlock') IS NOT NULL
+        )`,
     conversationId,
   );
 }

package/src/memory/conversation-queries.ts

@@ -88,6 +88,59 @@ export function listPinnedConversations(): ConversationRow[] {
   return query.all().map(parseConversation);
 }
 
+/**
+ * Row shape returned by {@link listConversationsByTitlePrefix}.
+ *
+ * Kept deliberately narrow (no full `ConversationRow`) since the only caller
+ * today is the playground's seeded-conversation listing endpoint, which only
+ * needs display metadata plus a message count to show in a list.
+ */
+export interface ConversationTitlePrefixRow {
+  id: string;
+  title: string;
+  messageCount: number;
+  createdAt: number;
+}
+
+/**
+ * List non-archived conversations whose `title` begins with `prefix`.
+ *
+ * Uses raw SQL with a subquery for `messageCount` so a single round-trip
+ * returns everything the caller needs. The `LIKE ? || '%'` pattern does a
+ * prefix match; SQLite optimizes this with an index when one exists on
+ * `title`, otherwise it degrades to a table scan — acceptable for the
+ * playground-seeded set, which is small by construction.
+ *
+ * Escaping is unnecessary here because the prefix is a build-time constant
+ * (`PLAYGROUND_TITLE_PREFIX`) rather than user input. If callers ever pass
+ * dynamic prefixes, switch to `ESCAPE '\\'` and pre-escape `%` / `_` / `\`.
+ */
+export function listConversationsByTitlePrefix(
+  prefix: string,
+): ConversationTitlePrefixRow[] {
+  interface Row {
+    id: string;
+    title: string;
+    message_count: number;
+    created_at: number;
+  }
+  const rows = rawAll<Row>(
+    `SELECT c.id, c.title,
+            (SELECT COUNT(*) FROM messages WHERE conversation_id = c.id) AS message_count,
+            c.created_at
+     FROM conversations c
+     WHERE c.title LIKE ? || '%' AND c.archived_at IS NULL
+     ORDER BY c.created_at DESC`,
+    prefix,
+  );
+  return rows.map((r) => ({
+    id: r.id,
+    title: r.title,
+    messageCount: r.message_count,
+    createdAt: r.created_at,
+  }));
+}
+
 export function countConversations(backgroundOnly = false): number {
   const db = getDb();
   const where = backgroundOnly
@@ -257,10 +310,10 @@ export function searchConversations(
     .from(conversations)
     .where(
       and(
-          sql`${conversations.conversationType} NOT IN ('background', 'private', 'scheduled')`,
-          sql`${conversations.title} LIKE ${titlePattern} ESCAPE '\\'`,
-          sql`${conversations.archivedAt} IS NULL`,
-        ),
+        sql`${conversations.conversationType} NOT IN ('background', 'private', 'scheduled')`,
+        sql`${conversations.title} LIKE ${titlePattern} ESCAPE '\\'`,
+        sql`${conversations.archivedAt} IS NULL`,
+      ),
     )
     .all();
   for (const row of titleMatchConvs) ftsConvIds.add(row.id);

package/src/memory/conversation-title-service.ts

@@ -234,6 +234,12 @@ export async function regenerateConversationTitle(
   }
 
   const prompt = buildRegenerationPrompt(recentMessages);
+  // Skip the LLM call if no messages yielded extractable text — the prompt
+  // would be just the "Recent messages:" header, and the model tends to
+  // fabricate a meta-title about the emptiness rather than decline.
+  if (!/\n(?:User|Assistant): /.test(prompt)) {
+    return { title: conversation.title ?? UNTITLED_FALLBACK, updated: false };
+  }
   const result = await runBtwSidechain({
     content: prompt,
     provider,
@@ -296,6 +302,7 @@ function buildTitleSystemPrompt(): string {
     "- Do NOT echo back what the user asked you to do",
     "- Do NOT respond to the conversation content",
     "- Do NOT assess feasibility or comment on capabilities",
+    "- If input is sparse or references external context, extract a topic from the words that ARE present (e.g. 'so about that t-shirt...' → 'T-Shirt Discussion'). Never describe the absence, emptiness, or insufficiency of context — titles like 'Missing Context', 'Unclear Request', 'No Topic' are forbidden",
   ].join("\n");
 }
 
@@ -329,9 +336,27 @@ function buildTitlePrompt(
   return parts.join("\n");
 }
 
+const META_FAILURE_TITLES = new Set([
+  "missing context",
+  "no context",
+  "insufficient context",
+  "unclear context",
+  "empty context",
+  "no topic",
+  "unclear topic",
+  "unclear request",
+  "unclear message",
+  "empty conversation",
+  "empty message",
+  "no content",
+]);
+
 function normalizeTitle(raw: string): string {
   let title = raw.trim().replace(/^["']|["']$/g, "");
   title = stripMarkdown(title);
+  if (META_FAILURE_TITLES.has(title.toLowerCase())) {
+    return "";
+  }
   return title;
 }
 

package/src/memory/db-init.ts

@@ -17,6 +17,7 @@ import {
   addCoreColumns,
   createActorRefreshTokenRecordsTable,
   createActorTokenRecordsTable,
+  createApprovalPromptTsTrackerTable,
   createAssistantInboxTables,
   createCallSessionsTables,
   createCanonicalGuardianTables,
@@ -110,11 +111,13 @@ import {
   migrateNormalizeUserFileByPrincipal,
   migrateNotificationDeliveryThreadDecision,
   migrateOAuthAppsClientSecretPath,
+  migrateOAuthProvidersAvailableScopes,
   migrateOAuthProvidersBehaviorColumns,
   migrateOAuthProvidersDisplayMetadata,
   migrateOAuthProvidersFeatureFlag,
   migrateOAuthProvidersLogoUrl,
   migrateOAuthProvidersManagedServiceConfigKey,
+  migrateOAuthProvidersManagedServiceIsPaid,
   migrateOAuthProvidersPingConfig,
   migrateOAuthProvidersPingUrl,
   migrateOAuthProvidersRefreshUrl,
@@ -143,6 +146,7 @@ import {
   migrateScheduleOneShotRouting,
   migrateScheduleQuietFlag,
   migrateScheduleReuseConversation,
+  migrateScheduleScriptColumn,
   migrateSchemaIndexesAndColumns,
   migrateScrubCorruptedImageAttachments,
   migrateStripIntegrationPrefixFromProviderKeys,
@@ -267,6 +271,7 @@ export function initializeDb(): void {
     migrateInviteCodeHashColumn,
     createActorTokenRecordsTable,
     createActorRefreshTokenRecordsTable,
+    createApprovalPromptTsTrackerTable,
     migrateGuardianPrincipalIdColumns,
     migrateBackfillGuardianPrincipalId,
     migrateGuardianPrincipalIdNotNull,
@@ -360,6 +365,7 @@ export function initializeDb(): void {
     migrateConversationsLastMessageAt,
     migrateStripThinkingFromConsolidated,
     migrateScheduleReuseConversation,
+    migrateScheduleScriptColumn,
     migrateMemoryRecallLogsQueryContext,
     migrateLlmRequestLogsCreatedAtIndex,
     migrateOAuthProvidersScopeSeparator,
@@ -372,6 +378,8 @@ export function initializeDb(): void {
     migrateNormalizeUserFileByPrincipal,
     migrateConversationsArchivedAt,
     migrateStripPlaceholderSentinelsFromMessages,
+    migrateOAuthProvidersManagedServiceIsPaid,
+    migrateOAuthProvidersAvailableScopes,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/embedding-gemini.test.ts

@@ -35,7 +35,7 @@ describe("GeminiEmbeddingBackend", () => {
       expect(url).toContain("key=test-key");
 
       const body = JSON.parse(init.body as string);
-      expect(body.model).toBe("models/test-model");
+      expect(body.model).toBeUndefined();
       expect(body.content).toEqual({ parts: [{ text: "hello world" }] });
     });
 
@@ -181,7 +181,7 @@ describe("GeminiEmbeddingBackend", () => {
       const body = JSON.parse(init.body as string);
       expect(body.taskType).toBeUndefined();
       expect(body.outputDimensionality).toBeUndefined();
-      expect(Object.keys(body)).toEqual(["model", "content"]);
+      expect(Object.keys(body)).toEqual(["content"]);
     });
   });
 
@@ -276,6 +276,45 @@ describe("GeminiEmbeddingBackend", () => {
       // Should have Bearer auth header
       const headers = init.headers as Record<string, string>;
       expect(headers["Authorization"]).toBe("Bearer ast-managed-key");
+      // Managed path must NOT include `model` in the body — Gemini models it
+      // as a protobuf oneof populated from the URL path (internally `_model`)
+      // and rejects the duplicate with "oneof field '_model' is already set".
+      // See the comment in embedSingle() for the full invariant.
+      const body = JSON.parse(init.body as string);
+      expect(body.model).toBeUndefined();
+      expect(body._model).toBeUndefined();
+    });
+
+    test("never sets `model` or `_model` in the request body (oneof invariant)", async () => {
+      // Regression for JARVIS-587: every embed_segment job was failing with
+      // `Invalid value (oneof), oneof field '_model' is already set. Cannot
+      // set 'model'`. Ensure neither field is ever present on the wire,
+      // regardless of transport.
+      const managedBackend = new GeminiEmbeddingBackend(
+        "ast-managed-key",
+        "gemini-embedding-2-preview",
+        {
+          managedBaseUrl:
+            "https://platform.example.com/v1/runtime-proxy/gemini",
+          taskType: "RETRIEVAL_DOCUMENT",
+          dimensions: 3072,
+        },
+      );
+      await managedBackend.embed(["hello"]);
+
+      const directBackend = new GeminiEmbeddingBackend(
+        "direct-key",
+        "test-model",
+      );
+      await directBackend.embed(["hello"]);
+
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+      for (const call of mockFetch.mock.calls) {
+        const [, init] = call as [string, RequestInit];
+        const body = JSON.parse(init.body as string);
+        expect(body.model).toBeUndefined();
+        expect(body._model).toBeUndefined();
+      }
     });
 
     test("uses direct Google API URL when managedBaseUrl is not set", async () => {

package/src/memory/embedding-gemini.ts

@@ -58,9 +58,14 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
     const parts = this.buildParts(normalized);
 
     const body: Record<string, unknown> = {
-      model: `models/${this.model}`,
       content: { parts },
     };
+    // Do NOT set `model` in the body. Gemini's embedContent API models `model`
+    // as a protobuf oneof populated from the URL path (internally `_model`),
+    // so adding it to the body triggers a 400: "oneof field '_model' is
+    // already set. Cannot set 'model'". This holds for both the direct API
+    // and the managed proxy, which forwards the body unchanged; the platform
+    // billing layer parses the model from the URL path instead.
     if (this.taskType) body.taskType = this.taskType;
     if (this.dimensions) body.outputDimensionality = this.dimensions;
 

package/src/memory/graph/bootstrap.test.ts

@@ -0,0 +1,282 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+
+import { setMemoryCheckpoint } from "../checkpoints.js";
+import {
+  initializeDb,
+  rawAll,
+  rawGet,
+  rawRun,
+  resetTestTables,
+} from "../db.js";
+import { migrateToolCreatedItems } from "./bootstrap.js";
+
+// ---------------------------------------------------------------------------
+// The checkpoint key used by migrateToolCreatedItems (not exported, so we
+// inline the literal value).
+// ---------------------------------------------------------------------------
+const MIGRATE_ITEMS_CHECKPOINT = "graph_bootstrap:migrated_tool_items";
+
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+
+beforeAll(() => {
+  initializeDb();
+});
+
+beforeEach(() => {
+  // Clear graph nodes and checkpoints between tests so each test starts clean.
+  resetTestTables("memory_graph_nodes", "memory_checkpoints", "memory_jobs");
+});
+
+// ---------------------------------------------------------------------------
+// migrateToolCreatedItems
+// ---------------------------------------------------------------------------
+
+describe("migrateToolCreatedItems", () => {
+  test("migrates legacy memory_items to graph nodes", () => {
+    // The memory_items table has been dropped by migration 203, so we need to
+    // recreate it for this test. We create a minimal version with just the
+    // columns the migration reads.
+    rawRun(
+      `CREATE TABLE IF NOT EXISTS memory_items (
+        id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL,
+        subject TEXT NOT NULL,
+        statement TEXT NOT NULL,
+        status TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        importance REAL,
+        scope_id TEXT NOT NULL DEFAULT 'default',
+        first_seen_at INTEGER NOT NULL,
+        fingerprint TEXT NOT NULL DEFAULT ''
+      )`,
+    );
+
+    try {
+      // Insert a legacy playbook item
+      rawRun(
+        `INSERT INTO memory_items (id, kind, subject, statement, status, confidence, importance, scope_id, first_seen_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        "legacy-item-1",
+        "playbook",
+        "Test Playbook",
+        "Do the thing correctly",
+        "active",
+        0.9,
+        0.8,
+        "default",
+        1700000000000,
+      );
+
+      // Clear the checkpoint so the migration re-runs
+      rawRun(
+        "DELETE FROM memory_checkpoints WHERE key = ?",
+        MIGRATE_ITEMS_CHECKPOINT,
+      );
+
+      // Run migration
+      migrateToolCreatedItems();
+
+      // Assert a corresponding graph node was created
+      const node = rawGet<{
+        id: string;
+        content: string;
+        type: string;
+        source_conversations: string;
+        image_refs: string | null;
+      }>(
+        `SELECT id, content, type, source_conversations, image_refs
+         FROM memory_graph_nodes
+         WHERE source_conversations LIKE ?`,
+        "%playbook:legacy-item-1%",
+      );
+
+      expect(node).not.toBeNull();
+      expect(node!.content).toBe("Test Playbook\nDo the thing correctly");
+      expect(node!.type).toBe("semantic");
+      expect(JSON.parse(node!.source_conversations)).toContain(
+        "playbook:legacy-item-1",
+      );
+      expect(node!.image_refs).toBeNull();
+    } finally {
+      // Clean up the recreated table so it does not interfere with other tests
+      rawRun("DROP TABLE IF EXISTS memory_items");
+    }
+  });
+
+  test("succeeds when image_refs column does not exist", () => {
+    // This is the regression test for the v0.6.0 bug: when upgrading from
+    // v0.5.x, migrateToolCreatedItems ran before the image_refs column was
+    // added by migration 205, causing a crash.
+
+    // Recreate memory_items for legacy data
+    rawRun(
+      `CREATE TABLE IF NOT EXISTS memory_items (
+        id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL,
+        subject TEXT NOT NULL,
+        statement TEXT NOT NULL,
+        status TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        importance REAL,
+        scope_id TEXT NOT NULL DEFAULT 'default',
+        first_seen_at INTEGER NOT NULL,
+        fingerprint TEXT NOT NULL DEFAULT ''
+      )`,
+    );
+
+    try {
+      // Rebuild memory_graph_nodes WITHOUT the image_refs column to simulate
+      // the pre-205 schema. SQLite doesn't support DROP COLUMN on all
+      // versions, so we use the standard CREATE-new/INSERT-SELECT/DROP-old/
+      // RENAME pattern.
+      rawRun(`CREATE TABLE memory_graph_nodes_backup AS
+        SELECT
+          id, content, type, created, last_accessed, last_consolidated,
+          event_date, emotional_charge, fidelity, confidence, significance,
+          stability, reinforcement_count, last_reinforced,
+          source_conversations, source_type, narrative_role, part_of_story,
+          scope_id
+        FROM memory_graph_nodes`);
+      rawRun("DROP TABLE memory_graph_nodes");
+      rawRun(
+        `CREATE TABLE memory_graph_nodes (
+          id                    TEXT PRIMARY KEY,
+          content               TEXT NOT NULL,
+          type                  TEXT NOT NULL,
+          created               INTEGER NOT NULL,
+          last_accessed         INTEGER NOT NULL,
+          last_consolidated     INTEGER NOT NULL,
+          event_date            INTEGER,
+          emotional_charge      TEXT NOT NULL,
+          fidelity              TEXT NOT NULL DEFAULT 'vivid',
+          confidence            REAL NOT NULL,
+          significance          REAL NOT NULL,
+          stability             REAL NOT NULL DEFAULT 14,
+          reinforcement_count   INTEGER NOT NULL DEFAULT 0,
+          last_reinforced       INTEGER NOT NULL,
+          source_conversations  TEXT NOT NULL DEFAULT '[]',
+          source_type           TEXT NOT NULL DEFAULT 'inferred',
+          narrative_role        TEXT,
+          part_of_story         TEXT,
+          scope_id              TEXT NOT NULL DEFAULT 'default'
+        )`,
+      );
+      rawRun(
+        `INSERT INTO memory_graph_nodes
+         SELECT * FROM memory_graph_nodes_backup`,
+      );
+      rawRun("DROP TABLE memory_graph_nodes_backup");
+
+      // Clear checkpoint
+      rawRun(
+        "DELETE FROM memory_checkpoints WHERE key = ?",
+        MIGRATE_ITEMS_CHECKPOINT,
+      );
+
+      // Insert a legacy item
+      rawRun(
+        `INSERT INTO memory_items (id, kind, subject, statement, status, confidence, importance, scope_id, first_seen_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        "legacy-item-2",
+        "style",
+        "Formal tone",
+        "Always use formal language",
+        "active",
+        0.85,
+        0.7,
+        "default",
+        1700000000000,
+      );
+
+      // This should NOT throw — the migration should succeed without image_refs
+      expect(() => migrateToolCreatedItems()).not.toThrow();
+
+      // Verify the row was migrated
+      const node = rawGet<{ id: string; content: string }>(
+        `SELECT id, content FROM memory_graph_nodes
+         WHERE source_conversations LIKE ?`,
+        "%style:legacy-item-2%",
+      );
+      expect(node).not.toBeNull();
+      expect(node!.content).toBe("Formal tone\nAlways use formal language");
+    } finally {
+      rawRun("DROP TABLE IF EXISTS memory_items");
+      // Restore the full schema for subsequent tests by re-adding image_refs
+      try {
+        rawRun("ALTER TABLE memory_graph_nodes ADD COLUMN image_refs TEXT");
+      } catch {
+        // Column may already exist
+      }
+    }
+  });
+
+  test("skips migration when checkpoint is already set", () => {
+    // Recreate memory_items for legacy data
+    rawRun(
+      `CREATE TABLE IF NOT EXISTS memory_items (
+        id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL,
+        subject TEXT NOT NULL,
+        statement TEXT NOT NULL,
+        status TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        importance REAL,
+        scope_id TEXT NOT NULL DEFAULT 'default',
+        first_seen_at INTEGER NOT NULL,
+        fingerprint TEXT NOT NULL DEFAULT ''
+      )`,
+    );
+
+    try {
+      // Set the checkpoint BEFORE inserting data — the migration should skip
+      setMemoryCheckpoint(MIGRATE_ITEMS_CHECKPOINT, "done");
+
+      rawRun(
+        `INSERT INTO memory_items (id, kind, subject, statement, status, confidence, importance, scope_id, first_seen_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        "legacy-item-3",
+        "relationship",
+        "Colleague",
+        "Works with user on project X",
+        "active",
+        0.75,
+        0.6,
+        "default",
+        1700000000000,
+      );
+
+      // Run migration — should be a no-op because checkpoint is set
+      migrateToolCreatedItems();
+
+      // Assert no rows were inserted into memory_graph_nodes
+      const rows = rawAll<{ id: string }>("SELECT id FROM memory_graph_nodes");
+      expect(rows).toHaveLength(0);
+    } finally {
+      rawRun("DROP TABLE IF EXISTS memory_items");
+    }
+  });
+
+  test("handles missing memory_items table gracefully", () => {
+    // Ensure memory_items table does not exist
+    rawRun("DROP TABLE IF EXISTS memory_items");
+
+    // Clear the checkpoint so migration attempts to run
+    rawRun(
+      "DELETE FROM memory_checkpoints WHERE key = ?",
+      MIGRATE_ITEMS_CHECKPOINT,
+    );
+
+    // Should not throw even though the table doesn't exist
+    expect(() => migrateToolCreatedItems()).not.toThrow();
+
+    // The checkpoint should be set to "done" (migration handled the missing table)
+    const checkpoint = rawGet<{ value: string }>(
+      "SELECT value FROM memory_checkpoints WHERE key = ?",
+      MIGRATE_ITEMS_CHECKPOINT,
+    );
+    expect(checkpoint).not.toBeNull();
+    expect(checkpoint!.value).toBe("done");
+  });
+});