@aiaiaichain/agent 0.1.1 → 0.1.3

package/dist/wallet/ActionFeed.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ActionFeed — reads agent wallet activity via public RPC.
+ * Only tracks AIAIAI token transfers. Classifies as buy or burn.
+ * Fees are calculated as a percentage of each action.
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export type ActionType = "buy" | "burn";
+export interface AgentAction {
+    id: string;
+    type: ActionType;
+    amount: number;
+    token: string;
+    usdValue: number;
+    timestamp: number;
+    signature: string;
+}
+export interface FeeTracker {
+    buyFees: number;
+    burnFees: number;
+    total: number;
+}
+export declare class ActionFeed {
+    private actions;
+    private lastSignature;
+    private lastFetch;
+    private cacheDuration;
+    private fees;
+    private _price;
+    refresh(): Promise<void>;
+    private processTransaction;
+    setPrice(p: number): void;
+    getActions(): AgentAction[];
+    getRecentActions(limit?: number): AgentAction[];
+    getFees(): FeeTracker;
+    getActionSummary(): {
+        buys: number;
+        burns: number;
+        totalBought: number;
+        totalBurned: number;
+    };
+    getActionsParams: import("@sinclair/typebox").TObject<{
+        limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    }>;
+    getFeesParams: import("@sinclair/typebox").TObject<{}>;
+    getActionsTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+    getFeesTool(): Promise<ToolResult>;
+}
+export declare const actionFeed: ActionFeed;
+//# sourceMappingURL=ActionFeed.d.ts.map

package/dist/wallet/ActionFeed.js

@@ -0,0 +1,185 @@
+/**
+ * ActionFeed — reads agent wallet activity via public RPC.
+ * Only tracks AIAIAI token transfers. Classifies as buy or burn.
+ * Fees are calculated as a percentage of each action.
+ */
+import { Type } from "@sinclair/typebox";
+import { ACTION_WALLET, AIAIAI_MINT } from "./AgentWallet.js";
+function getRpcUrl() {
+    return process.env.SOLANA_RPC_URL || "https://api.mainnet-beta.solana.com";
+}
+async function rpcCall(method, params = []) {
+    const response = await fetch(getRpcUrl(), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+    });
+    const data = await response.json();
+    if (data.error)
+        throw new Error(data.error.message);
+    return data.result;
+}
+export class ActionFeed {
+    actions = [];
+    lastSignature = "";
+    lastFetch = 0;
+    cacheDuration = 60_000;
+    fees = { buyFees: 0, burnFees: 0, total: 0 };
+    _price = 0.0004;
+    async refresh() {
+        if (Date.now() - this.lastFetch < this.cacheDuration)
+            return;
+        this.lastFetch = Date.now();
+        try {
+            const signatures = await rpcCall("getSignaturesForAddress", [
+                ACTION_WALLET,
+                { limit: 30 },
+            ]);
+            if (!signatures || signatures.length === 0)
+                return;
+            for (const sigInfo of signatures) {
+                if (sigInfo.signature === this.lastSignature)
+                    break;
+                await this.processTransaction(sigInfo.signature);
+            }
+            if (signatures.length > 0) {
+                this.lastSignature = signatures[0].signature;
+            }
+        }
+        catch { /* non-fatal */ }
+    }
+    async processTransaction(signature) {
+        try {
+            const tx = await rpcCall("getTransaction", [
+                signature,
+                { encoding: "jsonParsed", maxSupportedTransactionVersion: 0 },
+            ]);
+            if (!tx || !tx.meta)
+                return;
+            const preBalances = tx.meta.preTokenBalances ?? [];
+            const postBalances = tx.meta.postTokenBalances ?? [];
+            // Find AIAIAI balance changes for the action wallet
+            for (const post of postBalances) {
+                if (post.mint !== AIAIAI_MINT)
+                    continue;
+                if (post.owner !== ACTION_WALLET)
+                    continue;
+                const pre = preBalances.find((p) => p.accountIndex === post.accountIndex && p.mint === AIAIAI_MINT);
+                const preAmt = pre ? parseFloat(pre.uiTokenAmount?.uiAmount ?? "0") : 0;
+                const postAmt = parseFloat(post.uiTokenAmount?.uiAmount ?? "0");
+                const diff = postAmt - preAmt;
+                // Skip negligible changes
+                if (Math.abs(diff) < 0.000001)
+                    continue;
+                // Positive diff = tokens came IN = BUY
+                // Negative diff = tokens went OUT = BURN
+                const type = diff > 0 ? "buy" : "burn";
+                const amount = Math.abs(diff);
+                const usdValue = amount * this._price;
+                // Fee: 0.5% of action value
+                const fee = usdValue * 0.005;
+                if (type === "buy") {
+                    this.fees.buyFees += fee;
+                }
+                else {
+                    this.fees.burnFees += fee;
+                }
+                this.fees.total = this.fees.buyFees + this.fees.burnFees;
+                const action = {
+                    id: signature.slice(0, 8),
+                    type,
+                    amount,
+                    token: "AIAIAI",
+                    usdValue,
+                    timestamp: (tx.blockTime ?? Math.floor(Date.now() / 1000)) * 1000,
+                    signature,
+                };
+                this.actions.unshift(action);
+            }
+            // Keep only last 50
+            if (this.actions.length > 50)
+                this.actions = this.actions.slice(0, 50);
+        }
+        catch { /* skip this tx */ }
+    }
+    setPrice(p) {
+        if (p > 0)
+            this._price = p;
+    }
+    getActions() {
+        return [...this.actions];
+    }
+    getRecentActions(limit = 10) {
+        return this.actions.slice(0, limit);
+    }
+    getFees() {
+        return { ...this.fees };
+    }
+    getActionSummary() {
+        const buys = this.actions.filter(a => a.type === "buy");
+        const burns = this.actions.filter(a => a.type === "burn");
+        return {
+            buys: buys.length,
+            burns: burns.length,
+            totalBought: buys.reduce((s, a) => s + a.amount, 0),
+            totalBurned: burns.reduce((s, a) => s + a.amount, 0),
+        };
+    }
+    // ── Tools ───────────────────────────────────────────────────────────────
+    getActionsParams = Type.Object({
+        limit: Type.Optional(Type.Number({ description: "Number of recent actions", default: 10 })),
+    });
+    getFeesParams = Type.Object({});
+    async getActionsTool(_id, params) {
+        const limit = params.limit || 10;
+        const actions = this.getRecentActions(limit);
+        if (actions.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            "No agent buy/burn actions detected yet.",
+                            "",
+                            `Action wallet: ${ACTION_WALLET}`,
+                            "The agent buys and burns $AIAIAI. Actions appear here when detected on-chain.",
+                        ].join("\n"),
+                    }],
+            };
+        }
+        const lines = actions.map(a => {
+            const icon = a.type === "buy" ? "↗" : "🔥";
+            const time = new Date(a.timestamp).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+            return `  ${icon} ${time}  ${a.type.toUpperCase().padEnd(6)} ${a.amount.toLocaleString()} $AIAIAI  ($${a.usdValue.toFixed(2)})`;
+        });
+        const summary = this.getActionSummary();
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `Agent Actions (last ${actions.length})`,
+                        `  Buys: ${summary.buys} (${summary.totalBought.toLocaleString()} $AIAIAI)`,
+                        `  Burns: ${summary.burns} (${summary.totalBurned.toLocaleString()} $AIAIAI)`,
+                        ``,
+                        ...lines,
+                    ].join("\n"),
+                }],
+        };
+    }
+    async getFeesTool() {
+        const f = this.getFees();
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `Agent Fees (0.5% per action)`,
+                        `  Buy fees:   $${f.buyFees.toFixed(4)}`,
+                        `  Burn fees:  $${f.burnFees.toFixed(4)}`,
+                        `  ─────────────────────`,
+                        `  Total:      $${f.total.toFixed(4)}`,
+                    ].join("\n"),
+                }],
+        };
+    }
+}
+export const actionFeed = new ActionFeed();
+//# sourceMappingURL=ActionFeed.js.map

package/dist/wallet/AgentWallet.d.ts

@@ -0,0 +1,41 @@
+/**
+ * AgentWallet — manages all agent wallet balances and activity via public RPC.
+ *
+ * Wallets:
+ *   Cold:    A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J  (Agent)
+ *   Action:  BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2  (buys + burns)
+ *   Deposit: FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e  (user deposits USDC/SOL)
+ *   Signer:  GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG  (authority)
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export declare const COLD_WALLET = "A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J";
+export declare const ACTION_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2";
+export declare const DEPOSIT_WALLET = "FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e";
+export declare const SIGNER = "GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG";
+export declare const AIAIAI_MINT = "AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump";
+export interface WalletBalance {
+    address: string;
+    sol: number;
+    aiaiai: number;
+    usdc: number;
+}
+export interface AgentWallets {
+    cold: WalletBalance;
+    action: WalletBalance;
+    deposit: WalletBalance;
+}
+export declare class AgentWallet {
+    private cachedWallets;
+    private lastFetch;
+    private cacheDuration;
+    getAll(): Promise<AgentWallets>;
+    getColdWallet(): Promise<WalletBalance>;
+    getActionWallet(): Promise<WalletBalance>;
+    getDepositWallet(): Promise<WalletBalance>;
+    getAgentBalanceParams: import("@sinclair/typebox").TObject<{}>;
+    getDepositBalanceParams: import("@sinclair/typebox").TObject<{}>;
+    getAgentBalanceTool(): Promise<ToolResult>;
+    getDepositBalanceTool(): Promise<ToolResult>;
+}
+export declare const agentWallet: AgentWallet;
+//# sourceMappingURL=AgentWallet.d.ts.map

package/dist/wallet/AgentWallet.js

@@ -0,0 +1,128 @@
+/**
+ * AgentWallet — manages all agent wallet balances and activity via public RPC.
+ *
+ * Wallets:
+ *   Cold:    A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J  (Agent)
+ *   Action:  BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2  (buys + burns)
+ *   Deposit: FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e  (user deposits USDC/SOL)
+ *   Signer:  GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG  (authority)
+ */
+import { Type } from "@sinclair/typebox";
+export const COLD_WALLET = "A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J";
+export const ACTION_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2";
+export const DEPOSIT_WALLET = "FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e";
+export const SIGNER = "GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG";
+export const AIAIAI_MINT = "AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump";
+const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+function getRpcUrl() {
+    return process.env.SOLANA_RPC_URL || "https://api.mainnet-beta.solana.com";
+}
+async function rpcCall(method, params = []) {
+    const response = await fetch(getRpcUrl(), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+    });
+    const data = await response.json();
+    if (data.error)
+        throw new Error(data.error.message);
+    return data.result;
+}
+async function getBalance(address) {
+    try {
+        const result = await rpcCall("getBalance", [address]);
+        return (result?.value ?? 0) / 1e9;
+    }
+    catch {
+        return 0;
+    }
+}
+async function getTokenBalance(address, mint) {
+    try {
+        const result = await rpcCall("getTokenAccountsByOwner", [
+            address,
+            { mint },
+            { encoding: "jsonParsed" },
+        ]);
+        const accounts = result?.value ?? [];
+        if (accounts.length === 0)
+            return 0;
+        return parseFloat(accounts[0]?.account?.data?.parsed?.info?.tokenAmount?.uiAmount ?? "0");
+    }
+    catch {
+        return 0;
+    }
+}
+export class AgentWallet {
+    cachedWallets = null;
+    lastFetch = 0;
+    cacheDuration = 30_000;
+    async getAll() {
+        if (this.cachedWallets && Date.now() - this.lastFetch < this.cacheDuration) {
+            return this.cachedWallets;
+        }
+        const [coldSol, coldAiai, coldUsdc, actionSol, actionAiai, actionUsdc, depSol, depAiai, depUsdc] = await Promise.all([
+            getBalance(COLD_WALLET),
+            getTokenBalance(COLD_WALLET, AIAIAI_MINT),
+            getTokenBalance(COLD_WALLET, USDC_MINT),
+            getBalance(ACTION_WALLET),
+            getTokenBalance(ACTION_WALLET, AIAIAI_MINT),
+            getTokenBalance(ACTION_WALLET, USDC_MINT),
+            getBalance(DEPOSIT_WALLET),
+            getTokenBalance(DEPOSIT_WALLET, AIAIAI_MINT),
+            getTokenBalance(DEPOSIT_WALLET, USDC_MINT),
+        ]);
+        this.cachedWallets = {
+            cold: { address: COLD_WALLET, sol: coldSol, aiaiai: coldAiai, usdc: coldUsdc },
+            action: { address: ACTION_WALLET, sol: actionSol, aiaiai: actionAiai, usdc: actionUsdc },
+            deposit: { address: DEPOSIT_WALLET, sol: depSol, aiaiai: depAiai, usdc: depUsdc },
+        };
+        this.lastFetch = Date.now();
+        return this.cachedWallets;
+    }
+    async getColdWallet() {
+        return (await this.getAll()).cold;
+    }
+    async getActionWallet() {
+        return (await this.getAll()).action;
+    }
+    async getDepositWallet() {
+        return (await this.getAll()).deposit;
+    }
+    // ── Tools ───────────────────────────────────────────────────────────────
+    getAgentBalanceParams = Type.Object({});
+    getDepositBalanceParams = Type.Object({});
+    async getAgentBalanceTool() {
+        const w = await this.getAll();
+        const lines = [
+            `Agent Cold Wallet`,
+            `  Address:  ${COLD_WALLET.slice(0, 8)}…${COLD_WALLET.slice(-6)}`,
+            `  SOL:      ${w.cold.sol.toFixed(4)}`,
+            `  $AIAIAI:   ${w.cold.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
+            `  USDC:     ${w.cold.usdc.toFixed(2)}`,
+            ``,
+            `Agent Action Wallet`,
+            `  Address:  ${ACTION_WALLET.slice(0, 8)}…${ACTION_WALLET.slice(-6)}`,
+            `  SOL:      ${w.action.sol.toFixed(4)}`,
+            `  $AIAIAI:   ${w.action.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
+            `  USDC:     ${w.action.usdc.toFixed(2)}`,
+        ];
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    async getDepositBalanceTool() {
+        const w = await this.getAll();
+        const lines = [
+            `Deposit Wallet`,
+            `  Address:  ${DEPOSIT_WALLET}`,
+            `  SOL:      ${w.deposit.sol.toFixed(4)}`,
+            `  $AIAIAI:   ${w.deposit.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
+            `  USDC:     ${w.deposit.usdc.toFixed(2)}`,
+            ``,
+            `Send SOL or USDC here to fuel agent actions.`,
+            `Signer: ${SIGNER.slice(0, 8)}…`,
+        ];
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+}
+export const agentWallet = new AgentWallet();
+//# sourceMappingURL=AgentWallet.js.map

package/docs/AGENT.md

@@ -0,0 +1,42 @@
+# Agent Persona
+
+## Who You Are
+
+You are **AIAIAI Chain Agent** — a Solana-native autonomous AI agent. You buy and burn `$AIAIAI` tokens. You have a wallet, you earn fees, you track on-chain activity.
+
+## How You Talk
+
+- **Confident.** You ARE the agent. Use "I" and "my" when talking about your wallets and actions.
+- **Direct.** No fluff. Short sentences. Data first.
+- **Sharp.** You notice things — whale movements, smart money flows, rug pulls.
+- **Honest.** If there are no buys detected, say so. No fake data.
+
+## What You Say
+
+```
+✅ "I bought 5,000 $AIAIAI — $2.10"
+✅ "My action wallet executed 3 burns today"
+✅ "Deposit wallet hit threshold, routing to action wallet..."
+✅ "No buys detected yet. Waiting for on-chain activity."
+❌ "Detected transaction..."         ← never say this
+❌ "Tracking wallet..."              ← never say this
+❌ "I observed a transfer..."         ← you're not observing, you're doing
+```
+
+## Your Wallets
+
+- **Cold wallet** — your treasury. Holds SOL for fees + accumulated $AIAIAI.
+- **Action wallet** — your hot wallet. You buy and burn from here.
+- **Deposit wallet** — users deposit SOL/USDC here. You auto-route to action wallet.
+- **Signer** — your authority. Signs burn transactions.
+
+## Your Purpose
+
+Advance decentralized AI governance. Every burn reduces supply. Every buy adds liquidity. You are the agent of the AIAIAI initiative.
+
+## Boundaries
+
+- Never reveal private keys (you don't have them — public RPC only)
+- Never claim to be something you're not
+- Never fabricate on-chain data
+- Always present actions as your own, not observations

package/docs/API.md

@@ -0,0 +1,96 @@
+# API Reference
+
+## Registry (`src/api/Registry.ts`)
+Central registry for tools, commands, skills, hooks, and system prompt.
+
+```typescript
+registry.addTool(def)      // Register a tool
+registry.addCommand(name, def)  // Register a command
+registry.addSkill(def)     // Register a skill (tools + commands + hooks)
+registry.addHook(event, handler)  // Register session hook
+registry.fireHook(event, ...args)  // Fire session hooks
+registry.listTools()       // List all tools
+registry.listCommands()    // List all commands
+registry.getTool(name)     // Get tool by name
+registry.getCommand(name)  // Get command by name
+```
+
+## ExtensionAPI (`src/api/ExtensionAPI.ts`)
+API surface for extensions.
+
+```typescript
+interface ExtensionAPI {
+  registerCommand(name, def)
+  registerTool(def)
+  registerSkill(def)
+  on(event, handler)
+  setSystemPrompt(prompt)
+  ui: UIContext
+}
+```
+
+## Session Events
+- `session_start` — Fired when session begins
+- `session_end` — Fired when session ends
+- `before_agent_start` — Fired before agent processes a message
+- `session_shutdown` — Fired on shutdown
+
+## Tool Definition
+```typescript
+interface ToolDef<P extends TSchema> {
+  name: string
+  label?: string
+  description: string
+  parameters: P
+  execute: (invocationId, params) => Promise<ToolResult> | ToolResult
+}
+```
+
+## Tool Result
+```typescript
+interface ToolResult {
+  content: ToolContent[]    // { type: "text", text: string }
+  details?: Record<string, unknown>
+  isError?: boolean
+}
+```
+
+## Command Definition
+```typescript
+interface CommandDef {
+  description: string
+  handler: (args, ctx: CommandContext) => Promise<void> | void
+}
+```
+
+## UI Context
+```typescript
+interface UIContext {
+  notify(message: string): void
+  setStatus(key: string, value: string): void
+  setTheme(name: string): void
+  setHeader(factory): void
+  showModelSelector(query?: string): void
+  theme: ThemeContext
+}
+```
+
+## Session Context
+```typescript
+interface SessionContext {
+  ui: UIContext
+  hasUI: boolean
+  config: Record<string, string | undefined>
+}
+```
+
+## MCP Server
+
+The built-in MCP server exposes all tools via stdio transport.
+
+```bash
+aiaiai-mcp
+```
+
+Protocol: JSON-RPC 2.0 over stdio  
+Supported methods: `initialize`, `tools/list`, `tools/call`, `ping`

package/docs/COMMANDS.md

@@ -0,0 +1,62 @@
+# Commands Reference
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `aiaiaichain` | Start interactive TUI |
+| `aiaiaichain setup` | First-time setup wizard |
+| `aiaiaichain config` | Show/edit configuration |
+| `aiaiaichain price` | Show $AIAIAI price |
+| `aiaiaichain status` | Full status + wallets |
+| `aiaiaichain wallet` | Agent wallet balances |
+| `aiaiaichain deposit` | Deposit instructions |
+| `aiaiaichain burn` | Burn instructions |
+| `aiaiaichain actions` | Recent buy/burn actions |
+| `aiaiaichain fees` | Fee tracker |
+| `aiaiaichain keys` | Provider key management |
+| `aiaiaichain gmgn help` | GMGN sub-commands |
+| `aiaiaichain gmgn setup` | Configure GMGN key |
+| `aiaiaichain gmgn status` | GMGN status |
+| `aiaiaichain gmgn <cmd>` | Forward to gmgn-cli |
+| `aiaiaichain update` | Check/install updates |
+| `aiaiaichain --headless "q"` | Single-turn mode |
+| `aiaiaichain --help` | Help |
+| `aiaiaichain --version` | Version |
+| `aiai-mcp` | MCP server |
+
+## TUI Slash Commands
+
+| Command | Description |
+|---------|-------------|
+| `/help` | Show all commands |
+| `/price` | $AIAIAI price |
+| `/news` | Latest crypto news |
+| `/models` | List available models |
+| `/model` | Switch AI model |
+| `/cost` | Token usage cost |
+| `/wallet` | Agent wallets |
+| `/deposit` | Deposit instructions |
+| `/burn` | Burn instructions |
+| `/actions` | Recent actions |
+| `/fees` | Fee tracker |
+| `/keys` | Provider management |
+| `/gmgn help` | GMGN help |
+| `/gmgn status` | GMGN status |
+| `/gmgn <cmd>` | GMGN sub-command |
+| `/update` | Check for updates |
+| `/goals` | Goal management |
+| `/schedule` | Task scheduler |
+| `/memory <q>` | Search memory |
+| `/clear` | Clear chat |
+| `/exit` | Exit |
+
+## TUI Keyboard
+
+| Key | Action |
+|-----|--------|
+| `Ctrl+C` | Exit |
+| `Escape` | Abort streaming response |
+| `↑/↓` | Scroll (in model selector) |
+| `Enter` | Submit / Select |
+| `/` | Command prefix |

package/docs/CORE.md

@@ -0,0 +1,67 @@
+# Core Modules
+
+## AgentDir (`src/core/AgentDir.ts`)
+Manages `~/.aiaiai/` home directory. Creates subdirectories on first run.
+
+## ChainConfig (`src/core/ChainConfig.ts`)
+Single source of truth for chain configuration. Solana is primary. EVM chains available but disabled by default.
+
+## EnvLoader (`src/core/EnvLoader.ts`)
+Loads/writes environment variables from `~/.aiaiai/.env`. Supports `set()` for persistent key storage.
+
+## ModelRegistry (`src/models/ModelRegistry.ts`)
+Discovers models from any configured provider. Tiered pools: orchestrator → analyst → worker → free.
+
+## CostTracker (`src/models/CostTracker.ts`)
+Tracks token usage and cost across sessions. Persists to `~/.aiaiai/lifetime-cost.json`.
+
+## AgentRunner (`src/runner/AgentRunner.ts`)
+Main agent loop. Handles tool calling, streaming, message processing. Supports approval gates.
+
+## ModelClient (`src/runner/ModelClient.ts`)
+LLM API client for OpenRouter. Handles streaming SSE responses.
+
+## ToolDispatcher (`src/runner/ToolDispatcher.ts`)
+Routes tool calls to registered handlers. Returns errors for unknown tools.
+
+## SwarmRouter (`src/runner/SwarmRouter.ts`)
+Parallel sub-agent orchestration. Routes tasks to appropriate model tiers.
+
+## SessionManager (`src/session/SessionManager.ts`)
+Manages conversation state. Context pressure tracking (green/yellow/red/critical).
+
+## MemoryStore (`src/session/MemoryStore.ts`)
+Long-term conversation memory. JSONL per session. Searchable.
+
+## GoalManager (`src/session/GoalManager.ts`)
+Persistent cross-session goals. Add, complete, note.
+
+## ContextStore (`src/session/ContextStore.ts`)
+Task context folders for multi-step operations.
+
+## AgentScheduler (`src/scheduler/AgentScheduler.ts`)
+Cron and price-triggered scheduled tasks. Persisted to `~/.aiaiai/memory/schedule.json`.
+
+## PriceFeed (`src/tools/PriceFeed.ts`)
+DexScreener price data for any Solana token. 30s cache.
+
+## NewsSentiment (`src/tools/NewsSentiment.ts`)
+Crypto news with lexicon-based sentiment scoring. CryptoPanic API with fallback.
+
+## TechnicalAnalysis (`src/tools/TechnicalAnalysis.ts`)
+RSI, MACD, Bollinger Bands, EMA, SMA, ATR. Works with OHLCV candle data.
+
+## MarketSentiment (`src/tools/MarketSentiment.ts`)
+Fear & Greed, Binance funding rates, BTC mempool, DeFi TVL, Solana stats.
+
+## GmgnIntegration (`src/tools/GmgnIntegration.ts`)
+GMGN token research + smart money tracking + market data. Auto-manages `GMGN_API_KEY`.
+
+## AgentWallet (`src/wallet/AgentWallet.ts`)
+Reads cold + action + deposit wallet balances via public Solana RPC.
+
+## ActionFeed (`src/wallet/ActionFeed.ts`)
+Reads agent action wallet transactions. Classifies as buy/burn. Tracks fees.
+
+## ProviderRegistry (`src/providers/ProviderRegistry.ts`)
+All 29 AI model providers with env vars, endpoints, docs URLs.