chainlesschain 0.162.149 → 0.162.150

package/src/harness/remote-command-ledger.js

@@ -28,6 +28,7 @@ export class RemoteCommandLedger {
     this._order = []; // applyIndex → commandId (total order)
     this._revoked = new Set(revokedDevices);
     this._perDeviceSeq = new Map(); // deviceId → highest accepted seq
+    this._inFlight = new Map(); // commandId → Promise<record> for an in-progress apply
   }
 
   isRevoked(deviceId) {
@@ -73,6 +74,28 @@ export class RemoteCommandLedger {
       };
     }
 
+    // Coalesce CONCURRENT deliveries of the same commandId. `execute` is awaited
+    // below, so without this a second delivery arriving while the first is still
+    // running would ALSO pass the `prior` check (nothing is recorded until
+    // execute resolves) and run the side effect a SECOND time — the exact
+    // double-exec this ledger exists to prevent on reconnect. An already-in-flight
+    // same-commandId delivery waits for it and returns its result as `replayed`.
+    const inflight = this._inFlight.get(commandId);
+    if (inflight) {
+      try {
+        const rec = await inflight;
+        return {
+          status: "replayed",
+          result: rec.result,
+          applyIndex: rec.applyIndex,
+        };
+      } catch {
+        // The in-flight execution failed → it recorded nothing and is retryable;
+        // report rejection to this caller too (it can retry the same commandId).
+        return { status: "rejected", reason: "concurrent execution failed" };
+      }
+    }
+
     // Optional per-device monotonic sequence check: a STALE seq (below what we've
     // already accepted from this device) with a NEW commandId is a protocol
     // violation (a genuine reconnect resends the SAME commandId, caught above).
@@ -85,28 +108,36 @@ export class RemoteCommandLedger {
       return { status: "rejected", reason: "stale sequence" };
     }
 
-    let result;
+    // Reserve the commandId BEFORE the first await so a concurrent same-id
+    // delivery (above) sees it in flight. The promise records the applied result
+    // on success and rejects on failure (so a retry can re-run the side effect).
+    const runPromise = (async () => {
+      const result = await execute(command);
+      const applyIndex = this._order.length;
+      const rec = { applyIndex, result, deviceId, ts: this._now() };
+      this._applied.set(commandId, rec);
+      this._order.push(commandId);
+      if (deviceId != null && Number.isFinite(command.seq)) {
+        this._perDeviceSeq.set(deviceId, command.seq);
+      }
+      return rec;
+    })();
+    this._inFlight.set(commandId, runPromise);
     try {
-      result = await execute(command);
+      const rec = await runPromise;
+      return {
+        status: "applied",
+        result: rec.result,
+        applyIndex: rec.applyIndex,
+      };
     } catch (err) {
       // A failed execution is NOT recorded as applied — the command may be
       // retried (with the same commandId) and will run again. Surfacing the
       // error lets the caller decide; idempotency only protects SUCCESSES.
       return { status: "rejected", reason: `execute failed: ${err.message}` };
+    } finally {
+      this._inFlight.delete(commandId);
     }
-
-    const applyIndex = this._order.length;
-    this._applied.set(commandId, {
-      applyIndex,
-      result,
-      deviceId,
-      ts: this._now(),
-    });
-    this._order.push(commandId);
-    if (deviceId != null && Number.isFinite(command.seq)) {
-      this._perDeviceSeq.set(deviceId, command.seq);
-    }
-    return { status: "applied", result, applyIndex };
   }
 
   /**

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/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,
@@ -43,5 +44,6 @@ export {
   _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 });
 }

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(