chainlesschain 0.162.149 → 0.162.150

package/src/lib/eval/trend.js

@@ -16,10 +16,25 @@
 /** Normalize one `cc eval` summary into a compact trend record. */
 export function summarizeRun(record, { ranAt = null, label = null } = {}) {
   const results = Array.isArray(record?.results) ? record.results : [];
-  const perTask = {};
+  let perTask = {};
   for (const r of results) {
     if (r && r.id != null) perTask[r.id] = r.pass === true;
   }
+  // Idempotency: an already-summarized record carries `perTask` but NO
+  // `results` (that's exactly this function's own output shape). computeTrend
+  // documents "already-summarized" records as valid input and re-runs every
+  // record through summarizeRun — so if we always rebuilt perTask from
+  // `results` alone, a summarized record would come back with an EMPTY perTask,
+  // silently erasing every per-task regression/fix/drop and making the release
+  // gate report "no regression" when there was one. Preserve the record's own
+  // perTask when it has no results to derive from.
+  if (
+    results.length === 0 &&
+    record?.perTask &&
+    typeof record.perTask === "object"
+  ) {
+    perTask = { ...record.perTask };
+  }
   const total = Number.isFinite(record?.total) ? record.total : results.length;
   const passed = Number.isFinite(record?.passed)
     ? record.passed

package/src/lib/evolution-system.js

@@ -63,6 +63,79 @@ export function ensureEvolutionTables(db) {
   `);
 }
 
+/**
+ * Rehydrate the capabilities/models/growthLog stores from the persisted
+ * evolution_* tables. The `cc` CLI runs every command in a fresh process, so
+ * without this the Maps/array start empty and a capability/model/growth event
+ * recorded in a prior invocation is invisible (`cc evolution stats`/`growth`
+ * report nothing; `cc evolution export <id>` throws "not found"; `diagnose`
+ * always reports healthy/idle). It also lets assessCapability find an existing
+ * capability by name across processes instead of minting a fresh id each time
+ * (which would leave duplicate persisted rows). Call after
+ * ensureEvolutionTables(db). (diagnoses is write-only — no reader — so it is
+ * not rehydrated.)
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  capabilities.clear();
+  models.clear();
+  growthLog.length = 0;
+
+  const capRows = db.prepare(`SELECT * FROM evolution_capabilities`).all();
+  for (const row of capRows) {
+    let history = [];
+    try {
+      history = row.history ? JSON.parse(row.history) : [];
+    } catch {
+      history = [];
+    }
+    // keyed by name (matches assessCapability)
+    capabilities.set(row.name, {
+      id: row.id,
+      name: row.name,
+      score: row.score ?? 0,
+      category: row.category,
+      trend: row.trend,
+      history,
+    });
+  }
+
+  const modelRows = db.prepare(`SELECT * FROM evolution_models`).all();
+  for (const row of modelRows) {
+    let parameters = {};
+    try {
+      parameters = row.parameters ? JSON.parse(row.parameters) : {};
+    } catch {
+      parameters = {};
+    }
+    // keyed by id (matches trainIncremental modelId)
+    models.set(row.id, {
+      id: row.id,
+      name: row.name,
+      type: row.type,
+      accuracy: row.accuracy ?? 0.5,
+      dataPoints: row.data_points ?? 0,
+      parameters,
+      createdAt: row.created_at ?? null,
+      updatedAt: row.updated_at ?? null,
+    });
+  }
+
+  const logRows = db.prepare(`SELECT * FROM evolution_growth_log`).all();
+  for (const row of logRows) {
+    growthLog.push({
+      id: row.id,
+      eventType: row.event_type,
+      description: row.description,
+      capabilityId: row.capability_id ?? null,
+      delta: row.delta ?? 0,
+      timestamp: row.timestamp,
+    });
+  }
+
+  return capabilities.size + models.size + growthLog.length;
+}
+
 // ─── Core functions ───────────────────────────────────────────
 
 /**
@@ -70,6 +143,7 @@ export function ensureEvolutionTables(db) {
  */
 export function assessCapability(db, name, score, category = "general") {
   ensureEvolutionTables(db);
+  loadFromDb(db);
 
   let cap = capabilities.get(name);
   if (!cap) {
@@ -151,6 +225,7 @@ export function assessCapability(db, name, score, category = "general") {
  */
 export function trainIncremental(db, modelId, newData, options = {}) {
   ensureEvolutionTables(db);
+  loadFromDb(db);
 
   let model = models.get(modelId);
   if (!model) {
@@ -217,6 +292,7 @@ export function trainIncremental(db, modelId, newData, options = {}) {
  */
 export function selfDiagnose(db) {
   ensureEvolutionTables(db);
+  loadFromDb(db);
 
   const components = [];
   const issues = [];
@@ -327,6 +403,7 @@ export function selfDiagnose(db) {
  */
 export function selfRepair(db, issue) {
   ensureEvolutionTables(db);
+  loadFromDb(db);
 
   const actions = [];
   const timestamp = new Date().toISOString();
@@ -349,6 +426,10 @@ export function selfRepair(db, issue) {
         cap.history = cap.history.filter(
           (h) => new Date(h.timestamp).getTime() > cutoff,
         );
+        // Persist the prune, else the repair is lost when the process exits.
+        db.prepare(
+          `UPDATE evolution_capabilities SET history = ?, updated_at = datetime('now') WHERE id = ?`,
+        ).run(JSON.stringify(cap.history), cap.id);
       }
       actions.push("Pruned stale capability history entries");
       break;
@@ -359,6 +440,12 @@ export function selfRepair(db, issue) {
         if (model.accuracy < 0.6) {
           model.accuracy = 0.5;
           model.dataPoints = 0;
+          model.updatedAt = new Date().toISOString();
+          // Persist the reset, else the repair is lost when the process exits
+          // (the DB row keeps the degraded accuracy across invocations).
+          db.prepare(
+            `UPDATE evolution_models SET accuracy = ?, data_points = ?, updated_at = datetime('now') WHERE id = ?`,
+          ).run(model.accuracy, model.dataPoints, model.id);
           actions.push(`Reset model ${model.id} for retraining`);
         }
       }
@@ -400,6 +487,7 @@ export function selfRepair(db, issue) {
  */
 export function predictBehavior(db, userId, options = {}) {
   ensureEvolutionTables(db);
+  loadFromDb(db);
 
   // Build predictions from capability patterns and growth log
   const recentEvents = growthLog.slice(-50);
@@ -431,6 +519,7 @@ export function predictBehavior(db, userId, options = {}) {
  */
 export function getGrowthLog(db, options = {}) {
   ensureEvolutionTables(db);
+  loadFromDb(db);
 
   let entries = [...growthLog];
 
@@ -449,6 +538,7 @@ export function getGrowthLog(db, options = {}) {
  */
 export function getCapabilities(db) {
   ensureEvolutionTables(db);
+  loadFromDb(db);
 
   return [...capabilities.values()].map((c) => ({
     id: c.id,
@@ -465,6 +555,7 @@ export function getCapabilities(db) {
  */
 export function getModels(db) {
   ensureEvolutionTables(db);
+  loadFromDb(db);
 
   return [...models.values()].map((m) => ({
     id: m.id,
@@ -480,6 +571,7 @@ export function getModels(db) {
  */
 export function exportModel(db, modelId) {
   ensureEvolutionTables(db);
+  loadFromDb(db);
 
   const model = models.get(modelId);
   if (!model) {

package/src/lib/evomap-federation.js

@@ -47,6 +47,61 @@ export function ensureEvoMapFederationTables(db) {
   `);
 }
 
+/**
+ * Hydrate the in-memory _hubs/_lineage Maps from the DB. The CLI is one-shot:
+ * both start empty each process. Writes dual-write (Map + INSERT) but every read
+ * (listFederatedHubs/getPressureReport/getLineage/listHubsV2/buildFederationContext/
+ * getFederationStatsV2) is Map-only, and syncGenes/setHubStatus look up _hubs —
+ * so persisted hubs/lineage were invisible and sync/status-change threw
+ * "Hub not found". Call after ensureEvoMapFederationTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureEvoMapFederationTables(db);
+  _hubs.clear();
+  _lineage.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT id, hub_url, hub_name, status, region, gene_count, last_sync, trust_score, created_at
+         FROM evomap_hub_federation`,
+    )
+    .all()) {
+    _hubs.set(r.id, {
+      id: r.id,
+      hubUrl: r.hub_url,
+      hubName: r.hub_name,
+      status: r.status,
+      region: r.region,
+      geneCount: Number(r.gene_count) || 0,
+      lastSync: r.last_sync,
+      trustScore: Number(r.trust_score) || 0,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, gene_id, parent_gene_id, hub_id, generation, fitness_score, mutation_type, recombination_source, created_at
+         FROM gene_lineage`,
+    )
+    .all()) {
+    _lineage.set(r.id, {
+      id: r.id,
+      geneId: r.gene_id,
+      parentGeneId: r.parent_gene_id,
+      hubId: r.hub_id,
+      generation: Number(r.generation) || 0,
+      fitnessScore: Number(r.fitness_score) || 0,
+      mutationType: r.mutation_type,
+      recombinationSource: r.recombination_source,
+      createdAt: r.created_at,
+    });
+  }
+
+  return _hubs.size + _lineage.size;
+}
+
 /* ── Hub Management ────────────────────────────────────────── */
 
 export function listFederatedHubs(db, filter = {}) {

package/src/lib/evomap-governance.js

@@ -51,6 +51,100 @@ export function ensureEvoMapGovernanceTables(db) {
   `);
 }
 
+/**
+ * Hydrate the in-memory _ownerships/_proposals Maps from the DB. The CLI is
+ * one-shot: both start empty each process. Writes dual-write (Map + INSERT) but
+ * every read (traceOwnership/getGovernanceDashboard/listProposalsV2/
+ * getGovernanceStatsV2) is Map-only and voteOnGovernanceProposal/castVoteV2/
+ * setProposalStatus look up _proposals — so persisted ownerships/proposals were
+ * invisible and voting threw "Proposal not found". Call after
+ * ensureEvoMapGovernanceTables(db).
+ *
+ * Note: the proposals table stores only the legacy columns; V2-only fields
+ * (abstain/weight tallies, custom quorum/threshold) are not persisted, so they
+ * default here (0 / quorum 3 / threshold 0.5) to keep V2 reads and votes
+ * non-crashing. votesFor/votesAgainst/status ARE faithfully restored.
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureEvoMapGovernanceTables(db);
+  _ownerships.clear();
+  _proposals.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT id, gene_id, owner_did, originality_proof, derivation_chain, revenue_split, verified, plagiarism_score, created_at
+         FROM gene_ownership`,
+    )
+    .all()) {
+    // One corrupt JSON cell must not crash the whole load.
+    let originalityProof = null;
+    let derivationChain = [];
+    let revenueSplit = {};
+    try {
+      originalityProof = r.originality_proof
+        ? JSON.parse(r.originality_proof)
+        : null;
+    } catch {
+      originalityProof = null;
+    }
+    try {
+      derivationChain = r.derivation_chain
+        ? JSON.parse(r.derivation_chain)
+        : [];
+    } catch {
+      derivationChain = [];
+    }
+    try {
+      revenueSplit = r.revenue_split ? JSON.parse(r.revenue_split) : {};
+    } catch {
+      revenueSplit = {};
+    }
+    _ownerships.set(r.id, {
+      id: r.id,
+      geneId: r.gene_id,
+      ownerDid: r.owner_did,
+      originalityProof,
+      derivationChain,
+      revenueSplit,
+      verified: r.verified,
+      plagiarismScore: Number(r.plagiarism_score) || 0,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, title, description, proposer_did, type, status, votes_for, votes_against, quorum_reached, voting_deadline, executed_at, created_at
+         FROM evomap_governance_proposals`,
+    )
+    .all()) {
+    _proposals.set(r.id, {
+      id: r.id,
+      title: r.title,
+      description: r.description || "",
+      proposerDid: r.proposer_did,
+      type: r.type,
+      status: r.status,
+      votesFor: Number(r.votes_for) || 0,
+      votesAgainst: Number(r.votes_against) || 0,
+      quorumReached: !!r.quorum_reached,
+      votingDeadline: r.voting_deadline,
+      executedAt: r.executed_at,
+      createdAt: r.created_at,
+      // Non-persisted V2 fields — default to stay NaN-safe (see fn doc).
+      votesAbstain: 0,
+      weightFor: 0,
+      weightAgainst: 0,
+      weightAbstain: 0,
+      quorum: 3,
+      threshold: 0.5,
+    });
+  }
+
+  return _ownerships.size + _proposals.size;
+}
+
 /* ── Ownership Registration ───────────────────────────────── */
 
 export function registerOwnership(db, geneId, ownerDid, opts = {}) {

package/src/lib/fatal-handler.js

@@ -21,6 +21,19 @@ export function reportFatal(
     env = process.env,
   } = {},
 ) {
+  // Ctrl-C / Esc on an interactive @inquirer prompt throws ExitPromptError.
+  // That's a normal user cancel, not a failure — printing `error: User force
+  // closed the prompt...` + a non-descript exit is confusing. Treat it as a
+  // clean cancel: a brief note to stderr and the conventional SIGINT exit code
+  // (130 = 128 + SIGINT), so scripts can tell "cancelled" from "succeeded".
+  if (
+    err &&
+    (err.name === "ExitPromptError" || err.code === "ERR_USE_AFTER_CLOSE")
+  ) {
+    stderr.write("\nCancelled.\n");
+    exit(130);
+    return;
+  }
   const verbose =
     argv.includes("--verbose") || Boolean(env.CC_DEBUG) || Boolean(env.DEBUG);
   if (verbose && err && err.stack) {
@@ -38,7 +51,10 @@ export function reportFatal(
  * this only swaps the ugly default stack for the friendly boundary — it is not
  * a behavior change (still exits non-zero).
  */
-export function installGlobalErrorHandlers(proc = process, report = reportFatal) {
+export function installGlobalErrorHandlers(
+  proc = process,
+  report = reportFatal,
+) {
   proc.on("unhandledRejection", (reason) =>
     report(reason instanceof Error ? reason : new Error(String(reason))),
   );

package/src/lib/hardening-manager.js

@@ -67,6 +67,79 @@ export function ensureHardeningTables(db) {
   `);
 }
 
+/**
+ * Rehydrate _baselines/_audits from the persisted performance_baselines/
+ * hardening_audits tables. The `cc` CLI runs every command in a fresh process,
+ * so without this the Maps start empty and a baseline/audit collected in a
+ * prior invocation is invisible (`cc hardening baseline list`/`audit reports`
+ * show nothing; `baseline compare`/`audit report <id>` throw "not found"; and —
+ * most damagingly — `cc hardening deploy-check` reports "No baseline / No audit"
+ * and yields a silently-wrong go/no-go verdict even when the rows exist). Call
+ * after ensureHardeningTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _baselines.clear();
+  _audits.clear();
+
+  const baselineRows = db.prepare(`SELECT * FROM performance_baselines`).all();
+  for (const row of baselineRows) {
+    let metrics = {};
+    let environment = {};
+    try {
+      metrics = row.metrics ? JSON.parse(row.metrics) : {};
+    } catch {
+      metrics = {};
+    }
+    try {
+      environment = row.environment ? JSON.parse(row.environment) : {};
+    } catch {
+      environment = {};
+    }
+    _baselines.set(row.id, {
+      id: row.id,
+      name: row.name,
+      version: row.version,
+      status: row.status,
+      metrics,
+      environment,
+      sampleCount: row.sample_count ?? 0,
+      createdAt: row.created_at ?? null,
+      completedAt: row.completed_at ?? null,
+    });
+  }
+
+  const auditRows = db.prepare(`SELECT * FROM hardening_audits`).all();
+  for (const row of auditRows) {
+    let checks = [];
+    let recommendations = [];
+    try {
+      checks = row.checks ? JSON.parse(row.checks) : [];
+    } catch {
+      checks = [];
+    }
+    try {
+      recommendations = row.recommendations
+        ? JSON.parse(row.recommendations)
+        : [];
+    } catch {
+      recommendations = [];
+    }
+    _audits.set(row.id, {
+      id: row.id,
+      name: row.name,
+      checks,
+      passed: row.passed ?? 0,
+      failed: row.failed ?? 0,
+      score: row.score ?? 0,
+      recommendations,
+      createdAt: row.created_at ?? null,
+    });
+  }
+
+  return _baselines.size + _audits.size;
+}
+
 /* ── Baseline Collection ──────────────────────────────────── */
 
 export function collectBaseline(db, name, version) {

package/src/lib/hierarchical-memory.js

@@ -5,6 +5,8 @@
  * with Ebbinghaus forgetting curve and spacing effect reinforcement.
  */
 
+import { escapeLike } from "./sql-like.js";
+
 // ─── Configuration ───────────────────────────────────────────────
 export const MEMORY_CONFIG = {
   workingCapacity: 50,
@@ -292,8 +294,10 @@ export function recallMemory(db, query, options = {}) {
   // Search long-term memory (DB)
   ensureMemoryTables(db);
   const ltRows = db
-    .prepare(`SELECT * FROM memory_long_term WHERE content LIKE ? LIMIT ?`)
-    .all(`%${query}%`, limit);
+    .prepare(
+      `SELECT * FROM memory_long_term WHERE content LIKE ? ESCAPE '\\' LIMIT ?`,
+    )
+    .all(`%${escapeLike(query)}%`, limit);
   for (const row of ltRows) {
     const retention = calcRetention(row.last_accessed);
     if (retention >= MEMORY_CONFIG.recallThreshold) {
@@ -316,8 +320,10 @@ export function recallMemory(db, query, options = {}) {
 
   // Search core memory (DB) — core memories don't decay
   const coreRows = db
-    .prepare(`SELECT * FROM memory_core WHERE content LIKE ? LIMIT ?`)
-    .all(`%${query}%`, limit);
+    .prepare(
+      `SELECT * FROM memory_core WHERE content LIKE ? ESCAPE '\\' LIMIT ?`,
+    )
+    .all(`%${escapeLike(query)}%`, limit);
   for (const row of coreRows) {
     db.prepare(
       `UPDATE memory_core SET access_count = access_count + 1, last_accessed = ? WHERE id = ?`,
@@ -444,9 +450,9 @@ function _searchByType(db, query, type, options = {}) {
   ensureMemoryTables(db);
   const ltRows = db
     .prepare(
-      `SELECT * FROM memory_long_term WHERE type = ? AND content LIKE ? LIMIT ?`,
+      `SELECT * FROM memory_long_term WHERE type = ? AND content LIKE ? ESCAPE '\\' LIMIT ?`,
     )
-    .all(type, `%${query}%`, limit);
+    .all(type, `%${escapeLike(query)}%`, limit);
   for (const row of ltRows) {
     results.push({
       id: row.id,
@@ -462,9 +468,9 @@ function _searchByType(db, query, type, options = {}) {
 
   const coreRows = db
     .prepare(
-      `SELECT * FROM memory_core WHERE type = ? AND content LIKE ? LIMIT ?`,
+      `SELECT * FROM memory_core WHERE type = ? AND content LIKE ? ESCAPE '\\' LIMIT ?`,
     )
-    .all(type, `%${query}%`, limit);
+    .all(type, `%${escapeLike(query)}%`, limit);
   for (const row of coreRows) {
     results.push({
       id: row.id,

package/src/lib/knowledge-exporter.js

@@ -78,7 +78,10 @@ export function sanitizeFilename(name) {
  * Convert a note to markdown with YAML frontmatter.
  */
 export function noteToMarkdown(note) {
-  const tags = JSON.parse(note.tags || "[]");
+  // safeJsonParse (not bare JSON.parse): exportToMarkdown loops over every note,
+  // so one corrupt/hand-edited `tags` cell would otherwise throw and abort the
+  // ENTIRE export mid-way. Matches generateIndexHtml, which already guards.
+  const tags = safeJsonParse(note.tags, []);
   const lines = [
     "---",
     `title: "${note.title.replace(/"/g, '\\"')}"`,
@@ -136,7 +139,10 @@ export function exportToMarkdown(db, outputDir, options = {}) {
  * Generate a minimal HTML page for a note.
  */
 export function noteToHtml(note) {
-  const tags = JSON.parse(note.tags || "[]");
+  // safeJsonParse (not bare JSON.parse): exportToSite loops over every note, so
+  // one corrupt `tags` cell would otherwise throw and abort the whole site
+  // export — after index.html was already written, leaving dangling links.
+  const tags = safeJsonParse(note.tags, []);
   const tagsHtml = tags
     .map((t) => `<span class="tag">${escapeHtml(t)}</span>`)
     .join(" ");

package/src/lib/knowledge-graph.js

@@ -95,6 +95,85 @@ export function ensureKnowledgeGraphTables(db) {
   );
 }
 
+/**
+ * Hydrate the in-memory graph from the DB. The CLI is one-shot: _entities/
+ * _relations/_outEdges/_inEdges start empty every process. Writes dual-write
+ * (Map + INSERT), but every read is Map-only and nothing ever SELECTed the
+ * tables back — so persisted entities/relations were invisible on the next
+ * invocation (list/show/stats/export empty; add-relation threw "Source entity
+ * not found"; remove returned false and left the row). Call after
+ * ensureKnowledgeGraphTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureKnowledgeGraphTables(db);
+  _entities.clear();
+  _relations.clear();
+  _outEdges.clear();
+  _inEdges.clear();
+
+  const entityRows = db
+    .prepare(
+      `SELECT id, name, type, properties, tags, created_at, updated_at
+         FROM kg_entities ORDER BY created_at ASC`,
+    )
+    .all();
+  for (const r of entityRows) {
+    // A single corrupt properties/tags cell must not crash the whole load.
+    let properties = null;
+    let tags = null;
+    try {
+      properties = r.properties ? JSON.parse(r.properties) : null;
+    } catch {
+      properties = null;
+    }
+    try {
+      tags = r.tags ? JSON.parse(r.tags) : null;
+    } catch {
+      tags = null;
+    }
+    _entities.set(r.id, {
+      id: r.id,
+      name: r.name,
+      type: r.type,
+      properties,
+      tags,
+      createdAt: Number(r.created_at),
+      updatedAt: Number(r.updated_at),
+      _seq: ++_seq,
+    });
+  }
+
+  const relationRows = db
+    .prepare(
+      `SELECT id, source_id, target_id, relation_type, weight, properties, created_at
+         FROM kg_relationships ORDER BY created_at ASC`,
+    )
+    .all();
+  for (const r of relationRows) {
+    let properties = null;
+    try {
+      properties = r.properties ? JSON.parse(r.properties) : null;
+    } catch {
+      properties = null;
+    }
+    const relation = {
+      id: r.id,
+      sourceId: r.source_id,
+      targetId: r.target_id,
+      relationType: r.relation_type,
+      weight: Number(r.weight),
+      properties,
+      createdAt: Number(r.created_at),
+      _seq: ++_seq,
+    };
+    _relations.set(r.id, relation);
+    _indexRelation(relation);
+  }
+
+  return _entities.size + _relations.size;
+}
+
 /* ── Catalogs ──────────────────────────────────────────────── */
 
 export function listEntityTypes() {

package/src/lib/llm-providers.js

@@ -292,20 +292,29 @@ export class LLMProviderRegistry {
     if (!this.providers.has(name)) {
       throw new Error(`Provider "${name}" not found`);
     }
-    // Reset all
-    this.db.prepare("UPDATE llm_providers SET is_active = 0 WHERE 1=1").run();
-    // Set active
-    this.db
-      .prepare(
-        "INSERT OR REPLACE INTO llm_providers (name, display_name, base_url, api_key_env, models, is_active) VALUES (?, ?, ?, ?, ?, 1)",
-      )
-      .run(
-        name,
-        this.providers.get(name).displayName,
-        this.providers.get(name).baseUrl,
-        this.providers.get(name).apiKeyEnv,
-        JSON.stringify(this.providers.get(name).models),
-      );
+    // Clear every active flag then mark the new provider active atomically.
+    // Without a transaction, a failure on the second statement leaves NO
+    // provider active — which getActive() silently masks as the "ollama"
+    // fallback, so a failed switch would quietly lose the current provider.
+    const applyWrites = () => {
+      this.db.prepare("UPDATE llm_providers SET is_active = 0 WHERE 1=1").run();
+      this.db
+        .prepare(
+          "INSERT OR REPLACE INTO llm_providers (name, display_name, base_url, api_key_env, models, is_active) VALUES (?, ?, ?, ?, ?, 1)",
+        )
+        .run(
+          name,
+          this.providers.get(name).displayName,
+          this.providers.get(name).baseUrl,
+          this.providers.get(name).apiKeyEnv,
+          JSON.stringify(this.providers.get(name).models),
+        );
+    };
+    if (this.db && typeof this.db.transaction === "function") {
+      this.db.transaction(applyWrites)();
+    } else {
+      applyWrites();
+    }
     return this.providers.get(name);
   }