chainlesschain 0.162.148 → 0.162.150

package/src/lib/eval/trend.js

@@ -0,0 +1,200 @@
+/**
+ * Eval trend analysis (Phase 7) — turn a history of `cc eval` runs into a
+ * release-gate signal: is the task-success rate trending down, and did any task
+ * that used to pass start failing (a regression)?
+ *
+ * The eval RUNS themselves need a real model (a dry-run is always 0%), but the
+ * REPORTING is pure: given the recorded per-run summaries (pass-rate + which
+ * tasks passed), computing the delta, per-task regressions, and the gate verdict
+ * is deterministic and unit-testable with fixtures — which is what a release
+ * pipeline actually wires up. This module is that consumer.
+ *
+ * A run record is the JSON `cc eval --json` emits, optionally tagged with
+ * `ranAt` / `label` (version or commit). `perTask` is derived from `results`.
+ */
+
+/** 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 : [];
+  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
+    : results.filter((r) => r && r.pass === true).length;
+  const passRate = Number.isFinite(record?.passRate)
+    ? record.passRate
+    : total > 0
+      ? passed / total
+      : 0;
+  return {
+    ranAt: record?.ranAt ?? ranAt,
+    label: record?.label ?? label,
+    passed,
+    total,
+    passRate,
+    perTask,
+  };
+}
+
+/** Stable chronological order: by `ranAt` when present, else preserve input order. */
+function ordered(records) {
+  const withIdx = records.map((r, i) => ({ r, i }));
+  withIdx.sort((a, b) => {
+    const ax = a.r.ranAt,
+      bx = b.r.ranAt;
+    if (ax != null && bx != null && ax !== bx) return ax < bx ? -1 : 1;
+    if (ax != null && bx == null) return 1; // timestamped runs sort after untimestamped
+    if (ax == null && bx != null) return -1;
+    return a.i - b.i; // stable fallback
+  });
+  return withIdx.map((x) => x.r);
+}
+
+/**
+ * Compare the latest run against the previous one and report the trend.
+ *
+ * @param {object[]} runs  array of run records (raw `cc eval` summaries or
+ *   already-summarized); ordered by `ranAt` when available, else input order.
+ * @param {object} [opts]
+ * @param {number} [opts.regressionThreshold] pass-rate drop (0..1) that trips the
+ *   gate on its own, independent of per-task regressions. Default 0 (any drop or
+ *   any newly-failing task trips it).
+ * @returns {{
+ *   runs:number, latest:object|null, previous:object|null, delta:number,
+ *   direction:"up"|"down"|"flat"|"n/a", regressions:string[], fixed:string[],
+ *   newlyMissing:string[], regressed:boolean, history:number[]
+ * }}
+ */
+export function computeTrend(runs, { regressionThreshold = 0 } = {}) {
+  const norm = ordered((runs || []).map((r) => summarizeRun(r)));
+  const history = norm.map((r) => r.passRate);
+  if (norm.length === 0) {
+    return {
+      runs: 0,
+      latest: null,
+      previous: null,
+      delta: 0,
+      direction: "n/a",
+      regressions: [],
+      fixed: [],
+      newlyMissing: [],
+      regressed: false,
+      history,
+    };
+  }
+  const latest = norm[norm.length - 1];
+  const previous = norm.length >= 2 ? norm[norm.length - 2] : null;
+  if (!previous) {
+    return {
+      runs: norm.length,
+      latest,
+      previous: null,
+      delta: 0,
+      direction: "n/a",
+      regressions: [],
+      fixed: [],
+      newlyMissing: [],
+      regressed: false,
+      history,
+    };
+  }
+  const delta = latest.passRate - previous.passRate;
+  const regressions = []; // passed before, fails now
+  const fixed = []; // failed before, passes now
+  const newlyMissing = []; // in previous suite, absent from latest (dropped task)
+  for (const [id, prevPass] of Object.entries(previous.perTask)) {
+    if (!(id in latest.perTask)) {
+      newlyMissing.push(id);
+      continue;
+    }
+    const nowPass = latest.perTask[id];
+    if (prevPass && !nowPass) regressions.push(id);
+    else if (!prevPass && nowPass) fixed.push(id);
+  }
+  const direction = delta > 1e-9 ? "up" : delta < -1e-9 ? "down" : "flat";
+  // The gate trips on ANY task regression, or a pass-rate drop beyond the
+  // threshold. A per-task regression matters even when the aggregate holds
+  // (one task fixed while another broke = flat rate but a real regression).
+  const regressed =
+    regressions.length > 0 || delta < -Math.abs(regressionThreshold);
+  return {
+    runs: norm.length,
+    latest,
+    previous,
+    delta,
+    direction,
+    regressions: regressions.sort(),
+    fixed: fixed.sort(),
+    newlyMissing: newlyMissing.sort(),
+    regressed,
+    history,
+  };
+}
+
+const BARS = "▁▂▃▄▅▆▇█";
+/** Tiny unicode sparkline of pass-rates (0..1) across the run history. */
+export function sparkline(rates) {
+  if (!rates || rates.length === 0) return "";
+  return rates
+    .map((r) => {
+      const clamped = Math.max(0, Math.min(1, Number(r) || 0));
+      return BARS[
+        Math.min(BARS.length - 1, Math.round(clamped * (BARS.length - 1)))
+      ];
+    })
+    .join("");
+}
+
+/** Human-readable trend report. */
+export function formatTrend(trend) {
+  if (!trend || trend.runs === 0) return "No eval history to report.";
+  const pct = (n) => `${(n * 100).toFixed(1)}%`;
+  const lines = [];
+  const l = trend.latest;
+  lines.push(
+    `Eval trend over ${trend.runs} run(s)  ${sparkline(trend.history)}`,
+  );
+  lines.push(
+    `  latest: ${l.passed}/${l.total} (${pct(l.passRate)})` +
+      (l.label ? ` [${l.label}]` : ""),
+  );
+  if (!trend.previous) {
+    lines.push("  (only one run — no delta yet)");
+    return lines.join("\n");
+  }
+  const arrow =
+    trend.direction === "up" ? "▲" : trend.direction === "down" ? "▼" : "▬";
+  const sign = trend.delta >= 0 ? "+" : "";
+  lines.push(
+    `  vs previous: ${arrow} ${sign}${(trend.delta * 100).toFixed(1)} pts`,
+  );
+  if (trend.regressions.length)
+    lines.push(`  ✗ regressions: ${trend.regressions.join(", ")}`);
+  if (trend.fixed.length) lines.push(`  ✔ fixed: ${trend.fixed.join(", ")}`);
+  if (trend.newlyMissing.length)
+    lines.push(`  · dropped tasks: ${trend.newlyMissing.join(", ")}`);
+  lines.push(
+    trend.regressed
+      ? "  RESULT: REGRESSED (gate fails)"
+      : "  RESULT: ok (no regression)",
+  );
+  return lines.join("\n");
+}

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) {