@dvmkit/sdk 0.1.0-rc.5 → 0.1.0-rc.6

package/dist/internal/index.js

@@ -1,36 +1,73 @@
 import {
-  TEMPO_CHAIN_ID,
+  IDENTITIES_VERSION,
   TEMPO_CHARGE_PENDING_STALE_MS,
+  TEMPO_EXIT_KEY_MISSING_HINT,
+  advanceTempoChannelExit,
   assertTempoSessionChallengeWithinAsk,
   assertTempoSessionDepositWithinCap,
   assertTempoSessionVoucherWithinAsk,
+  assertTempoWalletIdle,
   clearPendingTempoChargeFunding,
-  connectedTempoAccount,
+  createTempoCloseCredential,
   createTempoCreditSession,
   createTempoSessionPaymentFetch,
+  deriveIdentityFromPrivkey,
+  findSigningIdentityByPubkey,
   fundingRailLabel,
+  generateIdentity as generateIdentity2,
+  identitiesFileExists,
+  isPaymentRailKey,
   listResumableTempoChargeFundings,
   listTempoChannelAssociations,
+  loadIdentities,
   loadResumableTempoChargeFunding,
   loadTempoChannelAssociation,
+  loadTempoChannelController,
   loadTempoChannelEntry,
+  nwcRejectionDisplay,
   offersTempoCreditCharge,
   offersTempoCreditFunding,
   offersTempoCreditSession,
+  paymentRailLabel,
   persistTempoOpenCredential,
+  probeRailLabel,
+  railLabelAtSentenceStart,
+  reconcileTempoChannelOnChain,
   recordPendingTempoChargeFunding,
+  resolveSigningIdentity,
+  rpcEndpointLine,
+  rpcEndpointSuffix,
+  saveIdentities,
   shellQuoteArg,
+  tempoChannelControlledBy,
   tempoChargeCredentialSettleable,
+  tempoKeyImportRoutes,
   tempoSessionAssociationByKey,
   tempoSessionChallenge,
   tempoSessionChallengeChannelScope,
+  tempoSessionChallengeMicro,
   tempoSessionCredentialChannelScope,
   tempoSessionCredentialCumulativeMicro,
   tempoSessionCumulativeCapMicro,
   tempoSessionPriorCumulativeMicro,
+  unreachableRailDisplay,
+  unreachableRailHint,
+  withIdentitiesLock,
   withTempoChannelLock,
   withholdsTempoCreditSession
-} from "../chunk-ZMZTZFRC.js";
+} from "../chunk-7AKBC4PW.js";
+import {
+  TEMPO_CHAIN_ID,
+  connectedTempoAccount,
+  deriveTempoAddress,
+  generateTempoKey,
+  getTempoUsdcBalance,
+  resolveTempoAsset,
+  tempoBalanceCheckHint,
+  tempoTokenReference,
+  tempoWrongAssetHint,
+  tryResolveTempoAsset
+} from "../chunk-ANFX5HEG.js";
 import {
   DvmX402ChannelStorage,
   X402_EXACT_AUTHORIZATION_TTL_SECONDS,
@@ -59,8 +96,10 @@ import {
   removeX402Wallet,
   repinX402WalletNetwork,
   resolveBtcUsdRate,
+  resolveX402Asset,
   retirePendingX402Funding,
   saveX402Wallet,
+  staleRateNotice,
   tryResolveBtcUsdRate,
   tryX402Payment,
   verifyX402Payment,
@@ -72,34 +111,74 @@ import {
   x402PendingFundingJson,
   x402PendingRetired,
   x402PendingStale,
-  x402PendingUnsettled
-} from "../chunk-AB3L6B52.js";
+  x402PendingUnsettled,
+  x402WrongAssetHint
+} from "../chunk-FJDCFHW5.js";
 import {
+  RAIL_FLAGS,
   SUPPORTED_PROTOCOL_VERSION,
+  applyImplicitReceiptCredit,
+  applyReceiptCredit,
+  clearCreditSelection,
   clearPendingDrain,
   clearPendingFunding,
+  clearRefillRailUnavailable,
+  dvmLocationIdentity,
   ensureProvisionalCredit,
+  forgetCredit,
+  getOutputTraceId,
   info,
-  isCreditPosture,
-  isValidEvmPrivateKey,
+  json,
+  listCredits,
+  listFundingMenuSnapshots,
+  listImplicitCredits,
   listPendingFundings,
-  loadConfig,
   loadCredit,
   loadCreditX402Binding,
+  loadImplicitCredits,
   loadPendingFunding,
+  markCredit,
+  markImplicitCreditLost,
+  markRefillDrainNoticed,
+  markRefillRailUnavailable,
   maxAdvertisedMicro,
   normalizeCreditEndpoint,
   parseCreditMenu,
   parseCreditTerms,
+  pendingDrainById,
   pendingDrainFor,
   progress,
+  raw,
+  recordBalanceResponse,
   recordCreditX402Instrument,
+  recordDrainReceipts,
   recordFundResponse,
+  recordFundingMenuSnapshot,
   recordPendingDrain,
   recordPendingFunding,
-  updateConfig,
+  recordRefusedDrawBalance,
+  setOutputTraceId,
+  settleDrainEvidence,
   withinAdvertisedTolerance
-} from "../chunk-4KB3LTOS.js";
+} from "../chunk-KSQEFVFJ.js";
+import {
+  CREDIT_POSTURES,
+  FEEDBACK_POSTURES,
+  authorizeProtectedRemoval,
+  configSnapshotPath,
+  describeConfigBackup,
+  ensureConfig,
+  isCreditPosture,
+  isFeedbackPosture,
+  isValidEvmPrivateKey,
+  loadConfig,
+  pinConfigSnapshot,
+  planConfigReset,
+  previewConfigRollback,
+  retireConfigBackup,
+  rollbackConfig,
+  updateConfig
+} from "../chunk-TSWKITGR.js";
 import {
   RevenueReporter
 } from "../chunk-2ABMGUDS.js";
@@ -115,22 +194,27 @@ import {
 import "../chunk-YG7G4DPZ.js";
 import {
   CAPABILITY_NAME_RE
-} from "../chunk-XYTSDAPH.js";
+} from "../chunk-LDTWX7JW.js";
 import {
   ADMIN_STATE_UNAVAILABLE,
+  DEFAULT_AGENT_MINT_URL,
   DEFAULT_LOCK_PUBKEY_GRACE_SECONDS,
   DbTransport,
   MintHealthTracker,
   NwcBackend,
   NwcError,
   PAYMENT_PROOF_KEYS,
+  PRIVKEY_HEX_RE,
+  PersistentCounterSource,
   RECENT_SPENDS_CAP,
+  RECOMMENDED_MINTS,
   SPANS_INSERTED_CHANNEL,
   SpanWriter,
   TEMPO_CLOSE_DB_RECOVERY_BUDGET_MS,
   TEMPO_CLOSE_REQUESTED_TOPIC,
   TEMPO_SESSION_UPDATED_REASON,
   TempoSessionChannelMismatchError,
+  WALLET_VERSION,
   X402EnvValidationError,
   X402FacilitatorHealth,
   X402_BATCH_CHANNEL_ABI,
@@ -140,7 +224,10 @@ import {
   X402_RPC_URL_KEY,
   X402_SELF_RELAY_KEY,
   activePubkeySet,
+  amountBoundsVerdict,
   applyPaymentInfoToJob,
+  assertAgentMnemonicReplaceable,
+  assertNutSupport,
   assertRevenueReporterReady,
   attestedDvmIdentity,
   authenticatedBuilderPubkey,
@@ -158,14 +245,20 @@ import {
   createDVMServer,
   createMonotonicClock,
   creditDepositPayload,
+  deleteAgentMnemonic,
+  deriveAgentMasterKeypair,
+  derivePubkeyFromPrivkey,
   deriveReceiptKeypair,
   deriveReceiptSecret,
   derivedFundCreditId,
   devModeSkipsPaymentVerification,
   drainReceiptsDisplay,
   drainReceiptsHint,
+  effectiveFundingMint,
+  effectiveMints,
   epochMsToIso,
   fundedMicroFor,
+  generateAgentMnemonic,
   generateEphemeralReceiptKey,
   generateIdentity,
   getBalance,
@@ -183,6 +276,7 @@ import {
   isDerivedCreditId,
   isDrainReceipt,
   isFundingReceipt,
+  isPublicRequestId,
   isSignedJobReceipt,
   isX402SettlementReconciliationReason,
   issueUpfrontChallenges,
@@ -190,12 +284,16 @@ import {
   loadAgentWallet,
   loadIdentitySecret,
   loadLockPubkeyState,
+  looksLikeMnemonic,
   lookupInvoice,
   makeInvoice,
+  meltAmountBounds,
+  mnemonicFingerprint,
   msatsToFiatMicro,
   nwcDedupWindowMs,
   nwcTimeoutMs,
   parseNwcUri,
+  parseTraceparent,
   payInvoiceReconciling,
   paymentErrorBody,
   pinAskFiat,
@@ -223,6 +321,7 @@ import {
   toCreditTerms,
   toLockPubkey,
   unknownRouteNotFound,
+  validateAgentMnemonic,
   validateX402Env,
   verifyAttestation,
   verifyChallenge,
@@ -235,13 +334,15 @@ import {
   verifyReceipt,
   verifyTempoSessionManagementCredential,
   verifyUpfrontPayment,
+  walletExists,
   weakestReceiptVerdict,
   withNwcPool,
   withWalletLock,
+  writeAgentMnemonic,
   writeIdentity,
   x402RequiredUsdcMicro,
   x402SettledShare
-} from "../chunk-ATQIII6K.js";
+} from "../chunk-CMDI3ENK.js";
 import {
   X402_BATCH_SETTLEMENT_SCHEME,
   X402_DEFAULT_FACILITATOR,
@@ -274,15 +375,11 @@ import {
   x402NetworkListForCopy,
   x402NetworkToCaip2,
   x402SupportedNetworksHint
-} from "../chunk-AAJNGQMC.js";
+} from "../chunk-JGGI65I3.js";
 import {
-  BUDGET_FILE,
   COINGECKO_SIMPLE_PRICE_URL,
-  DvmError,
-  RECEIPTS_FILE,
   assertValidBudget,
   costAnchor,
-  ensureConfigDir,
   fetchBtcUsdRate,
   fetchCoinGeckoBtcUsd,
   fetchCoinGeckoSpot,
@@ -294,19 +391,46 @@ import {
   formatUsd,
   formatUsdcMicrounits,
   getLastKnownBtcRate,
-  isAbortError,
   monetaryJson,
   msatsToUsd,
   msatsToUsdCents,
   msatsToUsdc,
   parseBudget,
+  usdToMsats,
+  usdcToMsats
+} from "../chunk-5URG56JJ.js";
+import {
+  AGENT_MNEMONIC_FILE,
+  BTC_RATE_FILE,
+  BUDGET_FILE,
+  CONFIG_AUDIT_FILE,
+  CONFIG_BACKUP_FILE,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  CONFIG_PINNED_FILE,
+  CREDITS_FILE,
+  DvmError,
+  FAVORITES_FILE,
+  FEEDBACK_NUDGES_FILE,
+  IDENTITIES_FILE,
+  JOBS_FILE,
+  MESSAGES_DIR,
+  PAIRINGS_DIR,
+  RECEIPTS_FILE,
+  RECOVERY_MNEMONIC_FILE,
+  REQUEST_INTENTS_DIR,
+  TEMPO_CHANNELS_FILE,
+  WALLET_FILE,
+  X402_CHANNELS_FILE,
+  ensureConfigDir,
+  ensureConfigSubdir,
+  isAbortError,
   providerProseSources,
+  repairConfigDirMode,
   resolveRpcHttpTransportOptions,
   resolveRpcOverride,
-  transportErrorCode,
-  usdToMsats,
-  usdcToMsats
-} from "../chunk-F2L6KIMD.js";
+  transportErrorCode
+} from "../chunk-MKI6OVW4.js";
 import "../chunk-EXHBXA4U.js";
 import {
   RAIL_REFUNDABLE,
@@ -320,8 +444,9 @@ import {
   createDefaultReplayStore,
   humanizeZodError,
   signedRequestStatementHeader,
+  testOnlySignedRequestDomain,
   verifyCanonicalSignedRequest
-} from "../chunk-AZBXSXQT.js";
+} from "../chunk-P4RUVDU7.js";
 import {
   JobCancelledError,
   MemoryKVStore,
@@ -346,6 +471,7 @@ import {
 } from "../chunk-TKA6ZP4M.js";
 import "../chunk-66HGCPBU.js";
 import {
+  redactUrl,
   redactUrlsInText
 } from "../chunk-FUJ36YDV.js";
 import {
@@ -477,6 +603,23 @@ async function enforceGlobalBudget(opts) {
   }
   return rate;
 }
+function statusSnapshot(now = /* @__PURE__ */ new Date()) {
+  const ledger = loadLedger();
+  const windows = ["daily", "weekly", "monthly"];
+  return {
+    caps: ledger.caps,
+    windows: windows.map((window) => {
+      const breakdown = breakdownSince(ledger.entries, windowStart(window, now).getTime());
+      return {
+        window,
+        spentUsd: breakdown.totalUsd,
+        limitUsd: capFor(ledger.caps, window),
+        resetsAt: windowEnd(window, now).getTime(),
+        breakdown
+      };
+    })
+  };
+}
 function entryKind(entry) {
   return entry.kind ?? "job";
 }
@@ -678,6 +821,14 @@ function signDvmRequestData(privkeyHex, body, domain, opts = {}) {
   );
   return { ...input, auth_statement: authStatement, signature };
 }
+function unsignRequestData(body) {
+  if (!body) return null;
+  const { pubkey, timestamp, nonce, signature, auth_statement: _authStatement, ...rest } = body;
+  if (typeof pubkey !== "string" || typeof timestamp !== "number" || typeof nonce !== "string" || typeof signature !== "string") {
+    return null;
+  }
+  return { body: rest, pubkey };
+}
 function bytesToHex(bytes) {
   let s = "";
   for (const b of bytes) s += b.toString(16).padStart(2, "0");
@@ -704,6 +855,14 @@ import { Challenge, Credential } from "mppx";
 import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 
 // src/lib/float.ts
+function floatPaymentJson(payment) {
+  return {
+    outcome: payment.outcome,
+    principal_sats: payment.principalMsats / 1e3,
+    routing_fee_sats: payment.routingFeeMsats === null ? null : payment.routingFeeMsats / 1e3,
+    wallet_debit_sats: payment.walletDebitMsats === null ? null : payment.walletDebitMsats / 1e3
+  };
+}
 function floatPaymentDisplay(payment) {
   const principal = formatSats2(payment.principalMsats);
   if (payment.routingFeeMsats === null || payment.walletDebitMsats === null) {
@@ -734,6 +893,23 @@ function emitFloatBudgetWarning(args) {
     hint: "Set a connection policy in the wallet app, confirm whether it counts routing fees, then reconnect with --budget to record it for dvm."
   });
 }
+var NWC_FUNDING_FLOAT_ROLE = {
+  role: "nwc_funding_float",
+  uses: ["cashu_wallet_topups", "eligible_prepaid_credit_funding"],
+  direct_request_rail: false,
+  display: "This connected Lightning wallet is an NWC funding float: it funds ecash wallet top-ups and eligible prepaid credits directly, not direct dvm request payments.",
+  hint: "dvm request uses ecash, Tempo stablecoin, or x402 stablecoin. Prepaid-credit funding is selected automatically: ecash below a DVM's advertised Lightning floor, this wallet directly when eligible. dvm checks Lightning invoice principal against local caps; the wallet chooses the route and routing fee."
+};
+var BUDGET_PERIODS = {
+  day: "day",
+  daily: "day",
+  week: "week",
+  weekly: "week",
+  month: "month",
+  monthly: "month",
+  year: "year",
+  yearly: "year"
+};
 function loadFloat(config) {
   const cfg = config === void 0 ? loadConfig() : config;
   if (!cfg?.nwcUri) return null;
@@ -821,6 +997,47 @@ async function fundViaFloat(params) {
   });
   return { ...payment, btcRate };
 }
+async function probeFloat(params) {
+  const { float, timeoutMs } = params;
+  return withNwcPool(float.conn, (opts) => probeOnPool(float, opts), timeoutMs);
+}
+async function probeOnPool(float, opts) {
+  const backend = backendFor(float, opts);
+  let info2;
+  try {
+    info2 = await backend.getInfo();
+  } catch (err) {
+    const mapped = toFloatError(err);
+    return {
+      reachable: false,
+      methods: [],
+      canPay: false,
+      canInvoice: false,
+      canReconcile: false,
+      error: {
+        code: mapped.code,
+        message: mapped.message,
+        display: typeof mapped.data?.display === "string" ? mapped.data.display : mapped.message,
+        hint: mapped.hint,
+        ...mapped.data ? { data: mapped.data } : {}
+      }
+    };
+  }
+  const probe = {
+    reachable: true,
+    alias: info2.alias,
+    methods: info2.methods,
+    canPay: supportsMethod(info2.methods, "pay_invoice"),
+    canInvoice: supportsMethod(info2.methods, "make_invoice"),
+    canReconcile: supportsMethod(info2.methods, "lookup_invoice")
+  };
+  if (info2.walletReportedBudget) probe.walletReportedBudget = info2.walletReportedBudget;
+  try {
+    probe.balanceMsats = await backend.getBalance();
+  } catch {
+  }
+  return probe;
+}
 function backendFor(float, opts) {
   return new NwcBackend(float.conn, opts);
 }
@@ -828,6 +1045,43 @@ function formatSats2(msats) {
   const sats = msats / 1e3;
   return `${Number.isInteger(sats) ? sats.toLocaleString("en-US") : String(sats)} sats`;
 }
+function parseStatedBudget(raw2) {
+  const trimmed = raw2.trim();
+  if (!trimmed || trimmed.length > 64) {
+    throw new DvmError(
+      "invalid_budget",
+      `Invalid budget: "${raw2}".`,
+      "Pass the cap you set on the wallet, e.g. --budget '$20/month' or --budget '50000 sats/week'.",
+      { display: "That budget didn't look like an amount \u2014 try something like '$20/month'." }
+    );
+  }
+  const slash = trimmed.lastIndexOf("/");
+  if (slash === -1) return { raw: trimmed, display: trimmed };
+  const suffix = trimmed.slice(slash + 1).trim().toLowerCase();
+  const period = BUDGET_PERIODS[suffix];
+  if (!period) {
+    throw new DvmError(
+      "invalid_budget",
+      `Unknown budget period: "${suffix}".`,
+      "Use one of day, week, month, or year \u2014 e.g. --budget '$20/month'.",
+      {
+        display: `"${suffix}" isn't a period we recognise. Use day, week, month, or year.`
+      }
+    );
+  }
+  return { raw: trimmed, period, display: trimmed };
+}
+function floatBudgetJson(float, walletReported) {
+  const stated = float.statedBudget;
+  return {
+    stated: stated ?? null,
+    source: "user_stated",
+    routing_fee_inclusion: "unknown",
+    ...walletReported ? { wallet_reported: { _source: "wallet", ...walletReported } } : {},
+    display: stated ? `Wallet connection budget: ${stated} (as you reported it \u2014 not a live wallet reading)` : "No wallet budget recorded. Set one in your wallet app, then re-connect with --budget to note it here.",
+    hint: "The wallet enforces its connection policy, but dvm does not know whether that policy counts routing fees. dvm checks invoice principal against its own local caps; NIP-47 cannot set a per-payment routing-fee ceiling."
+  };
+}
 function toFloatError(err) {
   if (err instanceof DvmError) return err;
   if (!(err instanceof NwcError)) {
@@ -1010,6 +1264,10 @@ function describeNwcMethod(method) {
   }
 }
 var BUDGET_WORDING = /\b(budget\w*|quota\w*|limit\w*|caps?|capped|allowance\w*|exceed\w*)\b/i;
+function supportsMethod(methods, method) {
+  if (methods.length === 0) return true;
+  return methods.some((m) => m === method || m.endsWith(`.${method}`));
+}
 
 // src/lib/payment-rails/tempo-credential.ts
 async function buildTempoCredential(args) {
@@ -1103,8 +1361,65 @@ function fail(mode, refusal) {
   return null;
 }
 
+// src/lib/job-store.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+function saveJob(job) {
+  const jobs = loadAllJobs();
+  jobs.push(job);
+  writeJobs(jobs);
+}
+function updateJob(id, update) {
+  const jobs = loadAllJobs();
+  const idx = jobs.findIndex((j) => j.id === id);
+  if (idx === -1) return;
+  jobs[idx] = { ...jobs[idx], ...update };
+  writeJobs(jobs);
+}
+function markJobTerminal(id, status, completion, extra) {
+  const existing = loadJob(id);
+  if (!existing) return;
+  updateJob(id, {
+    ...extra,
+    status,
+    completedAt: existing.completedAt ?? Date.now(),
+    completion
+  });
+}
+function loadJob(id) {
+  const jobs = loadAllJobs();
+  return jobs.find((j) => j.id === id) ?? null;
+}
+function loadAllJobs() {
+  if (!existsSync2(JOBS_FILE)) return [];
+  try {
+    return JSON.parse(readFileSync2(JOBS_FILE, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function addPayment(jobId, amountMsats) {
+  const job = loadJob(jobId);
+  if (!job) return;
+  updateJob(jobId, {
+    totalPaidMsats: (job.totalPaidMsats ?? 0) + amountMsats,
+    paymentsHonoured: (job.paymentsHonoured ?? 0) + 1
+  });
+}
+function refFromJob(job) {
+  return { endpoint: job.endpoint };
+}
+function writeJobs(jobs) {
+  ensureConfigDir();
+  writeFileSync2(JOBS_FILE, JSON.stringify(jobs, null, 2) + "\n");
+}
+
 // src/lib/receipt-store.ts
-import { appendFileSync, existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { appendFileSync, existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+function appendReceipt(entry) {
+  if (loadReceipt(entry.receipt.job_id)) return;
+  ensureConfigDir();
+  appendFileSync(RECEIPTS_FILE, JSON.stringify(entry) + "\n");
+}
 function appendFundingReceipt(entry) {
   if (loadFundingReceipts().some(
     (held) => held.receipt.credit_id === entry.receipt.credit_id && held.receipt.fund_id === entry.receipt.fund_id
@@ -1115,9 +1430,9 @@ function appendFundingReceipt(entry) {
   appendFileSync(RECEIPTS_FILE, JSON.stringify(entry) + "\n");
 }
 function loadFundingReceipts() {
-  if (!existsSync2(RECEIPTS_FILE)) return [];
+  if (!existsSync3(RECEIPTS_FILE)) return [];
   try {
-    return readFileSync2(RECEIPTS_FILE, "utf-8").split("\n").flatMap((line) => {
+    return readFileSync3(RECEIPTS_FILE, "utf-8").split("\n").flatMap((line) => {
       if (!line.trim()) return [];
       try {
         const parsed = JSON.parse(line);
@@ -1130,10 +1445,37 @@ function loadFundingReceipts() {
     return [];
   }
 }
+function loadReceipts() {
+  if (!existsSync3(RECEIPTS_FILE)) return [];
+  let content;
+  try {
+    content = readFileSync3(RECEIPTS_FILE, "utf-8").trim();
+  } catch {
+    return [];
+  }
+  if (!content) return [];
+  const entries = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (isStoredReceipt(parsed)) entries.push(parsed);
+    } catch {
+    }
+  }
+  return entries;
+}
+function isStoredReceipt(value) {
+  if (!value || typeof value !== "object") return false;
+  return isSignedJobReceipt(value.receipt);
+}
 function isStoredFundingReceipt(value) {
   if (!value || typeof value !== "object") return false;
   return isFundingReceipt(value.receipt);
 }
+function loadReceipt(jobId) {
+  return loadReceipts().find((e) => e.receipt.job_id === jobId) ?? null;
+}
 
 // src/lib/receipt-capture.ts
 function captureFundingReceipt(args) {
@@ -1167,6 +1509,139 @@ function captureFundingReceipt(args) {
   }
   return result.status;
 }
+function captureJobReceipt(jobId, receipt, parseError) {
+  if (!receipt && parseError) {
+    persistParseError(jobId, parseError);
+    const capture = unparseableCapture(parseError);
+    info(`Warning: this job's receipt could not be parsed (${parseError}). ${capture.display}`);
+    return capture;
+  }
+  if (!receipt) return absentCapture();
+  const job = loadJob(jobId);
+  const result = verifyJobReceipt({ receipt, builder: job?.builderAnchor, expectedJobId: jobId });
+  if (result.reason !== "job_id_mismatch") persist(jobId, receipt, result.status, job);
+  if (result.status === "invalid") {
+    info(
+      `Warning: this job's receipt did not verify. ${receiptFailureDetail(result.reason ?? "signature_invalid")}`
+    );
+  }
+  return toCapture(receipt, result);
+}
+function captureTransportReceipt(jobId, response) {
+  return captureJobReceipt(jobId, response.receipt, response.receiptParseError);
+}
+function receiptJsonFields(capture) {
+  const out = { receipt_verified: capture.status };
+  if (capture.status !== "absent") out.receipt_display = capture.display;
+  if (capture.receipt) {
+    out.receipt = capture.receipt;
+    if (capture.checks) out.receipt_checks = capture.checks;
+  }
+  if (capture.reason) out.receipt_error = capture.reason;
+  return out;
+}
+function renderReceiptHuman(capture) {
+  if (capture.status === "absent") return;
+  info(`\u{1F9FE} ${capture.display}`);
+}
+function receiptTrustFields(provider) {
+  return {
+    ...provider.receipts === true ? { receiptsSupported: true } : {},
+    ...provider.builder ? { builderAnchor: provider.builder } : {}
+  };
+}
+async function fetchTrustAnchor(transport, ref) {
+  try {
+    const { builderAnchor } = receiptTrustFields(await transport.describe(ref));
+    return { reachable: true, ...builderAnchor ? { anchor: builderAnchor } : {} };
+  } catch {
+    return { reachable: false };
+  }
+}
+async function fetchMissingJobReceipt(jobId, transport, ref) {
+  const job = loadJob(jobId);
+  if (!job?.receiptsSupported) return {};
+  const held = recordedReceipt(job);
+  if (held) return { receipt: held };
+  try {
+    const status = await transport.status(jobId, ref, { jobToken: job.jobToken });
+    return {
+      ...status.receipt ? { receipt: status.receipt } : {},
+      ...status.receiptParseError ? { receiptParseError: status.receiptParseError } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+async function backfillTrustAnchor(jobId, transport, ref) {
+  try {
+    const provider = await transport.describe(ref);
+    const fields = receiptTrustFields(provider);
+    if (Object.keys(fields).length > 0) updateJob(jobId, fields);
+    return fields.builderAnchor;
+  } catch {
+    return void 0;
+  }
+}
+function replayStoredReceipt(job) {
+  const receipt = recordedReceipt(job);
+  if (!receipt) {
+    return job.receiptParseError === "shape_invalid" ? unparseableCapture(job.receiptParseError) : absentCapture();
+  }
+  return toCapture(
+    receipt,
+    verifyJobReceipt({
+      receipt,
+      builder: job.builderAnchor,
+      expectedJobId: job.id
+    })
+  );
+}
+function recordedReceipt(job) {
+  const receipt = job.receipt;
+  return isSignedJobReceipt(receipt) ? receipt : void 0;
+}
+function absentCapture() {
+  return { status: "absent", display: receiptHint("absent") };
+}
+function unparseableCapture(reason) {
+  const display = "UNREADABLE receipt: this DVM returned a receipt block that does not match the signed receipt protocol shape. The job itself is unaffected.";
+  return { status: "unparseable", reason, display };
+}
+function toCapture(receipt, result) {
+  return {
+    status: result.status,
+    receipt,
+    checks: result.checks,
+    ...result.reason ? { reason: result.reason } : {},
+    display: receiptDisplay(receipt, result.status, getLastKnownBtcRate()?.rate ?? 0)
+  };
+}
+function persist(jobId, receipt, verification, job) {
+  try {
+    updateJob(jobId, { receipt });
+    appendReceipt({
+      receipt,
+      endpoint: job?.endpoint ?? "",
+      ...job?.builderAnchor ? { builder: job.builderAnchor } : {},
+      verification,
+      verified_at: Date.now()
+    });
+  } catch (err) {
+    info(
+      `Warning: could not store job receipt: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function persistParseError(jobId, receiptParseError) {
+  try {
+    updateJob(jobId, { receiptParseError });
+  } catch (err) {
+    info(
+      `Warning: could not store job receipt diagnostic: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 
 // src/lib/signed-request-target.ts
 function signedRequestAudience(provider, endpoint) {
@@ -1216,6 +1691,19 @@ function isLoopbackEndpoint(endpoint) {
 
 // src/lib/wallet-agent/builder-handle.ts
 var BUILDER_RESERVE_PREFIX = "builder/";
+function extractBuilderHandle(endpoint) {
+  let url;
+  try {
+    url = new URL(endpoint);
+  } catch {
+    throw new DvmError(
+      "invalid_endpoint",
+      `Could not parse "${endpoint}" as a URL.`,
+      "Pass a full HTTPS URL like `https://scrape.dvmkit.ai`, or a favorite alias like `@scrape`."
+    );
+  }
+  return url.hostname.toLowerCase();
+}
 function reservedForMarker(builderHandle) {
   return `${BUILDER_RESERVE_PREFIX}${builderHandle}`;
 }
@@ -1387,14 +1875,25 @@ async function validateLnAddress(address) {
 var DEFAULT_INFLIGHT_PROOF_TIMEOUT_SEC = 60;
 var INFLIGHT_TIMEOUT_ENV = "DVM_INFLIGHT_PROOF_TIMEOUT_SEC";
 function inFlightTimeoutSeconds() {
-  const raw = process.env[INFLIGHT_TIMEOUT_ENV];
-  if (!raw) return DEFAULT_INFLIGHT_PROOF_TIMEOUT_SEC;
-  const parsed = Number(raw);
+  const raw2 = process.env[INFLIGHT_TIMEOUT_ENV];
+  if (!raw2) return DEFAULT_INFLIGHT_PROOF_TIMEOUT_SEC;
+  const parsed = Number(raw2);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     return DEFAULT_INFLIGHT_PROOF_TIMEOUT_SEC;
   }
   return parsed;
 }
+var DEFAULT_MELT_INFLIGHT_TIMEOUT_SEC = 900;
+var MELT_INFLIGHT_TIMEOUT_ENV = "DVM_MELT_INFLIGHT_TIMEOUT_SEC";
+function meltInFlightTimeoutSeconds() {
+  const raw2 = process.env[MELT_INFLIGHT_TIMEOUT_ENV];
+  if (!raw2) return DEFAULT_MELT_INFLIGHT_TIMEOUT_SEC;
+  const parsed = Number(raw2);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return DEFAULT_MELT_INFLIGHT_TIMEOUT_SEC;
+  }
+  return parsed;
+}
 function proofKey(p) {
   return `${p.mint}\0${p.secret}`;
 }
@@ -1466,8 +1965,8 @@ function rehydrateOutputData(persisted) {
 }
 function bigintToHex(n) {
   if (n < 0n) throw new Error(`blinding factor must be non-negative, got ${n.toString()}`);
-  const raw = n.toString(16);
-  return raw.length % 2 === 0 ? raw : "0" + raw;
+  const raw2 = n.toString(16);
+  return raw2.length % 2 === 0 ? raw2 : "0" + raw2;
 }
 function hexToBigint(hex) {
   if (!/^[0-9a-fA-F]*$/.test(hex)) throw new Error(`invalid hex: ${hex}`);
@@ -1542,59 +2041,500 @@ function toCashuProofs(proofs) {
   return proofs.map(toCashuProof);
 }
 
-// src/lib/wallet-agent/denominations.ts
-var TINY_AMOUNT_THRESHOLD_SATS = 8;
-function computeSmartDenominations(amountSats, opts = {}) {
-  if (!Number.isFinite(amountSats) || amountSats <= 0) return [];
-  const cap = normalizeCap(opts.maxDenomination);
-  const withTail = opts.includeTinyTail !== false;
-  if (!withTail || amountSats < TINY_AMOUNT_THRESHOLD_SATS) {
-    return greedyPowerOfTwo(Math.floor(amountSats), cap);
+// src/lib/wallet-agent/cash-out.ts
+async function cashOutFromMint(opts) {
+  const mintUrl = opts.mintUrl;
+  const now = opts.now ?? (() => Date.now());
+  const getWalletForMint = opts.getWalletForMint ?? getWallet;
+  const fetchInvoice = opts.fetchInvoice ?? fetchLnurlPayInvoice;
+  const initial = loadAgentWallet();
+  if (!initial) {
+    throw new DvmError(
+      "wallet_missing",
+      "No agent wallet found.",
+      "Run `dvm wallet init` first to generate a lock keypair."
+    );
   }
-  const total = Math.floor(amountSats);
-  const small1 = Math.floor(total * 0.05);
-  const small2 = Math.floor(total * 0.1 / 2) * 2;
-  const small4 = Math.floor(total * 0.2 / 4) * 4;
-  const remainder = total - small1 - small2 - small4;
-  const out = [];
-  for (let i = 0; i < small1; i++) out.push(1);
-  for (let i = 0; i < small2 / 2; i++) out.push(2);
-  for (let i = 0; i < small4 / 4; i++) out.push(4);
-  out.push(...greedyPowerOfTwo(remainder, cap));
-  return out;
-}
-function greedyPowerOfTwo(n, cap) {
-  const out = [];
-  let r = n;
-  if (cap !== void 0 && r >= cap) {
-    const capCount = Math.floor(r / cap);
-    for (let i = 0; i < capCount; i++) out.push(cap);
-    r -= capCount * cap;
+  const candidates = spendableAt(initial.proofs, mintUrl);
+  if (candidates.length === 0) {
+    return {
+      kind: "skipped",
+      mint: mintUrl,
+      reason: "no_balance",
+      message: `No spendable proofs at ${mintUrl}.`
+    };
   }
-  let bit = 1;
-  while (r > 0) {
-    if (r & 1) out.push(bit);
-    r = Math.floor(r / 2);
-    bit *= 2;
+  let cashuWallet;
+  try {
+    cashuWallet = await getWalletForMint(mintUrl);
+  } catch (err) {
+    return { kind: "failed", mint: mintUrl, message: errorMessage(err), settlement: "reverted" };
+  }
+  const meltBounds = meltBoundsOf(cashuWallet);
+  let target = opts.target;
+  let cappedByMintMax;
+  if (meltBounds.maxSats !== null) {
+    const wanted = opts.target.kind === "all" ? sumSats(candidates) : opts.target.sats;
+    if (wanted > meltBounds.maxSats) {
+      target = { kind: "exact", sats: meltBounds.maxSats };
+      cappedByMintMax = meltBounds.maxSats;
+    }
   }
-  return out;
-}
-function normalizeCap(raw) {
-  if (raw === void 0) return void 0;
-  if (!Number.isFinite(raw) || raw <= 0) return void 0;
-  const floored = Math.floor(raw);
-  let pow = 1;
-  while (pow * 2 <= floored) pow *= 2;
-  return pow;
-}
-
-// src/lib/wallet-agent/fund.ts
-import { MintQuoteState } from "@cashu/cashu-ts";
-async function prepareP2PKMint(cashuWallet, sats, quote, lockPrivkey, lockPubkey, denominations, extras = {}) {
-  const options = {
-    pubkey: lockPubkey
+  let selected = selectInputs(candidates, target);
+  let inputFees;
+  try {
+    inputFees = await getInputFeesForProofs(mintUrl, toCashuProofs(selected));
+  } catch (err) {
+    return { kind: "failed", mint: mintUrl, message: errorMessage(err), settlement: "reverted" };
+  }
+  let selectedTotal = sumSats(selected);
+  if (target.kind === "exact" && selectedTotal - inputFees < target.sats) {
+    const widened = widenSelection(candidates, selected, target.sats, inputFees);
+    if (widened) {
+      selected = widened.selected;
+      selectedTotal = sumSats(selected);
+      try {
+        inputFees = await getInputFeesForProofs(mintUrl, toCashuProofs(selected));
+      } catch (err) {
+        return {
+          kind: "failed",
+          mint: mintUrl,
+          message: errorMessage(err),
+          settlement: "reverted"
+        };
+      }
+    }
+  }
+  const desired = target.kind === "all" ? selectedTotal - inputFees : Math.min(target.sats, selectedTotal - inputFees);
+  if (desired <= 0) {
+    return {
+      kind: "skipped",
+      mint: mintUrl,
+      reason: "fees_exceed_balance",
+      message: `The mint's per-input fee (${inputFees} sats) meets or exceeds the ${selectedTotal} sats available at ${mintUrl}.`
+    };
+  }
+  if (meltBounds.minSats !== null && desired < meltBounds.minSats) {
+    return {
+      kind: "skipped",
+      mint: mintUrl,
+      reason: "amount_out_of_range",
+      message: `${mintUrl} won't pay out less than ${meltBounds.minSats} sats in one go, and only ${desired} sats can be sent from here after fees.`
+    };
+  }
+  if (opts.maxFeeSats !== void 0 && inputFees > opts.maxFeeSats) {
+    return {
+      kind: "skipped",
+      mint: mintUrl,
+      reason: "fee_cap_exceeded",
+      message: `The per-input fee at ${mintUrl} is ${inputFees} sats on its own, over the ${opts.maxFeeSats} sat cap.`
+    };
+  }
+  let invoice;
+  let quote;
+  try {
+    invoice = await fetchInvoice(opts.destination, desired * 1e3);
+    quote = await fetchMeltQuote(mintUrl, invoice);
+  } catch (err) {
+    return classifyPreCommitError(mintUrl, err);
+  }
+  if (selectedTotal < quote.amountSats + quote.feeReserveSats + inputFees) {
+    const widened = widenSelection(
+      candidates,
+      selected,
+      quote.amountSats + quote.feeReserveSats,
+      inputFees
+    );
+    if (widened) {
+      selected = widened.selected;
+      selectedTotal = sumSats(selected);
+      try {
+        inputFees = await getInputFeesForProofs(mintUrl, toCashuProofs(selected));
+      } catch (err) {
+        return {
+          kind: "failed",
+          mint: mintUrl,
+          message: errorMessage(err),
+          settlement: "reverted"
+        };
+      }
+    }
+    if (selectedTotal < quote.amountSats + quote.feeReserveSats + inputFees) {
+      const target2 = selectedTotal - quote.feeReserveSats - inputFees;
+      if (target2 <= 0) {
+        return {
+          kind: "skipped",
+          mint: mintUrl,
+          reason: "fees_exceed_balance",
+          message: `Fees at ${mintUrl} (${quote.feeReserveSats} sats routing reserve + ${inputFees} sats input fee) meet or exceed the ${selectedTotal} sats available.`
+        };
+      }
+      try {
+        invoice = await fetchInvoice(opts.destination, target2 * 1e3);
+        quote = await fetchMeltQuote(mintUrl, invoice);
+      } catch (err) {
+        return classifyPreCommitError(mintUrl, err);
+      }
+      if (selectedTotal < quote.amountSats + quote.feeReserveSats + inputFees) {
+        return {
+          kind: "skipped",
+          mint: mintUrl,
+          reason: "fees_exceed_balance",
+          message: `${mintUrl} quoted a routing reserve (${quote.feeReserveSats} sats) the ${selectedTotal} sats available can't cover.`
+        };
+      }
+    }
+  }
+  const quoteView = {
+    mint: mintUrl,
+    quote_id: quote.rawQuote.quote,
+    amount_sats: quote.amountSats,
+    fee_reserve_sats: quote.feeReserveSats,
+    input_fee_sats: inputFees,
+    debit_sats: selectedTotal,
+    expires_at: typeof quote.rawQuote.expiry === "number" ? quote.rawQuote.expiry : null
   };
-  if (extras.locktimeUnixSec !== void 0) options.locktime = extras.locktimeUnixSec;
+  const totalFees = quote.feeReserveSats + inputFees;
+  if (opts.maxFeeSats !== void 0 && totalFees > opts.maxFeeSats) {
+    return {
+      kind: "skipped",
+      mint: mintUrl,
+      reason: "fee_cap_exceeded",
+      message: `Fees at ${mintUrl} would be up to ${totalFees} sats, over the ${opts.maxFeeSats} sat cap.`,
+      quote: quoteView
+    };
+  }
+  opts.onQuote?.(quoteView);
+  if (opts.dryRun) {
+    return {
+      kind: "quoted",
+      mint: mintUrl,
+      quote: quoteView,
+      ...cappedByMintMax !== void 0 ? { mint_max_sats: cappedByMintMax } : {}
+    };
+  }
+  let preview;
+  try {
+    preview = await cashuWallet.ops.meltBolt11(quote.rawQuote, toCashuProofs(selected)).asP2PK({ pubkey: initial.lock_pubkey }).privkey(initial.lock_privkey).prepare();
+  } catch (err) {
+    return {
+      kind: "failed",
+      mint: mintUrl,
+      message: errorMessage(err),
+      settlement: "reverted",
+      quote: quoteView
+    };
+  }
+  const untilMs = now() + (opts.inFlightTimeoutSec ?? meltInFlightTimeoutSeconds()) * 1e3;
+  const selectedKeys = new Set(selected.map((p) => proofKey(p)));
+  const entry = {
+    mint: mintUrl,
+    quote_id: quote.rawQuote.quote,
+    bolt11: invoice,
+    destination: opts.destination,
+    amount_sats: quote.amountSats,
+    fee_reserve_sats: quote.feeReserveSats,
+    input_fee_sats: inputFees,
+    input_proofs: selected,
+    melting: {
+      keyset_id: preview.keysetId,
+      outputs: serializeOutputData(preview.outputData)
+    },
+    created_at: new Date(now()).toISOString(),
+    ...quoteView.expires_at !== null ? { expires_at: quoteView.expires_at } : {}
+  };
+  const committed = await withWalletLock(() => {
+    const fresh = loadAgentWallet();
+    if (!fresh) return false;
+    const swept = sweepStaleInFlight(fresh, now());
+    const available = new Set(spendableAt(swept.wallet.proofs, mintUrl).map((p) => proofKey(p)));
+    if (![...selectedKeys].every((k) => available.has(k))) {
+      if (swept.reverted > 0) saveAgentWallet(swept.wallet);
+      return false;
+    }
+    const marked = markProofsInFlight(swept.wallet, selectedKeys, untilMs);
+    saveAgentWallet({ ...marked, pending_melts: [...marked.pending_melts, entry] });
+    return true;
+  });
+  if (!committed) {
+    return {
+      kind: "failed",
+      mint: mintUrl,
+      message: `Proofs at ${mintUrl} changed underneath the melt (another dvm run may have spent them). Nothing was sent.`,
+      settlement: "reverted",
+      quote: quoteView
+    };
+  }
+  let change;
+  let preimage;
+  try {
+    const result = await cashuWallet.completeMelt(preview, initial.lock_privkey);
+    change = result.change;
+    preimage = result.quote.payment_preimage ?? null;
+  } catch (err) {
+    return resolveFailedMelt(cashuWallet, mintUrl, entry, selectedKeys, quoteView, err);
+  }
+  const changeProofs = change.map((p) => toAgentProof(p, mintUrl, initial.lock_pubkey));
+  await withWalletLock(() => {
+    const fresh = loadAgentWallet();
+    if (!fresh) return;
+    saveAgentWallet({
+      ...fresh,
+      proofs: [...fresh.proofs.filter((p) => !selectedKeys.has(proofKey(p))), ...changeProofs],
+      pending_melts: fresh.pending_melts.filter((m) => m.quote_id !== entry.quote_id)
+    });
+  });
+  return {
+    kind: "sent",
+    mint: mintUrl,
+    quote: quoteView,
+    preimage,
+    change_sats: sumSats(changeProofs),
+    ...cappedByMintMax !== void 0 ? { mint_max_sats: cappedByMintMax } : {}
+  };
+}
+function meltBoundsOf(wallet) {
+  const reader = wallet;
+  try {
+    const nuts = reader.getMintInfo?.().cache?.nuts;
+    if (nuts === void 0 || nuts === null) return { minSats: null, maxSats: null };
+    return meltAmountBounds(nuts);
+  } catch {
+    return { minSats: null, maxSats: null };
+  }
+}
+function spendableAt(proofs, mintUrl) {
+  return proofs.filter((p) => p.mint === mintUrl && p.status === "valid" && p.reserved_for === void 0).slice().sort((a, b) => b.amount - a.amount);
+}
+async function resolveFailedMelt(cashuWallet, mintUrl, entry, selectedKeys, quoteView, err) {
+  let unpaid;
+  try {
+    const state = await cashuWallet.checkMeltQuoteBolt11(entry.quote_id);
+    unpaid = state.state === "UNPAID";
+  } catch {
+    unpaid = false;
+  }
+  if (!unpaid) {
+    return {
+      kind: "failed",
+      mint: mintUrl,
+      message: `${errorMessage(err)} \u2014 ${entry.amount_sats} sats may still be in flight at ${mintUrl}. Run \`dvm wallet show\` to reconcile before retrying.`,
+      settlement: "unresolved",
+      quote: quoteView
+    };
+  }
+  await withWalletLock(() => {
+    const fresh = loadAgentWallet();
+    if (!fresh) return;
+    const reverted = revertInFlight(fresh, selectedKeys);
+    saveAgentWallet({
+      ...reverted,
+      pending_melts: reverted.pending_melts.filter((m) => m.quote_id !== entry.quote_id)
+    });
+  });
+  return {
+    kind: "failed",
+    mint: mintUrl,
+    message: `${errorMessage(err)} \u2014 the mint confirms the invoice is unpaid, so the ${quoteView.debit_sats} sats are back in the wallet.`,
+    settlement: "reverted",
+    quote: quoteView
+  };
+}
+function selectInputs(candidates, target) {
+  if (target.kind === "all") return [...candidates];
+  const selected = [];
+  let total = 0;
+  for (const p of candidates) {
+    selected.push(p);
+    total += p.amount;
+    if (total >= target.sats) return selected;
+  }
+  return selected;
+}
+function widenSelection(candidates, selected, needed, currentInputFees) {
+  const chosen = new Set(selected.map((p) => proofKey(p)));
+  const rest = candidates.filter((p) => !chosen.has(proofKey(p)));
+  if (rest.length === 0) return null;
+  const next = [...selected];
+  let total = sumSats(next);
+  for (const p of rest) {
+    if (total >= needed + currentInputFees) break;
+    next.push(p);
+    total += p.amount;
+  }
+  return next.length === selected.length ? null : { selected: next };
+}
+function classifyPreCommitError(mintUrl, err) {
+  if (err instanceof DvmError && err.code === "lnurl_amount_out_of_range") {
+    return {
+      kind: "skipped",
+      mint: mintUrl,
+      reason: "amount_out_of_range",
+      message: err.message
+    };
+  }
+  return { kind: "failed", mint: mintUrl, message: errorMessage(err), settlement: "reverted" };
+}
+function sumSats(proofs) {
+  return proofs.reduce((sum, p) => sum + p.amount, 0);
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/lib/wallet-agent/denominations.ts
+var TINY_AMOUNT_THRESHOLD_SATS = 8;
+function computeSmartDenominations(amountSats, opts = {}) {
+  if (!Number.isFinite(amountSats) || amountSats <= 0) return [];
+  const cap = normalizeCap(opts.maxDenomination);
+  const withTail = opts.includeTinyTail !== false;
+  if (!withTail || amountSats < TINY_AMOUNT_THRESHOLD_SATS) {
+    return greedyPowerOfTwo(Math.floor(amountSats), cap);
+  }
+  const total = Math.floor(amountSats);
+  const small1 = Math.floor(total * 0.05);
+  const small2 = Math.floor(total * 0.1 / 2) * 2;
+  const small4 = Math.floor(total * 0.2 / 4) * 4;
+  const remainder = total - small1 - small2 - small4;
+  const out = [];
+  for (let i = 0; i < small1; i++) out.push(1);
+  for (let i = 0; i < small2 / 2; i++) out.push(2);
+  for (let i = 0; i < small4 / 4; i++) out.push(4);
+  out.push(...greedyPowerOfTwo(remainder, cap));
+  return out;
+}
+function greedyPowerOfTwo(n, cap) {
+  const out = [];
+  let r = n;
+  if (cap !== void 0 && r >= cap) {
+    const capCount = Math.floor(r / cap);
+    for (let i = 0; i < capCount; i++) out.push(cap);
+    r -= capCount * cap;
+  }
+  let bit = 1;
+  while (r > 0) {
+    if (r & 1) out.push(bit);
+    r = Math.floor(r / 2);
+    bit *= 2;
+  }
+  return out;
+}
+function normalizeCap(raw2) {
+  if (raw2 === void 0) return void 0;
+  if (!Number.isFinite(raw2) || raw2 <= 0) return void 0;
+  const floored = Math.floor(raw2);
+  let pow = 1;
+  while (pow * 2 <= floored) pow *= 2;
+  return pow;
+}
+
+// src/lib/wallet-agent/fund.ts
+import { MintQuoteState } from "@cashu/cashu-ts";
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+var DEFAULT_TIMEOUT_SEC = 600;
+async function fundAgentWallet(amountSats, opts) {
+  if (!Number.isFinite(amountSats) || amountSats <= 0) {
+    throw new DvmError(
+      "invalid_amount",
+      "Amount must be a positive integer number of sats.",
+      "Pass a positive sats amount, e.g. `dvm wallet fund 1000`, or a USD amount, e.g. `dvm wallet fund $5`."
+    );
+  }
+  const sats = Math.floor(amountSats);
+  const initial = loadAgentWallet();
+  if (!initial) {
+    throw new DvmError(
+      "wallet_missing",
+      "No agent wallet found.",
+      "Run `dvm wallet init` first to generate a lock keypair."
+    );
+  }
+  const cashuWallet = await (opts.getWalletForMint ?? getWallet)(opts.mintUrl);
+  const quote = await cashuWallet.createLockedMintQuote(sats, initial.lock_pubkey);
+  const pending = {
+    mint: opts.mintUrl,
+    quote_id: quote.quote,
+    amount_sats: sats,
+    requested_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await withWalletLock(() => {
+    const fresh = loadAgentWallet() ?? initial;
+    saveAgentWallet({
+      ...fresh,
+      pending_mints: [...fresh.pending_mints, pending]
+    });
+  });
+  let floatPayment;
+  if (opts.testSkipLightning) {
+  } else if (opts.payInvoice) {
+    floatPayment = await opts.payInvoice(quote.request, quote);
+    if (opts.onFloatPayment) await opts.onFloatPayment(floatPayment);
+  } else if (opts.onInvoice) {
+    await opts.onInvoice(quote.request, quote);
+  }
+  const finalState = await pollUntilPaidOrTimeout(cashuWallet, quote.quote, opts);
+  if (finalState === MintQuoteState.ISSUED) {
+    throw new DvmError(
+      "fund_already_issued",
+      `Mint quote ${quote.quote} was already collected by a concurrent run.`,
+      "Inspect wallet state with `dvm wallet show` \u2014 the proofs should be persisted by the other instance."
+    );
+  }
+  if (finalState !== MintQuoteState.PAID) {
+    throw new DvmError(
+      "fund_timeout",
+      floatPayment ? `Your Lightning wallet paid mint quote ${quote.quote}, but the mint has not credited it yet.` : `Mint quote ${quote.quote} was not paid within the fund timeout.`,
+      floatPayment ? "Run `dvm wallet show` \u2014 the pending mint is on disk and will be collected once the mint catches up." : "Pay the invoice from a Lightning wallet, then run `dvm wallet show` to recover the pending mint, or `dvm wallet fund <amount>` to start a new flow.",
+      floatPayment ? {
+        display: "Your Lightning wallet sent the payment but the mint hasn't credited it yet. The sats aren't lost \u2014 run 'dvm wallet show' and they'll be collected once the mint catches up.",
+        float_payment: floatPaymentJson(floatPayment)
+      } : void 0
+    );
+  }
+  const denominations = computeSmartDenominations(sats, {
+    maxDenomination: maxKeysetDenomination(cashuWallet),
+    includeTinyTail: false
+  });
+  const preview = await prepareP2PKMint(
+    cashuWallet,
+    sats,
+    quote,
+    initial.lock_privkey,
+    initial.lock_pubkey,
+    denominations
+  );
+  const minting = {
+    keyset_id: preview.keysetId,
+    outputs: serializeOutputData(preview.outputData)
+  };
+  await withWalletLock(() => {
+    const fresh = loadAgentWallet() ?? initial;
+    saveAgentWallet(upsertPending(fresh, { ...pending, minting }));
+  });
+  const proofs = await cashuWallet.completeMint(preview);
+  const agentProofs = proofs.map((p) => toAgentProof(p, opts.mintUrl, initial.lock_pubkey));
+  await withWalletLock(() => {
+    const post = loadAgentWallet() ?? initial;
+    saveAgentWallet({
+      ...post,
+      proofs: [...post.proofs, ...agentProofs],
+      pending_mints: post.pending_mints.filter((p) => p.quote_id !== quote.quote)
+    });
+  });
+  return {
+    mint: opts.mintUrl,
+    amount_sats: sats,
+    quote_id: quote.quote,
+    denominations,
+    proofs: agentProofs,
+    ...floatPayment ? { float_payment: floatPayment } : {}
+  };
+}
+async function prepareP2PKMint(cashuWallet, sats, quote, lockPrivkey, lockPubkey, denominations, extras = {}) {
+  const options = {
+    pubkey: lockPubkey
+  };
+  if (extras.locktimeUnixSec !== void 0) options.locktime = extras.locktimeUnixSec;
   if (extras.refundKeys && extras.refundKeys.length > 0) options.refundKeys = extras.refundKeys;
   return cashuWallet.prepareMint(
     "bolt11",
@@ -1604,6 +2544,17 @@ async function prepareP2PKMint(cashuWallet, sats, quote, lockPrivkey, lockPubkey
     { type: "p2pk", options, denominations }
   );
 }
+function fundTimeoutMs() {
+  const raw2 = process.env.DVM_FUND_TIMEOUT_SEC;
+  if (!raw2) return DEFAULT_TIMEOUT_SEC * 1e3;
+  const n = Number(raw2);
+  if (!Number.isFinite(n) || n <= 0) return DEFAULT_TIMEOUT_SEC * 1e3;
+  return Math.floor(n) * 1e3;
+}
+function upsertPending(wallet, entry) {
+  const others = wallet.pending_mints.filter((p) => p.quote_id !== entry.quote_id);
+  return { ...wallet, pending_mints: [...others, entry] };
+}
 function maxKeysetDenomination(cashuWallet) {
   const keysets = cashuWallet.keyChain.getKeysets();
   if (keysets.length === 0) return void 0;
@@ -1613,14 +2564,35 @@ function maxKeysetDenomination(cashuWallet) {
   if (amounts.length === 0) return void 0;
   return Math.max(...amounts);
 }
+async function pollUntilPaidOrTimeout(cashuWallet, quoteId, opts) {
+  const now = opts.now ?? (() => Date.now());
+  const sleep2 = opts.sleep ?? defaultSleep;
+  const intervalMs = opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const timeoutMs = opts.timeoutMs ?? fundTimeoutMs();
+  const start = now();
+  let lastState = MintQuoteState.UNPAID;
+  while (now() - start < timeoutMs) {
+    const checked = await cashuWallet.checkMintQuoteBolt11(quoteId);
+    lastState = checked.state;
+    if (opts.onPoll) opts.onPoll(lastState, now() - start);
+    if (lastState === MintQuoteState.PAID || lastState === MintQuoteState.ISSUED) {
+      return lastState;
+    }
+    await sleep2(intervalMs);
+  }
+  return lastState;
+}
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 // src/lib/wallet-agent/locktime.ts
 var DEFAULT_RESERVE_LOCKTIME_SECONDS = 30 * 24 * 60 * 60;
 var DEFAULT_PERCALL_LOCKTIME_SECONDS = 48 * 60 * 60;
 var PERCALL_LOCKTIME_ENV = "DVM_PERCALL_LOCKTIME_SEC";
 function perCallLocktimeSeconds(minLocktimeSeconds) {
-  const raw = process.env[PERCALL_LOCKTIME_ENV];
-  const parsed = raw ? Number(raw) : NaN;
+  const raw2 = process.env[PERCALL_LOCKTIME_ENV];
+  const parsed = raw2 ? Number(raw2) : NaN;
   const base = Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : DEFAULT_PERCALL_LOCKTIME_SECONDS;
   const floor = typeof minLocktimeSeconds === "number" && Number.isFinite(minLocktimeSeconds) ? Math.max(0, Math.floor(minLocktimeSeconds)) : 0;
   return Math.max(base, floor);
@@ -1631,6 +2603,35 @@ var SUFFIXES = {
   h: 60 * 60,
   d: 24 * 60 * 60
 };
+function parseLocktime(raw2) {
+  const trimmed = raw2.trim().toLowerCase();
+  const match = /^(\d+)([smhd])$/.exec(trimmed);
+  if (!match) {
+    throw new DvmError(
+      "invalid_locktime",
+      `Could not parse "${raw2}" as a locktime.`,
+      "Pass a positive integer followed by `s`, `m`, `h`, or `d` \u2014 e.g. `30d`, `12h`, `90m`."
+    );
+  }
+  const n = Number(match[1]);
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new DvmError(
+      "invalid_locktime",
+      `Locktime must be a positive number; got "${raw2}".`,
+      "Pass a positive integer followed by `s`, `m`, `h`, or `d` \u2014 e.g. `30d`, `12h`, `90m`."
+    );
+  }
+  const suffix = match[2];
+  const seconds = n * SUFFIXES[suffix];
+  return seconds;
+}
+function formatLocktime(seconds) {
+  if (seconds <= 0) return `${seconds}s`;
+  if (seconds % SUFFIXES.d === 0) return `${seconds / SUFFIXES.d}d`;
+  if (seconds % SUFFIXES.h === 0) return `${seconds / SUFFIXES.h}h`;
+  if (seconds % SUFFIXES.m === 0) return `${seconds / SUFFIXES.m}m`;
+  return `${seconds}s`;
+}
 
 // src/lib/wallet-agent/mint-inventory.ts
 async function loadConfiguredMints() {
@@ -1653,6 +2654,29 @@ async function loadConfiguredMints() {
     return merged;
   });
 }
+function buildDisplayMintInventory(wallet) {
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const url of wallet.mints) {
+    if (seen.has(url)) continue;
+    seen.add(url);
+    entries.push({ url, source: "configured" });
+  }
+  for (const proof of wallet.proofs) {
+    if (seen.has(proof.mint)) continue;
+    seen.add(proof.mint);
+    entries.push({ url: proof.mint, source: "proofs" });
+  }
+  for (const pending of wallet.pending_mints) {
+    if (seen.has(pending.mint)) continue;
+    seen.add(pending.mint);
+    entries.push({ url: pending.mint, source: "pending" });
+  }
+  if (entries.length === 0) {
+    entries.push({ url: DEFAULT_AGENT_MINT_URL, source: "default" });
+  }
+  return entries;
+}
 function dedupe(values) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
@@ -1664,84 +2688,492 @@ function dedupe(values) {
   return out;
 }
 
-// src/lib/wallet-agent/receive.ts
-import { Amount as Amount5, getP2PKExpectedWitnessPubkeys, getTokenMetadata } from "@cashu/cashu-ts";
-
-// src/lib/wallet-agent/recovery.ts
-import { MintQuoteState as MintQuoteState2 } from "@cashu/cashu-ts";
-
-// src/lib/wallet-agent/recovery-submissions.ts
-import {
-  Amount as Amount6,
-  CheckStateEnum,
-  getEncodedToken as getEncodedToken2
-} from "@cashu/cashu-ts";
-
-// src/lib/cashu/agent-refund-subkey.ts
-import { HDKey as HDKey2 } from "@scure/bip32";
-import { mnemonicToSeedSync as mnemonicToSeedSync2 } from "@scure/bip39";
-var PURPOSE_INDEX2 = 1789;
-var AGENT_REFUND_ROLE_INDEX = 2;
-function agentRefundSubkeyPath(canonicalDvmId) {
-  const dvmIndex = hashedCanonicalDvmId(canonicalDvmId);
-  return `m/${PURPOSE_INDEX2}'/${AGENT_REFUND_ROLE_INDEX}'/${dvmIndex}'`;
-}
-function deriveAgentRefundSubkey(mnemonic, canonicalDvmId) {
-  const seed = mnemonicToSeedSync2(mnemonic);
-  const hd = HDKey2.fromMasterSeed(seed);
-  const child = hd.derive(agentRefundSubkeyPath(canonicalDvmId));
-  if (!child.privateKey || !child.publicKey) {
-    throw new Error("Failed to derive agent refund subkey from mnemonic");
+// src/lib/wallet-agent/mint-selection.ts
+async function resolveFundMint(args) {
+  const { preferred, explicit, configured, sats } = args;
+  const probe = await probeMintHealthOnce(preferred);
+  if (explicit) {
+    if (probe.ok) {
+      return { url: preferred, fallbackKind: null, preferredProbe: probe };
+    }
+    const healthy = await findFundableAlternatives(configured, preferred, sats);
+    const hint = healthy.length > 0 ? `Pass --mint one of: ${healthy.join(", ")}, or drop --mint to auto-select a healthy mint.` : `No other wallet-configured mint can issue ${sats} sats right now \u2014 wait and retry, or add a new mint with \`dvm wallet mint-add\`.`;
+    throw new DvmError(
+      "mint_unhealthy",
+      `Mint ${preferred} failed health probe (${probe.error?.code ?? "unknown"}: ${probe.error?.message ?? "\u2014"}).`,
+      hint
+    );
   }
-  return {
-    privkey: Buffer.from(child.privateKey).toString("hex"),
-    pubkey: Buffer.from(child.publicKey).toString("hex")
+  if (canFund(probe, sats)) {
+    return { url: preferred, fallbackKind: null, preferredProbe: probe };
+  }
+  const preferredReason = fundRefusalReason(probe, sats);
+  const passedOver = [];
+  const notePassedOver = (mint, candidate) => {
+    passedOver.push({
+      mint,
+      reason: fundRefusalReason(candidate, sats),
+      bounds: candidate.mintAmountBounds ?? { minSats: null, maxSats: null }
+    });
   };
+  notePassedOver(preferred, probe);
+  for (const candidate of configured) {
+    if (candidate === preferred) continue;
+    const candidateProbe = await probeMintHealthOnce(candidate);
+    if (canFund(candidateProbe, sats)) {
+      const fallbackKind = fallbackKindFor(preferredReason);
+      return {
+        url: candidate,
+        fallbackKind,
+        preferredProbe: probe,
+        fallback: { preferred, selected: candidate, reason: preferredReason }
+      };
+    }
+    notePassedOver(candidate, candidateProbe);
+  }
+  const outOfRange = passedOver.filter((m) => isBoundsRefusal(m.reason));
+  const unavailable = passedOver.filter((m) => !isBoundsRefusal(m.reason));
+  if (outOfRange.length > 0) {
+    const named = outOfRange.map((m) => `${m.mint} takes ${describeMintBounds(m.bounds)}`).join("; ");
+    const alsoDown = unavailable.length > 0 ? ` ${unavailable.map((m) => `${m.mint} (${m.reason})`).join(", ")} couldn't be used at all right now.` : "";
+    const retryNote = unavailable.length > 0 ? " Retrying later may also help \u2014 at least one mint is currently unavailable rather than limited." : "";
+    throw new DvmError(
+      "mint_amount_out_of_range",
+      `No configured mint will issue ${sats} sats in one go: ${named}.${alsoDown}`,
+      `${suggestInRangeAmount(outOfRange, sats)}${retryNote} Or add a mint with different limits using \`dvm wallet mint-add\`. Nothing was charged and no Lightning invoice was created.`,
+      {
+        amount_sats: sats,
+        mint_bounds: outOfRange.map((m) => ({
+          mint: m.mint,
+          min_sats: m.bounds.minSats,
+          max_sats: m.bounds.maxSats
+        })),
+        unavailable_mints: unavailable.map((m) => ({ mint: m.mint, reason: m.reason }))
+      }
+    );
+  }
+  throw new DvmError(
+    "all_mints_unhealthy",
+    `No wallet-configured mint can currently issue ecash (preferred: ${preferred}, ${preferredReason}).`,
+    "Wait for at least one mint to recover, or add a new mint with `dvm wallet mint-add`. Existing balance is unaffected \u2014 `dvm wallet cash-out` still works against a mint that can only melt."
+  );
 }
-function deriveAgentRefundSubkeyPubkey(mnemonic, canonicalDvmId) {
-  return deriveAgentRefundSubkey(mnemonic, canonicalDvmId).pubkey;
-}
-
-// src/lib/credit-policy.ts
-import { randomUUID } from "crypto";
-
-// src/lib/x402/menu.ts
-function offersX402CreditFunding(menu, network) {
-  return matchesNetwork(x402CreditFundingNetworks(menu), network);
-}
-function offersX402CreditChannel(menu, network) {
-  return matchesNetwork(x402CreditChannelNetworks(menu), network);
+function describeMintBounds(bounds) {
+  const min = bounds?.minSats ?? null;
+  const max = bounds?.maxSats ?? null;
+  if (min !== null && max !== null) return `${min}\u2013${max} sats`;
+  if (max !== null) return `up to ${max} sats`;
+  if (min !== null) return `at least ${min} sats`;
+  return "any amount";
 }
-function x402CreditFlavour(menu, network) {
-  if (offersX402CreditChannel(menu, network)) return X402_BATCH_SETTLEMENT_SCHEME;
-  if (matchesNetwork(x402CreditExactNetworks(menu), network)) return X402_EXACT_SCHEME;
-  return void 0;
+function isBoundsRefusal(reason) {
+  return reason === "amount_below_min" || reason === "amount_above_max";
 }
-function offersX402CreditFlavour(menu, network, flavour) {
-  return matchesNetwork(
-    flavour === X402_BATCH_SETTLEMENT_SCHEME ? x402CreditChannelNetworks(menu) : x402CreditExactNetworks(menu),
-    network
-  );
+function canFund(probe, sats) {
+  return probe.ok && probe.mintingEnabled !== false && amountBoundsVerdict(sats, probe.mintAmountBounds) === "ok";
 }
-function x402InstrumentForFlavour(flavour) {
-  return flavour === X402_BATCH_SETTLEMENT_SCHEME ? "x402_channel" : "x402_exact";
+function fundRefusalReason(probe, sats) {
+  if (!probe.ok) return probe.error?.code ?? "unhealthy";
+  if (probe.mintingEnabled === false) return "minting_disabled";
+  const verdict = amountBoundsVerdict(sats, probe.mintAmountBounds);
+  return verdict === "below_min" ? "amount_below_min" : verdict === "above_max" ? "amount_above_max" : "unhealthy";
 }
-function x402FlavourForInstrument(instrument) {
-  if (instrument === "x402_channel") return X402_BATCH_SETTLEMENT_SCHEME;
-  if (instrument === "x402_exact") return X402_EXACT_SCHEME;
-  return void 0;
+function fallbackKindFor(reason) {
+  if (reason === "minting_disabled") return "capability";
+  if (isBoundsRefusal(reason)) return "bounds";
+  return "health";
 }
-function x402CreditChannelNetworks(menu) {
-  return schemeNetworks(menu, X402_BATCH_SETTLEMENT_SCHEME);
+function suggestInRangeAmount(outOfRange, sats) {
+  const maxima = outOfRange.map((m) => m.bounds.maxSats).filter((n) => n !== null);
+  const largestMax = maxima.length > 0 ? Math.max(...maxima) : null;
+  if (largestMax !== null && sats > largestMax) {
+    return `Fund ${largestMax} sats or less, then repeat for the rest.`;
+  }
+  const minima = outOfRange.map((m) => m.bounds.minSats).filter((n) => n !== null);
+  const smallestMin = minima.length > 0 ? Math.min(...minima) : null;
+  if (smallestMin !== null && sats < smallestMin) {
+    return `Fund at least ${smallestMin} sats.`;
+  }
+  return "Try a different amount.";
 }
-function x402CreditExactNetworks(menu) {
-  return schemeNetworks(menu, X402_EXACT_SCHEME);
+async function probeMintHealthOnce(mintUrl) {
+  return checkMintHealth(mintUrl, { retries: 1, backoffMs: [0] });
 }
-function x402CreditFundingNetworks(menu) {
-  return [.../* @__PURE__ */ new Set([...x402CreditChannelNetworks(menu), ...x402CreditExactNetworks(menu)])];
+async function findFundableAlternatives(configured, skip, sats) {
+  const healthy = [];
+  for (const mint of configured) {
+    if (mint === skip) continue;
+    const probe = await probeMintHealthOnce(mint);
+    if (canFund(probe, sats)) healthy.push(mint);
+  }
+  return healthy;
 }
-function schemeNetworks(menu, scheme) {
-  return (menu?.x402?.schemes ?? []).filter((entry) => entry.scheme === scheme).map((entry) => entry.network);
+
+// src/lib/wallet-agent/receive.ts
+import { Amount as Amount5, getP2PKExpectedWitnessPubkeys, getTokenMetadata } from "@cashu/cashu-ts";
+async function receiveToAgentWallet(token, opts = {}) {
+  const initial = loadAgentWallet();
+  if (!initial) {
+    throw new DvmError(
+      "wallet_missing",
+      "No agent wallet found.",
+      "Run `dvm wallet init` first to generate a lock keypair."
+    );
+  }
+  let mintUrl;
+  try {
+    mintUrl = getTokenMetadata(token).mint;
+  } catch {
+    throw new DvmError(
+      "invalid_token",
+      "Could not decode the Cashu token.",
+      "Pass a complete `cashu...` token string."
+    );
+  }
+  const cashuWallet = await (opts.getWalletForMint ?? getWallet)(mintUrl);
+  const ours = toLockPubkey(initial.lock_pubkey);
+  for (const p of cashuWallet.decodeToken(token).proofs) {
+    let allowed;
+    try {
+      allowed = getP2PKExpectedWitnessPubkeys(p.secret);
+    } catch {
+      continue;
+    }
+    if (allowed.length === 0) continue;
+    if (!allowed.map(toLockPubkey).includes(ours)) {
+      throw new DvmError(
+        "cashu_not_claimable",
+        "This token is P2PK-locked to a key that isn't your agent wallet's master lock pubkey.",
+        "If it was issued to you as a per-DVM refund (NUT-11 `refund` tag), claim it via `dvm wallet release` instead \u2014 that path derives the matching per-DVM refund privkey. Otherwise it was issued to a third party; ask the sender for a token locked to your wallet, or one with no lock."
+      );
+    }
+  }
+  const proofs = await cashuWallet.receive(
+    token,
+    { privkey: initial.lock_privkey },
+    { type: "p2pk", options: { pubkey: initial.lock_pubkey } }
+  );
+  const agentProofs = proofs.map((p) => toAgentProof(p, mintUrl, initial.lock_pubkey));
+  const claimedSats = proofs.reduce((sum, p) => sum + Amount5.from(p.amount).toNumber(), 0);
+  await withWalletLock(() => {
+    const fresh = loadAgentWallet() ?? initial;
+    const mints = fresh.mints.includes(mintUrl) ? fresh.mints : [...fresh.mints, mintUrl];
+    saveAgentWallet({
+      ...fresh,
+      mints,
+      proofs: [...fresh.proofs, ...agentProofs]
+    });
+  });
+  return { mintUrl, claimedSats, proofCount: agentProofs.length };
+}
+
+// src/lib/wallet-agent/recovery.ts
+import { MintQuoteState as MintQuoteState2 } from "@cashu/cashu-ts";
+async function sweepPendingMints(opts = {}) {
+  const wallet = loadAgentWallet();
+  if (!wallet || wallet.pending_mints.length === 0) {
+    return { outcomes: [], recovered_proofs: [], still_pending: [], errors: [] };
+  }
+  const now = opts.now ?? (() => Date.now());
+  const expirationMs = opts.expirationMs ?? fundTimeoutMs();
+  const getWalletForMint = opts.getWalletForMint ?? getWallet;
+  const outcomes = [];
+  for (const entry of wallet.pending_mints) {
+    const outcome = await processEntry(wallet, entry, now(), expirationMs, getWalletForMint);
+    outcomes.push(outcome);
+  }
+  if (outcomes.some(
+    (o) => o.kind === "minted" || o.kind === "restored" || o.kind === "already_issued" || o.kind === "expired"
+  )) {
+    await withWalletLock(() => {
+      const fresh = loadAgentWallet() ?? wallet;
+      const updated = outcomes.reduce(applyOutcome, fresh);
+      saveAgentWallet(updated);
+    });
+  }
+  return {
+    outcomes,
+    recovered_proofs: outcomes.flatMap(
+      (o) => o.kind === "minted" || o.kind === "restored" ? o.proofs : []
+    ),
+    still_pending: outcomes.filter(
+      (o) => o.kind === "still_pending"
+    ).map((o) => o.entry),
+    errors: outcomes.filter((o) => o.kind === "error").map((o) => ({ quote_id: o.entry.quote_id, error: o.error }))
+  };
+}
+async function processEntry(wallet, entry, nowMs, expirationMs, getWalletForMint) {
+  let cashuWallet;
+  try {
+    cashuWallet = await getWalletForMint(entry.mint);
+  } catch (err) {
+    return { kind: "error", entry, error: errorMessage2(err) };
+  }
+  let state;
+  let quoteResponse;
+  try {
+    quoteResponse = await cashuWallet.checkMintQuoteBolt11(entry.quote_id);
+    state = quoteResponse.state;
+  } catch (err) {
+    return { kind: "error", entry, error: errorMessage2(err) };
+  }
+  if (state === MintQuoteState2.ISSUED) {
+    if (!entry.minting) {
+      return { kind: "already_issued", entry };
+    }
+    try {
+      const restoredProofs = await restoreFromMintingState(
+        cashuWallet,
+        entry.minting,
+        wallet.lock_pubkey,
+        entry.mint
+      );
+      if (restoredProofs.length === 0) {
+        return { kind: "already_issued", entry };
+      }
+      return { kind: "restored", entry, proofs: restoredProofs };
+    } catch (err) {
+      return { kind: "error", entry, error: errorMessage2(err) };
+    }
+  }
+  if (state === MintQuoteState2.PAID) {
+    try {
+      const denominations = computeSmartDenominations(entry.amount_sats, {
+        maxDenomination: maxKeysetDenomination(cashuWallet),
+        includeTinyTail: false
+      });
+      const preview = await prepareP2PKMint(
+        cashuWallet,
+        entry.amount_sats,
+        quoteResponse,
+        wallet.lock_privkey,
+        wallet.lock_pubkey,
+        denominations
+      );
+      const minting = {
+        keyset_id: preview.keysetId,
+        outputs: serializeOutputData(preview.outputData)
+      };
+      await withWalletLock(() => {
+        const fresh = loadAgentWallet() ?? wallet;
+        saveAgentWallet({
+          ...fresh,
+          pending_mints: fresh.pending_mints.map(
+            (p) => p.quote_id === entry.quote_id ? { ...p, minting } : p
+          )
+        });
+      });
+      const proofs = await cashuWallet.completeMint(preview);
+      const agentProofs = proofs.map((p) => toAgentProof(p, entry.mint, wallet.lock_pubkey));
+      return { kind: "minted", entry, proofs: agentProofs };
+    } catch (err) {
+      return { kind: "error", entry, error: errorMessage2(err) };
+    }
+  }
+  const requestedAtMs = Date.parse(entry.requested_at);
+  const ageMs2 = Number.isFinite(requestedAtMs) ? nowMs - requestedAtMs : Infinity;
+  if (ageMs2 > expirationMs) {
+    return { kind: "expired", entry };
+  }
+  return { kind: "still_pending", entry };
+}
+async function restoreFromMintingState(cashuWallet, minting, lockPubkey, mintUrl) {
+  const proofs = await restoreProofsFromOutputs(cashuWallet, minting.keyset_id, minting.outputs);
+  return proofs.map((proof) => toAgentProof(proof, mintUrl, lockPubkey));
+}
+function applyOutcome(wallet, outcome) {
+  if (outcome.kind === "still_pending" || outcome.kind === "error") {
+    return wallet;
+  }
+  const next = {
+    ...wallet,
+    pending_mints: wallet.pending_mints.filter((p) => p.quote_id !== outcome.entry.quote_id)
+  };
+  if (outcome.kind === "minted" || outcome.kind === "restored") {
+    next.proofs = [...wallet.proofs, ...outcome.proofs];
+  }
+  return next;
+}
+function errorMessage2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/lib/wallet-agent/recovery-melt.ts
+async function sweepPendingMelts(opts = {}) {
+  const wallet = loadAgentWallet();
+  if (!wallet || wallet.pending_melts.length === 0) {
+    return { outcomes: [], settled_sats: 0, returned_sats: 0, still_pending: [], errors: [] };
+  }
+  const now = opts.now ?? (() => Date.now());
+  const abandonAfterMs = opts.abandonAfterMs ?? meltInFlightTimeoutSeconds() * 1e3;
+  const getWalletForMint = opts.getWalletForMint ?? getWallet;
+  const outcomes = [];
+  for (const entry of wallet.pending_melts) {
+    outcomes.push(await processEntry2(wallet, entry, now(), abandonAfterMs, getWalletForMint));
+  }
+  if (outcomes.some((o) => o.kind === "settled" || o.kind === "reverted")) {
+    await withWalletLock(() => {
+      const fresh = loadAgentWallet() ?? wallet;
+      saveAgentWallet(outcomes.reduce(applyOutcome2, fresh));
+    });
+  }
+  return {
+    outcomes,
+    settled_sats: outcomes.filter((o) => o.kind === "settled").reduce((sum, o) => sum + o.entry.amount_sats, 0),
+    returned_sats: outcomes.filter((o) => o.kind === "reverted").reduce((sum, o) => sum + o.returned_sats, 0),
+    still_pending: outcomes.filter(
+      (o) => o.kind === "still_pending"
+    ).map((o) => o.entry),
+    errors: outcomes.filter((o) => o.kind === "error").map((o) => ({ quote_id: o.entry.quote_id, error: o.error }))
+  };
+}
+async function processEntry2(wallet, entry, nowMs, abandonAfterMs, getWalletForMint) {
+  let cashuWallet;
+  try {
+    cashuWallet = await getWalletForMint(entry.mint);
+  } catch (err) {
+    return { kind: "error", entry, error: errorMessage3(err) };
+  }
+  let state;
+  try {
+    const quote = await cashuWallet.checkMeltQuoteBolt11(entry.quote_id);
+    state = quote.state;
+  } catch (err) {
+    return { kind: "error", entry, error: errorMessage3(err) };
+  }
+  if (state === "PAID") {
+    let change;
+    try {
+      change = await restoreChange(cashuWallet, entry, wallet.lock_pubkey);
+    } catch {
+      change = [];
+    }
+    return { kind: "settled", entry, change };
+  }
+  if (state === "UNPAID") {
+    const createdAtMs = Date.parse(entry.created_at);
+    const ageMs2 = Number.isFinite(createdAtMs) ? nowMs - createdAtMs : Infinity;
+    if (ageMs2 <= abandonAfterMs) return { kind: "still_pending", entry };
+    return {
+      kind: "reverted",
+      entry,
+      returned_sats: entry.input_proofs.reduce((sum, p) => sum + p.amount, 0)
+    };
+  }
+  return { kind: "still_pending", entry };
+}
+async function restoreChange(cashuWallet, entry, lockPubkey) {
+  if (!entry.melting || entry.melting.outputs.length === 0) return [];
+  const data = rehydrateOutputData(entry.melting.outputs);
+  const keyset = cashuWallet.keyChain.getKeyset(entry.melting.keyset_id);
+  const restored = await cashuWallet.mint.restore({
+    outputs: data.map((d) => d.blindedMessage)
+  });
+  if (restored.outputs.length !== restored.signatures.length) {
+    throw new Error(
+      `mint returned mismatched outputs (${restored.outputs.length}) and signatures (${restored.signatures.length}) \u2014 NUT-09 requires parallel arrays`
+    );
+  }
+  const byB = new Map(data.map((d) => [d.blindedMessage.B_, d]));
+  const proofs = [];
+  for (let i = 0; i < restored.signatures.length; i++) {
+    const owner = byB.get(restored.outputs[i].B_);
+    if (!owner) continue;
+    proofs.push(
+      toAgentProof(owner.toProof(restored.signatures[i], keyset), entry.mint, lockPubkey)
+    );
+  }
+  return proofs;
+}
+function applyOutcome2(wallet, outcome) {
+  if (outcome.kind === "still_pending" || outcome.kind === "error") return wallet;
+  const inputKeys = new Set(outcome.entry.input_proofs.map((p) => proofKey(p)));
+  const next = {
+    ...wallet,
+    pending_melts: wallet.pending_melts.filter((m) => m.quote_id !== outcome.entry.quote_id)
+  };
+  if (outcome.kind === "settled") {
+    next.proofs = [...next.proofs.filter((p) => !inputKeys.has(proofKey(p))), ...outcome.change];
+    return next;
+  }
+  return revertInFlight(next, inputKeys);
+}
+function errorMessage3(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/lib/wallet-agent/recovery-submissions.ts
+import {
+  Amount as Amount6,
+  CheckStateEnum,
+  getEncodedToken as getEncodedToken2
+} from "@cashu/cashu-ts";
+
+// src/lib/cashu/agent-refund-subkey.ts
+import { HDKey as HDKey2 } from "@scure/bip32";
+import { mnemonicToSeedSync as mnemonicToSeedSync2 } from "@scure/bip39";
+var PURPOSE_INDEX2 = 1789;
+var AGENT_REFUND_ROLE_INDEX = 2;
+function agentRefundSubkeyPath(canonicalDvmId) {
+  const dvmIndex = hashedCanonicalDvmId(canonicalDvmId);
+  return `m/${PURPOSE_INDEX2}'/${AGENT_REFUND_ROLE_INDEX}'/${dvmIndex}'`;
+}
+function deriveAgentRefundSubkey(mnemonic, canonicalDvmId) {
+  const seed = mnemonicToSeedSync2(mnemonic);
+  const hd = HDKey2.fromMasterSeed(seed);
+  const child = hd.derive(agentRefundSubkeyPath(canonicalDvmId));
+  if (!child.privateKey || !child.publicKey) {
+    throw new Error("Failed to derive agent refund subkey from mnemonic");
+  }
+  return {
+    privkey: Buffer.from(child.privateKey).toString("hex"),
+    pubkey: Buffer.from(child.publicKey).toString("hex")
+  };
+}
+function deriveAgentRefundSubkeyPubkey(mnemonic, canonicalDvmId) {
+  return deriveAgentRefundSubkey(mnemonic, canonicalDvmId).pubkey;
+}
+
+// src/lib/credit-policy.ts
+import { randomUUID } from "crypto";
+
+// src/lib/x402/menu.ts
+function offersX402CreditFunding(menu, network) {
+  return matchesNetwork(x402CreditFundingNetworks(menu), network);
+}
+function offersX402CreditChannel(menu, network) {
+  return matchesNetwork(x402CreditChannelNetworks(menu), network);
+}
+function x402CreditFlavour(menu, network) {
+  if (offersX402CreditChannel(menu, network)) return X402_BATCH_SETTLEMENT_SCHEME;
+  if (matchesNetwork(x402CreditExactNetworks(menu), network)) return X402_EXACT_SCHEME;
+  return void 0;
+}
+function offersX402CreditFlavour(menu, network, flavour) {
+  return matchesNetwork(
+    flavour === X402_BATCH_SETTLEMENT_SCHEME ? x402CreditChannelNetworks(menu) : x402CreditExactNetworks(menu),
+    network
+  );
+}
+function x402InstrumentForFlavour(flavour) {
+  return flavour === X402_BATCH_SETTLEMENT_SCHEME ? "x402_channel" : "x402_exact";
+}
+function x402FlavourForInstrument(instrument) {
+  if (instrument === "x402_channel") return X402_BATCH_SETTLEMENT_SCHEME;
+  if (instrument === "x402_exact") return X402_EXACT_SCHEME;
+  return void 0;
+}
+function x402CreditChannelNetworks(menu) {
+  return schemeNetworks(menu, X402_BATCH_SETTLEMENT_SCHEME);
+}
+function x402CreditExactNetworks(menu) {
+  return schemeNetworks(menu, X402_EXACT_SCHEME);
+}
+function x402CreditFundingNetworks(menu) {
+  return [.../* @__PURE__ */ new Set([...x402CreditChannelNetworks(menu), ...x402CreditExactNetworks(menu)])];
+}
+function schemeNetworks(menu, scheme) {
+  return (menu?.x402?.schemes ?? []).filter((entry) => entry.scheme === scheme).map((entry) => entry.network);
 }
 function matchesNetwork(networks, network) {
   return networks.some((candidate) => network === void 0 || candidate === network);
@@ -1755,7 +3187,9 @@ var TIER2_MIN_RECEIPTS = 15;
 var TIER2_MIN_SPAN_MS = 7 * 24 * 60 * 60 * 1e3;
 var OPEN_TARGET_JOBS = 20;
 var CASHU_REFILL_TARGET_JOBS = 40;
+var TOPUP_THRESHOLD_FRACTION = 0.25;
 var DEFAULT_CREDIT_POSTURE = "suggest";
+var POCKET_TARGET_MICRO = 5e6;
 function trustTierFor(args) {
   const ladder = trustLadderFor(args);
   return { tier: ladder.tier, capMicro: ladder.capMicro ?? args.menu.max_micro };
@@ -1824,6 +3258,18 @@ function effectiveFundingRail(config, endpoint, identity) {
     return { rail: global, source: "global", ...conflict ? { conflict } : {} };
   return { source: "default", ...conflict ? { conflict } : {} };
 }
+function automaticCreditBoundRail(stored) {
+  if (stored?.status !== "active" || stored.reconciliationPending) return void 0;
+  return isCreditFundRail(stored.rail) ? stored.rail : void 0;
+}
+function trustOverrideCapMicro(args) {
+  const raw2 = args.builderPubkey ? lookupOverride(args.config?.trustOverrides, args.builderPubkey) : void 0;
+  if (!raw2) return void 0;
+  if (raw2.trim().toLowerCase() === "builder-max") {
+    return args.menu?.max_micro ?? Number.POSITIVE_INFINITY;
+  }
+  return parseCapMicro(raw2);
+}
 function tierCapOverrides(config) {
   const out = {};
   const tier0 = parseCapMicro(config?.tier0Cap);
@@ -1973,6 +3419,81 @@ function planCreditForQuote(args) {
     railReason: openRoute.reason
   };
 }
+function planProbeDraw(args) {
+  const now = args.now ?? Date.now();
+  const implicit = [...args.implicit ?? []].filter(
+    (credit) => credit.status === "active" && credit.remainingMicro > 0 && credit.expiryMs > now
+  ).sort((a, b) => a.expiryMs - b.expiryMs).at(0);
+  if (implicit) {
+    if (effectiveCreditPosture(args.config, implicit.endpoint, args.identity).posture === "off") {
+      return {
+        mode: "none",
+        drawSkipped: {
+          reason: "posture_off",
+          creditId: implicit.creditId,
+          remainingMicro: implicit.remainingMicro
+        }
+      };
+    }
+    return {
+      mode: "draw",
+      creditId: implicit.creditId,
+      drawId: randomUUID(),
+      source: "implicit"
+    };
+  }
+  const stored = args.stored;
+  if (!stored) return { mode: "none" };
+  const skip = (reason, extra) => ({
+    mode: "none",
+    drawSkipped: {
+      reason,
+      creditId: stored.creditId,
+      remainingMicro: stored.remainingMicro,
+      ...extra
+    }
+  });
+  if (effectiveCreditPosture(args.config, stored.endpoint, args.identity).posture === "off") {
+    return skip("posture_off");
+  }
+  if (stored.status !== "active") return skip("not_active");
+  if (stored.reconciliationPending) return skip("reconciliation_pending");
+  if (stored.remainingMicro <= 0 && !stored.provisional) return skip("exhausted");
+  if (stored.expiryMs > 0 && stored.expiryMs <= now) return skip("expired");
+  if (stored.lastPriceMicro !== void 0 && args.btcRate > 0) {
+    const ceilingMicro = msatsToMicro(args.drawCeilingMsats, args.btcRate);
+    if (ceilingMicro > 0 && stored.lastPriceMicro > ceilingMicro) {
+      return skip("price_above_ceiling", {
+        ceilingMicro,
+        lastPriceMicro: stored.lastPriceMicro,
+        ceilingSource: args.drawCeilingSource
+      });
+    }
+  }
+  return { mode: "draw", creditId: stored.creditId, drawId: randomUUID(), source: "prepaid" };
+}
+function needsTopup(balanceMicro, targetMicro) {
+  return targetMicro > 0 && balanceMicro < targetMicro * TOPUP_THRESHOLD_FRACTION;
+}
+function pocketTargetMicro(config) {
+  return parseCapMicro(config?.pocketTarget) ?? POCKET_TARGET_MICRO;
+}
+function needsPocketRefill(balanceMicro, targetMicro) {
+  return needsTopup(balanceMicro, targetMicro);
+}
+function fundWireAmountMicro(priceMicroServer, fundMsats, requiredMsats) {
+  if (fundMsats === requiredMsats) return priceMicroServer;
+  return Math.round(priceMicroServer * fundMsats / requiredMsats);
+}
+function readFundValuation(fields) {
+  const structured = usableMicro(fields.expectedMicro);
+  if (structured !== void 0) return { kind: "figure", micro: structured };
+  const match = /quoted price \((\d+)\)/.exec(fields.message ?? "");
+  const stated = match ? usableMicro(Number(match[1])) : void 0;
+  if (stated !== void 0) return { kind: "figure", micro: stated };
+  const providerStatedSomething = fields.expectedMicro !== void 0 || match !== null;
+  return providerStatedSomething ? { kind: "malformed" } : { kind: "absent" };
+}
 function msatsToMicro(msats, btcRate) {
   return Math.round(msatsToUsd(msats, btcRate) * 1e6);
 }
@@ -1988,6 +3509,9 @@ function perDvmEntriesFor(config, endpoint, identity) {
   );
 }
 var POSTURE_STRICTNESS = { auto: 0, suggest: 1, off: 2 };
+function usableMicro(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
 function fundAmounts(fundMicro, btcRate) {
   const fundSats = microToSats(fundMicro, btcRate);
   return { fundMicro, fundSats, fundMsats: fundSats * 1e3 };
@@ -2024,6 +3548,14 @@ function targetJobsFor(config, endpoint, identity) {
   if (targets.length > 0) return Math.min(...targets);
   return config?.targetJobs;
 }
+function lookupOverride(overrides, builderPubkey) {
+  if (!overrides) return void 0;
+  const key = builderPubkey.trim().toLowerCase();
+  for (const [pubkey, cap] of Object.entries(overrides)) {
+    if (pubkey.trim().toLowerCase() === key) return cap;
+  }
+  return void 0;
+}
 function parseCapMicro(cap) {
   if (!cap) return void 0;
   const match = /^\$?(\d+(?:\.\d{1,6})?)$/.exec(cap.trim());
@@ -2684,6 +4216,32 @@ async function commitAgentSpend(args) {
     saveAgentWallet(next);
   });
 }
+async function correctPendingFundAmount(args) {
+  await withWalletLock(() => {
+    const wallet = loadAgentWallet();
+    if (!wallet) return;
+    const next = {
+      ...wallet,
+      pending_submissions: wallet.pending_submissions.map((s) => {
+        if (s.request_id !== args.requestId || !s.context) return s;
+        const data = s.context.submit_body.data;
+        const fund = data?.fund;
+        if (!fund) return s;
+        return {
+          ...s,
+          context: {
+            ...s.context,
+            submit_body: {
+              ...s.context.submit_body,
+              data: { ...data, fund: { ...fund, amount_micro: args.amountMicro } }
+            }
+          }
+        };
+      })
+    };
+    saveAgentWallet(next);
+  });
+}
 async function abandonPendingSubmission(args) {
   await withWalletLock(() => {
     const wallet = loadAgentWallet();
@@ -2825,20 +4383,1085 @@ function minOvershootSubset(proofs, amountSats) {
       reachable.set(next, [...indices2, i]);
     }
   }
-  let bestTarget = -1;
-  for (const t of reachable.keys()) {
-    if (t >= amountSats && (bestTarget === -1 || t < bestTarget)) bestTarget = t;
+  let bestTarget = -1;
+  for (const t of reachable.keys()) {
+    if (t >= amountSats && (bestTarget === -1 || t < bestTarget)) bestTarget = t;
+  }
+  if (bestTarget === -1) return null;
+  const indices = reachable.get(bestTarget) ?? [];
+  return { selected: indices.map((i) => proofs[i]), totalSats: bestTarget };
+}
+
+// src/lib/wallet-agent/recovery-submissions.ts
+var RESUME_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var RESUME_MAX_ATTEMPTS = 5;
+async function sweepPendingSubmissions(opts = {}) {
+  const wallet = loadAgentWallet();
+  if (!wallet || wallet.pending_submissions.length === 0) {
+    return { outcomes: [] };
+  }
+  const deps = {
+    httpPost: opts.httpPost ?? createDefaultHttpPost(opts.fetchImpl ?? fetch),
+    getWalletForMint: opts.getWalletForMint ?? getWallet,
+    readMnemonic: opts.readMnemonic ?? readAgentMnemonic,
+    lockPubkey: wallet.lock_pubkey
+  };
+  const now = opts.now ?? (() => Date.now());
+  const outcomes = [];
+  for (const entry of wallet.pending_submissions) {
+    outcomes.push(await resolveEntry(entry, deps, now()));
+  }
+  if (outcomes.some(mutatesWallet)) {
+    await withWalletLock(() => {
+      const fresh = loadAgentWallet() ?? wallet;
+      const next = outcomes.reduce(
+        (acc, outcome) => applyOutcome3(acc, outcome, now),
+        fresh
+      );
+      saveAgentWallet(next);
+    });
+  }
+  return { outcomes };
+}
+async function recoverPendingSubmission(opts) {
+  if (!UUID_V4_RE.test(opts.requestId))
+    throw new DvmError("invalid_request_id", "The pending-submission request id must be a UUIDv4.");
+  if (!SHA256_RE.test(opts.bindingFingerprint))
+    throw new DvmError(
+      "invalid_submission_binding",
+      "The pending-submission binding fingerprint must be lowercase SHA-256 hex."
+    );
+  return withWalletLock(async () => {
+    const wallet = loadAgentWallet();
+    if (!wallet)
+      throw new DvmError("wallet_missing", "No agent wallet found.", "Run: dvm wallet init");
+    const matches = wallet.pending_submissions.filter(
+      (entry2) => entry2.request_id === opts.requestId
+    );
+    if (matches.length !== 1)
+      throw new DvmError(
+        "submission_not_found",
+        `No unique pending submission exists for request ${opts.requestId}.`,
+        "Inspect the journal with: dvm wallet submissions"
+      );
+    const entry = matches[0];
+    const binding = entry.context && cashuSubmissionBindingFromContext(entry.context);
+    const recomputed = binding ? cashuSubmissionBindingFingerprint(binding) : null;
+    if (entry.context?.binding_fingerprint !== opts.bindingFingerprint || recomputed !== opts.bindingFingerprint)
+      throw new DvmError(
+        "submission_binding_mismatch",
+        "The saved submission does not match the approved strict request binding.",
+        "Do not recover by endpoint, mint, or amount. Rebuild evidence for the exact saved request."
+      );
+    if (entry.output_proofs.length === 0 || entry.swapping)
+      throw new DvmError(
+        "submission_not_ready",
+        "The exact submission has no completed payment output to recover.",
+        "Use read-only NUT-09/NUT-07 reconciliation for the interrupted swap."
+      );
+    if ((entry.attempts ?? 0) !== 0)
+      throw new DvmError(
+        "submission_recovery_exhausted",
+        "The exact strict submission already consumed its one recovery attempt.",
+        "Use read-only receipt and job lookup; do not re-submit the payment."
+      );
+    const now = opts.now ?? (() => Date.now());
+    const attempted = {
+      ...entry,
+      attempts: 1,
+      last_attempt_at: new Date(now()).toISOString()
+    };
+    saveAgentWallet({
+      ...wallet,
+      pending_submissions: wallet.pending_submissions.map(
+        (candidate) => candidate.request_id === opts.requestId ? attempted : candidate
+      )
+    });
+    const outcome = await shipEntry(
+      attempted,
+      opts.httpPost ?? createDefaultHttpPost(opts.fetchImpl ?? fetch)
+    );
+    if (outcome.kind === "shipped" || outcome.kind === "already_accepted") {
+      const current = loadAgentWallet() ?? wallet;
+      saveAgentWallet(applyOutcome3(current, outcome, now));
+      return {
+        requestId: opts.requestId,
+        outcome: outcome.kind,
+        jobId: outcome.kind === "shipped" ? outcome.jobId ?? null : null,
+        attemptCount: 1
+      };
+    }
+    return { requestId: opts.requestId, outcome: "pending", jobId: null, attemptCount: 1 };
+  });
+}
+function isResumable(entry) {
+  return resumeBody(entry) !== null;
+}
+function reclaimAtMs(entry) {
+  if (entry.output_proofs.length === 0) return null;
+  if (!entry.canonical_id || typeof entry.t_expire !== "number") return null;
+  return entry.t_expire;
+}
+async function resolveEntry(entry, deps, nowMs) {
+  if (entry.output_proofs.length === 0) {
+    const inFlightWindowMs = inFlightTimeoutSeconds() * 1e3;
+    if (entry.swapping) {
+      return ageMs(entry, nowMs) >= inFlightWindowMs ? recoverPreparedSwap(entry, deps) : { kind: "no_swap", entry };
+    }
+    return ageMs(entry, nowMs) >= inFlightWindowMs ? { kind: "pruned", entry } : { kind: "no_swap", entry };
+  }
+  const reclaimAt = reclaimAtMs(entry);
+  if (reclaimAt !== null && nowMs >= reclaimAt) {
+    return reclaimEntry(entry, deps);
+  }
+  if (!isResumable(entry)) {
+    return { kind: "unresumable", entry };
+  }
+  if (ageMs(entry, nowMs) > RESUME_MAX_AGE_MS) {
+    return { kind: "stale", entry, reason: "older than the resume window" };
+  }
+  if ((entry.attempts ?? 0) >= RESUME_MAX_ATTEMPTS) {
+    return { kind: "stale", entry, reason: `no response after ${RESUME_MAX_ATTEMPTS} attempts` };
+  }
+  return shipEntry(entry, deps.httpPost);
+}
+async function recoverPreparedSwap(entry, deps) {
+  const swapping = entry.swapping;
+  if (!swapping) return { kind: "pruned", entry };
+  let cashuWallet;
+  try {
+    cashuWallet = await deps.getWalletForMint(entry.mint);
+  } catch (err) {
+    return { kind: "swap_recovery_pending", entry, reason: errorText2(err) };
+  }
+  let sendData;
+  let keepData;
+  try {
+    sendData = rehydrateOutputData(swapping.send_outputs);
+    keepData = rehydrateOutputData(swapping.keep_outputs);
+  } catch (err) {
+    return { kind: "swap_recovery_pending", entry, reason: errorText2(err) };
+  }
+  const allData = [...sendData, ...keepData];
+  let restoreError;
+  try {
+    const restored = await cashuWallet.mint.restore({
+      outputs: allData.map((data) => data.blindedMessage)
+    });
+    if (restored.outputs.length !== restored.signatures.length) {
+      return {
+        kind: "swap_recovery_pending",
+        entry,
+        reason: "mint returned mismatched NUT-09 outputs and signatures"
+      };
+    }
+    const signaturesByOutput = new Map(
+      restored.outputs.map((output, index) => [output.B_, restored.signatures[index]])
+    );
+    if (allData.length > 0 && allData.every((data) => signaturesByOutput.has(data.blindedMessage.B_))) {
+      const restoreGroup = (data) => data.map((output) => {
+        const signature = signaturesByOutput.get(output.blindedMessage.B_);
+        if (!signature) throw new Error("mint omitted a restored output");
+        if (signature.id !== swapping.keyset_id) {
+          throw new Error("mint restored an output under an unexpected keyset");
+        }
+        return output.toProof(signature, cashuWallet.keyChain.getKeyset(swapping.keyset_id));
+      });
+      const send = restoreGroup(sendData);
+      const keep = restoreGroup(keepData);
+      const cashuToken = getEncodedToken2({ mint: entry.mint, proofs: send });
+      return {
+        kind: "swap_restored",
+        entry,
+        outputs: send.map((proof) => toAgentProof(proof, entry.mint, entry.intended_lock_pubkey)),
+        keep: keep.map((proof) => toAgentProof(proof, entry.mint, deps.lockPubkey)),
+        cashuToken
+      };
+    }
+    if (restored.outputs.length > 0) {
+      return {
+        kind: "swap_recovery_pending",
+        entry,
+        reason: "mint restored only part of the interrupted swap"
+      };
+    }
+  } catch (err) {
+    restoreError = errorText2(err);
+  }
+  try {
+    const states = await cashuWallet.checkProofsStates(toCashuProofs(swapping.input_proofs));
+    if (states.length === swapping.input_proofs.length && states.every((state) => state.state === CheckStateEnum.UNSPENT)) {
+      return { kind: "swap_reverted", entry };
+    }
+    return {
+      kind: "swap_recovery_pending",
+      entry,
+      reason: restoreError ? `NUT-09 restore failed (${restoreError}); mint still reports the interrupted swap inputs spent or pending` : "mint still reports the interrupted swap inputs spent or pending"
+    };
+  } catch (err) {
+    return { kind: "swap_recovery_pending", entry, reason: errorText2(err) };
+  }
+}
+async function reclaimEntry(entry, deps) {
+  const skipped = (reason, terminal = false) => ({
+    kind: "reclaim_skipped",
+    entry,
+    reason,
+    terminal
+  });
+  const mnemonic = deps.readMnemonic();
+  if (!mnemonic) {
+    return skipped(
+      "no mnemonic at ~/.dvm/wallet.mnemonic, so the refund key can't be derived \u2014 restore it with `dvm wallet recover`"
+    );
+  }
+  let refundPrivkey;
+  try {
+    const refund = deriveAgentRefundSubkey(mnemonic, entry.canonical_id ?? "");
+    if (entry.refund_pubkey && entry.refund_pubkey !== refund.pubkey) {
+      return skipped(
+        "this wallet's mnemonic does not derive the refund key the payment was locked to"
+      );
+    }
+    refundPrivkey = refund.privkey;
+  } catch (err) {
+    return skipped(errorText2(err));
+  }
+  let cashuWallet;
+  try {
+    cashuWallet = await deps.getWalletForMint(entry.mint);
+  } catch (err) {
+    return skipped(errorText2(err));
+  }
+  let grouped;
+  try {
+    grouped = await cashuWallet.groupProofsByState(toCashuProofs(entry.output_proofs));
+  } catch (err) {
+    return skipped(errorText2(err));
+  }
+  const spentSecrets = new Set(grouped.spent.map((p) => p.secret));
+  const pendingSecrets = new Set(grouped.pending.map((p) => p.secret));
+  const spent = entry.output_proofs.filter((p) => spentSecrets.has(p.secret));
+  const pending = entry.output_proofs.filter((p) => pendingSecrets.has(p.secret));
+  const unspent = entry.output_proofs.filter(
+    (p) => !spentSecrets.has(p.secret) && !pendingSecrets.has(p.secret)
+  );
+  if (unspent.length === 0) {
+    return pending.length > 0 ? skipped("the mint still reports these proofs in flight") : { kind: "already_accepted", entry };
+  }
+  if (pending.length > 0) {
+    return skipped("the mint still reports some of these proofs in flight");
+  }
+  const totalSats = unspent.reduce((sum, p) => sum + p.amount, 0);
+  const inputs = toCashuProofs(unspent);
+  let outputs;
+  try {
+    const swapFeeSats = swapFeeForProofs(cashuWallet, inputs);
+    const allowance = reclaimFeeAllowance(entry);
+    if (!allowance.ok) {
+      return skipped(allowance.reason, true);
+    }
+    if (allowance.remainingSats !== null && swapFeeSats > allowance.remainingSats) {
+      return skipped(
+        `the initial swap used ${allowance.initialSats} sats of this job's ${allowance.maxSats}-sat Cashu fee ceiling, leaving a ${allowance.remainingSats}-sat allowance; the mint's ${swapFeeSats}-sat recovery swap fee exceeds that remainder`,
+        true
+      );
+    }
+    const reclaimSats = totalSats - swapFeeSats;
+    if (reclaimSats <= 0) {
+      return skipped(
+        `worth ${totalSats} sats, which does not cover the mint's ${swapFeeSats}-sat swap fee`,
+        true
+      );
+    }
+    const result = await cashuWallet.ops.send(reclaimSats, inputs).privkey(refundPrivkey).asP2PK({ pubkey: deps.lockPubkey }).run();
+    outputs = result.send;
+  } catch (err) {
+    const diagnostic = missingDleqRecoveryDiagnostic(inputs, err);
+    return skipped(diagnostic ?? errorText2(err), diagnostic !== null);
+  }
+  return {
+    kind: "reclaimed",
+    entry,
+    outputs: outputs.map((p) => toAgentProof(p, entry.mint, deps.lockPubkey)),
+    reclaimed_sats: outputs.reduce((sum, p) => sum + Amount6.from(p.amount).toNumber(), 0),
+    spent_sats: spent.reduce((sum, p) => sum + p.amount, 0)
+  };
+}
+function reclaimFeeAllowance(entry) {
+  const maxSats = entry.max_cashu_fee_sats;
+  const contextMaxSats = entry.context?.max_cashu_fee_sats;
+  const initialSats = entry.initial_cashu_fee_sats;
+  const contextInitialSats = entry.context?.initial_cashu_fee_sats;
+  if (maxSats === void 0) {
+    if (contextMaxSats !== void 0) {
+      return {
+        ok: false,
+        reason: "the saved submission's Cashu fee ceiling is missing from its money journal"
+      };
+    }
+    if (initialSats !== void 0 && !isNonNegativeSafeInteger(initialSats) || contextInitialSats !== void 0 && !isNonNegativeSafeInteger(contextInitialSats) || initialSats !== void 0 && contextInitialSats !== void 0 && initialSats !== contextInitialSats) {
+      return {
+        ok: false,
+        reason: "the saved submission's initial Cashu fee accounting is invalid"
+      };
+    }
+    return {
+      ok: true,
+      maxSats: null,
+      initialSats: initialSats ?? contextInitialSats ?? 0,
+      remainingSats: null
+    };
+  }
+  if (!isNonNegativeSafeInteger(maxSats)) {
+    return { ok: false, reason: "the saved submission's Cashu fee ceiling is invalid" };
+  }
+  if (!isNonNegativeSafeInteger(initialSats)) {
+    return {
+      ok: false,
+      reason: "the capped saved submission is missing valid initial Cashu fee accounting"
+    };
+  }
+  if (entry.context && (contextMaxSats !== maxSats || contextInitialSats !== initialSats)) {
+    return {
+      ok: false,
+      reason: "the saved submission's Cashu fee accounting disagrees with its request context"
+    };
+  }
+  if (initialSats > maxSats) {
+    return {
+      ok: false,
+      reason: "the saved submission's initial Cashu fee exceeds its job-wide ceiling"
+    };
+  }
+  return {
+    ok: true,
+    maxSats,
+    initialSats,
+    remainingSats: maxSats - initialSats
+  };
+}
+function isNonNegativeSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+var UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var SHA256_RE = /^[a-f0-9]{64}$/;
+async function shipEntry(entry, httpPost) {
+  const token = { mint: entry.mint, proofs: toCashuProofs(entry.output_proofs) };
+  const cashuToken = entry.cashu_token ?? getEncodedToken2(token);
+  const headers = {
+    "Content-Type": "application/json",
+    "X-Cashu": cashuToken,
+    "X-Cashu-Request-Id": entry.request_id
+  };
+  const route = entry.context?.route === "credit" ? "/v1/credit" : "/v1/job";
+  let active = entry;
+  let correctedOnce = false;
+  for (; ; ) {
+    const body = resumeBody(active);
+    if (!body) return { kind: "unresumable", entry };
+    let response;
+    try {
+      response = await httpPost({
+        url: `${entry.endpoint}${route}`,
+        headers,
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      return {
+        kind: "still_pending",
+        entry,
+        reason: `network error: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    if (response.status >= 200 && response.status < 300) {
+      if (entry.context?.route === "credit") {
+        applyResumedCreditFund(entry, response.body);
+        return { kind: "shipped", entry };
+      }
+      const jobId = typeof response.body?.job_id === "string" ? response.body.job_id : void 0;
+      if (jobId && entry.context) {
+        saveJob(jobRecordFromEntry(entry, jobId, response.body, response.feedbackClaim));
+      }
+      await reconcileResumedJobCredit(active, response.body, httpPost);
+      return { kind: "shipped", entry, jobId };
+    }
+    if (response.status === 409 || response.body?.error === "replay_rejected") {
+      await reconcileResumedJobCredit(active, response.body, httpPost);
+      return { kind: "already_accepted", entry };
+    }
+    const errCode = typeof response.body?.error === "string" ? response.body.error : null;
+    if (errCode === "funding_commitment_mismatch") {
+      if (!correctedOnce) {
+        const correction = await correctFundAmount(active, response.body);
+        if (correction.kind === "corrected") {
+          correctedOnce = true;
+          active = correction.entry;
+          continue;
+        }
+        if (correction.kind === "permanent") {
+          return { kind: "abandoned", entry, reason: errCode };
+        }
+      }
+      return { kind: "still_pending", entry, reason: errCode };
+    }
+    if (errCode === "wrong_lock_pubkey" || errCode === "not_p2pk_locked" || errCode === "payment_invalid" || errCode === "proof_not_unspent" || // Credit-route permanent refusals (internal-review): the fund can never land
+    // under this signed body.
+    errCode === "credit_id_unavailable" || errCode === "caller_mismatch" || errCode === "credit_not_supported") {
+      return { kind: "abandoned", entry, reason: errCode };
+    }
+    return {
+      kind: "still_pending",
+      entry,
+      reason: errCode ?? `http ${response.status}`
+    };
+  }
+}
+async function correctFundAmount(entry, body) {
+  const ctx = entry.context;
+  if (!ctx || ctx.route === "credit") return { kind: "permanent" };
+  const data = ctx.submit_body.data;
+  const fund = data?.fund;
+  if (!data || !fund) return { kind: "permanent" };
+  const valuation = readFundValuation({
+    expectedMicro: body?.expected_micro,
+    message: typeof body?.message === "string" ? body.message : void 0
+  });
+  if (valuation.kind === "absent") return { kind: "permanent" };
+  if (valuation.kind === "malformed") return { kind: "hold" };
+  const expected = valuation.micro;
+  if (expected === fund.amount_micro) return { kind: "hold" };
+  await correctPendingFundAmount({ requestId: entry.request_id, amountMicro: expected });
+  return {
+    kind: "corrected",
+    entry: {
+      ...entry,
+      context: {
+        ...ctx,
+        submit_body: {
+          ...ctx.submit_body,
+          data: { ...data, fund: { ...fund, amount_micro: expected } }
+        }
+      }
+    }
+  };
+}
+function resumeBody(entry) {
+  const ctx = entry.context;
+  if (!ctx) return null;
+  if (ctx.route === "credit") {
+    const domain2 = ctx.auth_domain ?? testOnlySignedRequestDomain();
+    if (!ctx.credit_body || !ctx.signing_pubkey || !domain2) return null;
+    const signer2 = findSigningIdentityByPubkey(ctx.signing_pubkey);
+    if (!signer2) return null;
+    return signDvmRequestData(signer2.privkey, ctx.credit_body, domain2);
+  }
+  if (!ctx.signing_pubkey) return ctx.submit_body;
+  const domain = ctx.auth_domain ?? testOnlySignedRequestDomain();
+  if (!domain) return null;
+  const signer = findSigningIdentityByPubkey(ctx.signing_pubkey);
+  if (!signer) return null;
+  const unsigned = ctx.submit_body.data ?? {};
+  return { ...ctx.submit_body, data: signDvmRequestData(signer.privkey, unsigned, domain) };
+}
+function applyResumedCreditFund(entry, body) {
+  const pubkey = entry.context?.signing_pubkey;
+  const credit = isCreditWire(body?.credit) ? body.credit : void 0;
+  const rawReceipt = body?.funding_receipt;
+  const receipt = isFundingReceipt(rawReceipt) ? rawReceipt : void 0;
+  if (!pubkey || !credit) return false;
+  const ctx = entry.context;
+  const request = fundingRequest(entry);
+  if (!ctx || !request) return false;
+  const mutableReplay = ctx.route === "credit" && body?.replayed === true;
+  const verification = captureFundingReceipt({
+    receipt,
+    ...rawReceipt !== void 0 && !receipt ? { parseError: "shape_invalid" } : {},
+    endpoint: entry.endpoint,
+    ...ctx.builder ? { builder: ctx.builder } : {},
+    expectedCreditId: credit.credit_id,
+    expectedFundId: request.fundId,
+    expectedFundedMicro: typeof body?.funded_micro === "number" ? body.funded_micro : request.amountMicro,
+    ...mutableReplay ? {} : {
+      expectedBalanceAfterMicro: credit.remaining_micro,
+      expectedLedgerSeq: credit.ledger_seq
+    },
+    expectedCallerPubkey: pubkey
+  });
+  const sequenced = !mutableReplay && (verification === "verified" || verification === "verified_unattested");
+  try {
+    const stored = loadCredit(entry.endpoint, pubkey);
+    recordFundResponse({
+      endpoint: entry.endpoint,
+      callerPubkey: pubkey,
+      credit,
+      targetMicro: stored?.targetMicro ?? credit.remaining_micro,
+      sequenced
+    });
+  } catch {
+    return false;
+  }
+  return true;
+}
+function fundingRequest(entry) {
+  const ctx = entry.context;
+  if (!ctx) return void 0;
+  const data = ctx.route === "credit" ? ctx.credit_body : ctx.submit_body.data;
+  const fund = data?.fund;
+  if (!fund) return void 0;
+  const fundId = ctx.route === "credit" ? fund.fund_id : entry.request_id;
+  if (typeof fundId !== "string") return void 0;
+  return {
+    fundId,
+    ...typeof fund.amount_micro === "number" ? { amountMicro: fund.amount_micro } : {}
+  };
+}
+async function reconcileResumedJobCredit(entry, body, httpPost) {
+  const ctx = entry.context;
+  if (!ctx || ctx.route === "credit") return;
+  const data = ctx.submit_body.data;
+  if (!data || !data.fund && typeof data.credit_id !== "string") return;
+  if (applyResumedCreditFund(entry, body)) return;
+  const pubkey = ctx.signing_pubkey;
+  if (!pubkey) return;
+  try {
+    if (loadCredit(entry.endpoint, pubkey)?.provisional !== true) return;
+  } catch {
+    return;
+  }
+  await readResumedCreditBalance(entry, httpPost).catch(() => void 0);
+}
+async function readResumedCreditBalance(entry, httpPost) {
+  const pubkey = entry.context?.signing_pubkey;
+  if (!pubkey) return;
+  const signer = findSigningIdentityByPubkey(pubkey);
+  const storedDomain = entry.context?.auth_domain ?? testOnlySignedRequestDomain();
+  if (!signer || !storedDomain) return;
+  const domain = creditOperationDomain(storedDomain);
+  if (!domain) return;
+  const response = await httpPost({
+    url: `${entry.endpoint}/v1/credit`,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(signDvmRequestData(signer.privkey, { op: "balance" }, domain))
+  });
+  if (response.status < 200 || response.status >= 300) return;
+  const credits = (Array.isArray(response.body?.credits) ? response.body.credits : []).filter(
+    isCreditWire
+  );
+  const primary = isCreditWire(response.body?.credit) ? response.body.credit : void 0;
+  if (!primary && credits.length === 0) return;
+  recordBalanceResponse({
+    endpoint: entry.endpoint,
+    callerPubkey: pubkey,
+    credits,
+    ...primary ? { primary } : {},
+    sequenced: false
+  });
+}
+function creditOperationDomain(domain) {
+  const jobSuffix = "/v1/job";
+  if (!domain.path.endsWith(jobSuffix)) return null;
+  const mount = domain.path.slice(0, -jobSuffix.length);
+  return {
+    audience: domain.audience,
+    method: "POST",
+    path: `${mount}/v1/credit`,
+    capability: null
+  };
+}
+function isCreditWire(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const credit = value;
+  return typeof credit.credit_id === "string" && typeof credit.remaining_micro === "number";
+}
+function jobRecordFromEntry(entry, jobId, body, feedbackClaim) {
+  const ctx = entry.context;
+  return {
+    id: jobId,
+    endpoint: entry.endpoint,
+    ...ctx?.dvm_id ? { dvmId: ctx.dvm_id } : {},
+    ...feedbackClaim ? { feedbackClaim } : {},
+    ...ctx?.capability ? { capability: ctx.capability } : {},
+    status: "submitted",
+    submittedAt: Date.parse(entry.created_at) || Date.now(),
+    paymentMethod: "cashu",
+    ...ctx?.pinned_mint ? { pinnedMint: ctx.pinned_mint } : {},
+    ...ctx?.policy ? { policy: ctx.policy } : {},
+    ...ctx?.strict_per_call ? { strictPerCall: true } : {},
+    ...ctx?.max_cashu_fee_sats !== void 0 ? { maxCashuFeeSats: ctx.max_cashu_fee_sats } : {},
+    // internal-review: the per-job token an anonymous caller needs on every later read.
+    ...typeof body?.job_token === "string" ? { jobToken: body.job_token } : {}
+  };
+}
+function mutatesWallet(outcome) {
+  if (outcome.kind === "reclaim_skipped") {
+    return outcome.entry.reclaim_error !== outcome.reason || (outcome.entry.reclaim_terminal ?? false) !== outcome.terminal;
+  }
+  return outcome.kind === "shipped" || outcome.kind === "already_accepted" || outcome.kind === "abandoned" || outcome.kind === "pruned" || outcome.kind === "swap_restored" || outcome.kind === "swap_reverted" || outcome.kind === "still_pending" || outcome.kind === "reclaimed";
+}
+function applyOutcome3(wallet, outcome, now) {
+  const drop = () => ({
+    ...wallet,
+    pending_submissions: wallet.pending_submissions.filter(
+      (s) => s.request_id !== outcome.entry.request_id
+    )
+  });
+  if (outcome.kind === "shipped" || outcome.kind === "already_accepted") {
+    const recentSpend = {
+      request_id: outcome.entry.request_id,
+      dvm_endpoint: outcome.entry.endpoint,
+      mint: outcome.entry.mint,
+      amount_sats: outcome.entry.amount_sats,
+      signed_at_ms: now()
+    };
+    const dropped = drop();
+    return {
+      ...dropped,
+      recent_spends: [...dropped.recent_spends, recentSpend].slice(-RECENT_SPENDS_CAP)
+    };
+  }
+  if (outcome.kind === "abandoned" || outcome.kind === "pruned") {
+    return drop();
+  }
+  if (outcome.kind === "swap_restored") {
+    const swapping = outcome.entry.swapping;
+    if (!swapping) return wallet;
+    const trackedKeys = new Set(
+      [...swapping.input_proofs, ...swapping.unselected_proofs].map((proof) => proofKey(proof))
+    );
+    const boundContext = bindCashuTokenToSubmissionContext(
+      outcome.entry.context,
+      outcome.cashuToken
+    );
+    return {
+      ...wallet,
+      proofs: [
+        ...wallet.proofs.filter((proof) => !trackedKeys.has(proofKey(proof))),
+        ...swapping.unselected_proofs.map((proof) => ({
+          ...proof,
+          status: "valid",
+          in_flight_until_ms: void 0
+        })),
+        ...outcome.keep
+      ],
+      pending_submissions: wallet.pending_submissions.map(
+        (submission) => submission.request_id === outcome.entry.request_id ? {
+          ...submission,
+          output_proofs: outcome.outputs,
+          cashu_token: outcome.cashuToken,
+          swapping: void 0,
+          ...boundContext ? { context: boundContext } : {}
+        } : submission
+      )
+    };
+  }
+  if (outcome.kind === "swap_reverted") {
+    const swapping = outcome.entry.swapping;
+    if (!swapping) return drop();
+    const trackedKeys = new Set(
+      [...swapping.input_proofs, ...swapping.unselected_proofs].map((proof) => proofKey(proof))
+    );
+    const reverted = revertInFlight(wallet, trackedKeys);
+    return {
+      ...reverted,
+      pending_submissions: reverted.pending_submissions.filter(
+        (submission) => submission.request_id !== outcome.entry.request_id
+      )
+    };
+  }
+  if (outcome.kind === "reclaimed") {
+    const dropped = drop();
+    const credited = { ...dropped, proofs: [...dropped.proofs, ...outcome.outputs] };
+    if (outcome.spent_sats <= 0) return credited;
+    const partialSpend = {
+      request_id: outcome.entry.request_id,
+      dvm_endpoint: outcome.entry.endpoint,
+      mint: outcome.entry.mint,
+      amount_sats: outcome.spent_sats,
+      signed_at_ms: now()
+    };
+    return {
+      ...credited,
+      recent_spends: [...credited.recent_spends, partialSpend].slice(-RECENT_SPENDS_CAP)
+    };
+  }
+  if (outcome.kind === "still_pending") {
+    return {
+      ...wallet,
+      pending_submissions: wallet.pending_submissions.map(
+        (s) => s.request_id === outcome.entry.request_id ? {
+          ...s,
+          attempts: (s.attempts ?? 0) + 1,
+          last_attempt_at: new Date(now()).toISOString()
+        } : s
+      )
+    };
+  }
+  if (outcome.kind === "reclaim_skipped") {
+    return {
+      ...wallet,
+      pending_submissions: wallet.pending_submissions.map(
+        (s) => s.request_id === outcome.entry.request_id ? { ...s, reclaim_error: outcome.reason, reclaim_terminal: outcome.terminal } : s
+      )
+    };
+  }
+  return wallet;
+}
+function ageMs(entry, nowMs) {
+  const created = Date.parse(entry.created_at);
+  if (Number.isNaN(created)) return Number.POSITIVE_INFINITY;
+  return nowMs - created;
+}
+function errorText2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function createDefaultHttpPost(fetchImpl) {
+  return async function defaultHttpPost(req) {
+    let res;
+    try {
+      res = await fetchImpl(req.url, { method: "POST", headers: req.headers, body: req.body });
+    } catch (err) {
+      if (err instanceof DvmError) throw err;
+      throw new DvmError(
+        "provider_unreachable",
+        `Could not reach ${req.url}: ${err instanceof Error ? err.message : String(err)}`,
+        "Retry once the DVM is reachable again."
+      );
+    }
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      body = null;
+    }
+    const feedbackClaim = res.headers.get(ROUTER_FEEDBACK_CLAIM_HEADER) ?? void 0;
+    return { status: res.status, body, ...feedbackClaim ? { feedbackClaim } : {} };
+  };
+}
+
+// src/lib/wallet-agent/release.ts
+async function releaseAgentReserve(opts) {
+  const cashu = opts.providerInfo.cashu;
+  if (!cashu?.canonical_id) {
+    throw new DvmError(
+      "missing_canonical_id",
+      "DVM advertises no `cashu.canonical_id` on /v1/info.",
+      "Release needs canonical_id so the agent can derive the matching per-DVM refund subkey. Upgrade the builder SDK (internal-review+)."
+    );
+  }
+  const outputMode = opts.outputMode ?? "locked";
+  const initial = loadAgentWallet();
+  if (!initial) {
+    throw new DvmError("wallet_missing", "No agent wallet found.", "Run `dvm wallet init` first.");
+  }
+  const readMnemonic = opts.readMnemonic ?? readAgentMnemonic;
+  const mnemonic = readMnemonic();
+  if (!mnemonic) {
+    throw new DvmError(
+      "mnemonic_required",
+      "Release requires a BIP-39 mnemonic at ~/.dvm/wallet.mnemonic.",
+      "Restore the mnemonic with `dvm wallet recover --force --file <path>` (or pipe it via stdin) \u2014 it's the only way to derive the refund subkey privkey."
+    );
+  }
+  const refund = deriveAgentRefundSubkey(mnemonic, cashu.canonical_id);
+  const marker = reservedForMarker(opts.builderHandle);
+  const now = (opts.now ?? Date.now)();
+  const candidates = initial.proofs.filter(
+    (p) => p.reserved_for === marker && p.status === "valid" && typeof p.t_expire === "number" && p.t_expire < now
+  );
+  if (candidates.length === 0) {
+    return { builder_handle: opts.builderHandle, output_mode: outputMode, mints: [] };
+  }
+  const getWalletForMint = opts.getWalletForMint ?? getWallet;
+  const byMint = /* @__PURE__ */ new Map();
+  for (const p of candidates) {
+    const bucket = byMint.get(p.mint) ?? [];
+    bucket.push(p);
+    byMint.set(p.mint, bucket);
+  }
+  const outcomes = [];
+  for (const [mintUrl, mintProofs] of byMint) {
+    outcomes.push(
+      await releaseAtMint(
+        mintUrl,
+        mintProofs,
+        refund.privkey,
+        initial,
+        outputMode,
+        getWalletForMint
+      )
+    );
+  }
+  return { builder_handle: opts.builderHandle, output_mode: outputMode, mints: outcomes };
+}
+async function releaseAtMint(mintUrl, mintProofs, refundPrivkey, initial, outputMode, getWalletForMint) {
+  let cashuWallet;
+  try {
+    cashuWallet = await getWalletForMint(mintUrl);
+  } catch (err) {
+    return {
+      mint: mintUrl,
+      alreadySpent: [],
+      pending: [],
+      reclaimedInputs: [],
+      reclaimedOutputs: [],
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  let grouped;
+  try {
+    grouped = await cashuWallet.groupProofsByState(toCashuProofs(mintProofs));
+  } catch (err) {
+    return {
+      mint: mintUrl,
+      alreadySpent: [],
+      pending: [],
+      reclaimedInputs: [],
+      reclaimedOutputs: [],
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  const spentSecrets = new Set(grouped.spent.map((p) => p.secret));
+  const pendingSecrets = new Set(grouped.pending.map((p) => p.secret));
+  const alreadySpent = mintProofs.filter((p) => spentSecrets.has(p.secret));
+  const pending = mintProofs.filter((p) => pendingSecrets.has(p.secret));
+  const unspent = mintProofs.filter(
+    (p) => !spentSecrets.has(p.secret) && !pendingSecrets.has(p.secret)
+  );
+  if (alreadySpent.length > 0) {
+    await withWalletLock(() => {
+      const fresh = loadAgentWallet() ?? initial;
+      const spentKeys = new Set(alreadySpent.map((p) => proofIdKey(p)));
+      saveAgentWallet({
+        ...fresh,
+        proofs: fresh.proofs.filter((p) => !spentKeys.has(proofIdKey(p)))
+      });
+    });
+  }
+  if (unspent.length === 0) {
+    return {
+      mint: mintUrl,
+      alreadySpent,
+      pending,
+      reclaimedInputs: [],
+      reclaimedOutputs: [],
+      error: null
+    };
+  }
+  const totalSats = unspent.reduce((sum, p) => sum + p.amount, 0);
+  const inputs = toCashuProofs(unspent);
+  let outputs;
+  try {
+    const swapFeeSats = swapFeeForProofs(cashuWallet, inputs);
+    const reclaimSats = totalSats - swapFeeSats;
+    if (reclaimSats <= 0) {
+      throw new Error(
+        `Reserve at ${mintUrl} is ${totalSats} sats, which does not cover the mint's ${swapFeeSats}-sat swap fee.`
+      );
+    }
+    const builder = cashuWallet.ops.send(reclaimSats, inputs).privkey(refundPrivkey);
+    const result = outputMode === "locked" ? await builder.asP2PK({ pubkey: initial.lock_pubkey }).run() : await builder.asRandom().run();
+    outputs = result.send;
+  } catch (err) {
+    return {
+      mint: mintUrl,
+      alreadySpent,
+      pending,
+      reclaimedInputs: [],
+      reclaimedOutputs: [],
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  const reclaimedOutputs = outputs.map(
+    (p) => toAgentProof(p, mintUrl, outputMode === "locked" ? initial.lock_pubkey : null)
+  );
+  await withWalletLock(() => {
+    const fresh = loadAgentWallet() ?? initial;
+    const inputKeys = new Set(unspent.map((p) => proofIdKey(p)));
+    saveAgentWallet({
+      ...fresh,
+      proofs: [...fresh.proofs.filter((p) => !inputKeys.has(proofIdKey(p))), ...reclaimedOutputs]
+    });
+  });
+  return {
+    mint: mintUrl,
+    alreadySpent,
+    pending,
+    reclaimedInputs: unspent,
+    reclaimedOutputs,
+    error: null
+  };
+}
+function proofIdKey(p) {
+  return `${p.secret}:${p.C}`;
+}
+
+// src/lib/wallet-agent/reserve.ts
+import { MintQuoteState as MintQuoteState3 } from "@cashu/cashu-ts";
+async function reserveAgentWallet(amountSats, opts) {
+  if (!Number.isFinite(amountSats) || amountSats <= 0) {
+    throw new DvmError(
+      "invalid_amount",
+      "Amount must be a positive integer number of sats.",
+      "Pass a positive sats amount, e.g. `dvm wallet reserve --builder scrape.dvmkit.ai 1000`, or a USD amount, e.g. `dvm wallet reserve --builder scrape.dvmkit.ai $5`."
+    );
+  }
+  const sats = Math.floor(amountSats);
+  const cashu = opts.providerInfo.cashu;
+  if (!cashu) {
+    throw new DvmError(
+      "missing_cashu_info",
+      "DVM does not advertise a `cashu` object on /v1/info.",
+      "Reserve requires the builder to expose lock_pubkeys, mints, and canonical_id. Check the builder is running an SDK that supports pre-fund (internal-review+)."
+    );
+  }
+  const lockPubkey = cashu.lock_pubkeys[0];
+  if (!lockPubkey) {
+    throw new DvmError(
+      "missing_lock_pubkey",
+      "DVM advertised no current lock pubkey.",
+      "Ask the builder operator to deploy with DVMKIT_CASHU_LOCK_PUBKEY set."
+    );
+  }
+  if (cashu.mints.length === 0) {
+    throw new DvmError(
+      "missing_dvm_mints",
+      "DVM advertises no accepted Cashu mints.",
+      "Ask the builder operator to set DVMKIT_CASHU_MINTS on the DVM machine."
+    );
+  }
+  if (!cashu.canonical_id) {
+    throw new DvmError(
+      "missing_canonical_id",
+      "DVM advertises no `cashu.canonical_id` on /v1/info.",
+      "Pre-fund requires canonical_id so the agent can derive a per-DVM refund subkey. Upgrade the builder SDK to one that advertises it (internal-review+)."
+    );
+  }
+  if (!cashu.mints.includes(opts.mintUrl)) {
+    throw new DvmError(
+      "mint_not_accepted",
+      `Mint ${opts.mintUrl} is not in the builder's allowlist (${cashu.mints.join(", ")}).`,
+      `Re-run with --mint set to one of the builder's accepted mints, or top up at one of them first.`
+    );
+  }
+  const locktimeSeconds = opts.locktimeSeconds ?? DEFAULT_RESERVE_LOCKTIME_SECONDS;
+  if (cashu.min_locktime && locktimeSeconds < cashu.min_locktime) {
+    throw new DvmError(
+      "locktime_too_short",
+      `Requested locktime ${locktimeSeconds}s is below the builder's minimum ${cashu.min_locktime}s.`,
+      `Re-run with --locktime at or above the builder's minimum (${cashu.min_locktime}s).`
+    );
+  }
+  const initial = loadAgentWallet();
+  if (!initial) {
+    throw new DvmError(
+      "wallet_missing",
+      "No agent wallet found.",
+      "Run `dvm wallet init` first to generate a wallet."
+    );
+  }
+  const readMnemonic = opts.readMnemonic ?? readAgentMnemonic;
+  const mnemonic = readMnemonic();
+  if (!mnemonic) {
+    throw new DvmError(
+      "mnemonic_required",
+      "Reserve requires a BIP-39 mnemonic at ~/.dvm/wallet.mnemonic.",
+      "The per-DVM refund subkey is derived from the mnemonic, so `dvm wallet release` post-expire requires it. Run `dvm wallet init` (fresh wallet) or `dvm wallet recover --force --file <path>` (or pipe the mnemonic via stdin) to attach the mnemonic file."
+    );
+  }
+  const refundPubkey = deriveAgentRefundSubkeyPubkey(mnemonic, cashu.canonical_id);
+  const cashuWallet = await (opts.getWalletForMint ?? getWallet)(opts.mintUrl);
+  const quote = await cashuWallet.createLockedMintQuote(sats, initial.lock_pubkey);
+  const pending = {
+    mint: opts.mintUrl,
+    quote_id: quote.quote,
+    amount_sats: sats,
+    requested_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await withWalletLock(() => {
+    const fresh = loadAgentWallet() ?? initial;
+    saveAgentWallet({
+      ...fresh,
+      pending_mints: [...fresh.pending_mints, pending]
+    });
+  });
+  if (opts.onInvoice) await opts.onInvoice(quote.request, quote);
+  const finalState = await pollUntilPaidOrTimeout(cashuWallet, quote.quote, {
+    timeoutMs: opts.timeoutMs ?? fundTimeoutMs(),
+    pollIntervalMs: opts.pollIntervalMs,
+    now: opts.now,
+    sleep: opts.sleep,
+    onPoll: opts.onPoll
+  });
+  if (finalState === MintQuoteState3.ISSUED) {
+    throw new DvmError(
+      "reserve_already_issued",
+      `Mint quote ${quote.quote} was already collected by a concurrent run.`,
+      "Inspect wallet state with `dvm wallet show` \u2014 the proofs should be persisted by the other instance."
+    );
+  }
+  if (finalState !== MintQuoteState3.PAID) {
+    throw new DvmError(
+      "reserve_timeout",
+      `Mint quote ${quote.quote} was not paid within the reserve timeout.`,
+      "Pay the invoice from a Lightning wallet, then run `dvm wallet show` to recover the pending mint, or `dvm wallet reserve` to start a new flow."
+    );
   }
-  if (bestTarget === -1) return null;
-  const indices = reachable.get(bestTarget) ?? [];
-  return { selected: indices.map((i) => proofs[i]), totalSats: bestTarget };
+  const denominations = computeSmartDenominations(sats, {
+    maxDenomination: maxKeysetDenomination(cashuWallet)
+  });
+  const nowMs = (opts.now ?? Date.now)();
+  const tExpireSeconds = Math.floor(nowMs / 1e3) + locktimeSeconds;
+  const tExpireMs = tExpireSeconds * 1e3;
+  const preview = await prepareP2PKMint(
+    cashuWallet,
+    sats,
+    quote,
+    initial.lock_privkey,
+    lockPubkey,
+    denominations,
+    { locktimeUnixSec: tExpireSeconds, refundKeys: [refundPubkey] }
+  );
+  const minting = {
+    keyset_id: preview.keysetId,
+    outputs: serializeOutputData(preview.outputData)
+  };
+  await withWalletLock(() => {
+    const fresh = loadAgentWallet() ?? initial;
+    saveAgentWallet(upsertPending2(fresh, { ...pending, minting }));
+  });
+  const reservedFor = reservedForMarker(opts.builderHandle);
+  const proofs = await cashuWallet.completeMint(preview);
+  const agentProofs = proofs.map(
+    (p) => toAgentProof(p, opts.mintUrl, lockPubkey, {
+      reservedFor,
+      tExpireMs
+    })
+  );
+  await withWalletLock(() => {
+    const post = loadAgentWallet() ?? initial;
+    saveAgentWallet({
+      ...post,
+      proofs: [...post.proofs, ...agentProofs],
+      pending_mints: post.pending_mints.filter((p) => p.quote_id !== quote.quote)
+    });
+  });
+  return {
+    mint: opts.mintUrl,
+    amount_sats: sats,
+    quote_id: quote.quote,
+    denominations,
+    proofs: agentProofs,
+    builder_handle: opts.builderHandle,
+    t_expire_ms: tExpireMs,
+    refund_pubkey: refundPubkey,
+    lock_pubkey: lockPubkey
+  };
+}
+function upsertPending2(wallet, entry) {
+  const others = wallet.pending_mints.filter((p) => p.quote_id !== entry.quote_id);
+  return { ...wallet, pending_mints: [...others, entry] };
 }
-
-// src/lib/wallet-agent/recovery-submissions.ts
-var RESUME_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
-
-// src/lib/wallet-agent/reserve.ts
-import { MintQuoteState as MintQuoteState3 } from "@cashu/cashu-ts";
 
 // src/lib/x402/batch-client.ts
 import {
@@ -2873,6 +5496,29 @@ function resolveX402ChannelRpc(channelNetwork, configuredNetwork, bundled) {
 
 // src/lib/x402/lifecycle.ts
 import { BATCH_SETTLEMENT_ADDRESS } from "@x402/evm";
+async function assertX402WalletIdle(wallet, intent) {
+  const payerAddress = wallet.address;
+  const owned = listX402Channels({ payer: payerAddress });
+  const clients = /* @__PURE__ */ new Map();
+  for (const channel of owned) {
+    const state = await readChannelState(channel, wallet.network, clients, "guard");
+    if (state.balance === 0n && state.pendingWithdrawal === 0n) continue;
+    throw new DvmError(
+      "x402_wallet_in_use",
+      state.balance > 0n ? `The connected x402 wallet still holds ${formatUsdcMicrounits(state.balance)} USDC in an open channel with ${channel.endpoint}.` : `The connected x402 wallet has a timed withdrawal of ${formatUsdcMicrounits(state.pendingWithdrawal)} USDC still in flight on its channel with ${channel.endpoint}.`,
+      `Only this key can move those funds. Empty the channel first \u2014 'dvm credit drain' for the cooperative exit, or 'dvm wallet x402-withdraw-initiate --channel-id ${channel.channelId}' and then finalize after the delay \u2014 and ${intentClause(intent)}.`,
+      {
+        anchor: "x402_channel_live",
+        address: payerAddress,
+        channel_id: channel.channelId,
+        endpoint: channel.endpoint,
+        network: channel.network,
+        balance_micro: state.balance.toString(),
+        pending_withdrawal_micro: state.pendingWithdrawal.toString()
+      }
+    );
+  }
+}
 function assertX402ChannelPayer(channel, address) {
   if (channel.config.payer.toLowerCase() === address.toLowerCase()) return;
   throw new DvmError(
@@ -2889,11 +5535,162 @@ function assertX402ChannelPayer(channel, address) {
     }
   );
 }
+async function readX402ChannelOnChain(args) {
+  const { channel } = args;
+  const clients = args.clients ?? /* @__PURE__ */ new Map();
+  let state;
+  let error;
+  try {
+    state = await readChannelState(channel, args.configuredNetwork, clients, "report");
+  } catch (err) {
+    error = err instanceof DvmError ? err : new DvmError(
+      "x402_chain_read_failed",
+      `Reading the x402 channel with ${channel.endpoint} on ${channel.network} failed: ${redactUrlsInText(err instanceof Error ? err.message : String(err))}`
+    );
+  }
+  let status = state ? classifyX402ChannelState(state) : "unreadable";
+  if (state && status === "unconfirmed") {
+    const refunds = await readChannelRefundNonce(channel, args.configuredNetwork, clients).catch(
+      () => 0n
+    );
+    if (refunds > 0n) status = "closed";
+  }
+  const accounted = status === "unconfirmed" ? void 0 : state;
+  const stored = accounted ? void 0 : await storedChannelBalance(channel.channelId);
+  const depositMicro = accounted ? Number(accounted.balance) : stored?.balanceMicro;
+  return {
+    status,
+    channelId: channel.channelId,
+    ...depositMicro !== void 0 ? { depositMicro } : {},
+    ...state ? {
+      settledMicro: Number(state.totalClaimed),
+      ...depositMicro !== void 0 ? { uncommittedMicro: Math.max(depositMicro - Number(state.totalClaimed), 0) } : {},
+      pendingWithdrawalMicro: Number(state.pendingWithdrawal)
+    } : {},
+    ...depositMicro !== void 0 && stored?.unreconciledAt !== void 0 ? { balanceUnreconciledAt: stored.unreconciledAt } : {},
+    ...error ? { error } : {}
+  };
+}
+function x402ChannelControlledBy(channel, address) {
+  if (!address) return false;
+  return channel.config.payer.toLowerCase() === address.toLowerCase();
+}
+async function storedChannelBalance(channelId) {
+  try {
+    const balance = (await new DvmX402ChannelStorage().get(channelId))?.balance;
+    const unreconciledAt = x402ChannelBalanceUnreconciledAt(channelId);
+    return {
+      ...balance !== void 0 ? { balanceMicro: Number(balance) } : {},
+      ...unreconciledAt !== void 0 ? { unreconciledAt } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function classifyX402ChannelState(state) {
+  if (state.pendingWithdrawal > 0n) return "closing";
+  if (state.balance > 0n) return "open";
+  return state.totalClaimed > 0n ? "closed" : "unconfirmed";
+}
+async function resolveChannelRead(channel, configuredNetwork, clients, posture) {
+  const spec = x402NetworkByCaip2(channel.network);
+  if (!spec) {
+    throw new DvmError(
+      "x402_unsupported_network",
+      `The channel with ${channel.endpoint} is recorded on ${channel.network}, a chain this rail can't read.`,
+      posture === "guard" ? `${x402SupportedNetworksHint()} The key stays connected: with no way to read that channel, there is no way to show it is empty.` : `${x402SupportedNetworksHint()} The local channel record is kept: with no way to read that chain, there is no way to show what the contract holds for it.`,
+      { channel_id: channel.channelId, endpoint: channel.endpoint, network: channel.network }
+    );
+  }
+  const chains2 = await import("viem/chains");
+  const { createPublicClient: createPublicClient2, http: http2 } = await import("viem");
+  const bundled = chains2[spec.viemChain]?.rpcUrls?.default.http[0];
+  const { url, source, overrideOutOfScope } = resolveX402ChannelRpc(
+    channel.network,
+    configuredNetwork,
+    bundled
+  );
+  let client = clients.get(channel.network);
+  if (!client) {
+    const transportOptions = resolveRpcHttpTransportOptions(
+      source,
+      process.env.DVM_X402_RPC_HEADERS_JSON
+    );
+    client = createPublicClient2({
+      chain: chains2[spec.viemChain],
+      transport: transportOptions ? http2(url, transportOptions) : http2(url)
+    });
+    clients.set(channel.network, client);
+  }
+  return { client, label: spec.label, url, source, overrideOutOfScope };
+}
+async function readChannelState(channel, configuredNetwork, clients, posture) {
+  const read = await resolveChannelRead(channel, configuredNetwork, clients, posture);
+  let onchain;
+  let pending;
+  try {
+    [onchain, pending] = await Promise.all([
+      read.client.readContract({
+        address: BATCH_SETTLEMENT_ADDRESS,
+        abi: X402_BATCH_CHANNEL_ABI,
+        functionName: "channels",
+        args: [channel.channelId]
+      }),
+      read.client.readContract({
+        address: BATCH_SETTLEMENT_ADDRESS,
+        abi: X402_BATCH_CHANNEL_ABI,
+        functionName: "pendingWithdrawals",
+        args: [channel.channelId]
+      })
+    ]);
+  } catch (err) {
+    throw rpcError(err, channel, read, posture);
+  }
+  await new DvmX402ChannelStorage().reconcileChainState(channel.channelId, {
+    balance: onchain[0].toString(),
+    totalClaimed: BigInt(onchain[1]).toString()
+  }).catch(() => void 0);
+  return {
+    balance: onchain[0],
+    totalClaimed: BigInt(onchain[1]),
+    pendingWithdrawal: pending[0]
+  };
+}
+async function readChannelRefundNonce(channel, configuredNetwork, clients) {
+  const read = await resolveChannelRead(channel, configuredNetwork, clients, "report");
+  try {
+    return await read.client.readContract({
+      address: BATCH_SETTLEMENT_ADDRESS,
+      abi: X402_BATCH_CHANNEL_ABI,
+      functionName: "refundNonce",
+      args: [channel.channelId]
+    });
+  } catch (err) {
+    throw rpcError(err, channel, read, "report");
+  }
+}
+function rpcError(err, channel, read, posture) {
+  const { label, url, source, overrideOutOfScope } = read;
+  const cause = redactUrlsInText(err instanceof Error ? err.message : String(err));
+  const opening = posture === "guard" ? "The x402 wallet is untouched. " : "Nothing was read or changed. ";
+  const closing = posture === "guard" ? " then retry \u2014 until the channel reads as empty the key stays connected." : " then re-run 'dvm wallet balance'. The local channel record is kept until the chain can be read, because it is the only route back to any collateral the contract does hold.";
+  const scopeClause = overrideOutOfScope ? `This channel is on ${label}, not the chain the wallet is pinned to, so DVM_X402_RPC_URL did not apply to it \u2014 it stays scoped to the pinned chain, because the settlement contract shares one address across chains and a cross-chain read would answer "empty" for a channel that isn't. Verify connectivity to ${label}'s bundled endpoint${url ? ` (${redactUrl(url)})` : ""},` : `Verify connectivity to ${label}'s bundled endpoint${url ? ` (${redactUrl(url)})` : ""}, or send the read somewhere else with DVM_X402_RPC_URL,`;
+  const diagnosis = source === "override" ? `DVM_X402_RPC_URL sent this read to ${redactUrl(url ?? "")}. Correct it, or unset it to fall back to ${label}'s bundled endpoint,` : scopeClause;
+  return new DvmError(
+    "x402_rpc_error",
+    `Reading the x402 channel with ${channel.endpoint} on ${label} failed: ${cause}`,
+    `${opening}${diagnosis}${closing}`,
+    { channel_id: channel.channelId, endpoint: channel.endpoint, network: channel.network }
+  );
+}
+function intentClause(intent) {
+  return intent === "replace" ? "retry the replacement" : "retry 'dvm wallet x402-disconnect'";
+}
 
 // src/lib/x402/voucher-cap.ts
 import { decodePaymentSignatureHeader } from "@x402/core/http";
-function x402VoucherFactsFromPayload(raw) {
-  const payload = raw;
+function x402VoucherFactsFromPayload(raw2) {
+  const payload = raw2;
   const maxClaimableMicro = payload.voucher?.maxClaimableAmount;
   if (maxClaimableMicro === void 0) return void 0;
   if (payload.type !== "deposit") return { maxClaimableMicro };
@@ -2910,6 +5707,10 @@ function x402ChannelReservation(journalled, totalClaimed) {
     totalClaimed
   );
 }
+function x402ReservationRelease(journalled) {
+  const retriable = journalled.filter((entry) => !x402PendingRetired(entry));
+  return retriable.length > 0 ? { entry: retriable[0], retriable: true } : { entry: journalled[0], retriable: false };
+}
 function x402VoucherCap(pending) {
   const recorded = pending.maxClaimableMicro ?? x402VoucherFacts(pending.paymentHeader)?.maxClaimableMicro;
   if (recorded === void 0) return X402_MAX_UINT128;
@@ -3264,9 +6065,9 @@ async function refundX402BatchChannelLocked(args) {
   return { result, paymentResponse: encoded, atRiskMicro, pendingFundings: journalled };
 }
 function x402RequiredFromError(err) {
-  const raw = err.data?.x402_payment_required;
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
-  return raw;
+  const raw2 = err.data?.x402_payment_required;
+  if (!raw2 || typeof raw2 !== "object" || Array.isArray(raw2)) return void 0;
+  return raw2;
 }
 function assertX402RequirementDescribesChannel(args) {
   assertX402ChannelPayer(
@@ -6058,40 +8859,587 @@ function isArtifactMessage(msg) {
 function isPaymentRequestMessage(msg) {
   return msg.type === "payment-request";
 }
+function isTextMessage(msg) {
+  return msg.type === "text";
+}
+function isCompleteMessage(msg) {
+  return msg.type === "complete";
+}
+function isCancelMessage(msg) {
+  return msg.type === "cancel";
+}
+function isWorkingMessage(msg) {
+  return msg.type === "working";
+}
+
+// src/lib/policy.ts
+function buildPolicy(opts, btcRate) {
+  if (opts.maxPayments === void 0) {
+    throw new DvmError(
+      "missing_max_payments",
+      "Cannot build a spending policy without a payment count cap.",
+      "Pass --max-payments <n> on dvm request. Use 0 for free jobs, 1 for typical paid jobs, or higher for multi-turn flows that may require progressive payments."
+    );
+  }
+  if (!Number.isInteger(opts.maxPayments) || opts.maxPayments < 0) {
+    throw new DvmError(
+      "invalid_max_payments",
+      "Invalid value for --max-payments.",
+      "Pass a non-negative integer (e.g. --max-payments 1)."
+    );
+  }
+  const maxTotalMsats = opts.budget ? parseBudget(opts.budget, btcRate) : 0;
+  const autoPayBelowMsats = opts.autoPayBelow ? parseBudget(opts.autoPayBelow, btcRate) : Math.floor(maxTotalMsats * 0.2);
+  const maxIncrementMsats = opts.maxIncrement ? parseBudget(opts.maxIncrement, btcRate) : maxTotalMsats;
+  return { maxTotalMsats, autoPayBelowMsats, maxIncrementMsats, maxPayments: opts.maxPayments };
+}
 
 // src/lib/provenance.ts
 function asProviderText(text) {
   return { _source: "provider", text };
 }
+function asProviderTextOpt(text) {
+  return text === void 0 ? void 0 : asProviderText(text);
+}
 function providerTextToString(value) {
   return typeof value === "string" ? value : value.text;
 }
+
+// src/lib/cashu/balance.ts
+function getBalance2(mintUrl) {
+  const wallet = loadAgentWallet();
+  if (!wallet) return 0;
+  const proofs = wallet.proofs.filter(
+    (p) => p.status === "valid" && (mintUrl === void 0 || p.mint === mintUrl)
+  );
+  return proofs.reduce((sum, p) => sum + p.amount, 0) * 1e3;
+}
+function getBalanceByMint() {
+  const wallet = loadAgentWallet();
+  if (!wallet) return /* @__PURE__ */ new Map();
+  const map = /* @__PURE__ */ new Map();
+  for (const p of wallet.proofs) {
+    if (p.status !== "valid") continue;
+    map.set(p.mint, (map.get(p.mint) ?? 0) + p.amount * 1e3);
+  }
+  return map;
+}
+
+// src/lib/completion-hints.ts
+function buildCompletionHintFields(jobId, input) {
+  const out = {};
+  if (input.hasArtifacts !== void 0) out.has_artifacts = input.hasArtifacts;
+  if (input.artifactCount !== void 0) out.artifact_count = input.artifactCount;
+  if (input.payloadIn) out.payload_in = input.payloadIn;
+  const hint = nextStepHint(jobId, input.payloadIn, input.artifactCount);
+  if (hint) out.next_step_hint = hint;
+  return out;
+}
+function nextStepHint(jobId, payloadIn, artifactCount) {
+  if (payloadIn !== "messages") return void 0;
+  const noun = artifactCount === 1 ? "artifact" : "artifacts";
+  return `Run 'dvm messages ${jobId} --no-stream' to fetch the ${noun}.`;
+}
+function completionSnapshot(src) {
+  const out = {};
+  if (src.summary !== void 0) out.summary = src.summary;
+  if (src.message !== void 0) out.message = src.message;
+  if (src.hasArtifacts !== void 0) out.hasArtifacts = src.hasArtifacts;
+  if (src.artifactCount !== void 0) out.artifactCount = src.artifactCount;
+  if (src.payloadIn) out.payloadIn = src.payloadIn;
+  return out;
+}
+function completionFromMessages(messages) {
+  const complete = messages.findLast((m) => m.type === "complete");
+  const summary = complete?.type === "complete" ? complete.content.summary : void 0;
+  const artifactCount = messages.filter((m) => m.type === "artifact").length;
+  const out = {
+    hasArtifacts: artifactCount > 0,
+    payloadIn: artifactCount > 0 ? "messages" : "summary"
+  };
+  if (summary !== void 0) out.summary = summary;
+  if (artifactCount > 0) out.artifactCount = artifactCount;
+  return out;
+}
+
+// src/lib/funding.ts
+var SAFE_FUNDING_ADVISORY = {
+  display: "Start small \u2014 fund a few days' worth and top up as confidence grows",
+  description: "There's no need to fund a large amount up front. A few days of expected spend is enough to get going; top up once you've seen how your agent uses the wallet.",
+  hint: "Funding lightly is the safest posture across all rails. A connected Lightning wallet lets the agent top itself up on its own \u2014 set a spending cap on the wallet (it's the one the agent can't change) and 'dvm budget set' caps here."
+};
+function detectWalletType(config, cashuMints) {
+  if (!config && cashuMints.length === 0) return null;
+  if (config?.nwcUri) return "nwc";
+  if (cashuMints.length > 0) return "cashu";
+  return null;
+}
+function getFundingGuidance(opts) {
+  const fundingOptions = (opts.balanceMsats ?? 0) > 0 ? [] : opts.walletType === "nwc" ? nwcOptions() : cashuOptions(opts.cashuMints, opts.hasLightningBackend ?? false);
+  return { fundingOptions, advisory: SAFE_FUNDING_ADVISORY };
+}
+function printFundingGuidance(result) {
+  info(`
+${result.advisory.display}`);
+  info(`  ${result.advisory.description}`);
+  info(`  ${result.advisory.hint}`);
+  if (result.fundingOptions.length === 0) return;
+  info("\nFund your wallet:");
+  for (let i = 0; i < result.fundingOptions.length; i++) {
+    const o = result.fundingOptions[i];
+    info(`  ${i + 1}. ${o.display}`);
+    if (o.command) info(`     ${o.command}`);
+    info(`     ${o.description}`);
+  }
+}
+function nwcOptions() {
+  return [
+    {
+      method: "external",
+      display: "Add funds in your wallet app",
+      description: "The connected Lightning wallet is the agent's float \u2014 the pot it tops itself up from. Money goes in through the wallet app itself (Alby Hub, Coinos, etc.); dvm spends from it but never fills it.",
+      hint: "Receive a payment in your wallet app, then run 'dvm wallet fund <amount>' \u2014 the agent will move sats across on its own."
+    }
+  ];
+}
+function cashuOptions(mints, hasLightningBackend) {
+  const exampleMint = mints && mints.length > 0 ? mints[0] : void 0;
+  const hasMints = exampleMint !== void 0;
+  const mintCommand = exampleMint ? `dvm wallet fund <sats> --mint ${exampleMint}` : "dvm wallet fund <sats> --mint <url>";
+  const mintOption = {
+    method: "cashu-mint",
+    display: "Mint Cashu tokens via Lightning",
+    command: mintCommand,
+    description: hasMints ? "Pays a Lightning invoice from your Lightning wallet and mints matching P2PK-locked Cashu tokens into the agent wallet. Cashu mints are custodial \u2014 only deposit what you're willing to lose." : "After adding a mint above, pays a Lightning invoice from your Lightning wallet and mints matching P2PK-locked Cashu tokens into the agent wallet. Cashu mints are custodial \u2014 only deposit what you're willing to lose.",
+    hint: hasLightningBackend ? "Requires a Lightning wallet \u2014 you have one configured." : "Requires a Lightning wallet \u2014 connect one with 'dvm wallet connect' first (pipe the connection string in, or pass --file <path>).",
+    ...hasMints ? { mints } : {}
+  };
+  const receiveTokenOption = {
+    method: "cashu-receive-token",
+    display: "Receive an existing Cashu token",
+    command: "dvm wallet receive-token <cashu-token>",
+    description: "Claim a pre-minted Cashu token (e.g. from a friend or a faucet) into the agent wallet. The token is re-locked to your wallet's key so it's spendable.",
+    hint: "Tokens are single-use; a token locked to a third party can't be claimed.",
+    ...hasMints ? { mints } : {}
+  };
+  const options = [];
+  if (!hasMints) {
+    options.push({
+      method: "cashu-add-mint",
+      display: "Add a Cashu mint",
+      command: "dvm wallet mint-add <url>",
+      description: "Cashu mints hold your tokens. Add one before you can mint or receive tokens \u2014 'dvm wallet mint-list' shows recommended mints. Cashu mints are custodial \u2014 only deposit what you're willing to lose.",
+      hint: "Recommended mints: see 'dvm wallet mint-list' for trusted options."
+    });
+  }
+  if (hasLightningBackend) {
+    options.push(mintOption, receiveTokenOption);
+  } else {
+    options.push(receiveTokenOption, mintOption);
+  }
+  return options;
+}
+
+// src/lib/next-action.ts
+function isTerminalJobStatus(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+function pollNextAction(jobId, hint) {
+  return {
+    type: "poll",
+    job_id: jobId,
+    hint: hint ?? "Provider is working, check back later"
+  };
+}
+var YIELD_TYPES = /* @__PURE__ */ new Set(["prompt", "payment-request", "working", "complete", "cancel"]);
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "cancelled"
+]);
+function computeNextAction(jobId, messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!YIELD_TYPES.has(msg.type)) continue;
+    switch (msg.type) {
+      case "complete":
+      case "cancel":
+        return null;
+      case "prompt": {
+        const c = msg.content;
+        const action = {
+          type: "respond",
+          job_id: jobId,
+          prompt_id: c.id,
+          prompt: asProviderText(c.text),
+          hint: "Provider is waiting for your input. Verify the question makes sense for your task before responding."
+        };
+        if (c.schema) action.schema = c.schema;
+        return action;
+      }
+      case "payment-request": {
+        const c = msg.content;
+        const display = formatPaymentAmount(c.amount_msats, c.fiat_amount);
+        return {
+          type: "pay",
+          job_id: jobId,
+          amount_msats: c.amount_msats,
+          // Mirror only a fiat figure the display actually led with: echoing a
+          // zero amount would tell an agent doing budget math the charge is free.
+          ...c.fiat_amount && c.fiat_amount.amount > 0 ? { fiat_amount: c.fiat_amount } : {},
+          display,
+          reason: asProviderText(c.reason),
+          hint: `Payment required to continue: ${display}. Relay that amount to your human and get approval, then run 'dvm pay ${jobId}'. Provider's stated reason is wrapped as { _source: "provider", text: ... } \u2014 verify it matches the work you expect.`
+        };
+      }
+      case "working": {
+        const c = msg.content;
+        return {
+          type: "poll",
+          job_id: jobId,
+          estimate_seconds: c.estimate_seconds,
+          hint: c.hint !== void 0 ? asProviderText(c.hint) : "Provider is working, check back later"
+        };
+      }
+    }
+  }
+  return null;
+}
+
+// src/lib/wallet-probe.ts
+async function probeWallets(opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const config = loadConfig();
+  const cashuMints = await loadConfiguredMints();
+  const walletType = detectWalletType(config, cashuMints);
+  const rate = await fetchBtcUsdRate().catch(() => null);
+  const probes = await Promise.allSettled([
+    probeLightning(timeoutMs),
+    probeX402(config?.x402, timeoutMs),
+    probeMpp(config?.tempo, timeoutMs)
+  ]);
+  const rails = [];
+  const cashuRow = probeCashu(cashuMints);
+  if (cashuRow) rails.push(cashuRow);
+  for (const result of probes) {
+    if (result.status === "fulfilled" && result.value !== null) {
+      rails.push(result.value);
+    }
+  }
+  const totalLnAndCashuMsats = rails.filter((r) => r.rail === "lightning" || r.rail === "cashu").reduce((sum, r) => sum + (r.balanceMsats ?? 0), 0);
+  return { walletType, rate, rails, totalLnAndCashuMsats, cashuMints };
+}
+async function probeLightning(timeoutMs) {
+  let float;
+  try {
+    float = loadFloat();
+  } catch (err) {
+    const mapped = toFloatError(err);
+    return {
+      rail: "lightning",
+      configured: true,
+      reachable: false,
+      error: {
+        code: mapped.code,
+        message: mapped.message,
+        // The same drop fixed one branch down: `float_invalid_uri` knows to say
+        // "reconnect with a URI copied whole", and the row was rendering the
+        // generic rail hint over the top of it (internal-review).
+        ...mapped.hint ? { hint: mapped.hint } : {},
+        ...refusalFields(mapped.data)
+      }
+    };
+  }
+  if (!float) return null;
+  const probe = await withTimeout(probeFloat({ float, timeoutMs }), timeoutMs, "lightning").catch(
+    (err) => ({
+      reachable: false,
+      methods: [],
+      canPay: false,
+      canInvoice: false,
+      canReconcile: false,
+      error: {
+        code: "float_wallet_offline",
+        message: err instanceof Error ? err.message : String(err),
+        display: "Your Lightning wallet didn't answer in time."
+      }
+    })
+  );
+  const details = {
+    alias: probe.alias ?? null,
+    methods: probe.methods,
+    can_pay: probe.canPay,
+    can_reconcile: probe.canReconcile,
+    stated_budget: float.statedBudget ?? null
+  };
+  if (probe.walletReportedBudget) details.wallet_reported_budget = probe.walletReportedBudget;
+  if (probe.reachable && probe.balanceMsats === void 0) details.balance_unknown = true;
+  if (!probe.reachable) {
+    return {
+      rail: "lightning",
+      configured: true,
+      reachable: false,
+      details,
+      error: {
+        code: probe.error?.code ?? "float_wallet_offline",
+        message: probe.error?.message ?? "The Lightning wallet did not respond.",
+        // Lightning was the one rail dropping the probe's own diagnosis here,
+        // so every float failure rendered as the generic "re-connect" remedy —
+        // the wrong move for a connection the wallet refused on a permission
+        // (internal-review). x402 and Tempo already forward theirs via `classifyError`.
+        ...probe.error?.hint ? { hint: probe.error.hint } : {},
+        ...refusalFields(probe.error?.data)
+      }
+    };
+  }
+  return {
+    rail: "lightning",
+    configured: true,
+    reachable: true,
+    // Left absent, never coerced to 0 — see `details.balance_unknown` above.
+    ...probe.balanceMsats === void 0 ? {} : { balanceMsats: probe.balanceMsats },
+    details
+  };
+}
+function refusalFields(data) {
+  const text = (key) => {
+    const value = data?.[key];
+    return typeof value === "string" ? value : void 0;
+  };
+  const method = text("method");
+  const restriction = text("restriction");
+  const walletMessage = text("wallet_message");
+  return {
+    ...method ? { method } : {},
+    ...restriction ? { restriction } : {},
+    ...walletMessage ? { wallet_message: walletMessage } : {}
+  };
+}
+function probeCashu(cashuMints) {
+  const configured = (cashuMints?.length ?? 0) > 0;
+  const balanceMsats = getBalance2();
+  if (!configured && balanceMsats === 0) return null;
+  const byMint = getBalanceByMint();
+  const byMintObj = {};
+  for (const url of cashuMints ?? []) {
+    byMintObj[url] = byMint.get(url) ?? 0;
+  }
+  for (const [url, msats] of byMint) {
+    if (!(url in byMintObj)) byMintObj[url] = msats;
+  }
+  return {
+    rail: "cashu",
+    configured,
+    reachable: true,
+    balanceMsats,
+    details: { byMint: byMintObj }
+  };
+}
+async function probeX402(x402, timeoutMs) {
+  if (!x402) return null;
+  let network;
+  let address;
+  try {
+    const { loadX402Wallet: loadX402Wallet2, getX402Balance: getX402Balance2, ensureAddress: ensureAddress2, usdcContractByCaip2: usdcContractByCaip22 } = await import("../x402-FTG2GRAQ.js");
+    const wallet = loadX402Wallet2();
+    if (!wallet) {
+      const storedKey = x402.privateKey;
+      const missing = storedKey === void 0 || storedKey === "";
+      return {
+        rail: "x402",
+        configured: true,
+        reachable: false,
+        ...x402.network ? { details: { network: x402.network } } : {},
+        error: missing ? {
+          code: "x402_key_missing",
+          message: "x402 config is present but privateKey is missing or empty.",
+          hint: "Run 'dvm wallet x402-connect' to create a wallet, or add --key-file <path> to import a key you already hold."
+        } : {
+          code: "x402_key_invalid",
+          message: "x402 config contains a privateKey that is not a valid secp256k1 scalar.",
+          hint: "Run 'dvm wallet x402-connect' to create a replacement wallet, or add --key-file <path> to import a valid key you already hold."
+        }
+      };
+    }
+    network = wallet.network;
+    const w = await withTimeout(ensureAddress2(wallet), timeoutMs, "x402");
+    address = w.address;
+    const balance = await withTimeout(getX402Balance2(w), timeoutMs, "x402");
+    return {
+      rail: "x402",
+      configured: true,
+      reachable: true,
+      balanceUsdc: balance.usdc,
+      // internal-review: record the contract the balance was actually read against —
+      // a zero here only means "none of *this* token, on *this* chain". Map
+      // lookup off the network already resolved; no second RPC.
+      details: {
+        address: w.address,
+        network: w.network,
+        token: usdcContractByCaip22(w.network),
+        // internal-review: and the endpoint that answered, which the caller can
+        // point elsewhere — a wrong one reads as a plausible $0.00 otherwise.
+        // Redacted here, at the boundary where the URL becomes display.
+        ...rpcDetails(balance.rpcUrlRedacted, balance.rpcSource)
+      }
+    };
+  } catch (err) {
+    const details = { ...address ? { address } : {}, ...network ? { network } : {} };
+    return {
+      rail: "x402",
+      configured: true,
+      reachable: false,
+      ...Object.keys(details).length > 0 ? { details } : {},
+      error: classifyError("x402_unreachable", err)
+    };
+  }
+}
+async function probeMpp(mpp, timeoutMs) {
+  if (!mpp) return null;
+  if (mpp.method === "tempo") {
+    try {
+      const { connectedTempoAccount: connectedTempoAccount2, getTempoUsdcBalance: getTempoUsdcBalance2, TEMPO_CHAIN_ID: TEMPO_CHAIN_ID2 } = await import("../tempo-wallet-QOLEIPCV.js");
+      const account = await connectedTempoAccount2();
+      if (!account) {
+        return {
+          rail: "tempo",
+          configured: true,
+          reachable: false,
+          error: {
+            code: "tempo_key_missing",
+            message: "Tempo config is present but apiKey is missing or not a private key.",
+            hint: "Run 'dvm wallet tempo-connect' to generate a key, or add '--key-file <path>' to import one you already hold (DVM_TEMPO_KEY and piped stdin work too)."
+          }
+        };
+      }
+      try {
+        const balance = await withTimeout(getTempoUsdcBalance2(account), timeoutMs, "tempo");
+        return {
+          rail: "tempo",
+          configured: true,
+          reachable: true,
+          balanceUsdc: balance.usdc,
+          // internal-review: record the contract the balance was actually read
+          // against — a zero here only means "none of *this* token".
+          details: {
+            address: account.address,
+            chain_id: TEMPO_CHAIN_ID2,
+            token: balance.tokenAddress,
+            // internal-review: as on x402 above — which endpoint the number came from.
+            ...rpcDetails(balance.rpcUrlRedacted, balance.rpcSource)
+          }
+        };
+      } catch (err) {
+        return {
+          rail: "tempo",
+          configured: true,
+          reachable: false,
+          balanceUsdc: void 0,
+          details: { address: account.address, chain_id: TEMPO_CHAIN_ID2, balance_unknown: true },
+          error: classifyError("tempo_unreachable", err)
+        };
+      }
+    } catch (err) {
+      return {
+        rail: "tempo",
+        configured: true,
+        reachable: false,
+        error: classifyError("tempo_unavailable", err)
+      };
+    }
+  }
+  return {
+    rail: "tempo",
+    configured: true,
+    reachable: false,
+    error: { code: "tempo_unknown_method", message: `unknown Tempo method: ${mpp.method}` }
+  };
+}
+function withTimeout(p, ms, rail) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => {
+      reject(new Error(`${rail} probe timed out after ${ms}ms`));
+    }, ms);
+    p.then(
+      (v) => {
+        clearTimeout(t);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(t);
+        reject(e instanceof Error ? e : new Error(String(e)));
+      }
+    );
+  });
+}
+function rpcDetails(rpcUrlRedacted, rpcSource) {
+  if (!rpcUrlRedacted) return {};
+  return { rpc_url: rpcUrlRedacted, rpc_source: rpcSource };
+}
+function classifyError(code, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (err instanceof DvmError) {
+    return { code: err.code, message, ...err.hint ? { hint: err.hint } : {} };
+  }
+  return { code, message };
+}
 export {
   ADMIN_STATE_UNAVAILABLE,
+  AGENT_MNEMONIC_FILE,
+  BTC_RATE_FILE,
+  BUDGET_FILE,
   CAPABILITY_NAME_RE,
   COINGECKO_SIMPLE_PRICE_URL,
+  CONFIG_AUDIT_FILE,
+  CONFIG_BACKUP_FILE,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  CONFIG_PINNED_FILE,
+  CREDITS_FILE,
   CREDIT_DRAIN_RAILS,
   CREDIT_FUNDING_MODES,
   CREDIT_FUND_RAILS,
+  CREDIT_POSTURES,
+  DEFAULT_AGENT_MINT_URL,
+  DEFAULT_CREDIT_POSTURE,
   DEFAULT_LOCK_PUBKEY_GRACE_SECONDS,
+  DEFAULT_RESERVE_LOCKTIME_SECONDS,
   DbTransport,
   DvmError,
   DvmX402ChannelStorage,
+  FAVORITES_FILE,
+  FEEDBACK_NUDGES_FILE,
+  FEEDBACK_POSTURES,
   FX_CACHE_TTL_MS,
   FX_RETRY_COUNT,
+  IDENTITIES_FILE,
+  IDENTITIES_VERSION,
   InvalidUsdPriceError,
+  JOBS_FILE,
   JobCancelledError,
+  MESSAGES_DIR,
   MemoryKVStore,
   MintHealthTracker,
   NON_CHANNEL_BITCOIN_RAILS,
+  NWC_FUNDING_FLOAT_ROLE,
   NwcBackend,
   NwcError,
+  PAIRINGS_DIR,
   PAYMENT_PROOF_KEYS,
+  PRIVKEY_HEX_RE,
   PayoutReporter,
+  PersistentCounterSource,
   PostgresTempoChargeStore,
   PostgresTempoSessionStore,
+  RAIL_FLAGS,
   RAIL_REFUNDABLE,
+  RECEIPTS_FILE,
   RECENT_SPENDS_CAP,
+  RECOMMENDED_MINTS,
+  RECOVERY_MNEMONIC_FILE,
+  REQUEST_INTENTS_DIR,
+  RESUME_MAX_AGE_MS,
+  RESUME_MAX_ATTEMPTS,
   ROUTER_FEEDBACK_CLAIM_HEADER,
   ROUTER_FEEDBACK_CLAIM_TTL_MS,
   RevenueReporter,
@@ -6103,15 +9451,20 @@ export {
   SpanWriter,
   StepCache,
   TEMPO_CHAIN_ID,
+  TEMPO_CHANNELS_FILE,
   TEMPO_CLOSE_DB_RECOVERY_BUDGET_MS,
   TEMPO_CLOSE_REQUESTED_TOPIC,
+  TEMPO_EXIT_KEY_MISSING_HINT,
   TempoSessionChannelMismatchError,
+  WALLET_FILE,
+  WALLET_VERSION,
   X402EnvValidationError,
   X402FacilitatorHealth,
   X402_BATCH_CHANNEL_ABI,
   X402_BATCH_SETTLEMENT_KEY,
   X402_BATCH_SETTLEMENT_MAINNET_NETWORK,
   X402_BATCH_SETTLEMENT_SCHEME,
+  X402_CHANNELS_FILE,
   X402_DEFAULT_FACILITATOR,
   X402_DEFAULT_NETWORK,
   X402_EXACT_AUTHORIZATION_TTL_SECONDS,
@@ -6125,47 +9478,81 @@ export {
   X402_V1_VERSION,
   X402_VERSION,
   _testing,
+  abandonPendingSubmission,
   abortJob,
   acknowledgeReplayedX402Payment,
   acknowledgeX402ChannelOwner,
   activePubkeySet,
+  addPayment,
+  advanceTempoChannelExit,
+  amountBoundsVerdict,
+  applyImplicitReceiptCredit,
   applyPaymentInfoToJob,
+  applyReceiptCredit,
   applyRetryToPool,
   asProviderText,
+  asProviderTextOpt,
+  assertAgentMnemonicReplaceable,
+  assertFloatBudget,
+  assertNutSupport,
   assertRevenueReporterReady,
   assertSupportedX402Network,
+  assertTempoWalletIdle,
   assertValidBudget,
+  assertX402ChannelPayer,
   assertX402RequirementDescribesChannel,
+  assertX402WalletIdle,
   attestedDvmIdentity,
   authenticatedBuilderPubkey,
+  authorizeProtectedRemoval,
+  automaticCreditBoundRail,
   availableRails,
+  backfillTrustAnchor,
   backupSecretFile,
   buildAdminAuthHeader,
   buildAdminChallenge,
   buildAttestation,
+  buildCompletionHintFields,
+  buildDisplayMintInventory,
   buildPaymentErrorResponse,
   buildPaymentRequiredV2,
   buildPaymentRequirements,
+  buildPolicy,
   buildTempoCredential,
   builderLockPath,
   caip2ToX402Network,
   canReplaceExpiredX402Deposit,
   canSwap,
+  canonicalRequestPath,
   canonicaliseForSigning,
   canonicalize,
+  captureFundingReceipt,
+  captureTransportReceipt,
+  cashOutFromMint,
   cashuSubmissionBindingFingerprint,
   chainIdFromCaip2,
   checkMeltQuoteState,
   checkMintHealth,
   checkReceiptAttestation,
   clearAccumulatorForDvm,
+  clearCreditSelection,
   clearPendingDrain,
   clearPendingX402ExactFunding,
   clearPendingX402Funding,
+  clearRefillRailUnavailable,
+  generateIdentity2 as cliIdentityStoreGenerateIdentity,
+  commitAgentSpend,
+  completionFromMessages,
+  completionSnapshot,
+  computeNextAction,
   computeResultHash,
   computeSmartDenominations,
+  configSnapshotPath,
+  connectedTempoAccount,
   connectedX402Payer,
+  correctPendingFundAmount,
   costAnchor,
+  coveringMintsForSpend,
   createAdminCashuNonceStore,
   createDVMServer,
   createDefaultReplayStore,
@@ -6173,55 +9560,90 @@ export {
   createMonotonicClock,
   createNoopLogger,
   createStdoutLogger,
+  createTempoCloseCredential,
   createX402BatchPayment,
   creditDepositPayload,
   currentContext,
   decodePayment,
   decodePaymentRequiredHeader,
+  deleteAgentMnemonic,
   depleteLots,
+  deriveAgentMasterKeypair,
   deriveBuilderLockKeypair,
   deriveBuilderLockPubkey,
+  deriveIdentityFromPrivkey,
+  derivePubkeyFromPrivkey,
   deriveReceiptKeypair,
   deriveReceiptSecret,
+  deriveTempoAddress,
   derivedFundCreditId,
+  describeConfigBackup,
+  describeMintBounds,
   devModeSkipsPaymentVerification,
   drainReceiptsDisplay,
   drainReceiptsHint,
+  dvmLocationIdentity,
+  effectiveCreditPosture,
+  effectiveFundingMint,
+  effectiveFundingRail,
+  effectiveMints,
+  emitFloatBudgetWarning,
   encodePayment,
   encodePaymentRequiredHeader,
   encodeSettleResponseHeader,
   enforceGlobalBudget,
   ensureAddress,
+  ensureConfig,
+  ensureConfigDir,
+  ensureConfigSubdir,
   ensureProvisionalCredit,
+  entryKind,
   epochMsToIso,
   exactEvmAuthorization,
+  extractBuilderHandle,
   fetchBtcUsdRate,
   fetchCoinGeckoBtcUsd,
   fetchCoinGeckoSpot,
   fetchLnurlPayInvoice,
   fetchMeltQuote,
+  fetchMissingJobReceipt,
+  fetchTrustAnchor,
   fifoOrder,
+  findSigningIdentityByPubkey,
   findX402Channel,
+  floatBudgetJson,
+  floatPaymentDisplay,
+  floatPaymentJson,
+  forgetCredit,
   formatAmount,
   formatAmountBestEffort,
+  formatLocktime,
   formatPaymentAmount,
   formatSats,
   formatStaleness,
   formatUsd,
   formatUsdcMicrounits,
   fromJobRecord,
+  fundAgentWallet,
   fundCredit,
+  fundWireAmountMicro,
   fundedMicroFor,
   fundingModeForTempoIntent,
   fundingModeForX402Flavour,
   fundingRailLabel,
+  generateAgentMnemonic,
   generateEphemeralReceiptKey,
   generateIdentity,
+  generateTempoKey,
   generateX402PrivateKey,
   getBalance,
+  getBalanceByMint,
+  getFundingGuidance,
   getInfo,
   getInputFeesForProofs,
   getLastKnownBtcRate,
+  getOutputTraceId,
+  getTempoUsdcBalance,
   getWallet,
   getX402Balance,
   hasPaymentProof,
@@ -6229,8 +9651,10 @@ export {
   hashLockKey,
   hashedCanonicalDvmId,
   humanizeZodError,
+  identitiesFileExists,
   implicitCreditId,
   inKindDrawMsats,
+  info,
   initLockPubkeyTable,
   initLoggers,
   initWalletAccumulatorTable,
@@ -6239,74 +9663,134 @@ export {
   installAdminCashuRoutes,
   isAbortError,
   isArtifactMessage,
+  isCancelMessage,
+  isCompleteMessage,
   isCreditFundRail,
   isCreditFundingMode,
+  isCreditPosture,
   isDerivedCreditId,
   isDrainReceipt,
+  isFeedbackPosture,
   isFundingReceipt,
   isInKindDepletion,
   isNonChannelBitcoinRail,
+  isPaymentRailKey,
   isPaymentRequestMessage,
   isPromptMessage,
+  isPublicRequestId,
+  isResumable,
   isSignedJobReceipt,
   isStablecoinFundRail,
   isStaleJobReapable,
   isTerminal,
+  isTerminalJobStatus,
+  isTextMessage,
+  isValidEvmPrivateKey,
+  isWorkingMessage,
   isYieldMessage,
   issueRouterFeedbackClaim,
   issueUpfrontChallenges,
   jobCredentialGate,
+  json,
+  listCredits,
+  listFundingMenuSnapshots,
+  listImplicitCredits,
+  listPendingFundings,
   listPendingX402Fundings,
   listPendingX402FundingsForChannel,
+  listResumableTempoChargeFundings,
   listResumableX402ExactFundings,
   listResumableX402Fundings,
   listTempoChannelAssociations,
   listX402Channels,
   loadAgentWallet,
+  loadAllJobs,
+  loadConfig,
   loadConfiguredMints,
   loadCredit,
+  loadFloat,
+  loadIdentities,
   loadIdentitySecret,
+  loadImplicitCredits,
+  loadJob,
   loadLedger,
   loadLockPubkeyState,
+  loadPendingFunding,
+  loadReceipt,
+  loadReceipts,
   loadResumableX402ExactFunding,
   loadResumableX402Funding,
+  loadTempoChannelAssociation,
+  loadTempoChannelController,
   loadTempoChannelEntry,
   loadX402Wallet,
   toLockPubkey as lockPubkeyStoreToLockPubkey,
   loggers,
+  looksLikeMnemonic,
   lookupInvoice,
   lotOwedSats,
   makeInvoice,
+  markCredit,
+  markImplicitCreditLost,
+  markJobTerminal,
+  markRefillDrainNoticed,
+  markRefillRailUnavailable,
   maxKeysetDenomination,
+  microToSats,
   missingDleqRecoveryDiagnostic,
+  mnemonicFingerprint,
   monetaryJson,
   msatsToFiatMicro,
+  msatsToMicro,
   msatsToUsd,
   msatsToUsdCents,
   msatsToUsdc,
+  needsPocketRefill,
+  needsTopup,
   netOwedSats,
+  nextStepHint,
+  normalizeCreditEndpoint,
   normalizeFeedbackEndpointHost,
   nwcDedupWindowMs,
+  nwcRejectionDisplay,
   nwcTimeoutMs,
+  offersTempoCreditFunding,
   offersX402CreditFunding,
   parseBudget,
   parseCreditMenu,
   parseCreditTerms,
   parseLnAddress,
+  parseLocktime,
   parseNwcUri,
+  parseStatedBudget,
+  parseTraceparent,
   parseUsdPrice,
   payInvoiceReconciling,
+  payViaFloat,
   paymentErrorBody,
+  paymentRailLabel,
   paymentRequiredV2FromV1,
+  pendingDrainById,
   pendingDrainFor,
   pickCreditFundRail,
   pinAskFiat,
+  pinConfigSnapshot,
   pinDimension,
+  planConfigReset,
   planCreditForQuote,
+  planProbeDraw,
+  pocketTargetMicro,
+  pollNextAction,
   pollPendingCreditFundings,
   preferLightningFirst,
+  prepareAgentSpend,
   prepareP2PKMint,
+  previewConfigRollback,
   priceFiatMicro,
+  printFundingGuidance,
+  probeFloat,
+  probeRailLabel,
+  probeWallets,
   processIncomingPayment,
   processX402BatchCorrection,
   processX402BatchResponse,
@@ -6315,39 +9799,78 @@ export {
   providerProseSources,
   providerTextToString,
   pruneRetired,
+  railLabelAtSentenceStart,
   randomTraceId,
   rateUnavailablePaymentError,
+  raw,
+  readFundValuation,
+  readX402ChannelOnChain,
   receiptDisplay,
   receiptFailureDetail,
   receiptHint,
   receiptIssuedAtIso,
+  receiptJsonFields,
   receiptPubkeyFromSecret,
+  receiptTrustFields,
+  receiveToAgentWallet,
+  reclaimAtMs,
   reconcileRefusedX402Deposits,
+  reconcileTempoChannelOnChain,
+  recordBalanceResponse,
   recordCreditX402Instrument,
+  recordDrainReceipts,
+  recordFloatSpend,
+  recordFundResponse,
+  recordFundingMenuSnapshot,
   recordPendingDrain,
   recordPendingX402ExactFunding,
   recordPendingX402Funding,
+  recordRefusedDrawBalance,
   recordSpend,
   recordX402ChannelMetadata,
+  recoverPendingSubmission,
+  redactUrl,
+  redactUrlsInText,
+  refFromJob,
   refundX402BatchChannel,
+  releaseAgentReserve,
   removeX402Wallet,
+  renderReceiptHuman,
+  repairConfigDirMode,
   repairX402ExactSettlementEffect,
   repinX402WalletNetwork,
+  replayStoredReceipt,
+  reserveAgentWallet,
+  resolveBtcUsdRate,
+  resolveFundMint,
   resolveFxSnapshot,
   resolveLnurlPayMetadataUrl,
   resolvePriceFiat,
   resolveRpcHttpTransportOptions,
   resolveRpcOverride,
+  resolveSigningIdentity,
+  resolveTempoAsset,
+  resolveX402Asset,
+  resolveX402ChannelRpc,
   restoreProofsFromOutputs,
+  retireConfigBackup,
   retirePendingX402Funding,
   revenueReporterBannerState,
+  rollbackConfig,
   rotateLockPubkey,
+  rpcEndpointLine,
+  rpcEndpointSuffix,
   saveAgentWallet,
+  saveIdentities,
+  saveJob,
+  saveLedger,
   saveX402Wallet,
   seedLockPubkeyState,
   selectProofsForSpend,
   serializeOutputData,
   setEmitter,
+  setOutputTraceId,
+  settleDrainEvidence,
   settleWithFacilitator,
   shellQuoteArg,
   signAttestation,
@@ -6357,20 +9880,49 @@ export {
   signReceipt,
   signRequestData,
   signedRequestDomain,
+  spendableAt,
+  staleRateNotice,
+  statusSnapshot,
   swapFeeForProofs,
   swapSendReserve,
+  sweepPendingMelts,
+  sweepPendingMints,
+  sweepPendingSubmissions,
+  sweepStaleInFlight,
+  tempoBalanceCheckHint,
+  tempoChannelControlledBy,
   tempoCredentialAmountMicro,
+  tempoKeyImportRoutes,
+  tempoSessionChallenge,
+  tempoSessionChallengeMicro,
+  tempoTokenReference,
+  tempoWrongAssetHint,
+  tierCapOverrides,
+  toAgentProof,
   toCreditTerms,
+  toFloatError,
   toJobRecord,
   toLockPubkey,
   transportErrorCode,
+  trustLadderFor,
+  trustOverrideCapMicro,
+  tryResolveBtcUsdRate,
+  tryResolveTempoAsset,
+  tryX402Payment,
   unknownRouteNotFound,
+  unreachableRailDisplay,
+  unreachableRailHint,
+  unrecordedFloatBudgetWarning,
+  unsignRequestData,
+  updateConfig,
+  updateJob,
   usdToMsats,
   usdcContractByCaip2,
   usdcContractFor,
   usdcDomainNameFor,
   usdcDomainVersionFor,
   usdcToMsats,
+  validateAgentMnemonic,
   validateLnAddress,
   validateX402Env,
   verifyAttestation,
@@ -6388,17 +9940,27 @@ export {
   verifyUpfrontPayment,
   verifyWithFacilitator,
   verifyX402Payment,
+  walletExists,
   warmFxSnapshot,
   weakestReceiptVerdict,
+  windowStart,
+  withIdentitiesLock,
   withInitRetry,
   withNwcPool,
+  withTempoChannelLock,
   withTraceContext,
   withWalletLock,
   withX402ChannelLock,
   wrapMppx,
+  writeAgentMnemonic,
   writeIdentity,
   x402ChannelBalanceUnreconciledAt,
+  x402ChannelControlledBy,
+  x402ChannelReservation,
+  x402CreditChannelNetworks,
+  x402CreditExactNetworks,
   x402ExactFundingDead,
+  x402FlavourForInstrument,
   x402NetworkByCaip2,
   x402NetworkBySlug,
   x402NetworkLabel,
@@ -6412,7 +9974,9 @@ export {
   x402PendingUnsettled,
   x402RequiredFromError,
   x402RequiredUsdcMicro,
+  x402ReservationRelease,
   x402SettledShare,
   x402SupportedNetworksHint,
-  x402VoucherPendingRefusal
+  x402VoucherPendingRefusal,
+  x402WrongAssetHint
 };