chainlesschain 0.162.149 → 0.162.151

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

package/src/lib/agent-network.js

@@ -966,7 +966,13 @@ export function updateReputation(
     throw new Error(
       `Invalid dimension: ${dimension}. Expected one of ${REPUTATION_DIMENSIONS.join(",")}`,
     );
-  const s = Math.max(MIN_REPUTATION, Math.min(MAX_REPUTATION, Number(score)));
+  // Reject non-finite scores: Math.max/min pass NaN straight through, so a
+  // non-numeric CLI arg (Number("abc") → NaN) would persist NaN (→ NULL) and
+  // corrupt every getReputation average + routeTask agent scoring.
+  const numericScore = Number(score);
+  if (!Number.isFinite(numericScore))
+    throw new Error("score must be a finite number");
+  const s = Math.max(MIN_REPUTATION, Math.min(MAX_REPUTATION, numericScore));
   const id = `rep:${_uuid()}`;
   const now = _now();
   db.prepare(

package/src/lib/agent-team/team-runner.js

@@ -217,9 +217,10 @@ export class TeamRunner {
         mailbox: this.mailbox,
         budget: this.budget,
       });
-      this.registry.complete(key, { holder, result });
-      // Fold usage/cost into the team budget. `--exec` shell tasks carry no
-      // usage → only the task-count / wall-clock dimensions move.
+      const done = this.registry.complete(key, { holder, result });
+      // Fold usage/cost into the team budget regardless — the task DID execute
+      // and consumed resources. `--exec` shell tasks carry no usage → only the
+      // task-count / wall-clock dimensions move.
       if (this.budget) {
         this.budget.record(
           {
@@ -230,12 +231,27 @@ export class TeamRunner {
           this._now(),
         );
       }
-      this._setState(holder, "completed-task");
-      this._emit("task:completed", {
-        key,
-        holder,
-        ms: this._now() - startedAt,
-      });
+      if (done.ok) {
+        this._setState(holder, "completed-task");
+        this._emit("task:completed", {
+          key,
+          holder,
+          ms: this._now() - startedAt,
+        });
+      } else {
+        // The registry REJECTED the completion — the lease expired mid-run (the
+        // task outran its TTL without renewing), so a peer may already own it.
+        // Reporting `task:completed` + bumping the completed counter here would
+        // be a phantom success (the registry has no record of it, and the task
+        // will be reclaimed and re-run). Surface the discard honestly instead so
+        // the event stream and per-teammate stats stay truthful.
+        this._emit("task:completion-discarded", {
+          key,
+          holder,
+          reason: done.reason,
+          ms: this._now() - startedAt,
+        });
+      }
     } catch (err) {
       // A failed task still consumed a task-count slot (and any wall-clock) — fold
       // it so a doomed retry loop can't dodge the budget.

package/src/lib/agent-team/team-worktree.js

@@ -96,6 +96,24 @@ export class TeamWorktreeCoordinator {
   makeRunTask({ runInWorktree = null } = {}) {
     return async ({ key, task, holder }) => {
       const branch = this.branchFor(key);
+      // A retry (the prior attempt failed and TaskLeaseRegistry re-queued the
+      // task) would collide with its own leftover worktree: createWorktree
+      // derives a DETERMINISTIC path from the branch and throws "Worktree
+      // already exists" (and `worktree add -b` rejects the existing branch), so
+      // the retry can never recover — it just re-fails on the collision instead
+      // of the real task. Tear down the prior attempt's worktree + branch first
+      // so a retry starts clean.
+      const prior = this._created.get(key);
+      if (prior) {
+        try {
+          _deps.removeWorktree(this.repoDir, prior.path, {
+            deleteBranch: true,
+          });
+        } catch {
+          /* best-effort — a real problem will resurface in createWorktree */
+        }
+        this._created.delete(key);
+      }
       const { path: worktreePath } = _deps.createWorktree(this.repoDir, branch);
       this._created.set(key, { branch, path: worktreePath, committed: false });
       if (typeof runInWorktree === "function") {
@@ -157,20 +175,34 @@ export class TeamWorktreeCoordinator {
       const conflicts = preview?.conflicts || [];
       let merged = false;
       if (clean && merge) {
+        // mergeWorktree does NOT throw on a failed merge — it catches internally
+        // and RETURNS {success:false, conflicts?, message} (a conflict the clean
+        // preview didn't predict, or any non-conflict git failure). The old
+        // try/catch was dead for that path and set merged:true unconditionally,
+        // reporting a real merge failure as success with empty conflicts. Inspect
+        // the return value. (The try still catches assertSafeGitRef, the only
+        // throw path — a malformed branch ref.)
+        let mergeResult;
         try {
-          _deps.mergeWorktree(this.repoDir, info.branch, {
+          mergeResult = _deps.mergeWorktree(this.repoDir, info.branch, {
             message: `Merge team task ${key}`,
           });
-          merged = true;
         } catch (err) {
+          mergeResult = { success: false, message: err.message };
+        }
+        if (mergeResult?.success === true) {
+          merged = true;
+        } else {
           results.push({
             key,
             branch: info.branch,
             committed: true,
             clean: false,
             merged: false,
-            conflicts,
-            error: `merge failed: ${err.message}`,
+            conflicts: mergeResult?.conflicts?.length
+              ? mergeResult.conflicts
+              : conflicts,
+            error: `merge failed: ${mergeResult?.message || "unknown error"}`,
           });
           continue;
         }