nanosolana 0.1.0

package/README.md

@@ -0,0 +1,163 @@
+<div align="center">
+
+```
+    ███╗   ██╗ █████╗ ███╗   ██╗ ██████╗ ███████╗ ██████╗ ██╗      █████╗ ███╗   ██╗ █████╗
+    ████╗  ██║██╔══██╗████╗  ██║██╔═══██╗██╔════╝██╔═══██╗██║     ██╔══██╗████╗  ██║██╔══██╗
+    ██╔██╗ ██║███████║██╔██╗ ██║██║   ██║███████╗██║   ██║██║     ███████║██╔██╗ ██║███████║
+    ██║╚██╗██║██╔══██║██║╚██╗██║██║   ██║╚════██║██║   ██║██║     ██╔══██║██║╚██╗██║██╔══██║
+    ██║ ╚████║██║  ██║██║ ╚████║╚██████╔╝███████║╚██████╔╝███████╗██║  ██║██║ ╚████║██║  ██║
+    ╚═╝  ╚═══╝╚═╝  ╚═╝╚═╝  ╚═══╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝
+```
+
+**The Open-Source Agentic Framework for Financial Intelligence on Solana**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-14F195.svg)](LICENSE)
+[![Solana](https://img.shields.io/badge/Solana-Native-9945FF.svg)](https://solana.com)
+[![npm](https://img.shields.io/npm/v/nanosolana?color=14F195)](https://npmjs.com/package/nanosolana)
+
+[Website](https://nanosolana.com) · [Hub](https://hub.nanosolana.com) · [Docs](https://docs.nanosolana.com) · [GitHub](https://github.com/x402agent/NanoSolana)
+
+</div>
+
+## One-Shot Deploy
+
+```bash
+npx nanosolana go
+```
+
+That's it — one command handles API key setup, wallet creation, blockchain scan, on-chain NFT identity, OODA trading loop, and gateway.
+
+## Install
+
+```bash
+npm install -g nanosolana
+```
+
+Or step-by-step:
+
+```bash
+nanosolana init      # Configure API keys (encrypted at rest)
+nanosolana birth     # Create Solana wallet + mint Birth Certificate NFT + blockchain scan
+nanosolana run       # Start the OODA trading loop
+```
+
+## Architecture
+
+```
+nano-core/
+├── src/
+│   ├── ai/          → OpenRouter AI provider (multimodal: text, image, audio, video)
+│   ├── cli/         → `nanosolana` CLI (25+ commands)
+│   ├── config/      → AES-256-GCM encrypted vault & Zod-validated config
+│   ├── gateway/     → HMAC-SHA256 authenticated WebSocket + HTTP server
+│   ├── hub/         → NanoHub bridge for UI communication
+│   ├── memory/      → ClawVault 3-tier epistemological memory engine
+│   ├── network/     → Tailscale + tmux mesh networking
+│   ├── nft/         → Metaplex gasless devnet birth certificate NFT
+│   ├── onchain/     → Helius blockchain reader (DAS, Enhanced Tx, wallet scan)
+│   ├── registry/    → On-chain agent identity (Metaplex NFT registration)
+│   ├── nanobot/     → Interactive local web UI companion
+│   ├── pet/         → TamaGOchi virtual pet engine (mood × risk)
+│   ├── strategy/    → RSI + EMA + ATR auto-optimizer
+│   ├── telegram/    → Persistent conversation store (200 msg/chat)
+│   ├── trading/     → OODA trading engine + Jupiter swap execution
+│   └── wallet/      → Solana Ed25519 wallet manager
+├── SOUL.md          → Agent identity system prompt
+└── extensions/      → 14+ plugins (Telegram, Discord, Nostr, etc.)
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `nanosolana go` | **One-shot: init + birth + scan + register + trade** |
+| `nanosolana init` | Configure + encrypt API keys |
+| `nanosolana birth` | Create wallet + mint Birth Certificate NFT + blockchain scan |
+| `nanosolana run` | Start OODA trading loop |
+| `nanosolana scan [address]` | **Blockchain data scan — SOL, tokens, NFTs, tx history** |
+| `nanosolana register` | **Mint on-chain agent identity NFT (devnet)** |
+| `nanosolana registry` | **Show on-chain agent identity** |
+| `nanosolana nanobot` | **Launch interactive NanoBot web UI** |
+| `nanosolana dvd` | Floating DVD screensaver 🦞 |
+| `nanosolana lobster` | Animated Unicode lobster mascot |
+| `nanosolana status` | Show agent + wallet + pet status |
+| `nanosolana trade status` | Trading P&L and strategy state |
+| `nanosolana trade signals` | Recent trading signals with confidence |
+| `nanosolana wallet balance` | SOL + SPL token balances |
+| `nanosolana pet status` | TamaGOchi pet mood and evolution |
+| `nanosolana memory search` | Search ClawVault memory |
+| `nanosolana gateway run` | Start WebSocket gateway |
+| `nanosolana channels status` | Check channel connections |
+| `nanosolana vault set <key> <val>` | Store encrypted secret |
+| `nanosolana send <msg>` | One-shot message to nano bots |
+| `nanosolana nodes` | List Tailscale mesh peers |
+| `nanosolana doctor` | Run diagnostics |
+| `nanosolana security audit` | Full security scan |
+
+## Required API Keys
+
+| Key | Source | Required |
+|-----|--------|----------|
+| `OPENROUTER_API_KEY` | [openrouter.ai](https://openrouter.ai) | ✅ |
+| `HELIUS_RPC_URL` | [helius.dev](https://helius.dev) | ✅ |
+| `HELIUS_API_KEY` | [helius.dev](https://helius.dev) | ✅ |
+| `HELIUS_WSS_URL` | [helius.dev](https://helius.dev) | Recommended |
+| `BIRDEYE_API_KEY` | [birdeye.so](https://birdeye.so) | Recommended |
+| `JUPITER_API_KEY` | [jup.ag](https://jup.ag) | For trading |
+
+## Security
+
+- ✅ AES-256-GCM encrypted secrets vault
+- ✅ HMAC-SHA256 gateway authentication
+- ✅ Ed25519 wallet signatures
+- ✅ Timing-safe token comparison
+- ✅ Rate limiting (10 conn/min, 100 msg/min)
+- ✅ File permissions enforced (0600/0700)
+- ✅ Wallet private key never leaves the vault
+
+## Trading Engine (OODA)
+
+1. **Observe** — Real-time data from Helius RPC + Birdeye API
+2. **Orient** — AI analysis via OpenRouter (multimodal)
+3. **Decide** — Structured signals with confidence scoring
+4. **Act** — Jupiter swap execution with slippage protection
+5. **Learn** — ClawVault experience replay + contradiction detection
+
+## Blockchain Intelligence (Helius)
+
+At agent birth, NanoSolana instantly reads the blockchain:
+
+- **DAS API** — tokens, NFTs, compressed assets
+- **Enhanced Transactions** — parsed tx history with descriptions
+- **Priority Fees** — real-time fee estimation
+- **Wallet Snapshot** — SOL balance, token prices, NFT inventory
+
+## On-Chain Identity
+
+Every agent mints a **Metaplex NFT** on devnet as its on-chain identity:
+
+- Agent public key
+- NanoSolana version
+- Registered skills
+- SHA-256 fingerprint
+
+## TamaGOchi Pet
+
+🥚 Egg → 🐛 Larva → 🐣 Juvenile → 🦞 Adult → 👑 Alpha → 👻 Ghost
+
+Pet mood affects risk tolerance. Feed to keep alive!
+
+## Chrome Extension
+
+Manifest V3 browser extension for tab relay, wallet management, chat, and manual trades via the gateway.
+
+## Links
+
+- **Website:** [nanosolana.com](https://nanosolana.com)
+- **Hub:** [hub.nanosolana.com](https://hub.nanosolana.com)
+- **Docs:** [docs.nanosolana.com](https://docs.nanosolana.com)
+- **GitHub:** [github.com/x402agent/NanoSolana](https://github.com/x402agent/NanoSolana)
+
+## License
+
+MIT — [NanoSolana Labs](https://nanosolana.com)

package/dist/chunk-DGUM43GV.js

@@ -0,0 +1,11 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};
+//# sourceMappingURL=chunk-DGUM43GV.js.map

package/dist/chunk-DGUM43GV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-FJ2L6IFK.js

@@ -0,0 +1,303 @@
+// src/memory/engine.ts
+import { EventEmitter } from "eventemitter3";
+import { randomUUID } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var MemoryEngine = class extends EventEmitter {
+  constructor(temporalDecayHours = 168, dbPath) {
+    super();
+    this.temporalDecayHours = temporalDecayHours;
+    this.dbPath = dbPath ?? join(homedir(), ".nanosolana", "memory");
+    this.ensureDbDir();
+    this.loadFromDisk();
+  }
+  memories = /* @__PURE__ */ new Map();
+  lessons = /* @__PURE__ */ new Map();
+  decayTimer = null;
+  persistTimer = null;
+  dbPath;
+  /**
+   * Store a new memory.
+   */
+  store(params) {
+    const memory = {
+      id: randomUUID(),
+      type: params.type,
+      content: params.content,
+      metadata: params.metadata ?? {},
+      confidence: 1,
+      importance: params.importance ?? 0.5,
+      accessCount: 0,
+      lastAccessedAt: Date.now(),
+      createdAt: Date.now(),
+      tags: params.tags ?? [],
+      linkedMemories: params.linkedMemories ?? []
+    };
+    this.memories.set(memory.id, memory);
+    this.emit("memoryCreated", memory);
+    return memory;
+  }
+  /**
+   * Record a trade outcome and learn from it.
+   */
+  recordTradeOutcome(params) {
+    const pnl = params.exitPrice - params.entryPrice;
+    const pnlPercent = params.entryPrice > 0 ? (params.exitPrice - params.entryPrice) / params.entryPrice * 100 : 0;
+    const wasCorrect = pnl > 0;
+    const memory = this.store({
+      type: "outcome",
+      content: `Trade ${params.tradeType} ${params.tokenSymbol}: ${wasCorrect ? "WIN" : "LOSS"} (${pnlPercent.toFixed(2)}%). Reasoning: ${params.reasoning}`,
+      metadata: {
+        signalId: params.signalId,
+        executionId: params.executionId,
+        tokenMint: params.tokenMint,
+        tokenSymbol: params.tokenSymbol,
+        tradeType: params.tradeType,
+        entryPrice: params.entryPrice,
+        exitPrice: params.exitPrice,
+        pnl,
+        pnlPercent,
+        reasoning: params.reasoning,
+        wasCorrect
+      },
+      tags: [
+        params.tradeType,
+        params.tokenSymbol,
+        wasCorrect ? "win" : "loss",
+        pnlPercent > 10 ? "big-win" : pnlPercent < -10 ? "big-loss" : "normal"
+      ],
+      importance: Math.abs(pnlPercent) > 5 ? 0.9 : 0.5
+    });
+    const lesson = this.learnFromOutcome(memory, wasCorrect, pnlPercent, params);
+    return { memory, lesson };
+  }
+  /**
+   * Learn a lesson from a trade outcome.
+   */
+  learnFromOutcome(memory, wasCorrect, pnlPercent, params) {
+    const similarOutcomes = this.searchByTags([params.tradeType, params.tokenSymbol], 10);
+    const recentWins = similarOutcomes.filter(
+      (m) => m.memory.metadata.wasCorrect === true
+    );
+    const recentLosses = similarOutcomes.filter(
+      (m) => m.memory.metadata.wasCorrect === false
+    );
+    const winRate = similarOutcomes.length > 0 ? recentWins.length / similarOutcomes.length : 0.5;
+    const patternKey = `${params.tradeType}:${params.tokenSymbol}`;
+    const existingLesson = this.lessons.get(patternKey);
+    if (existingLesson) {
+      existingLesson.occurrences++;
+      existingLesson.lastOccurrence = Date.now();
+      existingLesson.confidenceImpact = wasCorrect ? Math.min(1, existingLesson.confidenceImpact + 0.1) : Math.max(-1, existingLesson.confidenceImpact - 0.15);
+      if (!wasCorrect && recentLosses.length >= 3) {
+        existingLesson.adjustment = `STOP trading ${params.tokenSymbol} \u2014 ${recentLosses.length} consecutive losses. Win rate: ${(winRate * 100).toFixed(0)}%`;
+      }
+      this.lessons.set(patternKey, existingLesson);
+      this.emit("lessonLearned", existingLesson);
+      return existingLesson;
+    }
+    const lesson = {
+      id: randomUUID(),
+      pattern: `${params.tradeType} on ${params.tokenSymbol}`,
+      action: params.reasoning,
+      outcome: wasCorrect ? `Profit: +${pnlPercent.toFixed(2)}%` : `Loss: ${pnlPercent.toFixed(2)}%`,
+      adjustment: wasCorrect ? `Continue monitoring ${params.tokenSymbol} \u2014 strategy working` : `Reduce position size or avoid ${params.tokenSymbol} \u2014 reasoning "${params.reasoning}" led to loss`,
+      confidenceImpact: wasCorrect ? 0.1 : -0.15,
+      occurrences: 1,
+      lastOccurrence: Date.now()
+    };
+    this.lessons.set(patternKey, lesson);
+    this.emit("lessonLearned", lesson);
+    return lesson;
+  }
+  /**
+   * Search memories by content similarity (basic text match).
+   * In production, this would use vector embeddings.
+   */
+  search(query, limit = 10) {
+    const queryLower = query.toLowerCase();
+    const queryWords = queryLower.split(/\s+/);
+    const results = [];
+    for (const memory of this.memories.values()) {
+      const contentLower = memory.content.toLowerCase();
+      let matchScore = 0;
+      for (const word of queryWords) {
+        if (contentLower.includes(word)) {
+          matchScore += 1 / queryWords.length;
+        }
+      }
+      const relevance = matchScore * memory.confidence * (0.5 + memory.importance * 0.5);
+      if (relevance > 0) {
+        memory.accessCount++;
+        memory.lastAccessedAt = Date.now();
+        results.push({ memory, relevance });
+      }
+    }
+    return results.sort((a, b) => b.relevance - a.relevance).slice(0, limit);
+  }
+  /**
+   * Search memories by tags.
+   */
+  searchByTags(tags, limit = 10) {
+    const results = [];
+    for (const memory of this.memories.values()) {
+      const matchCount = tags.filter((t) => memory.tags.includes(t)).length;
+      if (matchCount > 0) {
+        const relevance = matchCount / tags.length * memory.confidence;
+        results.push({ memory, relevance });
+      }
+    }
+    return results.sort((a, b) => b.relevance - a.relevance).slice(0, limit);
+  }
+  /**
+   * Experience Replay — resurface past lessons for current context.
+   * Called before making trading decisions.
+   */
+  experienceReplay(context) {
+    const relevantLessons = [];
+    for (const lesson of this.lessons.values()) {
+      let relevant = false;
+      if (context.tokenSymbol && lesson.pattern.includes(context.tokenSymbol)) {
+        relevant = true;
+      }
+      if (context.tradeType && lesson.pattern.includes(context.tradeType)) {
+        relevant = true;
+      }
+      if (relevant) {
+        relevantLessons.push(lesson);
+      }
+    }
+    if (relevantLessons.length > 0) {
+      this.emit("replayTriggered", relevantLessons);
+    }
+    return relevantLessons;
+  }
+  /**
+   * Apply temporal decay to all memories.
+   * Older memories lose confidence unless they're important or frequently accessed.
+   */
+  applyDecay() {
+    const now = Date.now();
+    const decayWindowMs = this.temporalDecayHours * 60 * 60 * 1e3;
+    for (const [id, memory] of this.memories) {
+      const age = now - memory.createdAt;
+      const timeSinceAccess = now - memory.lastAccessedAt;
+      let decayRate = age / decayWindowMs;
+      if (memory.accessCount > 5) decayRate *= 0.5;
+      decayRate *= 1 - memory.importance * 0.7;
+      const newConfidence = Math.max(0.01, memory.confidence - decayRate * 0.01);
+      if (newConfidence !== memory.confidence) {
+        memory.confidence = newConfidence;
+        if (newConfidence < 0.1) {
+          this.emit("memoryDecayed", id);
+        }
+      }
+    }
+    for (const [id, memory] of this.memories) {
+      if (memory.confidence < 0.05 && memory.importance < 0.3) {
+        this.memories.delete(id);
+      }
+    }
+  }
+  /**
+   * Reinforce a memory — called when a past memory proves relevant again.
+   */
+  reinforce(id, boost = 0.2) {
+    const memory = this.memories.get(id);
+    if (!memory) return;
+    memory.confidence = Math.min(1, memory.confidence + boost);
+    memory.accessCount++;
+    memory.lastAccessedAt = Date.now();
+    this.emit("memoryReinforced", id, memory.confidence);
+  }
+  /**
+   * Start autonomous memory management.
+   */
+  startAutonomous(decayIntervalMs = 6e4, persistIntervalMs = 3e4) {
+    this.decayTimer = setInterval(() => this.applyDecay(), decayIntervalMs);
+    this.persistTimer = setInterval(() => this.persistToDisk(), persistIntervalMs);
+  }
+  /**
+   * Stop autonomous management.
+   */
+  stopAutonomous() {
+    if (this.decayTimer) {
+      clearInterval(this.decayTimer);
+      this.decayTimer = null;
+    }
+    if (this.persistTimer) {
+      clearInterval(this.persistTimer);
+      this.persistTimer = null;
+    }
+    this.persistToDisk();
+  }
+  /**
+   * Get memory stats.
+   */
+  getStats() {
+    let totalConfidence = 0;
+    let tradeWins = 0;
+    let totalTrades = 0;
+    for (const memory of this.memories.values()) {
+      totalConfidence += memory.confidence;
+      if (memory.type === "outcome") {
+        totalTrades++;
+        if (memory.metadata.wasCorrect) tradeWins++;
+      }
+    }
+    return {
+      totalMemories: this.memories.size,
+      totalLessons: this.lessons.size,
+      avgConfidence: this.memories.size > 0 ? totalConfidence / this.memories.size : 0,
+      tradeWinRate: totalTrades > 0 ? tradeWins / totalTrades : 0
+    };
+  }
+  /**
+   * Get all lessons.
+   */
+  getLessons() {
+    return [...this.lessons.values()];
+  }
+  // ── Persistence ────────────────────────────────────────────
+  ensureDbDir() {
+    if (!existsSync(this.dbPath)) {
+      mkdirSync(this.dbPath, { recursive: true, mode: 448 });
+    }
+  }
+  persistToDisk() {
+    try {
+      const memoriesFile = join(this.dbPath, "memories.json");
+      const lessonsFile = join(this.dbPath, "lessons.json");
+      const memoriesArr = [...this.memories.values()];
+      const lessonsArr = [...this.lessons.entries()];
+      writeFileSync(memoriesFile, JSON.stringify(memoriesArr, null, 2), { mode: 384 });
+      writeFileSync(lessonsFile, JSON.stringify(lessonsArr, null, 2), { mode: 384 });
+    } catch {
+    }
+  }
+  loadFromDisk() {
+    try {
+      const memoriesFile = join(this.dbPath, "memories.json");
+      const lessonsFile = join(this.dbPath, "lessons.json");
+      if (existsSync(memoriesFile)) {
+        const data = JSON.parse(readFileSync(memoriesFile, "utf8"));
+        for (const memory of data) {
+          this.memories.set(memory.id, memory);
+        }
+      }
+      if (existsSync(lessonsFile)) {
+        const data = JSON.parse(readFileSync(lessonsFile, "utf8"));
+        for (const [key, lesson] of data) {
+          this.lessons.set(key, lesson);
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+export {
+  MemoryEngine
+};
+//# sourceMappingURL=chunk-FJ2L6IFK.js.map

package/dist/chunk-FJ2L6IFK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory/engine.ts"],"sourcesContent":["/**\n * Nano Solana — Real-Time Memory Engine\n *\n * Adaptive memory system that learns from trading outcomes.\n * Features:\n *   - Temporal decay (older memories fade)\n *   - Experience replay (learn from mistakes)\n *   - Semantic search via embeddings\n *   - Trade outcome feedback loop\n *\n * The memory is \"sentient\" in the sense that it autonomously:\n *   1. Observes outcomes and correlates them with past decisions\n *   2. Adjusts confidence weights based on success/failure\n *   3. Surfaces relevant past experiences during decision-making\n *   4. Prunes low-value memories to stay focused\n */\n\nimport { EventEmitter } from \"eventemitter3\";\nimport { createHash, randomUUID } from \"node:crypto\";\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { homedir } from \"node:os\";\n\n// ── Types ────────────────────────────────────────────────────\n\nexport interface Memory {\n  id: string;\n  type: \"observation\" | \"decision\" | \"outcome\" | \"lesson\" | \"context\";\n  content: string;\n  embedding?: number[];\n  metadata: Record<string, unknown>;\n  confidence: number;       // 0-1, decays over time\n  importance: number;       // 0-1, increased by relevance\n  accessCount: number;\n  lastAccessedAt: number;\n  createdAt: number;\n  tags: string[];\n  linkedMemories: string[]; // IDs of related memories\n}\n\nexport interface TradeMemory extends Memory {\n  type: \"outcome\";\n  metadata: {\n    signalId: string;\n    executionId: string;\n    tokenMint: string;\n    tokenSymbol: string;\n    tradeType: \"buy\" | \"sell\";\n    entryPrice: number;\n    exitPrice?: number;\n    pnl?: number;\n    pnlPercent?: number;\n    holdDurationMs?: number;\n    reasoning: string;\n    wasCorrect?: boolean;\n  };\n}\n\nexport interface Lesson {\n  id: string;\n  pattern: string;         // What pattern was recognized\n  action: string;          // What the agent did\n  outcome: string;         // What happened\n  adjustment: string;      // What to do differently\n  confidenceImpact: number; // How much to adjust confidence (-1 to 1)\n  occurrences: number;\n  lastOccurrence: number;\n}\n\nexport interface MemorySearchResult {\n  memory: Memory;\n  relevance: number;\n}\n\nexport interface MemoryEngineEvents {\n  memoryCreated: (memory: Memory) => void;\n  lessonLearned: (lesson: Lesson) => void;\n  memoryDecayed: (id: string) => void;\n  memoryReinforced: (id: string, newConfidence: number) => void;\n  replayTriggered: (lessons: Lesson[]) => void;\n}\n\n// ── Memory Engine ────────────────────────────────────────────\n\nexport class MemoryEngine extends EventEmitter<MemoryEngineEvents> {\n  private memories: Map<string, Memory> = new Map();\n  private lessons: Map<string, Lesson> = new Map();\n  private decayTimer: ReturnType<typeof setInterval> | null = null;\n  private persistTimer: ReturnType<typeof setInterval> | null = null;\n  private dbPath: string;\n\n  constructor(\n    private temporalDecayHours = 168, // 7 days\n    dbPath?: string,\n  ) {\n    super();\n    this.dbPath = dbPath ?? join(homedir(), \".nanosolana\", \"memory\");\n    this.ensureDbDir();\n    this.loadFromDisk();\n  }\n\n  /**\n   * Store a new memory.\n   */\n  store(params: {\n    type: Memory[\"type\"];\n    content: string;\n    metadata?: Record<string, unknown>;\n    tags?: string[];\n    importance?: number;\n    linkedMemories?: string[];\n  }): Memory {\n    const memory: Memory = {\n      id: randomUUID(),\n      type: params.type,\n      content: params.content,\n      metadata: params.metadata ?? {},\n      confidence: 1.0,\n      importance: params.importance ?? 0.5,\n      accessCount: 0,\n      lastAccessedAt: Date.now(),\n      createdAt: Date.now(),\n      tags: params.tags ?? [],\n      linkedMemories: params.linkedMemories ?? [],\n    };\n\n    this.memories.set(memory.id, memory);\n    this.emit(\"memoryCreated\", memory);\n    return memory;\n  }\n\n  /**\n   * Record a trade outcome and learn from it.\n   */\n  recordTradeOutcome(params: {\n    signalId: string;\n    executionId: string;\n    tokenMint: string;\n    tokenSymbol: string;\n    tradeType: \"buy\" | \"sell\";\n    entryPrice: number;\n    exitPrice: number;\n    reasoning: string;\n  }): { memory: Memory; lesson: Lesson | null } {\n    const pnl = params.exitPrice - params.entryPrice;\n    const pnlPercent = params.entryPrice > 0\n      ? ((params.exitPrice - params.entryPrice) / params.entryPrice) * 100\n      : 0;\n    const wasCorrect = pnl > 0;\n\n    // Store the outcome as a memory\n    const memory = this.store({\n      type: \"outcome\",\n      content: `Trade ${params.tradeType} ${params.tokenSymbol}: ${wasCorrect ? \"WIN\" : \"LOSS\"} (${pnlPercent.toFixed(2)}%). Reasoning: ${params.reasoning}`,\n      metadata: {\n        signalId: params.signalId,\n        executionId: params.executionId,\n        tokenMint: params.tokenMint,\n        tokenSymbol: params.tokenSymbol,\n        tradeType: params.tradeType,\n        entryPrice: params.entryPrice,\n        exitPrice: params.exitPrice,\n        pnl,\n        pnlPercent,\n        reasoning: params.reasoning,\n        wasCorrect,\n      },\n      tags: [\n        params.tradeType,\n        params.tokenSymbol,\n        wasCorrect ? \"win\" : \"loss\",\n        pnlPercent > 10 ? \"big-win\" : pnlPercent < -10 ? \"big-loss\" : \"normal\",\n      ],\n      importance: Math.abs(pnlPercent) > 5 ? 0.9 : 0.5,\n    });\n\n    // Learn a lesson from the outcome\n    const lesson = this.learnFromOutcome(memory, wasCorrect, pnlPercent, params);\n\n    return { memory, lesson };\n  }\n\n  /**\n   * Learn a lesson from a trade outcome.\n   */\n  private learnFromOutcome(\n    memory: Memory,\n    wasCorrect: boolean,\n    pnlPercent: number,\n    params: { tokenSymbol: string; tradeType: string; reasoning: string },\n  ): Lesson | null {\n    // Find similar past outcomes to identify patterns\n    const similarOutcomes = this.searchByTags([params.tradeType, params.tokenSymbol], 10);\n    const recentWins = similarOutcomes.filter(\n      (m) => (m.memory.metadata as any).wasCorrect === true,\n    );\n    const recentLosses = similarOutcomes.filter(\n      (m) => (m.memory.metadata as any).wasCorrect === false,\n    );\n\n    // Generate a pattern-based lesson\n    const winRate = similarOutcomes.length > 0\n      ? recentWins.length / similarOutcomes.length\n      : 0.5;\n\n    const patternKey = `${params.tradeType}:${params.tokenSymbol}`;\n    const existingLesson = this.lessons.get(patternKey);\n\n    if (existingLesson) {\n      // Update existing lesson\n      existingLesson.occurrences++;\n      existingLesson.lastOccurrence = Date.now();\n      existingLesson.confidenceImpact = wasCorrect\n        ? Math.min(1, existingLesson.confidenceImpact + 0.1)\n        : Math.max(-1, existingLesson.confidenceImpact - 0.15);\n\n      if (!wasCorrect && recentLosses.length >= 3) {\n        existingLesson.adjustment = `STOP trading ${params.tokenSymbol} — ${recentLosses.length} consecutive losses. Win rate: ${(winRate * 100).toFixed(0)}%`;\n      }\n\n      this.lessons.set(patternKey, existingLesson);\n      this.emit(\"lessonLearned\", existingLesson);\n      return existingLesson;\n    }\n\n    // Create new lesson\n    const lesson: Lesson = {\n      id: randomUUID(),\n      pattern: `${params.tradeType} on ${params.tokenSymbol}`,\n      action: params.reasoning,\n      outcome: wasCorrect\n        ? `Profit: +${pnlPercent.toFixed(2)}%`\n        : `Loss: ${pnlPercent.toFixed(2)}%`,\n      adjustment: wasCorrect\n        ? `Continue monitoring ${params.tokenSymbol} — strategy working`\n        : `Reduce position size or avoid ${params.tokenSymbol} — reasoning \"${params.reasoning}\" led to loss`,\n      confidenceImpact: wasCorrect ? 0.1 : -0.15,\n      occurrences: 1,\n      lastOccurrence: Date.now(),\n    };\n\n    this.lessons.set(patternKey, lesson);\n    this.emit(\"lessonLearned\", lesson);\n    return lesson;\n  }\n\n  /**\n   * Search memories by content similarity (basic text match).\n   * In production, this would use vector embeddings.\n   */\n  search(query: string, limit = 10): MemorySearchResult[] {\n    const queryLower = query.toLowerCase();\n    const queryWords = queryLower.split(/\\s+/);\n\n    const results: MemorySearchResult[] = [];\n\n    for (const memory of this.memories.values()) {\n      const contentLower = memory.content.toLowerCase();\n      let matchScore = 0;\n\n      for (const word of queryWords) {\n        if (contentLower.includes(word)) {\n          matchScore += 1 / queryWords.length;\n        }\n      }\n\n      // Boost by confidence and importance\n      const relevance = matchScore * memory.confidence * (0.5 + memory.importance * 0.5);\n\n      if (relevance > 0) {\n        // Mark as accessed\n        memory.accessCount++;\n        memory.lastAccessedAt = Date.now();\n\n        results.push({ memory, relevance });\n      }\n    }\n\n    return results\n      .sort((a, b) => b.relevance - a.relevance)\n      .slice(0, limit);\n  }\n\n  /**\n   * Search memories by tags.\n   */\n  searchByTags(tags: string[], limit = 10): MemorySearchResult[] {\n    const results: MemorySearchResult[] = [];\n\n    for (const memory of this.memories.values()) {\n      const matchCount = tags.filter((t) => memory.tags.includes(t)).length;\n      if (matchCount > 0) {\n        const relevance = (matchCount / tags.length) * memory.confidence;\n        results.push({ memory, relevance });\n      }\n    }\n\n    return results\n      .sort((a, b) => b.relevance - a.relevance)\n      .slice(0, limit);\n  }\n\n  /**\n   * Experience Replay — resurface past lessons for current context.\n   * Called before making trading decisions.\n   */\n  experienceReplay(context: {\n    tokenSymbol?: string;\n    tradeType?: string;\n    marketCondition?: string;\n  }): Lesson[] {\n    const relevantLessons: Lesson[] = [];\n\n    for (const lesson of this.lessons.values()) {\n      let relevant = false;\n\n      if (context.tokenSymbol && lesson.pattern.includes(context.tokenSymbol)) {\n        relevant = true;\n      }\n      if (context.tradeType && lesson.pattern.includes(context.tradeType)) {\n        relevant = true;\n      }\n\n      if (relevant) {\n        relevantLessons.push(lesson);\n      }\n    }\n\n    if (relevantLessons.length > 0) {\n      this.emit(\"replayTriggered\", relevantLessons);\n    }\n\n    return relevantLessons;\n  }\n\n  /**\n   * Apply temporal decay to all memories.\n   * Older memories lose confidence unless they're important or frequently accessed.\n   */\n  applyDecay(): void {\n    const now = Date.now();\n    const decayWindowMs = this.temporalDecayHours * 60 * 60 * 1000;\n\n    for (const [id, memory] of this.memories) {\n      const age = now - memory.createdAt;\n      const timeSinceAccess = now - memory.lastAccessedAt;\n\n      // Base decay factor\n      let decayRate = age / decayWindowMs;\n\n      // Reduce decay for frequently accessed memories\n      if (memory.accessCount > 5) decayRate *= 0.5;\n\n      // Reduce decay for high-importance memories\n      decayRate *= 1 - memory.importance * 0.7;\n\n      // Apply decay\n      const newConfidence = Math.max(0.01, memory.confidence - decayRate * 0.01);\n\n      if (newConfidence !== memory.confidence) {\n        memory.confidence = newConfidence;\n\n        if (newConfidence < 0.1) {\n          this.emit(\"memoryDecayed\", id);\n        }\n      }\n    }\n\n    // Prune very old, low-confidence memories (keep the store lean)\n    for (const [id, memory] of this.memories) {\n      if (memory.confidence < 0.05 && memory.importance < 0.3) {\n        this.memories.delete(id);\n      }\n    }\n  }\n\n  /**\n   * Reinforce a memory — called when a past memory proves relevant again.\n   */\n  reinforce(id: string, boost = 0.2): void {\n    const memory = this.memories.get(id);\n    if (!memory) return;\n\n    memory.confidence = Math.min(1, memory.confidence + boost);\n    memory.accessCount++;\n    memory.lastAccessedAt = Date.now();\n\n    this.emit(\"memoryReinforced\", id, memory.confidence);\n  }\n\n  /**\n   * Start autonomous memory management.\n   */\n  startAutonomous(decayIntervalMs = 60000, persistIntervalMs = 30000): void {\n    // Temporal decay\n    this.decayTimer = setInterval(() => this.applyDecay(), decayIntervalMs);\n\n    // Periodic persistence\n    this.persistTimer = setInterval(() => this.persistToDisk(), persistIntervalMs);\n  }\n\n  /**\n   * Stop autonomous management.\n   */\n  stopAutonomous(): void {\n    if (this.decayTimer) {\n      clearInterval(this.decayTimer);\n      this.decayTimer = null;\n    }\n    if (this.persistTimer) {\n      clearInterval(this.persistTimer);\n      this.persistTimer = null;\n    }\n    this.persistToDisk(); // Final save\n  }\n\n  /**\n   * Get memory stats.\n   */\n  getStats(): {\n    totalMemories: number;\n    totalLessons: number;\n    avgConfidence: number;\n    tradeWinRate: number;\n  } {\n    let totalConfidence = 0;\n    let tradeWins = 0;\n    let totalTrades = 0;\n\n    for (const memory of this.memories.values()) {\n      totalConfidence += memory.confidence;\n      if (memory.type === \"outcome\") {\n        totalTrades++;\n        if ((memory.metadata as any).wasCorrect) tradeWins++;\n      }\n    }\n\n    return {\n      totalMemories: this.memories.size,\n      totalLessons: this.lessons.size,\n      avgConfidence: this.memories.size > 0 ? totalConfidence / this.memories.size : 0,\n      tradeWinRate: totalTrades > 0 ? tradeWins / totalTrades : 0,\n    };\n  }\n\n  /**\n   * Get all lessons.\n   */\n  getLessons(): Lesson[] {\n    return [...this.lessons.values()];\n  }\n\n  // ── Persistence ────────────────────────────────────────────\n\n  private ensureDbDir(): void {\n    if (!existsSync(this.dbPath)) {\n      mkdirSync(this.dbPath, { recursive: true, mode: 0o700 });\n    }\n  }\n\n  private persistToDisk(): void {\n    try {\n      const memoriesFile = join(this.dbPath, \"memories.json\");\n      const lessonsFile = join(this.dbPath, \"lessons.json\");\n\n      const memoriesArr = [...this.memories.values()];\n      const lessonsArr = [...this.lessons.entries()];\n\n      writeFileSync(memoriesFile, JSON.stringify(memoriesArr, null, 2), { mode: 0o600 });\n      writeFileSync(lessonsFile, JSON.stringify(lessonsArr, null, 2), { mode: 0o600 });\n    } catch {\n      // Silent fail on persistence — memory is primarily in-RAM\n    }\n  }\n\n  private loadFromDisk(): void {\n    try {\n      const memoriesFile = join(this.dbPath, \"memories.json\");\n      const lessonsFile = join(this.dbPath, \"lessons.json\");\n\n      if (existsSync(memoriesFile)) {\n        const data = JSON.parse(readFileSync(memoriesFile, \"utf8\")) as Memory[];\n        for (const memory of data) {\n          this.memories.set(memory.id, memory);\n        }\n      }\n\n      if (existsSync(lessonsFile)) {\n        const data = JSON.parse(readFileSync(lessonsFile, \"utf8\")) as [string, Lesson][];\n        for (const [key, lesson] of data) {\n          this.lessons.set(key, lesson);\n        }\n      }\n    } catch {\n      // Fresh start if files are corrupted\n    }\n  }\n}\n"],"mappings":"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","names":[]}