@vellumai/assistant 0.7.3 → 0.8.1

package/src/memory/migrations/244-provider-connection-status-label.ts

@@ -0,0 +1,23 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Adds `status` (NOT NULL DEFAULT 'active') and `label` (nullable) columns
+ * to the `provider_connections` table.
+ *
+ * Idempotent: reads PRAGMA table_info before each ALTER so re-running on a
+ * database that already has the columns is a no-op.
+ */
+export function migrateProviderConnectionStatusLabel(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  const columns = raw.query(`PRAGMA table_info(provider_connections)`).all() as Array<{ name: string }>;
+  const columnNames = new Set(columns.map((c) => c.name));
+
+  if (!columnNames.has("status")) {
+    raw.exec(`ALTER TABLE provider_connections ADD COLUMN status TEXT NOT NULL DEFAULT 'active'`);
+  }
+
+  if (!columnNames.has("label")) {
+    raw.exec(`ALTER TABLE provider_connections ADD COLUMN label TEXT`);
+  }
+}

package/src/memory/migrations/245-memory-retrospective-state.ts

@@ -0,0 +1,36 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const CHECKPOINT_KEY = "migration_memory_retrospective_state_v1";
+
+/**
+ * Create the memory_retrospective_state table.
+ *
+ * One row per source conversation tracks two independent pointers used by
+ * the memory-retrospective background job:
+ *
+ *   - `last_processed_message_id`: advances ONLY when a retrospective run
+ *     completes successfully (wake invoked + returned without error). On any
+ *     failure path this stays unchanged so the next run reprocesses the same
+ *     messages — the load-bearing correctness invariant.
+ *   - `last_run_at`: advances on EVERY job end (success or failure). Drives
+ *     the per-conversation cooldown gate in the trigger-check helper so a
+ *     failing job can't loop in tight retries across trigger types.
+ *
+ * The foreign key cascades so the state row dies with its source
+ * conversation. Without the cascade, deleted conversations would leak rows.
+ */
+export function migrateMemoryRetrospectiveState(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+
+    raw.exec(/*sql*/ `
+      CREATE TABLE IF NOT EXISTS memory_retrospective_state (
+        conversation_id TEXT PRIMARY KEY REFERENCES conversations(id) ON DELETE CASCADE,
+        last_processed_message_id TEXT NOT NULL,
+        last_run_at INTEGER NOT NULL
+      )
+    `);
+  });
+}

package/src/memory/migrations/246-backfill-provider-connection-label.ts

@@ -0,0 +1,81 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * One-shot backfill: set `label = name` for any `provider_connections` row
+ * whose `label` is NULL (or empty after trim). Migration 244 added the
+ * `label` column as nullable with no default, so every row that existed
+ * pre-244 (and any row created against an older client that didn't yet
+ * write a label) ended up with NULL.
+ *
+ * Why this matters for users: in 0.8.x the editor modal renders Display
+ * Name from `label` and shows the empty-state placeholder ("e.g. My
+ * OpenAI") whenever it's null. Users who created connections before the
+ * label field existed open the editor and see what looks like an empty
+ * field, then conclude their data was wiped during the upgrade.
+ *
+ * The fix is to give every pre-feature row a sensible default — its own
+ * connection name. The list view already falls back to `name` when label
+ * is empty (see ProvidersSheet.swift `connectionRow`), so this brings the
+ * editor into agreement with what's already on screen.
+ *
+ * Idempotency: guarded by `memory_checkpoints` so a second boot won't
+ * re-clobber a label the user has intentionally cleared after the
+ * backfill ran. New rows created post-backfill follow the normal
+ * label-is-optional contract.
+ */
+export function migrateBackfillProviderConnectionLabel(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const checkpointKey = "backfill_provider_connection_label";
+
+  const checkpoint = raw
+    .query(`SELECT 1 FROM memory_checkpoints WHERE key = ?`)
+    .get(checkpointKey);
+  if (checkpoint) return;
+
+  // Guard: skip if the table doesn't exist yet (first-boot edge case where
+  // migration 243 hasn't run, e.g. fresh install ordering test harness).
+  const tableExists = raw
+    .query(
+      `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'provider_connections'`,
+    )
+    .get();
+  if (!tableExists) {
+    raw
+      .query(
+        `INSERT OR IGNORE INTO memory_checkpoints (key, value, updated_at) VALUES (?, '1', ?)`,
+      )
+      .run(checkpointKey, Date.now());
+    return;
+  }
+
+  // Guard: also skip if the label column hasn't been added yet (migration
+  // 244 hasn't run). Treat as no-op + don't checkpoint, so the backfill
+  // runs the next time it gets a chance against a populated schema.
+  const columns = raw
+    .query(`PRAGMA table_info(provider_connections)`)
+    .all() as Array<{ name: string }>;
+  if (!columns.some((c) => c.name === "label")) {
+    return;
+  }
+
+  try {
+    raw.exec("BEGIN");
+
+    raw.exec(/*sql*/ `
+      UPDATE provider_connections
+      SET label = name
+      WHERE label IS NULL OR TRIM(label) = ''
+    `);
+
+    raw
+      .query(
+        `INSERT OR IGNORE INTO memory_checkpoints (key, value, updated_at) VALUES (?, '1', ?)`,
+      )
+      .run(checkpointKey, Date.now());
+
+    raw.exec("COMMIT");
+  } catch (err) {
+    raw.exec("ROLLBACK");
+    throw err;
+  }
+}

package/src/memory/migrations/__tests__/244-provider-connection-status-label.test.ts

@@ -0,0 +1,84 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateCreateProviderConnections } from "../243-provider-connections.js";
+import { migrateProviderConnectionStatusLabel } from "../244-provider-connection-status-label.js";
+
+interface ColumnRow {
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: string | null;
+  pk: number;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+describe("migration 244 — provider_connection status + label", () => {
+  test("adds status (NOT NULL DEFAULT active) and label (nullable) columns", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    // Bootstrap provider_connections table via migration 243.
+    migrateCreateProviderConnections(db);
+
+    // Verify the new columns are absent before migration 244.
+    const colsBefore = raw.query(`PRAGMA table_info(provider_connections)`).all() as ColumnRow[];
+    const namesBefore = colsBefore.map((c) => c.name);
+    expect(namesBefore).not.toContain("status");
+    expect(namesBefore).not.toContain("label");
+
+    migrateProviderConnectionStatusLabel(db);
+
+    const cols = raw.query(`PRAGMA table_info(provider_connections)`).all() as ColumnRow[];
+    const colMap = Object.fromEntries(cols.map((c) => [c.name, c]));
+
+    // status: NOT NULL, default 'active'
+    expect(colMap["status"]).toBeDefined();
+    expect(colMap["status"].notnull).toBe(1);
+    expect(colMap["status"].dflt_value).toBe("'active'");
+
+    // label: nullable
+    expect(colMap["label"]).toBeDefined();
+    expect(colMap["label"].notnull).toBe(0);
+    expect(colMap["label"].dflt_value).toBeNull();
+  });
+
+  test("is idempotent — running twice does not throw", () => {
+    const db = createTestDb();
+    migrateCreateProviderConnections(db);
+    migrateProviderConnectionStatusLabel(db);
+    expect(() => migrateProviderConnectionStatusLabel(db)).not.toThrow();
+  });
+
+  test("existing rows get status=active from column default", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    // Seed a row before adding the status column.
+    migrateCreateProviderConnections(db);
+
+    // Verify canonical connections got the default.
+    migrateProviderConnectionStatusLabel(db);
+
+    const rows = raw.query(`SELECT name, status, label FROM provider_connections`).all() as Array<{
+      name: string;
+      status: string;
+      label: string | null;
+    }>;
+    expect(rows.length).toBeGreaterThan(0);
+    for (const row of rows) {
+      expect(row.status).toBe("active");
+      expect(row.label).toBeNull();
+    }
+  });
+});

package/src/memory/migrations/__tests__/245-memory-retrospective-state.test.ts

@@ -0,0 +1,125 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateMemoryRetrospectiveState } from "../245-memory-retrospective-state.js";
+
+interface ColumnRow {
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: string | null;
+  pk: number;
+}
+
+interface ForeignKeyRow {
+  id: number;
+  seq: number;
+  table: string;
+  from: string;
+  to: string;
+  on_update: string;
+  on_delete: string;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  // `withCrashRecovery` (used by the migration) reads/writes a
+  // `memory_checkpoints` table. Seed a minimal version so the migration's
+  // structural setup can be exercised without booting the entire
+  // db-init pipeline.
+  sqlite.exec(`
+    CREATE TABLE memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  // The state table FK references `conversations(id)`, so the test DB needs
+  // that table to exist before we can apply the FK. Use a minimal table —
+  // we're only checking the migration's structural output, not exercising
+  // cascade behavior end-to-end.
+  sqlite.exec(`
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL
+    )
+  `);
+  return drizzle(sqlite, { schema });
+}
+
+describe("migration 245 — memory_retrospective_state", () => {
+  test("creates the table with the expected columns and primary key", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateMemoryRetrospectiveState(db);
+
+    const cols = raw
+      .query(`PRAGMA table_info(memory_retrospective_state)`)
+      .all() as ColumnRow[];
+    const colMap = Object.fromEntries(cols.map((c) => [c.name, c]));
+
+    expect(colMap["conversation_id"]).toBeDefined();
+    expect(colMap["conversation_id"].pk).toBe(1);
+
+    expect(colMap["last_processed_message_id"]).toBeDefined();
+    expect(colMap["last_processed_message_id"].notnull).toBe(1);
+
+    expect(colMap["last_run_at"]).toBeDefined();
+    expect(colMap["last_run_at"].notnull).toBe(1);
+  });
+
+  test("FK on conversation_id is ON DELETE CASCADE", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateMemoryRetrospectiveState(db);
+
+    const fks = raw
+      .query(`PRAGMA foreign_key_list(memory_retrospective_state)`)
+      .all() as ForeignKeyRow[];
+
+    expect(fks).toHaveLength(1);
+    expect(fks[0]!.from).toBe("conversation_id");
+    expect(fks[0]!.table).toBe("conversations");
+    expect(fks[0]!.to).toBe("id");
+    expect(fks[0]!.on_delete).toBe("CASCADE");
+  });
+
+  test("is idempotent — running twice does not throw", () => {
+    const db = createTestDb();
+
+    migrateMemoryRetrospectiveState(db);
+    expect(() => migrateMemoryRetrospectiveState(db)).not.toThrow();
+  });
+
+  test("deleting a conversation cascades to its state row", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+
+    migrateMemoryRetrospectiveState(db);
+
+    raw.exec(`INSERT INTO conversations (id, created_at) VALUES ('c1', 0)`);
+    raw.exec(
+      `INSERT INTO memory_retrospective_state (conversation_id, last_processed_message_id, last_run_at) VALUES ('c1', 'm1', 1000)`,
+    );
+
+    const before = raw
+      .query(`SELECT COUNT(*) AS c FROM memory_retrospective_state`)
+      .get() as { c: number };
+    expect(before.c).toBe(1);
+
+    raw.exec(`DELETE FROM conversations WHERE id = 'c1'`);
+
+    const after = raw
+      .query(`SELECT COUNT(*) AS c FROM memory_retrospective_state`)
+      .get() as { c: number };
+    expect(after.c).toBe(0);
+  });
+});

package/src/memory/migrations/__tests__/246-backfill-provider-connection-label.test.ts

@@ -0,0 +1,192 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import { migrateCreateProviderConnections } from "../243-provider-connections.js";
+import { migrateProviderConnectionStatusLabel } from "../244-provider-connection-status-label.js";
+import { migrateBackfillProviderConnectionLabel } from "../246-backfill-provider-connection-label.js";
+
+interface ConnectionRow {
+  name: string;
+  label: string | null;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+/// Ensure the `memory_checkpoints` table exists in test DBs — it's normally
+/// provisioned by earlier infra migrations that the test harness doesn't
+/// pull in. Schema mirrors what other backfill migrations expect.
+function ensureCheckpointsTable(db: ReturnType<typeof createTestDb>): void {
+  const raw = getSqliteFrom(db);
+  raw.exec(`
+    CREATE TABLE IF NOT EXISTS memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT,
+      updated_at INTEGER
+    )
+  `);
+}
+
+/// Bring the test DB up to the state right before migration 246 runs:
+/// provider_connections table present + status/label columns added.
+function prepareSchemaThroughMigration244(
+  db: ReturnType<typeof createTestDb>,
+): void {
+  migrateCreateProviderConnections(db);
+  migrateProviderConnectionStatusLabel(db);
+  ensureCheckpointsTable(db);
+}
+
+describe("migration 246 — backfill provider_connection label", () => {
+  test("sets label = name for rows where label is NULL", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    prepareSchemaThroughMigration244(db);
+
+    // Insert a row with label = NULL (simulating a pre-244 connection).
+    const now = Date.now();
+    raw
+      .query(
+        `INSERT INTO provider_connections (name, provider, auth, status, label, created_at, updated_at) VALUES (?, ?, ?, 'active', NULL, ?, ?)`,
+      )
+      .run("anthropic-personal", "anthropic", JSON.stringify({ type: "api_key", credential: "credential/anthropic/api_key" }), now, now);
+
+    migrateBackfillProviderConnectionLabel(db);
+
+    const row = raw
+      .query(`SELECT name, label FROM provider_connections WHERE name = ?`)
+      .get("anthropic-personal") as ConnectionRow;
+    expect(row.label).toBe("anthropic-personal");
+  });
+
+  test("sets label = name for rows where label is empty/whitespace", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    prepareSchemaThroughMigration244(db);
+
+    const now = Date.now();
+    raw
+      .query(
+        `INSERT INTO provider_connections (name, provider, auth, status, label, created_at, updated_at) VALUES (?, ?, ?, 'active', ?, ?, ?)`,
+      )
+      .run("openai-empty", "openai", JSON.stringify({ type: "api_key", credential: "credential/openai/api_key" }), "", now, now);
+    raw
+      .query(
+        `INSERT INTO provider_connections (name, provider, auth, status, label, created_at, updated_at) VALUES (?, ?, ?, 'active', ?, ?, ?)`,
+      )
+      .run("openai-whitespace", "openai", JSON.stringify({ type: "api_key", credential: "credential/openai/api_key" }), "   ", now, now);
+
+    migrateBackfillProviderConnectionLabel(db);
+
+    const empty = raw
+      .query(`SELECT label FROM provider_connections WHERE name = ?`)
+      .get("openai-empty") as ConnectionRow;
+    const whitespace = raw
+      .query(`SELECT label FROM provider_connections WHERE name = ?`)
+      .get("openai-whitespace") as ConnectionRow;
+    expect(empty.label).toBe("openai-empty");
+    expect(whitespace.label).toBe("openai-whitespace");
+  });
+
+  test("does NOT overwrite rows where the user has set a non-empty label", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    prepareSchemaThroughMigration244(db);
+
+    const now = Date.now();
+    raw
+      .query(
+        `INSERT INTO provider_connections (name, provider, auth, status, label, created_at, updated_at) VALUES (?, ?, ?, 'active', ?, ?, ?)`,
+      )
+      .run("anthropic-work", "anthropic", JSON.stringify({ type: "api_key", credential: "credential/anthropic/api_key" }), "Anthropic — Work", now, now);
+
+    migrateBackfillProviderConnectionLabel(db);
+
+    const row = raw
+      .query(`SELECT label FROM provider_connections WHERE name = ?`)
+      .get("anthropic-work") as ConnectionRow;
+    expect(row.label).toBe("Anthropic — Work");
+  });
+
+  test("is idempotent — second run does not re-clobber a later user-cleared label", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    prepareSchemaThroughMigration244(db);
+
+    const now = Date.now();
+    raw
+      .query(
+        `INSERT INTO provider_connections (name, provider, auth, status, label, created_at, updated_at) VALUES (?, ?, ?, 'active', NULL, ?, ?)`,
+      )
+      .run("anthropic-personal", "anthropic", JSON.stringify({ type: "api_key", credential: "credential/anthropic/api_key" }), now, now);
+
+    // First run: backfills NULL → "anthropic-personal".
+    migrateBackfillProviderConnectionLabel(db);
+    expect(
+      (raw.query(`SELECT label FROM provider_connections WHERE name = ?`).get("anthropic-personal") as ConnectionRow).label,
+    ).toBe("anthropic-personal");
+
+    // User clears the label after the backfill ran.
+    raw.query(`UPDATE provider_connections SET label = NULL WHERE name = ?`).run("anthropic-personal");
+
+    // Second run: should NOT re-clobber the user's deliberate clear, because
+    // the checkpoint was set on the first successful run.
+    migrateBackfillProviderConnectionLabel(db);
+    expect(
+      (raw.query(`SELECT label FROM provider_connections WHERE name = ?`).get("anthropic-personal") as ConnectionRow).label,
+    ).toBeNull();
+  });
+
+  test("checkpoint is set after a successful run", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    prepareSchemaThroughMigration244(db);
+
+    migrateBackfillProviderConnectionLabel(db);
+
+    const checkpoint = raw
+      .query(`SELECT key FROM memory_checkpoints WHERE key = ?`)
+      .get("backfill_provider_connection_label") as { key: string } | null;
+    expect(checkpoint).not.toBeNull();
+    expect(checkpoint?.key).toBe("backfill_provider_connection_label");
+  });
+
+  test("no-op when provider_connections table is absent (first-boot edge)", () => {
+    const db = createTestDb();
+    ensureCheckpointsTable(db);
+
+    // Don't run 243/244 — the table doesn't exist yet.
+    expect(() => migrateBackfillProviderConnectionLabel(db)).not.toThrow();
+
+    // Checkpoint should still get set so we don't retry forever.
+    const raw = getSqliteFrom(db);
+    const checkpoint = raw
+      .query(`SELECT key FROM memory_checkpoints WHERE key = ?`)
+      .get("backfill_provider_connection_label");
+    expect(checkpoint).not.toBeNull();
+  });
+
+  test("no-op when label column is absent (244 hasn't run yet) — no checkpoint set", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    migrateCreateProviderConnections(db); // 243 only, NOT 244
+    ensureCheckpointsTable(db);
+
+    expect(() => migrateBackfillProviderConnectionLabel(db)).not.toThrow();
+
+    // Crucially: no checkpoint should be set, so the backfill can run later
+    // once 244 has provisioned the column.
+    const checkpoint = raw
+      .query(`SELECT key FROM memory_checkpoints WHERE key = ?`)
+      .get("backfill_provider_connection_label");
+    expect(checkpoint).toBeNull();
+  });
+});

package/src/memory/migrations/index.ts

@@ -201,6 +201,13 @@ export {
 } from "./237-heartbeat-runs.js";
 export { migrateScheduleRetryPolicy } from "./238-schedule-retry-policy.js";
 export { migrateTraceEventsCreatedAtIndex } from "./239-trace-events-created-at-index.js";
+export { migrateConversationInferenceProfileSession } from "./240-conversation-inference-profile-session.js";
+export { migrateActivationStateFkCascade } from "./241-activation-state-fk-cascade.js";
+export { migrateMessageBookmarks } from "./242-message-bookmarks.js";
+export { migrateCreateProviderConnections } from "./243-provider-connections.js";
+export { migrateProviderConnectionStatusLabel } from "./244-provider-connection-status-label.js";
+export { migrateMemoryRetrospectiveState } from "./245-memory-retrospective-state.js";
+export { migrateBackfillProviderConnectionLabel } from "./246-backfill-provider-connection-label.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/pkb/pkb-search.test.ts

@@ -1,12 +1,13 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
-import { _setOverridesForTesting } from "../../config/assistant-feature-flags.js";
 
-// This test exercises the v1 PKB search path. The `memory-v2-enabled` flag
-// (registry default `true`) makes pkb-search short-circuit to keep traffic
-// off the legacy collection — disable it so the v1 path stays under test.
-_setOverridesForTesting({ "memory-v2-enabled": false });
+// This test exercises the v1 PKB search path. `config.memory.v2.enabled`
+// (default `true`) makes pkb-search short-circuit to keep traffic off the
+// legacy collection — force it off so the v1 path stays under test.
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({ memory: { v2: { enabled: false } } }),
+}));
 
 mock.module("../../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),

package/src/memory/pkb/pkb-search.ts

@@ -4,7 +4,6 @@
 
 import { getConfig } from "../../config/loader.js";
 import { getLogger } from "../../util/logger.js";
-import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import {
   isQdrantBreakerOpen,
   withQdrantBreaker,
@@ -42,10 +41,10 @@ export async function searchPkbFiles(
   limit: number,
   scopeIds?: string[],
 ): Promise<PkbSearchResult[]> {
-  // v2 owns the read path when both gates are on; v2 absorbs PKB as a read
-  // source, so PKB hint search short-circuits to keep traffic off the v1
-  // collection (avoiding OOM-crash risk from a corrupted sparse segment).
-  if (isMemoryV2ReadActive(getConfig())) return [];
+  // v2 owns the read path when enabled; v2 absorbs PKB as a read source,
+  // so PKB hint search short-circuits to keep traffic off the v1 collection
+  // (avoiding OOM-crash risk from a corrupted sparse segment).
+  if (getConfig().memory.v2.enabled) return [];
 
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping PKB search");

package/src/memory/published-pages-store.ts

@@ -36,6 +36,21 @@ export function getActivePublishedPageByAppId(
   return row ?? null;
 }
 
+export function insertPublishedPage(record: {
+  id: string;
+  deploymentId: string;
+  publicUrl: string;
+  pageTitle: string | null;
+  htmlHash: string;
+  publishedAt: number;
+  status: string;
+  appId: string | null;
+  projectSlug: string | null;
+}): void {
+  const db = getDb();
+  db.insert(publishedPages).values(record).run();
+}
+
 export function updatePublishedPage(
   id: string,
   updates: {
@@ -44,6 +59,7 @@ export function updatePublishedPage(
     htmlHash?: string;
     publishedAt?: number;
     appId?: string;
+    status?: string;
   },
 ): void {
   const db = getDb();

package/src/memory/qdrant-client.ts

@@ -248,6 +248,9 @@ export class VellumQdrantClient {
           m: 16,
           ef_construct: 100,
         },
+        optimizers_config: {
+          default_segment_number: 2,
+        },
         quantization_config:
           this.quantization === "scalar"
             ? {

package/src/memory/schema/bookmarks.ts

@@ -0,0 +1,38 @@
+import {
+  index,
+  integer,
+  sqliteTable,
+  text,
+  uniqueIndex,
+} from "drizzle-orm/sqlite-core";
+
+import { conversations, messages } from "./conversations.js";
+
+/**
+ * User-saved bookmarks for individual messages. Surfaced in the macOS app
+ * Settings → Bookmarks tab and on the message hover overflow menu, behind the
+ * `bookmarks` client feature flag.
+ *
+ * Both foreign keys CASCADE so bookmarks disappear automatically when their
+ * parent message or conversation is deleted. A unique index on `message_id`
+ * keeps the create-bookmark path idempotent.
+ */
+export const messageBookmarks = sqliteTable(
+  "message_bookmarks",
+  {
+    id: text("id").primaryKey(),
+    messageId: text("message_id")
+      .notNull()
+      .references(() => messages.id, { onDelete: "cascade" }),
+    conversationId: text("conversation_id")
+      .notNull()
+      .references(() => conversations.id, { onDelete: "cascade" }),
+    createdAt: integer("created_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("message_bookmarks_message_id_uniq").on(table.messageId),
+    index("message_bookmarks_created_at_idx").on(table.createdAt),
+  ],
+);
+
+export type MessageBookmarkRow = typeof messageBookmarks.$inferSelect;