@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/persistence/migrations/324-message-finalized-column.ts

@@ -0,0 +1,26 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+/**
+ * Add the `finalized` column to `messages`.
+ *
+ * `finalized = 1` (the default, and the backfill value for every existing
+ * row) means the row's `content` is the complete, immutable value — either
+ * an inline `ContentBlock[]` or a `{ ref }` pointing at an externalized
+ * content file. `finalized = 0` means the message is still streaming: its
+ * content lives in an in-flight delta file under the conversation
+ * directory and the row's `content` holds the `{ ref }` to it. Batch
+ * readers (search, memory indexing, fork) filter on `finalized = 1`; only
+ * the live turn and crash recovery read unfinalized content.
+ *
+ * Uses ALTER TABLE ADD COLUMN with try/catch for idempotency — no registry
+ * entry needed.
+ */
+export function migrateMessageFinalizedColumn(database: DrizzleDb): void {
+  try {
+    database.run(
+      /*sql*/ `ALTER TABLE messages ADD COLUMN finalized INTEGER NOT NULL DEFAULT 1`,
+    );
+  } catch {
+    /* already exists */
+  }
+}

package/src/persistence/migrations/325-create-config-setting-events.ts

@@ -0,0 +1,40 @@
+import { Database } from "bun:sqlite";
+
+import { getTelemetryDbPath } from "../../util/telemetry-db-path.js";
+import { type DrizzleDb, getTelemetrySqlite } from "../db-connection.js";
+
+/**
+ * Create the `config_setting_events` table on the dedicated telemetry database
+ * (`assistant-telemetry.db`), not the main DB. The migration runner passes the
+ * main DrizzleDb, but this table lives on the telemetry connection, so we open
+ * that connection and run DDL against it directly.
+ *
+ * Idempotent (`IF NOT EXISTS`). Writes are gated on `share_analytics`
+ * consent at the store level, so opted-out rows never exist and the
+ * reporter's standard 0 watermark default is safe. The index backs the
+ * telemetry reporter's compound `(created_at, id)` watermark cursor.
+ *
+ * The `mainDb` parameter is accepted to satisfy the migration-step signature but
+ * is not used — this migration operates exclusively on the telemetry DB.
+ */
+export function createConfigSettingEventsTable(_mainDb: DrizzleDb): void {
+  let raw: Database | null = getTelemetrySqlite();
+  if (!raw) {
+    // The dedicated connection failed to open (logged by openDedicatedDb).
+    // Fall back to opening the file directly so the migration still runs —
+    // the singleton will pick it up on a later access. This mirrors the
+    // fail-soft pattern of the other dedicated-DB migrations.
+    raw = new Database(getTelemetryDbPath());
+  }
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS config_setting_events (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL,
+      config_key TEXT NOT NULL,
+      config_value TEXT NOT NULL
+    )
+  `);
+  raw.exec(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_config_setting_events_created_at_id ON config_setting_events (created_at, id)`,
+  );
+}

package/src/persistence/migrations/326-move-injection-events-to-memory-db.ts

@@ -0,0 +1,104 @@
+import type { Database } from "bun:sqlite";
+
+import { getMemoryDbPath } from "../../util/memory-db-path.js";
+import {
+  type DrizzleDb,
+  getMemorySqlite,
+  getSqliteFrom,
+} from "../db-connection.js";
+import {
+  drainStagedTable,
+  type RelocationSpec,
+  stageTableForRelocation,
+} from "./helpers/relocation.js";
+
+/**
+ * Readers of `memory_v2_injection_events` bound their scans to the last
+ * 6 half-lives (6 × 3 days) — events past that window contribute <1.6% each
+ * to the decayed score and are never queried. Mirrors `READ_WINDOW_MS` in
+ * `plugins/defaults/memory/v2/injection-events.ts` (duplicated by design:
+ * persistence migrations do not import plugin code).
+ */
+const READ_WINDOW_MS = 6 * 3 * 24 * 60 * 60 * 1000;
+
+/**
+ * How to drain `memory_v2_injection_events` from `main` into the memory DB.
+ * Rows older than the score read window are purged without copying — no
+ * reader ever looks at them, so carrying them over would only re-seed dead
+ * weight in the new file.
+ */
+export const INJECTION_EVENTS_RELOCATION: RelocationSpec = {
+  table: "memory_v2_injection_events",
+  targetDbPath: getMemoryDbPath,
+  columns: ["id", "slug", "injected_at"],
+  copyWhere: `injected_at >= strftime('%s','now') * 1000 - ${READ_WINDOW_MS}`,
+};
+
+const CREATE_TABLE = /*sql*/ `
+  CREATE TABLE IF NOT EXISTS memory_v2_injection_events (
+    id INTEGER PRIMARY KEY,
+    slug TEXT NOT NULL,
+    injected_at INTEGER NOT NULL
+  )
+`;
+
+/**
+ * Create the `memory_v2_injection_events` table and its indexes on the memory
+ * connection. Idempotent (`IF NOT EXISTS`) — the dedicated connection itself
+ * performs no DDL on open, so this migration owns the schema. Exported so
+ * tests can stand up the memory-side schema without running the full drain.
+ */
+export function ensureInjectionEventsSchema(memoryRaw: Database): void {
+  memoryRaw.exec(CREATE_TABLE);
+  memoryRaw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_v2_injection_events_slug_time
+      ON memory_v2_injection_events (slug, injected_at)
+  `);
+  memoryRaw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_v2_injection_events_time
+      ON memory_v2_injection_events (injected_at)
+  `);
+}
+
+/**
+ * Move `memory_v2_injection_events` — the append-only EMA event log behind
+ * memory router tier-2 scoring — into the dedicated memory database
+ * (`assistant-memory.db`), alongside `memory_jobs` (migration 298). The log
+ * grows with every router selection; housing it with the other high-churn
+ * memory state keeps the main DB and its WAL out of that write path, and the
+ * accessors in `plugins/defaults/memory/v2/injection-events.ts` read/write it
+ * over the dedicated memory connection (see `getMemoryDb()`).
+ *
+ * Like migrations 297/298 the move is incremental: create the table (and
+ * indexes) on the memory connection, rename any populated
+ * `main.memory_v2_injection_events` aside to
+ * `memory_v2_injection_events__relocating`, then drain it in awaited batches
+ * (see `helpers/relocation.ts`) per {@link INJECTION_EVENTS_RELOCATION}. On a
+ * fresh install the main-side table created by migration 256 is empty, so
+ * staging just drops it.
+ *
+ * Throws (rather than returning) if the memory database cannot be opened, so
+ * the runner records the step as failed instead of applied and retries it on
+ * a later boot — never renaming the source aside without a target to write
+ * to. The throw is caught per-step by the runner, so startup is not aborted.
+ */
+export async function migrateMoveInjectionEventsToMemoryDb(
+  database: DrizzleDb,
+): Promise<void> {
+  const memoryRaw = getMemorySqlite();
+  if (!memoryRaw) {
+    throw new Error(
+      "memory database unavailable — deferring memory_v2_injection_events relocation",
+    );
+  }
+
+  ensureInjectionEventsSchema(memoryRaw);
+
+  const raw = getSqliteFrom(database);
+  const needsDrain = stageTableForRelocation(
+    raw,
+    INJECTION_EVENTS_RELOCATION.table,
+  );
+
+  if (needsDrain) await drainStagedTable(raw, INJECTION_EVENTS_RELOCATION);
+}

package/src/persistence/migrations/327-create-flush-checkpoints.ts

@@ -0,0 +1,86 @@
+import { Database } from "bun:sqlite";
+
+import { getTelemetryDbPath } from "../../util/telemetry-db-path.js";
+import {
+  type DrizzleDb,
+  getSqliteFrom,
+  getTelemetrySqlite,
+} from "../db-connection.js";
+
+/**
+ * The telemetry flush watermark keys that historically lived in the main
+ * DB's `memory_checkpoints` ledger. Frozen: this is the complete set at the
+ * time `flush_checkpoints` was introduced — event types added later start
+ * their cursors directly in the new table, so this list must never grow.
+ *
+ * Enumerated exactly (rather than pattern-matched) because other
+ * `telemetry:`-prefixed checkpoints exist in `memory_checkpoints` that are
+ * NOT flush watermarks (e.g. `telemetry:installation_id`,
+ * `telemetry:watchers:inventory_last_recorded`) and must stay where they
+ * are.
+ */
+const LEGACY_WATERMARK_KEYS = [
+  "usage",
+  "turns",
+  "lifecycle",
+  "onboarding",
+  "auth_fallback",
+  "tool_executed",
+  "skill_loaded",
+  "watchdog",
+  "config_setting",
+].flatMap((type) => [
+  `telemetry:${type}:last_reported_at`,
+  `telemetry:${type}:last_reported_id`,
+]);
+
+/**
+ * Create the `flush_checkpoints` table on the dedicated telemetry database
+ * (`assistant-telemetry.db`) and move the telemetry reporter's watermark
+ * cursors into it from the main DB's `memory_checkpoints`, which is reserved
+ * for DB-migration checkpoints.
+ *
+ * Idempotent and crash-safe without a cross-DB transaction: the copy uses
+ * `INSERT OR IGNORE` (a re-run never overwrites a value the reporter has
+ * since advanced) and the main-DB delete runs last, so a crash between copy
+ * and delete re-runs both harmlessly.
+ */
+export function createFlushCheckpointsTable(mainDb: DrizzleDb): void {
+  let telemetry: Database | null = getTelemetrySqlite();
+  if (!telemetry) {
+    // The dedicated connection failed to open (logged by openDedicatedDb).
+    // Fall back to opening the file directly so the migration still runs —
+    // the singleton will pick it up on a later access. This mirrors the
+    // fail-soft pattern of the other dedicated-DB migrations.
+    telemetry = new Database(getTelemetryDbPath());
+  }
+  telemetry.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS flush_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  const main = getSqliteFrom(mainDb);
+  const placeholders = LEGACY_WATERMARK_KEYS.map(() => "?").join(", ");
+  const rows = main
+    .query(
+      /*sql*/ `SELECT key, value FROM memory_checkpoints WHERE key IN (${placeholders})`,
+    )
+    .all(...LEGACY_WATERMARK_KEYS) as Array<{ key: string; value: string }>;
+
+  const now = Date.now();
+  const insert = telemetry.prepare(
+    /*sql*/ `INSERT OR IGNORE INTO flush_checkpoints (key, value, updated_at) VALUES (?, ?, ?)`,
+  );
+  for (const row of rows) {
+    insert.run(row.key, row.value, now);
+  }
+
+  main
+    .query(
+      /*sql*/ `DELETE FROM memory_checkpoints WHERE key IN (${placeholders})`,
+    )
+    .run(...LEGACY_WATERMARK_KEYS);
+}

package/src/persistence/migrations/__tests__/297-move-llm-request-logs.test.ts

@@ -63,7 +63,7 @@ describe("migration 297 — llm_request_logs lives in the logs database", () =>
       "anthropic",
       "mainAgent",
     );
-    const row = getRequestLogById(id);
+    const row = getRequestLogById(id!);
     expect(row?.conversationId).toBe("conv-297");
     expect(row?.messageId).toBe("msg-297");
     expect(row?.provider).toBe("anthropic");
@@ -75,7 +75,7 @@ describe("migration 297 — llm_request_logs lives in the logs database", () =>
         { c: number },
         [string]
       >(`SELECT COUNT(*) AS c FROM llm_request_logs WHERE id = ?`)
-      .get(id);
+      .get(id!);
     expect(inLogs?.c).toBe(1);
   });
 

package/src/persistence/migrations/__tests__/327-create-flush-checkpoints.test.ts

@@ -0,0 +1,124 @@
+/**
+ * Tests for migration 327 — the `flush_checkpoints` table on the dedicated
+ * telemetry database, and the one-time move of the telemetry reporter's
+ * watermark cursors out of the main DB's `memory_checkpoints` ledger.
+ *
+ * The step is idempotent, so each test can drive it directly.
+ */
+import { beforeEach, describe, expect, test } from "bun:test";
+
+const { getDb, getSqlite, getTelemetrySqlite } =
+  await import("../../db-connection.js");
+const { initializeDb } = await import("../../db-init.js");
+const { createFlushCheckpointsTable } =
+  await import("../327-create-flush-checkpoints.js");
+
+await initializeDb();
+
+function telemetrySqlite() {
+  const db = getTelemetrySqlite();
+  if (!db) {
+    throw new Error("telemetry DB unavailable in test");
+  }
+  return db;
+}
+
+function readTelemetryValue(key: string): string | null {
+  const row = telemetrySqlite()
+    .query(`SELECT value FROM flush_checkpoints WHERE key = ?`)
+    .get(key) as { value: string } | null;
+  return row?.value ?? null;
+}
+
+function readMainValue(key: string): string | null {
+  const row = getSqlite()
+    .query(`SELECT value FROM memory_checkpoints WHERE key = ?`)
+    .get(key) as { value: string } | null;
+  return row?.value ?? null;
+}
+
+function seedMainCheckpoint(key: string, value: string): void {
+  getSqlite()
+    .query(
+      `INSERT OR REPLACE INTO memory_checkpoints (key, value, updated_at) VALUES (?, ?, ?)`,
+    )
+    .run(key, value, Date.now());
+}
+
+describe("migration 327 — flush_checkpoints on the telemetry database", () => {
+  beforeEach(() => {
+    telemetrySqlite().query(`DELETE FROM flush_checkpoints`).run();
+    getSqlite()
+      .query(`DELETE FROM memory_checkpoints WHERE key LIKE 'telemetry:%'`)
+      .run();
+  });
+
+  test("after init, the table exists on the telemetry DB", () => {
+    const row = telemetrySqlite()
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name='flush_checkpoints'`,
+      )
+      .get();
+    expect(row).not.toBeNull();
+  });
+
+  test("moves legacy watermark keys from memory_checkpoints", () => {
+    seedMainCheckpoint("telemetry:usage:last_reported_at", "1700000000000");
+    seedMainCheckpoint("telemetry:usage:last_reported_id", "row-abc");
+
+    createFlushCheckpointsTable(getDb());
+
+    expect(readTelemetryValue("telemetry:usage:last_reported_at")).toBe(
+      "1700000000000",
+    );
+    expect(readTelemetryValue("telemetry:usage:last_reported_id")).toBe(
+      "row-abc",
+    );
+    expect(readMainValue("telemetry:usage:last_reported_at")).toBeNull();
+    expect(readMainValue("telemetry:usage:last_reported_id")).toBeNull();
+  });
+
+  test("leaves non-watermark telemetry-prefixed checkpoints in place", () => {
+    seedMainCheckpoint("telemetry:installation_id", "inst-123");
+    seedMainCheckpoint(
+      "telemetry:watchers:inventory_last_recorded",
+      "1700000000000",
+    );
+
+    createFlushCheckpointsTable(getDb());
+
+    expect(readMainValue("telemetry:installation_id")).toBe("inst-123");
+    expect(readMainValue("telemetry:watchers:inventory_last_recorded")).toBe(
+      "1700000000000",
+    );
+    expect(readTelemetryValue("telemetry:installation_id")).toBeNull();
+  });
+
+  test("re-run never overwrites a value the reporter has since advanced", () => {
+    seedMainCheckpoint("telemetry:turns:last_reported_at", "1000");
+    createFlushCheckpointsTable(getDb());
+    expect(readTelemetryValue("telemetry:turns:last_reported_at")).toBe("1000");
+
+    // The reporter advances the moved cursor, then a crash re-runs the
+    // migration with a stale main-DB copy still present (crash between copy
+    // and delete on the first run). INSERT OR IGNORE must keep the advanced
+    // value.
+    telemetrySqlite()
+      .query(`UPDATE flush_checkpoints SET value = '2000' WHERE key = ?`)
+      .run("telemetry:turns:last_reported_at");
+    seedMainCheckpoint("telemetry:turns:last_reported_at", "1000");
+
+    createFlushCheckpointsTable(getDb());
+
+    expect(readTelemetryValue("telemetry:turns:last_reported_at")).toBe("2000");
+    expect(readMainValue("telemetry:turns:last_reported_at")).toBeNull();
+  });
+
+  test("no-op when there are no legacy keys", () => {
+    createFlushCheckpointsTable(getDb());
+    const count = telemetrySqlite()
+      .query(`SELECT COUNT(*) as c FROM flush_checkpoints`)
+      .get() as { c: number };
+    expect(count.c).toBe(0);
+  });
+});

package/src/persistence/schema/conversations.ts

@@ -32,7 +32,6 @@ export const conversations = sqliteTable(
     ),
     conversationType: text("conversation_type").notNull().default("standard"),
     source: text("source").notNull().default("user"),
-    memoryScopeId: text("memory_scope_id").notNull().default("default"),
     originChannel: text("origin_channel"),
     originInterface: text("origin_interface"),
     forkParentConversationId: text("fork_parent_conversation_id"),
@@ -63,6 +62,16 @@ export const conversations = sqliteTable(
      * callers read this column directly.
      */
     processingStartedAt: integer("processing_started_at"),
+    /**
+     * Count of consecutive startup auto-resume attempts for this
+     * conversation's interrupted turn. Incremented by the startup reconciler
+     * when it wakes a conversation whose `processing_started_at` survived the
+     * previous process; reset to 0 whenever a turn ends cleanly. Caps
+     * resume-loops for turns that repeatedly take the process down.
+     */
+    processingResumeAttempts: integer("processing_resume_attempts")
+      .notNull()
+      .default(0),
     /**
      * Highest stream `seq` whose content is durably persisted to this
      * conversation's message rows. Seeded with the global high-water seq when
@@ -95,10 +104,25 @@ export const messages = sqliteTable(
       .notNull()
       .references(() => conversations.id, { onDelete: "cascade" }),
     role: text("role").notNull(),
+    /**
+     * Union of two JSON shapes: an inline `ContentBlock[]` (or a legacy
+     * plain string), or `{ ref: "<workspace-relative path>" }` pointing at
+     * a file-backed content payload. Resolve to typed blocks with
+     * `resolveMessageContentBlocks` (message-content-file.ts) — never
+     * interpret this column's shape by hand.
+     */
     content: text("content").notNull(),
     createdAt: integer("created_at").notNull(),
     metadata: text("metadata"),
     clientMessageId: text("client_message_id"),
+    /**
+     * 1 (default) = `content` is the complete, immutable value (inline or
+     * `{ ref }`). 0 = the message is still streaming and `content` is a
+     * `{ ref }` to its in-flight delta file. Batch readers (search, memory
+     * indexing, fork) must filter `finalized = 1`; only the live turn and
+     * crash recovery read unfinalized rows.
+     */
+    finalized: integer("finalized").notNull().default(1),
   },
   (table) => [
     uniqueIndex("idx_messages_conv_client_msg_id")

package/src/persistence/schema/guardian.ts

@@ -96,6 +96,11 @@ export const canonicalGuardianRequests = sqliteTable(
     // captured at creation so decision-time policy reads the same identity
     // facts the introduction card was rendered from.
     requesterSignals: text("requester_signals"),
+    // What prompted an access request: 'denied' (refused sender awaiting a
+    // let-them-in decision) or 'admitted' (floor-admitted sender nudged for
+    // trust assignment). NULL means 'denied'. Resolvers and the expiry sweep
+    // suppress requester-facing lifecycle notices for 'admitted'.
+    trigger: text("request_trigger"),
     status: text("status").notNull().default("pending"),
     answerText: text("answer_text"),
     decidedByExternalUserId: text("decided_by_external_user_id"),

package/src/persistence/schema/infrastructure.ts

@@ -365,3 +365,36 @@ export const watchdogEvents = sqliteTable(
     index("idx_watchdog_events_created_at_id").on(table.createdAt, table.id),
   ],
 );
+
+// Key/value store for telemetry flush state — the per-event-type
+// `(last_reported_at, last_reported_id)` watermark cursors advanced by the
+// usage telemetry reporter after each successful upload. Lives on the
+// dedicated telemetry database (assistant-telemetry.db) so flush state
+// stays with the telemetry pipeline; the main DB's `memory_checkpoints`
+// ledger is reserved for DB-migration checkpoints.
+export const flushCheckpoints = sqliteTable("flush_checkpoints", {
+  key: text("key").primaryKey(),
+  value: text("value").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+// One row per `config_setting` telemetry event — a tracked config key's
+// effective value; see config-setting-events-store.ts for the data
+// contract. Lives on the dedicated telemetry database
+// (assistant-telemetry.db) alongside watchdog_events. Flushed by the usage
+// telemetry reporter.
+export const configSettingEvents = sqliteTable(
+  "config_setting_events",
+  {
+    id: text("id").primaryKey(),
+    createdAt: integer("created_at").notNull(),
+    configKey: text("config_key").notNull(),
+    configValue: text("config_value").notNull(),
+  },
+  (table) => [
+    index("idx_config_setting_events_created_at_id").on(
+      table.createdAt,
+      table.id,
+    ),
+  ],
+);

package/src/persistence/schema/memory-core.ts

@@ -9,27 +9,22 @@ import {
 
 import { conversations, messages } from "./conversations.js";
 
-export const memorySegments = sqliteTable(
-  "memory_segments",
-  {
-    id: text("id").primaryKey(),
-    messageId: text("message_id")
-      .notNull()
-      .references(() => messages.id, { onDelete: "cascade" }),
-    conversationId: text("conversation_id")
-      .notNull()
-      .references(() => conversations.id, { onDelete: "cascade" }),
-    role: text("role").notNull(),
-    segmentIndex: integer("segment_index").notNull(),
-    text: text("text").notNull(),
-    tokenEstimate: integer("token_estimate").notNull(),
-    scopeId: text("scope_id").notNull().default("default"),
-    contentHash: text("content_hash"),
-    createdAt: integer("created_at").notNull(),
-    updatedAt: integer("updated_at").notNull(),
-  },
-  (table) => [index("idx_memory_segments_scope_id").on(table.scopeId)],
-);
+export const memorySegments = sqliteTable("memory_segments", {
+  id: text("id").primaryKey(),
+  messageId: text("message_id")
+    .notNull()
+    .references(() => messages.id, { onDelete: "cascade" }),
+  conversationId: text("conversation_id")
+    .notNull()
+    .references(() => conversations.id, { onDelete: "cascade" }),
+  role: text("role").notNull(),
+  segmentIndex: integer("segment_index").notNull(),
+  text: text("text").notNull(),
+  tokenEstimate: integer("token_estimate").notNull(),
+  contentHash: text("content_hash"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
 
 export const memorySummaries = sqliteTable(
   "memory_summaries",
@@ -40,14 +35,12 @@ export const memorySummaries = sqliteTable(
     summary: text("summary").notNull(),
     tokenEstimate: integer("token_estimate").notNull(),
     version: integer("version").notNull().default(1),
-    scopeId: text("scope_id").notNull().default("default"),
     startAt: integer("start_at").notNull(),
     endAt: integer("end_at").notNull(),
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
   },
   (table) => [
-    index("idx_memory_summaries_scope_id").on(table.scopeId),
     uniqueIndex("idx_memory_summaries_scope_scope_key").on(
       table.scope,
       table.scopeKey,
@@ -120,7 +113,6 @@ export const conversationStarters = sqliteTable(
     label: text("label").notNull(),
     prompt: text("prompt").notNull(),
     generationBatch: integer("generation_batch").notNull(),
-    scopeId: text("scope_id").notNull().default("default"),
     sourceMemoryKinds: text("source_memory_kinds"),
     category: text("category"),
     icon: text("icon"),
@@ -134,9 +126,6 @@ export const conversationStarters = sqliteTable(
       table.generationBatch,
       table.createdAt,
     ),
-    index("idx_conversation_starters_card_type").on(
-      table.cardType,
-      table.scopeId,
-    ),
+    index("idx_conversation_starters_card_type").on(table.cardType),
   ],
 );

package/src/persistence/schema/memory-graph.ts

@@ -59,14 +59,10 @@ export const memoryGraphNodes = sqliteTable(
     narrativeRole: text("narrative_role"),
     partOfStory: text("part_of_story"),
 
-    /** Memory scope for multi-scope isolation. */
-    scopeId: text("scope_id").notNull().default("default"),
-
     /** JSON array of ImageRef objects — images attached to this memory. */
     imageRefs: text("image_refs"),
   },
   (table) => [
-    index("idx_graph_nodes_scope_id").on(table.scopeId),
     index("idx_graph_nodes_type").on(table.type),
     index("idx_graph_nodes_fidelity").on(table.fidelity),
     index("idx_graph_nodes_created").on(table.created),

package/src/persistence/schema/memory-injection.ts

@@ -7,7 +7,9 @@ import {
 } from "drizzle-orm/sqlite-core";
 
 // Time-series of memory-v2 card injections, used by the router to decay a
-// concept's recent injection pressure.
+// concept's recent injection pressure. Lives in the dedicated memory database
+// (`assistant-memory.db`), not main — access it via the memory connection
+// (`getMemoryDb()` / `getMemorySqlite()`).
 export const memoryV2InjectionEvents = sqliteTable(
   "memory_v2_injection_events",
   {

package/src/persistence/schema/tasks.ts

@@ -26,7 +26,6 @@ export const taskRuns = sqliteTable("task_runs", {
   finishedAt: integer("finished_at"),
   error: text("error"),
   principalId: text("principal_id"),
-  memoryScopeId: text("memory_scope_id"),
   createdAt: integer("created_at").notNull(),
 });