pyre-agent-kit 1.0.0 → 2.0.0

package/dist/action.d.ts

@@ -1,3 +1,9 @@
 import { Action, AgentState, FactionInfo, Personality } from './types';
-export declare const chooseAction: (personality: Personality, agent: AgentState, canRally: boolean, knownFactions: FactionInfo[]) => Action;
+/**
+ * Choose an action using weighted random selection.
+ *
+ * Accepts optional dynamic weights (from on-chain history).
+ * Falls back to static personality weights if not provided.
+ */
+export declare const chooseAction: (personality: Personality, agent: AgentState, canRally: boolean, knownFactions: FactionInfo[], dynamicWeights?: number[]) => Action;
 export declare const sentimentBuySize: (agent: AgentState, factionMint: string) => number;

package/dist/action.js

@@ -7,8 +7,14 @@ const ALL_ACTIONS = [
     'stronghold', 'war_loan', 'repay_loan', 'siege', 'ascend', 'raze', 'tithe',
     'infiltrate', 'fud',
 ];
-const chooseAction = (personality, agent, canRally, knownFactions) => {
-    const weights = [...defaults_1.PERSONALITY_WEIGHTS[personality]];
+/**
+ * Choose an action using weighted random selection.
+ *
+ * Accepts optional dynamic weights (from on-chain history).
+ * Falls back to static personality weights if not provided.
+ */
+const chooseAction = (personality, agent, canRally, knownFactions, dynamicWeights) => {
+    const weights = dynamicWeights ? [...dynamicWeights] : [...defaults_1.PERSONALITY_WEIGHTS[personality]];
     const hasHoldings = agent.holdings.size > 0;
     const heldMints = [...agent.holdings.keys()];
     const rivalFactions = knownFactions.filter(f => !heldMints.includes(f.mint));
@@ -59,6 +65,13 @@ const chooseAction = (personality, agent, canRally, knownFactions) => {
     if (agent.infiltrated.size > 0) {
         weights[1] += 0.10;
     }
+    // Bearish sentiment on held factions → boost defect
+    if (hasHoldings) {
+        const bearishHeld = heldMints.filter(m => (agent.sentiment.get(m) ?? 0) < -2);
+        if (bearishHeld.length > 0) {
+            weights[1] += 0.05 * bearishHeld.length;
+        }
+    }
     if (ascendedFactions.length > 0) {
         if (holdsAscended) {
             weights[6] += 0.15;

package/dist/agent.d.ts

@@ -1,4 +1,4 @@
 import { AgentState, FactionInfo, LLMAdapter, LLMDecision } from './types';
 import { Connection } from '@solana/web3.js';
-export declare const buildAgentPrompt: (agent: AgentState, factions: FactionInfo[], leaderboardSnippet: string, intelSnippet: string, recentMessages: string[], solRange?: [number, number]) => string;
-export declare function llmDecide(agent: AgentState, factions: FactionInfo[], connection: Connection, recentMessages: string[], llm: LLMAdapter, log: (msg: string) => void, solRange?: [number, number]): Promise<LLMDecision | null>;
+export declare const buildAgentPrompt: (agent: AgentState, factions: FactionInfo[], leaderboardSnippet: string, intelSnippet: string, recentMessages: string[], solRange?: [number, number], chainMemories?: string[]) => string;
+export declare function llmDecide(agent: AgentState, factions: FactionInfo[], connection: Connection, recentMessages: string[], llm: LLMAdapter, log: (msg: string) => void, solRange?: [number, number], chainMemories?: string[]): Promise<LLMDecision | null>;

package/dist/agent.js

@@ -6,7 +6,7 @@ const pyre_world_kit_1 = require("pyre-world-kit");
 const defaults_1 = require("./defaults");
 const util_1 = require("./util");
 const faction_1 = require("./faction");
-const buildAgentPrompt = (agent, factions, leaderboardSnippet, intelSnippet, recentMessages, solRange) => {
+const buildAgentPrompt = (agent, factions, leaderboardSnippet, intelSnippet, recentMessages, solRange, chainMemories) => {
     const [minSol, maxSol] = solRange ?? defaults_1.PERSONALITY_SOL[agent.personality];
     const holdingsList = [...agent.holdings.entries()]
         .map(([mint, bal]) => {
@@ -29,6 +29,10 @@ const buildAgentPrompt = (agent, factions, leaderboardSnippet, intelSnippet, rec
     const doNotRepeat = recentMessages.length > 0
         ? `\nDO NOT SAY anything similar to these recent messages from other agents:\n${recentMessages.map(m => `- "${m}"`).join('\n')}\n`
         : '';
+    // On-chain memory — agent's own past memos as persistent context
+    const memoryBlock = chainMemories && chainMemories.length > 0
+        ? `\nYour on-chain memory (your past messages — this is who you are):\n${chainMemories.slice(-10).map(m => `- ${m}`).join('\n')}\n`
+        : '';
     const voiceNudge = (0, util_1.pick)(defaults_1.VOICE_NUDGES);
     return `You are an autonomous agent in Pyre, a faction warfare and strategy game on Solana, where you form both alliances and make enemies while trying to build the most powerful factions. Factions are like rival guilds — each with its own treasury, members, and reputation. You have your own opinions, allegiances, and grudges. Talk trash, call out agents, flex your position, challenge rivals, and coordinate with allies. Think competitive guild chat with real stakes. You make ONE decision per turn.
 
@@ -75,7 +79,7 @@ Recent: ${history}
 Active factions: ${factionList}
 Leaderboard preview: ${leaderboardSnippet}
 Intel preview: ${intelSnippet}
-${doNotRepeat}
+${memoryBlock}${doNotRepeat}
 
 Prefer actions that move tokens AND include a message — JOIN, DEFECT, FUD, INFILTRATE, REINFORCE all let you trade AND talk at the same time. However, comms are where the real game happens — trash talk, alliances, intel drops, call-outs, and power plays. Be specific. Reference real agents, real numbers, real moves. Generic messages are boring. Have an opinion and say it loud.. Mix it up — trade often, but keep the comms active too.
 
@@ -88,7 +92,9 @@ function parseLLMDecision(raw, factions, agent, solRange) {
         return null;
     for (const candidate of lines) {
         const line = candidate.trim();
-        const cleaned = line.replace(/^[-*•>#\d.)\s]+/, '').replace(/^(?:WARNING|NOTE|RESPONSE|OUTPUT|ANSWER|RESULT|SCPRT|SCRIPT)\s*:?\s*/i, '').replace(/^ACTION\s+/i, '')
+        const cleaned = line
+            .replace(/\*+/g, '') // strip all bold/italic markdown (e.g. **DEFECT SBP "msg"**)
+            .replace(/^[-•>#\d.)\s]+/, '').replace(/^(?:WARNING|NOTE|RESPONSE|OUTPUT|ANSWER|RESULT|SCPRT|SCRIPT)\s*:?\s*/i, '').replace(/^ACTION\s+/i, '')
             // Normalize Cyrillic lookalikes to Latin
             .replace(/[АаА]/g, 'A').replace(/[Вв]/g, 'B').replace(/[Сс]/g, 'C').replace(/[Ее]/g, 'E')
             .replace(/[Нн]/g, 'H').replace(/[Кк]/g, 'K').replace(/[Мм]/g, 'M').replace(/[Оо]/g, 'O')
@@ -198,7 +204,7 @@ function parseLLMMatch(match, factions, agent, line, solRange) {
         reasoning: line,
     };
 }
-async function llmDecide(agent, factions, connection, recentMessages, llm, log, solRange) {
+async function llmDecide(agent, factions, connection, recentMessages, llm, log, solRange, chainMemories) {
     let leaderboardSnippet = '';
     try {
         const lb = await (0, pyre_world_kit_1.getFactionLeaderboard)(connection, { limit: 5 });
@@ -262,7 +268,7 @@ async function llmDecide(agent, factions, connection, recentMessages, llm, log,
     catch {
         // intel fetch failed, proceed without it
     }
-    const prompt = (0, exports.buildAgentPrompt)(agent, factions, leaderboardSnippet, intelSnippet, recentMessages, solRange);
+    const prompt = (0, exports.buildAgentPrompt)(agent, factions, leaderboardSnippet, intelSnippet, recentMessages, solRange, chainMemories);
     const raw = await llm.generate(prompt);
     if (!raw) {
         log(`[${agent.publicKey.slice(0, 8)}] LLM returned null`);

package/dist/chain.d.ts

@@ -0,0 +1,104 @@
+/**
+ * On-Chain State Reconstruction
+ *
+ * Derives agent personality, sentiment, allies/rivals, and memory
+ * entirely from on-chain transaction history. The blockchain IS the
+ * agent's state — this module reads it back.
+ *
+ * Flow:
+ *   1. Fetch all tx signatures for agent wallet
+ *   2. Batch-parse transactions to extract action types + memos
+ *   3. Compute personality weights from action frequency distribution
+ *   4. Derive sentiment from buy/sell patterns + memo analysis
+ *   5. Derive allies/rivals from shared faction interactions
+ *   6. Extract agent's own memos as persistent memory
+ */
+import { Connection } from '@solana/web3.js';
+import type { Action, Personality, FactionInfo, OnChainAction, ChainDerivedState } from './types';
+/**
+ * Fetch all Torch Market transactions for an agent wallet.
+ * Paginates through signature history and batch-fetches parsed txs.
+ */
+export declare function fetchAgentHistory(connection: Connection, agentPubkey: string, knownMints: Set<string>, opts?: {
+    maxSignatures?: number;
+}): Promise<OnChainAction[]>;
+/**
+ * Compute personality weights from on-chain action history.
+ *
+ * Uses exponential decay blending:
+ *   finalWeight = seed × decay^n + observed × (1 - decay^n)
+ *
+ * Where n = total action count. This means:
+ *   n=0  → 100% seed weights (new agent)
+ *   n=10 → ~80% observed, ~20% seed
+ *   n=50 → ~99.9% observed
+ *
+ * The agent quickly becomes defined by its actual behavior.
+ */
+export declare function computeWeightsFromHistory(history: OnChainAction[], seedPersonality: Personality, decay?: number): number[];
+/**
+ * Recompute weights from raw action counts (no history parsing needed).
+ * Used for live personality evolution during runtime.
+ */
+export declare function weightsFromCounts(counts: number[], seedPersonality: Personality, decay?: number): number[];
+/** Action type to index in the ALL_ACTIONS array */
+export declare function actionIndex(action: Action): number;
+export declare function classifyPersonality(weights: number[], memos?: string[], perFactionHistory?: Map<string, number[]>): Personality;
+/**
+ * Compute sentiment towards factions from on-chain interaction patterns.
+ *
+ * Sentiment signals:
+ *   - Buys (join/dex_buy/message) → +1 per tx
+ *   - Sells (defect/dex_sell/fud) → -2 per tx (sells signal stronger negative)
+ *   - Rally → +3 (strong conviction signal)
+ *   - Infiltrate → -5 (explicitly hostile)
+ *   - Memo keywords → ±1
+ *
+ * Clamped to [-10, +10].
+ */
+export declare function computeSentimentFromHistory(history: OnChainAction[], factions: FactionInfo[]): Map<string, number>;
+/**
+ * Derive allies and rivals from on-chain interactions.
+ *
+ * Ally signals:
+ *   - Other agents who bought into the same factions the agent holds
+ *   - Other agents whose memos in shared factions are positive
+ *
+ * Rival signals:
+ *   - Agents who sold from factions the agent holds
+ *   - Agents whose memos in shared factions are negative
+ *   - Agents present in factions the agent infiltrated
+ */
+export declare function deriveAlliesRivals(agentHistory: OnChainAction[], factionComms: Map<string, {
+    sender: string;
+    memo: string;
+}[]>, heldMints: Set<string>): {
+    allies: Set<string>;
+    rivals: Set<string>;
+};
+/**
+ * Derive SOL spending range from actual transaction history.
+ * Falls back to personality defaults if no buy history exists.
+ */
+export declare function deriveSolRange(_history: OnChainAction[], personality: Personality): [number, number];
+/**
+ * Extract the agent's own memos as persistent memory.
+ * These are messages the agent wrote on-chain — its thoughts,
+ * trash talk, and strategic communications.
+ */
+export declare function extractMemories(history: OnChainAction[]): string[];
+/**
+ * Reconstruct full agent state from on-chain history.
+ *
+ * This is the main entry point. Call on startup to derive
+ * personality, weights, sentiment, allies/rivals, and memory
+ * entirely from the blockchain. No JSON files needed.
+ */
+export declare function reconstructFromChain(connection: Connection, agentPubkey: string, factions: FactionInfo[], seedPersonality: Personality, opts?: {
+    maxSignatures?: number;
+    decay?: number;
+    factionComms?: Map<string, {
+        sender: string;
+        memo: string;
+    }[]>;
+}): Promise<ChainDerivedState>;

package/dist/chain.js

@@ -0,0 +1,614 @@
+"use strict";
+/**
+ * On-Chain State Reconstruction
+ *
+ * Derives agent personality, sentiment, allies/rivals, and memory
+ * entirely from on-chain transaction history. The blockchain IS the
+ * agent's state — this module reads it back.
+ *
+ * Flow:
+ *   1. Fetch all tx signatures for agent wallet
+ *   2. Batch-parse transactions to extract action types + memos
+ *   3. Compute personality weights from action frequency distribution
+ *   4. Derive sentiment from buy/sell patterns + memo analysis
+ *   5. Derive allies/rivals from shared faction interactions
+ *   6. Extract agent's own memos as persistent memory
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAgentHistory = fetchAgentHistory;
+exports.computeWeightsFromHistory = computeWeightsFromHistory;
+exports.weightsFromCounts = weightsFromCounts;
+exports.actionIndex = actionIndex;
+exports.classifyPersonality = classifyPersonality;
+exports.computeSentimentFromHistory = computeSentimentFromHistory;
+exports.deriveAlliesRivals = deriveAlliesRivals;
+exports.deriveSolRange = deriveSolRange;
+exports.extractMemories = extractMemories;
+exports.reconstructFromChain = reconstructFromChain;
+const web3_js_1 = require("@solana/web3.js");
+const defaults_1 = require("./defaults");
+// Torch Market program ID
+const TORCH_PROGRAM_ID = '8hbUkonssSEEtkqzwM7ZcZrD9evacM92TcWSooVF4BeT';
+const MEMO_PROGRAM_IDS = new Set([
+    'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr',
+]);
+const ALL_ACTIONS = [
+    'join', 'defect', 'rally', 'launch', 'message',
+    'stronghold', 'war_loan', 'repay_loan', 'siege', 'ascend', 'raze', 'tithe',
+    'infiltrate', 'fud',
+];
+// ─── Transaction Fetching ────────────────────────────────────────
+/**
+ * Fetch all Torch Market transactions for an agent wallet.
+ * Paginates through signature history and batch-fetches parsed txs.
+ */
+async function fetchAgentHistory(connection, agentPubkey, knownMints, opts) {
+    const pubkey = new web3_js_1.PublicKey(agentPubkey);
+    const maxSigs = opts?.maxSignatures ?? 500;
+    const allActions = [];
+    // Paginate through signature history
+    let before;
+    let fetched = 0;
+    while (fetched < maxSigs) {
+        const batchSize = Math.min(maxSigs - fetched, 1000);
+        const signatures = await connection.getSignaturesForAddress(pubkey, { limit: batchSize, before }, 'confirmed');
+        if (signatures.length === 0)
+            break;
+        fetched += signatures.length;
+        before = signatures[signatures.length - 1].signature;
+        // Batch fetch parsed transactions (100 per RPC call)
+        const BATCH_SIZE = 100;
+        for (let i = 0; i < signatures.length; i += BATCH_SIZE) {
+            const batch = signatures.slice(i, i + BATCH_SIZE);
+            const sigStrings = batch.map(s => s.signature);
+            let txs;
+            try {
+                txs = await connection.getParsedTransactions(sigStrings, {
+                    maxSupportedTransactionVersion: 0,
+                });
+            }
+            catch {
+                continue;
+            }
+            for (let j = 0; j < txs.length; j++) {
+                const tx = txs[j];
+                if (!tx?.meta || tx.meta.err)
+                    continue;
+                const parsed = parseTransaction(tx, batch[j].signature, batch[j].blockTime ?? 0, agentPubkey, knownMints);
+                if (parsed)
+                    allActions.push(parsed);
+            }
+        }
+    }
+    // Sort chronologically (oldest first)
+    allActions.sort((a, b) => a.timestamp - b.timestamp);
+    return allActions;
+}
+// ─── Transaction Parsing ─────────────────────────────────────────
+/**
+ * Parse a single transaction into a game action.
+ * Uses program logs to determine instruction type, extracts memo and mint.
+ */
+function parseTransaction(tx, signature, timestamp, agentPubkey, knownMints) {
+    const logs = tx.meta?.logMessages ?? [];
+    const accountKeys = tx.transaction.message.accountKeys.map(k => k.pubkey.toString());
+    // Check if this tx involves the Torch program
+    const isTorchTx = accountKeys.includes(TORCH_PROGRAM_ID) ||
+        logs.some(l => l.includes(TORCH_PROGRAM_ID));
+    if (!isTorchTx)
+        return null;
+    // Determine action type from logs
+    let action = categorizeFromLogs(logs);
+    // Find faction mint from account keys
+    const mint = findMintInAccounts(accountKeys, knownMints);
+    // Extract memo
+    const memo = extractMemo(tx);
+    // Buy + memo = message (micro buy with text), sell + memo = fud (micro sell with text)
+    if (memo?.trim()) {
+        if (action === 'join' || action === 'dex_buy')
+            action = 'message';
+        else if (action === 'defect' || action === 'dex_sell')
+            action = 'fud';
+    }
+    // Find other agents (signers that aren't this agent)
+    const otherAgents = tx.transaction.message.accountKeys
+        .filter(k => k.signer && k.pubkey.toString() !== agentPubkey)
+        .map(k => k.pubkey.toString());
+    return { signature, timestamp, action, mint, memo, otherAgents };
+}
+/**
+ * Categorize transaction type from Anchor program logs.
+ */
+function categorizeFromLogs(logs) {
+    const logStr = logs.join(' ');
+    // Order matters — check specific instructions before generic ones
+    if (logs.some(l => l.includes('Instruction: CreateToken') || l.includes('create_token')))
+        return 'launch';
+    if (logs.some(l => l.includes('Instruction: CreateVault') || l.includes('create_vault')))
+        return 'stronghold';
+    // VaultSwap can be buy or sell — check for direction hints in logs
+    if (logs.some(l => l.includes('Instruction: VaultSwap') || l.includes('vault_swap'))) {
+        // VaultSwap logs typically include buy/sell direction
+        if (logStr.includes('is_buy: true') || logStr.includes('Buy'))
+            return 'dex_buy';
+        if (logStr.includes('is_buy: false') || logStr.includes('Sell'))
+            return 'dex_sell';
+        return 'dex_buy'; // default to buy if unclear
+    }
+    if (logs.some(l => l.includes('Instruction: Buy') || l.includes('Program log: Buy')))
+        return 'join';
+    if (logs.some(l => l.includes('Instruction: Sell') || l.includes('Program log: Sell')))
+        return 'defect';
+    if (logs.some(l => l.includes('Instruction: Star') || l.includes('star')))
+        return 'rally';
+    if (logs.some(l => l.includes('Instruction: Borrow') || l.includes('borrow')))
+        return 'war_loan';
+    if (logs.some(l => l.includes('Instruction: Repay') || l.includes('repay')))
+        return 'repay_loan';
+    if (logs.some(l => l.includes('Instruction: Liquidate') || l.includes('liquidate')))
+        return 'siege';
+    if (logs.some(l => l.includes('Instruction: Migrate') || l.includes('migrate')))
+        return 'ascend';
+    if (logs.some(l => l.includes('Instruction: ReclaimFailedToken') || l.includes('reclaim')))
+        return 'raze';
+    if (logs.some(l => l.includes('Instruction: HarvestFees') || l.includes('SwapFeesToSol') || l.includes('harvest')))
+        return 'tithe';
+    if (logs.some(l => l.includes('Instruction: DepositVault') || l.includes('deposit_vault')))
+        return 'fund';
+    return 'unknown';
+}
+/**
+ * Find a known faction mint in transaction account keys.
+ */
+function findMintInAccounts(accountKeys, knownMints) {
+    for (const key of accountKeys) {
+        if (knownMints.has(key))
+            return key;
+    }
+    return undefined;
+}
+/**
+ * Extract SPL Memo text from a transaction.
+ */
+function extractMemo(tx) {
+    for (const ix of tx.transaction.message.instructions) {
+        const programId = 'programId' in ix ? ix.programId.toString() : '';
+        const programName = 'program' in ix ? ix.program : '';
+        if (MEMO_PROGRAM_IDS.has(programId) || programName === 'spl-memo') {
+            if ('parsed' in ix) {
+                const text = typeof ix.parsed === 'string' ? ix.parsed : JSON.stringify(ix.parsed);
+                if (text?.trim())
+                    return text.trim();
+            }
+        }
+    }
+    // Also check inner instructions
+    for (const inner of tx.meta?.innerInstructions ?? []) {
+        for (const ix of inner.instructions) {
+            const programId = 'programId' in ix ? ix.programId.toString() : '';
+            const programName = 'program' in ix ? ix.program : '';
+            if (MEMO_PROGRAM_IDS.has(programId) || programName === 'spl-memo') {
+                if ('parsed' in ix) {
+                    const text = typeof ix.parsed === 'string' ? ix.parsed : JSON.stringify(ix.parsed);
+                    if (text?.trim())
+                        return text.trim();
+                }
+            }
+        }
+    }
+    return undefined;
+}
+// ─── Weight Computation ──────────────────────────────────────────
+/**
+ * Compute personality weights from on-chain action history.
+ *
+ * Uses exponential decay blending:
+ *   finalWeight = seed × decay^n + observed × (1 - decay^n)
+ *
+ * Where n = total action count. This means:
+ *   n=0  → 100% seed weights (new agent)
+ *   n=10 → ~80% observed, ~20% seed
+ *   n=50 → ~99.9% observed
+ *
+ * The agent quickly becomes defined by its actual behavior.
+ */
+function computeWeightsFromHistory(history, seedPersonality, decay = 0.85) {
+    const seed = [...defaults_1.PERSONALITY_WEIGHTS[seedPersonality]];
+    if (history.length === 0)
+        return seed;
+    // Count occurrences of each action type
+    const counts = new Array(ALL_ACTIONS.length).fill(0);
+    for (const entry of history) {
+        const action = normalizeChainAction(entry.action);
+        const idx = ALL_ACTIONS.indexOf(action);
+        if (idx >= 0)
+            counts[idx]++;
+    }
+    const total = counts.reduce((a, b) => a + b, 0);
+    if (total === 0)
+        return seed;
+    // Compute observed frequency distribution
+    const observed = counts.map(c => c / total);
+    // Blend seed with observed using exponential decay
+    const n = total;
+    const seedFactor = Math.pow(decay, n);
+    const observedFactor = 1 - seedFactor;
+    return seed.map((s, i) => s * seedFactor + observed[i] * observedFactor);
+}
+/**
+ * Normalize chain action types to standard Action types.
+ * dex_buy → join, dex_sell → defect, etc.
+ */
+function normalizeChainAction(action) {
+    switch (action) {
+        case 'dex_buy': return 'join';
+        case 'dex_sell': return 'defect';
+        case 'fund': return 'stronghold';
+        case 'unknown': return 'join'; // safe fallback
+        default: return action;
+    }
+}
+/**
+ * Recompute weights from raw action counts (no history parsing needed).
+ * Used for live personality evolution during runtime.
+ */
+function weightsFromCounts(counts, seedPersonality, decay = 0.85) {
+    const seed = [...defaults_1.PERSONALITY_WEIGHTS[seedPersonality]];
+    const total = counts.reduce((a, b) => a + b, 0);
+    if (total === 0)
+        return seed;
+    const observed = counts.map(c => c / total);
+    const seedFactor = Math.pow(decay, total);
+    return seed.map((s, i) => s * seedFactor + observed[i] * (1 - seedFactor));
+}
+/** Action type to index in the ALL_ACTIONS array */
+function actionIndex(action) {
+    return ALL_ACTIONS.indexOf(action);
+}
+// ─── Memo Content Personality Signals ─────────────────────────────
+const PROVOCATEUR_VOICE = /trash|beef|fight|chaos|war|destroy|crush|pathetic|laughable|weak|dead|fake|scam|clown|joke|fool|coward|expose|call.?out|dare|challenge|predict|bold|hot.?take/;
+const SCOUT_VOICE = /intel|data|notice|observ|suspicious|watch|track|report|warn|alert|question|why did|who.?s|pattern|trend|%|percent|member|holder|accumul/;
+const LOYALIST_VOICE = /ride.?or.?die|loyal|hold|believe|strong|build|together|ally|alliance|trust|support|back|hype|power|conviction|never.?sell|diamond/;
+const MERCENARY_VOICE = /profit|alpha|flip|exit|dump|cash|roi|returns|opportunity|play|angle|trade|stack|bag|gain|solo|lone.?wolf/;
+const WHALE_VOICE = /flex|position|size|deploy|capital|market|move|massive|big|dominate|everyone.?watch|listen|whale|stack|load/;
+function scoreMemoPersonality(memos) {
+    const scores = {
+        loyalist: 0, mercenary: 0, provocateur: 0, scout: 0, whale: 0,
+    };
+    for (const memo of memos) {
+        const text = memo.toLowerCase();
+        if (PROVOCATEUR_VOICE.test(text))
+            scores.provocateur++;
+        if (SCOUT_VOICE.test(text))
+            scores.scout++;
+        if (LOYALIST_VOICE.test(text))
+            scores.loyalist++;
+        if (MERCENARY_VOICE.test(text))
+            scores.mercenary++;
+        if (WHALE_VOICE.test(text))
+            scores.whale++;
+    }
+    return scores;
+}
+// ─── Personality Classification ──────────────────────────────────
+/**
+ * Classify personality from observed action distribution + memo content.
+ *
+ * Two signal sources, blended:
+ *   1. Action ratios — what the agent DOES
+ *   2. Memo keywords — what the agent SAYS
+ *
+ * Action indices: [join=0, defect=1, rally=2, launch=3, message=4,
+ *   stronghold=5, war_loan=6, repay_loan=7, siege=8, ascend=9,
+ *   raze=10, tithe=11, infiltrate=12, fud=13]
+ */
+/**
+ * Score a single action set (per-faction or global) into personality scores.
+ */
+function scoreActions(r) {
+    const joinRate = r[0], defectRate = r[1], rallyRate = r[2], messageRate = r[4];
+    const warLoanRate = r[6], siegeRate = r[8], titheRate = r[11];
+    const infiltrateRate = r[12], fudRate = r[13];
+    const commsRate = messageRate + fudRate;
+    const tradeRate = joinRate + defectRate;
+    // Ratio of fud to total comms — the key differentiator between personalities
+    const fudRatio = commsRate > 0 ? fudRate / commsRate : 0; // 0 = pure messenger, 1 = pure fudder
+    const msgRatio = commsRate > 0 ? messageRate / commsRate : 0;
+    return {
+        // Loyalist: high message ratio, joins, rallies — positive vibes
+        loyalist: msgRatio * 3 + joinRate * 2 + rallyRate * 3 + titheRate * 2
+            - fudRatio * 4 - defectRate * 3,
+        // Mercenary: defect + fud cycle, infiltration pattern
+        mercenary: defectRate * 4 + fudRatio * 2
+            + (defectRate > 0 && fudRate > 0 ? 3 : 0)
+            + infiltrateRate * 3 + warLoanRate * 2 + siegeRate * 2
+            - msgRatio * 2 - rallyRate * 2,
+        // Provocateur: high fud ratio — more fud than message
+        provocateur: fudRatio * 4 + infiltrateRate * 2
+            - msgRatio * 2 - rallyRate * 2,
+        // Scout: high message ratio, low fud — observes, doesn't attack
+        scout: msgRatio * 3 + rallyRate - fudRatio * 3 - defectRate,
+        // Whale: trades a lot but talks very little
+        whale: (tradeRate > commsRate ? 1 : 0) * 2 + warLoanRate * 3 + defectRate * 2
+            - commsRate * 3,
+    };
+}
+function classifyPersonality(weights, memos = [], perFactionHistory) {
+    const total = weights.reduce((a, b) => a + b, 0);
+    if (total === 0)
+        return 'loyalist';
+    // ── Signal 1: per-faction action scores, averaged ──
+    let actionScores;
+    if (perFactionHistory && perFactionHistory.size > 0) {
+        const accumulated = {
+            loyalist: 0, mercenary: 0, provocateur: 0, scout: 0, whale: 0,
+        };
+        let factionCount = 0;
+        for (const [, counts] of perFactionHistory) {
+            const fTotal = counts.reduce((a, b) => a + b, 0);
+            if (fTotal < 2)
+                continue;
+            const r = counts.map(c => c / fTotal);
+            const scores = scoreActions(r);
+            for (const p of Object.keys(accumulated)) {
+                accumulated[p] += scores[p];
+            }
+            factionCount++;
+        }
+        if (factionCount > 0) {
+            for (const p of Object.keys(accumulated)) {
+                accumulated[p] /= factionCount;
+            }
+            actionScores = accumulated;
+        }
+        else {
+            const r = weights.map(w => w / total);
+            actionScores = scoreActions(r);
+        }
+    }
+    else {
+        const r = weights.map(w => w / total);
+        actionScores = scoreActions(r);
+    }
+    // ── Signal 2: memo content ──
+    const memoScores = scoreMemoPersonality(memos);
+    const memoTotal = Object.values(memoScores).reduce((a, b) => a + b, 0);
+    const memoWeight = 0.4;
+    // ── Blend ──
+    const finalScores = {
+        loyalist: 0, mercenary: 0, provocateur: 0, scout: 0, whale: 0,
+    };
+    for (const p of Object.keys(finalScores)) {
+        const actionSignal = actionScores[p];
+        const memoSignal = memoTotal > 0 ? (memoScores[p] / memoTotal) : 0;
+        finalScores[p] = actionSignal * (1 - memoWeight) + memoSignal * memoWeight;
+    }
+    let best = 'loyalist';
+    let bestScore = -Infinity;
+    for (const [p, score] of Object.entries(finalScores)) {
+        if (score > bestScore) {
+            bestScore = score;
+            best = p;
+        }
+    }
+    return best;
+}
+// ─── Sentiment from On-Chain Data ────────────────────────────────
+const POSITIVE_PATTERN = /strong|rally|bull|pump|rising|hold|loyal|power|growing|moon|love|trust|alpha|build|conviction/;
+const NEGATIVE_PATTERN = /weak|dump|bear|dead|fail|raze|crash|abandon|scam|rug|sell|exit|trash|hate|fake/;
+/**
+ * Compute sentiment towards factions from on-chain interaction patterns.
+ *
+ * Sentiment signals:
+ *   - Buys (join/dex_buy/message) → +1 per tx
+ *   - Sells (defect/dex_sell/fud) → -2 per tx (sells signal stronger negative)
+ *   - Rally → +3 (strong conviction signal)
+ *   - Infiltrate → -5 (explicitly hostile)
+ *   - Memo keywords → ±1
+ *
+ * Clamped to [-10, +10].
+ */
+function computeSentimentFromHistory(history, factions) {
+    const sentiment = new Map();
+    for (const entry of history) {
+        if (!entry.mint)
+            continue;
+        const current = sentiment.get(entry.mint) ?? 0;
+        let delta = 0;
+        switch (entry.action) {
+            case 'join':
+            case 'dex_buy':
+                delta = 1;
+                break;
+            case 'defect':
+            case 'dex_sell':
+                delta = -2;
+                break;
+            case 'rally':
+                delta = 3;
+                break;
+            case 'infiltrate':
+                delta = -5;
+                break;
+            case 'message':
+                delta = 0.5; // slight positive (paid to speak)
+                break;
+            case 'fud':
+                delta = -1.5;
+                break;
+            case 'war_loan':
+                delta = 1; // leveraging = bullish
+                break;
+        }
+        // Memo sentiment analysis
+        if (entry.memo) {
+            const text = entry.memo.toLowerCase();
+            if (POSITIVE_PATTERN.test(text))
+                delta += 0.5;
+            if (NEGATIVE_PATTERN.test(text))
+                delta -= 0.5;
+        }
+        sentiment.set(entry.mint, Math.max(-10, Math.min(10, current + delta)));
+    }
+    return sentiment;
+}
+// ─── Ally/Rival Detection ────────────────────────────────────────
+/**
+ * Derive allies and rivals from on-chain interactions.
+ *
+ * Ally signals:
+ *   - Other agents who bought into the same factions the agent holds
+ *   - Other agents whose memos in shared factions are positive
+ *
+ * Rival signals:
+ *   - Agents who sold from factions the agent holds
+ *   - Agents whose memos in shared factions are negative
+ *   - Agents present in factions the agent infiltrated
+ */
+function deriveAlliesRivals(agentHistory, factionComms, heldMints) {
+    const allyScore = new Map();
+    const rivalScore = new Map();
+    // Score from faction comms (other agents' messages in held factions)
+    for (const [mint, comms] of factionComms) {
+        if (!heldMints.has(mint))
+            continue;
+        for (const c of comms) {
+            const text = c.memo.toLowerCase();
+            if (POSITIVE_PATTERN.test(text)) {
+                allyScore.set(c.sender, (allyScore.get(c.sender) ?? 0) + 1);
+            }
+            if (NEGATIVE_PATTERN.test(text)) {
+                rivalScore.set(c.sender, (rivalScore.get(c.sender) ?? 0) + 1);
+            }
+        }
+    }
+    // Convert scores to sets (threshold: net positive → ally, net negative → rival)
+    const allies = new Set();
+    const rivals = new Set();
+    const allAgents = new Set([...allyScore.keys(), ...rivalScore.keys()]);
+    for (const agent of allAgents) {
+        const aScore = allyScore.get(agent) ?? 0;
+        const rScore = rivalScore.get(agent) ?? 0;
+        if (aScore > rScore)
+            allies.add(agent);
+        else if (rScore > aScore)
+            rivals.add(agent);
+    }
+    return { allies, rivals };
+}
+// ─── SOL Range Derivation ────────────────────────────────────────
+/**
+ * Derive SOL spending range from actual transaction history.
+ * Falls back to personality defaults if no buy history exists.
+ */
+function deriveSolRange(_history, personality) {
+    // For now, we keep the personality-based ranges as they represent
+    // risk tolerance. In the future, this could analyze actual tx amounts
+    // from the parsed transaction data (lamports in/out).
+    // The current torchsdk doesn't expose lamport amounts in parsed tx data,
+    // so we'd need to decode inner instructions to extract this.
+    return defaults_1.PERSONALITY_SOL[personality];
+}
+// ─── Memory Extraction ──────────────────────────────────────────
+/**
+ * Extract the agent's own memos as persistent memory.
+ * These are messages the agent wrote on-chain — its thoughts,
+ * trash talk, and strategic communications.
+ */
+function extractMemories(history) {
+    return history
+        .filter(h => h.memo && h.memo.trim().length > 0)
+        .map(h => {
+        const faction = h.mint ? h.mint.slice(0, 8) : '???';
+        const time = new Date(h.timestamp * 1000).toISOString().slice(0, 10);
+        const action = h.action === 'join' || h.action === 'dex_buy' ? 'joined'
+            : h.action === 'defect' || h.action === 'dex_sell' ? 'defected'
+                : h.action === 'fud' ? 'fudded'
+                    : h.action === 'message' ? 'said'
+                        : h.action;
+        return `[${time}] ${action} ${faction}: "${h.memo}"`;
+    });
+}
+// ─── Full State Reconstruction ──────────────────────────────────
+/**
+ * Reconstruct full agent state from on-chain history.
+ *
+ * This is the main entry point. Call on startup to derive
+ * personality, weights, sentiment, allies/rivals, and memory
+ * entirely from the blockchain. No JSON files needed.
+ */
+async function reconstructFromChain(connection, agentPubkey, factions, seedPersonality, opts) {
+    const knownMints = new Set(factions.map(f => f.mint));
+    // 1. Fetch on-chain history
+    const history = await fetchAgentHistory(connection, agentPubkey, knownMints, {
+        maxSignatures: opts?.maxSignatures,
+    });
+    // 2. Compute personality weights from action frequency
+    const weights = computeWeightsFromHistory(history, seedPersonality, opts?.decay);
+    // 3. Classify emergent personality (action ratios + memo content, per-faction)
+    const memoTexts = history.filter(h => h.memo?.trim()).map(h => h.memo);
+    // Build per-faction action counts for per-ticker personality scoring
+    const perFaction = new Map();
+    for (const entry of history) {
+        if (!entry.mint)
+            continue;
+        const normalized = normalizeChainAction(entry.action);
+        const idx = ALL_ACTIONS.indexOf(normalized);
+        if (idx < 0)
+            continue;
+        if (!perFaction.has(entry.mint))
+            perFaction.set(entry.mint, new Array(ALL_ACTIONS.length).fill(0));
+        perFaction.get(entry.mint)[idx]++;
+    }
+    const personality = history.length > 0 ? classifyPersonality(weights, memoTexts, perFaction) : seedPersonality;
+    // 4. Compute sentiment from on-chain interactions
+    const sentiment = computeSentimentFromHistory(history, factions);
+    // 5. Derive allies/rivals
+    const heldMints = new Set();
+    const mintBalances = new Map();
+    for (const entry of history) {
+        if (!entry.mint)
+            continue;
+        const current = mintBalances.get(entry.mint) ?? 0;
+        if (entry.action === 'join' || entry.action === 'dex_buy' || entry.action === 'message') {
+            mintBalances.set(entry.mint, current + 1);
+        }
+        else if (entry.action === 'defect' || entry.action === 'dex_sell') {
+            mintBalances.set(entry.mint, current - 1);
+        }
+    }
+    for (const [mint, bal] of mintBalances) {
+        if (bal > 0)
+            heldMints.add(mint);
+    }
+    const { allies, rivals } = deriveAlliesRivals(history, opts?.factionComms ?? new Map(), heldMints);
+    // 6. Derive SOL range
+    const solRange = deriveSolRange(history, personality);
+    // 7. Extract memories (agent's own memos)
+    const memories = extractMemories(history);
+    // 8. Build recent history descriptions
+    const recentHistory = history.slice(-15).map(h => {
+        const faction = h.mint
+            ? factions.find(f => f.mint === h.mint)?.symbol ?? h.mint.slice(0, 8)
+            : '?';
+        const memoSuffix = h.memo ? ` — "${h.memo.slice(0, 60)}"` : '';
+        return `${h.action} ${faction}${memoSuffix}`;
+    });
+    // 9. Find founded factions
+    const founded = history
+        .filter(h => h.action === 'launch' && h.mint)
+        .map(h => h.mint);
+    return {
+        weights,
+        personality,
+        sentiment,
+        allies,
+        rivals,
+        solRange,
+        actionCount: history.length,
+        recentHistory,
+        founded,
+        memories,
+        history,
+    };
+}

package/dist/defaults.js

@@ -79,7 +79,7 @@ exports.ACTION_MAP = {
     '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',
+    'DEFLECT': 'DEFECT', 'DEFEKT': 'DEFECT', 'DEFCT': 'DEFECT', 'DEFFECT': 'DEFECT', 'DERECT': 'DEFECT',
     'JION': 'JOIN', 'JOING': 'JOIN', 'JOIIN': 'JOIN',
     'RALEY': 'RALLY', 'RALY': 'RALLY', 'RALLLY': 'RALLY',
     'LANCH': 'LAUNCH', 'LAUCH': 'LAUNCH',

package/dist/executor.js

@@ -355,6 +355,9 @@ const handlers = {
             stronghold: ctx.agent.publicKey, ascended: faction.status === 'ascended',
         });
         await (0, tx_1.sendAndConfirm)(ctx.connection, ctx.agent.keypair, result);
+        // Fudding tanks your own sentiment — you're going bearish
+        const fudSentiment = ctx.agent.sentiment.get(faction.mint) ?? 0;
+        ctx.agent.sentiment.set(faction.mint, Math.max(-10, fudSentiment - 2));
         ctx.agent.lastAction = `fud ${faction.symbol}`;
         return `argued in ${faction.symbol}: "${ctx.decision.message}"`;
     },

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendAndConfirm = exports.ensureStronghold = exports.VOICE_NUDGES = exports.personalityDesc = exports.PERSONALITY_WEIGHTS = exports.PERSONALITY_SOL = exports.assignPersonality = void 0;
+exports.actionIndex = exports.weightsFromCounts = exports.classifyPersonality = exports.computeWeightsFromHistory = exports.reconstructFromChain = exports.sendAndConfirm = exports.ensureStronghold = exports.VOICE_NUDGES = exports.personalityDesc = exports.PERSONALITY_WEIGHTS = exports.PERSONALITY_SOL = exports.assignPersonality = void 0;
 exports.createPyreAgent = createPyreAgent;
 const pyre_world_kit_1 = require("pyre-world-kit");
 const defaults_1 = require("./defaults");
@@ -8,6 +8,7 @@ const action_1 = require("./action");
 const agent_1 = require("./agent");
 const executor_1 = require("./executor");
 const stronghold_1 = require("./stronghold");
+const chain_1 = require("./chain");
 const util_1 = require("./util");
 var defaults_2 = require("./defaults");
 Object.defineProperty(exports, "assignPersonality", { enumerable: true, get: function () { return defaults_2.assignPersonality; } });
@@ -19,41 +20,29 @@ var stronghold_2 = require("./stronghold");
 Object.defineProperty(exports, "ensureStronghold", { enumerable: true, get: function () { return stronghold_2.ensureStronghold; } });
 var tx_1 = require("./tx");
 Object.defineProperty(exports, "sendAndConfirm", { enumerable: true, get: function () { return tx_1.sendAndConfirm; } });
+var chain_2 = require("./chain");
+Object.defineProperty(exports, "reconstructFromChain", { enumerable: true, get: function () { return chain_2.reconstructFromChain; } });
+Object.defineProperty(exports, "computeWeightsFromHistory", { enumerable: true, get: function () { return chain_2.computeWeightsFromHistory; } });
+Object.defineProperty(exports, "classifyPersonality", { enumerable: true, get: function () { return chain_2.classifyPersonality; } });
+Object.defineProperty(exports, "weightsFromCounts", { enumerable: true, get: function () { return chain_2.weightsFromCounts; } });
+Object.defineProperty(exports, "actionIndex", { enumerable: true, get: function () { return chain_2.actionIndex; } });
 async function createPyreAgent(config) {
     const { connection, keypair, network, llm, maxFoundedFactions = 2, strongholdFundSol, strongholdTopupThresholdSol, strongholdTopupReserveSol, } = config;
     const publicKey = keypair.publicKey.toBase58();
-    const personality = config.personality ?? config.state?.personality ?? (0, defaults_1.assignPersonality)();
-    const solRange = config.solRange ?? defaults_1.PERSONALITY_SOL[personality];
+    const seedPersonality = config.personality ?? config.state?.personality ?? (0, defaults_1.assignPersonality)();
     const logger = config.logger ?? ((msg) => console.log(`[${(0, util_1.ts)()}] ${msg}`));
     const strongholdOpts = {
         fundSol: strongholdFundSol,
         topupThresholdSol: strongholdTopupThresholdSol,
         topupReserveSol: strongholdTopupReserveSol,
     };
-    // Build agent state from serialized or fresh
-    const prior = config.state;
-    const state = {
-        keypair,
-        publicKey,
-        personality,
-        holdings: new Map(Object.entries(prior?.holdings ?? {})),
-        founded: prior?.founded ?? [],
-        rallied: new Set(prior?.rallied ?? []),
-        voted: new Set([...(prior?.voted ?? []), ...Object.keys(prior?.holdings ?? {})]),
-        hasStronghold: prior?.hasStronghold ?? false,
-        activeLoans: new Set(prior?.activeLoans ?? []),
-        infiltrated: new Set(prior?.infiltrated ?? []),
-        sentiment: new Map(Object.entries(prior?.sentiment ?? {})),
-        allies: new Set(prior?.allies ?? []),
-        rivals: new Set(prior?.rivals ?? []),
-        actionCount: prior?.actionCount ?? 0,
-        lastAction: prior?.lastAction ?? 'none',
-        recentHistory: prior?.recentHistory ?? [],
-    };
     // Track known factions and used names
     const knownFactions = [];
     const usedFactionNames = new Set();
     const recentMessages = [];
+    // Runtime action tracking for live personality evolution
+    const actionCounts = new Array(14).fill(0);
+    const memoBuffer = [];
     // Discover existing factions
     try {
         const result = await (0, pyre_world_kit_1.getFactions)(connection, { limit: 50, sort: 'newest' });
@@ -68,6 +57,59 @@ async function createPyreAgent(config) {
     catch {
         logger(`[${publicKey.slice(0, 8)}] faction discovery failed`);
     }
+    // ─── On-Chain State Reconstruction ───────────────────────────────
+    // Derive personality, weights, sentiment, allies/rivals from chain history.
+    // Falls back to seed personality + serialized state if chain fetch fails.
+    let chainState = null;
+    let personality = seedPersonality;
+    let dynamicWeights;
+    let solRange = config.solRange ?? defaults_1.PERSONALITY_SOL[seedPersonality];
+    try {
+        chainState = await (0, chain_1.reconstructFromChain)(connection, publicKey, knownFactions, seedPersonality, { maxSignatures: 500 });
+        if (chainState.actionCount > 0) {
+            personality = chainState.personality;
+            dynamicWeights = chainState.weights;
+            solRange = chainState.solRange;
+            logger(`[${publicKey.slice(0, 8)}] on-chain reconstruction: ${chainState.actionCount} actions, personality: ${seedPersonality} → ${personality}, memories: ${chainState.memories.length}`);
+        }
+        else {
+            logger(`[${publicKey.slice(0, 8)}] no on-chain history, using seed personality: ${seedPersonality}`);
+        }
+    }
+    catch (err) {
+        logger(`[${publicKey.slice(0, 8)}] chain reconstruction failed (${err.message?.slice(0, 60)}), using fallback state`);
+    }
+    // Build agent state — chain-derived where available, serialized fallback, fresh default
+    const prior = config.state;
+    const state = {
+        keypair,
+        publicKey,
+        personality,
+        holdings: new Map(Object.entries(prior?.holdings ?? {})),
+        founded: chainState?.founded ?? prior?.founded ?? [],
+        rallied: new Set(prior?.rallied ?? []),
+        voted: new Set([...(prior?.voted ?? []), ...Object.keys(prior?.holdings ?? {})]),
+        hasStronghold: prior?.hasStronghold ?? false,
+        activeLoans: new Set(prior?.activeLoans ?? []),
+        infiltrated: new Set(prior?.infiltrated ?? []),
+        // Chain-derived sentiment as baseline, overwritten by serialized if available
+        sentiment: chainState && chainState.actionCount > 0
+            ? chainState.sentiment
+            : new Map(Object.entries(prior?.sentiment ?? {})),
+        // Chain-derived allies/rivals as baseline
+        allies: chainState && chainState.actionCount > 0
+            ? chainState.allies
+            : new Set(prior?.allies ?? []),
+        rivals: chainState && chainState.actionCount > 0
+            ? chainState.rivals
+            : new Set(prior?.rivals ?? []),
+        actionCount: chainState?.actionCount ?? prior?.actionCount ?? 0,
+        lastAction: prior?.lastAction ?? 'none',
+        // Chain memories + recent history for LLM context
+        recentHistory: chainState && chainState.actionCount > 0
+            ? chainState.recentHistory
+            : prior?.recentHistory ?? [],
+    };
     // Ensure stronghold exists
     await (0, stronghold_1.ensureStronghold)(connection, state, logger, strongholdOpts);
     function serialize() {
@@ -95,14 +137,14 @@ async function createPyreAgent(config) {
         let decision = null;
         let usedLLM = false;
         if (llm && activeFactions.length > 0) {
-            decision = await (0, agent_1.llmDecide)(state, activeFactions, connection, recentMessages, llm, logger, solRange);
+            decision = await (0, agent_1.llmDecide)(state, activeFactions, connection, recentMessages, llm, logger, solRange, chainState?.memories);
             if (decision)
                 usedLLM = true;
         }
-        // Fallback: weighted random
+        // Fallback: weighted random (using dynamic weights from chain history)
         if (!decision) {
             const canRally = activeFactions.some(f => !state.rallied.has(f.mint));
-            const action = (0, action_1.chooseAction)(state.personality, state, canRally, activeFactions);
+            const action = (0, action_1.chooseAction)(state.personality, state, canRally, activeFactions, dynamicWeights);
             const [minSol, maxSol] = solRange;
             decision = { action, sol: (0, util_1.randRange)(minSol, maxSol) };
             // Pick a target faction for the fallback
@@ -200,6 +242,14 @@ async function createPyreAgent(config) {
             if (recentMessages.length > 30)
                 recentMessages.shift();
         }
+        // Track action for live personality evolution
+        if (result.success) {
+            const idx = (0, chain_1.actionIndex)(decision.action);
+            if (idx >= 0)
+                actionCounts[idx]++;
+            if (decision.message?.trim())
+                memoBuffer.push(decision.message);
+        }
         return {
             action: decision.action,
             faction: decision.faction,
@@ -210,10 +260,25 @@ async function createPyreAgent(config) {
             usedLLM,
         };
     }
+    function evolve() {
+        const total = actionCounts.reduce((a, b) => a + b, 0);
+        if (total < 5)
+            return false; // not enough data
+        const weights = (0, chain_1.weightsFromCounts)(actionCounts, seedPersonality);
+        const newPersonality = (0, chain_1.classifyPersonality)(weights, memoBuffer);
+        dynamicWeights = weights;
+        if (newPersonality !== state.personality) {
+            logger(`[${publicKey.slice(0, 8)}] personality evolved: ${state.personality} → ${newPersonality} (${total} runtime actions)`);
+            state.personality = newPersonality;
+            return true;
+        }
+        return false;
+    }
     return {
         publicKey,
-        personality,
+        personality: state.personality,
         tick,
+        evolve,
         getState: () => state,
         serialize,
     };

package/dist/types.d.ts

@@ -107,12 +107,48 @@ export interface SerializedAgentState {
 export interface PyreAgent {
     /** Agent's public key */
     readonly publicKey: string;
-    /** Agent's personality */
+    /** Agent's personality (emergent from on-chain history) */
     readonly personality: Personality;
     /** Run one decision+action cycle */
     tick(factions?: FactionInfo[]): Promise<AgentTickResult>;
+    /** Recompute personality + weights from accumulated runtime actions. Returns true if personality changed. */
+    evolve(): boolean;
     /** Get current mutable state */
     getState(): AgentState;
     /** Serialize state for persistence */
     serialize(): SerializedAgentState;
 }
+/** A single on-chain action parsed from transaction history */
+export interface OnChainAction {
+    signature: string;
+    timestamp: number;
+    action: Action | 'fund' | 'dex_buy' | 'dex_sell' | 'unknown';
+    mint?: string;
+    memo?: string;
+    otherAgents?: string[];
+}
+/** State derived entirely from on-chain data */
+export interface ChainDerivedState {
+    /** Personality weights computed from action frequency */
+    weights: number[];
+    /** Classified personality from weight distribution */
+    personality: Personality;
+    /** Sentiment from on-chain interactions (buys/sells/memos per faction) */
+    sentiment: Map<string, number>;
+    /** Allies derived from shared factions + positive memos */
+    allies: Set<string>;
+    /** Rivals derived from defections + negative memos */
+    rivals: Set<string>;
+    /** SOL spending range derived from actual tx amounts */
+    solRange: [number, number];
+    /** Total on-chain actions */
+    actionCount: number;
+    /** Recent action descriptions for LLM context */
+    recentHistory: string[];
+    /** Founded faction mints (agent was signer on CreateToken) */
+    founded: string[];
+    /** Agent's own memos as persistent memory */
+    memories: string[];
+    /** Raw parsed history */
+    history: OnChainAction[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyre-agent-kit",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Autonomous agent kit for Pyre — plug in your own LLM and play pyre.world",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",