indelible-mcp 5.7.8 → 5.8.0

package/LICENSE

@@ -15,7 +15,7 @@ Additional Use Grant: You may make use of the Licensed Work for personal,
                       commercial blockchain storage, session saving, or
                       encrypted vault service without written permission
                       from the Licensor.
-Change Date:          August 14, 2030
+Change Date:          August 18, 2030
 Change License:       MIT License
 
 Terms

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indelible-mcp",
-  "version": "5.7.8",
+  "version": "5.8.0",
   "description": "Blockchain-backed memory and code storage for Claude Code. Save AI conversations and source code permanently on BSV.",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -744,6 +744,52 @@ var init_utxo_cache = __esm({
   }
 });
 
+// mcp-server/lib/tx-size.js
+function sdkCompatVarIntSize(i) {
+  if (i > 2 ** 32) return 9;
+  if (i > 2 ** 16) return 5;
+  if (i > 253) return 3;
+  return 1;
+}
+function pushDataHeaderSize(n) {
+  if (n <= 75) return 1;
+  if (n <= 255) return 2;
+  if (n <= 65535) return 3;
+  return 5;
+}
+function txBytes(inputs, { dataBytes = 0, prefixBytes = SAVE_PREFIX_BYTES, p2pkhOuts = 0 } = {}) {
+  const k = Math.max(0, Math.floor(inputs));
+  let outCount = 1 + p2pkhOuts;
+  let outBytes = 8 + 1 + 25;
+  outBytes += p2pkhOuts * (8 + 1 + 25);
+  if (dataBytes > 0) {
+    outCount += 1;
+    const script = 1 + 1 + pushDataHeaderSize(prefixBytes) + prefixBytes + pushDataHeaderSize(dataBytes) + dataBytes;
+    outBytes += 8 + sdkCompatVarIntSize(script) + script;
+  }
+  return 4 + sdkCompatVarIntSize(k) + k * INPUT_BYTES + sdkCompatVarIntSize(outCount) + outBytes + 4;
+}
+function feeForInputs(inputs, shape = {}) {
+  return Math.ceil(txBytes(inputs, shape) / 1e3 * FEE_PER_KB);
+}
+function fragmentationBudget(shape = {}) {
+  return Math.max(FRAG_BUDGET_FLOOR_SATS, Math.ceil(FRAG_BUDGET_RATIO * feeForInputs(1, shape)));
+}
+var INPUT_BYTES, FEE_PER_KB, MIN_SPENDABLE_SATS, MIN_RECORDED_CHANGE, SAVE_PREFIX_BYTES, FRAG_BUDGET_FLOOR_SATS, FRAG_BUDGET_RATIO, MAX_TX_BYTES, MAX_INPUTS_BY_SIGN_BUDGET;
+var init_tx_size = __esm({
+  "mcp-server/lib/tx-size.js"() {
+    INPUT_BYTES = 149;
+    FEE_PER_KB = 150;
+    MIN_SPENDABLE_SATS = 24;
+    MIN_RECORDED_CHANGE = 547;
+    SAVE_PREFIX_BYTES = 19;
+    FRAG_BUDGET_FLOOR_SATS = 1e3;
+    FRAG_BUDGET_RATIO = 1;
+    MAX_TX_BYTES = 12 * 1024 * 1024 - 512;
+    MAX_INPUTS_BY_SIGN_BUDGET = 3e3;
+  }
+});
+
 // mcp-server/lib/spent-by.js
 var spent_by_exports = {};
 __export(spent_by_exports, {
@@ -807,6 +853,7 @@ var utxo_reservation_exports = {};
 __export(utxo_reservation_exports, {
   CONFLICT_RE: () => CONFLICT_RE,
   TX_KNOWN_RE: () => TX_KNOWN_RE,
+  claimRefusalMessage: () => claimRefusalMessage,
   claimSpendableUtxos: () => claimSpendableUtxos,
   linkOrRefuse: () => linkOrRefuse,
   linkReservation: () => linkReservation,
@@ -814,6 +861,7 @@ __export(utxo_reservation_exports, {
   probeTxVerdict: () => probeTxVerdict,
   reconcileHooks: () => reconcileHooks,
   reconcileReservations: () => reconcileReservations,
+  selectInputs: () => selectInputs,
   settleFromWriteResult: () => settleFromWriteResult,
   settleReservation: () => settleReservation
 });
@@ -911,6 +959,82 @@ function reservedInputSet(store, { exceptToken } = {}) {
   }
   return s;
 }
+function claimRefusalMessage(claim2) {
+  const r = claim2 && claim2.reason;
+  if (r === "UNECONOMIC_FRAGMENTATION") {
+    return `This save is blocked to protect your money: your wallet holds enough (${claim2.available} sats), but it is spread across so many small coins that the transaction fee would be ${claim2.feeTotal} sats - ${claim2.fragSats} sats MORE than the ${claim2.baseline} sats this save would cost from a single coin (limit: ${claim2.budgetSats} sats extra). Do NOT add funds - you already have them, and adding more will not help. This needs a consolidation step the software does not offer yet; contact support at indeliblebsv@gmail.com and mention UNECONOMIC_FRAGMENTATION. Your data is not lost - nothing was broadcast and nothing was spent.`;
+  }
+  if (r === "TOO_MANY_INPUTS") {
+    return `This save cannot be funded in one transaction: it would need ${claim2.inputsNeeded} coins, above the ${claim2.cap}-input signing limit. Nothing was spent. Contact support at indeliblebsv@gmail.com and mention TOO_MANY_INPUTS.`;
+  }
+  if (r === "TX_TOO_LARGE") {
+    return `This save would produce a ${claim2.txBytes.toLocaleString()}-byte transaction, above the ${claim2.maxTxBytes.toLocaleString()}-byte network envelope - too large to broadcast. Nothing was spent. Split the content into smaller saves.`;
+  }
+  if (r === "NO_ECONOMIC_COINS") {
+    return `Your wallet holds ${claim2.dust && claim2.dust.sats ? claim2.dust.sats : 0} sats, but only in coins so small that each costs more in fees (~23 sats) than it adds. These cannot fund a save. Add funds in ONE normal-sized payment - the small coins remain yours, but stay unusable until a consolidation feature exists.`;
+  }
+  if (r === "INSUFFICIENT_FUNDS") {
+    const held = claim2.reservedSats > 0 ? ` (${claim2.reservedSats} more sats are temporarily reserved by another agent on this box and free up shortly)` : "";
+    return `Not enough funds: this save needs about ${claim2.need} sats and the wallet holds ${claim2.available} spendable${held}. Fund your wallet - a single payment of at least ${claim2.need} sats always suffices.`;
+  }
+  if (r === "NO_COINS") return "No UTXOs available. Fund your wallet.";
+  return "No UTXOs available. Fund your wallet.";
+}
+function selectInputs(free, spend = {}) {
+  const {
+    dataBytes = 0,
+    prefixBytes,
+    p2pkhOuts = 0,
+    extraOutSats = 0,
+    allowFragmentationCost = false,
+    maxInputs = MAX_INPUTS_BY_SIGN_BUDGET,
+    maxTxBytes = MAX_TX_BYTES
+  } = spend;
+  const shape = { dataBytes, p2pkhOuts, ...prefixBytes !== void 0 ? { prefixBytes } : {} };
+  const raw = (free || []).filter((u) => Number.isFinite(u?.value) && u.value > 0);
+  const coins = raw.filter((u) => u.value >= MIN_SPENDABLE_SATS);
+  const rawSats = raw.reduce((n, u) => n + u.value, 0);
+  const available = coins.reduce((n, u) => n + u.value, 0);
+  const dust = { count: raw.length - coins.length, sats: rawSats - available };
+  const target = (k) => feeForInputs(k, shape) + extraOutSats + MIN_RECORDED_CHANGE;
+  if (raw.length === 0) return { ok: false, reason: "NO_COINS", need: target(1), available: 0, dust };
+  if (coins.length === 0) return { ok: false, reason: "NO_ECONOMIC_COINS", need: target(1), available: 0, dust };
+  if (txBytes(1, shape) > maxTxBytes) {
+    return { ok: false, reason: "TX_TOO_LARGE", txBytes: txBytes(1, shape), maxTxBytes, available, dust };
+  }
+  const ascending = [...coins].sort((a, b) => a.value - b.value);
+  const single = ascending.find((u) => u.value >= target(1));
+  if (single) return { ok: true, inputs: [single], fee: feeForInputs(1, shape), fragSats: 0, dust };
+  const descending = [...coins].sort((a, b) => b.value - a.value);
+  const picked = [];
+  let total = 0;
+  let kMin = 0;
+  for (const u of descending) {
+    picked.push(u);
+    total += u.value;
+    if (total >= target(picked.length)) {
+      kMin = picked.length;
+      break;
+    }
+  }
+  if (!kMin) {
+    return { ok: false, reason: "INSUFFICIENT_FUNDS", need: target(1), available, dust };
+  }
+  if (txBytes(kMin, shape) > maxTxBytes) {
+    return { ok: false, reason: "TX_TOO_LARGE", txBytes: txBytes(kMin, shape), maxTxBytes, available, dust };
+  }
+  if (kMin > maxInputs) {
+    return { ok: false, reason: "TOO_MANY_INPUTS", inputsNeeded: kMin, cap: maxInputs, available, dust };
+  }
+  const baseline = feeForInputs(1, shape);
+  const feeTotal = feeForInputs(kMin, shape);
+  const fragSats = feeTotal - baseline;
+  const budgetSats = fragmentationBudget(shape);
+  if (fragSats > budgetSats && !allowFragmentationCost) {
+    return { ok: false, reason: "UNECONOMIC_FRAGMENTATION", fragSats, budgetSats, feeTotal, baseline, inputsNeeded: kMin, available, dust };
+  }
+  return { ok: true, inputs: picked, fee: feeTotal, fragSats, dust };
+}
 async function claimSpendableUtxos(address, bridgeFallback, opts = {}) {
   const { waitMs = DEFAULT_WAIT_MS, pollMs = DEFAULT_POLL_MS, leaseMs = DEFAULT_LEASE_MS, now = Date.now } = opts;
   const deadline = now() + waitMs;
@@ -933,12 +1057,20 @@ async function claimSpendableUtxos(address, bridgeFallback, opts = {}) {
       if (free.length === 0) {
         return { busy: (candidates || []).length > 0 };
       }
+      const selected = selectInputs(free, opts.spend);
+      if (!selected.ok) {
+        const wholeWallet = selectInputs(candidates || [], opts.spend);
+        if (wholeWallet.ok) return { busy: true };
+        const { ok: _ok, ...evidence } = selected;
+        const reservedSats = (candidates || []).filter((u) => reserved.has(inputKey(u))).reduce((s, u) => s + (u?.value || 0), 0);
+        return { refused: true, ...evidence, reservedSats };
+      }
       const token = randomUUID();
       store.reservations[token] = {
         owner_token: token,
         pid: process.pid,
         address,
-        inputs: free,
+        inputs: selected.inputs,
         claimed_at: now(),
         lease_until: now() + leaseMs,
         build_cache_key: null,
@@ -946,9 +1078,10 @@ async function claimSpendableUtxos(address, bridgeFallback, opts = {}) {
         unknown_cycles: 0
       };
       writeReservations(store);
-      return { token, utxos: free };
+      return { token, utxos: selected.inputs };
     }, LOCK_OPTS);
     if (claimed.token) return claimed;
+    if (claimed.refused) return { token: null, utxos: [], ...claimed };
     if (!claimed.busy) return { token: null, utxos: [] };
     if (!_saidWaiting) {
       _saidWaiting = true;
@@ -1200,6 +1333,7 @@ var init_utxo_reservation = __esm({
   "mcp-server/lib/utxo-reservation.js"() {
     init_file_lock();
     init_utxo_cache();
+    init_tx_size();
     CACHE_PATH2 = process.env.INDELIBLE_UTXO_CACHE || join6(homedir5(), ".indelible", "utxo-cache.json");
     RES_PATH = `${CACHE_PATH2}.reservations.json`;
     LOCK_PATH = `${CACHE_PATH2}.g401.lock`;
@@ -1233,6 +1367,7 @@ __export(spv_exports, {
   checkConfirmation: () => checkConfirmation,
   checkHealth: () => checkHealth,
   extractEncryptedFromTx: () => extractEncryptedFromTx,
+  fetchSourceTransactions: () => fetchSourceTransactions,
   getAddressHistory: () => getAddressHistory,
   getBridges: () => getBridges,
   getRawTx: () => getRawTx,
@@ -1435,6 +1570,26 @@ async function getRawTx(txid) {
 `);
   return text;
 }
+async function fetchSourceTransactions(utxos, fetchRaw = getRawTx) {
+  const wanted = [...new Set((utxos || []).map((u) => String(u.tx_hash).trim()))];
+  const byTxid = /* @__PURE__ */ new Map();
+  const t0 = Date.now();
+  let cursor = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const i = cursor++;
+      if (i >= wanted.length) return;
+      const txid = wanted[i];
+      byTxid.set(txid, Transaction.fromHex(await fetchRaw(txid)));
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(SOURCE_FETCH_CONCURRENCY, wanted.length) }, worker));
+  if ((utxos || []).length > 1) {
+    process.stderr.write(`[MCP] sources: ${wanted.length} distinct for ${utxos.length} inputs (${Date.now() - t0}ms)
+`);
+  }
+  return byTxid;
+}
 function bcastTimeoutMs(rawTxHex) {
   const txMB = (rawTxHex?.length || 0) / 2 / 1048576;
   return Math.min(18e4, Math.round(15e3 + txMB * 12e3));
@@ -1702,9 +1857,10 @@ async function buildOpReturnTx(wif, utxos, dataStr) {
   const tx = new Transaction();
   const p2pkh = new P2PKH();
   const lockingScript = p2pkh.lock(address);
+  const sourceByTxid = await fetchSourceTransactions(utxos);
   for (const utxo of utxos) {
-    const rawHex = await getRawTx(utxo.tx_hash);
-    const sourceTransaction = Transaction.fromHex(rawHex);
+    const sourceTransaction = sourceByTxid.get(String(utxo.tx_hash).trim());
+    if (!sourceTransaction) throw new Error(`source transaction unavailable for input ${utxo.tx_hash}:${utxo.tx_pos}`);
     tx.addInput({
       sourceTransaction,
       sourceOutputIndex: utxo.tx_pos,
@@ -1734,6 +1890,29 @@ async function buildOpReturnTx(wif, utxos, dataStr) {
     change: true
   });
   await tx.fee(new SatoshisPerKilobyte(150));
+  {
+    const _ci = tx.outputs.findIndex((o) => o.change);
+    if (_ci >= 0) {
+      const _cv = tx.outputs[_ci].satoshis || 0;
+      if (_cv > 0 && _cv <= 546) tx.outputs.splice(_ci, 1);
+    }
+  }
+  {
+    if (tx.inputs.length === 0) {
+      const e = new Error("ZERO_INPUT_BUILD: refusing to sign a transaction with no inputs \u2014 the caller handed an empty coin set");
+      e.code = "ZERO_INPUT_BUILD";
+      throw e;
+    }
+    const _totalIn = (utxos || []).reduce((s, u) => s + (u?.value || 0), 0);
+    const _outSum = tx.outputs.reduce((s, o) => s + (o.satoshis || 0), 0);
+    const _residual = _totalIn - _outSum;
+    const _model = await new SatoshisPerKilobyte(150).computeFee(tx);
+    if (_residual < _model) {
+      const e = new Error(`UNDERFUNDED_BUILD: inputs ${_totalIn} sats cannot cover outputs ${_outSum} + fee ${_model} \u2014 refusing to sign an under-paying transaction`);
+      e.code = "UNDERFUNDED_BUILD";
+      throw e;
+    }
+  }
   await tx.sign();
   return {
     txHex: tx.toHex(),
@@ -1747,9 +1926,10 @@ async function buildOpReturnTxWithChange(wif, utxos, dataStr) {
   const p2pkh = new P2PKH();
   const lockingScript = p2pkh.lock(address);
   let totalInput = 0;
+  const sourceByTxid = await fetchSourceTransactions(utxos);
   for (const utxo of utxos) {
-    const rawHex = await getRawTx(utxo.tx_hash);
-    const sourceTransaction = Transaction.fromHex(rawHex);
+    const sourceTransaction = sourceByTxid.get(String(utxo.tx_hash).trim());
+    if (!sourceTransaction) throw new Error(`source transaction unavailable for input ${utxo.tx_hash}:${utxo.tx_pos}`);
     tx.addInput({
       sourceTransaction,
       sourceOutputIndex: utxo.tx_pos,
@@ -1780,6 +1960,29 @@ async function buildOpReturnTxWithChange(wif, utxos, dataStr) {
     change: true
   });
   await tx.fee(new SatoshisPerKilobyte(150));
+  {
+    const _ci = tx.outputs.findIndex((o) => o.change);
+    if (_ci >= 0) {
+      const _cv = tx.outputs[_ci].satoshis || 0;
+      if (_cv > 0 && _cv <= 546) tx.outputs.splice(_ci, 1);
+    }
+  }
+  {
+    if (tx.inputs.length === 0) {
+      const e = new Error("ZERO_INPUT_BUILD: refusing to sign a transaction with no inputs \u2014 the caller handed an empty coin set");
+      e.code = "ZERO_INPUT_BUILD";
+      throw e;
+    }
+    const _totalIn = (utxos || []).reduce((s, u) => s + (u?.value || 0), 0);
+    const _outSum = tx.outputs.reduce((s, o) => s + (o.satoshis || 0), 0);
+    const _residual = _totalIn - _outSum;
+    const _model = await new SatoshisPerKilobyte(150).computeFee(tx);
+    if (_residual < _model) {
+      const e = new Error(`UNDERFUNDED_BUILD: inputs ${_totalIn} sats cannot cover outputs ${_outSum} + fee ${_model} \u2014 refusing to sign an under-paying transaction`);
+      e.code = "UNDERFUNDED_BUILD";
+      throw e;
+    }
+  }
   await tx.sign();
   const txId = tx.id("hex");
   const txHex = tx.toHex();
@@ -1805,9 +2008,10 @@ async function buildPaymentTx(wif, utxos, payToAddress, satoshis) {
   const p2pkh = new P2PKH();
   const lockingScript = p2pkh.lock(address);
   let totalInput = 0;
+  const sourceByTxid = await fetchSourceTransactions(utxos);
   for (const utxo of utxos) {
-    const rawHex = await getRawTx(utxo.tx_hash);
-    const sourceTransaction = Transaction.fromHex(rawHex);
+    const sourceTransaction = sourceByTxid.get(String(utxo.tx_hash).trim());
+    if (!sourceTransaction) throw new Error(`source transaction unavailable for input ${utxo.tx_hash}:${utxo.tx_pos}`);
     tx.addInput({
       sourceTransaction,
       sourceOutputIndex: utxo.tx_pos,
@@ -1830,6 +2034,29 @@ async function buildPaymentTx(wif, utxos, payToAddress, satoshis) {
     change: true
   });
   await tx.fee(new SatoshisPerKilobyte(150));
+  {
+    const _ci = tx.outputs.findIndex((o) => o.change);
+    if (_ci >= 0) {
+      const _cv = tx.outputs[_ci].satoshis || 0;
+      if (_cv > 0 && _cv <= 546) tx.outputs.splice(_ci, 1);
+    }
+  }
+  {
+    if (tx.inputs.length === 0) {
+      const e = new Error("ZERO_INPUT_BUILD: refusing to sign a transaction with no inputs \u2014 the caller handed an empty coin set");
+      e.code = "ZERO_INPUT_BUILD";
+      throw e;
+    }
+    const _totalIn = (utxos || []).reduce((s, u) => s + (u?.value || 0), 0);
+    const _outSum = tx.outputs.reduce((s, o) => s + (o.satoshis || 0), 0);
+    const _residual = _totalIn - _outSum;
+    const _model = await new SatoshisPerKilobyte(150).computeFee(tx);
+    if (_residual < _model) {
+      const e = new Error(`UNDERFUNDED_BUILD: inputs ${_totalIn} sats cannot cover outputs ${_outSum} + fee ${_model} \u2014 refusing to sign an under-paying transaction`);
+      e.code = "UNDERFUNDED_BUILD";
+      throw e;
+    }
+  }
   await tx.sign();
   const txId = tx.id("hex");
   const txHex = tx.toHex();
@@ -1857,7 +2084,7 @@ function extractEncryptedFromTx(tx) {
   const match = str.match(/([A-Za-z0-9+/=]{12,}):([A-Za-z0-9+/=]{20,}):([A-Za-z0-9+/=]{20,})/);
   return match ? match[0] : null;
 }
-var SEED_BRIDGES, OLD_BRIDGE_IPS, bridgeHealth, HEALTH_CHECK_INTERVAL, MAX_FAILURES, migrationDone, ARC_NETWORK_STATUSES, StoredError, _stickyBridge, STICKY_WINDOW_MS;
+var SEED_BRIDGES, OLD_BRIDGE_IPS, bridgeHealth, HEALTH_CHECK_INTERVAL, MAX_FAILURES, migrationDone, SOURCE_FETCH_CONCURRENCY, ARC_NETWORK_STATUSES, StoredError, _stickyBridge, STICKY_WINDOW_MS;
 var init_spv = __esm({
   "mcp-server/lib/spv.js"() {
     init_config_customer();
@@ -1884,6 +2111,7 @@ var init_spv = __esm({
     HEALTH_CHECK_INTERVAL = 6e4;
     MAX_FAILURES = 3;
     migrationDone = false;
+    SOURCE_FETCH_CONCURRENCY = 8;
     ARC_NETWORK_STATUSES = /* @__PURE__ */ new Set([
       // Tightened 2026-06-17 to match the relay-federation bridge: a node must have
       // TAKEN the tx — dropped ANNOUNCED_TO_NETWORK/REQUESTED_BY_NETWORK (ARC merely
@@ -2392,17 +2620,19 @@ async function commitSession(session, wif) {
   const apiKey = config2?.api_key || null;
   await checkTier(apiKey);
   const RECONCILE_HOOKS = { checkConfirmation: (id) => checkConfirmation(id), broadcast: (hex) => broadcastTx(hex), readEntry };
+  const payload = {
+    protocol: "indelible.claude-code",
+    encrypted: session.encrypted,
+    wrap_owner: session.wrap_owner || null
+  };
+  const payloadStr = JSON.stringify(payload);
+  const SPEND = { dataBytes: Buffer.byteLength(payloadStr) };
   let claim2 = null;
   try {
-    claim2 = await claimSpendableUtxos(session.address, getUtxos, { reconcile: RECONCILE_HOOKS });
+    claim2 = await claimSpendableUtxos(session.address, getUtxos, { reconcile: RECONCILE_HOOKS, spend: SPEND });
     const utxos = claim2.utxos;
     if (utxos && utxos.length > 0) {
-      const payload = {
-        protocol: "indelible.claude-code",
-        encrypted: session.encrypted,
-        wrap_owner: session.wrap_owner || null
-      };
-      let { txHex, txId, changeUtxos, fee, txSize } = await buildOpReturnTxWithChange(wif, utxos, JSON.stringify(payload));
+      let { txHex, txId, changeUtxos, fee, txSize } = await buildOpReturnTxWithChange(wif, utxos, payloadStr);
       await linkOrRefuse(claim2.token, { txId, txHex, changeUtxos });
       let writeReceipt;
       try {
@@ -2410,10 +2640,10 @@ async function commitSession(session, wif) {
       } catch (bErr) {
         const settled = await settleFromWriteResult(claim2.token, { error: bErr, changeUtxos });
         if (settled.reason !== "conflict") throw bErr;
-        claim2 = await claimSpendableUtxos(session.address, getUtxos, { reconcile: RECONCILE_HOOKS });
+        claim2 = await claimSpendableUtxos(session.address, getUtxos, { reconcile: RECONCILE_HOOKS, spend: SPEND });
         const fresh = claim2.utxos;
         if (!fresh || fresh.length === 0) throw bErr;
-        ({ txHex, txId, changeUtxos, fee, txSize } = await buildOpReturnTxWithChange(wif, fresh, JSON.stringify(payload)));
+        ({ txHex, txId, changeUtxos, fee, txSize } = await buildOpReturnTxWithChange(wif, fresh, payloadStr));
         await linkOrRefuse(claim2.token, { txId, txHex, changeUtxos });
         try {
           writeReceipt = await broadcastTx(txHex);
@@ -2465,7 +2695,7 @@ async function commitSession(session, wif) {
   }
   if (claim2?.token) await settleReservation(claim2.token, "abort").catch(() => {
   });
-  throw new Error("No UTXOs available. Fund your wallet or check gateway connection.");
+  throw new Error(claimRefusalMessage(claim2));
 }
 function buildReceipt(writeResult, { txId, fee, txSize, indexed } = {}) {
   const w = writeResult || {};
@@ -3379,7 +3609,7 @@ async function saveStyle(rulesText, styleName, description) {
   };
   let claim2 = null;
   try {
-    claim2 = await claimSpendableUtxos(config2.address, getUtxos, { reconcile: reconcileHooks(spv_exports) });
+    claim2 = await claimSpendableUtxos(config2.address, getUtxos, { reconcile: reconcileHooks(spv_exports), spend: { dataBytes: Buffer.byteLength(JSON.stringify(payload)) } });
   } catch (e) {
     if (e.code === "WALLET_BUSY_RESERVED") return { success: false, error: e.message, retryable: true };
     throw e;
@@ -3388,7 +3618,7 @@ async function saveStyle(rulesText, styleName, description) {
     const utxos = claim2.utxos;
     if (!utxos || utxos.length === 0) {
       await settleReservation(claim2.token, "abort");
-      return { success: false, error: "No UTXOs available. Fund your wallet first." };
+      return { success: false, error: claimRefusalMessage(claim2) };
     }
     const { txHex, txId, changeUtxos, fee, txSize } = await buildOpReturnTxWithChange(wif, utxos, JSON.stringify(payload));
     await linkOrRefuse(claim2.token, { txId, txHex, changeUtxos });
@@ -8378,9 +8608,16 @@ async function fulfilNotaryOrder({ scope = "", agentName, order, spv = null } =
         };
       }
       const claimRes = await claimSpendableUtxos(agentAddress, async () => paymentUtxos, {
-        reconcile: reconcileHooks({ checkConfirmation: spv?.checkConfirmation || checkConfirmation, broadcast: spv?.broadcastTx || broadcastTx })
+        reconcile: reconcileHooks({ checkConfirmation: spv?.checkConfirmation || checkConfirmation, broadcast: spv?.broadcastTx || broadcastTx }),
+        // AUDIT F5 (wf_dda0064a): the claim used the DEFAULT shape (dataBytes 0), so a payment
+        // could pass the ~576-sat default target yet underfund the real anchor build. Size from
+        // the anchor's actual bytes; the F6 builder invariant backstops whatever remains.
+        spend: { dataBytes: Buffer.byteLength(data) }
       });
       if (!claimRes || !claimRes.token || !claimRes.utxos?.length) {
+        if (claimRes?.refused) {
+          return { state: "error", reason: "PAYMENT_OUTPOINT_UNFUNDABLE", detail: claimRefusalMessage(claimRes).slice(0, 300) };
+        }
         return { state: "error", reason: "PAYMENT_OUTPOINT_RESERVED", detail: "another worker holds the payment coin right now \u2014 retry shortly" };
       }
       claimTok = claimRes.token;
@@ -8403,7 +8640,7 @@ async function fulfilNotaryOrder({ scope = "", agentName, order, spv = null } =
     } catch (e) {
       if (claimTok) {
         try {
-          await settleReservation(claimTok, "failed", {});
+          await settleReservation(claimTok, "abort", {});
         } catch {
         }
       }
@@ -10968,6 +11205,7 @@ init_save_log();
 init_spv();
 init_build_cache();
 init_utxo_cache();
+init_tx_size();
 init_utxo_reservation();
 import { gzipSync } from "zlib";
 import { readFile as readFile4, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
@@ -11086,10 +11324,33 @@ async function saveFile(filePath, options = {}) {
   const encrypted = encrypt("gz:" + compressed.toString("base64"), wif);
   const heldClaims = [];
   let utxos = options.utxos || null;
+  let claim2 = null;
   if (!utxos) {
-    let claim2;
     try {
-      claim2 = await claimSpendableUtxos(config2.address, getUtxos, { reconcile: reconcileHooks(spv_exports, readEntry) });
+      claim2 = await claimSpendableUtxos(config2.address, getUtxos, {
+        reconcile: reconcileHooks(spv_exports, readEntry),
+        // ⚠️ AUDIT F2/F3 (wf_dda0064a): sizing the claim as ONE tx of the WHOLE payload was
+        // wrong in both directions at once — TX_TOO_LARGE refused every >12.58MB payload the
+        // chunker exists to SPLIT (a hard regression: each chunk tx is individually legal), and
+        // when it did pass, the chain was UNDER-funded by construction (per-chunk envelopes +
+        // per-tx overhead + the master tx were never budgeted; proven end-to-end: 1.84M sats
+        // spent, no master tx, file unrestorable). Now the claim is sized for the CHAIN: the
+        // first chunk as the tx shape, and every remaining fee — later chunks + the master —
+        // as extraOutSats, which is exactly what the first tx's change must retain. TX_TOO_LARGE
+        // then gates the CHUNK size, never the whole payload.
+        spend: (() => {
+          const E = Buffer.byteLength(String(encrypted || ""));
+          if (E <= MAX_CHUNK_SIZE) return { dataBytes: E };
+          const CHUNK_ENV = 400;
+          const n = Math.ceil(E / MAX_CHUNK_SIZE);
+          let restFees = 0;
+          for (let i = 1; i < n; i++) {
+            restFees += feeForInputs(1, { dataBytes: Math.min(MAX_CHUNK_SIZE, E - i * MAX_CHUNK_SIZE) + CHUNK_ENV });
+          }
+          restFees += feeForInputs(1, { dataBytes: 2e3 + n * 70 });
+          return { dataBytes: Math.min(E, MAX_CHUNK_SIZE) + CHUNK_ENV, extraOutSats: restFees };
+        })()
+      });
     } catch (e) {
       if (e.code === "WALLET_BUSY_RESERVED") return { success: false, error: e.message, retryable: true };
       throw e;
@@ -11099,7 +11360,7 @@ async function saveFile(filePath, options = {}) {
   }
   if (!utxos || utxos.length === 0) {
     if (heldClaims[0]) await settleReservation(heldClaims[0].token, "abort");
-    return { success: false, error: "No UTXOs available. Fund your wallet first." };
+    return { success: false, error: claimRefusalMessage(claim2) };
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   try {
@@ -11171,7 +11432,16 @@ async function saveFile(filePath, options = {}) {
         if (!utxos || utxos.length === 0) {
           await new Promise((r) => setTimeout(r, 500));
           if (heldClaims.length) {
-            const extra = await claimSpendableUtxos(config2.address, getUtxos);
+            const extra = await claimSpendableUtxos(config2.address, getUtxos, {
+              // g-419: sized from the CURRENT chunk's exact payload — the right magnitude for
+              // the next chunk it funds.
+              spend: { dataBytes: Buffer.byteLength(chunkPayload) }
+            });
+            if (extra.refused || !extra.utxos || extra.utxos.length === 0) {
+              const e = new Error(`INSUFFICIENT_FUNDS_MID_CHAIN: the wallet ran dry after ${i + 1} of ${chunks.length} chunks \u2014 ${claimRefusalMessage(extra)}`);
+              e.code = "INSUFFICIENT_FUNDS_MID_CHAIN";
+              throw e;
+            }
             heldClaims.push(extra);
             utxos = extra.utxos;
           } else {
@@ -12806,15 +13076,18 @@ async function _saveSessionInner(transcriptPath, summary, mode, hostBinding = nu
     let memoryTxId = config2.memory_file_txid || null;
     let historyTxId = config2.session_history_txid || null;
     let changeUtxos = result.changeUtxos || [];
-    if (config2.memory_auto_save !== false && changeUtxos.length > 0) {
+    if (config2.memory_auto_save !== false) {
       try {
         const memoryDir = getMemoryDir(actualPath);
         const memoryPath = join15(memoryDir, "MEMORY.md");
         const historyPath = join15(memoryDir, "session-history.md");
+        if (changeUtxos.length === 0) {
+          process.stderr.write("[save_session] change folded to fee (g-419 dust backstop) \u2014 memory/history saves will claim their own coin\n");
+        }
         if (existsSync10(memoryPath)) {
           const memResult = await saveFile(memoryPath, {
             relativePath: "memory/MEMORY.md",
-            utxos: changeUtxos,
+            ...changeUtxos.length > 0 ? { utxos: changeUtxos } : {},
             skipVaultIndex: true
           });
           if (memResult.success) {
@@ -12822,10 +13095,10 @@ async function _saveSessionInner(transcriptPath, summary, mode, hostBinding = nu
             changeUtxos = memResult.changeUtxos || [];
           }
         }
-        if (existsSync10(historyPath) && changeUtxos.length > 0) {
+        if (existsSync10(historyPath)) {
           const histResult = await saveFile(historyPath, {
             relativePath: "memory/session-history.md",
-            utxos: changeUtxos,
+            ...changeUtxos.length > 0 ? { utxos: changeUtxos } : {},
             skipVaultIndex: true
           });
           if (histResult.success) {
@@ -13199,7 +13472,7 @@ async function saveProject(dirPath, options = {}) {
     };
     let claim2;
     try {
-      claim2 = await claimSpendableUtxos(config2.address, getUtxos, { reconcile: reconcileHooks(spv_exports, readEntry) });
+      claim2 = await claimSpendableUtxos(config2.address, getUtxos, { reconcile: reconcileHooks(spv_exports, readEntry), spend: { dataBytes: Buffer.byteLength(JSON.stringify(payload)) } });
     } catch (e) {
       if (e.code === "WALLET_BUSY_RESERVED") return { success: false, error: e.message, retryable: true };
       throw e;
@@ -13208,7 +13481,7 @@ async function saveProject(dirPath, options = {}) {
     const utxos = claim2.utxos;
     if (!utxos || utxos.length === 0) {
       await settleReservation(claim2.token, "abort");
-      return { success: false, error: "No UTXOs available. Fund your wallet first." };
+      return { success: false, error: claimRefusalMessage(claim2) };
     }
     const bundleKey = sha256(bundleFiles.map((f) => f.content_hash).join(","));
     const bc = await idempotentBuildAndBroadcast({
@@ -13748,7 +14021,7 @@ async function updateVaultIndex() {
   };
   let claim2 = null;
   try {
-    claim2 = await claimSpendableUtxos(config2.address, getUtxos, { reconcile: reconcileHooks(spv_exports) });
+    claim2 = await claimSpendableUtxos(config2.address, getUtxos, { reconcile: reconcileHooks(spv_exports), spend: { dataBytes: Buffer.byteLength(JSON.stringify(payload)) } });
   } catch (e) {
     if (e.code === "WALLET_BUSY_RESERVED") return { success: false, error: e.message, retryable: true };
     throw e;
@@ -13757,7 +14030,7 @@ async function updateVaultIndex() {
     let utxos = claim2.utxos;
     if (!utxos || utxos.length === 0) {
       await settleReservation(claim2.token, "abort");
-      return { success: false, error: "No UTXOs for vault index tx" };
+      return { success: false, error: claimRefusalMessage(claim2) };
     }
     const { txHex, txId, changeUtxos, fee, txSize } = await buildOpReturnTxWithChange(
       wif,
@@ -14275,7 +14548,13 @@ async function x402Fetch({ url, method = "GET", headers = {}, body, maxSats }) {
   const address = privateKey.toPublicKey().toAddress();
   let claim2;
   try {
-    claim2 = await claimSpendableUtxos(address, getUtxos, { reconcile: reconcileHooks(spv_exports) });
+    claim2 = await claimSpendableUtxos(address, getUtxos, {
+      reconcile: reconcileHooks(spv_exports),
+      // ⚠️ SELECT AGAINST WHAT THIS CAN ACTUALLY PAY (codex-money 41657e3b). This route pays up
+      // to `cap` sats to a third party via buildPaymentTx — a P2PKH payment output plus change,
+      // no OP_RETURN. The exact shape, not a floor.
+      spend: { dataBytes: 0, p2pkhOuts: 1, extraOutSats: cap }
+    });
   } catch (err9) {
     if (err9.code === "WALLET_BUSY_RESERVED") return { success: false, error: err9.message, retryable: true };
     return { success: false, error: `Failed to get UTXOs: ${err9.message}` };
@@ -14283,7 +14562,7 @@ async function x402Fetch({ url, method = "GET", headers = {}, body, maxSats }) {
   const utxos = claim2.utxos;
   if (!utxos || utxos.length === 0) {
     await settleReservation(claim2.token, "abort");
-    return { success: false, error: "No UTXOs available. Wallet may be empty." };
+    return { success: false, error: claimRefusalMessage(claim2) };
   }
   let txResult;
   try {
@@ -14416,9 +14695,23 @@ async function saveGoalsToChain() {
   const completed = goalsData.completed || [];
   process.stderr.write(`[save_goals_to_chain] Bootstrapping ${goals.length} active + ${completed.length} completed goals to chain for ${address}...
 `);
+  const encrypted = encryptGoals(goalsData, wif);
+  const payload = {
+    protocol: "indelible.goals-snapshot",
+    version: 1,
+    owner: address,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    count: goals.length,
+    completed_count: completed.length,
+    encrypted
+  };
+  const snapshotAt = payload.timestamp;
   let claim2;
   try {
-    claim2 = await claimSpendableUtxos(address, getUtxos, { reconcile: reconcileHooks(spv_exports) });
+    claim2 = await claimSpendableUtxos(address, getUtxos, {
+      reconcile: reconcileHooks(spv_exports),
+      spend: { dataBytes: Buffer.byteLength(JSON.stringify(payload)) }
+    });
   } catch (e) {
     if (e.code === "WALLET_BUSY_RESERVED") {
       return { content: [{ type: "text", text: `${e.message}` }] };
@@ -14429,22 +14722,11 @@ async function saveGoalsToChain() {
   if (!utxos || utxos.length === 0) {
     await settleReservation(claim2.token, "abort");
     return {
-      content: [{ type: "text", text: "No UTXOs available. Fund your wallet." }]
+      content: [{ type: "text", text: claimRefusalMessage(claim2) }]
     };
   }
-  let txId, fee, txSize, writeReceipt, snapshotAt;
+  let txId, fee, txSize, writeReceipt;
   try {
-    const encrypted = encryptGoals(goalsData, wif);
-    const payload = {
-      protocol: "indelible.goals-snapshot",
-      version: 1,
-      owner: address,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      count: goals.length,
-      completed_count: completed.length,
-      encrypted
-    };
-    snapshotAt = payload.timestamp;
     let txHex, changeUtxos;
     ({ txHex, txId, changeUtxos, fee, txSize } = await buildOpReturnTxWithChange(
       wif,
@@ -17039,7 +17321,7 @@ Answer THAT message and nothing else \u2014 the wire also carries unrelated conv
 }
 function printHelp() {
   console.log(`
-Indelible MCP \u2014 Blockchain memory for Claude Code (v5.7.8)
+Indelible MCP \u2014 Blockchain memory for Claude Code (v5.8.0)
 
 Setup:
   indelible-mcp                              Set up interactively (recommended \u2014 your key is never written to shell history)
@@ -17368,7 +17650,7 @@ function readStdin() {
 }
 var SERVER_INFO = {
   name: "indelible",
-  version: "5.7.8",
+  version: "5.8.0",
   description: "Blockchain-backed memory and code storage for Claude Code"
 };
 var TOOLS = [