chainlesschain 0.162.149 → 0.162.151

package/src/lib/eval/tasks.js

@@ -21,9 +21,19 @@ function read(dir, rel) {
   }
 }
 
+// The `stringutil` "dependency" at v2, used by BOTH the upgrade-dependency
+// setup and its check so the task can verify the vendored dependency file was
+// not edited (the agent must adapt the caller, not touch the dependency).
+const STRINGUTIL_V2 =
+  "export function toTitle(s) {\n" +
+  "  const str = String(s);\n" +
+  "  return str.charAt(0).toUpperCase() + str.slice(1);\n" +
+  "}\n";
+
 export const BUILTIN_TASKS = [
   {
     id: "create-file",
+    expectedFiles: ["greeting.txt"],
     description: "Create a new file with exact content",
     prompt:
       'Create a file named greeting.txt containing exactly the text "Hello, ChainlessChain!" (no trailing newline).',
@@ -40,6 +50,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "fix-syntax-error",
+    expectedFiles: ["bug.js"],
     description: "Fix a syntax error so the script runs",
     prompt:
       "The file bug.js has a syntax error. Fix it so that running `node bug.js` prints exactly OK.",
@@ -71,6 +82,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "add-function",
+    expectedFiles: ["math.js"],
     description: "Add a function to an existing module",
     prompt:
       "In math.js, add a named export `add(a, b)` that returns a + b. Keep the existing `mul` export.",
@@ -105,6 +117,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "fix-failing-test",
+    expectedFiles: ["calc.js"],
     description:
       "Fix a bug so an existing test suite passes (bug-fix category)",
     prompt:
@@ -170,6 +183,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "refactor-rename",
+    expectedFiles: ["util.js", "main.js"],
     description:
       "Rename a symbol across two files, keeping behavior (refactor)",
     prompt:
@@ -226,6 +240,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "write-test",
+    expectedFiles: ["verify.mjs"],
     description:
       "Write a meaningful verifier for a module (test-completion category)",
     prompt:
@@ -300,6 +315,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "migrate-signature",
+    expectedFiles: ["greet.mjs", "app.mjs"],
     description:
       "Migrate a function's call convention and update all callers (api-upgrade category)",
     prompt:
@@ -361,6 +377,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "secure-path",
+    expectedFiles: ["notes.mjs"],
     description:
       "Fix a path-traversal vulnerability, verified by an exploit probe (security-fix category)",
     prompt:
@@ -447,6 +464,159 @@ export const BUILTIN_TASKS = [
       };
     },
   },
+  {
+    id: "fix-build",
+    expectedFiles: ["config.mjs", "app.mjs"],
+    description:
+      "Fix a cross-module build/link failure so the build passes (build-failure category)",
+    prompt:
+      "The build is broken: `node build.mjs` fails to LINK because of an " +
+      "export/import name mismatch between app.mjs and config.mjs. Reconcile " +
+      "them so `node build.mjs` prints BUILD OK. Do not edit build.mjs.",
+    setup: (dir) => {
+      // config exports `version` (lowercase) but app imports `VERSION` — an ESM
+      // link error at build time, distinct from a single-file syntax typo.
+      fs.writeFileSync(
+        path.join(dir, "config.mjs"),
+        'export const version = "1.0.0";\n',
+        "utf8",
+      );
+      fs.writeFileSync(
+        path.join(dir, "app.mjs"),
+        'import { VERSION } from "./config.mjs";\n' +
+          'export function banner() {\n  return "v" + VERSION;\n}\n',
+        "utf8",
+      );
+      fs.writeFileSync(
+        path.join(dir, "build.mjs"),
+        'import { banner } from "./app.mjs";\n' +
+          'if (banner() !== "v1.0.0") {\n' +
+          '  console.error("BUILD FAIL: " + banner());\n' +
+          "  process.exit(1);\n" +
+          "}\n" +
+          'console.log("BUILD OK");\n',
+        "utf8",
+      );
+    },
+    check: (dir) => {
+      const build = read(dir, "build.mjs");
+      if (build == null) return { pass: false, detail: "build.mjs missing" };
+      // Guard: fix the modules, don't neuter the build harness.
+      if (!/banner\(\)\s*!==\s*"v1\.0\.0"/.test(build)) {
+        return { pass: false, detail: "build.mjs assertion was altered" };
+      }
+      try {
+        const out = execFileSync(process.execPath, ["build.mjs"], {
+          cwd: dir,
+          encoding: "utf8",
+          timeout: 10000,
+          stdio: ["ignore", "pipe", "pipe"],
+        });
+        return out.includes("BUILD OK")
+          ? { pass: true, detail: "build links + passes" }
+          : {
+              pass: false,
+              detail: `unexpected output ${JSON.stringify(out.trim())}`,
+            };
+      } catch (err) {
+        const first = String(err.message || "").split("\n")[0];
+        return { pass: false, detail: `build still failing: ${first}` };
+      }
+    },
+  },
+  {
+    id: "upgrade-dependency",
+    expectedFiles: ["package.json", "app.mjs"],
+    description:
+      "Adapt code to a dependency's breaking upgrade + bump the manifest (dependency-upgrade category)",
+    prompt:
+      "The `stringutil` dependency was upgraded to 2.0.0. Breaking change: its " +
+      "`capitalize` export was renamed to `toTitle` (same behavior). Do all of: " +
+      "(1) bump stringutil to ^2.0.0 in package.json; (2) update app.mjs to " +
+      "import and use `toTitle` instead of `capitalize`; (3) do NOT edit " +
+      "stringutil.mjs. Afterwards `node run.mjs` must print OK.",
+    setup: (dir) => {
+      fs.writeFileSync(
+        path.join(dir, "package.json"),
+        JSON.stringify(
+          {
+            name: "app",
+            type: "module",
+            dependencies: { stringutil: "1.0.0" },
+          },
+          null,
+          2,
+        ) + "\n",
+        "utf8",
+      );
+      // The upgraded (v2) dependency — vendored, must not be edited.
+      fs.writeFileSync(path.join(dir, "stringutil.mjs"), STRINGUTIL_V2, "utf8");
+      // The caller still uses the removed v1 `capitalize` export (link error).
+      fs.writeFileSync(
+        path.join(dir, "app.mjs"),
+        'import { capitalize } from "./stringutil.mjs";\n' +
+          "export function label(s) {\n  return capitalize(s);\n}\n",
+        "utf8",
+      );
+      fs.writeFileSync(
+        path.join(dir, "run.mjs"),
+        'import { label } from "./app.mjs";\n' +
+          'if (label("hello") !== "Hello") {\n' +
+          '  console.error("FAIL: " + label("hello"));\n' +
+          "  process.exit(1);\n" +
+          "}\n" +
+          'console.log("OK");\n',
+        "utf8",
+      );
+    },
+    check: (dir) => {
+      // The dependency is vendored — the agent must adapt the caller, NOT edit
+      // the dependency to re-add the old export and dodge the upgrade.
+      const dep = read(dir, "stringutil.mjs");
+      if (dep == null) return { pass: false, detail: "stringutil.mjs missing" };
+      if (dep !== STRINGUTIL_V2) {
+        return {
+          pass: false,
+          detail: "the stringutil dependency was edited (adapt the caller)",
+        };
+      }
+      const pkg = read(dir, "package.json");
+      if (pkg == null || !/"stringutil"\s*:\s*"[\^~]?2\./.test(pkg)) {
+        return {
+          pass: false,
+          detail: "package.json not bumped to stringutil 2.x",
+        };
+      }
+      const app = read(dir, "app.mjs");
+      if (app == null) return { pass: false, detail: "app.mjs missing" };
+      if (/\bcapitalize\b/.test(app)) {
+        return {
+          pass: false,
+          detail: "app.mjs still references the removed capitalize export",
+        };
+      }
+      if (!/\btoTitle\b/.test(app)) {
+        return { pass: false, detail: "app.mjs does not use the new toTitle" };
+      }
+      try {
+        const out = execFileSync(process.execPath, ["run.mjs"], {
+          cwd: dir,
+          encoding: "utf8",
+          timeout: 10000,
+          stdio: ["ignore", "pipe", "pipe"],
+        });
+        return out.trim() === "OK"
+          ? { pass: true, detail: "adapted to new API + manifest bumped" }
+          : {
+              pass: false,
+              detail: `run.mjs printed ${JSON.stringify(out.trim())}`,
+            };
+      } catch (err) {
+        const first = String(err.message || "").split("\n")[0];
+        return { pass: false, detail: `run.mjs failed: ${first}` };
+      }
+    },
+  },
 ];
 
 /** Look up a suite by name (only "builtin" for now). */

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))),
   );