refactor: break storage-db<->migrations cycle + remove genuine dead code

Findings from the aft_inspect/fallow dogfooding pass that apply to our own code:

- Circular dependency (fallow-detected, verified at source): storage-db.ts imported
  runMigrations from migrations.ts while migrations.ts imported ensureColumn/
  healAllNullColumns back from storage-db.ts. Function-level so it ran, but it
  blocks tree-shaking and risks init-order bugs. Extracted the two schema helpers
  (+ their private heal functions) into a leaf module storage-schema-helpers.ts that
  depends only on the SQLite handle; both storage-db and migrations now import from
  the leaf. storage-db re-exports them so existing importers/tests are unaffected.
  fallow now reports zero circular dependencies.

- Dead code: deleted hooks/is-anthropic-provider.ts (isAnthropicProvider, zero refs
  anywhere) and removed isLocalEmbeddingRuntimeMissing from embedding-local.ts (zero
  refs; its 'used by callers/tests' docstring was stale).

- Dashboard test lint: dropped an unused  binding in db_mutations.rs (the only
  rustc warning aft_inspect surfaced).

Gate: plugin 2602/0, plugin tsc + biome clean, dashboard rust build clean.

Co-authored-by: Alfonso [Magic Context] <288211368+alfonso-magic-context@users.noreply.github.com>

Author: ualtinok

packages/dashboard/src-tauri/tests/db_mutations.rs

@@ -751,7 +751,7 @@ fn test_update_memory_category_collision() {
         [],
     )
     .unwrap();
-    let id2 = conn.last_insert_rowid();
+    // Memory 2 exists with category NAMING; we don't need its id below.
 
     // Try to update Memory 1's category to NAMING. This should collide with Memory 2.
     let res = db::update_memory_category(&mut conn, id1, "NAMING");

packages/plugin/src/features/magic-context/memory/embedding-local.ts

@@ -273,12 +273,6 @@ async function withQuietConsole<T>(fn: () => Promise<T>): Promise<T> {
 // because the missing package affects the whole install, not one model.
 let nativeRuntimeMissing = false;
 
-/** Whether local embeddings have been disabled this process due to a missing
- * native runtime (issue #128). Used by callers/tests to detect the degraded state. */
-export function isLocalEmbeddingRuntimeMissing(): boolean {
-    return nativeRuntimeMissing;
-}
-
 export function isNativeRuntimeMissingError(error: unknown): boolean {
     const message = error instanceof Error ? error.message : String(error ?? "");
     const lower = message.toLowerCase();

packages/plugin/src/features/magic-context/migrations.ts

@@ -1,6 +1,6 @@
 import { log } from "../../shared/logger";
 import type { Database } from "../../shared/sqlite";
-import { ensureColumn, healAllNullColumns } from "./storage-db";
+import { ensureColumn, healAllNullColumns } from "./storage-schema-helpers";
 import { bumpEpochsForWorkspaceMemberSet } from "./workspaces";
 
 /**

packages/plugin/src/features/magic-context/storage-db.ts

@@ -11,12 +11,18 @@ import { Database } from "../../shared/sqlite";
 import { closeQuietly } from "../../shared/sqlite-helpers";
 
 import { runMigrations } from "./migrations";
+import { ensureColumn, healAllNullColumns } from "./storage-schema-helpers";
 import {
     loadToolDefinitionMeasurements,
     setDatabase as setToolDefinitionDatabase,
 } from "./tool-definition-tokens";
 import { runToolOwnerBackfill } from "./tool-owner-backfill";
 
+// Re-exported so existing `from "./storage-db"` importers (and tests) keep
+// resolving these; the definitions live in the leaf module to break the
+// storage-db <-> migrations import cycle.
+export { ensureColumn, healAllNullColumns };
+
 const databases = new Map<string, Database>();
 const persistenceByDatabase = new WeakMap<Database, boolean>();
 const persistenceErrorByDatabase = new WeakMap<Database, string>();
@@ -1427,31 +1433,6 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
     // cannot go here because the table doesn't exist yet on a fresh DB.
 }
 
-/**
- * Heal NULL columns added via ensureColumn against pre-existing rows.
- *
- * SQLite does NOT backfill column defaults when ALTER TABLE ADD COLUMN runs
- * on an already-populated table — old rows get NULL regardless of the
- * DEFAULT clause. isSessionMetaRow used to require strict typeof === "string"
- * / "number", which NULL fails, so rows with NULL columns were rejected,
- * getOrCreateSessionMeta returned zeroed defaults (lastResponseTime=0,
- * cacheTtl="5m"), the scheduler returned "execute" forever, and every
- * execute pass mutated message content — a sustained cache-bust cascade.
- *
- * The validator now tolerates NULL, but we normalize the data too so every
- * code path sees well-formed values. Each UPDATE is best-effort: if a column
- * doesn't exist yet (migration ran on a DB older than the ensureColumn call),
- * the UPDATE throws and we move on — the next schema upgrade runs ensureColumn
- * first, then this heal again.
- *
- * Exported so migration v5 can call it. Not exported from any barrel.
- */
-export function healAllNullColumns(db: Database): void {
-    healNullTextColumns(db);
-    healNullIntegerColumns(db);
-    healMissingMemoryBlockIds(db);
-}
-
 const CHANNEL2_CLAIM_TTL_MS = 120_000;
 
 /**
@@ -1476,145 +1457,6 @@ function healWedgedChannel2Claims(db: Database): void {
     }
 }
 
-/**
- * One-shot heal for sessions upgraded from a build without memory_block_ids.
- *
- * Those sessions have a populated memory_block_cache but no ids — ctx_search's
- * visible-memory filter then silently no-ops. Clearing the cache forces the
- * next transform pass to regenerate BOTH cache + ids in one UPDATE. The
- * regenerated block is byte-identical (renderMemoryBlock is deterministic
- * over the same memory set in stable id order), so this does NOT cause an
- * Anthropic prompt-cache bust.
- *
- * Best-effort — wrapped because the columns may not exist on a brand-new DB
- * that hasn't finished ensureColumn yet.
- */
-function healMissingMemoryBlockIds(db: Database): void {
-    try {
-        db.prepare(
-            "UPDATE session_meta SET memory_block_cache = '' WHERE memory_block_cache != '' AND (memory_block_ids IS NULL OR memory_block_ids = '') AND memory_block_count > 0",
-        ).run();
-    } catch {
-        // Column missing on very fresh DBs — next startup reruns this after
-        // ensureColumn adds the column.
-    }
-}
-
-function healNullTextColumns(db: Database): void {
-    const columns: Array<[string, string]> = [
-        ["cache_ttl", ""],
-        ["last_nudge_band", ""],
-        ["last_nudge_level", ""],
-        ["last_transform_error", ""],
-        ["nudge_anchor_message_id", ""],
-        ["nudge_anchor_text", ""],
-        ["sticky_turn_reminder_text", ""],
-        ["sticky_turn_reminder_message_id", ""],
-        ["note_nudge_trigger_message_id", ""],
-        ["note_nudge_sticky_text", ""],
-        ["note_nudge_sticky_message_id", ""],
-        ["last_todo_state", ""],
-        ["todo_synthetic_call_id", ""],
-        ["todo_synthetic_anchor_message_id", ""],
-        ["todo_synthetic_state_json", ""],
-        ["system_prompt_hash", ""],
-        ["stripped_placeholder_ids", ""],
-        ["stale_reduce_stripped_ids", ""],
-        ["processed_image_stripped_ids", ""],
-        ["memory_block_cache", ""],
-        ["memory_block_ids", ""],
-        ["compaction_marker_state", ""],
-        ["key_files", ""],
-    ];
-    for (const [column, fallback] of columns) {
-        try {
-            db.prepare(`UPDATE session_meta SET ${column} = ? WHERE ${column} IS NULL`).run(
-                fallback,
-            );
-        } catch (_error) {
-            // Ignore — the column may not exist yet on a brand-new DB that
-            // hasn't gone through all ensureColumn calls yet. The heal runs
-            // again on next startup.
-        }
-    }
-}
-
-function healNullIntegerColumns(db: Database): void {
-    // INTEGER columns added via ensureColumn against pre-existing rows.
-    // SQLite does not backfill the DEFAULT on ALTER TABLE, so old rows have
-    // NULL. The validator tolerates null as of this release, but we still
-    // normalize to 0 so subsequent reads from any path (including paths
-    // that bypass toSessionMeta) see a well-formed row.
-    const columns: Array<[string, number]> = [
-        ["times_execute_threshold_reached", 0],
-        ["compartment_in_progress", 0],
-        ["historian_failure_count", 0],
-        ["cleared_reasoning_through_tag", 0],
-        ["memory_block_count", 0],
-        ["system_prompt_tokens", 0],
-        ["conversation_tokens", 0],
-        ["tool_call_tokens", 0],
-        ["note_nudge_trigger_pending", 0],
-        ["observed_safe_input_tokens", 0],
-        ["cache_alert_sent", 0],
-        ["new_work_tokens", 0],
-        ["total_input_tokens", 0],
-        ["last_emergency_input_sample", 0],
-        ["channel2_nudge_claimed_at", 0],
-        ["last_usage_context_limit", 0],
-        ["prior_boundary_ordinal", 1],
-        ["protected_tail_policy_version", 0],
-        ["protected_tail_drain_window_started_at", 0],
-        ["protected_tail_drain_tokens", 0],
-        ["recovery_no_eligible_head_count", 0],
-        ["force_emergency_bypass_window_start", 0],
-        ["force_emergency_bypass_used", 0],
-        ["emergency_drain_active", 0],
-        ["historian_drain_failure_at", 0],
-    ];
-    for (const [column, fallback] of columns) {
-        try {
-            db.prepare(`UPDATE session_meta SET ${column} = ? WHERE ${column} IS NULL`).run(
-                fallback,
-            );
-        } catch (_error) {
-            // Same rationale as the text heal — swallow missing-column errors
-            // on brand-new DBs; next startup reruns this.
-        }
-    }
-}
-
-// Intentional: the definition regex allows single quotes and parens because SQLite column
-// defaults use them (e.g. TEXT DEFAULT '', INTEGER DEFAULT 0). All callsites pass hardcoded
-// string literals — no user input reaches this function, so the regex is sufficient.
-export function ensureColumn(
-    db: Database,
-    table: string,
-    column: string,
-    definition: string,
-): void {
-    if (
-        !/^[a-z][a-z0-9_]*$/.test(table) ||
-        !/^[a-z][a-z0-9_]*$/.test(column) ||
-        !/^[A-Z0-9_"'(),[\]\s]+$/i.test(definition)
-    ) {
-        throw new Error(`Unsafe schema identifier: ${table}.${column} ${definition}`);
-    }
-    const rows = db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name?: string }>;
-    if (rows.some((row) => row.name === column)) {
-        return;
-    }
-    try {
-        db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
-    } catch (err) {
-        const recheck = db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name?: string }>;
-        if (recheck.some((row) => row.name === column)) {
-            return;
-        }
-        throw err;
-    }
-}
-
 /**
  * Open the persistent Magic Context SQLite database.
  *

packages/plugin/src/features/magic-context/storage-schema-helpers.ts

@@ -0,0 +1,160 @@
+import { Database } from "../../shared/sqlite";
+
+/**
+ * Schema-mutation helpers shared by storage-db (fresh-DB init) and migrations
+ * (versioned upgrades). They live in this leaf module — depending only on the
+ * SQLite handle — so storage-db and migrations don't import each other (storage-db
+ * imports `runMigrations` from migrations; without this split, migrations would
+ * import these back from storage-db and form an import cycle).
+ */
+
+// Intentional: the definition regex allows single quotes and parens because SQLite column
+// defaults use them (e.g. TEXT DEFAULT '', INTEGER DEFAULT 0). All callsites pass hardcoded
+// string literals — no user input reaches this function, so the regex is sufficient.
+export function ensureColumn(
+    db: Database,
+    table: string,
+    column: string,
+    definition: string,
+): void {
+    if (
+        !/^[a-z][a-z0-9_]*$/.test(table) ||
+        !/^[a-z][a-z0-9_]*$/.test(column) ||
+        !/^[A-Z0-9_"'(),[\]\s]+$/i.test(definition)
+    ) {
+        throw new Error(`Unsafe schema identifier: ${table}.${column} ${definition}`);
+    }
+    const rows = db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name?: string }>;
+    if (rows.some((row) => row.name === column)) {
+        return;
+    }
+    try {
+        db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+    } catch (err) {
+        const recheck = db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name?: string }>;
+        if (recheck.some((row) => row.name === column)) {
+            return;
+        }
+        throw err;
+    }
+}
+
+/**
+ * Heal NULL columns added via ensureColumn against pre-existing rows.
+ *
+ * SQLite does NOT backfill column defaults when ALTER TABLE ADD COLUMN runs
+ * on an already-populated table — old rows get NULL regardless of the
+ * DEFAULT clause. isSessionMetaRow used to require strict typeof === "string"
+ * / "number", which NULL fails, so rows with NULL columns were rejected,
+ * getOrCreateSessionMeta returned zeroed defaults (lastResponseTime=0,
+ * cacheTtl="5m"), the scheduler returned "execute" forever, and every
+ * execute pass mutated message content — a sustained cache-bust cascade.
+ *
+ * The validator now tolerates NULL, but we normalize the data too so every
+ * code path sees well-formed values. Each UPDATE is best-effort: if a column
+ * doesn't exist yet (migration ran on a DB older than the ensureColumn call),
+ * the UPDATE throws and we move on — the next schema upgrade runs ensureColumn
+ * first, then this heal again.
+ *
+ * Exported so migration v5 can call it. Not exported from any barrel.
+ */
+export function healAllNullColumns(db: Database): void {
+    healNullTextColumns(db);
+    healNullIntegerColumns(db);
+    healMissingMemoryBlockIds(db);
+}
+
+function healMissingMemoryBlockIds(db: Database): void {
+    try {
+        db.prepare(
+            "UPDATE session_meta SET memory_block_cache = '' WHERE memory_block_cache != '' AND (memory_block_ids IS NULL OR memory_block_ids = '') AND memory_block_count > 0",
+        ).run();
+    } catch {
+        // Column missing on very fresh DBs — next startup reruns this after
+        // ensureColumn adds the column.
+    }
+}
+
+function healNullTextColumns(db: Database): void {
+    const columns: Array<[string, string]> = [
+        ["cache_ttl", ""],
+        ["last_nudge_band", ""],
+        ["last_nudge_level", ""],
+        ["last_transform_error", ""],
+        ["nudge_anchor_message_id", ""],
+        ["nudge_anchor_text", ""],
+        ["sticky_turn_reminder_text", ""],
+        ["sticky_turn_reminder_message_id", ""],
+        ["note_nudge_trigger_message_id", ""],
+        ["note_nudge_sticky_text", ""],
+        ["note_nudge_sticky_message_id", ""],
+        ["last_todo_state", ""],
+        ["todo_synthetic_call_id", ""],
+        ["todo_synthetic_anchor_message_id", ""],
+        ["todo_synthetic_state_json", ""],
+        ["system_prompt_hash", ""],
+        ["stripped_placeholder_ids", ""],
+        ["stale_reduce_stripped_ids", ""],
+        ["processed_image_stripped_ids", ""],
+        ["memory_block_cache", ""],
+        ["memory_block_ids", ""],
+        ["compaction_marker_state", ""],
+        ["key_files", ""],
+    ];
+    for (const [column, fallback] of columns) {
+        try {
+            db.prepare(`UPDATE session_meta SET ${column} = ? WHERE ${column} IS NULL`).run(
+                fallback,
+            );
+        } catch (_error) {
+            // Ignore — the column may not exist yet on a brand-new DB that
+            // hasn't gone through all ensureColumn calls yet. The heal runs
+            // again on next startup.
+        }
+    }
+}
+
+function healNullIntegerColumns(db: Database): void {
+    // INTEGER columns added via ensureColumn against pre-existing rows.
+    // SQLite does not backfill the DEFAULT on ALTER TABLE, so old rows have
+    // NULL. The validator tolerates null as of this release, but we still
+    // normalize to 0 so subsequent reads from any path (including paths
+    // that bypass toSessionMeta) see a well-formed row.
+    const columns: Array<[string, number]> = [
+        ["times_execute_threshold_reached", 0],
+        ["compartment_in_progress", 0],
+        ["historian_failure_count", 0],
+        ["cleared_reasoning_through_tag", 0],
+        ["memory_block_count", 0],
+        ["system_prompt_tokens", 0],
+        ["conversation_tokens", 0],
+        ["tool_call_tokens", 0],
+        ["note_nudge_trigger_pending", 0],
+        ["observed_safe_input_tokens", 0],
+        ["cache_alert_sent", 0],
+        ["new_work_tokens", 0],
+        ["total_input_tokens", 0],
+        ["last_emergency_input_sample", 0],
+        ["channel2_nudge_claimed_at", 0],
+        ["last_usage_context_limit", 0],
+        ["prior_boundary_ordinal", 1],
+        ["protected_tail_policy_version", 0],
+        ["protected_tail_drain_window_started_at", 0],
+        ["protected_tail_drain_tokens", 0],
+        ["recovery_no_eligible_head_count", 0],
+        ["force_emergency_bypass_window_start", 0],
+        ["force_emergency_bypass_used", 0],
+        ["emergency_drain_active", 0],
+        ["historian_drain_failure_at", 0],
+    ];
+    for (const [column, fallback] of columns) {
+        try {
+            db.prepare(`UPDATE session_meta SET ${column} = ? WHERE ${column} IS NULL`).run(
+                fallback,
+            );
+        } catch (_error) {
+            // Same rationale as the text heal — swallow missing-column errors
+            // on brand-new DBs; next startup reruns this.
+        }
+    }
+}