chainlesschain 0.162.148 → 0.162.150

package/src/lib/autonomous-developer.js

@@ -151,6 +151,66 @@ export function ensureAutonomousDevTables(db) {
   );
 }
 
+/**
+ * Rehydrate _sessions/_adrs from the persisted dev_sessions/
+ * architecture_decisions tables. The `cc` CLI runs every command in a fresh
+ * process, so without this the Maps start empty and a session/ADR created in a
+ * prior invocation is invisible (`cc dev list`/`show`/`adrs` show nothing) and
+ * every mutation — recordADR, advancePhase, etc. — throws "Session not found"
+ * against the empty Map. Call after ensureAutonomousDevTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _sessions.clear();
+  _adrs.clear();
+
+  const parse = (v, fallback) => {
+    if (v == null) return fallback;
+    try {
+      return JSON.parse(v);
+    } catch {
+      return fallback;
+    }
+  };
+
+  const sessionRows = db.prepare(`SELECT * FROM dev_sessions`).all();
+  for (const row of sessionRows) {
+    _sessions.set(row.session_id, {
+      sessionId: row.session_id,
+      requirement: row.requirement,
+      currentPhase: row.current_phase,
+      status: row.status,
+      autonomyLevel: row.autonomy_level ?? 2,
+      codeChanges: parse(row.code_changes, []),
+      testResults: parse(row.test_results, null),
+      reviewFeedback: parse(row.review_feedback, null),
+      startedAt: row.started_at,
+      completedAt: row.completed_at ?? null,
+      createdBy: row.created_by ?? null,
+      updatedAt: row.updated_at,
+      _seq: ++_seq,
+    });
+  }
+
+  const adrRows = db.prepare(`SELECT * FROM architecture_decisions`).all();
+  for (const row of adrRows) {
+    _adrs.set(row.adr_id, {
+      adrId: row.adr_id,
+      sessionId: row.session_id,
+      title: row.title,
+      context: row.context,
+      decision: row.decision,
+      consequences: row.consequences ?? "",
+      alternatives: parse(row.alternatives, []),
+      status: row.status,
+      createdAt: row.created_at,
+      _seq: ++_seq,
+    });
+  }
+
+  return _sessions.size + _adrs.size;
+}
+
 /* ── Catalogs ──────────────────────────────────────────────── */
 
 export function listAutonomyLevels() {

package/src/lib/chat-core.js

@@ -134,6 +134,11 @@ export async function streamOllama(
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let fullResponse = "";
+  // Buffer incomplete lines across reads: an NDJSON line can be split across two
+  // stream chunks (TCP doesn't align to '\n'), so parsing each chunk in
+  // isolation would drop the split line entirely (both halves fail JSON.parse).
+  // Keep the trailing partial for the next read — same pattern as streamAnthropic.
+  let buf = "";
 
   try {
     while (true) {
@@ -141,10 +146,12 @@ export async function streamOllama(
       if (done) break;
       guard.bump();
 
-      const text = decoder.decode(value, { stream: true });
-      const lines = text.split("\n").filter(Boolean);
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop() || "";
 
       for (const line of lines) {
+        if (!line) continue;
         try {
           const json = JSON.parse(line);
           if (json.message?.content) {
@@ -225,6 +232,11 @@ export async function streamOpenAI(
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let fullResponse = "";
+  // Buffer incomplete lines across reads: an SSE `data:` line can be split
+  // across two stream chunks, so parsing each chunk in isolation would drop the
+  // split line (both halves fail JSON.parse) — losing content and usage. Keep
+  // the trailing partial for the next read — same pattern as streamAnthropic.
+  let buf = "";
 
   try {
     while (true) {
@@ -232,8 +244,9 @@ export async function streamOpenAI(
       if (done) break;
       guard.bump();
 
-      const text = decoder.decode(value, { stream: true });
-      const lines = text.split("\n").filter(Boolean);
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop() || "";
 
       for (const line of lines) {
         if (line.startsWith("data: ")) {

package/src/lib/collaboration-governance.js

@@ -129,6 +129,62 @@ export function ensureGovernanceTables(db) {
   );
 }
 
+/**
+ * Rehydrate _decisions/_agentLevels from the persisted governance_decisions/
+ * autonomy_levels tables. The `cc` CLI runs every command in a fresh process, so
+ * without this the Maps start empty and a decision/level set in a prior
+ * invocation is invisible (`cc collab decisions`/`show`/`agents` show nothing),
+ * decision voting throws "not found", and setAutonomyLevel on a cold Map takes
+ * the INSERT branch on an already-persisted agent_id → PRIMARY KEY conflict.
+ * Call after ensureGovernanceTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _decisions.clear();
+  _agentLevels.clear();
+
+  const parse = (v, fallback) => {
+    if (v == null) return fallback;
+    try {
+      return JSON.parse(v);
+    } catch {
+      return fallback;
+    }
+  };
+
+  const decisionRows = db.prepare(`SELECT * FROM governance_decisions`).all();
+  for (const row of decisionRows) {
+    _decisions.set(row.decision_id, {
+      decisionId: row.decision_id,
+      type: row.type,
+      proposal: row.proposal,
+      status: row.status,
+      votes: parse(row.votes, {}),
+      resolution: row.resolution ?? null,
+      executedAt: row.executed_at ?? null,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      _seq: ++_seq,
+    });
+  }
+
+  const levelRows = db.prepare(`SELECT * FROM autonomy_levels`).all();
+  for (const row of levelRows) {
+    _agentLevels.set(row.agent_id, {
+      agentId: row.agent_id,
+      currentLevel: row.current_level,
+      permissions: parse(row.permissions, []),
+      adjustmentHistory: parse(row.adjustment_history, []),
+      lastReviewAt: row.last_review_at ?? null,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      _seq: ++_seq,
+    });
+  }
+
+  return _decisions.size + _agentLevels.size;
+}
+
 /* ── Catalogs ──────────────────────────────────────────────── */
 
 export function listDecisionTypes() {

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)
 // ═══════════════════════════════════════════════════════════════