@unicitylabs/sphere-sdk 0.14.0-dev.5 → 0.14.0-dev.7

package/dist/core/index.js

@@ -10584,14 +10584,14 @@ var IntentResume = class {
     }
     let changeOutput = null;
     if (payload.split) {
-      const splitOpIndex = payload.direct.length;
+      const splitOpIndex2 = payload.direct.length;
       let splitDelivered = false;
       {
         const source = await engine.decodeToken(await provider.getToken(payload.split.tokenId));
         const outcome = await this.host.certifyOperation(
           {
             kind: "split",
-            opIndex: splitOpIndex,
+            opIndex: splitOpIndex2,
             uiTokenId: `v2_${payload.split.tokenId}`,
             genesisId: payload.split.tokenId,
             sourceSdkData: "",
@@ -20699,6 +20699,7 @@ var AccountingModule = class _AccountingModule {
     const unsubHistory = deps.on(
       "history:updated",
       (entry) => {
+        if (!("dedupKey" in entry)) return;
         this._handleHistoryUpdated(entry).catch((err) => {
           logger.warn(LOG_TAG2, "Error handling history:updated event:", err);
         });
@@ -25968,7 +25969,10 @@ var STORE_KEYS = {
   shortfalls: "shortfalls",
   settlingLinks: "settling",
   streamCursor: (s) => `cursor:${s}`,
-  epochLatch: "epoch-latch"
+  epochLatch: "epoch-latch",
+  // §5.2 InventoryView durable overlays (#625/#679).
+  suspectedSpent: "suspected-spent",
+  knownSpends: "known-spends"
 };
 
 // modules/payments-v2/machine/journal.ts
@@ -25991,6 +25995,10 @@ function isValidationReject(err) {
   if (e === null) return false;
   return e.status === 422 || e.statusCode === 422 || e.code === "VALIDATION" || e.code === "VALIDATION_FAILED";
 }
+function retryAfterMsOf(err) {
+  const retryAfter = err !== null && typeof err === "object" ? err.retryAfter : void 0;
+  return typeof retryAfter === "number" && Number.isFinite(retryAfter) && retryAfter >= 0 ? retryAfter : null;
+}
 var chainRegistry = /* @__PURE__ */ new WeakMap();
 var replayRegistry = /* @__PURE__ */ new WeakMap();
 function registryFor(registry, kv, storeKey, make) {
@@ -26214,7 +26222,7 @@ var TransferMachine = class {
     }
     if (cls === null) {
       await this.applyCommitted(engine, plan.transferId, committed);
-      this.closeTail(plan.transferId, plan.payload);
+      this.closeTail(engine, plan.transferId, plan.payload, committed);
       return { committed, deliveryPending };
     }
     if (cls === "conflict" && committed.length > 0) {
@@ -26240,10 +26248,10 @@ var TransferMachine = class {
     }
     await this.applyCommitted(engine, r.transferId, committed);
     if (conflicts.length > 0) {
-      return { deliveryPending, partial: await this.settlePartial(r, committed, conflicts) };
+      return { deliveryPending, partial: await this.settlePartial(engine, r, committed, conflicts) };
     }
     await this.completeIntent(r.transferId, r.payload);
-    await this.finishBookkeeping(r.transferId, r.payload, "resumed");
+    await this.finishBookkeeping(engine, r.transferId, r.payload, "resumed", committed);
     return { deliveryPending, partial: null };
   }
   // ── shared transitions ─────────────────────────────────────────────────────
@@ -26425,7 +26433,7 @@ var TransferMachine = class {
     }
     return added;
   }
-  async settlePartial(r, committed, conflicts) {
+  async settlePartial(engine, r, committed, conflicts) {
     const undelivered = conflicts.reduce((sum, c) => sum + c.amount, 0n);
     const entry = {
       transferId: r.transferId,
@@ -26437,26 +26445,27 @@ var TransferMachine = class {
     };
     await this.stores.shortfalls.upsert(entry);
     await this.completeIntent(r.transferId, r.payload);
-    await this.finishBookkeeping(r.transferId, r.payload, "resumed");
+    await this.finishBookkeeping(engine, r.transferId, r.payload, "resumed", committed);
     return entry;
   }
-  closeTail(transferId, payload) {
+  closeTail(engine, transferId, payload, committed) {
     void (async () => {
       try {
         await this.completeIntent(transferId, payload);
       } catch {
         return;
       }
-      await this.finishBookkeeping(transferId, payload, "sent");
+      await this.finishBookkeeping(engine, transferId, payload, "sent", committed);
     })();
   }
   async completeIntent(transferId, payload) {
     const signature = payload.split !== void 0 ? await this.deps.signComplete(transferId) : void 0;
     await this.deps.intents.complete(transferId, signature);
   }
-  async finishBookkeeping(transferId, payload, phase) {
+  async finishBookkeeping(engine, transferId, payload, phase, committed) {
     try {
-      await this.deps.recordHistory?.({ transferId, payload, phase });
+      const committedAmount = await this.settledAmount(engine, payload.coinId, committed);
+      await this.deps.recordHistory?.({ transferId, payload, phase, committedAmount });
     } catch {
     }
     try {
@@ -26464,6 +26473,26 @@ var TransferMachine = class {
     } catch {
     }
   }
+  /**
+   * §5.9: SENT history records what SETTLED, never the plan — the value of the
+   * certified recipient blobs (summarize()'s committed set is the only source;
+   * a journal-rehydrated resume leg has no source token, but every committed
+   * leg carries its recipient blob, so the outcome-derived rule is uniform).
+   */
+  async settledAmount(engine, coinId, committed) {
+    let total = 0n;
+    for (const outcome of committed) {
+      if (outcome.recipientBlob === void 0) continue;
+      const token = await engine.decodeToken({
+        v: TOKEN_BLOB_VERSION,
+        network: 0,
+        tokenId: "",
+        token: outcome.recipientBlob
+      });
+      total += engine.balanceOf(token, coinId);
+    }
+    return total.toString();
+  }
   async disposeOnFailure(transferId, committed, cls) {
     if (committed.length > 0 || cls === "keep-open") return;
     try {
@@ -26488,7 +26517,7 @@ function conflictAmount(engine, payload, op, source) {
 }
 
 // modules/payments-v2/machine/resume.ts
-async function resumeAll(deps) {
+async function resumeAll(deps, options = {}) {
   const report = { resumed: [], conflicted: [], failed: [] };
   const stores = createMachineStores(deps.kv);
   const open = await deps.intents.listOpen();
@@ -26498,7 +26527,12 @@ async function resumeAll(deps) {
   } catch {
     return report;
   }
-  await dropStaleLocalAborts(stores, locals, new Set(open.map((i) => i.transferId)));
+  await dropStaleBackstops(
+    stores,
+    locals,
+    new Set(open.map((i) => i.transferId)),
+    options.isLocallyActive ?? (() => false)
+  );
   const jobs = await gateAndDecode(deps, stores, open, locals, report);
   const ctx = {
     deps,
@@ -26511,11 +26545,16 @@ async function resumeAll(deps) {
   }
   return report;
 }
-async function dropStaleLocalAborts(stores, locals, openIds) {
+async function dropStaleBackstops(stores, locals, openIds, isLocallyActive) {
   for (const entry of locals.values()) {
-    if (entry.disposition !== "open" && !openIds.has(entry.transferId)) {
+    if (openIds.has(entry.transferId)) continue;
+    if (entry.disposition !== "open") {
       await stores.backstop.removeByKey(entry.transferId);
+      continue;
     }
+    if (isLocallyActive(entry.transferId)) continue;
+    if ((await stores.deliveryJournal.byTransfer(entry.transferId)).size > 0) continue;
+    await stores.backstop.removeByKey(entry.transferId);
   }
 }
 async function gateAndDecode(deps, stores, open, locals, report) {
@@ -26628,6 +26667,349 @@ function validatePayload(raw) {
   return p;
 }
 
+// modules/payments-v2/convergence.ts
+var HEARTBEAT_SEED_MS = 5e3;
+var HEARTBEAT_CAP_MS = 12e4;
+var ConvergenceHeartbeat = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  timer = null;
+  delayMs = HEARTBEAT_SEED_MS;
+  notBefore = 0;
+  running = false;
+  start() {
+    this.running = true;
+    this.delayMs = HEARTBEAT_SEED_MS;
+    this.notBefore = 0;
+  }
+  /** §7 quiescence unchanged: a mid-backoff stop() cancels cleanly. */
+  stop() {
+    this.running = false;
+    this.clearTimer();
+  }
+  /** Reset to seed on progress, ×2 to the cap otherwise; idle stops rescheduling. */
+  settle(outcome, pending) {
+    if (outcome.retryAfterMs !== null) {
+      this.notBefore = Math.max(this.notBefore, this.deps.now() + outcome.retryAfterMs);
+    }
+    if (!pending) {
+      this.delayMs = HEARTBEAT_SEED_MS;
+      return;
+    }
+    const delay = outcome.progress ? HEARTBEAT_SEED_MS : this.delayMs;
+    this.delayMs = Math.min(delay * 2, HEARTBEAT_CAP_MS);
+    this.schedule(delay);
+  }
+  /** New pending work (keep-open park / journaled delivery / mint hold): prompt retry. */
+  arm() {
+    if (!this.running) return;
+    this.delayMs = Math.min(HEARTBEAT_SEED_MS * 2, HEARTBEAT_CAP_MS);
+    this.schedule(HEARTBEAT_SEED_MS);
+  }
+  /** connection:status recovery: the backoff resets; a pending tick re-fires at the seed. */
+  recovered() {
+    this.delayMs = HEARTBEAT_SEED_MS;
+    if (this.timer !== null) this.arm();
+  }
+  schedule(delayMs) {
+    this.clearTimer();
+    if (!this.running) return;
+    const floored = Math.max(delayMs, this.notBefore - this.deps.now());
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.deps.onTick();
+    }, floored);
+  }
+  clearTimer() {
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+  }
+};
+var Converger = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /** Resume open intents, then drain the delivery + mint journals (all idempotent). */
+  async convergeOnce() {
+    let progress = false;
+    let retryAfterMs = null;
+    try {
+      progress = await this.resumePass();
+    } catch (err) {
+      retryAfterMs = retryAfterMsOf(err);
+    }
+    try {
+      const stats = await this.deps.stores.deliveryJournal.replay(this.replayDeps());
+      progress = progress || stats.delivered > 0;
+    } catch (err) {
+      retryAfterMs ??= retryAfterMsOf(err);
+    }
+    try {
+      progress = await this.deps.replayMints() > 0 || progress;
+    } catch (err) {
+      retryAfterMs ??= retryAfterMsOf(err);
+    }
+    return { progress, retryAfterMs };
+  }
+  /** §4 heartbeat predicate — read fresh from the §6 stores, never cached. */
+  async pendingWork() {
+    const [backstop, journal, mints] = await Promise.all([
+      this.deps.stores.backstop.list(),
+      this.deps.stores.deliveryJournal.list(),
+      this.deps.stores.mintJournal.list()
+    ]);
+    return backstop.length > 0 || journal.some((e) => e.undeliverable !== true) || mints.length > 0;
+  }
+  async resumePass() {
+    const report = await resumeAll(this.filteredMachineDeps(), {
+      isLocallyActive: (id) => this.deps.isActiveOp(id)
+    });
+    const progress = report.resumed.length > 0 || report.conflicted.length > 0;
+    await this.deps.reconcile({
+      resumed: report.resumed,
+      conflicted: report.conflicted,
+      open: report.failed
+    });
+    if (progress) await this.deps.refreshView().catch(() => void 0);
+    return progress;
+  }
+  filteredMachineDeps() {
+    const intents = this.deps.machineDeps.intents;
+    return {
+      ...this.deps.machineDeps,
+      intents: {
+        ...intents,
+        listOpen: async () => (await intents.listOpen()).filter((intent) => !this.deps.isActiveOp(intent.transferId))
+      }
+    };
+  }
+  replayDeps() {
+    return {
+      delivery: this.deps.delivery,
+      now: () => this.deps.now(),
+      attention: (transferId, code, detail) => {
+        this.deps.emit(
+          "transfer:attention",
+          detail === void 0 ? { transferId, code } : { transferId, code, detail }
+        );
+      }
+    };
+  }
+};
+async function derivePendingTransfers(stores, decryptPayload) {
+  const [backstop, journal, shortfalls] = await Promise.all([
+    stores.backstop.list(),
+    stores.deliveryJournal.list(),
+    stores.shortfalls.list()
+  ]);
+  const byTransfer = groupJournal(journal);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of backstop) {
+    if (entry.disposition !== "open") continue;
+    seen.add(entry.transferId);
+    out.push(await openRow(entry, byTransfer.get(entry.transferId) ?? [], decryptPayload));
+  }
+  for (const [transferId, entries] of byTransfer) {
+    if (seen.has(transferId)) continue;
+    seen.add(transferId);
+    out.push(journalOnlyRow(transferId, entries));
+  }
+  for (const entry of shortfalls) {
+    if (!seen.has(entry.transferId)) out.push(shortfallRow(entry));
+  }
+  return out;
+}
+function groupJournal(journal) {
+  const byTransfer = /* @__PURE__ */ new Map();
+  for (const entry of journal) {
+    const mine = byTransfer.get(entry.transferId);
+    if (mine === void 0) byTransfer.set(entry.transferId, [entry]);
+    else mine.push(entry);
+  }
+  return byTransfer;
+}
+async function openRow(entry, journal, decryptPayload) {
+  let payload = null;
+  try {
+    const raw = await decryptPayload(entry.payloadEnvelope);
+    if (raw !== null && typeof raw === "object") payload = raw;
+  } catch {
+    payload = null;
+  }
+  const total = Array.isArray(payload?.direct) ? payload.direct.length + (payload.split !== void 0 ? 1 : 0) : 0;
+  const certified = distinctOpCount(journal);
+  return {
+    transferId: entry.transferId,
+    kind: "open",
+    recipient: typeof payload?.recipient === "string" ? payload.recipient : "",
+    coinId: typeof payload?.coinId === "string" ? payload.coinId : "",
+    amount: typeof payload?.amount === "string" ? payload.amount : "",
+    legs: { certified, total: Math.max(total, certified) },
+    deliveryPending: journal.length > 0,
+    createdAt: entry.createdAt
+  };
+}
+function journalOnlyRow(transferId, entries) {
+  const certified = distinctOpCount(entries);
+  return {
+    transferId,
+    kind: "open",
+    recipient: entries[0].recipientPubkey,
+    coinId: "",
+    amount: "",
+    legs: { certified, total: certified },
+    deliveryPending: true,
+    createdAt: 0
+  };
+}
+function shortfallRow(entry) {
+  return {
+    transferId: entry.transferId,
+    kind: "shortfall",
+    recipient: entry.recipient,
+    coinId: entry.coinId,
+    amount: entry.remainingAmount,
+    legs: { certified: entry.committedTokenIds.length, total: entry.committedTokenIds.length },
+    deliveryPending: false,
+    createdAt: entry.createdAt
+  };
+}
+function distinctOpCount(entries) {
+  return new Set(entries.map((entry) => entry.opIndex)).size;
+}
+
+// modules/payments-v2/restore.ts
+var ATTENTION_RESEED_REJECTED = "intent:reseed-rejected";
+var ALL_STREAMS = ["inventory", "mailbox", "payment_requests", "history"];
+async function reseedAndReset(deps) {
+  for (const entry of await deps.stores.backstop.list()) {
+    if (entry.disposition !== "open") continue;
+    try {
+      await deps.reput(entry.transferId, entry.payloadEnvelope, entry.requiresSeedClose);
+      if (entry.requiresSeedClose) {
+        await deps.reseedCheckpoint(entry.transferId, await splitOpIndex(deps, entry.payloadEnvelope));
+      }
+    } catch (err) {
+      deps.attention(entry.transferId, ATTENTION_RESEED_REJECTED, err instanceof Error ? err.message : String(err));
+    }
+  }
+  for (const stream of ALL_STREAMS) await deps.kv.remove(STORE_KEYS.streamCursor(stream));
+  await deps.fullRePull();
+}
+async function splitOpIndex(deps, envelope) {
+  const payload = await deps.decryptPayload(envelope);
+  return Array.isArray(payload.direct) ? payload.direct.length : 0;
+}
+
+// modules/payments-v2/inventory/presentation.ts
+function toToken(tokenId, snapshot, asset, registry, flags) {
+  const iconUrl = registry.getIconUrl(asset.coinId);
+  return {
+    id: tokenId,
+    coinId: asset.coinId,
+    symbol: registry.getSymbol(asset.coinId),
+    name: registry.getName(asset.coinId),
+    decimals: registry.getDecimals(asset.coinId),
+    ...iconUrl !== null ? { iconUrl } : {},
+    amount: asset.amount,
+    status: flags.transferring ? "transferring" : "confirmed",
+    createdAt: snapshot.createdAt,
+    updatedAt: snapshot.updatedAt,
+    lazy: true,
+    ...flags.suspectedSpent ? { suspectedSpent: true } : {}
+  };
+}
+function aggregateAssets(entries, isTransferring, registry) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [tokenId, entry] of entries) {
+    const moving = isTransferring(tokenId);
+    for (const asset of entry.assets) {
+      let group = groups.get(asset.coinId);
+      if (!group) {
+        group = { total: 0n, count: 0, transferring: 0n, transferringCount: 0 };
+        groups.set(asset.coinId, group);
+      }
+      if (moving) {
+        group.transferring += BigInt(asset.amount);
+        group.transferringCount += 1;
+      } else {
+        group.total += BigInt(asset.amount);
+        group.count += 1;
+      }
+    }
+  }
+  return [...groups].map(([coinId, totals]) => toAsset(coinId, totals, registry));
+}
+function toAsset(coinId, totals, registry) {
+  const iconUrl = registry.getIconUrl(coinId);
+  return {
+    coinId,
+    symbol: registry.getSymbol(coinId),
+    name: registry.getName(coinId),
+    decimals: registry.getDecimals(coinId),
+    ...iconUrl !== null ? { iconUrl } : {},
+    totalAmount: totals.total.toString(),
+    tokenCount: totals.count,
+    confirmedAmount: totals.total.toString(),
+    unconfirmedAmount: "0",
+    confirmedTokenCount: totals.count,
+    unconfirmedTokenCount: 0,
+    transferringTokenCount: totals.transferringCount,
+    transferringAmount: totals.transferring.toString(),
+    priceUsd: null,
+    priceEur: null,
+    change24h: null,
+    fiatValueUsd: null,
+    fiatValueEur: null
+  };
+}
+async function withPrices(raw, registry, price) {
+  try {
+    const names = [...new Set(raw.map((a) => registry.getName(a.coinId)))];
+    const quotes = await price.getPrices(names);
+    return raw.map((a) => priceOne(a, quotes.get(registry.getName(a.coinId))));
+  } catch {
+    return raw;
+  }
+}
+function priceOne(asset, quote) {
+  if (!quote) return asset;
+  const human = Number(asset.totalAmount) / Math.pow(10, asset.decimals);
+  return {
+    ...asset,
+    priceUsd: quote.priceUsd,
+    priceEur: quote.priceEur ?? null,
+    change24h: quote.change24h ?? null,
+    fiatValueUsd: human * quote.priceUsd,
+    fiatValueEur: quote.priceEur != null ? human * quote.priceEur : null
+  };
+}
+
+// modules/payments-v2/machine/payload.ts
+function buildPayload(recipientPubkey, request, spend, spentStates) {
+  return {
+    v: 2,
+    recipient: recipientPubkey,
+    coinId: request.coinId,
+    amount: request.amount,
+    ...request.memo !== void 0 ? { memo: request.memo } : {},
+    direct: [...spend.plan.direct],
+    ...spend.plan.split !== void 0 ? {
+      split: {
+        tokenId: spend.plan.split.tokenId,
+        splitAmount: spend.plan.split.splitAmount.toString(),
+        remainderAmount: spend.plan.split.remainderAmount.toString()
+      }
+    } : {},
+    spentStates
+  };
+}
+function messageOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
 // modules/payments-v2/history/History.ts
 var WIRE_TOKEN_ID = /^(?:[0-9a-f]{2}){1,64}$/;
 var WIRE_PUBKEY = /^0[23][0-9a-f]{64}$/;
@@ -26686,13 +27068,14 @@ var History = class {
   }
   // ── internals ────────────────────────────────────────────────────────────────
   async post(build) {
+    const record = build();
     try {
-      await this.deps.client.postHistory([build()]);
+      await this.deps.client.postHistory([record]);
     } catch (err) {
       this.deps.log?.("history POST failed (dedupKey makes retry safe)", err);
       return;
     }
-    this.deps.emit("history:updated");
+    this.deps.emit("history:updated", this.toEntry(record));
   }
   ts(timestamp) {
     return new Date(timestamp ?? (this.deps.now ?? Date.now)()).toISOString();
@@ -26749,93 +27132,9 @@ var History = class {
   }
 };
 
-// modules/payments-v2/inventory/presentation.ts
-function toToken(tokenId, snapshot, asset, registry, flags) {
-  const iconUrl = registry.getIconUrl(asset.coinId);
-  return {
-    id: tokenId,
-    coinId: asset.coinId,
-    symbol: registry.getSymbol(asset.coinId),
-    name: registry.getName(asset.coinId),
-    decimals: registry.getDecimals(asset.coinId),
-    ...iconUrl !== null ? { iconUrl } : {},
-    amount: asset.amount,
-    status: flags.transferring ? "transferring" : "confirmed",
-    createdAt: snapshot.createdAt,
-    updatedAt: snapshot.updatedAt,
-    lazy: true,
-    ...flags.suspectedSpent ? { suspectedSpent: true } : {}
-  };
-}
-function aggregateAssets(entries, isTransferring, registry) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [tokenId, entry] of entries) {
-    const moving = isTransferring(tokenId);
-    for (const asset of entry.assets) {
-      let group = groups.get(asset.coinId);
-      if (!group) {
-        group = { total: 0n, count: 0, transferring: 0n, transferringCount: 0 };
-        groups.set(asset.coinId, group);
-      }
-      if (moving) {
-        group.transferring += BigInt(asset.amount);
-        group.transferringCount += 1;
-      } else {
-        group.total += BigInt(asset.amount);
-        group.count += 1;
-      }
-    }
-  }
-  return [...groups].map(([coinId, totals]) => toAsset(coinId, totals, registry));
-}
-function toAsset(coinId, totals, registry) {
-  const iconUrl = registry.getIconUrl(coinId);
-  return {
-    coinId,
-    symbol: registry.getSymbol(coinId),
-    name: registry.getName(coinId),
-    decimals: registry.getDecimals(coinId),
-    ...iconUrl !== null ? { iconUrl } : {},
-    totalAmount: totals.total.toString(),
-    tokenCount: totals.count,
-    confirmedAmount: totals.total.toString(),
-    unconfirmedAmount: "0",
-    confirmedTokenCount: totals.count,
-    unconfirmedTokenCount: 0,
-    transferringTokenCount: totals.transferringCount,
-    transferringAmount: totals.transferring.toString(),
-    priceUsd: null,
-    priceEur: null,
-    change24h: null,
-    fiatValueUsd: null,
-    fiatValueEur: null
-  };
-}
-async function withPrices(raw, registry, price) {
-  try {
-    const names = [...new Set(raw.map((a) => registry.getName(a.coinId)))];
-    const quotes = await price.getPrices(names);
-    return raw.map((a) => priceOne(a, quotes.get(registry.getName(a.coinId))));
-  } catch {
-    return raw;
-  }
-}
-function priceOne(asset, quote) {
-  if (!quote) return asset;
-  const human = Number(asset.totalAmount) / Math.pow(10, asset.decimals);
-  return {
-    ...asset,
-    priceUsd: quote.priceUsd,
-    priceEur: quote.priceEur ?? null,
-    change24h: quote.change24h ?? null,
-    fiatValueUsd: human * quote.priceUsd,
-    fiatValueEur: quote.priceEur != null ? human * quote.priceEur : null
-  };
-}
-
 // modules/payments-v2/inventory/InventoryView.ts
-var SUSPECTED_KEY = "suspected-spent";
-var KNOWN_SPENDS_KEY = "known-spends";
+var SUSPECTED_KEY = STORE_KEYS.suspectedSpent;
+var KNOWN_SPENDS_KEY = STORE_KEYS.knownSpends;
 var CURSOR_KEY = STORE_KEYS.streamCursor("inventory");
 function stateKey(tokenId, stateHash) {
   return `${tokenId}:${stateHash}`;
@@ -27139,19 +27438,24 @@ var Receive = class {
     const engine = deps.engine();
     const stored = [];
     const pending = [];
-    let epoch = "";
+    const pageEpoch = () => deps.delivery.incomingEpoch() ?? deps.syncEpoch();
     try {
-      epoch = deps.syncEpoch();
       const record = await deps.kv.get(STORE_KEYS.streamCursor("mailbox"));
-      const since = record !== null && record.syncEpoch === epoch ? String(record.cursor) : void 0;
-      for await (const entry of deps.delivery.incoming(since)) {
-        await this.processEntry(deps, engine, entry, pending, stored);
-        if (pending.length >= ACK_BATCH_SIZE) await flushAcks(deps, pending, epoch);
+      let basis = record !== null && record.syncEpoch === deps.syncEpoch() ? record : null;
+      for (let pass = 0; pass < 2; pass++) {
+        for await (const entry of deps.delivery.incoming(basis === null ? void 0 : String(basis.cursor))) {
+          await this.processEntry(deps, engine, entry, pending, stored);
+          if (pending.length >= ACK_BATCH_SIZE) await flushAcks(deps, pending, pageEpoch);
+        }
+        await flushAcks(deps, pending, pageEpoch);
+        const served = deps.delivery.incomingEpoch();
+        if (basis === null || served === null || served === basis.syncEpoch) break;
+        await deps.kv.remove(STORE_KEYS.streamCursor("mailbox"));
+        basis = null;
       }
-      await flushAcks(deps, pending, epoch);
     } catch (err) {
       logger.warn("PaymentsV2", "receive drain interrupted \u2014 unacked entries retry next drain:", err);
-      await flushAcks(deps, pending, epoch).catch((flushErr) => {
+      await flushAcks(deps, pending, pageEpoch).catch((flushErr) => {
         logger.warn("PaymentsV2", "receive ack flush failed \u2014 cursor holds at the acked prefix:", flushErr);
       });
     }
@@ -27224,7 +27528,7 @@ async function announce(deps, entry, record) {
     receivedAt
   };
 }
-async function flushAcks(deps, pending, epoch) {
+async function flushAcks(deps, pending, epochOf) {
   let lastAcked = null;
   try {
     while (pending.length > 0) {
@@ -27235,7 +27539,7 @@ async function flushAcks(deps, pending, epoch) {
     }
   } finally {
     if (lastAcked !== null) {
-      const record = { cursor: lastAcked, syncEpoch: epoch };
+      const record = { cursor: lastAcked, syncEpoch: epochOf() };
       await deps.kv.set(STORE_KEYS.streamCursor("mailbox"), record);
     }
   }
@@ -27336,9 +27640,19 @@ var Requests = class {
       }
     });
   }
+  /** Idempotent for a same-transferId re-write: committed only ratchets up, createdAt kept. */
   writeLink(requestId, transferId, committed) {
     return this.mutateJournal((m) => {
-      m.set(requestId, { requestId, transferId, committed, createdAt: this.now() });
+      const prev = m.get(requestId);
+      const same = prev !== void 0 && prev.transferId === transferId;
+      const next = {
+        requestId,
+        transferId,
+        committed: committed || same && prev.committed,
+        createdAt: same ? prev.createdAt : this.now()
+      };
+      if (same && prev.committed === next.committed) return false;
+      m.set(requestId, next);
       return true;
     });
   }
@@ -27491,23 +27805,46 @@ var Requests = class {
         const transferId = error instanceof SphereError && error.transferId !== void 0 ? error.transferId : void 0;
         if (transferId !== void 0) {
           const committed = error instanceof PartialSendConflictError;
-          await this.writeLink(id, transferId, committed);
-          this.setStatus(id, "settling");
+          await this.settle(id, transferId, { committed, respond: false });
         } else {
           logger.error("PaymentsV2", `possibly-committed send for ${id} carried no transferId \u2014 paid (fail-closed)`);
           this.setStatus(id, "paid");
         }
       } else {
-        await this.clearLink(id);
-        this.setStatus(id, "pending");
+        await this.revertPayable(id);
       }
       throw error;
     }
-    this.setStatus(id, "paid");
-    await this.respondPaid(id, result.id);
-    await this.clearLink(id);
+    await this.settle(id, result.id, { committed: true, respond: true });
     return result;
   }
+  /**
+   * THE settlement invariant (#441 + the failed-respond P1): a settling link is
+   * removed ONLY by (a) a CONFIRMED paid respond — a 2xx, or the 409
+   * already-resolved absorb — or (b) a proven clean pre-commit failure
+   * (revertPayable). Nothing else removes one: not a network error, not a 5xx,
+   * not a reload. Every path that binds a request to a transfer outcome funnels
+   * through here — pay()'s clean success (respond now), pay()'s
+   * possibly-committed throw (respond deferred), and reconcile's deferred arms
+   * — so a failed respond always leaves the link + 'settling' and the next
+   * reconcile pass (the committed-link override) retries the respond.
+   */
+  async settle(requestId, transferId, opts) {
+    let journalDown = false;
+    try {
+      await this.writeLink(requestId, transferId, opts.committed);
+    } catch (err) {
+      if (!opts.respond) throw err;
+      journalDown = true;
+      logger.error("PaymentsV2", `settling link write failed for ${requestId} \u2014 responding fail-closed:`, err);
+    }
+    if (!(opts.respond && await this.respondPaid(requestId, transferId))) {
+      this.setStatus(requestId, journalDown ? "paid" : "settling");
+      return;
+    }
+    if (!journalDown) await this.clearLink(requestId).catch(() => void 0);
+    this.setStatus(requestId, "paid");
+  }
   /** 'paid' respond leg: 409 = already resolved = idempotent success; other errors defer. */
   async respondPaid(id, transferId) {
     try {
@@ -27543,32 +27880,32 @@ var Requests = class {
     let aborted = null;
     for (const [requestId, link] of [...this.journal]) {
       if (link.committed || resumed.has(link.transferId)) {
-        await this.resolvePaid(requestId, link.transferId);
+        await this.resolvePaid(requestId, link);
       } else if (conflicted.has(link.transferId)) {
         await this.revertPayable(requestId);
       } else if (open.has(link.transferId)) {
       } else {
-        aborted = await this.reconcileUnaccounted(requestId, link.transferId, aborted);
+        aborted = await this.reconcileUnaccounted(requestId, link, aborted);
       }
     }
   }
   // Unaccounted link: consult the server aborted authority (lazy, memoized);
   // a probe failure defers the link to the next session.
-  async reconcileUnaccounted(requestId, transferId, aborted) {
+  async reconcileUnaccounted(requestId, link, aborted) {
     try {
       aborted ??= new Set(await this.deps.listAbortedTransferIds());
-      if (aborted.has(transferId)) await this.revertPayable(requestId);
-      else await this.resolvePaid(requestId, transferId);
+      if (aborted.has(link.transferId)) await this.revertPayable(requestId);
+      else await this.resolvePaid(requestId, link);
     } catch (err) {
       logger.warn("PaymentsV2", `aborted-intent probe failed \u2014 ${requestId} deferred:`, err);
     }
     return aborted;
   }
-  async resolvePaid(requestId, transferId) {
-    if (!await this.respondPaid(requestId, transferId)) return;
-    await this.clearLink(requestId);
-    this.setStatus(requestId, "paid");
+  /** Deferred paid: the ONE settlement path again — a failed respond keeps the link. */
+  resolvePaid(requestId, link) {
+    return this.settle(requestId, link.transferId, { committed: link.committed, respond: true });
   }
+  /** Removal cause (b): a PROVEN clean outcome (pre-commit failure / server-aborted). */
   async revertPayable(requestId) {
     await this.clearLink(requestId);
     this.setStatus(requestId, "pending");
@@ -27892,11 +28229,12 @@ function composeFacadeParts(deps, hooks) {
     client: deps.client,
     fieldKey: deps.fieldKey,
     registry: deps.registry,
-    emit: (event) => deps.emit(event, {}),
+    emit: (event, entry) => deps.emit(event, entry),
     ...deps.now !== void 0 ? { now: deps.now } : {},
     ...deps.newId !== void 0 ? { newId: deps.newId } : {}
   });
   const machineDeps = buildMachineDeps(deps, hooks, historyStore);
+  const machineStores = createMachineStores(deps.kv);
   const heldStates = /* @__PURE__ */ new Map();
   return {
     ownPubkeyBytes,
@@ -27904,12 +28242,29 @@ function composeFacadeParts(deps, hooks) {
     ledger,
     queue,
     historyStore,
-    machineStores: createMachineStores(deps.kv),
+    machineStores,
     machineDeps,
     machine: new TransferMachine(machineDeps),
     heldStates,
     receiveLoop: buildReceive(deps, hooks, historyStore, heldStates),
-    requests: buildRequests(deps, hooks)
+    requests: buildRequests(deps, hooks),
+    restoreDeps: buildRestoreDeps(deps, machineDeps, machineStores, view)
+  };
+}
+function buildRestoreDeps(deps, machineDeps, machineStores, view) {
+  return {
+    stores: machineStores,
+    kv: deps.kv,
+    reput: (transferId, envelope, requiresSeedClose) => machineDeps.intents.put(transferId, envelope, requiresSeedClose),
+    reseedCheckpoint: (transferId, opIndex) => deps.checkpointStore.reseedCheckpoint(transferId, opIndex),
+    decryptPayload: machineDeps.decryptPayload,
+    fullRePull: () => view.onEpochReset(),
+    attention: (transferId, code, detail) => {
+      deps.emit(
+        "transfer:attention",
+        detail === void 0 ? { transferId, code } : { transferId, code, detail }
+      );
+    }
   };
 }
 function buildMachineDeps(deps, hooks, historyStore) {
@@ -27931,11 +28286,13 @@ function buildMachineDeps(deps, hooks, historyStore) {
     ownPubkey: hexToBytes4(deps.ownPubkey),
     emit: deps.emit,
     now: deps.now ?? Date.now,
-    recordHistory: async ({ transferId, payload }) => {
+    recordHistory: async ({ transferId, payload, committedAmount }) => {
       await historyStore.recordSent({
         transferId,
         coinId: payload.coinId,
-        amount: payload.amount,
+        // §5.9: the SETTLED amount (machine-computed from the certified
+        // recipient blobs), never payload.amount — the plan.
+        amount: committedAmount,
         recipientPubkey: payload.recipient,
         ...payload.memo !== void 0 ? { memo: payload.memo } : {}
       });
@@ -27962,7 +28319,7 @@ function buildReceive(deps, hooks, historyStore, heldStates) {
         detail === void 0 ? { transferId, code } : { transferId, code, detail }
       );
     },
-    syncEpoch: deps.syncEpoch ?? (() => ""),
+    syncEpoch: deps.syncEpoch,
     ...deps.now !== void 0 ? { now: deps.now } : {}
   });
 }
@@ -28015,8 +28372,24 @@ var PaymentsFacade = class {
     this.receiveLoop = parts.receiveLoop;
     this.heldStates = parts.heldStates;
     this.ownPubkeyBytes = parts.ownPubkeyBytes;
+    this.restoreDeps = parts.restoreDeps;
     this.requests = parts.requests;
     deps.deliveryPort.bindDeliveryKeys((blob) => this.engine().deliveryKeys(blob));
+    this.heartbeat = new ConvergenceHeartbeat({
+      now: () => this.nowMs(),
+      onTick: () => this.trackTail(this.runConvergencePass())
+    });
+    this.converger = new Converger({
+      machineDeps: this.machineDeps,
+      stores: this.machineStores,
+      delivery: deps.deliveryPort,
+      reconcile: (report) => this.requests.reconcile(report),
+      refreshView: () => this.view.delta(),
+      replayMints: () => this.replayMints(),
+      isActiveOp: (id) => this.activeMoneyOps.has(id),
+      emit: deps.emit,
+      now: () => this.nowMs()
+    });
   }
   view;
   ledger;
@@ -28028,17 +28401,28 @@ var PaymentsFacade = class {
   receiveLoop;
   heldStates;
   ownPubkeyBytes;
+  restoreDeps;
   requests;
   currentEngine = null;
   pendingOps = /* @__PURE__ */ new Set();
   unsubscribers = [];
   started = false;
+  // §7 heartbeat: in-memory timing cell + pass runner (see convergence.ts).
+  heartbeat;
+  converger;
+  /** Resume single-flight (§7): ticks, start() and resumeNow() coalesce onto ONE pass. */
+  resumeFlight = new SingleFlight();
+  /** §5.1/§7: restore + convergence passes SERIALIZE here. */
+  passChain = new SerialChain();
+  /** §7 ownership: ids with an in-process machine attempt — the pass never adopts one. */
+  activeMoneyOps = /* @__PURE__ */ new Set();
   // ── lifecycle ──────────────────────────────────────────────────────────────
   async start() {
     if (this.started) return;
     this.started = true;
-    await this.deps.session.start();
+    this.heartbeat.start();
     this.unsubscribers.push(
+      this.deps.session.subscribeEpochChange((epoch) => this.handleEpochChange(epoch)),
       this.deps.session.subscribeStream("mailbox", () => {
         this.trackTail(this.receiveLoop.drainOnce());
       }),
@@ -28049,20 +28433,12 @@ var PaymentsFacade = class {
         this.trackTail(this.requests.drainIncoming());
       })
     );
-    this.trackTail(this.runResume());
-    this.trackTail(
-      this.machineStores.deliveryJournal.replay({
-        delivery: this.deps.deliveryPort,
-        now: this.deps.now ?? Date.now,
-        attention: (transferId, code, detail) => {
-          this.deps.emit(
-            "transfer:attention",
-            detail === void 0 ? { transferId, code } : { transferId, code, detail }
-          );
-        }
-      })
-    );
-    this.trackTail(this.replayMints());
+    const statusUnsub = this.deps.session.subscribeStatus?.((status) => {
+      if (status === "connected") this.heartbeat.recovered();
+    });
+    if (statusUnsub !== void 0) this.unsubscribers.push(statusUnsub);
+    await this.deps.session.start();
+    this.trackTail(this.runConvergencePass());
     this.trackTail(this.seedHeldStates());
     await this.view.fullPull().catch(() => void 0);
     this.receiveLoop.start(this.deps.receivePollMs);
@@ -28070,6 +28446,7 @@ var PaymentsFacade = class {
   /** §7 same-address restart gate: resolves only after in-flight ops settle. */
   async stop() {
     this.started = false;
+    this.heartbeat.stop();
     this.receiveLoop.stop();
     for (const unsubscribe of this.unsubscribers) unsubscribe();
     this.unsubscribers = [];
@@ -28095,9 +28472,13 @@ var PaymentsFacade = class {
   history(page) {
     return this.historyStore.page(page ?? {});
   }
+  /** §4 pending-transfers UI surface — derived on read, never cached (convergence.ts). */
+  pendingTransfers() {
+    return derivePendingTransfers(this.machineStores, this.machineDeps.decryptPayload);
+  }
   // ── money movement ─────────────────────────────────────────────────────────
   send(request) {
-    return this.track(this.sendWithPolicy(request));
+    return this.track(this.sendOutcome(request));
   }
   async receive() {
     const transfers = await this.track(this.receiveLoop.drainOnce());
@@ -28107,9 +28488,32 @@ var PaymentsFacade = class {
   mint(coinId, amount) {
     return this.track(this.mintInner(coinId, amount));
   }
+  // §4 retry verb: coalesces onto the running pass — NEVER re-issue send() (#631/#676).
+  async resumeNow() {
+    if (!this.started) return;
+    await this.track(this.runConvergencePass());
+  }
+  /** §5.1 restore — awaited by the session latch BEFORE streams resume; never coalesced onto a pre-restore pass. */
+  async handleEpochChange(_newEpoch) {
+    await this.passChain.enqueue(() => reseedAndReset(this.restoreDeps));
+    await this.passChain.enqueue(() => this.convergeBody());
+  }
+  /** One single-flighted pass + its reschedule: concurrent callers coalesce. */
+  runConvergencePass() {
+    return this.resumeFlight.run(() => this.passChain.enqueue(() => this.convergeBody()));
+  }
+  async convergeBody() {
+    const outcome = await this.converger.convergeOnce();
+    const pending = await this.converger.pendingWork().catch(() => true);
+    this.heartbeat.settle(outcome, pending);
+  }
+  nowMs() {
+    return (this.deps.now ?? Date.now)();
+  }
   // ── send policy (§5.5 + old-loop parity; the machine stays policy-free) ────
-  async sendWithPolicy(request) {
-    const recipient = await this.requireSameNetworkRecipient(request.recipient);
+  /** The ONE place a send() outcome is shaped: success emits in finishSend, a
+   *  CLEAN rejection emits `transfer:updated{status:'failed'}` here (§4). */
+  async sendOutcome(request) {
     const run = {
       amount: request.amount,
       delivered: [],
@@ -28117,12 +28521,36 @@ var PaymentsFacade = class {
       tokenTransfers: [],
       settledShortfalls: [],
       firstPartialId: void 0,
-      pendingAny: false
+      pendingAny: false,
+      lastTransferId: ""
     };
+    try {
+      return await this.sendWithPolicy(request, run);
+    } catch (err) {
+      this.emitCleanFailure(err, run.lastTransferId);
+      throw err;
+    }
+  }
+  /** Only a CLEAN failure (nothing certified, classifyError 'other') is 'failed'.
+   *  Keep-open/partial/conflict outcomes are pending/converging — labelling them
+   *  'failed' invites a dApp re-send, i.e. a double-pay (#631/#676). */
+  emitCleanFailure(err, transferId) {
+    if (isPossiblyCommittedSendOutcome(err) || classifyError(err) !== "other") return;
+    const failed = {
+      id: transferId,
+      status: "failed",
+      tokens: [],
+      tokenTransfers: [],
+      error: messageOf(err)
+    };
+    this.deps.emit("transfer:updated", failed);
+  }
+  async sendWithPolicy(request, run) {
+    const recipient = await this.requireSameNetworkRecipient(request.recipient);
     for (let attempt = 0; ; attempt++) {
       let ctx;
       try {
-        ctx = await this.planAndMaterialize(recipient.chainPubkey, { ...request, amount: run.amount });
+        ctx = await this.planAndMaterialize(recipient.chainPubkey, { ...request, amount: run.amount }, run);
       } catch (err) {
         throw this.partialize(err, run);
       }
@@ -28156,21 +28584,24 @@ var PaymentsFacade = class {
     return recipient;
   }
   async runAttempt(ctx) {
+    this.activeMoneyOps.add(ctx.transferId);
     try {
       const { deliveryPending } = await this.machine.run(ctx.plan);
       this.settleSuccess(ctx, ctx.sourceIds);
       return { kind: "success", deliveryPending };
     } catch (err) {
-      return this.disposeFailedAttempt(ctx, err);
+      return await this.disposeFailedAttempt(ctx, err);
+    } finally {
+      this.activeMoneyOps.delete(ctx.transferId);
     }
   }
-  /**
-   * Partial outcome (#677/#690): the shortfall is already durable (written by
-   * the machine BEFORE complete). Accumulate the settled set, then re-plan ONLY
-   * the remainder under a NEW transferId — never the full amount.
-   */
+  /** Partial (#677/#690): shortfall already durable (machine wrote it BEFORE
+   *  complete); accumulate settled, re-plan ONLY the remainder, NEW transferId. */
   async consumePartial(ctx, disposition, run, attempt) {
-    run.pendingAny = run.pendingAny || disposition.deliveryPending;
+    if (disposition.deliveryPending) {
+      run.pendingAny = true;
+      this.heartbeat.arm();
+    }
     const partial = disposition.entry;
     run.delivered.push(...partial.committedTokenIds);
     run.firstPartialId ??= partial.transferId;
@@ -28191,11 +28622,8 @@ var PaymentsFacade = class {
     run.amount = partial.remainingAmount;
     return null;
   }
-  /**
-   * One attempt's failure disposition: possibly-committed → rethrow UNWRAPPED;
-   * backstop still 'open' (committed>0) → converge via the same machine's
-   * resumeIntent; clean conflict with a demoted source → bounded full re-plan.
-   */
+  /** Failure disposition: possibly-committed → rethrow UNWRAPPED; backstop
+   *  'open' → converge via resumeIntent; clean demoted conflict → full re-plan. */
   async disposeFailedAttempt(ctx, err) {
     if (isPossiblyCommittedSendOutcome(err)) {
       this.settleKeepOpen(ctx);
@@ -28244,8 +28672,9 @@ var PaymentsFacade = class {
     }
     return { kind: "rethrow", error: err };
   }
-  async planAndMaterialize(recipientPubkey, request) {
+  async planAndMaterialize(recipientPubkey, request, run) {
     const transferId = this.newId();
+    run.lastTransferId = transferId;
     const planned = this.queue.plan(transferId, { coinId: request.coinId, amount: request.amount });
     const spend = planned.kind === "planned" ? planned.spend : await planned.settled;
     const sourceIds = this.markPlanned(transferId, request.coinId, spend);
@@ -28328,6 +28757,7 @@ var PaymentsFacade = class {
   /** Open intent: sources stay reserved + in-flight (§5.2) until resume adopts them. */
   settleKeepOpen(ctx) {
     this.queue.clearExpectedChange(ctx.transferId);
+    this.heartbeat.arm();
   }
   settlePartial(ctx, partial) {
     this.ledger.cancel(ctx.transferId);
@@ -28364,6 +28794,7 @@ var PaymentsFacade = class {
     for (const id of run.settledShortfalls.splice(0)) {
       await this.machineStores.shortfalls.removeByKey(id).catch(() => void 0);
     }
+    if (run.pendingAny) this.heartbeat.arm();
     const result = {
       id: transferId,
       status: run.pendingAny ? "confirmed" : "delivered",
@@ -28375,11 +28806,7 @@ var PaymentsFacade = class {
     this.deps.emit("transfer:updated", result);
     return result;
   }
-  /**
-   * With nothing delivered the error passes UNWRAPPED (identity + cause kept);
-   * after ≥1 delivered leg EVERY failure surfaces as PartialSendConflictError
-   * over the accumulated settled set — never bare, never a full-amount retry.
-   */
+  /** Nothing delivered → UNWRAPPED; after ≥1 delivered leg every failure surfaces as PartialSendConflictError over the settled set. */
   partialize(err, run) {
     if (run.delivered.length === 0) return err;
     return new PartialSendConflictError(
@@ -28408,21 +28835,29 @@ var PaymentsFacade = class {
     if (!/^(?:[0-9a-f]{2})+$/.test(coinId) || amount <= 0n) {
       return { success: false, error: "coinId must be even-length lowercase hex and amount positive" };
     }
-    const engine = this.engine();
     const mintId = this.newId();
-    const params = this.mintParams(coinId, amount);
+    this.activeMoneyOps.add(mintId);
+    try {
+      return await this.mintUnderJournal(mintId, coinId, amount);
+    } finally {
+      this.activeMoneyOps.delete(mintId);
+    }
+  }
+  async mintUnderJournal(mintId, coinId, amount) {
+    const engine = this.engine();
     const entry = {
       mintId,
       coinId,
       amount: amount.toString(),
       tokenId: "",
-      createdAt: (this.deps.now ?? Date.now)()
+      createdAt: this.nowMs()
     };
     await this.machineStores.mintJournal.upsert(entry);
     let token;
     try {
-      token = await engine.mint(params, { transferId: mintId });
+      token = await engine.mint(this.mintParams(coinId, amount), { transferId: mintId });
     } catch (err) {
+      this.heartbeat.arm();
       return { success: false, error: messageOf(err) };
     }
     if (token.blob.tokenId !== entry.tokenId) {
@@ -28431,6 +28866,7 @@ var PaymentsFacade = class {
     try {
       await this.finalizeMint(engine, mintId, token, coinId, amount.toString());
     } catch (err) {
+      this.heartbeat.arm();
       return { success: false, tokenId: token.blob.tokenId, error: messageOf(err) };
     }
     return { success: true, tokenId: token.blob.tokenId };
@@ -28453,18 +28889,22 @@ var PaymentsFacade = class {
     this.heldStates.set(token.blob.tokenId, (await engine.deliveryKeys(bytes)).stateHash);
     this.trackTail(this.view.delta());
   }
+  /** @returns how many journal entries were RESOLVED (cleared) — heartbeat progress. */
   async replayMints() {
+    let resolved = 0;
     for (const entry of await this.machineStores.mintJournal.list()) {
+      if (this.activeMoneyOps.has(entry.mintId)) continue;
       try {
-        await this.replayMint(entry);
+        if (await this.replayMint(entry)) resolved += 1;
       } catch {
       }
     }
+    return resolved;
   }
   async replayMint(entry) {
     if (entry.tokenId !== "" && await this.tokenInServerInventory(entry.tokenId)) {
       await this.machineStores.mintJournal.removeByKey(entry.mintId);
-      return;
+      return true;
     }
     const engine = this.engine();
     if (!supportsDeterministicMint(engine)) {
@@ -28472,7 +28912,7 @@ var PaymentsFacade = class {
         transferId: entry.mintId,
         code: ATTENTION_MINT_UNRESOLVED
       });
-      return;
+      return false;
     }
     const token = await engine.mint(this.mintParams(entry.coinId, BigInt(entry.amount)), {
       transferId: entry.mintId
@@ -28481,6 +28921,7 @@ var PaymentsFacade = class {
       await this.machineStores.mintJournal.upsert({ ...entry, tokenId: token.blob.tokenId });
     }
     await this.finalizeMint(engine, entry.mintId, token, entry.coinId, entry.amount);
+    return true;
   }
   mintParams(coinId, amount) {
     return {
@@ -28506,17 +28947,6 @@ var PaymentsFacade = class {
   newId() {
     return (this.deps.newId ?? randomUUID)();
   }
-  async runResume() {
-    const report = await resumeAll(this.machineDeps);
-    await this.requests.reconcile({
-      resumed: report.resumed,
-      conflicted: report.conflicted,
-      open: report.failed
-    });
-    if (report.resumed.length > 0 || report.conflicted.length > 0) {
-      await this.view.delta().catch(() => void 0);
-    }
-  }
   async seedHeldStates() {
     let page = await this.deps.storagePort.listInventory();
     for (let i = 0; i < INVENTORY_SCAN_PAGE_LIMIT; i++) {
@@ -28528,22 +28958,14 @@ var PaymentsFacade = class {
     }
   }
   toUiToken(tokenId, coinId, amount) {
-    const registry = this.deps.registry;
-    const iconUrl = registry.getIconUrl(coinId);
-    const now = (this.deps.now ?? Date.now)();
-    return {
-      id: tokenId,
-      coinId,
-      symbol: registry.getSymbol(coinId),
-      name: registry.getName(coinId),
-      decimals: registry.getDecimals(coinId),
-      ...iconUrl !== null ? { iconUrl } : {},
-      amount: amount.toString(),
-      status: "transferring",
-      createdAt: now,
-      updatedAt: now,
-      lazy: true
-    };
+    const now = this.nowMs();
+    return toToken(
+      tokenId,
+      { assets: [], createdAt: now, updatedAt: now },
+      { coinId, amount: amount.toString() },
+      this.deps.registry,
+      { transferring: true, suspectedSpent: false }
+    );
   }
   track(op) {
     const settled = op.then(
@@ -28558,27 +28980,6 @@ var PaymentsFacade = class {
     this.track(op).catch(() => void 0);
   }
 };
-function buildPayload(recipientPubkey, request, spend, spentStates) {
-  return {
-    v: 2,
-    recipient: recipientPubkey,
-    coinId: request.coinId,
-    amount: request.amount,
-    ...request.memo !== void 0 ? { memo: request.memo } : {},
-    direct: [...spend.plan.direct],
-    ...spend.plan.split !== void 0 ? {
-      split: {
-        tokenId: spend.plan.split.tokenId,
-        splitAmount: spend.plan.split.splitAmount.toString(),
-        remainderAmount: spend.plan.split.remainderAmount.toString()
-      }
-    } : {},
-    spentStates
-  };
-}
-function messageOf(err) {
-  return err instanceof Error ? err.message : String(err);
-}
 
 // impl/wallet-api-v2/http.ts
 var WalletApiHttpError = class extends Error {
@@ -28924,7 +29325,9 @@ var WalletApiSession = class {
   epochLatch = null;
   reseedChain = Promise.resolve();
   reseedsPending = 0;
+  epochHandlers = /* @__PURE__ */ new Set();
   handlers = /* @__PURE__ */ new Map();
+  statusHandlers = /* @__PURE__ */ new Set();
   socket = null;
   started = false;
   stopped = false;
@@ -29025,6 +29428,18 @@ var WalletApiSession = class {
     await this.deps.kv.set(this.refreshKey, tokens.refreshToken);
   }
   // ── epoch latch (F12) ─────────────────────────────────────────────────────
+  /** §5.1: the latched server syncEpoch ('' before first server contact). */
+  currentEpoch() {
+    return this.epochLatch ?? "";
+  }
+  /**
+   * §5.1 restore hook (FacadeSession contract): handlers are AWAITED inside
+   * the reseed chain, BEFORE any stream nudge resumes.
+   */
+  subscribeEpochChange(handler) {
+    this.epochHandlers.add(handler);
+    return () => this.epochHandlers.delete(handler);
+  }
   noteEpoch(epoch) {
     if (this.epochLatch === epoch) return;
     const previous = this.epochLatch;
@@ -29038,7 +29453,7 @@ var WalletApiSession = class {
   }
   async runReseed(epoch, previous) {
     try {
-      await this.deps.onEpochChange(epoch);
+      for (const handler of [...this.epochHandlers]) await handler(epoch);
       await this.deps.kv.set(STORE_KEYS.epochLatch, epoch);
     } catch {
       if (this.epochLatch === epoch) this.epochLatch = previous;
@@ -29075,10 +29490,16 @@ var WalletApiSession = class {
   status() {
     return this.lastStatus ?? "offline";
   }
+  /** Transition feed off the existing emitStatus point (FacadeSession.subscribeStatus). */
+  subscribeStatus(handler) {
+    this.statusHandlers.add(handler);
+    return () => this.statusHandlers.delete(handler);
+  }
   emitStatus(status) {
     if (this.stopped || this.lastStatus === status) return;
     this.lastStatus = status;
     this.deps.emitStatus(status);
+    for (const handler of this.statusHandlers) handler(status);
   }
   async connect() {
     if (this.stopped) return;
@@ -29294,6 +29715,7 @@ var WalletApiDeliveryPort = class {
   wake;
   deriveFn;
   seenChain = new SerialChain();
+  lastIncomingEpoch = null;
   constructor(config) {
     this.client = config.client;
     this.kv = config.kv;
@@ -29388,6 +29810,7 @@ var WalletApiDeliveryPort = class {
     const seen = await this.readSeen();
     let page = await this.client.listMailbox(sinceCursor === void 0 ? 0 : Number(sinceCursor));
     for (; ; ) {
+      this.lastIncomingEpoch = String(page.syncEpoch);
       for (const entry of page.entries) {
         if (entry.status !== "unclaimed") continue;
         if (seen.has(entry.entryId)) continue;
@@ -29397,6 +29820,10 @@ var WalletApiDeliveryPort = class {
       page = await this.client.listMailbox(page.cursor);
     }
   }
+  /** §5.7: the page-honest epoch — the restore-detection source Receive keys on. */
+  incomingEpoch() {
+    return this.lastIncomingEpoch;
+  }
   toIncoming(entry) {
     const bundle = this.openEnvelope(entry);
     return {
@@ -29474,7 +29901,7 @@ var WalletApiSplitCheckpointStore = class {
     return utf8(`${transferId}:${String(opIndex)}`);
   }
   async put(transferId, opIndex, bytes) {
-    const { client, kv, fieldKey, signProgress } = this.config;
+    const { kv, fieldKey } = this.config;
     const aad = this.aad(transferId, opIndex);
     const cacheKey = this.cacheKey(transferId, opIndex);
     let envelope = await kv.get(cacheKey);
@@ -29482,10 +29909,21 @@ var WalletApiSplitCheckpointStore = class {
       envelope = encryptFieldBytes(fieldKey, bytes, aad);
       await kv.set(cacheKey, envelope);
     }
-    const signature = await signProgress(progressSignMessage(transferId, opIndex, envelope));
-    const record = await client.postProgress(transferId, opIndex, envelope, signature);
+    const record = await this.post(transferId, opIndex, envelope);
     return this.open(record.payload, aad);
   }
+  /** §5.1 restore (CheckpointReseeder): re-POST the cached ciphertext byte-identical; false = none cached. */
+  async reseedCheckpoint(transferId, opIndex) {
+    const envelope = await this.config.kv.get(this.cacheKey(transferId, opIndex));
+    if (envelope === null) return false;
+    await this.post(transferId, opIndex, envelope);
+    return true;
+  }
+  /** The ONE signed progress-append path put() and reseedCheckpoint() share. */
+  async post(transferId, opIndex, envelope) {
+    const signature = await this.config.signProgress(progressSignMessage(transferId, opIndex, envelope));
+    return this.config.client.postProgress(transferId, opIndex, envelope, signature);
+  }
   async get(transferId, opIndex) {
     const records = await this.config.client.getProgress(transferId);
     const record = records.find((r) => r.opIndex === opIndex);
@@ -29508,7 +29946,7 @@ var WalletApiSplitCheckpointStore = class {
 };
 
 // core/payments-v2-wiring.ts
-function resolvePaymentsV2Composition(walletApi) {
+function resolvePaymentsV2Composition(walletApi, sphereNetwork) {
   const source = walletApi;
   const network = typeof source?.network === "string" && source.network !== "" ? source.network : null;
   if (!source || network === null) {
@@ -29517,6 +29955,18 @@ function resolvePaymentsV2Composition(walletApi) {
       "INVALID_CONFIG"
     );
   }
+  if (!(network in NETWORKS)) {
+    throw new SphereError(
+      `paymentsV2: walletApi.network "${network}" is not a known network (${Object.keys(NETWORKS).join("/")}) \u2014 a payments composition is single-network (Sphere network "${String(sphereNetwork)}").`,
+      "INVALID_CONFIG"
+    );
+  }
+  if (network !== sphereNetwork) {
+    throw new SphereError(
+      `paymentsV2: walletApi.network "${network}" does not match the Sphere network "${String(sphereNetwork)}" the engine/registry run on \u2014 a payments composition is single-network.`,
+      "INVALID_CONFIG"
+    );
+  }
   if (typeof source.paymentsV2Transport === "function") {
     return { network, factory: source.paymentsV2Transport.bind(source) };
   }
@@ -29582,8 +30032,7 @@ function defaultPaymentsV2Transport(config) {
       deviceId: `${config.deviceId}:pv2`,
       kv: args.kv,
       webSocketFactory,
-      emitStatus: args.emitStatus,
-      onEpochChange: args.onEpochChange
+      emitStatus: args.emitStatus
     });
     return { session, client: authedWireClient(session, client) };
   };
@@ -29653,8 +30102,7 @@ function composePaymentsV2(spec) {
     identity: identitySlice,
     network,
     kv,
-    emitStatus: (status) => host.emit("connection:status", { status }),
-    onEpochChange: async () => void 0
+    emitStatus: (status) => host.emit("connection:status", { status })
   });
   const deps = {
     session: transport.session,
@@ -29684,7 +30132,10 @@ function composePaymentsV2(spec) {
     network,
     ownPubkey: identity.chainPubkey,
     ownNametag: host.nametag,
-    requestMemo: requestMemoCodec(identity.privateKey)
+    requestMemo: requestMemoCodec(identity.privateKey),
+    // §5.1: the session is the epoch authority — the facade registers its
+    // restore hook on the session itself (FacadeSession.subscribeEpochChange).
+    syncEpoch: () => transport.session.currentEpoch()
   };
   return new PaymentsFacade(deps);
 }
@@ -30014,18 +30465,20 @@ var Sphere = class _Sphere {
   }
   /**
    * P9: validate + resolve the paymentsV2 opt-in BEFORE any storage writes —
-   * fail-closed at init, never a silently-degraded composition.
+   * fail-closed at init, never a silently-degraded composition. Returns the
+   * resolved composition (null = flag off); #728: resolving here also asserts
+   * the single-network invariant (walletApi.network known + equal to the
+   * Sphere network) before any session/KV/provider exists.
    */
-  static resolvePaymentsV2Flag(flag, accountingConfig, swapConfig, walletApi) {
-    if (flag !== true) return false;
+  static resolvePaymentsV2Flag(flag, accountingConfig, swapConfig, walletApi, network) {
+    if (flag !== true) return null;
     if (accountingConfig || swapConfig) {
       throw new SphereError(
         "paymentsV2 is incompatible with the accounting/swap modules (both are built on the legacy PaymentsModule and are deleted with the P11 flip) \u2014 disable them or the flag.",
         "INVALID_CONFIG"
       );
     }
-    resolvePaymentsV2Composition(walletApi);
-    return true;
+    return resolvePaymentsV2Composition(walletApi, network);
   }
   /**
    * Configure TokenRegistry in the main bundle context.
@@ -30080,12 +30533,14 @@ var Sphere = class _Sphere {
       options.walletApi
     );
     sphere._verification = options.verification;
-    sphere._paymentsV2Enabled = _Sphere.resolvePaymentsV2Flag(
+    sphere._paymentsV2Composition = _Sphere.resolvePaymentsV2Flag(
       options.paymentsV2,
       accountingConfig,
       swapConfig,
-      options.walletApi
+      options.walletApi,
+      options.network
     );
+    sphere._paymentsV2Enabled = sphere._paymentsV2Composition !== null;
     sphere._password = options.password ?? null;
     sphere._passwordProtected = sphere._password !== null;
     progress?.({ step: "storing_keys", message: "Storing wallet keys..." });
@@ -30152,12 +30607,14 @@ var Sphere = class _Sphere {
       options.walletApi
     );
     sphere._verification = options.verification;
-    sphere._paymentsV2Enabled = _Sphere.resolvePaymentsV2Flag(
+    sphere._paymentsV2Composition = _Sphere.resolvePaymentsV2Flag(
       options.paymentsV2,
       accountingConfig,
       swapConfig,
-      options.walletApi
+      options.walletApi,
+      options.network
     );
+    sphere._paymentsV2Enabled = sphere._paymentsV2Composition !== null;
     sphere._password = options.password ?? null;
     sphere._passwordProtected = sphere._password !== null;
     if (!options.storage.isConnected()) {
@@ -30231,12 +30688,14 @@ var Sphere = class _Sphere {
       options.walletApi
     );
     sphere._verification = options.verification;
-    sphere._paymentsV2Enabled = _Sphere.resolvePaymentsV2Flag(
+    sphere._paymentsV2Composition = _Sphere.resolvePaymentsV2Flag(
       options.paymentsV2,
       accountingConfig,
       swapConfig,
-      options.walletApi
+      options.walletApi,
+      options.network
     );
+    sphere._paymentsV2Enabled = sphere._paymentsV2Composition !== null;
     sphere._password = options.password ?? null;
     sphere._passwordProtected = sphere._password !== null;
     progress?.({ step: "storing_keys", message: "Storing wallet keys..." });
@@ -32894,7 +33353,9 @@ var Sphere = class _Sphere {
    * setOracleApiKey rebuild is what future operations snapshot.
    */
   async startPaymentsV2Inner(index, identity) {
-    this._paymentsV2Composition ??= resolvePaymentsV2Composition(this._walletApiTemplate);
+    if (this._paymentsV2Composition === null) {
+      throw new SphereError("paymentsV2: composition unresolved \u2014 init never ran the flag gate", "INVALID_CONFIG");
+    }
     if (!this._addressModules.get(index)?.tokenEngine) {
       throw new SphereError(
         "paymentsV2 requires the v2 token engine \u2014 the oracle must supply a trust base + gateway URL (and API key where required).",