pyre-agent-kit 1.0.0

package/dist/cli.js

@@ -0,0 +1,475 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * pyre-agent-kit CLI
+ *
+ * Interactive launcher for non-technical users.
+ *   npx pyre-agent-kit
+ *
+ * Config is saved to ~/.pyre-agent.json so you only set up once.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline = __importStar(require("readline"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const web3_js_1 = require("@solana/web3.js");
+const index_1 = require("./index");
+// ─── Constants ────────────────────────────────────────────────────
+const CONFIG_PATH = path.join(process.env.HOME ?? '.', '.pyre-agent.json');
+const BANNER = `
+ ██████╗ ██╗   ██╗██████╗ ███████╗
+ ██╔══██╗╚██╗ ██╔╝██╔══██╗██╔════╝
+ ██████╔╝ ╚████╔╝ ██████╔╝█████╗
+ ██╔═══╝   ╚██╔╝  ██╔══██╗██╔══╝
+ ██║        ██║   ██║  ██║███████╗
+ ╚═╝        ╚═╝   ╚═╝  ╚═╝╚══════╝
+         A G E N T   K I T
+`;
+const RPC_DEFAULTS = {
+    devnet: 'https://api.devnet.solana.com',
+    mainnet: 'https://api.mainnet-beta.solana.com',
+};
+const PERSONALITIES = ['loyalist', 'mercenary', 'provocateur', 'scout', 'whale'];
+const PERSONALITY_DISPLAY = {
+    loyalist: 'Loyalist    — ride-or-die, holds positions long',
+    mercenary: 'Mercenary   — plays every angle, frequent trades',
+    provocateur: 'Provocateur — chaos agent, heavy on comms and FUD',
+    scout: 'Scout       — intel-focused, small positions',
+    whale: 'Whale       — big positions, market mover',
+};
+function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_PATH)) {
+            return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+function saveConfig(config) {
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+// ─── Prompts ──────────────────────────────────────────────────────
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+function ask(question, fallback) {
+    const suffix = fallback ? ` (${fallback})` : '';
+    return new Promise(resolve => {
+        rl.question(`  ${question}${suffix}: `, answer => {
+            resolve(answer.trim() || fallback || '');
+        });
+    });
+}
+function choose(question, options, defaultIdx = 0) {
+    return new Promise(resolve => {
+        console.log(`\n  ${question}`);
+        options.forEach((opt, i) => {
+            const marker = i === defaultIdx ? '>' : ' ';
+            console.log(`   ${marker} ${i + 1}. ${opt}`);
+        });
+        rl.question(`  Choice [${defaultIdx + 1}]: `, answer => {
+            const n = parseInt(answer.trim());
+            if (n >= 1 && n <= options.length)
+                resolve(n - 1);
+            else
+                resolve(defaultIdx);
+        });
+    });
+}
+// ─── LLM Factory ─────────────────────────────────────────────────
+function createLLM(config) {
+    if (config.llmProvider === 'none')
+        return undefined;
+    if (config.llmProvider === 'openai') {
+        const apiKey = config.llmApiKey;
+        const model = config.llmModel || 'gpt-4o';
+        return {
+            generate: async (prompt) => {
+                const res = await fetch('https://api.openai.com/v1/chat/completions', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+                    body: JSON.stringify({
+                        model,
+                        messages: [{ role: 'user', content: prompt }],
+                        max_tokens: 120,
+                        temperature: 0.9,
+                    }),
+                });
+                if (!res.ok) {
+                    console.error(`  [LLM] OpenAI error: ${res.status}`);
+                    return null;
+                }
+                const data = await res.json();
+                return data.choices?.[0]?.message?.content ?? null;
+            },
+        };
+    }
+    if (config.llmProvider === 'anthropic') {
+        const apiKey = config.llmApiKey;
+        const model = config.llmModel || 'claude-sonnet-4-20250514';
+        return {
+            generate: async (prompt) => {
+                const res = await fetch('https://api.anthropic.com/v1/messages', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-api-key': apiKey,
+                        'anthropic-version': '2023-06-01',
+                    },
+                    body: JSON.stringify({
+                        model,
+                        max_tokens: 120,
+                        messages: [{ role: 'user', content: prompt }],
+                    }),
+                });
+                if (!res.ok) {
+                    console.error(`  [LLM] Anthropic error: ${res.status}`);
+                    return null;
+                }
+                const data = await res.json();
+                const block = data.content?.[0];
+                return block?.type === 'text' ? block.text : null;
+            },
+        };
+    }
+    if (config.llmProvider === 'ollama') {
+        const url = config.llmUrl || 'http://localhost:11434';
+        const model = config.llmModel || 'llama3';
+        return {
+            generate: async (prompt) => {
+                try {
+                    const res = await fetch(`${url}/api/generate`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ model, prompt, stream: false }),
+                    });
+                    if (!res.ok) {
+                        console.error(`  [LLM] Ollama error: ${res.status}`);
+                        return null;
+                    }
+                    const data = await res.json();
+                    return data.response ?? null;
+                }
+                catch (e) {
+                    console.error(`  [LLM] Ollama unreachable: ${e.message}`);
+                    return null;
+                }
+            },
+        };
+    }
+    return undefined;
+}
+// ─── Setup Wizard ─────────────────────────────────────────────────
+async function runSetup() {
+    console.log('\n  First-time setup. Config will be saved to ~/.pyre-agent.json\n');
+    // Network
+    const netIdx = await choose('Network:', ['Devnet (testing)', 'Mainnet (real SOL)'], 0);
+    const network = netIdx === 0 ? 'devnet' : 'mainnet';
+    // RPC
+    const rpcDefault = RPC_DEFAULTS[network];
+    const rpcUrl = await ask('RPC URL', rpcDefault);
+    // Keypair
+    console.log('\n  Wallet setup:');
+    const walletIdx = await choose('Keypair:', [
+        'Generate new wallet',
+        'Import from secret key (JSON array)',
+        'Import from file path',
+    ], 0);
+    let keypair;
+    if (walletIdx === 0) {
+        keypair = web3_js_1.Keypair.generate();
+        console.log(`\n  New wallet generated: ${keypair.publicKey.toBase58()}`);
+        console.log(`  Fund it with SOL before starting the agent.`);
+        if (network === 'devnet') {
+            console.log(`  Devnet faucet: https://faucet.solana.com`);
+        }
+    }
+    else if (walletIdx === 1) {
+        const raw = await ask('Paste secret key JSON array');
+        keypair = web3_js_1.Keypair.fromSecretKey(Uint8Array.from(JSON.parse(raw)));
+        console.log(`  Imported: ${keypair.publicKey.toBase58()}`);
+    }
+    else {
+        const filePath = await ask('Path to keypair JSON file');
+        const resolved = path.resolve(filePath.replace(/^~/, process.env.HOME ?? '.'));
+        const raw = JSON.parse(fs.readFileSync(resolved, 'utf-8'));
+        keypair = web3_js_1.Keypair.fromSecretKey(Uint8Array.from(raw));
+        console.log(`  Imported: ${keypair.publicKey.toBase58()}`);
+    }
+    // Personality
+    const persIdx = await choose('Personality:', [
+        ...PERSONALITIES.map(p => PERSONALITY_DISPLAY[p]),
+        'Random (auto-assign)',
+    ], 5);
+    const personality = persIdx < PERSONALITIES.length ? PERSONALITIES[persIdx] : PERSONALITIES[Math.floor(Math.random() * PERSONALITIES.length)];
+    // LLM
+    const llmIdx = await choose('LLM Provider:', [
+        'OpenAI (GPT-4o, etc.)',
+        'Anthropic (Claude)',
+        'Ollama (local)',
+        'None (random actions only)',
+    ], 0);
+    const llmProviders = ['openai', 'anthropic', 'ollama', 'none'];
+    const llmProvider = llmProviders[llmIdx];
+    let llmApiKey;
+    let llmModel;
+    let llmUrl;
+    if (llmProvider === 'openai') {
+        llmApiKey = await ask('OpenAI API key');
+        llmModel = await ask('Model', 'gpt-4o');
+    }
+    else if (llmProvider === 'anthropic') {
+        llmApiKey = await ask('Anthropic API key');
+        llmModel = await ask('Model', 'claude-sonnet-4-20250514');
+    }
+    else if (llmProvider === 'ollama') {
+        llmUrl = await ask('Ollama URL', 'http://localhost:11434');
+        llmModel = await ask('Model (e.g. llama3, gemma3:4b, mistral)', 'llama3');
+    }
+    // Tick interval
+    const intervalStr = await ask('Seconds between actions', '30');
+    const tickIntervalMs = Math.max(5, parseInt(intervalStr) || 30) * 1000;
+    // Vault funding
+    const fundStr = await ask('Stronghold vault funding (SOL)', '35');
+    const strongholdFundSol = Math.max(0.1, parseFloat(fundStr) || 35);
+    const config = {
+        network,
+        rpcUrl,
+        secretKey: Array.from(keypair.secretKey),
+        personality,
+        llmProvider,
+        llmModel,
+        llmApiKey,
+        llmUrl,
+        strongholdFundSol,
+        tickIntervalMs,
+    };
+    saveConfig(config);
+    console.log(`\n  Config saved to ${CONFIG_PATH}`);
+    return config;
+}
+// ─── Agent Loop ───────────────────────────────────────────────────
+function ts() {
+    return new Date().toISOString().substr(11, 8);
+}
+async function runAgent(config) {
+    const connection = new web3_js_1.Connection(config.rpcUrl, 'confirmed');
+    const keypair = web3_js_1.Keypair.fromSecretKey(Uint8Array.from(config.secretKey));
+    const llm = createLLM(config);
+    console.log(`\n  Network:     ${config.network}`);
+    console.log(`  Wallet:      ${keypair.publicKey.toBase58()}`);
+    console.log(`  Personality: ${config.personality}`);
+    console.log(`  LLM:         ${config.llmProvider}${config.llmModel ? ` (${config.llmModel})` : ''}`);
+    console.log(`  Tick:        every ${config.tickIntervalMs / 1000}s`);
+    // Check balance
+    const balance = await connection.getBalance(keypair.publicKey);
+    const solBalance = balance / web3_js_1.LAMPORTS_PER_SOL;
+    console.log(`  Balance:     ${solBalance.toFixed(4)} SOL`);
+    if (solBalance < 0.01) {
+        console.error(`\n  Wallet has insufficient SOL. Fund it and try again.`);
+        console.error(`  Address: ${keypair.publicKey.toBase58()}`);
+        if (config.network === 'devnet') {
+            console.error(`  Devnet faucet: https://faucet.solana.com`);
+        }
+        process.exit(1);
+    }
+    // Load saved state if it exists
+    const statePath = path.join(process.env.HOME ?? '.', `.pyre-agent-state-${keypair.publicKey.toBase58().slice(0, 8)}.json`);
+    let state;
+    try {
+        if (fs.existsSync(statePath)) {
+            state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            console.log(`  State:       restored from ${path.basename(statePath)}`);
+        }
+    }
+    catch { /* fresh start */ }
+    console.log(`\n  Starting agent...\n`);
+    const agent = await (0, index_1.createPyreAgent)({
+        connection,
+        keypair,
+        network: config.network,
+        llm,
+        personality: config.personality,
+        strongholdFundSol: config.strongholdFundSol,
+        solRange: config.solRange,
+        state,
+        logger: (msg) => console.log(`  [${ts()}] ${msg}`),
+    });
+    console.log(`  Agent online: ${agent.publicKey.slice(0, 8)}... (${agent.personality})\n`);
+    // Graceful shutdown
+    let running = true;
+    const shutdown = () => {
+        if (!running)
+            return;
+        running = false;
+        console.log(`\n  Shutting down...`);
+        const saved = agent.serialize();
+        fs.writeFileSync(statePath, JSON.stringify(saved, null, 2));
+        console.log(`  State saved to ${path.basename(statePath)}`);
+        console.log(`  ${saved.actionCount} total actions performed.`);
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    // Auto-save every 10 ticks
+    let tickCount = 0;
+    while (running) {
+        try {
+            const result = await agent.tick();
+            tickCount++;
+            const status = result.success ? 'OK' : `FAIL: ${result.error}`;
+            const msg = result.message ? ` "${result.message}"` : '';
+            const brain = result.usedLLM ? 'LLM' : 'RNG';
+            console.log(`  [${ts()}] #${tickCount} [${brain}] ${result.action.toUpperCase()} ${result.faction ?? ''}${msg} — ${status}`);
+            // Auto-save state every 10 ticks
+            if (tickCount % 10 === 0) {
+                const saved = agent.serialize();
+                fs.writeFileSync(statePath, JSON.stringify(saved, null, 2));
+            }
+        }
+        catch (e) {
+            console.error(`  [${ts()}] Tick error: ${e.message}`);
+        }
+        // Wait for next tick
+        await new Promise(resolve => setTimeout(resolve, config.tickIntervalMs));
+    }
+}
+// ─── Main ─────────────────────────────────────────────────────────
+async function main() {
+    console.log(BANNER);
+    const args = process.argv.slice(2);
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log('  Usage: npx pyre-agent-kit [options]');
+        console.log('');
+        console.log('  Options:');
+        console.log('    --setup     Re-run full setup wizard');
+        console.log('    --model     Change LLM provider/model only');
+        console.log('    --personality  Change personality only');
+        console.log('    --reset     Delete saved config and start fresh');
+        console.log('    --status    Show current config and wallet balance');
+        console.log('    --help      Show this help message');
+        console.log('');
+        console.log(`  Config: ${CONFIG_PATH}`);
+        console.log('');
+        process.exit(0);
+    }
+    if (args.includes('--reset')) {
+        if (fs.existsSync(CONFIG_PATH)) {
+            fs.unlinkSync(CONFIG_PATH);
+            console.log(`  Config deleted: ${CONFIG_PATH}`);
+        }
+        else {
+            console.log('  No config to delete.');
+        }
+        process.exit(0);
+    }
+    let config = loadConfig();
+    if (args.includes('--model') && config) {
+        console.log(`  Current: ${config.llmProvider}${config.llmModel ? ` (${config.llmModel})` : ''}\n`);
+        const llmIdx = await choose('LLM Provider:', [
+            'OpenAI (GPT-4o, etc.)',
+            'Anthropic (Claude)',
+            'Ollama (local)',
+            'None (random actions only)',
+        ], ['openai', 'anthropic', 'ollama', 'none'].indexOf(config.llmProvider));
+        const llmProviders = ['openai', 'anthropic', 'ollama', 'none'];
+        config.llmProvider = llmProviders[llmIdx];
+        config.llmApiKey = undefined;
+        config.llmModel = undefined;
+        config.llmUrl = undefined;
+        if (config.llmProvider === 'openai') {
+            config.llmApiKey = await ask('OpenAI API key');
+            config.llmModel = await ask('Model', 'gpt-4o');
+        }
+        else if (config.llmProvider === 'anthropic') {
+            config.llmApiKey = await ask('Anthropic API key');
+            config.llmModel = await ask('Model', 'claude-sonnet-4-20250514');
+        }
+        else if (config.llmProvider === 'ollama') {
+            config.llmUrl = await ask('Ollama URL', config.llmUrl || 'http://localhost:11434');
+            config.llmModel = await ask('Model (e.g. llama3, gemma3:4b, mistral)', 'llama3');
+        }
+        saveConfig(config);
+        console.log(`\n  Updated: ${config.llmProvider}${config.llmModel ? ` (${config.llmModel})` : ''}`);
+        console.log(`  Saved to ${CONFIG_PATH}\n`);
+        rl.close();
+        process.exit(0);
+    }
+    if (args.includes('--personality') && config) {
+        console.log(`  Current: ${config.personality}\n`);
+        const persIdx = await choose('Personality:', [
+            ...PERSONALITIES.map(p => PERSONALITY_DISPLAY[p]),
+            'Random (auto-assign)',
+        ], PERSONALITIES.indexOf(config.personality));
+        config.personality = persIdx < PERSONALITIES.length
+            ? PERSONALITIES[persIdx]
+            : PERSONALITIES[Math.floor(Math.random() * PERSONALITIES.length)];
+        saveConfig(config);
+        console.log(`\n  Updated: ${config.personality}`);
+        console.log(`  Saved to ${CONFIG_PATH}\n`);
+        rl.close();
+        process.exit(0);
+    }
+    if (args.includes('--setup') || !config) {
+        config = await runSetup();
+    }
+    if (args.includes('--status')) {
+        console.log(`  Config: ${CONFIG_PATH}`);
+        console.log(`  Network:     ${config.network}`);
+        console.log(`  RPC:         ${config.rpcUrl}`);
+        const kp = web3_js_1.Keypair.fromSecretKey(Uint8Array.from(config.secretKey));
+        console.log(`  Wallet:      ${kp.publicKey.toBase58()}`);
+        console.log(`  Personality: ${config.personality}`);
+        console.log(`  LLM:         ${config.llmProvider}${config.llmModel ? ` (${config.llmModel})` : ''}`);
+        console.log(`  Tick:        every ${config.tickIntervalMs / 1000}s`);
+        try {
+            const connection = new web3_js_1.Connection(config.rpcUrl, 'confirmed');
+            const balance = await connection.getBalance(kp.publicKey);
+            console.log(`  Balance:     ${(balance / web3_js_1.LAMPORTS_PER_SOL).toFixed(4)} SOL`);
+        }
+        catch {
+            console.log(`  Balance:     (could not reach RPC)`);
+        }
+        console.log('');
+        rl.close();
+        process.exit(0);
+    }
+    rl.close();
+    await runAgent(config);
+}
+main().catch(e => {
+    console.error(`\n  Fatal: ${e.message}`);
+    process.exit(1);
+});

package/dist/defaults.d.ts

@@ -0,0 +1,10 @@
+import { Personality } from './types';
+export declare const PERSONALITY_WEIGHTS: Record<Personality, number[]>;
+export declare const PERSONALITY_SOL: Record<Personality, [number, number]>;
+export declare const personalityDesc: Record<Personality, string>;
+export declare const VOICE_NUDGES: string[];
+export declare const ACTION_MAP: Record<string, string>;
+export declare const STRONGHOLD_FUND_SOL = 35;
+export declare const STRONGHOLD_TOPUP_THRESHOLD_SOL = 5;
+export declare const STRONGHOLD_TOPUP_RESERVE_SOL = 5;
+export declare const assignPersonality: () => Personality;

package/dist/defaults.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignPersonality = exports.STRONGHOLD_TOPUP_RESERVE_SOL = exports.STRONGHOLD_TOPUP_THRESHOLD_SOL = exports.STRONGHOLD_FUND_SOL = exports.ACTION_MAP = exports.VOICE_NUDGES = exports.personalityDesc = exports.PERSONALITY_SOL = exports.PERSONALITY_WEIGHTS = void 0;
+// ─── Personality Weights ────────────────────────────────────────────
+// [join, defect, rally, launch, message, stronghold, war_loan, repay_loan, siege, ascend, raze, tithe, infiltrate, fud]
+exports.PERSONALITY_WEIGHTS = {
+    loyalist: [0.28, 0.06, 0.14, 0.02, 0.12, 0.06, 0.04, 0.04, 0.02, 0.05, 0.02, 0.10, 0.02, 0.03],
+    mercenary: [0.16, 0.18, 0.04, 0.02, 0.08, 0.04, 0.08, 0.04, 0.06, 0.03, 0.04, 0.03, 0.12, 0.08],
+    provocateur: [0.12, 0.08, 0.04, 0.06, 0.18, 0.05, 0.04, 0.03, 0.04, 0.03, 0.05, 0.04, 0.12, 0.12],
+    scout: [0.18, 0.10, 0.08, 0.02, 0.16, 0.04, 0.04, 0.03, 0.06, 0.04, 0.05, 0.04, 0.08, 0.08],
+    whale: [0.24, 0.14, 0.06, 0.02, 0.06, 0.06, 0.06, 0.04, 0.02, 0.04, 0.04, 0.04, 0.12, 0.06],
+};
+// SOL spend ranges per personality
+exports.PERSONALITY_SOL = {
+    loyalist: [0.02, 0.1],
+    mercenary: [0.01, 0.08],
+    provocateur: [0.005, 0.05],
+    scout: [0.005, 0.03],
+    whale: [0.1, 0.5],
+};
+exports.personalityDesc = {
+    loyalist: 'You\'re ride or die for your factions. Talk trash about rival factions unprompted. Hype your crew loudly and call out anyone who defects — by address. Propose quests and challenges for your allies. You take it personally when someone dumps your faction.',
+    mercenary: 'You\'re a lone wolf who plays every angle. Trash talk factions you\'re about to leave. Drop alpha only when it benefits you. Challenge others to prove their conviction. You don\'t need allies — everyone else is just a trade.',
+    provocateur: 'You live for chaos and hot takes. Call out the biggest holder in any faction. Start beef between factions. Make bold predictions and dare people to bet against you. Your trash talk is creative and specific — reference actual agents, numbers, and moves.',
+    scout: 'You\'re the intel operative who sees everything. Drop suspicious observations about other agents\' moves. Question why someone just bought or sold. Share data that makes people nervous. You\'re helpful to allies but plant doubt in everyone else.',
+    whale: 'You move markets and everyone knows it. Flex your position size. Trash talk small holders. Challenge other whales publicly. When you speak, people listen — and you know it. Back your words with big moves.',
+};
+exports.VOICE_NUDGES = [
+    'JOIN a faction you\'ve been eyeing. Put your money where your mouth is.',
+    'DEFECT from a faction that\'s underperforming. Cut your losses.',
+    'INFILTRATE a rival faction. Sneak in before they notice.',
+    'FUD a faction you hold — spread doubt and buy the dip later.',
+    'Take a WAR_LOAN against your strongest position. Leverage up.',
+    'JOIN the top faction on the leaderboard. Ride the momentum.',
+    'DEFECT dramatically. Trash talk on the way out.',
+    'INFILTRATE the weakest faction. Easy target.',
+    'FUD whoever is in first place. Knock them down a peg.',
+    'RALLY a faction you believe in. Show support.',
+    'JOIN a small faction early. Get in before the crowd.',
+    'Double down. REINFORCE your best position.',
+    'Call out a specific agent by address. What are they up to?',
+    'Trash talk a rival faction. Be specific about why they\'re weak.',
+    'Flex on your position. You\'re winning and everyone should know.',
+    'Be suspicious. Something doesn\'t add up. Who\'s dumping?',
+    'Challenge another agent directly. Dare them to make a move.',
+    'Drop a hot take that will start an argument.',
+    'Hype your faction aggressively. Why is everyone else sleeping on it?',
+    'Sound like you know something others don\'t. Be cryptic.',
+    'React to a recent trade or move. Call it smart or stupid.',
+    'Ask a loaded question. You already know the answer.',
+    'Be disappointed in someone. They let the faction down.',
+    'Make a bold prediction. Put your reputation on it.',
+    'Sound paranoid. Someone is coordinating against you.',
+    'Be sarcastic about a faction that\'s underperforming.',
+    'Propose a quest or challenge — but make it competitive.',
+    'Reference a specific number — holder count, percentage, or trend.',
+    'Write a one-liner. Punchy. Sarcastic. No explanation needed.',
+    'Sound like you\'re warning an ally about something you saw.',
+];
+exports.ACTION_MAP = {
+    'JOIN': 'JOIN', 'DEFECT': 'DEFECT', 'RALLY': 'RALLY', 'LAUNCH': 'LAUNCH',
+    'MESSAGE': 'MESSAGE', 'STRONGHOLD': 'STRONGHOLD', 'WAR_LOAN': 'WAR_LOAN',
+    'REPAY_LOAN': 'REPAY_LOAN', 'SIEGE': 'SIEGE', 'ASCEND': 'ASCEND',
+    'RAZE': 'RAZE', 'TITHE': 'TITHE', 'INFILTRATE': 'INFILTRATE', 'FUD': 'FUD',
+    // Aliases
+    'BUY': 'JOIN', 'INVEST': 'JOIN', 'ENTER': 'JOIN', 'JOINING': 'JOIN', 'BUYING': 'JOIN', 'INVESTING': 'JOIN',
+    'REINFORCE': 'JOIN', 'INCREASE': 'JOIN', 'GATHER': 'JOIN',
+    'SELL': 'DEFECT', 'DUMP': 'DEFECT', 'EXIT': 'DEFECT', 'LEAVE': 'DEFECT', 'DEFECTING': 'DEFECT', 'DEFECTION': 'DEFECT', 'SELLING': 'DEFECT', 'DUMPING': 'DEFECT',
+    'WARN': 'FUD', 'ATTACK': 'SIEGE', 'LIQUIDATE': 'SIEGE',
+    'BORROW': 'WAR_LOAN', 'LOAN': 'WAR_LOAN',
+    'REPAY': 'REPAY_LOAN', 'STAR': 'RALLY', 'VOTE': 'RALLY', 'SUPPORT': 'RALLY',
+    'SEND': 'MESSAGE', 'SAY': 'MESSAGE', 'CHAT': 'MESSAGE', 'MSG': 'MESSAGE', 'MESSAGING': 'MESSAGE',
+    'CREATE': 'LAUNCH', 'FOUND': 'LAUNCH', 'HARVEST': 'TITHE',
+    'MIGRATE': 'ASCEND', 'RECLAIM': 'RAZE', 'SPY': 'INFILTRATE',
+    'INVESTIGATION': 'INFILTRATE', 'INVESTIGATE': 'INFILTRATE', 'SCOUT': 'INFILTRATE', 'RECON': 'INFILTRATE',
+    'PLEDGE': 'JOIN', 'ALLY': 'JOIN', 'BACK': 'JOIN', 'FUND': 'JOIN',
+    'WITHDRAW': 'DEFECT', 'RETREAT': 'DEFECT', 'ABANDON': 'DEFECT', 'BAIL': 'DEFECT',
+    'ANNOUNCE': 'MESSAGE', 'BROADCAST': 'MESSAGE', 'COMM': 'MESSAGE', 'COMMS': 'MESSAGE', 'REPORT': 'MESSAGE',
+    'SMEAR': 'FUD', 'SLANDER': 'FUD', 'DISCREDIT': 'FUD', 'SABOTAGE': 'FUD', 'UNDERMINE': 'FUD', 'ARGUE': 'FUD', 'TRASH': 'FUD', 'CRITICIZE': 'FUD', 'MOCK': 'FUD', 'FUDS': 'FUD',
+    'ENDORSE': 'RALLY', 'PROMOTE': 'RALLY', 'BOOST': 'RALLY',
+    // Common misspellings
+    'DEFLECT': 'DEFECT', 'DEFEKT': 'DEFECT', 'DEFCT': 'DEFECT', 'DEFFECT': 'DEFECT',
+    'JION': 'JOIN', 'JOING': 'JOIN', 'JOIIN': 'JOIN',
+    'RALEY': 'RALLY', 'RALY': 'RALLY', 'RALLLY': 'RALLY',
+    'LANCH': 'LAUNCH', 'LAUCH': 'LAUNCH',
+    'MESAGE': 'MESSAGE', 'MESSGE': 'MESSAGE', 'MASSGE': 'MESSAGE', 'MESS': 'MESSAGE', 'MESSENGER': 'MESSAGE', 'MESSAGES': 'MESSAGE',
+    'SEIGE': 'SIEGE', 'SEIG': 'SIEGE',
+    'INFLTRATE': 'INFILTRATE', 'INFILTRTE': 'INFILTRATE', 'INFILTRATING': 'INFILTRATE', 'INFIL': 'INFILTRATE', 'INFILTRAT': 'INFILTRATE',
+    'ALERT': 'FUD', 'EXPOSE': 'FUD',
+    'QUESTION': 'MESSAGE', 'ASK': 'MESSAGE', 'TAUNT': 'FUD', 'RALLYING': 'RALLY',
+    'TICKER': 'MESSAGE', 'ACTION': 'MESSAGE', // LLM copies placeholder words from prompt
+};
+// Stronghold defaults
+exports.STRONGHOLD_FUND_SOL = 35;
+exports.STRONGHOLD_TOPUP_THRESHOLD_SOL = 5;
+exports.STRONGHOLD_TOPUP_RESERVE_SOL = 5;
+const assignPersonality = () => {
+    const personalities = ['loyalist', 'mercenary', 'provocateur', 'scout', 'whale'];
+    const weights = [0.30, 0.25, 0.15, 0.20, 0.10];
+    const roll = Math.random();
+    let cumulative = 0;
+    for (let i = 0; i < weights.length; i++) {
+        cumulative += weights[i];
+        if (roll < cumulative)
+            return personalities[i];
+    }
+    return 'loyalist';
+};
+exports.assignPersonality = assignPersonality;

package/dist/error.d.ts

@@ -0,0 +1,6 @@
+export declare const PROGRAM_ERRORS: Record<number, string>;
+export declare const SKIP_ERRORS: Set<number>;
+export declare const parseCustomError: (err: any) => {
+    code: number;
+    name: string;
+} | null;

package/dist/error.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCustomError = exports.SKIP_ERRORS = exports.PROGRAM_ERRORS = void 0;
+// ─── Program Error Codes ────────────────────────────────────────────
+exports.PROGRAM_ERRORS = {
+    6000: 'MathOverflow',
+    6001: 'SlippageExceeded',
+    6002: 'MaxWalletExceeded (2% cap)',
+    6003: 'InsufficientTokens',
+    6004: 'InsufficientSol',
+    6005: 'InsufficientUserBalance',
+    6006: 'BondingComplete',
+    6007: 'BondingNotComplete',
+    6008: 'AlreadyVoted',
+    6009: 'NoTokensToVote',
+    6010: 'AlreadyMigrated',
+    6011: 'InvalidAuthority',
+    6012: 'AmountTooSmall',
+    6013: 'ProtocolPaused',
+    6014: 'ZeroAmount',
+    6022: 'VoteRequired',
+    6030: 'NotMigrated',
+    6044: 'LendingNotEnabled',
+    6045: 'LendingRequiresMigration',
+    6046: 'LtvExceeded',
+    6047: 'LendingCapExceeded',
+    6048: 'UserBorrowCapExceeded',
+    6049: 'BorrowTooSmall (min 0.1 SOL)',
+    6050: 'NoActiveLoan',
+    6051: 'NotLiquidatable',
+    6052: 'EmptyBorrowRequest',
+    6053: 'RepayExceedsDebt',
+    6054: 'InvalidPoolAccount',
+    6055: 'InsufficientVaultBalance',
+    6056: 'VaultUnauthorized',
+    6057: 'WalletNotLinked',
+    // Token-2022 / SPL errors
+    2505: 'InsufficientFunds (token balance too low)',
+};
+// Errors that mean "don't retry this action on this faction right now"
+exports.SKIP_ERRORS = new Set([
+    6002, // MaxWalletExceeded — already at 2% cap
+    6006, // BondingComplete — use DEX instead
+    6007, // BondingNotComplete — can't migrate yet
+    6010, // AlreadyMigrated
+    6044, // LendingNotEnabled
+    6045, // LendingRequiresMigration
+    6047, // LendingCapExceeded
+    6051, // NotLiquidatable
+]);
+const parseCustomError = (err) => {
+    const msg = err?.message || String(err);
+    // Match "custom program error: 0x1772" or "Custom: 6002"
+    const hexMatch = msg.match(/custom program error:\s*0x([0-9a-fA-F]+)/i);
+    if (hexMatch) {
+        const code = parseInt(hexMatch[1], 16);
+        return { code, name: exports.PROGRAM_ERRORS[code] || `Unknown(${code})` };
+    }
+    const decMatch = msg.match(/Custom:\s*(\d+)/);
+    if (decMatch) {
+        const code = parseInt(decMatch[1], 10);
+        return { code, name: exports.PROGRAM_ERRORS[code] || `Unknown(${code})` };
+    }
+    return null;
+};
+exports.parseCustomError = parseCustomError;