indelible-mcp 4.8.0 → 4.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indelible-mcp",
-  "version": "4.8.0",
+  "version": "4.8.1",
   "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,6 +1581,11 @@ 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";
@@ -1579,6 +1604,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 +1736,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 +1773,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 +1783,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 +2165,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 +2185,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 +2266,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 +2289,7 @@ async function saveFile(filePath, options = {}) {
         path_enc: pathEnc,
         size: fileSize,
         content_hash: `sha256:${contentHash}`,
+        enc: fileEnc,
         encrypted,
         owner: config.address,
         timestamp
@@ -2236,6 +2346,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 +2979,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 +3423,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 +4515,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 +4638,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 +4831,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 +4857,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 +4865,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 +4888,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 +4932,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 +5061,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 {
@@ -5121,16 +5320,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 +5339,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 +5351,7 @@ async function loadFile(txId, options = {}) {
     filename,
     path: filePath,
     size: payload.size,
+    enc: payload.enc || "utf8",
     content,
     contentHash: `sha256:${contentHash}`,
     verified,
@@ -5676,7 +5880,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 +5897,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 +5973,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;
@@ -6223,7 +6427,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,
@@ -6384,7 +6588,9 @@ import {
   P2PKH as P2PKH3,
   SatoshisPerKilobyte as SatoshisPerKilobyte3,
   LockingScript as LockingScript3,
-  OP as OP3
+  OP as OP3,
+  CompletedProtoWallet as CompletedProtoWallet3,
+  AuthFetch as AuthFetch2
 } from "@bsv/sdk";
 var SHARE_DUST_SATS = 546;
 async function findRecipientPubkey(recipientAddr, scanLimit = 20) {
@@ -6462,12 +6668,23 @@ async function shareSession({ session_txid, recipient_addr, expires_at = null })
   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 CompletedProtoWallet3(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 +6739,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 +6747,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 CompletedProtoWallet3(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 +7083,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.1)
 
 Setup:
   indelible-mcp setup --wif=KEY --pin=PIN    Import and encrypt your private key
@@ -7047,7 +7302,7 @@ function readStdin() {
 }
 var SERVER_INFO = {
   name: "indelible",
-  version: "4.8.0",
+  version: "4.8.1",
   description: "Blockchain-backed memory and code storage for Claude Code"
 };
 var TOOLS = [