indelible-mcp 4.8.0 → 4.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indelible-mcp",
-  "version": "4.8.0",
+  "version": "4.8.2",
   "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

@@ -314,15 +314,17 @@ async function getRawTx(txid) {
 `);
   return text;
 }
+function bcastTimeoutMs(rawTxHex) {
+  const txMB = (rawTxHex?.length || 0) / 2 / 1048576;
+  return Math.min(18e4, Math.round(15e3 + txMB * 12e3));
+}
 async function broadcastViaBridges(rawTxHex) {
   const bridges = await getBridges();
-  process.stderr.write(`[MCP] Bridge fallback \u2014 broadcasting to ${bridges.length} bridges (parallel)...
-`);
   const t0 = Date.now();
-  const attempts = bridges.map(async (bridge) => {
+  const tryBridge = async (bridge) => {
     const bt0 = Date.now();
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const timeout = setTimeout(() => controller.abort(), bcastTimeoutMs(rawTxHex));
     try {
       const res = await fetch(`${bridge.url}/api/broadcast`, {
         method: "POST",
@@ -349,16 +351,34 @@ async function broadcastViaBridges(rawTxHex) {
 `);
       throw err;
     }
-  });
-  try {
-    const result = await Promise.any(attempts);
-    process.stderr.write(`[MCP] Bridge broadcast accepted in ${Date.now() - t0}ms
+  };
+  let ordered = bridges;
+  if (bridges.length > 1) {
+    try {
+      const winner = await Promise.any(bridges.map(async (b) => {
+        const r = await fetch(`${b.url}/health`, { signal: AbortSignal.timeout(5e3) });
+        if (!r.ok) throw new Error("unhealthy");
+        return b;
+      }));
+      ordered = [winner, ...bridges.filter((b) => b.url !== winner.url)];
+      process.stderr.write(`[MCP] Bridge broadcast \u2014 ${winner.name} answered first; sending the tx to it (single bridge; mesh gossips the rest)
+`);
+    } catch {
+    }
+  }
+  let lastErr = null;
+  for (const bridge of ordered) {
+    try {
+      const r = await tryBridge(bridge);
+      setStickyBridge(bridge);
+      process.stderr.write(`[MCP] Bridge broadcast accepted via ${bridge.name} in ${Date.now() - t0}ms
 `);
-    return result;
-  } catch (agg) {
-    const msgs = agg.errors ? agg.errors.map((e) => e.message).join(" | ") : agg.message;
-    throw new Error(`Bridge broadcast failed \u2014 all ${bridges.length} bridges down: ${msgs}`);
+      return r;
+    } catch (e) {
+      lastErr = e;
+    }
   }
+  throw new Error(`Bridge broadcast failed \u2014 all ${bridges.length} bridges down: ${lastErr && lastErr.message}`);
 }
 function setStickyBridge(bridge) {
   _stickyBridge = { url: bridge.url, name: bridge.name, until: Date.now() + STICKY_WINDOW_MS };
@@ -438,8 +458,8 @@ async function buildOpReturnTxWithChange(wif, utxos, dataStr) {
     });
     totalInput += utxo.value;
   }
-  const prefixBytes = Array.from(Buffer.from("BSVWRAPPER_MERKLE_E", "utf8"));
-  const dataBytes = Array.from(Buffer.from(dataStr, "utf8"));
+  const prefixBytes = Buffer.from("BSVWRAPPER_MERKLE_E", "utf8");
+  const dataBytes = Buffer.from(dataStr, "utf8");
   const opReturnScript = new LockingScript([
     { op: OP.OP_FALSE },
     { op: OP.OP_RETURN },
@@ -454,7 +474,7 @@ async function buildOpReturnTxWithChange(wif, utxos, dataStr) {
     lockingScript: p2pkh.lock(address),
     change: true
   });
-  await tx.fee(new SatoshisPerKilobyte(1e3));
+  await tx.fee(new SatoshisPerKilobyte(150));
   await tx.sign();
   const txId = tx.id("hex");
   const txHex = tx.toHex();
@@ -504,7 +524,7 @@ async function buildPaymentTx(wif, utxos, payToAddress, satoshis) {
     lockingScript: p2pkh.lock(address),
     change: true
   });
-  await tx.fee(new SatoshisPerKilobyte(1e3));
+  await tx.fee(new SatoshisPerKilobyte(150));
   await tx.sign();
   const txId = tx.id("hex");
   const txHex = tx.toHex();
@@ -1561,10 +1581,23 @@ function verifyShare(envelope, ownerPubkey) {
   }
 }
 function detectSaveFormat(payload) {
+  const hasV3Fields = payload != null && (payload.wrap_self !== void 0 || payload.wrap_version !== void 0);
+  if (hasV3Fields) {
+    if (payload.wrap_version === 3 && typeof payload.wrap_self === "string" && payload.wrap_self.length > 0) return "v3-wallet";
+    return "v3-malformed";
+  }
   if (payload && payload.version === 2) return "v2-brc100";
   if (payload && typeof payload.wrap_owner === "string" && payload.wrap_owner.length > 0) return "v2-wrapped";
   return "legacy";
 }
+function detectVaultFormat(payload) {
+  if (!payload) return "legacy";
+  return detectSaveFormat({
+    wrap_owner: payload.wrap_owner,
+    wrap_self: payload.wrap_self,
+    wrap_version: payload.wrap_version
+  });
+}
 function generateContentKey() {
   return randomBytes3(32);
 }
@@ -1579,6 +1612,49 @@ function unwrapForOwner(wrapStr, ownerPrivkey) {
   const aad = buildAAD(ownerAddr, ownerAddr, SELF_WRAP_TXID);
   return eciesUnwrap(wrapStr, ownerPrivkey, aad);
 }
+function isValidHex(s) {
+  return typeof s === "string" && s.length > 0 && s.length % 2 === 0 && /^[0-9a-f]+$/i.test(s);
+}
+async function unwrapForSelfV3(wrapHex, wallet, keyID) {
+  if (!wallet) return { ok: false, reason: "wallet_unavailable" };
+  if (!isValidHex(wrapHex)) return { ok: false, reason: "corrupt" };
+  if (typeof keyID !== "string" || keyID.length === 0) return { ok: false, reason: "corrupt" };
+  try {
+    const { plaintext } = await wallet.decrypt({
+      protocolID: ENCRYPT_PROTOCOL_ID_V2,
+      keyID,
+      counterparty: "self",
+      ciphertext: Array.from(Buffer.from(wrapHex, "hex"))
+    });
+    const contentKey = Buffer.from(plaintext);
+    if (contentKey.length !== 32) return { ok: false, reason: "corrupt" };
+    return { ok: true, contentKey };
+  } catch {
+    return { ok: false, reason: "corrupt" };
+  }
+}
+async function unwrapRecoveryV3(wrapHex, wallet, keyID, ownerPubkeyHex) {
+  if (!wallet) return { ok: false, reason: "wallet_unavailable" };
+  if (!isValidHex(wrapHex)) return { ok: false, reason: "corrupt" };
+  if (typeof keyID !== "string" || keyID.length === 0) return { ok: false, reason: "corrupt" };
+  if (typeof ownerPubkeyHex !== "string" || !/^[0-9a-f]{66}$/i.test(ownerPubkeyHex)) {
+    return { ok: false, reason: "corrupt" };
+  }
+  try {
+    const { plaintext } = await wallet.decrypt({
+      protocolID: ENCRYPT_PROTOCOL_ID_V2,
+      keyID,
+      counterparty: ownerPubkeyHex,
+      ciphertext: Array.from(Buffer.from(wrapHex, "hex"))
+    });
+    const contentKey = Buffer.from(plaintext);
+    if (contentKey.length !== 32) return { ok: false, reason: "corrupt" };
+    return { ok: true, contentKey };
+  } catch {
+    return { ok: false, reason: "corrupt" };
+  }
+}
+var ENCRYPT_PROTOCOL_ID_V2 = [2, "indelible share"];
 
 // mcp-server/tools/save_session.js
 init_api_client();
@@ -1668,6 +1744,36 @@ async function pollInfraEmotions() {
 }
 
 // mcp-server/lib/redact.js
+import { createHash as createHash3 } from "node:crypto";
+var B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Decode(str) {
+  const bytes = [0];
+  for (let i = 0; i < str.length; i++) {
+    const c = B58_ALPHABET.indexOf(str[i]);
+    if (c < 0) return null;
+    let carry = c;
+    for (let j = 0; j < bytes.length; j++) {
+      carry += bytes[j] * 58;
+      bytes[j] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  for (let i = 0; i < str.length && str[i] === "1"; i++) bytes.push(0);
+  return Buffer.from(bytes.reverse());
+}
+function isValidWif(candidate) {
+  const decoded = base58Decode(candidate);
+  if (!decoded || decoded.length < 5) return false;
+  const payload = decoded.subarray(0, decoded.length - 4);
+  const checksum = decoded.subarray(decoded.length - 4);
+  const h = createHash3("sha256").update(createHash3("sha256").update(payload).digest()).digest();
+  return h.subarray(0, 4).equals(checksum);
+}
+var MAX_VALIDATED_CANDIDATES = 2e4;
 var CREDENTIAL_PATTERNS = [
   { name: "anthropic_key", pattern: /\bsk-ant-api03-[A-Za-z0-9_\-]{80,}/g },
   // Catches legacy `sk-XXXX...` (51 chars) and modern `sk-proj-XXXX...` (longer,
@@ -1675,8 +1781,8 @@ var CREDENTIAL_PATTERNS = [
   { name: "openai_key", pattern: /\bsk-(?!ant-)(?:proj-)?[A-Za-z0-9_\-]{40,}/g },
   { name: "stripe_key", pattern: /\bsk_(?:live|test)_[A-Za-z0-9]{20,}\b/g },
   { name: "aws_access_key", pattern: /\bAKIA[A-Z0-9]{16}\b/g },
-  { name: "bsv_wif", pattern: /\b[5KL][1-9A-HJ-NP-Za-km-z]{50,51}\b/g },
-  // true base58 alphabet (no 0/O/I/l) — fewer false positives
+  { name: "bsv_wif", pattern: /\b[5KL][1-9A-HJ-NP-Za-km-z]{50,51}\b/g, validate: isValidWif },
+  // base58 shape + Base58Check checksum (no base64 false positives)
   { name: "telegram_token", pattern: /\b\d{8,12}:[A-Za-z0-9_-]{30,40}\b/g },
   { name: "github_pat", pattern: /\bghp_[A-Za-z0-9]{36}\b/g },
   { name: "github_pat_v2", pattern: /\bgithub_pat_[A-Za-z0-9_]{82}\b/g },
@@ -1685,10 +1791,17 @@ var CREDENTIAL_PATTERNS = [
 function scanContentForCredentials(text) {
   if (typeof text !== "string" || text.length === 0) return [];
   const found = [];
-  for (const { name, pattern } of CREDENTIAL_PATTERNS) {
+  for (const { name, pattern, validate } of CREDENTIAL_PATTERNS) {
     pattern.lastIndex = 0;
     let m;
+    let validated = 0;
     while ((m = pattern.exec(text)) !== null) {
+      if (validate) {
+        if (validated < MAX_VALIDATED_CANDIDATES) {
+          validated++;
+          if (!validate(m[0])) continue;
+        }
+      }
       found.push({
         pattern_name: name,
         preview: m[0].slice(0, 12) + "..."
@@ -2060,7 +2173,7 @@ import { fileURLToPath as _fileURLToPath } from "url";
 var PROJECT_ROOT_FOR_SAVE_FILE_CLONE_CHECK = _pathResolve(_dirname(_fileURLToPath(import.meta.url)), "..");
 var CODE_EXTS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"]);
 var CLONE_CHECK_TIMEOUT_MS = 5e3;
-var MAX_CHUNK_SIZE = 5e4;
+var MAX_CHUNK_SIZE = 1e7;
 var TX_CACHE_DIR = join4(homedir4(), ".indelible", "tx-cache");
 async function cacheTx(txId, payload) {
   try {
@@ -2080,9 +2193,13 @@ async function saveFile(filePath, options = {}) {
   if (!existsSync4(filePath)) {
     return { success: false, error: `File not found: ${filePath}` };
   }
-  const content = await readFile(filePath, "utf-8");
-  const contentHash = sha256(content);
-  const fileSize = Buffer.byteLength(content, "utf-8");
+  const buf = await readFile(filePath);
+  const asText = buf.toString("utf-8");
+  const isText = Buffer.from(asText, "utf-8").equals(buf);
+  const fileEnc = isText ? "utf8" : "b64";
+  const content = isText ? asText : "";
+  const contentHash = sha256(buf);
+  const fileSize = buf.length;
   const filename = basename(filePath);
   const relativePath = options.relativePath || filePath;
   const fileVerdict = reviewFile({ filename, relativePath, contentHash, fileSize, content });
@@ -2157,7 +2274,7 @@ async function saveFile(filePath, options = {}) {
 `);
     }
   }
-  const compressed = gzipSync(Buffer.from(content));
+  const compressed = gzipSync(buf);
   const encrypted = encrypt("gz:" + compressed.toString("base64"), wif);
   let utxos = options.utxos || await getSpendableUtxos(config.address, getUtxos);
   if (!utxos || utxos.length === 0) {
@@ -2180,6 +2297,7 @@ async function saveFile(filePath, options = {}) {
         path_enc: pathEnc,
         size: fileSize,
         content_hash: `sha256:${contentHash}`,
+        enc: fileEnc,
         encrypted,
         owner: config.address,
         timestamp
@@ -2236,6 +2354,7 @@ async function saveFile(filePath, options = {}) {
         path_enc: pathEnc,
         size: fileSize,
         content_hash: `sha256:${contentHash}`,
+        enc: fileEnc,
         _chunks: chunks.length,
         owner: config.address,
         timestamp
@@ -2868,6 +2987,13 @@ async function _saveSessionInner(transcriptPath, summary, mode) {
   const config = await loadConfig();
   const wif = await getWif();
   if (!wif) {
+    if (config?.external_identity) {
+      return {
+        success: false,
+        wallet_native: true,
+        error: "Wallet-native account: this box holds no signing key (it lives in your external wallet). Save from the web app, or link a recovery key to enable box saves."
+      };
+    }
     return {
       success: false,
       error: "Wallet not configured or PIN incorrect. Run setup_wallet first."
@@ -3305,7 +3431,7 @@ import { join as join9 } from "path";
 import { homedir as homedir9 } from "os";
 init_api_client();
 init_spv();
-import { PrivateKey as PrivateKey7 } from "@bsv/sdk";
+import { PrivateKey as PrivateKey7, CompletedProtoWallet as CompletedProtoWallet2 } from "@bsv/sdk";
 import { Transaction as Transaction5 } from "@bsv/sdk";
 
 // mcp-server/tools/load_style.js
@@ -4397,22 +4523,80 @@ async function updateInnerState({ observed, source, preoccupations, open_loops,
 
 // mcp-server/tools/load_context.js
 import { readFileSync as readFileSync7 } from "fs";
-function decryptSession(payloadOrEncrypted, wif) {
-  let encrypted, wrap_owner;
+async function decryptSession(payloadOrEncrypted, wif, wallet = null) {
+  let payload;
   if (typeof payloadOrEncrypted === "string") {
-    encrypted = payloadOrEncrypted;
-    wrap_owner = null;
+    payload = { encrypted: payloadOrEncrypted, wrap_owner: null };
   } else {
-    encrypted = payloadOrEncrypted.encrypted;
-    wrap_owner = payloadOrEncrypted.wrap_owner;
+    payload = payloadOrEncrypted;
   }
+  const encrypted = payload.encrypted;
+  const wrap_owner = payload.wrap_owner;
   let text;
-  const fmt = detectSaveFormat({ wrap_owner });
-  if (fmt === "v2-wrapped") {
-    const r = unwrapForOwner(wrap_owner, PrivateKey7.fromWif(wif));
+  const fmt = detectSaveFormat({ wrap_owner, wrap_self: payload.wrap_self, wrap_version: payload.wrap_version });
+  if (fmt === "v3-wallet") {
+    let w = wallet;
+    if (!w && wif) {
+      try {
+        w = new CompletedProtoWallet2(PrivateKey7.fromWif(wif));
+      } catch {
+        w = null;
+      }
+    }
+    let r = null;
+    if (payload.owner_pubkey && w) {
+      let idPub = null;
+      try {
+        idPub = (await w.getPublicKey({ identityKey: true }))?.publicKey || null;
+      } catch {
+      }
+      if (idPub && idPub !== payload.owner_pubkey) {
+        if (payload.wrap_recovery) {
+          const rr = await unwrapRecoveryV3(payload.wrap_recovery, w, payload.key_id, payload.owner_pubkey);
+          if (rr.ok) r = rr;
+        }
+        if (!r) r = { ok: false, reason: "wallet_unavailable" };
+      }
+    }
+    if (!r) {
+      r = await unwrapForSelfV3(payload.wrap_self, w, payload.key_id);
+      if (!r.ok && r.reason === "corrupt" && payload.wrap_recovery && payload.owner_pubkey) {
+        r = await unwrapRecoveryV3(payload.wrap_recovery, w, payload.key_id, payload.owner_pubkey);
+      }
+    }
+    if (!r.ok) {
+      const err = new Error(r.reason === "wallet_unavailable" ? "wallet-native (v3) save: no wallet available to unwrap \u2014 connect the wallet that made this save" : `wallet-native (v3) save: unwrap failed (${r.reason})`);
+      err.code = r.reason === "wallet_unavailable" ? "WALLET_UNAVAILABLE" : "V3_CORRUPT";
+      throw err;
+    }
+    text = decryptWithKey(encrypted, r.contentKey);
+  } else if (fmt === "v3-malformed") {
+    const err = new Error("v3 fields present but malformed \u2014 failing closed");
+    err.code = "V3_CORRUPT";
+    throw err;
+  } else if (fmt === "v2-wrapped") {
+    let ownerPriv = null;
+    if (wif) {
+      try {
+        ownerPriv = PrivateKey7.fromWif(wif);
+      } catch {
+        ownerPriv = null;
+      }
+    }
+    if (!ownerPriv) {
+      const err = new Error("v2-wrapped save: no valid key available to unwrap (wif missing or invalid)");
+      err.code = "WALLET_UNAVAILABLE";
+      throw err;
+    }
+    const r = unwrapForOwner(wrap_owner, ownerPriv);
     if (!r.ok) throw new Error(`wrap_owner unwrap failed: ${r.reason}`);
     text = decryptWithKey(encrypted, r.contentKey);
   } else {
+    if (!wif) {
+      const err = new Error("legacy save: no key available to decrypt (wif missing)");
+      err.code = "WALLET_UNAVAILABLE";
+      throw err;
+    }
     text = decrypt(encrypted, wif);
   }
   if (text.startsWith("gz:")) {
@@ -4462,7 +4646,15 @@ async function fetchEncryptedFromChain(txId) {
           if (end > 0) {
             try {
               const payload = JSON.parse(str.slice(jsonStart, end + 1));
-              if (payload.encrypted) return { encrypted: payload.encrypted, wrap_owner: payload.wrap_owner || null };
+              if (payload.encrypted) {
+                const out = { encrypted: payload.encrypted, wrap_owner: payload.wrap_owner || null };
+                if (payload.wrap_version !== void 0) out.wrap_version = payload.wrap_version;
+                if (payload.wrap_self !== void 0) out.wrap_self = payload.wrap_self;
+                if (payload.key_id !== void 0) out.key_id = payload.key_id;
+                if (payload.wrap_recovery !== void 0) out.wrap_recovery = payload.wrap_recovery;
+                if (payload.owner_pubkey !== void 0) out.owner_pubkey = payload.owner_pubkey;
+                return out;
+              }
             } catch {
             }
           }
@@ -4647,14 +4839,19 @@ async function loadContext(numSessions = 5, pagination = null, opts = {}) {
       process.stderr.write(`[indelible] Scavenging ${recent.length} sessions from JSONL index (streamed tail)
 `);
     }
+    let v3Locked = 0;
     if (recent.length) {
       for (const entry of recent) {
         try {
           if (entry.encrypted) {
-            const data = decryptSession(entry, wif);
+            const data = await decryptSession(entry, wif);
             decrypted.push(data);
           }
-        } catch {
+        } catch (e) {
+          if (e?.code === "WALLET_UNAVAILABLE") {
+            v3Locked++;
+            continue;
+          }
         }
       }
       decrypted.reverse();
@@ -4668,7 +4865,7 @@ async function loadContext(numSessions = 5, pagination = null, opts = {}) {
           try {
             const enc = await fetchEncryptedFromChain(cursorTx);
             if (!enc) break;
-            const data = decryptSession(enc, wif);
+            const data = await decryptSession(enc, wif);
             if (data.type === "diary" || data.type === "duo") {
               cursorTx = data.prev_tx_id;
               continue;
@@ -4676,7 +4873,8 @@ async function loadContext(numSessions = 5, pagination = null, opts = {}) {
             decrypted.push(data);
             if (data.type !== "delta") break;
             cursorTx = data.prev_tx_id;
-          } catch {
+          } catch (e) {
+            if (e?.code === "WALLET_UNAVAILABLE") v3Locked++;
             break;
           }
         }
@@ -4698,16 +4896,20 @@ async function loadContext(numSessions = 5, pagination = null, opts = {}) {
       for (const session of sessions) {
         try {
           if (session.encrypted) {
-            const data = decryptSession(session, wif);
+            const data = await decryptSession(session, wif);
             decrypted.push(data);
           } else if (session.txId) {
             const fromChain = await fetchEncryptedFromChain(session.txId);
             if (fromChain) {
-              const data = decryptSession(fromChain, wif);
+              const data = await decryptSession(fromChain, wif);
               decrypted.push(data);
             }
           }
-        } catch {
+        } catch (e) {
+          if (e?.code === "WALLET_UNAVAILABLE") {
+            v3Locked++;
+            continue;
+          }
         }
       }
       if (decrypted.length === 0) {
@@ -4738,6 +4940,10 @@ async function loadContext(numSessions = 5, pagination = null, opts = {}) {
       "# Restored from Blockchain Memory (Indelible)",
       ""
     ];
+    if (v3Locked > 0) {
+      contextParts.push(`\u26A0\uFE0F PARTIAL RESTORE \u2014 ${v3Locked} wallet-native (v3) save(s) could NOT be decrypted because the wallet that made them is not available here. Connect that wallet (e.g. MetaNet Desktop via the web app) to restore them. Nothing was skipped silently \u2014 this notice is the record.`);
+      contextParts.push("");
+    }
     if (merged.length > 0) {
       contextParts.push(formatCurrentConversation(merged[0], pagination));
       for (let i = 1; i < merged.length; i++) {
@@ -4863,7 +5069,8 @@ async function loadContext(numSessions = 5, pagination = null, opts = {}) {
         total_preserved: driftResult.total_preserved,
         warning_emitted: !!driftWarning
       } : null,
-      message: `Smart restore (${source}): ${merged.length} conversation(s) from ${decrypted.length} chunks. Current conversation shown in full.`
+      wallet_native_locked: v3Locked,
+      message: `Smart restore (${source}): ${merged.length} conversation(s) from ${decrypted.length} chunks. Current conversation shown in full.` + (v3Locked > 0 ? ` \u26A0\uFE0F ${v3Locked} wallet-native save(s) locked \u2014 wallet not available (PARTIAL restore).` : "")
     };
   } catch (error) {
     return {
@@ -5045,12 +5252,41 @@ ${formatSaveReceipt(receipt)}`
 // mcp-server/tools/load_file.js
 init_config_customer();
 init_crypto();
-init_spv();
 import { gunzipSync as gunzipSync2 } from "zlib";
 import { writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
 import { dirname as dirname2 } from "path";
-import { Transaction as Transaction6 } from "@bsv/sdk";
+import { Transaction as Transaction6, PrivateKey as PrivateKey8, CompletedProtoWallet as CompletedProtoWallet3 } from "@bsv/sdk";
+init_spv();
+async function unwrapVaultV3(payload, wif) {
+  let w = null;
+  try {
+    w = new CompletedProtoWallet3(PrivateKey8.fromWif(wif));
+  } catch {
+    w = null;
+  }
+  if (!w) return { ok: false, code: "WALLET_UNAVAILABLE" };
+  if (payload.owner_pubkey) {
+    let idPub = null;
+    try {
+      idPub = (await w.getPublicKey({ identityKey: true }))?.publicKey || null;
+    } catch {
+    }
+    if (idPub && idPub !== payload.owner_pubkey) {
+      if (payload.wrap_recovery) {
+        const rr = await unwrapRecoveryV3(payload.wrap_recovery, w, payload.key_id, payload.owner_pubkey);
+        if (rr.ok) return { ok: true, contentKey: rr.contentKey };
+      }
+      return { ok: false, code: "WALLET_UNAVAILABLE" };
+    }
+  }
+  let r = await unwrapForSelfV3(payload.wrap_self, w, payload.key_id);
+  if (!r.ok && r.reason === "corrupt" && payload.wrap_recovery && payload.owner_pubkey) {
+    r = await unwrapRecoveryV3(payload.wrap_recovery, w, payload.key_id, payload.owner_pubkey);
+  }
+  if (!r.ok) return { ok: false, code: r.reason === "wallet_unavailable" ? "WALLET_UNAVAILABLE" : "V3_CORRUPT" };
+  return { ok: true, contentKey: r.contentKey };
+}
 async function fetchJsonPayload(txId) {
   const cleanTxId = txId.trim();
   try {
@@ -5100,6 +5336,47 @@ async function loadFile(txId, options = {}) {
   if (payload.protocol !== "indelible.file") {
     return { success: false, error: `Not an indelible.file tx (got: ${payload.protocol || "unknown"})` };
   }
+  const vfmt = detectVaultFormat(payload);
+  if (vfmt === "v3-wallet") {
+    const uv = await unwrapVaultV3(payload, wif);
+    if (!uv.ok) {
+      return { success: false, code: uv.code, error: uv.code === "WALLET_UNAVAILABLE" ? "wallet-native file: not readable from this box \u2014 its key lives in an external wallet (open it in the web app), or this WIF is not the owner" : "wallet-native file: unwrap failed (corrupt or wrong wallet)" };
+    }
+    let outBuf2;
+    try {
+      const dec = decryptWithKey(payload.encrypted, Buffer.from(uv.contentKey));
+      outBuf2 = dec.startsWith("gz:") ? gunzipSync2(Buffer.from(dec.slice(3), "base64")) : Buffer.from(dec, "utf8");
+    } catch (err) {
+      return { success: false, code: "V3_CORRUPT", error: `wallet-native decrypt failed: ${err.message}` };
+    }
+    const contentHash2 = sha256(outBuf2);
+    let meta = {};
+    try {
+      meta = JSON.parse(decryptWithKey(payload.meta_enc, Buffer.from(uv.contentKey)));
+    } catch {
+    }
+    const verified2 = meta.sha256 ? contentHash2 === meta.sha256 : payload.content_hash ? contentHash2 === payload.content_hash.replace("sha256:", "") : null;
+    if (options.outputPath) {
+      const dir = dirname2(options.outputPath);
+      if (!existsSync11(dir)) await mkdir4(dir, { recursive: true });
+      await writeFile4(options.outputPath, outBuf2);
+    }
+    const isBinary2 = payload.enc === "b64";
+    return {
+      success: true,
+      txId,
+      wallet_native: true,
+      filename: meta.filename,
+      path: meta.path,
+      size: payload.size,
+      content_hash: payload.content_hash,
+      verified: verified2,
+      content: isBinary2 ? `[binary file: ${outBuf2.length} bytes${options.outputPath ? ", written to disk" : ""}]` : outBuf2.toString("utf8")
+    };
+  }
+  if (vfmt === "v3-malformed") {
+    return { success: false, code: "V3_CORRUPT", error: "file carries malformed v3 wrap fields \u2014 failing closed" };
+  }
   let encrypted;
   if (payload._chunks) {
     let encryptedParts = "";
@@ -5121,16 +5398,18 @@ async function loadFile(txId, options = {}) {
   if (!encrypted) {
     return { success: false, error: "No encrypted content found in tx" };
   }
-  let content;
+  let outBuf;
   try {
-    content = decrypt(encrypted, wif);
-    if (content.startsWith("gz:")) {
-      content = gunzipSync2(Buffer.from(content.slice(3), "base64")).toString("utf8");
+    const dec = decrypt(encrypted, wif);
+    if (dec.startsWith("gz:")) {
+      outBuf = gunzipSync2(Buffer.from(dec.slice(3), "base64"));
+    } else {
+      outBuf = Buffer.from(dec, "utf8");
     }
   } catch (err) {
     return { success: false, error: `Decryption failed: ${err.message}` };
   }
-  const contentHash = sha256(content);
+  const contentHash = sha256(outBuf);
   const expectedHash = payload.content_hash?.replace("sha256:", "") || null;
   const verified = expectedHash ? contentHash === expectedHash : null;
   if (options.outputPath) {
@@ -5138,8 +5417,10 @@ async function loadFile(txId, options = {}) {
     if (!existsSync11(dir)) {
       await mkdir4(dir, { recursive: true });
     }
-    await writeFile4(options.outputPath, content, "utf-8");
+    await writeFile4(options.outputPath, outBuf);
   }
+  const isBinary = payload.enc === "b64";
+  const content = isBinary ? `[binary file: ${outBuf.length} bytes${options.outputPath ? ", written to disk" : ""}]` : outBuf.toString("utf8");
   const filename = payload.filename_enc ? decrypt(payload.filename_enc, wif) : payload.filename;
   const filePath = payload.path_enc ? decrypt(payload.path_enc, wif) : payload.path;
   return {
@@ -5148,6 +5429,7 @@ async function loadFile(txId, options = {}) {
     filename,
     path: filePath,
     size: payload.size,
+    enc: payload.enc || "utf8",
     content,
     contentHash: `sha256:${contentHash}`,
     verified,
@@ -5159,11 +5441,12 @@ async function loadFile(txId, options = {}) {
 // mcp-server/tools/load_project.js
 init_config_customer();
 init_crypto();
-init_spv();
+import { gunzipSync as gunzipSync3 } from "zlib";
 import { mkdir as mkdir5 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
 import { join as join11, dirname as dirname3 } from "path";
 import { Transaction as Transaction7 } from "@bsv/sdk";
+init_spv();
 async function fetchJsonPayload2(txId) {
   const cleanTxId = txId.trim();
   try {
@@ -5216,6 +5499,61 @@ async function loadProject(txId, options = {}) {
   if (!manifest.files || !Array.isArray(manifest.files)) {
     return { success: false, error: "Manifest has no files array" };
   }
+  if (detectVaultFormat(manifest) === "v3-wallet") {
+    const uv = await unwrapVaultV3(manifest, wif);
+    if (!uv.ok) {
+      return { success: false, code: uv.code, error: uv.code === "WALLET_UNAVAILABLE" ? "wallet-native project: not readable from this box \u2014 open it in the web app with the wallet that saved it" : "wallet-native project: manifest unwrap failed (corrupt or wrong wallet)" };
+    }
+    const ck = Buffer.from(uv.contentKey);
+    const dk = (s) => decryptWithKey(s, ck);
+    let sealed = {};
+    try {
+      sealed = JSON.parse(dk(manifest.name_enc));
+    } catch {
+    }
+    const v3Files = [];
+    const v3Errors = [];
+    for (const fileRef of manifest.files) {
+      try {
+        const meta = JSON.parse(dk(fileRef.meta_enc));
+        const dec = dk(fileRef.encrypted);
+        const outBuf = dec.startsWith("gz:") ? gunzipSync3(Buffer.from(dec.slice(3), "base64")) : Buffer.from(dec, "utf8");
+        const verified = meta.sha256 ? sha256(outBuf) === meta.sha256 : null;
+        if (verified === false) {
+          v3Errors.push({ path: "(tampered)", error: "content hash mismatch vs sealed meta" });
+          continue;
+        }
+        if (options.outputDir) {
+          const outputPath = join11(options.outputDir, sealed.name || "project", meta.path);
+          const dir = dirname3(outputPath);
+          if (!existsSync12(dir)) await mkdir5(dir, { recursive: true });
+          const { writeFile: writeFile5 } = await import("fs/promises");
+          await writeFile5(outputPath, outBuf);
+        }
+        const isBinary = fileRef.enc === "b64";
+        v3Files.push({ path: meta.path, size: fileRef.size, verified, content: options.outputDir ? void 0 : isBinary ? `[binary: ${outBuf.length} bytes]` : outBuf.toString("utf8") });
+      } catch (err) {
+        v3Errors.push({ path: "(locked)", error: err.message });
+      }
+    }
+    const setOk = sealed.file_count == null || sealed.file_count === manifest.files.length;
+    return {
+      success: true,
+      txId,
+      wallet_native: true,
+      projectName: sealed.name,
+      fileCount: sealed.file_count ?? manifest.files.length,
+      set_integrity: setOk ? "ok" : "FAILED",
+      totalSize: manifest.total_size,
+      loadedFiles: v3Files.length,
+      files: v3Files,
+      errors: v3Errors.length ? v3Errors : void 0,
+      message: `Project "${sealed.name || ""}" loaded (wallet-native): ${v3Files.length}/${sealed.file_count ?? manifest.files.length} files${setOk ? "" : " \u2014 \u26A0\uFE0F SET-INTEGRITY MISMATCH"}`
+    };
+  }
+  if (detectVaultFormat(manifest) === "v3-malformed") {
+    return { success: false, code: "V3_CORRUPT", error: "project manifest carries malformed v3 wrap fields \u2014 failing closed" };
+  }
   const isBundle = manifest.protocol === "indelible.project-bundle";
   const projectName = manifest.name_enc ? decrypt(manifest.name_enc, wif) : manifest.name;
   const loadedFiles = [];
@@ -5292,20 +5630,20 @@ async function updateVaultIndex() {
   if (!_gate.ok) return { success: false, gated: true, plan: _gate.plan, upsell: _gate.upsell, error: _gate.error };
   const files = config.file_txids || [];
   const projects = config.project_txids || [];
-  const encFiles = files.map((f) => ({
+  const encFiles = files.map((f) => f.filename ? {
     txid: f.txId,
-    filename_enc: encrypt(f.filename || "", wif),
-    path_enc: encrypt(f.path || "", wif),
+    filename_enc: encrypt(f.filename, wif),
+    path_enc: encrypt(f.path || f.filename, wif),
     size: f.size || 0,
     timestamp: f.timestamp || null
-  }));
-  const encProjects = projects.map((p) => ({
+  } : { txid: f.txId, size: f.size || 0, timestamp: f.timestamp || null, wrap: "v3" });
+  const encProjects = projects.map((p) => p.name ? {
     txid: p.txId,
-    name_enc: encrypt(p.name || "", wif),
+    name_enc: encrypt(p.name, wif),
     fileCount: p.fileCount || 0,
     totalSize: p.totalSize || 0,
     timestamp: p.timestamp || null
-  }));
+  } : { txid: p.txId, fileCount: p.fileCount || 0, totalSize: p.totalSize || 0, timestamp: p.timestamp || null, wrap: "v3" });
   const payload = {
     protocol: "indelible.vault-index",
     version: 1,
@@ -5676,7 +6014,7 @@ async function buildIndexWindow(address, wif, { fromDate = null, toDate = null,
       if (!fromChain || !fromChain.encrypted) {
         newGaps.push({ txId: s.txId, date: s.timestamp || null, save_type: s.save_type || null, reason: "NOT_ON_CHAIN", on_chain: false, logged_at: nowISO });
       } else {
-        const session = decryptSession(fromChain, wif);
+        const session = await decryptSession(fromChain, wif);
         const { title, searchText, message_count } = deriveTitleSearch(session);
         newRecords.push({
           txId: s.txId,
@@ -5693,7 +6031,7 @@ async function buildIndexWindow(address, wif, { fromDate = null, toDate = null,
       }
     } catch (e) {
       const msg = String(e.message || e);
-      const reason = /timeout/i.test(msg) ? "FETCH_TIMEOUT" : "DECRYPT_FAIL";
+      const reason = e?.code === "WALLET_UNAVAILABLE" ? "WALLET_LOCKED" : /timeout/i.test(msg) ? "FETCH_TIMEOUT" : "DECRYPT_FAIL";
       newGaps.push({ txId: s.txId, date: s.timestamp || null, save_type: s.save_type || null, reason, detail: redactSecrets(msg).slice(0, 120), on_chain: reason === "DECRYPT_FAIL", logged_at: nowISO });
     }
     done++;
@@ -5769,7 +6107,7 @@ async function diaryRecall({ from_date = null, to_date = null, query = null, dep
           entries.push({ txId, error: "not_on_chain" });
           continue;
         }
-        const s = decryptSession(fromChain, wif);
+        const s = await decryptSession(fromChain, wif);
         if (!saveTypes.includes(s?.type)) {
           entries.push({ txId, error: "wrong_scope", type: s?.type || null });
           continue;
@@ -5964,7 +6302,7 @@ ${context}` });
 init_config_customer();
 init_spv();
 init_utxo_cache();
-import { PrivateKey as PrivateKey8 } from "@bsv/sdk";
+import { PrivateKey as PrivateKey9 } from "@bsv/sdk";
 var DEFAULT_MAX_SATS = 1e4;
 async function x402Fetch({ url, method = "GET", headers = {}, body, maxSats }) {
   const cap = typeof maxSats === "number" && maxSats > 0 ? maxSats : DEFAULT_MAX_SATS;
@@ -6025,7 +6363,7 @@ async function x402Fetch({ url, method = "GET", headers = {}, body, maxSats }) {
       pricing
     };
   }
-  const privateKey = PrivateKey8.fromWif(wif);
+  const privateKey = PrivateKey9.fromWif(wif);
   const address = privateKey.toPublicKey().toAddress();
   let utxos;
   try {
@@ -6110,10 +6448,10 @@ init_utxo_cache();
 init_config_customer();
 init_api_client();
 import crypto from "crypto";
-import { PrivateKey as PrivateKey9 } from "@bsv/sdk";
+import { PrivateKey as PrivateKey10 } from "@bsv/sdk";
 var GOALS_PATH2 = goalsPath("");
 function deriveAddress(wif) {
-  return PrivateKey9.fromWif(wif).toAddress().toString();
+  return PrivateKey10.fromWif(wif).toAddress().toString();
 }
 function encryptGoals(goalsData, wif) {
   const key = crypto.createHash("sha256").update(wif).digest();
@@ -6223,7 +6561,7 @@ async function recallContext({ from_date = null, to_date = null, query = null, d
           sessions.push({ txId, error: "not_on_chain" });
           continue;
         }
-        const s = decryptSession(fromChain, wif);
+        const s = await decryptSession(fromChain, wif);
         const msgs = Array.isArray(s?.messages) ? s.messages : [];
         sessions.push({
           txId,
@@ -6380,11 +6718,13 @@ init_spv();
 init_api_client();
 import {
   Transaction as Transaction8,
-  PrivateKey as PrivateKey10,
+  PrivateKey as PrivateKey11,
   P2PKH as P2PKH3,
   SatoshisPerKilobyte as SatoshisPerKilobyte3,
   LockingScript as LockingScript3,
-  OP as OP3
+  OP as OP3,
+  CompletedProtoWallet as CompletedProtoWallet4,
+  AuthFetch as AuthFetch2
 } from "@bsv/sdk";
 var SHARE_DUST_SATS = 546;
 async function findRecipientPubkey(recipientAddr, scanLimit = 20) {
@@ -6458,16 +6798,27 @@ async function shareSession({ session_txid, recipient_addr, expires_at = null })
   if (!wif) return { success: false, error: "wallet not configured \u2014 run setup_wallet first" };
   const _gate = await requireProForWrite(config.address);
   if (!_gate.ok) return { success: false, gated: true, plan: _gate.plan, upsell: _gate.upsell, error: _gate.error };
-  const ownerPriv = PrivateKey10.fromWif(wif);
+  const ownerPriv = PrivateKey11.fromWif(wif);
   const ownerAddr = ownerPriv.toPublicKey().toAddress();
   const payload = await fetchScopePayload(session_txid);
   if (!payload) return { success: false, error: `could not fetch scope tx ${session_txid}` };
-  if (!payload.wrap_owner) {
+  const fmt = detectSaveFormat({ wrap_owner: payload.wrap_owner, wrap_self: payload.wrap_self, wrap_version: payload.wrap_version });
+  let contentKey;
+  if (fmt === "v3-wallet") {
+    const rv3 = await unwrapForSelfV3(payload.wrap_self, new CompletedProtoWallet4(ownerPriv), payload.key_id);
+    if (!rv3.ok) {
+      return { success: false, error: rv3.reason === "wallet_unavailable" ? "failed to unwrap own v3 content_key: no wallet available" : `failed to unwrap own v3 content_key: ${rv3.reason} (wallet-native saves made by an external wallet can only be shared from the web app)` };
+    }
+    contentKey = rv3.contentKey;
+  } else if (fmt === "v2-wrapped") {
+    const r = unwrapForOwner(payload.wrap_owner, ownerPriv);
+    if (!r.ok) return { success: false, error: `failed to unwrap own content_key: ${r.reason}` };
+    contentKey = r.contentKey;
+  } else if (fmt === "v3-malformed") {
+    return { success: false, error: "scope carries malformed v3 fields \u2014 failing closed, not shareable" };
+  } else {
     return { success: false, error: "scope is legacy format (no wrap_owner) \u2014 only post-g-170 saves are shareable. Re-save the session to make it shareable." };
   }
-  const r = unwrapForOwner(payload.wrap_owner, ownerPriv);
-  if (!r.ok) return { success: false, error: `failed to unwrap own content_key: ${r.reason}` };
-  const contentKey = r.contentKey;
   const recipientPubkey = await findRecipientPubkey(recipient_addr);
   if (!recipientPubkey) {
     return { success: false, error: `recipient ${recipient_addr} has no signed tx in their history \u2014 they must broadcast at least one tx for their pubkey to be discoverable` };
@@ -6522,7 +6873,7 @@ async function shareSession({ session_txid, recipient_addr, expires_at = null })
     tx.addOutput({ lockingScript: opReturnScript, satoshis: 0 });
     tx.addOutput({ lockingScript: p2pkh.lock(recipient_addr), satoshis: SHARE_DUST_SATS });
     tx.addOutput({ lockingScript: ownerLock, change: true });
-    await tx.fee(new SatoshisPerKilobyte3(1e3));
+    await tx.fee(new SatoshisPerKilobyte3(150));
     await tx.sign();
     txHex = tx.toHex();
     txId = tx.id("hex");
@@ -6530,7 +6881,45 @@ async function shareSession({ session_txid, recipient_addr, expires_at = null })
   } catch (e) {
     return { success: false, error: `broadcast failed: ${e.message}` };
   }
-  return { success: true, share_txid: txId, envelope };
+  const index_status = await indexShareOnBridge(txId, envelope, ownerPriv);
+  return { success: true, share_txid: txId, envelope, index_status };
+}
+async function indexShareOnBridge(txId, envelope, ownerPriv) {
+  try {
+    const bridges = await getBridges();
+    const record = {
+      txId,
+      recipient: envelope.recipient_addr,
+      sender: envelope.owner_addr,
+      identityKey: ownerPriv.toPublicKey().toString(),
+      protocol: envelope.protocol,
+      payload: JSON.stringify(envelope),
+      // decryptShare recovers the full envelope from here
+      // the envelope stamps ISO; the bridge index demands ms-epoch (putShare validation)
+      issued_at: typeof envelope.issued_at === "number" ? envelope.issued_at : Date.parse(envelope.issued_at)
+    };
+    const af = new AuthFetch2(new CompletedProtoWallet4(ownerPriv));
+    let lastErr = null;
+    for (const b of bridges.slice(0, 3)) {
+      try {
+        const res = await af.fetch(`${b.url}/api/shares/index`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(record)
+        });
+        if (res.ok) {
+          const body = await res.json().catch(() => ({}));
+          return { ok: true, bridge: b.url, gossip: body.gossip_status || "unknown" };
+        }
+        lastErr = `${b.url}: HTTP ${res.status}`;
+      } catch (e) {
+        lastErr = `${b.url}: ${e.message}`;
+      }
+    }
+    return { ok: false, error: lastErr || "no bridge accepted the index record" };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
 }
 function pushDataChunk2(data) {
   const len = data.length;
@@ -6828,7 +7217,7 @@ Commands:
 }
 function printHelp() {
   console.log(`
-Indelible MCP \u2014 Blockchain memory for Claude Code (v4.8.0)
+Indelible MCP \u2014 Blockchain memory for Claude Code (v4.8.2)
 
 Setup:
   indelible-mcp setup --wif=KEY --pin=PIN    Import and encrypt your private key
@@ -7047,7 +7436,7 @@ function readStdin() {
 }
 var SERVER_INFO = {
   name: "indelible",
-  version: "4.8.0",
+  version: "4.8.2",
   description: "Blockchain-backed memory and code storage for Claude Code"
 };
 var TOOLS = [