@clude/sdk 3.0.3 → 3.0.4

package/README.md

@@ -471,7 +471,7 @@ Memories form a graph with typed bonds:
 This package also includes the full Clude bot — an autonomous AI agent on X ([@Cludebot](https://x.com/Cludebot)).
 
 ```bash
-git clone https://github.com/sebbsssss/cludebot.git
+git clone https://github.com/sebbsssss/clude.git
 cd cludebot
 npm install
 cp .env.example .env  # fill in API keys

package/dist/cli/index.js

@@ -2143,7 +2143,7 @@ async function runInit() {
     }
   }
   console.log(`
-  ${c.dim}Docs:    https://github.com/sebbsssss/cludebot${c.reset}`);
+  ${c.dim}Docs:    https://github.com/sebbsssss/clude${c.reset}`);
   console.log(`  ${c.dim}Website: https://clude.io${c.reset}`);
   printDivider();
   console.log("");
@@ -2797,6 +2797,232 @@ var init_status = __esm({
   }
 });
 
+// packages/brain/src/memorypack/types.ts
+var MEMORYPACK_VERSION;
+var init_types = __esm({
+  "packages/brain/src/memorypack/types.ts"() {
+    "use strict";
+    MEMORYPACK_VERSION = "0.1";
+  }
+});
+
+// packages/brain/src/memorypack/sign.ts
+function hashRecordLine(line) {
+  const clean = line.replace(/\n$/, "");
+  const hex = (0, import_crypto.createHash)("sha256").update(clean, "utf-8").digest("hex");
+  return `sha256:${hex}`;
+}
+function signHash(hash, secretKey) {
+  const messageBytes = Buffer.from(hash, "utf-8");
+  const sig = import_tweetnacl.default.sign.detached(messageBytes, secretKey);
+  return `base58:${bs58.encode(sig)}`;
+}
+function verifyHash(hash, signature, publicKey) {
+  try {
+    const messageBytes = Buffer.from(hash, "utf-8");
+    const sigRaw = signature.startsWith("base58:") ? signature.slice("base58:".length) : signature;
+    const sigBytes = bs58.decode(sigRaw);
+    const pkBytes = bs58.decode(publicKey);
+    return import_tweetnacl.default.sign.detached.verify(messageBytes, sigBytes, pkBytes);
+  } catch {
+    return false;
+  }
+}
+var import_crypto, import_tweetnacl, bs58Module, bs58;
+var init_sign = __esm({
+  "packages/brain/src/memorypack/sign.ts"() {
+    "use strict";
+    import_crypto = require("crypto");
+    import_tweetnacl = __toESM(require("tweetnacl"));
+    bs58Module = __toESM(require("bs58"));
+    bs58 = bs58Module.default || bs58Module;
+  }
+});
+
+// packages/brain/src/memorypack/writer.ts
+function serializeRecord(record) {
+  const KNOWN_ORDER = [
+    "id",
+    "created_at",
+    "kind",
+    "content",
+    "tags",
+    "importance",
+    "source",
+    "summary",
+    "embedding",
+    "embedding_model",
+    "metadata",
+    "access_count",
+    "last_accessed_at",
+    "parent_ids",
+    "compacted_from",
+    "blob_ref"
+  ];
+  const out = {};
+  for (const k of KNOWN_ORDER) {
+    if (record[k] !== void 0) out[k] = record[k];
+  }
+  const recAsUnknown = record;
+  const unknownKeys = Object.keys(recAsUnknown).filter(
+    (k) => !KNOWN_ORDER.includes(k)
+  );
+  for (const k of unknownKeys.sort()) {
+    out[k] = recAsUnknown[k];
+  }
+  return JSON.stringify(out);
+}
+function writeMemoryPack(dir, records, opts, anchors) {
+  (0, import_fs2.mkdirSync)(dir, { recursive: true });
+  const manifest = {
+    memorypack_version: MEMORYPACK_VERSION,
+    producer: opts.producer,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    record_count: records.length,
+    record_schema: opts.record_schema,
+    signature_algorithm: opts.secretKey ? "ed25519" : void 0,
+    anchor_chain: opts.anchor_chain
+  };
+  (0, import_fs2.writeFileSync)((0, import_path3.join)(dir, "manifest.json"), JSON.stringify(manifest, null, 2));
+  const recordLines = [];
+  const sigs = [];
+  for (const record of records) {
+    const line = serializeRecord(record);
+    recordLines.push(line);
+    if (opts.secretKey && opts.producer.public_key) {
+      const hash = hashRecordLine(line);
+      const signature = signHash(hash, opts.secretKey);
+      sigs.push({
+        record_hash: hash,
+        signature,
+        algorithm: "ed25519",
+        public_key: opts.producer.public_key
+      });
+    }
+  }
+  (0, import_fs2.writeFileSync)((0, import_path3.join)(dir, "records.jsonl"), recordLines.join("\n") + "\n");
+  if (sigs.length > 0) {
+    (0, import_fs2.writeFileSync)(
+      (0, import_path3.join)(dir, "signatures.jsonl"),
+      sigs.map((s) => JSON.stringify(s)).join("\n") + "\n"
+    );
+  }
+  if (anchors && anchors.length > 0) {
+    (0, import_fs2.writeFileSync)(
+      (0, import_path3.join)(dir, "anchors.jsonl"),
+      anchors.map((a) => JSON.stringify(a)).join("\n") + "\n"
+    );
+  }
+}
+var import_fs2, import_path3;
+var init_writer = __esm({
+  "packages/brain/src/memorypack/writer.ts"() {
+    "use strict";
+    import_fs2 = require("fs");
+    import_path3 = require("path");
+    init_types();
+    init_sign();
+  }
+});
+
+// packages/brain/src/memorypack/reader.ts
+function readMemoryPack(dir, opts = {}) {
+  const warnings = [];
+  const manifestPath = (0, import_path4.join)(dir, "manifest.json");
+  if (!(0, import_fs3.existsSync)(manifestPath)) {
+    throw new Error(`MemoryPack: manifest.json not found in ${dir}`);
+  }
+  const manifest = JSON.parse((0, import_fs3.readFileSync)(manifestPath, "utf-8"));
+  if (!manifest.memorypack_version) {
+    throw new Error("MemoryPack: manifest missing memorypack_version");
+  }
+  if (!manifest.memorypack_version.startsWith("0.")) {
+    throw new Error(
+      `MemoryPack: unsupported memorypack_version ${manifest.memorypack_version} (reader supports 0.x)`
+    );
+  }
+  const recordsPath = (0, import_path4.join)(dir, "records.jsonl");
+  if (!(0, import_fs3.existsSync)(recordsPath)) {
+    throw new Error(`MemoryPack: records.jsonl not found in ${dir}`);
+  }
+  const recordLines = (0, import_fs3.readFileSync)(recordsPath, "utf-8").split("\n").filter((l) => l.length > 0);
+  const records = [];
+  const lineByHash = /* @__PURE__ */ new Map();
+  for (const line of recordLines) {
+    const rec = JSON.parse(line);
+    records.push(rec);
+    lineByHash.set(hashRecordLine(line), line);
+  }
+  if (records.length !== manifest.record_count) {
+    warnings.push(`record_count mismatch: manifest ${manifest.record_count} vs jsonl ${records.length}`);
+  }
+  const verifiedRecords = /* @__PURE__ */ new Set();
+  const sigsPath = (0, import_path4.join)(dir, "signatures.jsonl");
+  const signaturesFilePresent = (0, import_fs3.existsSync)(sigsPath);
+  if (signaturesFilePresent) {
+    const sigLines = (0, import_fs3.readFileSync)(sigsPath, "utf-8").split("\n").filter((l) => l.length > 0);
+    const pubkey = opts.publicKey ?? manifest.producer.public_key;
+    if (!pubkey) {
+      throw new Error("MemoryPack: signatures.jsonl present but no public_key in manifest");
+    }
+    const validSigHashes = /* @__PURE__ */ new Set();
+    for (const line of sigLines) {
+      const sig = JSON.parse(line);
+      const ok = verifyHash(sig.record_hash, sig.signature, pubkey);
+      if (!ok) {
+        throw new Error(`MemoryPack: signature verification failed for ${sig.record_hash}`);
+      }
+      validSigHashes.add(sig.record_hash);
+    }
+    for (const recordHash of lineByHash.keys()) {
+      if (!validSigHashes.has(recordHash)) {
+        throw new Error(
+          `MemoryPack: signature verification failed \u2014 record ${recordHash} has no matching signature`
+        );
+      }
+      verifiedRecords.add(recordHash);
+    }
+  }
+  const unsignedRecords = /* @__PURE__ */ new Set();
+  if (!signaturesFilePresent) {
+    for (const hash of lineByHash.keys()) unsignedRecords.add(hash);
+  }
+  if (opts.strictSignatures && unsignedRecords.size > 0) {
+    throw new Error(
+      `MemoryPack: strictSignatures=true but ${unsignedRecords.size} records are unsigned`
+    );
+  }
+  const anchors = [];
+  const anchorsPath = (0, import_path4.join)(dir, "anchors.jsonl");
+  if ((0, import_fs3.existsSync)(anchorsPath)) {
+    const anchorLines = (0, import_fs3.readFileSync)(anchorsPath, "utf-8").split("\n").filter((l) => l.length > 0);
+    for (const line of anchorLines) {
+      anchors.push(JSON.parse(line));
+    }
+  }
+  return { manifest, records, verifiedRecords, unsignedRecords, anchors, warnings };
+}
+var import_fs3, import_path4;
+var init_reader = __esm({
+  "packages/brain/src/memorypack/reader.ts"() {
+    "use strict";
+    import_fs3 = require("fs");
+    import_path4 = require("path");
+    init_sign();
+  }
+});
+
+// packages/brain/src/memorypack/index.ts
+var init_memorypack = __esm({
+  "packages/brain/src/memorypack/index.ts"() {
+    "use strict";
+    init_types();
+    init_writer();
+    init_reader();
+    init_sign();
+  }
+});
+
 // packages/brain/src/mcp/local-store.ts
 var local_store_exports = {};
 __export(local_store_exports, {
@@ -2809,22 +3035,22 @@ __export(local_store_exports, {
   localUpdate: () => localUpdate
 });
 function ensureDir() {
-  if (!(0, import_fs2.existsSync)(CLUDE_DIR2)) {
-    (0, import_fs2.mkdirSync)(CLUDE_DIR2, { recursive: true });
+  if (!(0, import_fs4.existsSync)(CLUDE_DIR2)) {
+    (0, import_fs4.mkdirSync)(CLUDE_DIR2, { recursive: true });
   }
 }
 function loadStore() {
   ensureDir();
-  if (!(0, import_fs2.existsSync)(MEMORIES_FILE2)) {
+  if (!(0, import_fs4.existsSync)(MEMORIES_FILE2)) {
     return { version: 1, next_id: 1, memories: [] };
   }
   try {
-    const raw = (0, import_fs2.readFileSync)(MEMORIES_FILE2, "utf-8");
+    const raw = (0, import_fs4.readFileSync)(MEMORIES_FILE2, "utf-8");
     const data = JSON.parse(raw);
     if (!data || !Array.isArray(data.memories)) {
       console.error("[clude-local] Warning: memories.json has invalid structure, starting fresh. Backup saved.");
       try {
-        (0, import_fs2.writeFileSync)(MEMORIES_FILE2 + ".bak", raw);
+        (0, import_fs4.writeFileSync)(MEMORIES_FILE2 + ".bak", raw);
       } catch {
       }
       return { version: 1, next_id: 1, memories: [] };
@@ -2833,8 +3059,8 @@ function loadStore() {
   } catch (err) {
     console.error("[clude-local] Warning: failed to parse memories.json:", err.message);
     try {
-      const raw = (0, import_fs2.readFileSync)(MEMORIES_FILE2, "utf-8");
-      (0, import_fs2.writeFileSync)(MEMORIES_FILE2 + ".bak", raw);
+      const raw = (0, import_fs4.readFileSync)(MEMORIES_FILE2, "utf-8");
+      (0, import_fs4.writeFileSync)(MEMORIES_FILE2 + ".bak", raw);
       console.error("[clude-local] Backup saved to memories.json.bak");
     } catch {
     }
@@ -2844,8 +3070,8 @@ function loadStore() {
 function saveStore(store) {
   ensureDir();
   const tmpFile = MEMORIES_FILE2 + ".tmp";
-  (0, import_fs2.writeFileSync)(tmpFile, JSON.stringify(store, null, 2));
-  (0, import_fs2.renameSync)(tmpFile, MEMORIES_FILE2);
+  (0, import_fs4.writeFileSync)(tmpFile, JSON.stringify(store, null, 2));
+  (0, import_fs4.renameSync)(tmpFile, MEMORIES_FILE2);
 }
 function scoreRelevance(query, memory) {
   const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
@@ -3031,14 +3257,14 @@ function localList(opts) {
   const start = (page - 1) * pageSize;
   return { memories: memories.slice(start, start + pageSize), total };
 }
-var import_fs2, import_path3, CLUDE_DIR2, MEMORIES_FILE2;
+var import_fs4, import_path5, CLUDE_DIR2, MEMORIES_FILE2;
 var init_local_store = __esm({
   "packages/brain/src/mcp/local-store.ts"() {
     "use strict";
-    import_fs2 = require("fs");
-    import_path3 = require("path");
-    CLUDE_DIR2 = (0, import_path3.join)(process.env.HOME || process.env.USERPROFILE || ".", ".clude");
-    MEMORIES_FILE2 = (0, import_path3.join)(CLUDE_DIR2, "memories.json");
+    import_fs4 = require("fs");
+    import_path5 = require("path");
+    CLUDE_DIR2 = (0, import_path5.join)(process.env.HOME || process.env.USERPROFILE || ".", ".clude");
+    MEMORIES_FILE2 = (0, import_path5.join)(CLUDE_DIR2, "memories.json");
   }
 });
 
@@ -3679,11 +3905,12 @@ var init_text = __esm({
 });
 
 // packages/shared/src/utils/constants.ts
-var MEMO_PROGRAM_ID, BOT_X_HANDLE, MEMORY_MIN_DECAY, MEMORY_MAX_CONTENT_LENGTH, MEMORY_MAX_SUMMARY_LENGTH, DECAY_RATES, RECENCY_DECAY_BASE, RETRIEVAL_WEIGHT_RECENCY, RETRIEVAL_WEIGHT_RELEVANCE, RETRIEVAL_WEIGHT_IMPORTANCE, RETRIEVAL_WEIGHT_VECTOR, KNOWLEDGE_TYPE_BOOST, VECTOR_MATCH_THRESHOLD, BOND_TYPE_WEIGHTS, RETRIEVAL_WEIGHT_GRAPH, RETRIEVAL_WEIGHT_COOCCURRENCE, LINK_SIMILARITY_THRESHOLD, MAX_AUTO_LINKS, LINK_CO_RETRIEVAL_BOOST, INTERNAL_MEMORY_SOURCES, INTERNAL_IMPORTANCE_BOOST, REFLECTION_MIN_INTERVAL_MS, WHALE_SELL_COOLDOWN_MS, MEMO_MAX_LENGTH;
+var MEMO_PROGRAM_ID, SOLSCAN_TX_BASE_URL, BOT_X_HANDLE, MEMORY_MIN_DECAY, MEMORY_MAX_CONTENT_LENGTH, MEMORY_MAX_SUMMARY_LENGTH, DECAY_RATES, RECENCY_DECAY_BASE, RETRIEVAL_WEIGHT_RECENCY, RETRIEVAL_WEIGHT_RELEVANCE, RETRIEVAL_WEIGHT_IMPORTANCE, RETRIEVAL_WEIGHT_VECTOR, KNOWLEDGE_TYPE_BOOST, VECTOR_MATCH_THRESHOLD, BOND_TYPE_WEIGHTS, RETRIEVAL_WEIGHT_GRAPH, RETRIEVAL_WEIGHT_COOCCURRENCE, LINK_SIMILARITY_THRESHOLD, MAX_AUTO_LINKS, LINK_CO_RETRIEVAL_BOOST, INTERNAL_MEMORY_SOURCES, INTERNAL_IMPORTANCE_BOOST, REFLECTION_MIN_INTERVAL_MS, WHALE_SELL_COOLDOWN_MS, MEMO_MAX_LENGTH;
 var init_constants = __esm({
   "packages/shared/src/utils/constants.ts"() {
     "use strict";
     MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+    SOLSCAN_TX_BASE_URL = "https://solscan.io/tx";
     BOT_X_HANDLE = process.env.BOT_X_HANDLE || "cludebot";
     MEMORY_MIN_DECAY = 0.05;
     MEMORY_MAX_CONTENT_LENGTH = 5e3;
@@ -3990,12 +4217,46 @@ var init_claude_client = __esm({
 });
 
 // packages/shared/src/core/solana-client.ts
+var solana_client_exports = {};
+__export(solana_client_exports, {
+  _configureMemoryRegistry: () => _configureMemoryRegistry,
+  _configureSolana: () => _configureSolana,
+  getBotWallet: () => getBotWallet,
+  getConnection: () => getConnection,
+  initializeRegistry: () => initializeRegistry,
+  isRegistryEnabled: () => isRegistryEnabled,
+  parseMemoContentHash: () => parseMemoContentHash,
+  registerMemoryOnChain: () => registerMemoryOnChain,
+  solscanTxUrl: () => solscanTxUrl,
+  verifyMemoTransaction: () => verifyMemoTransaction,
+  verifyMemoryOnChain: () => verifyMemoryOnChain,
+  verifySignature: () => verifySignature,
+  writeMemo: () => writeMemo,
+  writeMemoDevnet: () => writeMemoDevnet
+});
 function getConnection() {
   if (!connection) {
     connection = new import_web3.Connection(config.solana.rpcUrl, "confirmed");
   }
   return connection;
 }
+function _configureSolana(rpcUrl, privateKey) {
+  connection = new import_web3.Connection(rpcUrl, "confirmed");
+  if (privateKey) {
+    try {
+      const raw = privateKey.trim();
+      let secretKey;
+      if (raw.startsWith("[")) {
+        secretKey = Uint8Array.from(JSON.parse(raw));
+      } else {
+        secretKey = bs582.decode(raw);
+      }
+      botWallet = import_web3.Keypair.fromSecretKey(secretKey);
+    } catch (err) {
+      log6.error({ err }, "SDK: Failed to load bot wallet");
+    }
+  }
+}
 function getBotWallet() {
   if (!botWallet && config.solana.botWalletPrivateKey) {
     try {
@@ -4004,7 +4265,7 @@ function getBotWallet() {
       if (raw.startsWith("[")) {
         secretKey = Uint8Array.from(JSON.parse(raw));
       } else {
-        secretKey = bs58.decode(raw);
+        secretKey = bs582.decode(raw);
       }
       botWallet = import_web3.Keypair.fromSecretKey(secretKey);
       log6.info({ publicKey: botWallet.publicKey.toBase58() }, "Bot wallet loaded");
@@ -4037,6 +4298,50 @@ async function writeMemo(memo) {
     return null;
   }
 }
+function getDevnetConnection() {
+  if (!devnetConnection) {
+    devnetConnection = new import_web3.Connection("https://api.devnet.solana.com", "confirmed");
+  }
+  return devnetConnection;
+}
+async function writeMemoDevnet(memo) {
+  const wallet = getBotWallet();
+  if (!wallet) {
+    log6.error("No bot wallet configured, cannot write devnet memo");
+    return null;
+  }
+  const conn = getDevnetConnection();
+  const truncatedMemo = memo.slice(0, MEMO_MAX_LENGTH);
+  const instruction = new import_web3.TransactionInstruction({
+    keys: [{ pubkey: wallet.publicKey, isSigner: true, isWritable: true }],
+    programId: MEMO_PROGRAM_ID2,
+    data: Buffer.from(truncatedMemo, "utf-8")
+  });
+  const transaction = new import_web3.Transaction().add(instruction);
+  try {
+    const signature = await (0, import_web3.sendAndConfirmTransaction)(conn, transaction, [wallet]);
+    log6.info({ signature, memoLength: truncatedMemo.length }, "Memo written on devnet");
+    return signature;
+  } catch (err) {
+    log6.error({ err }, "Failed to write devnet memo");
+    return null;
+  }
+}
+function verifySignature(message, signature, publicKey) {
+  const messageBytes = new TextEncoder().encode(message);
+  return import_tweetnacl2.default.sign.detached.verify(messageBytes, signature, publicKey);
+}
+function solscanTxUrl(signature) {
+  return `${SOLSCAN_TX_BASE_URL}/${signature}`;
+}
+function _configureMemoryRegistry(programId) {
+  try {
+    registryProgramId = new import_web3.PublicKey(programId);
+    log6.info({ programId: programId.slice(0, 12) + "..." }, "Memory registry program configured");
+  } catch (err) {
+    log6.error({ err }, "Invalid memory registry program ID");
+  }
+}
 function isRegistryEnabled() {
   return registryProgramId !== null;
 }
@@ -4048,10 +4353,42 @@ function deriveRegistryPDA(authority) {
   );
 }
 function anchorDiscriminator(name) {
-  const { createHash: createHash3 } = require("crypto");
-  const hash = createHash3("sha256").update(`global:${name}`).digest();
+  const { createHash: createHash4 } = require("crypto");
+  const hash = createHash4("sha256").update(`global:${name}`).digest();
   return hash.subarray(0, 8);
 }
+async function initializeRegistry() {
+  if (registryInitialized) return;
+  const wallet = getBotWallet();
+  if (!wallet || !registryProgramId) return;
+  const conn = getConnection();
+  const [registryPDA] = deriveRegistryPDA(wallet.publicKey);
+  const accountInfo = await conn.getAccountInfo(registryPDA);
+  if (accountInfo) {
+    registryInitialized = true;
+    log6.info({ registry: registryPDA.toBase58() }, "Registry PDA already exists");
+    return;
+  }
+  const discriminator = anchorDiscriminator("initialize");
+  const instruction = new import_web3.TransactionInstruction({
+    keys: [
+      { pubkey: registryPDA, isSigner: false, isWritable: true },
+      { pubkey: wallet.publicKey, isSigner: true, isWritable: true },
+      { pubkey: import_web3.SystemProgram.programId, isSigner: false, isWritable: false }
+    ],
+    programId: registryProgramId,
+    data: discriminator
+  });
+  const transaction = new import_web3.Transaction().add(instruction);
+  try {
+    const signature = await (0, import_web3.sendAndConfirmTransaction)(conn, transaction, [wallet]);
+    registryInitialized = true;
+    log6.info({ signature, registry: registryPDA.toBase58() }, "Registry PDA initialized on-chain");
+  } catch (err) {
+    log6.error({ err }, "Failed to initialize registry PDA");
+    throw err;
+  }
+}
 function memoryTypeToU8(type) {
   switch (type) {
     case "episodic":
@@ -4103,21 +4440,82 @@ async function registerMemoryOnChain(contentHash, memoryType, importance, memory
     return null;
   }
 }
-var import_web3, bs58Module, import_tweetnacl, bs58, log6, connection, botWallet, MEMO_PROGRAM_ID2, registryProgramId;
+async function verifyMemoryOnChain(contentHash, authority) {
+  const wallet = getBotWallet();
+  const authPubkey = authority || wallet?.publicKey;
+  if (!authPubkey || !registryProgramId) return false;
+  const conn = getConnection();
+  const [registryPDA] = deriveRegistryPDA(authPubkey);
+  try {
+    const accountInfo = await conn.getAccountInfo(registryPDA);
+    if (!accountInfo || !accountInfo.data) return false;
+    const data = accountInfo.data;
+    if (data.length < 53) return false;
+    const vecLen = data.readUInt32LE(49);
+    const ENTRY_SIZE = 56;
+    const entriesStart = 53;
+    for (let i = 0; i < vecLen; i++) {
+      const offset = entriesStart + i * ENTRY_SIZE;
+      if (offset + 32 > data.length) break;
+      const hash = data.subarray(offset, offset + 32);
+      if (contentHash.equals(hash)) return true;
+    }
+    return false;
+  } catch (err) {
+    log6.warn({ err }, "Failed to verify memory on-chain");
+    return false;
+  }
+}
+function parseMemoContentHash(memo) {
+  if (!memo.startsWith("clude-memory |")) return null;
+  const v2Match = memo.match(/^clude-memory \| v2 \| ([a-f0-9]{64})$/);
+  if (v2Match) return v2Match[1];
+  const v1Match = memo.match(/^clude-memory \| id: \d+ \| type: \w+ \| hash: ([a-f0-9]{16}) \|/);
+  if (v1Match) return v1Match[1];
+  return null;
+}
+async function verifyMemoTransaction(signature, contentHash) {
+  const conn = getConnection();
+  try {
+    const tx = await conn.getTransaction(signature, { maxSupportedTransactionVersion: 0 });
+    if (!tx?.meta || !tx.transaction.message) return false;
+    const memoProgram = MEMO_PROGRAM_ID2.toBase58();
+    const message = tx.transaction.message;
+    const accountKeys = message.staticAccountKeys?.map((k) => k.toBase58()) ?? [];
+    const compiledIxs = message.compiledInstructions;
+    for (const ix of compiledIxs) {
+      if (accountKeys[ix.programIdIndex] !== memoProgram) continue;
+      const memoStr = Buffer.from(ix.data).toString("utf-8");
+      const parsedHash = parseMemoContentHash(memoStr);
+      if (!parsedHash) continue;
+      const contentHashHex = contentHash.toString("hex");
+      if (parsedHash.length === 64) {
+        return parsedHash === contentHashHex;
+      }
+      return contentHashHex.startsWith(parsedHash);
+    }
+    return false;
+  } catch (err) {
+    log6.warn({ err, signature: signature.slice(0, 16) }, "Failed to verify memo transaction");
+    return false;
+  }
+}
+var import_web3, bs58Module2, import_tweetnacl2, bs582, log6, connection, botWallet, MEMO_PROGRAM_ID2, devnetConnection, registryProgramId, registryInitialized;
 var init_solana_client = __esm({
   "packages/shared/src/core/solana-client.ts"() {
     "use strict";
     import_web3 = require("@solana/web3.js");
-    bs58Module = __toESM(require("bs58"));
+    bs58Module2 = __toESM(require("bs58"));
     init_config();
     init_logger();
-    import_tweetnacl = __toESM(require("tweetnacl"));
+    import_tweetnacl2 = __toESM(require("tweetnacl"));
     init_constants();
-    bs58 = bs58Module.default || bs58Module;
+    bs582 = bs58Module2.default || bs58Module2;
     log6 = createChildLogger("solana-client");
     botWallet = null;
     MEMO_PROGRAM_ID2 = new import_web3.PublicKey(MEMO_PROGRAM_ID);
     registryProgramId = null;
+    registryInitialized = false;
   }
 });
 
@@ -4391,9 +4789,9 @@ function encryptContent(plaintext) {
   if (!encryptionKey) {
     throw new Error("Encryption not configured. Call configureEncryption() first.");
   }
-  const nonce = import_tweetnacl2.default.randomBytes(NONCE_LENGTH);
+  const nonce = import_tweetnacl3.default.randomBytes(NONCE_LENGTH);
   const messageBytes = new TextEncoder().encode(plaintext);
-  const ciphertext = import_tweetnacl2.default.secretbox(messageBytes, nonce, encryptionKey);
+  const ciphertext = import_tweetnacl3.default.secretbox(messageBytes, nonce, encryptionKey);
   const combined = new Uint8Array(NONCE_LENGTH + ciphertext.length);
   combined.set(nonce, 0);
   combined.set(ciphertext, NONCE_LENGTH);
@@ -4410,7 +4808,7 @@ function decryptContent(encrypted) {
     }
     const nonce = combined.subarray(0, NONCE_LENGTH);
     const ciphertext = combined.subarray(NONCE_LENGTH);
-    const plaintext = import_tweetnacl2.default.secretbox.open(ciphertext, nonce, encryptionKey);
+    const plaintext = import_tweetnacl3.default.secretbox.open(ciphertext, nonce, encryptionKey);
     if (!plaintext) {
       return null;
     }
@@ -4436,17 +4834,17 @@ function decryptMemoryBatch(memories) {
   }
   return memories;
 }
-var import_tweetnacl2, import_crypto, import_util, log9, hkdfAsync, NONCE_LENGTH, encryptionKey, encryptionPubkey;
+var import_tweetnacl3, import_crypto2, import_util, log9, hkdfAsync, NONCE_LENGTH, encryptionKey, encryptionPubkey;
 var init_encryption = __esm({
   "packages/shared/src/core/encryption.ts"() {
     "use strict";
-    import_tweetnacl2 = __toESM(require("tweetnacl"));
-    import_crypto = require("crypto");
+    import_tweetnacl3 = __toESM(require("tweetnacl"));
+    import_crypto2 = require("crypto");
     import_util = require("util");
     init_logger();
     log9 = createChildLogger("encryption");
-    hkdfAsync = (0, import_util.promisify)(import_crypto.hkdf);
-    NONCE_LENGTH = import_tweetnacl2.default.secretbox.nonceLength;
+    hkdfAsync = (0, import_util.promisify)(import_crypto2.hkdf);
+    NONCE_LENGTH = import_tweetnacl3.default.secretbox.nonceLength;
     encryptionKey = null;
     encryptionPubkey = null;
   }
@@ -4787,7 +5185,7 @@ function scopeToOwner(query) {
   return query;
 }
 function generateHashId() {
-  return `${HASH_ID_PREFIX}-${(0, import_crypto2.randomBytes)(4).toString("hex")}`;
+  return `${HASH_ID_PREFIX}-${(0, import_crypto3.randomBytes)(4).toString("hex")}`;
 }
 function isValidHashId(id) {
   return /^clude-[a-f0-9]{8}$/.test(id);
@@ -4899,7 +5297,7 @@ async function storeMemory(opts) {
 }
 async function commitMemoryToChain(memoryId, opts) {
   if (opts.source === "demo" || opts.source === "demo-maas" || opts.source === "locomo-benchmark" || opts.source === "longmemeval-benchmark") return;
-  const contentHashBuf = (0, import_crypto2.createHash)("sha256").update(opts.content).digest();
+  const contentHashBuf = (0, import_crypto3.createHash)("sha256").update(opts.content).digest();
   let signature = null;
   if (isRegistryEnabled()) {
     const encrypted = isEncryptionEnabled();
@@ -4913,7 +5311,7 @@ async function commitMemoryToChain(memoryId, opts) {
   }
   if (!signature) {
     const contentHashHex = contentHashBuf.toString("hex");
-    const memo = `clude-memory | v2 | ${contentHashHex}`;
+    const memo = `clude:v1:sha256:${contentHashHex}`;
     signature = await writeMemo(memo);
   }
   if (!signature) return;
@@ -5865,7 +6263,7 @@ function moodToValence(mood) {
       return 0;
   }
 }
-var import_crypto2, EMBED_CACHE_MAX, embeddingCache, _ownerWallet, SCOPE_BOT_OWN, HASH_ID_PREFIX, log11, DEDUP_TTL_MS, dedupCache, STOPWORDS;
+var import_crypto3, EMBED_CACHE_MAX, embeddingCache, _ownerWallet, SCOPE_BOT_OWN, HASH_ID_PREFIX, log11, DEDUP_TTL_MS, dedupCache, STOPWORDS;
 var init_memory = __esm({
   "packages/brain/src/memory/memory.ts"() {
     "use strict";
@@ -5880,7 +6278,7 @@ var init_memory = __esm({
     init_openrouter_client();
     init_encryption();
     init_event_bus();
-    import_crypto2 = require("crypto");
+    import_crypto3 = require("crypto");
     init_graph();
     init_owner_context();
     EMBED_CACHE_MAX = 200;
@@ -6179,7 +6577,8 @@ async function runExport() {
     -h, --help             Show this help
 
   ${c.bold}Formats:${c.reset}
-    ${c.cyan}json${c.reset}        MemoryPack JSON (default)
+    ${c.cyan}json${c.reset}        Legacy single-file JSON (default)
+    ${c.cyan}memorypack${c.reset}  MemoryPack v0.1 spec directory (manifest + records.jsonl + sigs)
     ${c.cyan}md${c.reset}          Clean Markdown
     ${c.cyan}chatgpt${c.reset}     System prompt for ChatGPT Custom Instructions
     ${c.cyan}gemini${c.reset}      System prompt for Gemini Gems
@@ -6199,7 +6598,7 @@ async function runExport() {
   const output = getFlag(args, "--output") || getFlag(args, "-o");
   const typesRaw = getFlag(args, "--types");
   const types = typesRaw ? typesRaw.split(",").map((t) => t.trim()) : void 0;
-  const validFormats = ["json", "md", "chatgpt", "gemini", "clipboard"];
+  const validFormats = ["json", "md", "chatgpt", "gemini", "clipboard", "memorypack"];
   if (!validFormats.includes(format)) {
     printError(`Format must be one of: ${validFormats.join(", ")}`);
     process.exit(1);
@@ -6346,6 +6745,63 @@ async function runExport() {
   } else if (format === "md") {
     content = formatMarkdown(memories);
     defaultName = "clude-memories.md";
+  } else if (format === "memorypack") {
+    const outputDir = output || "clude-memorypack";
+    const records = memories.map((m, i) => {
+      const id = m.id ? String(m.id) : String(i + 1);
+      const kind = m.type || m.memory_type || "episodic";
+      const rec = {
+        id,
+        created_at: m.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+        kind,
+        content: m.content || "",
+        tags: m.tags || [],
+        importance: typeof m.importance === "number" ? m.importance : 0.5,
+        source: m.source || ""
+      };
+      if (m.summary) rec.summary = m.summary;
+      if (m.access_count != null) rec.access_count = m.access_count;
+      if (m.last_accessed_at) rec.last_accessed_at = m.last_accessed_at;
+      return rec;
+    });
+    let secretKey;
+    let publicKey;
+    try {
+      const { getBotWallet: getBotWallet2 } = (init_solana_client(), __toCommonJS(solana_client_exports));
+      const wallet = getBotWallet2();
+      if (wallet) {
+        secretKey = wallet.secretKey;
+        publicKey = wallet.publicKey.toBase58();
+      }
+    } catch {
+    }
+    writeMemoryPack(outputDir, records, {
+      producer: {
+        name: "clude",
+        version: "3.0.3",
+        agent_id: config3?.agent?.id,
+        public_key: publicKey
+      },
+      record_schema: "clude-memory-v3",
+      secretKey,
+      anchor_chain: "solana-mainnet"
+    });
+    printSuccess(
+      `MemoryPack written to ${outputDir}/ (${records.length} records${secretKey ? ", signed" : ", UNSIGNED"})`
+    );
+    if (!secretKey) {
+      console.log(
+        `
+  ${c.dim}No wallet configured \u2014 pack is unsigned. Set CLUDE_WALLET_SECRET to sign.${c.reset}`
+      );
+    }
+    console.log(
+      `
+  ${c.dim}Contents: manifest.json, records.jsonl${secretKey ? ", signatures.jsonl" : ""}${c.reset}`
+    );
+    printDivider();
+    console.log("");
+    return;
   } else {
     defaultName = "clude-memories.json";
     const pack = {
@@ -6374,7 +6830,7 @@ async function runExport() {
     content = JSON.stringify(pack, null, 2);
   }
   const filename = output || defaultName;
-  (0, import_fs3.writeFileSync)(filename, content, "utf-8");
+  (0, import_fs5.writeFileSync)(filename, content, "utf-8");
   printSuccess(`Written to ${filename} (${formatBytes(Buffer.byteLength(content))})`);
   if (format === "chatgpt") {
     console.log(`
@@ -6389,12 +6845,13 @@ async function runExport() {
   printDivider();
   console.log("");
 }
-var import_fs3;
+var import_fs5;
 var init_export = __esm({
   "packages/brain/src/cli/export.ts"() {
     "use strict";
-    import_fs3 = require("fs");
+    import_fs5 = require("fs");
     init_banner();
+    init_memorypack();
   }
 });
 
@@ -6406,9 +6863,35 @@ __export(import_exports, {
 function hasFlag2(args, flag) {
   return args.includes(flag);
 }
+function isMemoryPackDir(path8) {
+  try {
+    return (0, import_fs6.statSync)(path8).isDirectory() && (0, import_fs6.existsSync)((0, import_path6.join)(path8, "manifest.json"));
+  } catch {
+    return false;
+  }
+}
+function parseMemoryPackDir(dir) {
+  const result = readMemoryPack(dir);
+  const signedCount = result.verifiedRecords.size;
+  if (signedCount > 0) {
+    const pubFp = result.manifest.producer.public_key?.slice(0, 8) ?? "?";
+    printInfo(`Verified ${signedCount} record signature(s) against ${pubFp}...`);
+  } else {
+    printInfo("Pack is unsigned (no signatures.jsonl) \u2014 proceeding without verification");
+  }
+  for (const w of result.warnings) printInfo(`warning: ${w}`);
+  return result.records.map((r) => ({
+    content: r.content,
+    summary: r.summary || r.content.slice(0, 200),
+    type: ["episodic", "semantic", "procedural"].includes(r.kind) ? r.kind : "episodic",
+    importance: r.importance,
+    tags: [...r.tags || [], "imported", "memorypack"],
+    source: r.source || "memorypack"
+  }));
+}
 function isZipFile(path8) {
   try {
-    const buf = (0, import_fs4.readFileSync)(path8);
+    const buf = (0, import_fs6.readFileSync)(path8);
     return buf[0] === 80 && buf[1] === 75;
   } catch {
     return false;
@@ -6536,9 +7019,9 @@ function extractFromChatGPTConversations(conversations) {
 async function parseChatGPTZip(filePath) {
   const { execSync: execSync2 } = require("child_process");
   const { mkdtempSync, readdirSync: readdirSync2 } = require("fs");
-  const { join: join8 } = require("path");
+  const { join: join11 } = require("path");
   const os5 = require("os");
-  const tmpDir = mkdtempSync(join8(os5.tmpdir(), "clude-import-"));
+  const tmpDir = mkdtempSync(join11(os5.tmpdir(), "clude-import-"));
   try {
     execSync2(`unzip -o -q "${filePath}" -d "${tmpDir}"`);
   } catch {
@@ -6546,7 +7029,7 @@ async function parseChatGPTZip(filePath) {
     process.exit(1);
   }
   const files = readdirSync2(tmpDir);
-  const convFile = files.find((f) => f === "conversations.json") ? join8(tmpDir, "conversations.json") : null;
+  const convFile = files.find((f) => f === "conversations.json") ? join11(tmpDir, "conversations.json") : null;
   if (!convFile) {
     const { execSync: exec2 } = require("child_process");
     try {
@@ -6555,18 +7038,18 @@ async function parseChatGPTZip(filePath) {
         printError("No conversations.json found in ZIP.");
         process.exit(1);
       }
-      const conversations2 = JSON.parse((0, import_fs4.readFileSync)(found.split("\n")[0], "utf-8"));
+      const conversations2 = JSON.parse((0, import_fs6.readFileSync)(found.split("\n")[0], "utf-8"));
       return extractFromChatGPTConversations(conversations2);
     } catch {
       printError("No conversations.json found in ZIP.");
       process.exit(1);
     }
   }
-  const conversations = JSON.parse((0, import_fs4.readFileSync)(convFile, "utf-8"));
+  const conversations = JSON.parse((0, import_fs6.readFileSync)(convFile, "utf-8"));
   return extractFromChatGPTConversations(conversations);
 }
 function parseMarkdown(filePath) {
-  const content = (0, import_fs4.readFileSync)(filePath, "utf-8");
+  const content = (0, import_fs6.readFileSync)(filePath, "utf-8");
   const memories = [];
   const sections = content.split(/\n#{1,3}\s+|\n\n+/).filter((s) => s.trim().length > 20);
   for (const section of sections) {
@@ -6600,7 +7083,7 @@ function parseMarkdown(filePath) {
   return memories;
 }
 function parseMemoryPack(filePath) {
-  const data = JSON.parse((0, import_fs4.readFileSync)(filePath, "utf-8"));
+  const data = JSON.parse((0, import_fs6.readFileSync)(filePath, "utf-8"));
   if (data.memories && Array.isArray(data.memories)) {
     return data.memories.map((m) => ({
       content: m.content || m.summary || "",
@@ -6684,9 +7167,10 @@ async function runImport() {
   ${c.bold}Usage:${c.reset}  npx @clude/sdk import <file> [options]
 
   ${c.bold}Supported formats:${c.reset}
+    ${c.cyan}pack/${c.reset}                    MemoryPack v0.1 directory (manifest.json + records.jsonl)
     ${c.cyan}chatgpt-export.zip${c.reset}     ChatGPT data export (ZIP with conversations.json)
     ${c.cyan}memories.md${c.reset}             Markdown or text file (paragraphs \u2192 memories)
-    ${c.cyan}pack.json${c.reset}               Clude MemoryPack JSON
+    ${c.cyan}pack.json${c.reset}               Legacy Clude MemoryPack JSON
 
   ${c.bold}Options:${c.reset}
     --dry-run              Show what would be imported without storing
@@ -6702,7 +7186,7 @@ async function runImport() {
   }
   const filePath = args.find((a) => !a.startsWith("--"));
   const dryRun = hasFlag2(args, "--dry-run");
-  if (!(0, import_fs4.existsSync)(filePath)) {
+  if (!(0, import_fs6.existsSync)(filePath)) {
     printError(`File not found: ${filePath}`);
     process.exit(1);
   }
@@ -6730,11 +7214,14 @@ async function runImport() {
   ${c.bold}Import${c.reset}
 `);
   let memories;
-  if (isZipFile(filePath)) {
+  if (isMemoryPackDir(filePath)) {
+    printInfo("Detected: MemoryPack v0.1 directory");
+    memories = parseMemoryPackDir(filePath);
+  } else if (isZipFile(filePath)) {
     printInfo("Detected: ChatGPT data export (ZIP)");
     memories = await parseChatGPTZip(filePath);
   } else if (isJsonFile(filePath)) {
-    printInfo("Detected: MemoryPack JSON");
+    printInfo("Detected: Legacy MemoryPack JSON");
     memories = parseMemoryPack(filePath);
   } else if (isMarkdownOrText(filePath)) {
     printInfo("Detected: Markdown/text file");
@@ -6778,12 +7265,14 @@ async function runImport() {
   printDivider();
   console.log("");
 }
-var import_fs4;
+var import_fs6, import_path6;
 var init_import = __esm({
   "packages/brain/src/cli/import.ts"() {
     "use strict";
-    import_fs4 = require("fs");
+    import_fs6 = require("fs");
+    import_path6 = require("path");
     init_banner();
+    init_memorypack();
   }
 });
 
@@ -6895,7 +7384,7 @@ async function runSync() {
   const refresh = async () => {
     try {
       const content = await generatePrompt(format);
-      (0, import_fs5.writeFileSync)(output, content, "utf-8");
+      (0, import_fs7.writeFileSync)(output, content, "utf-8");
       printSuccess(`Updated ${output} (${content.split(/\s+/).length} words) \u2014 ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`);
     } catch (err) {
       printError(`Refresh failed: ${err.message}`);
@@ -6911,11 +7400,11 @@ async function runSync() {
 `);
   setInterval(refresh, interval * 1e3);
 }
-var import_fs5;
+var import_fs7;
 var init_sync = __esm({
   "packages/brain/src/cli/sync.ts"() {
     "use strict";
-    import_fs5 = require("fs");
+    import_fs7 = require("fs");
     init_banner();
   }
 });

package/dist/mcp/server.js

@@ -2717,7 +2717,7 @@ async function commitMemoryToChain(memoryId, opts) {
   }
   if (!signature) {
     const contentHashHex = contentHashBuf.toString("hex");
-    const memo = `clude-memory | v2 | ${contentHashHex}`;
+    const memo = `clude:v1:sha256:${contentHashHex}`;
     signature = await writeMemo(memo);
   }
   if (!signature) return;

package/dist/sdk/index.js

@@ -2542,7 +2542,7 @@ async function commitMemoryToChain(memoryId, opts) {
   }
   if (!signature) {
     const contentHashHex = contentHashBuf.toString("hex");
-    const memo = `clude-memory | v2 | ${contentHashHex}`;
+    const memo = `clude:v1:sha256:${contentHashHex}`;
     signature = await writeMemo(memo);
   }
   if (!signature) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clude/sdk",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "mcpName": "io.github.sebbsssss/clude",
   "description": "Persistent memory SDK for AI agents — Stanford Generative Agents architecture on Supabase + pgvector",
   "main": "dist/sdk/index.js",