chainlesschain 0.162.148 → 0.162.150

package/src/harness/remote-session-push-xiaomi.js

@@ -0,0 +1,99 @@
+// Remote Session vendor push — Xiaomi (小米) push sender.
+//
+// A concrete implementation of the RemoteSessionPushDispatcher `sender` contract
+// for MIUI devices, using the Xiaomi Push server API. Unlike FCM/APNs there is
+// no JWT — auth is a static app AppSecret in the `Authorization: key=` header —
+// so this sender is a straight form-encoded POST over plain HTTPS with an
+// injectable `fetch` (default global), fully unit-testable with a fake
+// transport. The payload carries only routing ids (no session content).
+
+import { PushTokenUnregisteredError } from "./remote-session-push-errors.js";
+
+const DEFAULT_HOST = "https://api.xmpush.xiaomi.com";
+const SEND_PATH = "/v3/message/regid";
+
+// Xiaomi does not use a single canonical "unregistered" code; match the reason
+// text it returns for a stale/invalid registration id.
+const INVALID_TOKEN_RE = /invalid|not valid|unregist|not ?exist|无效|不存在/i;
+
+/** Sends one notification to a Xiaomi registration id. */
+export class XiaomiPushSender {
+  constructor(options = {}) {
+    if (!options.appSecret) {
+      throw new Error("XiaomiPushSender requires an appSecret");
+    }
+    if (!options.packageName) {
+      throw new Error("XiaomiPushSender requires a packageName");
+    }
+    this.appSecret = options.appSecret;
+    this.packageName = options.packageName;
+    this.host = options.host || DEFAULT_HOST;
+    this.fetch = options.fetch || globalThis.fetch;
+  }
+
+  /** Bound function matching the dispatcher's `sender` contract. */
+  get handler() {
+    return (payload) => this.send(payload);
+  }
+
+  async send({ token, notification, sessionId, clientId } = {}) {
+    if (!token) throw new Error("Xiaomi send requires a registration id");
+    const params = new URLSearchParams({
+      registration_id: token,
+      restricted_package_name: this.packageName,
+      pass_through: "0", // 0 = show a notification, 1 = data-only
+      notify_type: "-1", // default sound/vibrate
+      title: notification?.title || "Approval requested",
+      description: notification?.body || "A coding session needs your approval",
+    });
+    // Routing ids only — no session content.
+    const payload = { type: "remote-session.approval-request" };
+    if (sessionId != null) payload.sessionId = String(sessionId);
+    if (clientId != null) payload.clientId = String(clientId);
+    params.set("payload", JSON.stringify(payload));
+
+    const res = await this.fetch(`${this.host}${SEND_PATH}`, {
+      method: "POST",
+      headers: {
+        Authorization: `key=${this.appSecret}`,
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+      body: params.toString(),
+    });
+    const json = await res.json().catch(() => ({}));
+    if (res.ok && json.result === "ok" && Number(json.code) === 0) {
+      return { id: json.data?.id || null };
+    }
+    const reason = json.reason || json.description || `HTTP ${res.status}`;
+    if (INVALID_TOKEN_RE.test(String(reason))) {
+      throw new PushTokenUnregisteredError(
+        `Xiaomi registration id invalid: ${reason}`,
+      );
+    }
+    throw new Error(`Xiaomi push failed: ${reason}`);
+  }
+}
+
+/**
+ * Build a bound Xiaomi `sender` from env, or null when unconfigured.
+ *
+ * Xiaomi env:
+ *   CHAINLESSCHAIN_REMOTE_SESSION_XIAOMI_APP_SECRET
+ *   CHAINLESSCHAIN_REMOTE_SESSION_XIAOMI_PACKAGE_NAME
+ *   CHAINLESSCHAIN_REMOTE_SESSION_XIAOMI_HOST  (optional; e.g. the global host)
+ */
+export function createXiaomiPushSender(env = {}, options = {}) {
+  const appSecret =
+    options.appSecret || env.CHAINLESSCHAIN_REMOTE_SESSION_XIAOMI_APP_SECRET;
+  const packageName =
+    options.packageName ||
+    env.CHAINLESSCHAIN_REMOTE_SESSION_XIAOMI_PACKAGE_NAME;
+  if (!appSecret || !packageName) return null;
+  const host = options.host || env.CHAINLESSCHAIN_REMOTE_SESSION_XIAOMI_HOST;
+  return new XiaomiPushSender({
+    appSecret,
+    packageName,
+    host,
+    ...options,
+  }).handler;
+}

package/src/harness/worktree-isolator.js

@@ -629,19 +629,29 @@ function _conflictStatusCode(repoDir, filePath) {
 }
 
 function _mapConflictType(statusCode) {
+  // NOTE: the porcelain XY code is reported relative to the ACTUAL merge, which
+  // previewWorktreeMerge/applyWorktreeAutomationCandidate run as `git merge
+  // <base>` INSIDE the agent worktree — i.e. ours=agent, theirs=base, the
+  // REVERSE of the "current merges in the agent branch" direction the candidate
+  // labels/suggestions describe. For symmetric codes (UU/AA) direction is
+  // irrelevant. For the asymmetric delete/add codes the U/D (us/them) halves
+  // must be swapped back to the label direction, otherwise the "keep the file"
+  // candidate checks out the side that DELETED it (`git checkout --ours/--theirs`
+  // → "path does not have our/their version") and throws — leaving no automated
+  // way to preserve the surviving file.
   switch (statusCode) {
     case "UU":
       return "both_modified";
     case "AA":
       return "both_added";
-    case "DU":
-      return "deleted_by_us";
-    case "UD":
+    case "DU": // ours(agent) deleted, theirs(base) modified
       return "deleted_by_them";
-    case "AU":
-      return "added_by_us";
-    case "UA":
+    case "UD": // ours(agent) modified, theirs(base) deleted
+      return "deleted_by_us";
+    case "AU": // added by ours(agent)
       return "added_by_them";
+    case "UA": // added by theirs(base)
+      return "added_by_us";
     default:
       return "unmerged";
   }

package/src/index.js

@@ -17,6 +17,8 @@ import { registerAskCommand } from "./commands/ask.js";
 import { registerLlmCommand } from "./commands/llm.js";
 import { registerHubCommand } from "./commands/hub.js";
 import { registerAndroidCommand } from "./commands/android.js";
+import { registerEvalCommand } from "./commands/eval.js";
+import { registerTeamCommand } from "./commands/team.js";
 import {
   registerAgentCommand,
   registerSubAgentV2Command,
@@ -58,6 +60,7 @@ import { registerRCacheCommand } from "./commands/rcache.js";
 import { registerSessionCommand } from "./commands/session.js";
 import { registerCostCommand } from "./commands/cost.js";
 import { registerContextCommand } from "./commands/context.js";
+import { registerCodeIntelCommand } from "./commands/codeintel.js";
 import { registerCheckpointCommand } from "./commands/checkpoint.js";
 import { registerGoalCommand } from "./commands/goal.js";
 import { registerCommandCommand } from "./commands/command.js";
@@ -428,6 +431,8 @@ export function createProgram(opts = {}) {
   registerHubCommand(program);
   registerAndroidCommand(program);
   registerAgentCommand(program);
+  registerEvalCommand(program);
+  registerTeamCommand(program);
   registerSubAgentV2Command(program);
   registerExecBackendV2Command(program);
   registerTodoV2Command(program);
@@ -468,6 +473,7 @@ export function createProgram(opts = {}) {
   registerSessionCommand(program);
   registerCostCommand(program);
   registerContextCommand(program);
+  registerCodeIntelCommand(program);
   registerCheckpointCommand(program);
   registerGoalCommand(program);
   registerCommandCommand(program);

package/src/lib/__tests__/logger.test.js

@@ -70,9 +70,12 @@ describe("quiet mode", () => {
     expect(logSpy).not.toHaveBeenCalled();
   });
 
-  it("does NOT suppress warn (still console.log)", () => {
+  it("does NOT suppress warn (writes to console.error/stderr)", () => {
     warn("careful");
-    expect(logSpy).toHaveBeenCalledTimes(1);
+    // warn goes to stderr (not stdout) so it never pollutes machine-readable
+    // stdout like `--json`; still never suppressed by quiet mode.
+    expect(errSpy).toHaveBeenCalledTimes(1);
+    expect(logSpy).not.toHaveBeenCalled();
   });
 
   it("does NOT suppress error", () => {

package/src/lib/a2a-protocol.js

@@ -5,7 +5,6 @@
  * capability negotiation, and peer discovery.
  */
 
-
 // Safe JSON-array parse for values read back from the DB (capabilities / skills /
 // history / artifacts are stored as JSON strings). Written via JSON.stringify so
 // normally valid, but a corrupted or externally-edited DB must not crash agent
@@ -523,6 +522,31 @@ export function getCardStatusV2(cardId) {
   return _v2Cards.get(cardId)?.status || "active";
 }
 
+/**
+ * Hydrate the in-memory _v2Cards Map from the DB. The CLI is one-shot: _v2Cards
+ * starts empty every process, so getCardStatusV2 always fell back to "active"
+ * and setCardStatus validated transitions against a phantom "active" prev-state
+ * — even though setCardStatus dual-writes the real status to a2a_agent_cards
+ * (which `peers`/`discover` read correctly). Call after ensureA2ATables(db)
+ * before reading or transitioning a persisted card's status.
+ */
+export function loadCardsFromDb(db) {
+  if (!db) return 0;
+  ensureA2ATables(db);
+  _v2Cards.clear();
+  const rows = db
+    .prepare(`SELECT id, status, updated_at FROM a2a_agent_cards`)
+    .all();
+  for (const r of rows) {
+    _v2Cards.set(r.id, {
+      cardId: r.id,
+      status: r.status || "active",
+      updatedAt: r.updated_at,
+    });
+  }
+  return _v2Cards.size;
+}
+
 // ─── Task lifecycle V2 ───────────────────────────────────────────
 
 /**

package/src/lib/activitypub-bridge.js

@@ -62,6 +62,67 @@ export function ensureActivityPubTables(db) {
   `);
 }
 
+/**
+ * Rehydrate _actors/_activities/_follows from the persisted ap_actors/
+ * ap_activities/ap_follows tables. The `cc` CLI runs every command in a fresh
+ * process, so without this the Maps start empty and an actor created / note
+ * published / follow made in a prior invocation is invisible (`cc ap actor
+ * list`/`outbox`/`followers`/`search` return nothing, and read paths first hit
+ * _requireActor against the empty _actors → "Actor not found"). Call after
+ * ensureActivityPubTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _actors.clear();
+  _activities.clear();
+  _follows.clear();
+
+  const actorRows = db.prepare(`SELECT * FROM ap_actors`).all();
+  for (const row of actorRows) {
+    const id = row.id;
+    // Derived fields (type/preferredUsername/inbox/outbox/followers/following)
+    // are not persisted — reconstruct them from id exactly as createActor does.
+    _actors.set(id, {
+      id,
+      type: "Person",
+      username: row.username ?? null,
+      preferredUsername: row.username ?? null,
+      name: row.name ?? null,
+      summary: row.summary ?? null,
+      inbox: row.inbox_url ?? `${id}/inbox`,
+      outbox: row.outbox_url ?? `${id}/outbox`,
+      followers: `${id}/followers`,
+      following: `${id}/following`,
+      isLocal: !!row.is_local,
+      createdAt: row.created_at ?? null,
+    });
+  }
+
+  const activityRows = db.prepare(`SELECT * FROM ap_activities`).all();
+  for (const row of activityRows) {
+    let activity;
+    try {
+      activity = row.object_json ? JSON.parse(row.object_json) : null;
+    } catch {
+      activity = null;
+    }
+    if (!activity || !activity.id) continue; // can't reconstruct without it
+    _activities.set(activity.id, {
+      direction: row.direction,
+      ownerId: row.owner_id,
+      activity,
+    });
+  }
+
+  const followRows = db.prepare(`SELECT * FROM ap_follows`).all();
+  for (const row of followRows) {
+    const key = `${row.follower_id}|${row.followee_id}`;
+    _follows.set(key, { state: row.state, createdAt: row.created_at ?? null });
+  }
+
+  return _actors.size + _activities.size + _follows.size;
+}
+
 /* ── Helpers ───────────────────────────────────────────────── */
 
 function _now() {

package/src/lib/agent-core.js

@@ -28,6 +28,7 @@ export {
   listBackgroundShellTasks,
   killBackgroundShellTask,
   killAllBackgroundShellTasks,
+  killAllBackgroundShellTasksSync,
   reapIdleBackgroundShellTasks,
   _ingestSearchOutput,
   writeFileVerified,
@@ -42,4 +43,7 @@ export {
   _toAnthropicMessages,
   _anthropicThinkingParams,
   _normalizeAnthropicResponse,
+  _resetFileFreshness,
+  _getSharedCodeIntel,
+  disposeSharedCodeIntel,
 } from "../runtime/agent-core.js";

package/src/lib/agent-economy.js

@@ -109,34 +109,58 @@ export function getBalance(agentId) {
 }
 
 export function pay(db, fromAgent, toAgent, 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 fromBal = _getBalance(fromAgent);
   if (fromBal.balance < amount) {
     throw new Error(`Insufficient balance: ${fromBal.balance} < ${amount}`);
   }
 
-  fromBal.balance -= amount;
   const toBal = _getBalance(toAgent);
+
+  // The ledger row, the debit and the credit must all land or none of them.
+  // Without a transaction a mid-way failure would debit the sender without
+  // crediting the receiver (tokens vanish); the CLI re-hydrates from these
+  // tables, so the loss would persist.
+  const fromSnap = { balance: fromBal.balance, locked: fromBal.locked };
+  const toSnap = { balance: toBal.balance, locked: toBal.locked };
+
+  fromBal.balance -= amount;
   toBal.balance += amount;
 
   const txId = crypto.randomUUID();
   const now = new Date().toISOString();
 
-  db.prepare(
-    `INSERT INTO economy_transactions (id, from_agent, to_agent, amount, type, description, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`,
-  ).run(txId, fromAgent, toAgent, amount, "transfer", description || "", now);
+  const applyWrites = () => {
+    db.prepare(
+      `INSERT INTO economy_transactions (id, from_agent, to_agent, amount, type, description, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    ).run(txId, fromAgent, toAgent, amount, "transfer", description || "", now);
 
-  db.prepare(
-    `INSERT OR REPLACE INTO economy_balances (agent_id, balance, locked, updated_at)
-     VALUES (?, ?, ?, ?)`,
-  ).run(fromAgent, fromBal.balance, fromBal.locked, now);
+    db.prepare(
+      `INSERT OR REPLACE INTO economy_balances (agent_id, balance, locked, updated_at)
+       VALUES (?, ?, ?, ?)`,
+    ).run(fromAgent, fromBal.balance, fromBal.locked, now);
 
-  db.prepare(
-    `INSERT OR REPLACE INTO economy_balances (agent_id, balance, locked, updated_at)
-     VALUES (?, ?, ?, ?)`,
-  ).run(toAgent, toBal.balance, toBal.locked, now);
+    db.prepare(
+      `INSERT OR REPLACE INTO economy_balances (agent_id, balance, locked, updated_at)
+       VALUES (?, ?, ?, ?)`,
+    ).run(toAgent, toBal.balance, toBal.locked, now);
+  };
+
+  try {
+    if (db && typeof db.transaction === "function") {
+      db.transaction(applyWrites)();
+    } else {
+      applyWrites();
+    }
+  } catch (err) {
+    // Roll the in-memory balances back to match the rolled-back DB.
+    Object.assign(fromBal, fromSnap);
+    Object.assign(toBal, toSnap);
+    throw err;
+  }
 
   return {
     txId,
@@ -158,6 +182,7 @@ export function openChannel(db, partyA, partyB, depositA) {
     );
   }
 
+  const balSnap = { balance: balA.balance, locked: balA.locked };
   if (deposit > 0) {
     balA.balance -= deposit;
     balA.locked += deposit;
@@ -174,12 +199,35 @@ export function openChannel(db, partyA, partyB, depositA) {
     status: "open",
     createdAt: now,
   };
-  _channels.set(id, channel);
 
-  db.prepare(
-    `INSERT INTO economy_channels (id, party_a, party_b, balance_a, balance_b, status, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`,
-  ).run(id, partyA, partyB, deposit, 0, "open", now);
+  // Persist the channel row AND the deposit debit together. Persisting only the
+  // channel (as before) left the locked deposit still fully available in
+  // economy_balances after the next process re-hydrates — double-counted, so a
+  // party could lock a deposit and still spend the same funds via pay().
+  const applyWrites = () => {
+    db.prepare(
+      `INSERT INTO economy_channels (id, party_a, party_b, balance_a, balance_b, status, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    ).run(id, partyA, partyB, deposit, 0, "open", now);
+    if (deposit > 0) {
+      db.prepare(
+        `INSERT OR REPLACE INTO economy_balances (agent_id, balance, locked, updated_at)
+         VALUES (?, ?, ?, ?)`,
+      ).run(partyA, balA.balance, balA.locked, now);
+    }
+  };
+
+  try {
+    if (db && typeof db.transaction === "function") {
+      db.transaction(applyWrites)();
+    } else {
+      applyWrites();
+    }
+    _channels.set(id, channel);
+  } catch (err) {
+    Object.assign(balA, balSnap);
+    throw err;
+  }
 
   return channel;
 }
@@ -189,18 +237,49 @@ export function closeChannel(db, channelId) {
   if (!channel) throw new Error(`Channel not found: ${channelId}`);
   if (channel.status === "closed") throw new Error("Channel already closed");
 
-  channel.status = "closed";
-
-  // Settle: return balances to parties
   const balA = _getBalance(channel.partyA);
   const balB = _getBalance(channel.partyB);
+  const aSnap = { balance: balA.balance, locked: balA.locked };
+  const bSnap = { balance: balB.balance, locked: balB.locked };
+  const prevStatus = channel.status;
+
+  channel.status = "closed";
+  // Settle: return balances to parties.
   balA.balance += channel.balanceA;
   balA.locked = Math.max(0, balA.locked - channel.balanceA);
   balB.balance += channel.balanceB;
 
-  db.prepare(`UPDATE economy_channels SET status = 'closed' WHERE id = ?`).run(
-    channelId,
-  );
+  const now = new Date().toISOString();
+  // Persist the settled balances alongside the status flip. Previously only the
+  // channel status was written, so the returned deposit was lost on re-hydrate.
+  const persistBal = (agentId, bal) =>
+    db
+      .prepare(
+        `INSERT OR REPLACE INTO economy_balances (agent_id, balance, locked, updated_at)
+         VALUES (?, ?, ?, ?)`,
+      )
+      .run(agentId, bal.balance, bal.locked, now);
+
+  const applyWrites = () => {
+    db.prepare(
+      `UPDATE economy_channels SET status = 'closed' WHERE id = ?`,
+    ).run(channelId);
+    persistBal(channel.partyA, balA);
+    if (channel.partyB !== channel.partyA) persistBal(channel.partyB, balB);
+  };
+
+  try {
+    if (db && typeof db.transaction === "function") {
+      db.transaction(applyWrites)();
+    } else {
+      applyWrites();
+    }
+  } catch (err) {
+    Object.assign(balA, aSnap);
+    Object.assign(balB, bSnap);
+    channel.status = prevStatus;
+    throw err;
+  }
 
   return { ...channel };
 }
@@ -257,9 +336,11 @@ export function getMarketListings(filter) {
   return listings;
 }
 
-export function tradeResource(listingId, buyer, quantity) {
+export function tradeResource(db, listingId, buyer, quantity) {
   const listing = _market.get(listingId);
   if (!listing) throw new Error(`Listing not found: ${listingId}`);
+  if (!Number.isFinite(quantity) || quantity <= 0)
+    throw new Error("Quantity must be positive");
   if (listing.available < quantity) {
     throw new Error(
       `Insufficient availability: ${listing.available} < ${quantity}`,
@@ -272,13 +353,52 @@ export function tradeResource(listingId, buyer, quantity) {
     throw new Error(`Insufficient balance: ${buyerBal.balance} < ${cost}`);
   }
 
-  buyerBal.balance -= cost;
   const sellerBal = _getBalance(listing.provider);
+  const buyerSnap = { balance: buyerBal.balance, locked: buyerBal.locked };
+  const sellerSnap = { balance: sellerBal.balance, locked: sellerBal.locked };
+  const listingSnap = { available: listing.available, status: listing.status };
+
+  buyerBal.balance -= cost;
   sellerBal.balance += cost;
   listing.available -= quantity;
-
   if (listing.available <= 0) listing.status = "sold_out";
 
+  const now = new Date().toISOString();
+  // Persist the money movement and the listing depletion. Previously this
+  // mutated only the in-memory Maps (the fn took no db at all), so a trade
+  // reported success but never survived the next process re-hydrate — the
+  // buyer was never charged, the seller never paid, and the listing never
+  // depleted (unlimited free re-purchases). Sibling listResource/pay persist.
+  const persistBal = (agentId, bal) =>
+    db
+      .prepare(
+        `INSERT OR REPLACE INTO economy_balances (agent_id, balance, locked, updated_at)
+         VALUES (?, ?, ?, ?)`,
+      )
+      .run(agentId, bal.balance, bal.locked, now);
+
+  const applyWrites = () => {
+    persistBal(buyer, buyerBal);
+    if (listing.provider !== buyer) persistBal(listing.provider, sellerBal);
+    db.prepare(
+      `UPDATE economy_market SET available = ?, status = ? WHERE id = ?`,
+    ).run(listing.available, listing.status, listingId);
+  };
+
+  try {
+    if (db && typeof db.transaction === "function") {
+      db.transaction(applyWrites)();
+    } else if (db) {
+      applyWrites();
+    }
+  } catch (err) {
+    // Roll the in-memory Maps back to match the rolled-back DB.
+    Object.assign(buyerBal, buyerSnap);
+    Object.assign(sellerBal, sellerSnap);
+    Object.assign(listing, listingSnap);
+    throw err;
+  }
+
   return { listingId, buyer, quantity, cost, remaining: listing.available };
 }
 
@@ -332,7 +452,8 @@ export function getContributions(agentId) {
 export function distributeRevenue(db, pool, agentIds) {
   if (!agentIds || agentIds.length === 0)
     throw new Error("No agents specified");
-  if (pool <= 0) throw new Error("Pool must be positive");
+  if (!Number.isFinite(pool) || pool <= 0)
+    throw new Error("Pool must be positive");
 
   const share = pool / agentIds.length;
   const results = [];
@@ -364,6 +485,118 @@ export function _resetState() {
   _priceList.clear();
 }
 
+/**
+ * Rehydrate the DB-backed in-memory Maps from the economy_* tables. The CLI runs
+ * each `cc economy` subcommand in a fresh node process, so these module-level
+ * Maps start empty every invocation. Every write dual-writes (Map + INSERT into
+ * economy_balances/channels/market/nfts/contributions) but every read
+ * (getBalance/getMarketListings/closeChannel/tradeResource/getContributions) is
+ * Map-only and nothing SELECTed the tables back — so `balance` read back 0, and
+ * `channel close`/`trade` threw "not found" for rows that genuinely exist on
+ * disk. Call after ensureEconomyTables(db).
+ *
+ * `_priceList` has no table and stays in-memory (out of scope).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureEconomyTables(db);
+  _balances.clear();
+  _channels.clear();
+  _market.clear();
+  _nfts.clear();
+  _contributions.clear();
+
+  for (const r of db
+    .prepare(`SELECT agent_id, balance, locked FROM economy_balances`)
+    .all()) {
+    _balances.set(r.agent_id, {
+      balance: Number(r.balance) || 0,
+      locked: Number(r.locked) || 0,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, party_a, party_b, balance_a, balance_b, status, created_at
+         FROM economy_channels ORDER BY created_at ASC`,
+    )
+    .all()) {
+    _channels.set(r.id, {
+      id: r.id,
+      partyA: r.party_a,
+      partyB: r.party_b,
+      balanceA: Number(r.balance_a) || 0,
+      balanceB: Number(r.balance_b) || 0,
+      status: r.status,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, resource_type, provider, price, available, unit, status, created_at
+         FROM economy_market ORDER BY created_at ASC`,
+    )
+    .all()) {
+    _market.set(r.id, {
+      id: r.id,
+      resourceType: r.resource_type,
+      provider: r.provider,
+      price: Number(r.price),
+      available: Number(r.available) || 0,
+      unit: r.unit || "unit",
+      status: r.status,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, owner, type, metadata, created_at FROM economy_nfts ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt metadata cell must not sink the whole NFT load.
+    let metadata = {};
+    try {
+      metadata = r.metadata ? JSON.parse(r.metadata) : {};
+    } catch {
+      metadata = {};
+    }
+    _nfts.set(r.id, {
+      id: r.id,
+      owner: r.owner,
+      type: r.type,
+      metadata,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, agent_id, type, value, proof, created_at
+         FROM economy_contributions ORDER BY created_at ASC`,
+    )
+    .all()) {
+    if (!_contributions.has(r.agent_id)) _contributions.set(r.agent_id, []);
+    _contributions.get(r.agent_id).push({
+      id: r.id,
+      agentId: r.agent_id,
+      type: r.type,
+      value: Number(r.value) || 0,
+      proof: r.proof || "",
+      createdAt: r.created_at,
+    });
+  }
+
+  return (
+    _balances.size +
+    _channels.size +
+    _market.size +
+    _nfts.size +
+    _contributions.size
+  );
+}
+
 export function _setBalance(agentId, balance, locked) {
   _balances.set(agentId, { balance, locked: locked || 0 });
 }