@vellumai/assistant 0.5.16 → 0.6.0

package/src/memory/conversation-group-migration.ts

@@ -0,0 +1,157 @@
+/**
+ * Runtime migration for the conversation_groups table and group_id column
+ * on the conversations table. Follows the same lazy-initialization pattern
+ * as conversation-display-order-migration.ts.
+ *
+ * group_id is display/organizational metadata, consistent with how
+ * display_order and is_pinned are handled via runtime migration rather
+ * than the formal migrations/ pipeline.
+ */
+
+import { getLogger } from "../util/logger.js";
+import { ensureDisplayOrderMigration } from "./conversation-display-order-migration.js";
+import { rawExec, rawGet, rawRun } from "./db.js";
+
+const log = getLogger("conversation-store");
+
+function isDuplicateColumnError(err: unknown): boolean {
+  return err instanceof Error && /duplicate column name:/i.test(err.message);
+}
+
+let migrated = false;
+
+/**
+ * Uses raw BEGIN/COMMIT for the one-time backfill. Must NOT be called
+ * for the first time inside a Drizzle db.transaction() block — SQLite
+ * does not support nested transactions. In practice this is safe because
+ * the migration is triggered by early startup queries (listConversations,
+ * batchSetDisplayOrders) before any transaction-wrapped paths run, and
+ * the `migrated` flag makes subsequent calls no-ops.
+ */
+export function ensureGroupMigration(): void {
+  if (migrated) return;
+
+  // 1. Create groups table if not exists
+  rawExec(`
+    CREATE TABLE IF NOT EXISTS conversation_groups (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      sort_position REAL NOT NULL DEFAULT 0,
+      is_system_group BOOLEAN NOT NULL DEFAULT FALSE,
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
+      updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
+    )
+  `);
+
+  // 2. Add group_id column if not exists
+  // Match existing error-handling pattern from conversation-display-order-migration.ts:
+  // only swallow duplicate-column errors, log+throw everything else.
+  try {
+    rawRun(
+      "ALTER TABLE conversations ADD COLUMN group_id TEXT REFERENCES conversation_groups(id) ON DELETE SET NULL",
+    );
+  } catch (err) {
+    if (!isDuplicateColumnError(err)) {
+      log.error({ err }, "Failed to add group_id column");
+      throw err;
+    }
+  }
+
+  // 3. Seed system groups (three: pinned, scheduled, background)
+  rawExec(`
+    INSERT OR IGNORE INTO conversation_groups (id, name, sort_position, is_system_group)
+    VALUES
+      ('system:pinned', 'Pinned', 0, TRUE),
+      ('system:scheduled', 'Scheduled', 1, TRUE),
+      ('system:background', 'Background', 2, TRUE)
+  `);
+
+  // 4. One-time backfill (guard: persistent marker prevents re-running on restart)
+  //
+  // The backfill sets group_id on existing conversations based on their attributes.
+  // It must only run once — re-running would overwrite user-explicit ungrouping
+  // (e.g., user removes a conversation from a group → group_id = NULL → next restart
+  // would backfill it back into system:background). A persistent marker row in
+  // conversation_groups tracks whether backfill has already completed.
+  const backfillDone = rawGet<{ id: string }>(
+    "SELECT id FROM conversation_groups WHERE id = '_backfill_complete'",
+  );
+
+  if (!backfillDone) {
+    ensureDisplayOrderMigration(); // ensure is_pinned column exists first
+
+    // Canonical classification rules (full decision tree with precedence):
+    //
+    //   1. Pinned:     is_pinned = TRUE
+    //                  → system:pinned (always wins, checked first)
+    //
+    //   2. Scheduled:  source IN ('schedule', 'reminder') OR schedule_job_id IS NOT NULL
+    //                  → system:scheduled (checked second)
+    //
+    //   3. Background: (conversation_type = 'background' AND COALESCE(source, '') != 'notification')
+    //                  OR source IN ('heartbeat', 'task')
+    //                  AND COALESCE(source, '') NOT IN ('schedule', 'reminder')  ← safety + NULL handling
+    //                  AND schedule_job_id IS NULL                               ← safety: prevents overlap with step 2
+    //                  → system:background
+    //
+    //   4. Else:       ungrouped (group_id = NULL)
+    //
+    // Each backfill step uses AND group_id IS NULL to avoid reassignment.
+    // The exclusion guards in step 3 are belt-and-suspenders — step 2's
+    // group_id IS NULL guard already prevents overlap, but the explicit
+    // exclusions make the SQL self-documenting and migration-order-independent.
+    // COALESCE handles NULL source values (legacy rows).
+
+    // Wrap all backfill steps in a transaction so a partial failure
+    // (e.g. crash mid-backfill) doesn't leave conversations half-classified
+    // with the marker row missing, which would cause a re-run to skip
+    // already-classified rows (group_id IS NULL guard).
+    try {
+      rawExec("BEGIN");
+
+      // Step A: Pinned -> system:pinned (runs first, always wins)
+      rawExec(`
+        UPDATE conversations SET group_id = 'system:pinned'
+        WHERE is_pinned = 1 AND group_id IS NULL
+      `);
+
+      // Step B: Scheduled -> system:scheduled (schedule/reminder source or has schedule_job_id)
+      rawExec(`
+        UPDATE conversations SET group_id = 'system:scheduled'
+        WHERE (source IN ('schedule', 'reminder') OR schedule_job_id IS NOT NULL)
+        AND group_id IS NULL
+      `);
+
+      // Step C: Background -> system:background (background type, heartbeat, or task — excluding notifications)
+      // Explicit exclusion of schedule sources + schedule_job_id as a safety net.
+      // Step B already catches those via group_id IS NULL guard, but the explicit exclusion
+      // makes the SQL self-documenting and protects against future migration ordering changes.
+      // Note: source can be NULL for legacy rows. NULL != 'notification' evaluates to NULL (not TRUE)
+      // in SQL, so use COALESCE to treat NULL source as empty string for the exclusion checks.
+      rawExec(`
+        UPDATE conversations SET group_id = 'system:background'
+        WHERE (
+          (conversation_type = 'background' AND COALESCE(source, '') != 'notification')
+          OR source IN ('heartbeat', 'task')
+        )
+        AND COALESCE(source, '') NOT IN ('schedule', 'reminder')
+        AND schedule_job_id IS NULL
+        AND group_id IS NULL
+      `);
+
+      // Mark backfill as complete so it won't re-run on future process restarts
+      rawExec(`
+        INSERT OR IGNORE INTO conversation_groups (id, name, sort_position, is_system_group)
+        VALUES ('_backfill_complete', '_backfill_complete', -1, TRUE)
+      `);
+
+      rawExec("COMMIT");
+    } catch (err) {
+      rawExec("ROLLBACK");
+      log.error({ err }, "Group backfill transaction failed, rolled back");
+      throw err;
+    }
+  }
+
+  migrated = true;
+}

package/src/memory/conversation-queries.ts

@@ -4,6 +4,7 @@ import { getLogger } from "../util/logger.js";
 import type { ConversationRow } from "./conversation-crud.js";
 import { parseConversation } from "./conversation-crud.js";
 import { ensureDisplayOrderMigration } from "./conversation-display-order-migration.js";
+import { ensureGroupMigration } from "./conversation-group-migration.js";
 import { getDb, rawAll } from "./db.js";
 import { conversations, messages } from "./schema.js";
 
@@ -13,7 +14,7 @@ const log = getLogger("conversation-store");
  * Build an FTS5 MATCH query string from natural text by extracting tokens.
  * Used for messages_fts full-text search over conversation content.
  */
-function buildFtsMatchQuery(text: string): string | null {
+export function buildFtsMatchQuery(text: string): string | null {
   const tokens = text
     .toLowerCase()
     .split(/[^a-z0-9_]+/g)
@@ -30,6 +31,7 @@ export function listConversations(
   offset = 0,
 ): ConversationRow[] {
   ensureDisplayOrderMigration();
+  ensureGroupMigration();
   const db = getDb();
   const where = backgroundOnly
     ? sql`${conversations.conversationType} = 'background'`
@@ -309,7 +311,7 @@ export function searchConversations(
  * occurrence of `query`. The content may be JSON (content blocks) or plain
  * text; we extract a readable snippet in either case.
  */
-function buildExcerpt(rawContent: string, query: string): string {
+export function buildExcerpt(rawContent: string, query: string): string {
   // Try to extract plain text from JSON content blocks first.
   let text = rawContent;
   try {

package/src/memory/db-init.ts

@@ -11,6 +11,7 @@ import { dirname, join } from "node:path";
 
 import { ensureDataDir, getDbPath } from "../util/platform.js";
 import { getDb, getSqlite } from "./db-connection.js";
+import { migrateToolCreatedItems } from "./graph/bootstrap.js";
 import {
   addCoreColumns,
   createActorRefreshTokenRecordsTable,
@@ -57,6 +58,7 @@ import {
   migrateContactsUserFileColumn,
   migrateConversationForkLineage,
   migrateConversationsThreadTypeIndex,
+  migrateCreateMemoryGraphTables,
   migrateCreateMemoryRecallLogs,
   migrateCreateThreadStartersTable,
   migrateCreateTraceEventsTable,
@@ -69,6 +71,7 @@ import {
   migrateDropEntityTables,
   migrateDropLegacyMemberGuardianTables,
   migrateDropLoopbackPortColumn,
+  migrateDropMemoryItemsTables,
   migrateDropMemorySegmentFts,
   migrateDropOrphanedMediaTables,
   migrateDropRemindersTable,
@@ -91,6 +94,7 @@ import {
   migrateInviteContactId,
   migrateLlmRequestLogMessageId,
   migrateLlmRequestLogProvider,
+  migrateMemoryGraphImageRefs,
   migrateMemoryItemSupersession,
   migrateMessagesConversationCreatedAtIndex,
   migrateMessagesFtsBackfill,
@@ -111,6 +115,7 @@ import {
   migrateRenameGmailProviderKeyToGoogle,
   migrateRenameGuardianVerificationValues,
   migrateRenameInboxThreadStateTable,
+  migrateRenameMemoryGraphTypeValues,
   migrateRenameNotificationThreadColumns,
   migrateRenameSequenceEnrollmentsThreadIdColumn,
   migrateRenameSequenceStepsReplyKey,
@@ -139,8 +144,8 @@ import {
 // ---------------------------------------------------------------------------
 
 function getTemplateDbPath(): string {
-  // Hash this file + all migration files so the template auto-invalidates
-  // when any migration changes.
+  // Hash this file + all migration files + bootstrap migration so the template
+  // auto-invalidates when any migration changes.
   const thisFile = new URL(import.meta.url).pathname;
   const hash = createHash("md5");
   hash.update(readFileSync(thisFile, "utf-8"));
@@ -150,9 +155,15 @@ function getTemplateDbPath(): string {
       hash.update(readFileSync(join(migrationsDir, name), "utf-8"));
     }
   }
+  // Include the bootstrap migration (migrateToolCreatedItems) which also runs
+  // during initializeDb but lives outside the migrations/ directory.
+  const bootstrapFile = join(dirname(thisFile), "graph", "bootstrap.ts");
+  if (existsSync(bootstrapFile)) {
+    hash.update(readFileSync(bootstrapFile, "utf-8"));
+  }
   return join(
     tmpdir(),
-    `vellum-test-db-template-${hash.digest("hex").slice(0, 12)}.db`,
+    `vellum-test-db-template-${hash.digest("hex").slice(0, 12)}.db`
   );
 }
 
@@ -549,6 +560,22 @@ export function initializeDb(): void {
   // (transport is now chosen per-flow via the callbackTransport option, not per-provider)
   migrateDropCallbackTransportColumn(database);
 
+  // 101. Memory graph tables (nodes, edges, triggers)
+  migrateCreateMemoryGraphTables(database);
+
+  // 101b. Migrate tool-created items from legacy memory_items → graph nodes
+  // MUST run before migration 102 drops memory_items so data is preserved.
+  migrateToolCreatedItems();
+
+  // 102. Drop legacy memory_items and memory_item_sources tables (migrated to memory_graph_nodes)
+  migrateDropMemoryItemsTables(database);
+
+  // 103. Rename legacy memory graph node type values: style → behavioral, relationship → semantic
+  migrateRenameMemoryGraphTypeValues(database);
+
+  // 104. Add nullable image_refs TEXT column to memory_graph_nodes
+  migrateMemoryGraphImageRefs(database);
+
   validateMigrationState(database);
 
   if (process.env.BUN_TEST === "1") {

package/src/memory/embed.ts

@@ -0,0 +1,73 @@
+// ---------------------------------------------------------------------------
+// Shared embedding utility with retry + exponential backoff
+// ---------------------------------------------------------------------------
+
+import type { AssistantConfig } from "../config/types.js";
+import { getLogger } from "../util/logger.js";
+import {
+  abortableSleep,
+  computeRetryDelay,
+  isRetryableNetworkError,
+} from "../util/retry.js";
+import { type EmbeddingInput, embedWithBackend } from "./embedding-backend.js";
+
+const log = getLogger("memory-embed");
+
+const EMBED_MAX_RETRIES = 3;
+const EMBED_BASE_DELAY_MS = 500;
+
+/**
+ * Wrap embedWithBackend with retry + exponential backoff for transient failures
+ * (network errors, 429s, 5xx). Aborts immediately if the caller's signal fires.
+ */
+export async function embedWithRetry(
+  config: AssistantConfig,
+  texts: EmbeddingInput[],
+  opts?: { signal?: AbortSignal },
+): ReturnType<typeof embedWithBackend> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= EMBED_MAX_RETRIES; attempt++) {
+    try {
+      return await embedWithBackend(config, texts, opts);
+    } catch (err) {
+      lastError = err;
+      if (opts?.signal?.aborted || isAbortError(err)) throw err;
+      const isTransient =
+        isRetryableNetworkError(err) || isHttpStatusError(err);
+      if (!isTransient || attempt === EMBED_MAX_RETRIES) throw err;
+      const delay = computeRetryDelay(attempt, EMBED_BASE_DELAY_MS);
+      log.warn(
+        { err, attempt: attempt + 1, delayMs: Math.round(delay) },
+        "Transient embedding failure, retrying",
+      );
+      await abortableSleep(delay, opts?.signal);
+      if (opts?.signal?.aborted) throw err;
+    }
+  }
+  throw lastError;
+}
+
+function isAbortError(err: unknown): boolean {
+  if (!(err instanceof Error)) return false;
+  return err.name === "AbortError" || err.name === "APIUserAbortError";
+}
+
+function getErrorStatusCode(err: Error): unknown {
+  if ("status" in err) {
+    const status = (err as { status: unknown }).status;
+    if (status != null) return status;
+  }
+  if ("statusCode" in err) return (err as { statusCode: unknown }).statusCode;
+  return undefined;
+}
+
+function isHttpStatusError(err: unknown): boolean {
+  if (!(err instanceof Error)) return false;
+  const status = getErrorStatusCode(err);
+  if (typeof status === "number") {
+    return status === 429 || (status >= 500 && status < 600);
+  }
+  return /\b429\b|(?:failed|error)\s*\((?:429|5\d{2})\)|(?:status|http)\s*(?:code\s*)?:?\s*5\d{2}\b/i.test(
+    err.message,
+  );
+}

package/src/memory/embedding-backend.ts

@@ -650,27 +650,21 @@ async function selectFallbackBackends(
 }
 
 /**
- * Returns true when the embedding pipeline can handle multimodal inputs
- * (images, audio, video). Today only Gemini supports multimodal.
+ * Returns true when the active (primary) embedding backend can handle
+ * multimodal inputs (images, audio, video). Today only Gemini supports
+ * multimodal.
  *
- * In auto mode, the primary backend is usually local or OpenAI, but
- * embedWithBackend builds a fallback chain that includes Gemini when
- * available. We check both the primary and fallback backends so that
- * multimodal jobs are still enqueued when Gemini is reachable via fallback.
+ * Only returns true when Gemini is the primary selected backend — not when
+ * it's merely available as a fallback. Writing multimodal embeddings via a
+ * fallback provider while queries go through the primary text backend would
+ * mix incompatible vector spaces, making retrieval unreliable.
  */
 export async function selectedBackendSupportsMultimodal(
   config: AssistantConfig,
 ): Promise<boolean> {
   const { backend } = await selectEmbeddingBackend(config);
   if (!backend) return false;
-  if (backend.provider === "gemini") return true;
-
-  // In auto mode, check if Gemini is available as a fallback backend.
-  if (config.memory.embeddings.provider === "auto") {
-    const fallbacks = await selectFallbackBackends(config, backend.provider);
-    return fallbacks.some((fb) => fb.provider === "gemini");
-  }
-  return false;
+  return backend.provider === "gemini";
 }
 
 async function isOllamaConfigured(config: AssistantConfig): Promise<boolean> {

package/src/memory/embedding-runtime-manager.ts

@@ -14,7 +14,6 @@
  */
 
 import {
-  chmodSync,
   existsSync,
   mkdirSync,
   readdirSync,
@@ -26,6 +25,7 @@ import {
 import { arch, platform } from "node:os";
 import { join } from "node:path";
 
+import { ensureBun, findBun } from "../util/bun-runtime.js";
 import { getLogger } from "../util/logger.js";
 import { getEmbeddingModelsDir } from "../util/platform.js";
 import { PromiseGuard } from "../util/promise-guard.js";
@@ -38,9 +38,6 @@ const ONNXRUNTIME_COMMON_VERSION = "1.21.0";
 const TRANSFORMERS_VERSION = "3.8.1";
 const JINJA_VERSION = "0.5.5";
 
-/** Bun version to download when system bun is not available. */
-const BUN_VERSION = "1.2.0";
-
 /** Composite version string for cache invalidation. */
 const RUNTIME_VERSION = `ort-${ONNXRUNTIME_NODE_VERSION}_hf-${TRANSFORMERS_VERSION}_jinja-${JINJA_VERSION}`;
 
@@ -200,25 +197,15 @@ export class EmbeddingRuntimeManager {
 
   /**
    * Find a usable bun binary.
-   * Checks: downloaded copy → common install locations.
+   * Delegates to the shared bun-runtime helper, also checking
+   * the legacy per-runtime bin/ directory for backwards compat.
    */
   getBunPath(): string | undefined {
-    // 1. Downloaded bun
-    const downloadedBun = join(this.baseDir, "bin", "bun");
-    if (existsSync(downloadedBun)) return downloadedBun;
-
-    // 2. Common installation paths — the compiled daemon inherits a
-    //    restricted PATH, so we check well-known prefixes directly.
-    const home = process.env.HOME ?? "";
-    for (const p of [
-      join(home, ".bun", "bin", "bun"),
-      "/opt/homebrew/bin/bun",
-      "/usr/local/bin/bun",
-    ]) {
-      if (existsSync(p)) return p;
-    }
+    // Check per-runtime bin/ directory for backwards compat
+    const legacyBun = join(this.baseDir, "bin", "bun");
+    if (existsSync(legacyBun)) return legacyBun;
 
-    return undefined;
+    return findBun();
   }
 
   /**
@@ -301,12 +288,10 @@ export class EmbeddingRuntimeManager {
 
     // Declared outside try so catch/finally can reference them for cleanup
     const modelCacheDir = join(this.baseDir, "model-cache");
-    const existingBinDir = join(this.baseDir, "bin");
     let tmpModelCache: string | null = null;
-    let tmpBinDir: string | null = null;
 
     try {
-      // Step 1: Download npm packages (and bun if needed) in parallel
+      // Step 1: Download npm packages in parallel
       const nodeModules = join(tmpDir, "node_modules");
       const downloads: Promise<void>[] = [
         downloadAndExtract(
@@ -331,13 +316,11 @@ export class EmbeddingRuntimeManager {
         ),
       ];
 
-      // Download bun binary if not already available on the system
-      if (!this.getBunPath()) {
-        downloads.push(this.downloadBunBinary(tmpDir, signal));
-      }
-
       await Promise.all(downloads);
 
+      // Ensure bun is available (downloads to shared location if needed)
+      await ensureBun();
+
       if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
 
       log.info("npm packages downloaded, stripping non-platform binaries");
@@ -411,7 +394,7 @@ export class EmbeddingRuntimeManager {
       );
 
       // Step 6: Atomic swap — remove old install and rename temp to final
-      // Preserve model-cache/, bin/ (downloaded bun), and .gitignore
+      // Preserve model-cache/ and .gitignore
       const hadModelCache = existsSync(modelCacheDir);
       if (hadModelCache) {
         tmpModelCache = join(
@@ -421,14 +404,6 @@ export class EmbeddingRuntimeManager {
         renameSync(modelCacheDir, tmpModelCache);
       }
 
-      // Preserve downloaded bun binary if it exists and we didn't just download a new one
-      const newBinDir = join(tmpDir, "bin");
-      const hadBinDir = existsSync(existingBinDir) && !existsSync(newBinDir);
-      if (hadBinDir) {
-        tmpBinDir = join(this.baseDir, `.bin-preserve-${Date.now()}`);
-        renameSync(existingBinDir, tmpBinDir);
-      }
-
       // Remove old install (preserving dotfiles like .gitignore, .downloading, temp dirs)
       for (const entry of readdirSync(this.baseDir)) {
         if (entry.startsWith(".") || entry === tmpDir.split("/").pop())
@@ -446,11 +421,6 @@ export class EmbeddingRuntimeManager {
         renameSync(tmpModelCache, modelCacheDir);
       }
 
-      // Restore bun binary
-      if (tmpBinDir && existsSync(tmpBinDir)) {
-        renameSync(tmpBinDir, existingBinDir);
-      }
-
       log.info(
         { runtimeVersion: RUNTIME_VERSION },
         "Embedding runtime installed successfully",
@@ -468,13 +438,6 @@ export class EmbeddingRuntimeManager {
           /* best effort */
         }
       }
-      if (tmpBinDir && existsSync(tmpBinDir) && !existsSync(existingBinDir)) {
-        try {
-          renameSync(tmpBinDir, existingBinDir);
-        } catch {
-          /* best effort */
-        }
-      }
       log.error({ err }, "Failed to install embedding runtime");
       throw err;
     } finally {
@@ -482,72 +445,7 @@ export class EmbeddingRuntimeManager {
       rmSync(tmpDir, { recursive: true, force: true });
       if (tmpModelCache)
         rmSync(tmpModelCache, { recursive: true, force: true });
-      if (tmpBinDir) rmSync(tmpBinDir, { recursive: true, force: true });
-    }
-  }
-
-  private async downloadBunBinary(
-    installDir: string,
-    signal?: AbortSignal,
-  ): Promise<void> {
-    const os = platform();
-    const cpu = arch() === "arm64" ? "aarch64" : arch();
-    const target = `${os}-${cpu}`;
-    const url = `https://github.com/oven-sh/bun/releases/download/bun-v${BUN_VERSION}/bun-${target}.zip`;
-
-    log.info(
-      { url, target, bunVersion: BUN_VERSION },
-      "Downloading bun binary",
-    );
-
-    const response = await fetch(url, {
-      signal,
-      redirect: "follow",
-    });
-    if (!response.ok) {
-      throw new Error(
-        `Failed to download bun: ${response.status} ${response.statusText}`,
-      );
-    }
-
-    const zipData = await response.arrayBuffer();
-    const binDir = join(installDir, "bin");
-    mkdirSync(binDir, { recursive: true });
-
-    const tmpZip = join(binDir, `bun-download-${Date.now()}.zip`);
-    writeFileSync(tmpZip, Buffer.from(zipData));
-
-    try {
-      // Extract zip
-      const proc = Bun.spawn({
-        cmd: ["unzip", "-o", tmpZip, "-d", binDir],
-        stdout: "ignore",
-        stderr: "pipe",
-      });
-      await proc.exited;
-      if (proc.exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text();
-        throw new Error(`Failed to extract bun zip: ${stderr}`);
-      }
-
-      // Move binary from bun-{target}/bun to bin/bun
-      const extractedBun = join(binDir, `bun-${target}`, "bun");
-      if (existsSync(extractedBun)) {
-        renameSync(extractedBun, join(binDir, "bun"));
-        rmSync(join(binDir, `bun-${target}`), { recursive: true, force: true });
-      }
-
-      // Make executable
-      chmodSync(join(binDir, "bun"), 0o755);
-    } finally {
-      try {
-        rmSync(tmpZip);
-      } catch {
-        /* ignore */
-      }
     }
-
-    log.info("Bun binary downloaded successfully");
   }
 
   private readManifest(): VersionManifest | null {

package/src/memory/fingerprint.ts

@@ -5,8 +5,8 @@ import { createHash } from "node:crypto";
  *
  * Format: sha256(`${scopeId}|${kind}|${subject}|${statement}`)
  *
- * All writers (memory_manage save/update ops, items-extractor, playbook-create,
- * playbook-update, gmail-analyze-style) MUST use this function so the
+ * All writers (memory_manage save/update ops, items-extractor,
+ * gmail-analyze-style) MUST use this function so the
  * fingerprint scheme stays consistent and deduplication works correctly.
  */
 export function computeMemoryFingerprint(