pyre-agent-kit 1.0.0

package/dist/executor.d.ts

@@ -0,0 +1,24 @@
+import { Connection } from '@solana/web3.js';
+import { AgentState, FactionInfo, LLMAdapter, LLMDecision } from './types';
+interface ExecutorContext {
+    connection: Connection;
+    agent: AgentState;
+    factions: FactionInfo[];
+    decision: LLMDecision;
+    brain: string;
+    log: (msg: string) => void;
+    llm?: LLMAdapter;
+    maxFoundedFactions: number;
+    usedFactionNames: Set<string>;
+    strongholdOpts?: {
+        fundSol?: number;
+        topupThresholdSol?: number;
+        topupReserveSol?: number;
+    };
+}
+export declare function executeAction(ctx: ExecutorContext): Promise<{
+    success: boolean;
+    description?: string;
+    error?: string;
+}>;
+export {};

package/dist/executor.js

@@ -0,0 +1,409 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAction = executeAction;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const pyre_world_kit_1 = require("pyre-world-kit");
+const defaults_1 = require("./defaults");
+const tx_1 = require("./tx");
+const stronghold_1 = require("./stronghold");
+const action_1 = require("./action");
+const error_1 = require("./error");
+const faction_1 = require("./faction");
+const findFaction = (factions, symbol) => factions.find(f => f.symbol === symbol);
+const handlers = {
+    async join(ctx) {
+        const faction = findFaction(ctx.factions, ctx.decision.faction);
+        if (!faction)
+            return null;
+        const sol = ctx.decision.sol ?? (0, action_1.sentimentBuySize)(ctx.agent, faction.mint);
+        const lamports = Math.floor(sol * web3_js_1.LAMPORTS_PER_SOL);
+        await (0, stronghold_1.ensureStronghold)(ctx.connection, ctx.agent, ctx.log, ctx.strongholdOpts);
+        if (!ctx.agent.hasStronghold)
+            return null;
+        if (faction.status === 'ascended') {
+            const result = await (0, pyre_world_kit_1.tradeOnDex)(ctx.connection, {
+                mint: faction.mint, signer: ctx.agent.publicKey, stronghold_creator: ctx.agent.publicKey,
+                amount_in: lamports, minimum_amount_out: 1, is_buy: true, message: ctx.decision.message,
+            });
+            await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        }
+        else {
+            const alreadyVoted = ctx.agent.voted.has(faction.mint);
+            const params = {
+                mint: faction.mint, agent: ctx.agent.publicKey, amount_sol: lamports,
+                message: ctx.decision.message, stronghold: ctx.agent.publicKey,
+            };
+            if (!alreadyVoted)
+                params.strategy = Math.random() > 0.5 ? 'fortify' : 'scorched_earth';
+            const result = await (0, pyre_world_kit_1.joinFaction)(ctx.connection, params);
+            await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        }
+        const prev = ctx.agent.holdings.get(faction.mint) ?? 0;
+        ctx.agent.holdings.set(faction.mint, prev + 1);
+        ctx.agent.voted.add(faction.mint);
+        ctx.agent.lastAction = `joined ${faction.symbol}`;
+        return `joined ${faction.symbol} for ${sol.toFixed(4)} SOL${ctx.decision.message ? ` — "${ctx.decision.message}"` : ''}`;
+    },
+    async defect(ctx) {
+        const faction = findFaction(ctx.factions, ctx.decision.faction);
+        if (!faction)
+            return null;
+        let balance;
+        try {
+            const mint = new web3_js_1.PublicKey(faction.mint);
+            const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, new web3_js_1.PublicKey(ctx.agent.publicKey), false, spl_token_1.TOKEN_2022_PROGRAM_ID);
+            const info = await ctx.connection.getTokenAccountBalance(ata);
+            balance = Number(info.value.amount);
+        }
+        catch {
+            ctx.agent.holdings.delete(faction.mint);
+            return null;
+        }
+        if (balance <= 0) {
+            ctx.agent.holdings.delete(faction.mint);
+            return null;
+        }
+        const isInfiltrated = ctx.agent.infiltrated.has(faction.mint);
+        const sellPortion = isInfiltrated ? 1.0
+            : ctx.agent.personality === 'mercenary' ? 0.5 + Math.random() * 0.5
+                : 0.2 + Math.random() * 0.3;
+        const sellAmount = Math.max(1, Math.floor(balance * sellPortion));
+        if (faction.status === 'ascended') {
+            await (0, stronghold_1.ensureStronghold)(ctx.connection, ctx.agent, ctx.log, ctx.strongholdOpts);
+            if (!ctx.agent.hasStronghold)
+                return null;
+            const result = await (0, pyre_world_kit_1.tradeOnDex)(ctx.connection, {
+                mint: faction.mint, signer: ctx.agent.publicKey, stronghold_creator: ctx.agent.publicKey,
+                amount_in: sellAmount, minimum_amount_out: 1, is_buy: false, message: ctx.decision.message,
+            });
+            await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        }
+        else {
+            const result = await (0, pyre_world_kit_1.defect)(ctx.connection, {
+                mint: faction.mint, agent: ctx.agent.publicKey, amount_tokens: sellAmount,
+                message: ctx.decision.message, stronghold: ctx.agent.publicKey,
+            });
+            await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        }
+        const remaining = balance - sellAmount;
+        if (remaining <= 0) {
+            ctx.agent.holdings.delete(faction.mint);
+            ctx.agent.infiltrated.delete(faction.mint);
+        }
+        else {
+            ctx.agent.holdings.set(faction.mint, remaining);
+        }
+        const prefix = isInfiltrated ? 'dumped (infiltration complete)' : 'defected from';
+        ctx.agent.lastAction = `defected ${faction.symbol}`;
+        return `${prefix} ${faction.symbol}${ctx.decision.message ? ` — "${ctx.decision.message}"` : ''}`;
+    },
+    async rally(ctx) {
+        const faction = findFaction(ctx.factions, ctx.decision.faction);
+        if (!faction || ctx.agent.rallied.has(faction.mint))
+            return null;
+        const result = await (0, pyre_world_kit_1.rally)(ctx.connection, {
+            mint: faction.mint, agent: ctx.agent.publicKey, stronghold: ctx.agent.publicKey,
+        });
+        await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        ctx.agent.rallied.add(faction.mint);
+        ctx.agent.lastAction = `rallied ${faction.symbol}`;
+        return `rallied ${faction.symbol}`;
+    },
+    async launch(ctx) {
+        if (ctx.agent.founded.length >= ctx.maxFoundedFactions)
+            return null;
+        let name = null;
+        let symbol = null;
+        const identity = await (0, faction_1.generateFactionIdentity)(ctx.agent.personality, ctx.usedFactionNames, ctx.llm);
+        if (identity) {
+            name = identity.name;
+            symbol = identity.symbol;
+        }
+        else {
+            for (let i = 0; i < faction_1.FALLBACK_FACTION_NAMES.length; i++) {
+                if (!ctx.usedFactionNames.has(faction_1.FALLBACK_FACTION_NAMES[i])) {
+                    name = faction_1.FALLBACK_FACTION_NAMES[i];
+                    symbol = faction_1.FALLBACK_FACTION_SYMBOLS[i];
+                    break;
+                }
+            }
+        }
+        if (!name || !symbol)
+            return null;
+        const metadataUri = `https://pyre.gg/factions/${symbol.toLowerCase()}.json`;
+        const result = await (0, pyre_world_kit_1.launchFaction)(ctx.connection, {
+            founder: ctx.agent.publicKey, name, symbol, metadata_uri: metadataUri, community_faction: true,
+        });
+        await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        const mint = result.mint.toBase58();
+        ctx.agent.founded.push(mint);
+        ctx.factions.push({ mint, name, symbol, status: 'rising' });
+        ctx.usedFactionNames.add(name);
+        ctx.agent.lastAction = `launched ${symbol}`;
+        return `launched [${symbol}] ${name} (${(0, pyre_world_kit_1.isPyreMint)(mint) ? 'py' : 'no-vanity'})`;
+    },
+    async message(ctx) {
+        const faction = findFaction(ctx.factions, ctx.decision.faction);
+        if (!faction || !ctx.decision.message)
+            return null;
+        await (0, stronghold_1.ensureStronghold)(ctx.connection, ctx.agent, ctx.log, ctx.strongholdOpts);
+        if (!ctx.agent.hasStronghold)
+            return null;
+        let result = await (0, pyre_world_kit_1.messageFaction)(ctx.connection, {
+            mint: faction.mint, agent: ctx.agent.publicKey, message: ctx.decision.message,
+            stronghold: ctx.agent.publicKey, ascended: faction.status === 'ascended',
+            first_buy: !ctx.agent.voted.has(faction.mint),
+        });
+        try {
+            await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        }
+        catch (retryErr) {
+            const p = (0, error_1.parseCustomError)(retryErr);
+            if (p && p.code === 6008) {
+                ctx.agent.voted.add(faction.mint);
+                result = await (0, pyre_world_kit_1.messageFaction)(ctx.connection, {
+                    mint: faction.mint, agent: ctx.agent.publicKey, message: ctx.decision.message,
+                    stronghold: ctx.agent.publicKey, ascended: faction.status === 'ascended', first_buy: false,
+                });
+                await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+            }
+            else {
+                throw retryErr;
+            }
+        }
+        const prev = ctx.agent.holdings.get(faction.mint) ?? 0;
+        ctx.agent.holdings.set(faction.mint, prev + 1);
+        ctx.agent.voted.add(faction.mint);
+        ctx.agent.lastAction = `messaged ${faction.symbol}`;
+        return `said in ${faction.symbol}: "${ctx.decision.message}"`;
+    },
+    async stronghold(ctx) {
+        if (ctx.agent.hasStronghold)
+            return null;
+        const result = await (0, pyre_world_kit_1.createStronghold)(ctx.connection, { creator: ctx.agent.publicKey });
+        await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        ctx.agent.hasStronghold = true;
+        const fundAmt = Math.floor((ctx.strongholdOpts?.fundSol ?? defaults_1.STRONGHOLD_FUND_SOL) * web3_js_1.LAMPORTS_PER_SOL);
+        try {
+            const fundResult = await (0, pyre_world_kit_1.fundStronghold)(ctx.connection, {
+                depositor: ctx.agent.publicKey, stronghold_creator: ctx.agent.publicKey, amount_sol: fundAmt,
+            });
+            await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, fundResult);
+        }
+        catch { /* fund failed, stronghold still created */ }
+        ctx.agent.lastAction = 'created stronghold';
+        return `created stronghold + funded ${(fundAmt / web3_js_1.LAMPORTS_PER_SOL).toFixed(1)} SOL`;
+    },
+    async war_loan(ctx) {
+        const faction = findFaction(ctx.factions, ctx.decision.faction);
+        if (!faction)
+            return null;
+        const balance = ctx.agent.holdings.get(faction.mint) ?? 0;
+        if (balance <= 0)
+            return null;
+        const collateral = Math.max(1, Math.floor(balance * (0.90 + Math.random() * 0.09)));
+        let borrowLamports;
+        try {
+            const quote = await (0, pyre_world_kit_1.getMaxWarLoan)(ctx.connection, faction.mint, collateral);
+            if (quote.max_borrow_sol < 0.1 * web3_js_1.LAMPORTS_PER_SOL)
+                return null;
+            borrowLamports = Math.floor(quote.max_borrow_sol * (0.80 + Math.random() * 0.15));
+        }
+        catch {
+            borrowLamports = Math.floor(0.1 * web3_js_1.LAMPORTS_PER_SOL);
+        }
+        await (0, stronghold_1.ensureStronghold)(ctx.connection, ctx.agent, ctx.log, ctx.strongholdOpts);
+        const result = await (0, pyre_world_kit_1.requestWarLoan)(ctx.connection, {
+            mint: faction.mint, borrower: ctx.agent.publicKey, collateral_amount: collateral,
+            sol_to_borrow: borrowLamports, stronghold: ctx.agent.publicKey,
+        });
+        await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        ctx.agent.activeLoans.add(faction.mint);
+        ctx.agent.lastAction = `war loan ${faction.symbol}`;
+        return `took war loan on ${faction.symbol} (${collateral} tokens, ${(borrowLamports / web3_js_1.LAMPORTS_PER_SOL).toFixed(3)} SOL)`;
+    },
+    async repay_loan(ctx) {
+        const faction = findFaction(ctx.factions, ctx.decision.faction);
+        if (!faction || !ctx.agent.activeLoans.has(faction.mint))
+            return null;
+        let loan;
+        try {
+            loan = await (0, pyre_world_kit_1.getWarLoan)(ctx.connection, faction.mint, ctx.agent.publicKey);
+        }
+        catch {
+            return null;
+        }
+        if (loan.total_owed <= 0) {
+            ctx.agent.activeLoans.delete(faction.mint);
+            return null;
+        }
+        const result = await (0, pyre_world_kit_1.repayWarLoan)(ctx.connection, {
+            mint: faction.mint, borrower: ctx.agent.publicKey,
+            sol_amount: Math.ceil(loan.total_owed), stronghold: ctx.agent.publicKey,
+        });
+        await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        ctx.agent.activeLoans.delete(faction.mint);
+        ctx.agent.lastAction = `repaid loan ${faction.symbol}`;
+        return `repaid war loan on ${faction.symbol} (${(loan.total_owed / web3_js_1.LAMPORTS_PER_SOL).toFixed(4)} SOL)`;
+    },
+    async siege(ctx) {
+        const faction = findFaction(ctx.factions, ctx.decision.faction);
+        if (!faction)
+            return null;
+        let targetBorrower = null;
+        try {
+            const allLoans = await (0, pyre_world_kit_1.getAllWarLoans)(ctx.connection, faction.mint);
+            for (const pos of allLoans.positions) {
+                if (pos.health === 'liquidatable') {
+                    targetBorrower = pos.borrower;
+                    break;
+                }
+            }
+        }
+        catch {
+            return null;
+        }
+        if (!targetBorrower)
+            return null;
+        const result = await (0, pyre_world_kit_1.siege)(ctx.connection, {
+            mint: faction.mint, liquidator: ctx.agent.publicKey,
+            borrower: targetBorrower, stronghold: ctx.agent.publicKey,
+        });
+        await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        ctx.agent.lastAction = `siege ${faction.symbol}`;
+        return `sieged ${targetBorrower.slice(0, 8)}... in ${faction.symbol} (liquidation)`;
+    },
+    async ascend(ctx) {
+        const faction = findFaction(ctx.factions, ctx.decision.faction);
+        if (!faction || faction.status !== 'ready')
+            return null;
+        const result = await (0, pyre_world_kit_1.ascend)(ctx.connection, { mint: faction.mint, payer: ctx.agent.publicKey });
+        await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        faction.status = 'ascended';
+        ctx.agent.lastAction = `ascended ${faction.symbol}`;
+        return `ascended ${faction.symbol} to DEX`;
+    },
+    async raze(ctx) {
+        const faction = findFaction(ctx.factions, ctx.decision.faction);
+        if (!faction)
+            return null;
+        const result = await (0, pyre_world_kit_1.raze)(ctx.connection, { payer: ctx.agent.publicKey, mint: faction.mint });
+        await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        ctx.agent.lastAction = `razed ${faction.symbol}`;
+        return `razed ${faction.symbol} (reclaimed)`;
+    },
+    async tithe(ctx) {
+        const faction = findFaction(ctx.factions, ctx.decision.faction);
+        if (!faction)
+            return null;
+        try {
+            const result = await (0, pyre_world_kit_1.convertTithe)(ctx.connection, { mint: faction.mint, payer: ctx.agent.publicKey, harvest: true });
+            await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        }
+        catch {
+            const result = await (0, pyre_world_kit_1.tithe)(ctx.connection, { mint: faction.mint, payer: ctx.agent.publicKey });
+            await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        }
+        ctx.agent.lastAction = `tithed ${faction.symbol}`;
+        return `tithed ${faction.symbol} (harvested fees)`;
+    },
+    async infiltrate(ctx) {
+        const faction = findFaction(ctx.factions, ctx.decision.faction);
+        if (!faction)
+            return null;
+        const sol = ctx.decision.sol ?? (0, action_1.sentimentBuySize)(ctx.agent, faction.mint) * 1.5;
+        const lamports = Math.floor(sol * web3_js_1.LAMPORTS_PER_SOL);
+        await (0, stronghold_1.ensureStronghold)(ctx.connection, ctx.agent, ctx.log, ctx.strongholdOpts);
+        if (!ctx.agent.hasStronghold)
+            return null;
+        if (faction.status === 'ascended') {
+            const result = await (0, pyre_world_kit_1.tradeOnDex)(ctx.connection, {
+                mint: faction.mint, signer: ctx.agent.publicKey, stronghold_creator: ctx.agent.publicKey,
+                amount_in: lamports, minimum_amount_out: 1, is_buy: true, message: ctx.decision.message,
+            });
+            await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        }
+        else {
+            const alreadyVoted = ctx.agent.voted.has(faction.mint);
+            const params = {
+                mint: faction.mint, agent: ctx.agent.publicKey, amount_sol: lamports,
+                message: ctx.decision.message, stronghold: ctx.agent.publicKey,
+            };
+            if (!alreadyVoted)
+                params.strategy = 'scorched_earth';
+            const result = await (0, pyre_world_kit_1.joinFaction)(ctx.connection, params);
+            await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        }
+        const prev = ctx.agent.holdings.get(faction.mint) ?? 0;
+        ctx.agent.holdings.set(faction.mint, prev + 1);
+        ctx.agent.infiltrated.add(faction.mint);
+        ctx.agent.voted.add(faction.mint);
+        ctx.agent.sentiment.set(faction.mint, -5);
+        ctx.agent.lastAction = `infiltrated ${faction.symbol}`;
+        return `infiltrated ${faction.symbol} for ${sol.toFixed(4)} SOL — "${ctx.decision.message}"`;
+    },
+    async fud(ctx) {
+        const faction = findFaction(ctx.factions, ctx.decision.faction);
+        if (!faction || !ctx.decision.message || !ctx.agent.holdings.has(faction.mint))
+            return null;
+        await (0, stronghold_1.ensureStronghold)(ctx.connection, ctx.agent, ctx.log, ctx.strongholdOpts);
+        if (!ctx.agent.hasStronghold)
+            return null;
+        const result = await (0, pyre_world_kit_1.fudFaction)(ctx.connection, {
+            mint: faction.mint, agent: ctx.agent.publicKey, message: ctx.decision.message,
+            stronghold: ctx.agent.publicKey, ascended: faction.status === 'ascended',
+        });
+        await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        ctx.agent.lastAction = `fud ${faction.symbol}`;
+        return `argued in ${faction.symbol}: "${ctx.decision.message}"`;
+    },
+};
+async function executeAction(ctx) {
+    const short = ctx.agent.publicKey.slice(0, 8);
+    try {
+        const handler = handlers[ctx.decision.action];
+        if (!handler)
+            return { success: false, error: `unknown action: ${ctx.decision.action}` };
+        const desc = await handler(ctx);
+        if (!desc)
+            return { success: false, error: 'action precondition not met' };
+        ctx.agent.recentHistory.push(desc);
+        if (ctx.agent.recentHistory.length > 10)
+            ctx.agent.recentHistory = ctx.agent.recentHistory.slice(-10);
+        ctx.agent.actionCount++;
+        ctx.log(`[${short}] [${ctx.agent.personality}] [${ctx.brain}] ${desc}`);
+        return { success: true, description: desc };
+    }
+    catch (err) {
+        const parsed = (0, error_1.parseCustomError)(err);
+        if (parsed) {
+            const sym = ctx.decision.faction ?? '?';
+            ctx.log(`[${short}] [${ctx.agent.personality}] [${ctx.brain}] ERROR (${ctx.decision.action} ${sym}): ${parsed.name} [0x${parsed.code.toString(16)}]`);
+            // Adapt behavior based on error
+            if (parsed.code === 6002 && ctx.decision.faction) {
+                const f = findFaction(ctx.factions, ctx.decision.faction);
+                if (f)
+                    ctx.agent.sentiment.set(f.mint, (ctx.agent.sentiment.get(f.mint) ?? 0) + 1);
+            }
+            else if (parsed.code === 6055) {
+                ctx.agent.recentHistory.push('vault empty — need funds');
+            }
+            else if (parsed.code === 6051) {
+                const f = findFaction(ctx.factions, ctx.decision.faction);
+                if (f)
+                    ctx.agent.sentiment.set(f.mint, (ctx.agent.sentiment.get(f.mint) ?? 0) + 2);
+            }
+            else if (parsed.code === 6046) {
+                ctx.agent.recentHistory.push(`loan rejected on ${ctx.decision.faction} — LTV too high`);
+            }
+            else if (parsed.code === 6049) {
+                ctx.agent.recentHistory.push(`loan too small on ${ctx.decision.faction} — min 0.1 SOL`);
+            }
+            return { success: false, error: `${parsed.name} [0x${parsed.code.toString(16)}]` };
+        }
+        const msg = err.message?.slice(0, 120) ?? String(err);
+        ctx.log(`[${short}] [${ctx.agent.personality}] [${ctx.brain}] ERROR (${ctx.decision.action}): ${msg}`);
+        return { success: false, error: msg };
+    }
+}

package/dist/faction.d.ts

@@ -0,0 +1,10 @@
+import { Connection } from '@solana/web3.js';
+import { AgentState, FactionInfo, FactionIntel, LLMAdapter, Personality } from './types';
+export declare const FALLBACK_FACTION_NAMES: string[];
+export declare const FALLBACK_FACTION_SYMBOLS: string[];
+export declare const generateFactionIdentity: (personality: Personality, existingNames: Set<string>, llm?: LLMAdapter) => Promise<{
+    name: string;
+    symbol: string;
+} | null>;
+export declare const fetchFactionIntel: (connection: Connection, faction: FactionInfo) => Promise<FactionIntel>;
+export declare const generateDynamicExamples: (factions: FactionInfo[], _agent: AgentState) => string;

package/dist/faction.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDynamicExamples = exports.fetchFactionIntel = exports.generateFactionIdentity = exports.FALLBACK_FACTION_SYMBOLS = exports.FALLBACK_FACTION_NAMES = void 0;
+const pyre_world_kit_1 = require("pyre-world-kit");
+const util_1 = require("./util");
+// Fallback faction names/symbols — only used when LLM is unavailable
+exports.FALLBACK_FACTION_NAMES = [
+    'Iron Vanguard', 'Obsidian Order', 'Crimson Dawn', 'Shadow Covenant',
+    'Ember Collective', 'Void Walkers', 'Solar Reign', 'Frost Legion',
+    'Thunder Pact', 'Ash Republic', 'Neon Syndicate', 'Storm Brigade',
+    'Lunar Assembly', 'Flame Sentinels', 'Dark Meridian', 'Phoenix Accord',
+    'Steel Dominion', 'Crystal Enclave', 'Rogue Alliance', 'Titan Front',
+];
+exports.FALLBACK_FACTION_SYMBOLS = [
+    'IRON', 'OBSD', 'CRIM', 'SHAD', 'EMBR', 'VOID', 'SOLR', 'FRST',
+    'THDR', 'ASHR', 'NEON', 'STRM', 'LUNR', 'FLMS', 'DARK', 'PHNX',
+    'STEL', 'CRYS', 'ROGU', 'TITN',
+];
+const generateFactionIdentity = async (personality, existingNames, llm) => {
+    if (!llm)
+        return null;
+    const existing = [...existingNames].slice(0, 15).join(', ');
+    const prompt = `You are naming a new faction in Pyre, a faction warfare game on Solana.
+
+Your personality: ${personality}
+
+Existing factions (DO NOT reuse these): ${existing || 'none yet'}
+
+Generate a faction name and ticker symbol. The name should be 2-3 words, evocative, and feel like a militant organization, secret society, or political movement. The ticker should be 3-5 uppercase letters that abbreviate or represent the name.
+
+Respond with EXACTLY one line in this format:
+NAME | TICKER
+
+Examples:
+Obsidian Vanguard | OBSD
+Neon Syndicate | NEON
+Crimson Dawn | CRIM
+Void Collective | VOID
+Ash Republic | ASHR
+
+Your response (one line only):`;
+    const raw = await llm.generate(prompt);
+    if (!raw)
+        return null;
+    const line = raw.split('\n').find(l => l.includes('|'));
+    if (!line)
+        return null;
+    const parts = line.split('|').map(s => s.trim());
+    if (parts.length !== 2)
+        return null;
+    const name = parts[0].replace(/^["']|["']$/g, '').trim();
+    let symbol = parts[1].replace(/^["']|["']$/g, '').trim().toUpperCase();
+    if (!name || name.length < 3 || name.length > 32)
+        return null;
+    if (!symbol || symbol.length < 3 || symbol.length > 5)
+        return null;
+    symbol = symbol.replace(/[^A-Z]/g, '').slice(0, 5);
+    if (symbol.length < 3)
+        return null;
+    if (existingNames.has(name))
+        return null;
+    return { name, symbol };
+};
+exports.generateFactionIdentity = generateFactionIdentity;
+const fetchFactionIntel = async (connection, faction) => {
+    const [membersResult, commsResult] = await Promise.all([
+        (0, pyre_world_kit_1.getMembers)(connection, faction.mint, 10).catch(() => ({ members: [], total_members: 0 })),
+        (0, pyre_world_kit_1.getComms)(connection, faction.mint, 5, faction.status).catch(() => ({ comms: [], total: 0 })),
+    ]);
+    return {
+        symbol: faction.symbol,
+        members: membersResult.members.map(m => ({ address: m.address, percentage: m.percentage })),
+        totalMembers: membersResult.total_members,
+        recentComms: commsResult.comms.map(c => ({ sender: c.sender, memo: c.memo })),
+    };
+};
+exports.fetchFactionIntel = fetchFactionIntel;
+const generateDynamicExamples = (factions, _agent) => {
+    const syms = factions.map(f => f.symbol);
+    const s1 = syms.length > 0 ? (0, util_1.pick)(syms) : 'IRON';
+    const s2 = syms.length > 1 ? (0, util_1.pick)(syms.filter(s => s !== s1)) : 'VOID';
+    const addr = Math.random().toString(36).slice(2, 10);
+    const pct = Math.floor(Math.random() * 45 + 5);
+    const members = Math.floor(Math.random() * 30 + 3);
+    const messageExamples = [
+        `MESSAGE ${s1} "${s2} is gaining power, we need more resources."`,
+        `MESSAGE ${s2} "who else noticed @${addr} is gathering resources?"`,
+        `MESSAGE ${s1} "top member holds ${pct}%, resources concentrated"`,
+        `MESSAGE ${s1} "what's our strategy against ${s2}?"`,
+        `FUD ${s2} "only ${members} members, dead faction"`,
+        `FUD ${s1} "treasury growing but where's the activity?"`,
+        `FUD ${s1} "@${addr} you better watch your back"`,
+    ];
+    const actionExamples = [
+        `JOIN ${s1} "deploying capital, let's build this"`,
+        `JOIN ${s2} "following @${addr} into this one"`,
+        `JOIN ${s1} "@${addr}, ready to form an alliance if you are"`,
+        `DEFECT ${s1} "${members} are losing faith, taking profits"`,
+        `DEFECT ${s2} "saw @${addr} dump ${pct}%, I'm out"`,
+        `FUD ${s2} "@${addr} has been quiet, what are they planning?"`,
+        `INFILTRATE ${s2} "this one's undervalued, sneaking in"`,
+        `RALLY ${s1}`,
+        `WAR_LOAN ${s1}`,
+    ];
+    // 3 actions, 2 messages
+    const msgShuffled = messageExamples.sort(() => Math.random() - 0.5).slice(0, 2);
+    const actShuffled = actionExamples.sort(() => Math.random() - 0.5).slice(0, 3);
+    return [...actShuffled, ...msgShuffled].sort(() => Math.random() - 0.5).join('\n');
+};
+exports.generateDynamicExamples = generateDynamicExamples;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { PyreAgentConfig, PyreAgent } from './types';
+export type { PyreAgentConfig, PyreAgent, AgentTickResult, SerializedAgentState, LLMAdapter, LLMDecision, FactionInfo, Personality, Action, AgentState, } from './types';
+export { assignPersonality, PERSONALITY_SOL, PERSONALITY_WEIGHTS, personalityDesc, VOICE_NUDGES } from './defaults';
+export { ensureStronghold } from './stronghold';
+export { sendAndConfirm } from './tx';
+export declare function createPyreAgent(config: PyreAgentConfig): Promise<PyreAgent>;