chainlesschain 0.162.149 → 0.162.151

package/src/lib/community-governance.js

@@ -129,6 +129,74 @@ export function ensureGovernanceTables(db) {
   );
 }
 
+/**
+ * Rehydrate _proposals/_votes/_proposalVotes from the persisted
+ * governance_proposals/governance_votes tables. The `cc` CLI runs every command
+ * in a fresh process, so without this the Maps start empty and a proposal/vote
+ * created in a prior invocation is invisible (`cc governance list`/`show`/
+ * `votes`/`tally`/`stats` show nothing) and activate/close/castVote throw
+ * "Proposal not found". Rebuilds the _proposalVotes proposalId→Set<voteId>
+ * index from the votes too. Call after ensureGovernanceTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _proposals.clear();
+  _votes.clear();
+  _proposalVotes.clear();
+
+  const parse = (v, fallback) => {
+    if (v == null) return fallback;
+    try {
+      return JSON.parse(v);
+    } catch {
+      return fallback;
+    }
+  };
+
+  const proposalRows = db.prepare(`SELECT * FROM governance_proposals`).all();
+  for (const row of proposalRows) {
+    _proposals.set(row.id, {
+      id: row.id,
+      title: row.title,
+      description: row.description ?? null,
+      type: row.type,
+      proposerDid: row.proposer_did ?? null,
+      status: row.status,
+      impactLevel: row.impact_level ?? null,
+      impactAnalysis: parse(row.impact_analysis, null),
+      voteYes: row.vote_yes ?? 0,
+      voteNo: row.vote_no ?? 0,
+      voteAbstain: row.vote_abstain ?? 0,
+      votingStartsAt: row.voting_starts_at ?? null,
+      votingEndsAt: row.voting_ends_at ?? null,
+      metadata: parse(row.metadata, null),
+      createdAt: row.created_at,
+      _seq: ++_seq,
+    });
+    _proposalVotes.set(row.id, new Set());
+  }
+
+  const voteRows = db.prepare(`SELECT * FROM governance_votes`).all();
+  for (const row of voteRows) {
+    _votes.set(row.id, {
+      id: row.id,
+      proposalId: row.proposal_id,
+      voterDid: row.voter_did,
+      vote: row.vote,
+      reason: row.reason ?? null,
+      weight: row.weight ?? 1.0,
+      createdAt: row.created_at,
+      _seq: ++_seq,
+    });
+    if (!_proposalVotes.has(row.proposal_id)) {
+      _proposalVotes.set(row.proposal_id, new Set());
+    }
+    _proposalVotes.get(row.proposal_id).add(row.id);
+  }
+
+  return _proposals.size + _votes.size;
+}
+
 /* ── Catalogs ──────────────────────────────────────────────── */
 
 export function listProposalTypes() {

package/src/lib/compliance-manager.js

@@ -723,6 +723,69 @@ export function _resetState() {
   _reportRetentionMs = COMPLIANCE_DEFAULT_REPORT_RETENTION_MS;
 }
 
+/**
+ * Rehydrate the in-memory _evidence/_policies Maps from the persisted
+ * compliance_* tables. The CLI runs each `cc compliance` subcommand in a fresh
+ * node process, so both Maps start empty every invocation. collectEvidence/
+ * addPolicy dual-write (Map + INSERT into compliance_evidence/compliance_policies)
+ * but generateReport (summary path), scanCompliance and listPolicies read the
+ * Maps only — so a `report`/`scan` after `evidence` in a separate process saw 0
+ * evidence items and scored 0. (The `report --detailed` path already SELECTed via
+ * the command-layer _loadEvidenceFromDb/_loadPoliciesFromDb; this makes the
+ * summary/scan/policies paths consistent.) `_reports` is write-only (no read
+ * path) and is not rehydrated. Call after ensureComplianceTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureComplianceTables(db);
+  _evidence.clear();
+  _policies.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT id, framework, type, description, source, status, collected_at
+         FROM compliance_evidence ORDER BY collected_at ASC`,
+    )
+    .all()) {
+    _evidence.set(r.id, {
+      id: r.id,
+      framework: r.framework,
+      type: r.type,
+      description: r.description || "",
+      source: r.source,
+      status: r.status,
+      collectedAt: r.collected_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, name, type, framework, rules, enabled, severity, created_at
+         FROM compliance_policies ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt rules cell must not sink the whole policy load.
+    let rules = {};
+    try {
+      rules = r.rules ? JSON.parse(r.rules) : {};
+    } catch {
+      rules = {};
+    }
+    _policies.set(r.id, {
+      id: r.id,
+      name: r.name,
+      type: r.type,
+      framework: r.framework,
+      rules,
+      enabled: !!r.enabled,
+      severity: r.severity,
+      createdAt: r.created_at,
+    });
+  }
+
+  return _evidence.size + _policies.size;
+}
+
 // =====================================================================
 // compliance-manager V2 governance overlay (iter17)
 // =====================================================================

package/src/lib/cross-chain.js

@@ -651,6 +651,11 @@ const BASE_FEE = {
 export function estimateFee({ fromChain, toChain, amount }) {
   if (!_validateChain(fromChain) || !_validateChain(toChain))
     return { fee: null, reason: "unsupported_chain" };
+  // `cc crosschain estimate-fee` passes parseFloat(amount); a non-numeric arg
+  // yields NaN. Without this guard percentageFee/totalFee become NaN, the
+  // command's `fee === null` check misses it, and it prints "$NaN USD".
+  if (!Number.isFinite(amount) || amount <= 0)
+    return { fee: null, reason: "invalid_amount" };
 
   const baseFee = (BASE_FEE[fromChain] || 1.0) + (BASE_FEE[toChain] || 1.0);
   const percentageFee = amount * (DEFAULT_CONFIG.feePercentage / 100);

package/src/lib/dao-governance.js

@@ -112,6 +112,153 @@ export function ensureDAOv2Tables(db) {
   `);
 }
 
+/**
+ * Hydrate the in-memory stores from the DB. The CLI is one-shot: _proposals/
+ * _votes/_delegations/_treasury/_delegationsV2/_treasuryTxs all start empty each
+ * process. Every write dual-writes (Map/obj + INSERT) but every read/mutate is
+ * Map-only and nothing SELECTed the tables back — so the ENTIRE dao feature was
+ * broken across invocations: vote/execute/allocate threw "not found", stats
+ * reported 0, and the treasury deposit was invisible (allocate always
+ * "Insufficient"). Call after ensureDAOv2Tables(db).
+ *
+ * Faithful: proposals' votesFor/votesAgainst/status, votes, legacy delegations,
+ * and the treasury balance (DERIVED = Σdeposit − Σallocation, replayed in
+ * chronological order so each tx's balanceAfter is reconstructed too).
+ *
+ * Lossy (defaulted to stay correct/safe — these columns don't exist in the
+ * schema): V2 proposal abstain/quadratic-weight tallies → 0; proposal.queueEnd →
+ * a far-future sentinel so executeProposalV2 FAILS CLOSED (a null/undefined
+ * would make its timelock check `now < NaN` and BYPASS the timelock); V2
+ * delegation status/expiresAt → ACTIVE/none (revocation is not persisted).
+ */
+const _REHYDRATE_QUEUE_END_SENTINEL = "9999-12-31T23:59:59.999Z";
+
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureDAOv2Tables(db);
+  _proposals.clear();
+  _votes.clear();
+  _delegations.clear();
+  _delegationsV2.clear();
+  _treasuryTxs.length = 0;
+  _treasury.balance = 0;
+  _treasury.allocations = [];
+
+  for (const r of db
+    .prepare(
+      `SELECT id, title, description, proposer, status, votes_for, votes_against, voting_type, created_at, ends_at, executed_at
+         FROM dao_v2_proposals`,
+    )
+    .all()) {
+    _proposals.set(r.id, {
+      id: r.id,
+      title: r.title,
+      description: r.description || "",
+      proposer: r.proposer,
+      proposerDid: r.proposer, // V2 field mirrors legacy proposer
+      type: "standard",
+      status: r.status,
+      votesFor: Number(r.votes_for) || 0,
+      votesAgainst: Number(r.votes_against) || 0,
+      votingType: r.voting_type,
+      createdAt: r.created_at,
+      updatedAt: r.created_at,
+      endsAt: r.ends_at,
+      executedAt: r.executed_at,
+      // Non-persisted V2 fields — default to stay NaN-safe (see fn doc).
+      votesAbstain: 0,
+      quadraticWeightFor: 0,
+      quadraticWeightAgainst: 0,
+      quorumReached: false,
+      votingStart: null,
+      votingEnd: null,
+      cancelledAt: null,
+      // Fail-closed: a rehydrated QUEUED proposal cannot be executed until it is
+      // re-queued (real queueEnd is not persisted). Never bypass the timelock.
+      queueEnd: _REHYDRATE_QUEUE_END_SENTINEL,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, proposal_id, voter, weight, direction, delegated_from, created_at
+         FROM dao_v2_votes`,
+    )
+    .all()) {
+    _votes.set(r.id, {
+      id: r.id,
+      proposalId: r.proposal_id,
+      voter: r.voter,
+      voterDid: r.voter, // both read paths (stats uses voter, anti-sybil voterDid)
+      weight: Number(r.weight) || 0,
+      voteCount: Number(r.weight) || 0,
+      direction: r.direction,
+      voteType: r.direction,
+      delegatedFrom: r.delegated_from,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT delegator, delegate, weight, created_at FROM dao_v2_delegations`,
+    )
+    .all()) {
+    _delegations.set(r.delegator, {
+      delegator: r.delegator,
+      delegate: r.delegate,
+      weight: Number(r.weight) || 0,
+    });
+    // Synthesize a V2 record (status/expiresAt are not persisted → default).
+    _delegationsV2.set(`deleg:${r.delegator}`, {
+      id: `deleg:${r.delegator}`,
+      fromDid: r.delegator,
+      toDid: r.delegate,
+      weight: Number(r.weight) || 0,
+      status: DELEGATION_STATUS.ACTIVE,
+      expiresAt: null,
+      revokedAt: null,
+      createdAt: r.created_at,
+    });
+  }
+
+  // Treasury: no balance column — derive it by replaying the tx log in
+  // chronological order (deposit +, allocation −), reconstructing balanceAfter.
+  const treasuryRows = db
+    .prepare(
+      `SELECT id, type, amount, description, proposal_id, created_at
+         FROM dao_v2_treasury ORDER BY created_at ASC`,
+    )
+    .all();
+  for (const r of treasuryRows) {
+    const amt = Number(r.amount) || 0;
+    if (r.type === TREASURY_TX_TYPE.DEPOSIT) _treasury.balance += amt;
+    else if (r.type === TREASURY_TX_TYPE.ALLOCATION) _treasury.balance -= amt;
+    _treasuryTxs.push({
+      id: r.id,
+      txType: r.type,
+      proposalId: r.proposal_id,
+      amount: amt,
+      memo: r.description || "",
+      balanceAfter: _treasury.balance,
+      createdAt: r.created_at,
+    });
+    if (r.type === TREASURY_TX_TYPE.ALLOCATION) {
+      _treasury.allocations.push({
+        id: r.id,
+        proposalId: r.proposal_id,
+        amount: amt,
+        description: r.description || "",
+        date: r.created_at,
+      });
+    }
+  }
+
+  return (
+    _proposals.size + _votes.size + _delegations.size + _treasuryTxs.length
+  );
+}
+
 /* ── Proposals ─────────────────────────────────────────────── */
 
 export function propose(db, title, description, proposer, options = {}) {
@@ -259,7 +406,8 @@ export function getTreasury() {
 
 export function allocate(db, proposalId, amount, description) {
   if (!proposalId) throw new Error("Proposal ID is required");
-  if (amount <= 0) throw new Error("Amount must be positive");
+  if (!Number.isFinite(amount) || amount <= 0)
+    throw new Error("Amount must be positive");
   if (_treasury.balance < amount) {
     throw new Error("Insufficient treasury balance");
   }
@@ -287,7 +435,8 @@ export function allocate(db, proposalId, amount, description) {
 }
 
 export function depositToTreasury(db, amount, description) {
-  if (amount <= 0) throw new Error("Amount must be positive");
+  if (!Number.isFinite(amount) || amount <= 0)
+    throw new Error("Amount must be positive");
 
   const id = `dep-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
   const now = new Date().toISOString();

package/src/lib/did-manager.js

@@ -163,16 +163,29 @@ export function setDefaultIdentity(db, did) {
   const identity = getIdentity(db, did);
   if (!identity) return false;
 
-  // Clear the current default(s). Match on is_default rather than `did LIKE '%'`
-  // so there's no wildcard pattern here that a reader/scanner could mistake for
-  // LIKE-injection — the target below is set via exact `did = ?` regardless.
-  db.prepare(
-    "UPDATE did_identities SET is_default = 0 WHERE is_default = 1",
-  ).run();
-  db.prepare("UPDATE did_identities SET is_default = ? WHERE did = ?").run(
-    1,
-    identity.did,
-  );
+  // Clear the current default(s) then set the new one atomically. Match on
+  // is_default rather than `did LIKE '%'` so there's no wildcard pattern here
+  // that a reader/scanner could mistake for LIKE-injection — the target below
+  // is set via exact `did = ?` regardless.
+  //
+  // The two UPDATEs must both land: without a transaction, a failure on the
+  // second leaves EVERY identity non-default (the default DID silently
+  // disappears until manually re-set), breaking the exactly-one-default
+  // invariant.
+  const applyWrites = () => {
+    db.prepare(
+      "UPDATE did_identities SET is_default = 0 WHERE is_default = 1",
+    ).run();
+    db.prepare("UPDATE did_identities SET is_default = ? WHERE did = ?").run(
+      1,
+      identity.did,
+    );
+  };
+  if (db && typeof db.transaction === "function") {
+    db.transaction(applyWrites)();
+  } else {
+    applyWrites();
+  }
   return true;
 }
 

package/src/lib/dlp-engine.js

@@ -325,6 +325,76 @@ export function _resetState() {
   _v2IncidentMeta.clear();
 }
 
+/**
+ * Rehydrate the in-memory _policies/_incidents Maps from the persisted dlp_*
+ * tables. The CLI runs each `cc dlp` subcommand in a fresh node process, so both
+ * Maps start empty every invocation. createPolicy/scanContent dual-write (Map +
+ * INSERT into dlp_policies/dlp_incidents) but every read (listDLPPolicies/
+ * listIncidents/getDLPStats + the scanContent enforcement loop over _policies)
+ * is Map-only and nothing SELECTed the tables back.
+ *
+ * SECURITY IMPACT: `cc dlp scan` iterates an empty _policies → matches nothing →
+ * returns allowed:true, so a BLOCK policy created in a prior invocation silently
+ * never enforces. Persisted policies were also un-listable and un-deletable
+ * (`policy delete`/`resolve` threw "not found"). Call after ensureDLPTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureDLPTables(db);
+  _policies.clear();
+  _incidents.clear();
+
+  const parse = (v, fallback) => {
+    try {
+      return v ? JSON.parse(v) : fallback;
+    } catch {
+      return fallback;
+    }
+  };
+
+  for (const r of db
+    .prepare(
+      `SELECT id, name, patterns, keywords, action, severity, enabled, created_at
+         FROM dlp_policies ORDER BY created_at ASC`,
+    )
+    .all()) {
+    _policies.set(r.id, {
+      id: r.id,
+      name: r.name,
+      patterns: parse(r.patterns, []),
+      keywords: parse(r.keywords, []),
+      action: r.action,
+      severity: r.severity,
+      enabled: !!r.enabled,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, policy_id, channel, action_taken, content_hash, matched_patterns,
+              severity, user_id, created_at, resolved_at, resolution
+         FROM dlp_incidents ORDER BY created_at ASC`,
+    )
+    .all()) {
+    _incidents.set(r.id, {
+      id: r.id,
+      policyId: r.policy_id,
+      channel: r.channel,
+      actionTaken: r.action_taken,
+      contentHash: r.content_hash,
+      matchedPatterns: parse(r.matched_patterns, []),
+      severity: r.severity,
+      userId: r.user_id,
+      createdAt: r.created_at,
+      resolvedAt: r.resolved_at ?? null,
+      resolution: r.resolution ?? null,
+    });
+  }
+
+  return _policies.size + _incidents.size;
+}
+
 // ═══════════════════════════════════════════════════════════════
 // V2 Canonical Surface (Phase 50)
 // ═══════════════════════════════════════════════════════════════

package/src/lib/eval/runner.js

@@ -18,6 +18,7 @@
 import fs from "fs";
 import os from "os";
 import path from "path";
+import crypto from "crypto";
 
 export const _deps = {
   mkdtempSync: fs.mkdtempSync,
@@ -25,6 +26,55 @@ export const _deps = {
   now: () => Date.now(),
 };
 
+/**
+ * Content-hash every file under `dir` → Map<relPath (forward-slash), sha1>. Used
+ * to measure edit locality: snapshot after setup (the baseline the agent starts
+ * from) vs after the agent runs, so we can see EXACTLY which files it touched.
+ */
+function snapshotWorkspace(dir) {
+  const out = new Map();
+  const walk = (cur) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(cur, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = path.join(cur, e.name);
+      if (e.isDirectory()) {
+        walk(full);
+      } else if (e.isFile()) {
+        const rel = path.relative(dir, full).split(path.sep).join("/");
+        let hash;
+        try {
+          hash = crypto
+            .createHash("sha1")
+            .update(fs.readFileSync(full))
+            .digest("hex");
+        } catch {
+          hash = "?"; // unreadable → treat as its own value (still "changed" if it flips)
+        }
+        out.set(rel, hash);
+      }
+    }
+  };
+  walk(dir);
+  return out;
+}
+
+/** Relative paths that were created, modified, or deleted between two snapshots. */
+function diffSnapshots(before, after) {
+  const changed = new Set();
+  for (const [p, h] of after) {
+    if (!before.has(p) || before.get(p) !== h) changed.add(p); // created / modified
+  }
+  for (const p of before.keys()) {
+    if (!after.has(p)) changed.add(p); // deleted
+  }
+  return [...changed].sort();
+}
+
 /**
  * Run a suite of eval tasks and score them.
  *
@@ -77,6 +127,9 @@ export async function runEvalSuite(tasks, opts = {}) {
       if (typeof task.setup === "function") {
         await task.setup(dir);
       }
+      // Baseline AFTER setup, BEFORE the agent — so the diff is exactly the
+      // agent's edits (not the task's starting files).
+      const before = snapshotWorkspace(dir);
       let agentResult;
       try {
         agentResult = await runAgent({
@@ -90,6 +143,20 @@ export async function runEvalSuite(tasks, opts = {}) {
         rec.error = `agent error: ${agentErr.message}`;
       }
       rec.agentOk = agentResult ? agentResult.ok !== false : false;
+      // Edit locality — snapshot NOW, before check() (some checks write to the
+      // workspace themselves). `unrelatedChanges` = files touched outside the
+      // task's declared legitimate surface; null when the task doesn't declare
+      // `expectedFiles` (→ excluded from the suite's 无关改动率).
+      const changed = diffSnapshots(before, snapshotWorkspace(dir));
+      rec.changedFiles = changed;
+      if (Array.isArray(task.expectedFiles)) {
+        const expected = new Set(
+          task.expectedFiles.map((p) => String(p).split(path.sep).join("/")),
+        );
+        rec.unrelatedChanges = changed.filter((p) => !expected.has(p));
+      } else {
+        rec.unrelatedChanges = null; // not measured
+      }
       const verdict = await task.check(dir, agentResult);
       rec.pass = verdict?.pass === true;
       rec.detail = verdict?.detail || "";
@@ -136,12 +203,23 @@ export async function runEvalSuite(tasks, opts = {}) {
 
   const passed = results.filter((r) => r.pass).length;
   const total = results.length;
+  // 无关改动率: over tasks that declared expectedFiles, the fraction that
+  // touched at least one file outside their legitimate surface. An agent that
+  // solves a task but also scribbles on unrelated files scores lower quality.
+  const measured = results.filter((r) => Array.isArray(r.unrelatedChanges));
+  const tasksWithUnrelatedChanges = measured.filter(
+    (r) => r.unrelatedChanges.length > 0,
+  ).length;
   return {
     results,
     passed,
     failed: total - passed,
     total,
     passRate: total > 0 ? passed / total : 0,
+    tasksWithUnrelatedChanges,
+    unrelatedChangeRate: measured.length
+      ? tasksWithUnrelatedChanges / measured.length
+      : 0,
     ms: _deps.now() - suiteStart,
     ...(recorder ? { telemetry: recorder.summary() } : {}),
   };
@@ -154,10 +232,20 @@ export function formatEvalReport(summary) {
   lines.push(
     `Eval: ${summary.passed}/${summary.total} passed (${pct}%) in ${summary.ms}ms`,
   );
+  if (typeof summary.unrelatedChangeRate === "number") {
+    const upct = (summary.unrelatedChangeRate * 100).toFixed(1);
+    lines.push(
+      `Unrelated-change rate: ${upct}% (${summary.tasksWithUnrelatedChanges} task(s) edited files outside their expected surface)`,
+    );
+  }
   for (const r of summary.results) {
     const mark = r.pass ? "✔" : "✗";
     const detail = r.error ? ` — ${r.error}` : r.detail ? ` — ${r.detail}` : "";
-    lines.push(`  ${mark} ${r.id} (${r.ms}ms)${detail}`);
+    const stray =
+      Array.isArray(r.unrelatedChanges) && r.unrelatedChanges.length
+        ? ` [+${r.unrelatedChanges.length} unrelated: ${r.unrelatedChanges.join(", ")}]`
+        : "";
+    lines.push(`  ${mark} ${r.id} (${r.ms}ms)${detail}${stray}`);
   }
   return lines.join("\n");
 }