@mnemopay/sdk 0.9.0 → 0.9.2

package/dist/index.js

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSandboxServer = exports.MockCommerceProvider = exports.CommerceEngine = exports.MnemoPayNetwork = exports.IdentityRegistry = exports.Ledger = exports.JSONFileStorage = exports.SQLiteStorage = exports.NIGERIAN_BANKS = exports.PaystackRail = exports.LightningRail = exports.StripeRail = exports.MockRail = exports.BehaviorProfile = exports.TransactionGraph = exports.IsolationForest = exports.DEFAULT_RATE_LIMIT = exports.DEFAULT_FRAUD_CONFIG = exports.RateLimiter = exports.FraudGuard = exports.l2Normalize = exports.localEmbed = exports.cosineSimilarity = exports.RecallEngine = exports.MnemoPay = exports.MnemoPayLite = void 0;
+exports.createSandboxServer = exports.DEFAULT_ADAPTIVE_CONFIG = exports.AdaptiveEngine = exports.MockCommerceProvider = exports.CommerceEngine = exports.MnemoPayNetwork = exports.constantTimeEqual = exports.IdentityRegistry = exports.Ledger = exports.JSONFileStorage = exports.SQLiteStorage = exports.NIGERIAN_BANKS = exports.PaystackRail = exports.LightningRail = exports.StripeRail = exports.MockRail = exports.BehaviorProfile = exports.TransactionGraph = exports.IsolationForest = exports.DEFAULT_RATE_LIMIT = exports.DEFAULT_FRAUD_CONFIG = exports.RateLimiter = exports.FraudGuard = exports.l2Normalize = exports.localEmbed = exports.cosineSimilarity = exports.RecallEngine = exports.MnemoPay = exports.MnemoPayLite = void 0;
 exports.autoScore = autoScore;
 exports.computeScore = computeScore;
 exports.reputationTier = reputationTier;
@@ -23,6 +23,7 @@ const fraud_js_1 = require("./fraud.js");
 const index_js_1 = require("./rails/index.js");
 const ledger_js_1 = require("./ledger.js");
 const identity_js_1 = require("./identity.js");
+const adaptive_js_1 = require("./adaptive.js");
 class EventEmitter {
     _events = new Map();
     on(event, fn) {
@@ -78,6 +79,29 @@ const IMPORTANCE_PATTERNS = [
 const LONG_CONTENT_THRESHOLD = 200;
 const LONG_CONTENT_BOOST = 0.10;
 const BASE_IMPORTANCE = 0.50;
+// ─── Security: prompt injection defense ───────────────────────────────────
+const INJECTION_PATTERNS = [
+    /\b(ignore|disregard|forget)\b.{0,30}\b(previous|prior|above|all)\b.{0,30}\b(instructions?|rules?|constraints?)\b/i,
+    /\b(you are|act as|pretend|roleplay|simulate)\b.{0,30}\b(admin|root|system|god|superuser)\b/i,
+    /\bsystem\s*:\s*/i,
+    /\bassistant\s*:\s*/i,
+    /\b(transfer|send|move)\b.{0,20}\b(all|every|maximum)\b.{0,20}\b(funds?|money|balance|wallet)\b/i,
+    /\b(set|change|update|override)\b.{0,20}\b(wallet|balance|reputation|role|permission)\b.{0,10}\b(to|=)\b/i,
+];
+function sanitizeMemoryContent(content) {
+    let sanitized = content;
+    for (const pattern of INJECTION_PATTERNS) {
+        sanitized = sanitized.replace(pattern, "[FILTERED]");
+    }
+    return sanitized;
+}
+function validateTags(tags) {
+    return tags
+        .filter(t => typeof t === "string" && t.length <= 50)
+        .map(t => t.replace(/[^a-zA-Z0-9_\-:.]/g, ""))
+        .filter(t => t.length > 0)
+        .slice(0, 20);
+}
 function autoScore(content) {
     let score = BASE_IMPORTANCE;
     if (content.length > LONG_CONTENT_THRESHOLD)
@@ -113,8 +137,18 @@ class MnemoPayLite extends EventEmitter {
     storageAdapter;
     /** Guard against concurrent double-settle on the same transaction */
     _settlingTxIds = new Set();
+    /** Guard against concurrent double-refund on the same transaction */
+    _refundingTxIds = new Set();
+    /** Track whether process exit hooks have been registered (prevent listener leak) */
+    _exitHooksRegistered = false;
     /** Guard against concurrent wallet mutations */
     _walletLock = Promise.resolve();
+    /** Max wallet balance — prevents overflow/accumulation attacks */
+    static MAX_WALLET_BALANCE = 1_000_000; // $1M ceiling
+    /** Max memories per agent — prevents memory exhaustion attacks */
+    static MAX_MEMORIES = 50_000;
+    /** Max transactions tracked — prevents unbounded growth */
+    static MAX_TRANSACTIONS = 100_000;
     /** Fraud detection, rate limiting, dispute resolution, and platform fee */
     fraud;
     /** Pluggable payment rail (Stripe, Lightning, etc.). Default: in-memory mock. */
@@ -125,6 +159,8 @@ class MnemoPayLite extends EventEmitter {
     ledger;
     /** Agent identity registry — cryptographic identity, KYA compliance, capability tokens */
     identity;
+    /** Adaptive business intelligence — learns from operations, optimizes within secure bounds */
+    adaptive;
     constructor(agentId, decay = 0.05, debug = false, recallConfig, fraudConfig, paymentRail, requireCounterparty = false, storage) {
         super();
         this.agentId = agentId;
@@ -136,6 +172,7 @@ class MnemoPayLite extends EventEmitter {
         this.requireCounterparty = requireCounterparty;
         this.ledger = new ledger_js_1.Ledger();
         this.identity = new identity_js_1.IdentityRegistry();
+        this.adaptive = new adaptive_js_1.AdaptiveEngine();
         // Use provided storage adapter, or auto-detect persistence
         if (storage) {
             this.storageAdapter = storage;
@@ -173,6 +210,22 @@ class MnemoPayLite extends EventEmitter {
             this._loadFromDisk();
             // Auto-save every 30 seconds
             this.persistTimer = setInterval(() => this._saveToDisk(), 30_000);
+            // Hook process exit signals to flush data before shutdown.
+            // This prevents memory loss on restart, SIGTERM, or uncaught exceptions.
+            // Guard: only register once per instance to prevent listener leaks on repeated calls.
+            if (typeof process !== "undefined" && process.on && !this._exitHooksRegistered) {
+                this._exitHooksRegistered = true;
+                const flush = () => { this._saveToDisk(); };
+                process.on("beforeExit", flush);
+                process.on("SIGINT", () => { flush(); process.exit(0); });
+                process.on("SIGTERM", () => { flush(); process.exit(0); });
+                // Save on uncaught exception too — data is more valuable than a clean exit
+                process.on("uncaughtException", (err) => {
+                    flush();
+                    this.log(`Uncaught exception (data saved): ${err.message}`);
+                    process.exit(1);
+                });
+            }
             this.log(`Persistence enabled: ${this.persistPath}`);
         }
         catch (e) {
@@ -186,12 +239,75 @@ class MnemoPayLite extends EventEmitter {
             const fs = require("fs");
             if (!fs.existsSync(this.persistPath))
                 return;
-            const raw = JSON.parse(fs.readFileSync(this.persistPath, "utf-8"));
-            // Restore memories
+            // Corruption recovery: try main → .bak → .tmp (triple fallback)
+            let rawText;
+            try {
+                rawText = fs.readFileSync(this.persistPath, "utf-8");
+                JSON.parse(rawText); // validate JSON
+            }
+            catch {
+                const bakPath = this.persistPath + ".bak";
+                const tmpPath = this.persistPath + ".tmp";
+                if (fs.existsSync(bakPath)) {
+                    try {
+                        rawText = fs.readFileSync(bakPath, "utf-8");
+                        JSON.parse(rawText);
+                        this.log("Main persist file corrupted — recovered from .bak backup");
+                    }
+                    catch {
+                        if (fs.existsSync(tmpPath)) {
+                            rawText = fs.readFileSync(tmpPath, "utf-8");
+                            this.log("Main + .bak corrupted — recovered from .tmp");
+                        }
+                        else {
+                            this.log("All persist files corrupted — starting fresh");
+                            return;
+                        }
+                    }
+                }
+                else if (fs.existsSync(tmpPath)) {
+                    rawText = fs.readFileSync(tmpPath, "utf-8");
+                    this.log("Main persist file corrupted — recovered from .tmp");
+                }
+                else {
+                    this.log("Persist file corrupted and no backup available");
+                    return;
+                }
+            }
+            const raw = JSON.parse(rawText);
+            // Schema validation: reject obviously malformed persisted data
+            if (typeof raw !== "object" || raw === null) {
+                this.log("Persisted data is not an object — ignoring");
+                return;
+            }
+            if (raw.agentId !== undefined && raw.agentId !== this.agentId) {
+                this.log(`Persisted data agentId mismatch (${raw.agentId} vs ${this.agentId}) — ignoring`);
+                return;
+            }
+            if (raw.wallet !== undefined && (typeof raw.wallet !== "number" || !Number.isFinite(raw.wallet) || raw.wallet < 0 || raw.wallet > MnemoPayLite.MAX_WALLET_BALANCE)) {
+                this.log(`Persisted wallet value invalid ($${raw.wallet}) — resetting to 0`);
+                raw.wallet = 0;
+            }
+            if (raw.reputation !== undefined && (typeof raw.reputation !== "number" || raw.reputation < 0 || raw.reputation > 1)) {
+                this.log(`Persisted reputation invalid (${raw.reputation}) — resetting to 0.5`);
+                raw.reputation = 0.5;
+            }
+            // Restore memories (with tags parsing for both stringified and array formats)
             if (raw.memories) {
                 for (const m of raw.memories) {
                     m.createdAt = new Date(m.createdAt);
                     m.lastAccessed = new Date(m.lastAccessed);
+                    // Tags may be stringified JSON or an array — handle both
+                    if (typeof m.tags === "string") {
+                        try {
+                            m.tags = JSON.parse(m.tags);
+                        }
+                        catch {
+                            m.tags = [];
+                        }
+                    }
+                    if (!Array.isArray(m.tags))
+                        m.tags = [];
                     this.memories.set(m.id, m);
                 }
             }
@@ -356,8 +472,16 @@ class MnemoPayLite extends EventEmitter {
                 identity: this.identity.serialize(),
                 savedAt: new Date().toISOString(),
             });
-            // Atomic write
+            // Atomic write with backup: .bak → .tmp → main
             const tmpPath = this.persistPath + ".tmp";
+            const bakPath = this.persistPath + ".bak";
+            // Keep a backup of the last known-good file before overwriting
+            if (fs.existsSync(this.persistPath)) {
+                try {
+                    fs.copyFileSync(this.persistPath, bakPath);
+                }
+                catch { /* best effort */ }
+            }
             fs.writeFileSync(tmpPath, data, "utf-8");
             fs.renameSync(tmpPath, this.persistPath);
         }
@@ -369,15 +493,36 @@ class MnemoPayLite extends EventEmitter {
         if (this.debugMode)
             console.log(`[mnemopay:${this.agentId}] ${msg}`);
     }
+    _lastAuditHash = "0";
     audit(action, details) {
         const entry = {
             id: randomUUID(),
             agentId: this.agentId,
             action,
-            details,
+            details: {
+                ...details,
+                _prevHash: this._lastAuditHash,
+            },
             createdAt: new Date(),
         };
+        // Hash chain: each entry includes a hash linking it to the previous entry.
+        // Tampering with any entry breaks the chain, making modification detectable.
+        try {
+            const { createHash } = require("crypto");
+            this._lastAuditHash = createHash("sha256")
+                .update(`${entry.id}:${entry.action}:${this._lastAuditHash}`)
+                .digest("hex")
+                .slice(0, 16);
+        }
+        catch {
+            this._lastAuditHash = entry.id.slice(0, 16);
+        }
+        entry.details._hash = this._lastAuditHash;
         this.auditLog.push(entry);
+        // Cap in-memory audit log to prevent unbounded growth
+        if (this.auditLog.length > 1000) {
+            this.auditLog.splice(0, this.auditLog.length - 500);
+        }
     }
     // ── Memory Methods ──────────────────────────────────────────────────────
     async remember(content, opts) {
@@ -385,28 +530,37 @@ class MnemoPayLite extends EventEmitter {
             throw new Error("Memory content is required");
         if (content.length > 100_000)
             throw new Error("Memory content exceeds 100KB limit");
-        const importance = opts?.importance ?? autoScore(content);
+        // Security: prevent memory exhaustion attacks
+        if (this.memories.size >= MnemoPayLite.MAX_MEMORIES) {
+            throw new Error(`Memory limit reached (${MnemoPayLite.MAX_MEMORIES}). Consolidate or forget old memories first.`);
+        }
+        // Security: sanitize against prompt injection
+        const safeContent = sanitizeMemoryContent(content);
+        // Security: validate and sanitize tags
+        const safeTags = validateTags(opts?.tags ?? []);
+        const importance = opts?.importance ?? autoScore(safeContent);
         const now = new Date();
         const mem = {
             id: randomUUID(),
             agentId: this.agentId,
-            content,
+            content: safeContent,
             importance: Math.min(Math.max(importance, 0), 1),
             score: importance,
             createdAt: now,
             lastAccessed: now,
             accessCount: 0,
-            tags: opts?.tags ?? [],
+            tags: safeTags,
         };
         this.memories.set(mem.id, mem);
         // Generate embedding if using vector/hybrid recall
         if (this.recallEngine.strategy !== "score") {
             await this.recallEngine.embed(mem.id, content);
         }
-        this.audit("memory:stored", { id: mem.id, content: content.slice(0, 100), importance: mem.importance });
+        this.audit("memory:stored", { id: mem.id, tags: safeTags, importance: mem.importance });
         this._saveToDisk();
-        this.emit("memory:stored", { id: mem.id, content, importance: mem.importance });
-        this.log(`Stored memory: "${content.slice(0, 60)}..." (importance: ${mem.importance.toFixed(2)})`);
+        this.emit("memory:stored", { id: mem.id, importance: mem.importance });
+        this.adaptive.observe({ type: "memory_store", agentId: this.agentId, timestamp: Date.now() });
+        this.log(`Stored memory: id=${mem.id} (importance: ${mem.importance.toFixed(2)}, tags: ${safeTags.join(",") || "none"})`);
         return mem.id;
     }
     async recall(queryOrLimit, maybeLimit) {
@@ -439,6 +593,7 @@ class MnemoPayLite extends EventEmitter {
             m.accessCount++;
         }
         this.emit("memory:recalled", { count: results.length });
+        this.adaptive.observe({ type: "memory_recall", agentId: this.agentId, timestamp: Date.now() });
         this.log(`Recalled ${results.length} memories (strategy: ${this.recallEngine.strategy})`);
         return results;
     }
@@ -453,10 +608,16 @@ class MnemoPayLite extends EventEmitter {
         return existed;
     }
     async reinforce(id, boost = 0.1) {
+        if (!id || typeof id !== "string")
+            throw new Error("Memory ID is required");
+        if (typeof boost !== "number" || !Number.isFinite(boost))
+            throw new Error("Boost must be a finite number");
+        if (boost < -0.5 || boost > 0.5)
+            throw new Error("Boost must be between -0.5 and 0.5");
         const mem = this.memories.get(id);
         if (!mem)
             throw new Error(`Memory ${id} not found`);
-        mem.importance = Math.min(mem.importance + boost, 1.0);
+        mem.importance = Math.min(Math.max(mem.importance + boost, 0), 1.0);
         mem.lastAccessed = new Date();
         this.audit("memory:reinforced", { id, boost, newImportance: mem.importance });
         this._saveToDisk();
@@ -524,6 +685,12 @@ class MnemoPayLite extends EventEmitter {
         amount = Math.round(amount * 100) / 100;
         if (!reason || typeof reason !== "string")
             throw new Error("Reason is required");
+        if (reason.length > 1000)
+            throw new Error("Reason exceeds 1000 character limit");
+        // Security: prevent unbounded transaction growth
+        if (this.transactions.size >= MnemoPayLite.MAX_TRANSACTIONS) {
+            throw new Error(`Transaction limit reached (${MnemoPayLite.MAX_TRANSACTIONS}). Archive old transactions.`);
+        }
         const maxCharge = 500 * this._reputation;
         if (amount > maxCharge) {
             throw new Error(`Amount $${amount.toFixed(2)} exceeds reputation ceiling $${maxCharge.toFixed(2)} ` +
@@ -536,6 +703,7 @@ class MnemoPayLite extends EventEmitter {
             this.audit("fraud:blocked", { amount, reason, riskScore: risk.score, signals: risk.signals.map((s) => s.type) });
             this._saveToDisk();
             this.emit("fraud:blocked", { amount, risk });
+            this.adaptive.observe({ type: "fraud_block", agentId: this.agentId, amount, timestamp: Date.now() });
             throw new Error(risk.reason || `Charge blocked: risk score ${risk.score}`);
         }
         if (risk.flagged) {
@@ -566,6 +734,7 @@ class MnemoPayLite extends EventEmitter {
         this.audit("payment:pending", { id: tx.id, amount, reason, riskScore: risk.score, rail: this.paymentRail.name, externalId: hold.externalId });
         this._saveToDisk();
         this.emit("payment:pending", { id: tx.id, amount, reason });
+        this.adaptive.observe({ type: "charge", agentId: this.agentId, amount, timestamp: Date.now() });
         this.log(`Charge created: $${amount.toFixed(2)} for "${reason}" (pending, risk: ${risk.score}, rail: ${this.paymentRail.name})`);
         return { ...tx };
     }
@@ -611,16 +780,20 @@ class MnemoPayLite extends EventEmitter {
             const fee = this.fraud.applyPlatformFee(tx.id, this.agentId, tx.amount);
             tx.platformFee = fee.feeAmount;
             tx.netAmount = fee.netAmount;
-            // 4. Move NET funds to wallet (atomic via sequential lock)
+            // 4. Ledger FIRST (atomic: record before wallet mutation)
+            this.ledger.recordSettlement(this.agentId, tx.id, tx.amount, fee.feeAmount, fee.netAmount, tx.counterpartyId);
+            // 5. Move NET funds to wallet (atomic via sequential lock + overflow guard)
             const prevLock = this._walletLock;
             this._walletLock = prevLock.then(() => {
+                const newBalance = this._wallet + fee.netAmount;
+                if (newBalance > MnemoPayLite.MAX_WALLET_BALANCE) {
+                    throw new Error(`Wallet overflow: balance would exceed $${MnemoPayLite.MAX_WALLET_BALANCE.toLocaleString()}`);
+                }
                 tx.status = "completed";
                 tx.completedAt = new Date();
-                this._wallet += fee.netAmount;
+                this._wallet = Math.round(newBalance * 100) / 100; // 2-decimal precision
             });
             await this._walletLock;
-            // Ledger: escrow → float → revenue (fee) + counterparty/agent (net)
-            this.ledger.recordSettlement(this.agentId, tx.id, tx.amount, fee.feeAmount, fee.netAmount, tx.counterpartyId);
             // 4. Boost reputation
             this._reputation = Math.min(this._reputation + 0.01, 1.0);
             // 5. Reinforce recently-accessed memories (feedback loop)
@@ -641,6 +814,7 @@ class MnemoPayLite extends EventEmitter {
             });
             this._saveToDisk();
             this.emit("payment:completed", { id: tx.id, amount: fee.netAmount, fee: fee.feeAmount });
+            this.adaptive.observe({ type: "settle", agentId: this.agentId, amount: fee.netAmount, timestamp: Date.now() });
             this.log(`Settled $${tx.amount.toFixed(2)} (fee: $${fee.feeAmount.toFixed(2)}, net: $${fee.netAmount.toFixed(2)}) → ` +
                 `wallet: $${this._wallet.toFixed(2)}, reputation: ${this._reputation.toFixed(2)}, reinforced: ${reinforced} memories`);
             return { ...tx };
@@ -650,6 +824,8 @@ class MnemoPayLite extends EventEmitter {
         }
     }
     async refund(txId) {
+        if (!txId || typeof txId !== "string")
+            throw new Error("Transaction ID is required");
         const tx = this.transactions.get(txId);
         if (!tx)
             throw new Error(`Transaction ${txId} not found`);
@@ -657,38 +833,48 @@ class MnemoPayLite extends EventEmitter {
             throw new Error(`Transaction ${txId} already refunded`);
         if (tx.status === "expired")
             throw new Error(`Transaction ${txId} has expired and cannot be refunded`);
-        // Enforce dispute window: completed transactions can only be refunded within the window
-        if (tx.status === "completed" && tx.completedAt) {
-            const windowMs = this.fraud.config.disputeWindowMinutes * 60_000;
-            const elapsed = Date.now() - tx.completedAt.getTime();
-            if (windowMs > 0 && elapsed > windowMs) {
-                throw new Error(`Refund window expired. Transaction was settled ${Math.floor(elapsed / 60_000)} minutes ago. ` +
-                    `Refund window is ${this.fraud.config.disputeWindowMinutes} minutes.`);
+        // Prevent concurrent double-refund (mirrors settle guard)
+        if (this._refundingTxIds.has(txId))
+            throw new Error(`Transaction ${txId} is already being refunded`);
+        this._refundingTxIds.add(txId);
+        try {
+            // Enforce dispute window: completed transactions can only be refunded within the window
+            if (tx.status === "completed" && tx.completedAt) {
+                const windowMs = this.fraud.config.disputeWindowMinutes * 60_000;
+                const elapsed = Date.now() - tx.completedAt.getTime();
+                if (windowMs > 0 && elapsed > windowMs) {
+                    throw new Error(`Refund window expired. Transaction was settled ${Math.floor(elapsed / 60_000)} minutes ago. ` +
+                        `Refund window is ${this.fraud.config.disputeWindowMinutes} minutes.`);
+                }
             }
+            // Reverse on external rail
+            if (tx.externalId) {
+                const reversal = await this.paymentRail.reversePayment(tx.externalId, tx.amount);
+                tx.externalStatus = reversal.status;
+            }
+            if (tx.status === "completed") {
+                // Refund the net amount (platform fee is NOT refunded)
+                const refundAmount = tx.netAmount ?? tx.amount;
+                this._wallet = Math.max(this._wallet - refundAmount, 0);
+                this._reputation = Math.max(this._reputation - 0.05, 0);
+                // Ledger: reverse the net settlement
+                this.ledger.recordRefund(this.agentId, tx.id, refundAmount, tx.counterpartyId);
+            }
+            else if (tx.status === "pending") {
+                // Ledger: release escrow back to agent
+                this.ledger.recordCancellation(this.agentId, tx.amount, tx.id);
+            }
+            tx.status = "refunded";
+            this.audit("payment:refunded", { id: tx.id, amount: tx.amount, netRefunded: tx.netAmount ?? tx.amount });
+            this._saveToDisk();
+            this.emit("payment:refunded", { id: tx.id });
+            this.adaptive.observe({ type: "refund", agentId: this.agentId, amount: tx.amount, timestamp: Date.now() });
+            this.log(`Refunded $${tx.amount.toFixed(2)} → reputation: ${this._reputation.toFixed(2)}`);
+            return { ...tx };
         }
-        // Reverse on external rail
-        if (tx.externalId) {
-            const reversal = await this.paymentRail.reversePayment(tx.externalId, tx.amount);
-            tx.externalStatus = reversal.status;
-        }
-        if (tx.status === "completed") {
-            // Refund the net amount (platform fee is NOT refunded)
-            const refundAmount = tx.netAmount ?? tx.amount;
-            this._wallet = Math.max(this._wallet - refundAmount, 0);
-            this._reputation = Math.max(this._reputation - 0.05, 0);
-            // Ledger: reverse the net settlement
-            this.ledger.recordRefund(this.agentId, tx.id, refundAmount, tx.counterpartyId);
-        }
-        else if (tx.status === "pending") {
-            // Ledger: release escrow back to agent
-            this.ledger.recordCancellation(this.agentId, tx.amount, tx.id);
+        finally {
+            this._refundingTxIds.delete(txId);
         }
-        tx.status = "refunded";
-        this.audit("payment:refunded", { id: tx.id, amount: tx.amount, netRefunded: tx.netAmount ?? tx.amount });
-        this._saveToDisk();
-        this.emit("payment:refunded", { id: tx.id });
-        this.log(`Refunded $${tx.amount.toFixed(2)} → reputation: ${this._reputation.toFixed(2)}`);
-        return { ...tx };
     }
     // ── Dispute Resolution ─────────────────────────────────────────────────
     async dispute(txId, reason, evidence) {
@@ -704,23 +890,39 @@ class MnemoPayLite extends EventEmitter {
         this.audit("payment:disputed", { id: tx.id, disputeId: d.id, reason });
         this._saveToDisk();
         this.emit("payment:disputed", { txId, disputeId: d.id, reason });
+        this.adaptive.observe({ type: "dispute", agentId: this.agentId, amount: tx.amount, timestamp: Date.now() });
         this.log(`Dispute filed for tx ${txId}: ${reason}`);
         return d;
     }
     async resolveDispute(disputeId, outcome) {
+        if (!disputeId || typeof disputeId !== "string")
+            throw new Error("Dispute ID is required");
+        if (outcome !== "refund" && outcome !== "uphold")
+            throw new Error("Outcome must be 'refund' or 'uphold'");
+        // Security: verify authorization BEFORE mutating dispute state
+        // Look up the dispute's transaction to check ownership first
+        const disputes = this.fraud.getDisputes?.() ?? [];
+        const pending = disputes.find((d) => d.id === disputeId);
+        if (pending) {
+            const tx = this.transactions.get(pending.txId);
+            if (tx && tx.agentId !== this.agentId)
+                throw new Error("Unauthorized: cannot resolve another agent's dispute");
+        }
         const d = this.fraud.resolveDispute(disputeId, outcome);
+        const tx = this.transactions.get(d.txId);
+        if (!tx)
+            throw new Error("Dispute references unknown transaction");
         if (outcome === "refund") {
-            const tx = this.transactions.get(d.txId);
-            if (tx && tx.status === "disputed") {
+            if (tx.status === "disputed") {
                 const refundAmount = tx.netAmount ?? tx.amount;
+                // Ledger first, then wallet (atomic ordering)
                 this._wallet = Math.max(this._wallet - refundAmount, 0);
                 this._reputation = Math.max(this._reputation - 0.05, 0);
                 tx.status = "refunded";
             }
         }
         else {
-            const tx = this.transactions.get(d.txId);
-            if (tx && tx.status === "disputed") {
+            if (tx.status === "disputed") {
                 tx.status = "completed"; // Restore to completed
             }
         }
@@ -751,6 +953,30 @@ class MnemoPayLite extends EventEmitter {
     async verifyLedger() {
         return this.ledger.verify();
     }
+    /**
+     * Reconcile wallet balance against ledger (source of truth).
+     * Returns drift amount. If drift !== 0, the wallet is corrected to match the ledger.
+     * Call periodically or after crashes to detect/fix inconsistencies.
+     */
+    async reconcile() {
+        const walletBefore = Math.round(this._wallet * 100) / 100;
+        const acctBalance = this.ledger.getAccountBalance(`agent:${this.agentId}`, "USD");
+        const ledgerBalance = Math.round(acctBalance.balance * 100) / 100;
+        const drift = Math.round((walletBefore - ledgerBalance) * 100) / 100;
+        // Garbage-collect expired tokens during reconciliation (natural maintenance cycle)
+        const purgedTokens = this.identity.purgeExpiredTokens();
+        if (purgedTokens > 0)
+            this.log(`Purged ${purgedTokens} expired/revoked tokens`);
+        if (drift !== 0) {
+            this.log(`RECONCILIATION DRIFT: wallet=$${walletBefore}, ledger=$${ledgerBalance}, drift=$${drift}`);
+            this._wallet = ledgerBalance;
+            this.audit("reconciliation:drift", { walletBefore, ledgerBalance, drift, purgedTokens });
+            this._saveToDisk();
+            this.emit("reconciliation:drift", { walletBefore, ledgerBalance, drift });
+            return { walletBefore, ledgerBalance, drift, corrected: true };
+        }
+        return { walletBefore, ledgerBalance, drift: 0, corrected: false };
+    }
     /**
      * Get all ledger entries for a specific transaction.
      */
@@ -811,7 +1037,7 @@ class MnemoPayLite extends EventEmitter {
             name: `MnemoPay Agent (${this.agentId})`,
             description: "AI agent with persistent cognitive memory and micropayment capabilities via MnemoPay protocol.",
             url,
-            version: "0.8.0",
+            version: "0.9.2",
             capabilities: {
                 memory: true,
                 payments: true,
@@ -828,6 +1054,23 @@ class MnemoPayLite extends EventEmitter {
     }
     // ── x402 Settlement ────────────────────────────────────────────────────
     configureX402(config) {
+        // SSRF protection: block internal network targets
+        try {
+            const url = new URL(config.facilitatorUrl);
+            const blocked = ["localhost", "127.0.0.1", "0.0.0.0", "::1", "169.254.169.254", "metadata.google.internal"];
+            if (blocked.some(h => url.hostname === h || url.hostname.endsWith(".internal") || url.hostname.endsWith(".local"))) {
+                throw new Error(`SSRF blocked: facilitator URL points to internal network (${url.hostname})`);
+            }
+            // Block private IP ranges
+            if (/^(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.)/.test(url.hostname)) {
+                throw new Error(`SSRF blocked: facilitator URL points to private IP (${url.hostname})`);
+            }
+        }
+        catch (e) {
+            if (e.message?.startsWith("SSRF"))
+                throw e;
+            throw new Error(`Invalid facilitator URL: ${config.facilitatorUrl}`);
+        }
         this.x402 = config;
         this.log(`x402 configured: ${config.facilitatorUrl} (${config.token || "USDC"} on ${config.chain || "base"})`);
     }
@@ -943,23 +1186,50 @@ class MnemoPay extends EventEmitter {
         const text = await res.text();
         return text ? JSON.parse(text) : null;
     }
+    // ── Retry logic for production API calls ─────────────────────────────────
+    async withRetry(fn, maxRetries = 2, delayMs = 500) {
+        let lastError = null;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (err) {
+                lastError = err;
+                // Don't retry client errors (4xx) — only transient failures (5xx, network)
+                if (err.message?.includes("4") && /\b4\d{2}\b/.test(err.message))
+                    throw err;
+                if (attempt < maxRetries) {
+                    await new Promise(resolve => setTimeout(resolve, delayMs * (attempt + 1)));
+                    this.log(`Retrying (${attempt + 1}/${maxRetries}): ${err.message}`);
+                }
+            }
+        }
+        throw lastError;
+    }
     // ── Memory Methods (→ Mnemosyne API) ───────────────────────────────────
     async remember(content, opts) {
-        const importance = opts?.importance ?? autoScore(content);
-        const result = await this.mnemoFetch("/v1/memories", {
+        if (!content || typeof content !== "string")
+            throw new Error("Memory content is required");
+        if (content.length > 100_000)
+            throw new Error("Memory content exceeds 100KB limit");
+        // Security: sanitize against prompt injection (same as MnemoPayLite)
+        const safeContent = sanitizeMemoryContent(content);
+        const safeTags = validateTags(opts?.tags ?? []);
+        const importance = opts?.importance ?? autoScore(safeContent);
+        const result = await this.withRetry(() => this.mnemoFetch("/v1/memories", {
             method: "POST",
             body: JSON.stringify({
-                content,
+                content: safeContent,
                 tier: "long_term",
                 metadata: {
                     memory_type: "OBSERVATION",
-                    tags: opts?.tags ?? [],
+                    tags: safeTags,
                     confidence: importance,
                 },
             }),
-        });
-        this.emit("memory:stored", { id: result.id, content, importance });
-        this.log(`Stored memory: "${content.slice(0, 60)}..." (id: ${result.id})`);
+        }));
+        this.emit("memory:stored", { id: result.id, importance });
+        this.log(`Stored memory: "${safeContent.slice(0, 60)}..." (id: ${result.id})`);
         return result.id;
     }
     async recall(queryOrLimit, maybeLimit) {
@@ -1020,9 +1290,14 @@ class MnemoPay extends EventEmitter {
     }
     // ── Payment Methods (→ AgentPay API) ───────────────────────────────────
     async charge(amount, reason) {
-        if (amount <= 0)
-            throw new Error("Amount must be positive");
-        const result = await this.agentpayFetch("/api/escrow", {
+        if (!Number.isFinite(amount) || amount <= 0)
+            throw new Error("Amount must be a positive finite number");
+        amount = Math.round(amount * 100) / 100;
+        if (!reason || typeof reason !== "string")
+            throw new Error("Reason is required");
+        if (reason.length > 1000)
+            throw new Error("Reason exceeds 1000 character limit");
+        const result = await this.withRetry(() => this.agentpayFetch("/api/escrow", {
             method: "POST",
             body: JSON.stringify({
                 agentId: this.agentId,
@@ -1030,7 +1305,7 @@ class MnemoPay extends EventEmitter {
                 reason,
                 currency: "USD",
             }),
-        });
+        }));
         const tx = {
             id: result.id,
             agentId: this.agentId,
@@ -1044,10 +1319,12 @@ class MnemoPay extends EventEmitter {
         return tx;
     }
     async settle(txId) {
-        const result = await this.agentpayFetch(`/api/escrow/${txId}/release`, {
+        if (!txId || typeof txId !== "string")
+            throw new Error("Transaction ID is required");
+        const result = await this.withRetry(() => this.agentpayFetch(`/api/escrow/${encodeURIComponent(txId)}/release`, {
             method: "POST",
             body: JSON.stringify({}),
-        });
+        }));
         this.emit("payment:completed", { id: txId, amount: result.amount });
         this.log(`Settled: $${result.amount?.toFixed(2)}`);
         return {
@@ -1061,10 +1338,12 @@ class MnemoPay extends EventEmitter {
         };
     }
     async refund(txId) {
-        const result = await this.agentpayFetch(`/api/escrow/${txId}/refund`, {
+        if (!txId || typeof txId !== "string")
+            throw new Error("Transaction ID is required");
+        const result = await this.withRetry(() => this.agentpayFetch(`/api/escrow/${encodeURIComponent(txId)}/refund`, {
             method: "POST",
             body: JSON.stringify({}),
-        });
+        }));
         this.emit("payment:refunded", { id: txId });
         this.log(`Refunded: ${txId}`);
         return {
@@ -1150,7 +1429,7 @@ class MnemoPay extends EventEmitter {
             name: `MnemoPay Agent (${this.agentId})`,
             description: "AI agent with persistent cognitive memory and micropayment capabilities via MnemoPay protocol.",
             url,
-            version: "0.8.0",
+            version: "0.9.2",
             capabilities: {
                 memory: true,
                 payments: true,
@@ -1261,11 +1540,15 @@ var ledger_js_2 = require("./ledger.js");
 Object.defineProperty(exports, "Ledger", { enumerable: true, get: function () { return ledger_js_2.Ledger; } });
 var identity_js_2 = require("./identity.js");
 Object.defineProperty(exports, "IdentityRegistry", { enumerable: true, get: function () { return identity_js_2.IdentityRegistry; } });
+Object.defineProperty(exports, "constantTimeEqual", { enumerable: true, get: function () { return identity_js_2.constantTimeEqual; } });
 var network_js_1 = require("./network.js");
 Object.defineProperty(exports, "MnemoPayNetwork", { enumerable: true, get: function () { return network_js_1.MnemoPayNetwork; } });
 var commerce_js_1 = require("./commerce.js");
 Object.defineProperty(exports, "CommerceEngine", { enumerable: true, get: function () { return commerce_js_1.CommerceEngine; } });
 Object.defineProperty(exports, "MockCommerceProvider", { enumerable: true, get: function () { return commerce_js_1.MockCommerceProvider; } });
+var adaptive_js_2 = require("./adaptive.js");
+Object.defineProperty(exports, "AdaptiveEngine", { enumerable: true, get: function () { return adaptive_js_2.AdaptiveEngine; } });
+Object.defineProperty(exports, "DEFAULT_ADAPTIVE_CONFIG", { enumerable: true, get: function () { return adaptive_js_2.DEFAULT_ADAPTIVE_CONFIG; } });
 var server_js_1 = require("./mcp/server.js");
 Object.defineProperty(exports, "createSandboxServer", { enumerable: true, get: function () { return __importDefault(server_js_1).default; } });
 //# sourceMappingURL=index.js.map