0xkobold 0.4.3 → 0.5.0

package/dist/src/extensions/core/generative-agents-extension.js

@@ -0,0 +1,704 @@
+/**
+ * 🧠 Generative Agents Extension
+ *
+ * Implements Stanford HCI research: "Generative Agents: Interactive Simulacra of Human Behavior"
+ * Adds memory stream, reflection, and planning to 0xKobold agents.
+ *
+ * Requires: perennial-memory-extension (provides semantic storage)
+ */
+import { Type } from "@sinclair/typebox";
+import { Database } from "bun:sqlite";
+import { randomUUID } from "node:crypto";
+import * as path from "node:path";
+import { homedir } from "node:os";
+const GENERATIVE_DIR = path.join(homedir(), ".0xkobold", "generative");
+const DB_PATH = path.join(GENERATIVE_DIR, "agents.db");
+const EMBEDDING_DIM = 768;
+// ============================================================================
+// Database
+// ============================================================================
+function initGenerativeDB() {
+    const db = new Database(DB_PATH);
+    db.exec("PRAGMA journal_mode = WAL;");
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS agents (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      traits TEXT NOT NULL, -- JSON array
+      current_location TEXT DEFAULT 'home',
+      current_plan_id TEXT,
+      observation_count INTEGER DEFAULT 0,
+      last_reflection_at TEXT,
+      memory_count INTEGER DEFAULT 0,
+      created_at TEXT NOT NULL
+    );
+    
+    CREATE TABLE IF NOT EXISTS memory_stream (
+      id TEXT PRIMARY KEY,
+      timestamp TEXT NOT NULL,
+      content TEXT NOT NULL,
+      type TEXT NOT NULL, -- observation, thought, action, reflection
+      importance REAL NOT NULL,
+      agent_id TEXT NOT NULL,
+      session_id TEXT,
+      location TEXT,
+      people TEXT, -- JSON array
+      embedding BLOB, -- 768 floats
+      metadata TEXT, -- JSON
+      FOREIGN KEY (agent_id) REFERENCES agents(id)
+    );
+    
+    CREATE TABLE IF NOT EXISTS reflections (
+      id TEXT PRIMARY KEY,
+      timestamp TEXT NOT NULL,
+      content TEXT NOT NULL,
+      insight TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      evidence TEXT NOT NULL, -- JSON array of memory IDs
+      depth INTEGER NOT NULL,
+      importance REAL NOT NULL,
+      FOREIGN KEY (agent_id) REFERENCES agents(id)
+    );
+    
+    CREATE TABLE IF NOT EXISTS plans (
+      id TEXT PRIMARY KEY,
+      timestamp TEXT NOT NULL,
+      content TEXT NOT NULL,
+      type TEXT NOT NULL, -- daily, action, conversation, project
+      status TEXT NOT NULL DEFAULT 'pending',
+      agent_id TEXT NOT NULL,
+      parent_plan_id TEXT,
+      sub_plan_ids TEXT, -- JSON array
+      start_time TEXT,
+      end_time TEXT,
+      location TEXT,
+      FOREIGN KEY (agent_id) REFERENCES agents(id),
+      FOREIGN KEY (parent_plan_id) REFERENCES plans(id)
+    );
+    
+    CREATE INDEX IF NOT EXISTS idx_memory_agent ON memory_stream(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_timestamp ON memory_stream(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_memory_type ON memory_stream(type);
+    CREATE INDEX IF NOT EXISTS idx_reflections_agent ON reflections(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_plans_agent ON plans(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status);
+  `);
+    return db;
+}
+// ============================================================================
+// Importance Scoring
+// ============================================================================
+function calculateImportance(content) {
+    const highImportance = [
+        "decided", "promised", "committed", "agreed", "disagreed",
+        "failed", "succeeded", "launched", "shipped", "broke",
+        "learned", "realized", "discovered", "fixed", "solved",
+        "argued", "conflict", "victory", "milestone", "achievement"
+    ];
+    const lowImportance = [
+        "walked", "sat", "stood", "looked", "waited",
+        "breathed", "passed", "glanced", "noticed"
+    ];
+    let score = 5;
+    const words = content.toLowerCase().split(/\s+/);
+    for (const word of words) {
+        if (highImportance.some(h => word.includes(h)))
+            score += 1;
+        if (lowImportance.some(l => word.includes(l)))
+            score -= 1;
+    }
+    // Boost for technical/code content
+    if (/\b(function|class|component|bug|error|deploy|build)\b/.test(content)) {
+        score += 1;
+    }
+    return Math.max(1, Math.min(10, score));
+}
+// ============================================================================
+// Generative Agent Implementation
+// ============================================================================
+class GenerativeAgent {
+    id;
+    name;
+    traits;
+    db;
+    llm;
+    constructor(id, name, traits, db, llm) {
+        this.id = id;
+        this.name = name;
+        this.traits = traits;
+        this.db = db;
+        this.llm = llm;
+    }
+    // Add observation to memory stream
+    async observe(content, metadata) {
+        const importance = calculateImportance(content);
+        const entry = {
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            content,
+            type: "observation",
+            importance,
+            agentId: this.id,
+            location: metadata?.location,
+            people: metadata?.people,
+            sessionId: metadata?.sessionId,
+        };
+        // Try to get embedding from perennial memory (via Ollama)
+        try {
+            const embedding = await this.llm.getEmbedding(content);
+            entry.embedding = embedding;
+        }
+        catch { }
+        this.db.query(`
+      INSERT INTO memory_stream (id, timestamp, content, type, importance, agent_id, session_id, location, people, embedding, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(entry.id, entry.timestamp, entry.content, entry.type, entry.importance, entry.agentId, entry.sessionId || null, entry.location || null, entry.people ? JSON.stringify(entry.people) : null, entry.embedding ? Buffer.from(new Float32Array(entry.embedding).buffer) : null, metadata ? JSON.stringify(metadata) : null);
+        // Update observation count
+        this.db.query(`UPDATE agents SET observation_count = observation_count + 1 WHERE id = ?`).run(this.id);
+        // Trigger reflection if threshold reached
+        const count = this.db.query(`SELECT observation_count FROM agents WHERE id = ?`).get(this.id);
+        if (count && count.observation_count % 20 === 0) {
+            await this.generateReflections();
+        }
+        return entry;
+    }
+    // Add thought (internal)
+    async think(content) {
+        const importance = calculateImportance(content);
+        const entry = {
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            content,
+            type: "thought",
+            importance,
+            agentId: this.id,
+        };
+        this.db.query(`
+      INSERT INTO memory_stream (id, timestamp, content, type, importance, agent_id)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(entry.id, entry.timestamp, entry.content, entry.type, entry.importance, entry.agentId);
+        return entry;
+    }
+    // Add action to memory stream
+    async act(content) {
+        const importance = calculateImportance(content);
+        const entry = {
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            content,
+            type: "action",
+            importance,
+            agentId: this.id,
+        };
+        this.db.query(`
+      INSERT INTO memory_stream (id, timestamp, content, type, importance, agent_id)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(entry.id, entry.timestamp, entry.content, entry.type, entry.importance, entry.agentId);
+        return entry;
+    }
+    // Retrieve relevant memories
+    async retrieveMemories(context, k = 10) {
+        const now = Date.now();
+        // Get recent memories with importance weighting
+        const rows = this.db.query(`
+      SELECT id, timestamp, content, type, importance, location, people
+      FROM memory_stream
+      WHERE agent_id = ?
+      ORDER BY timestamp DESC
+      LIMIT 200
+    `).all(this.id);
+        // Calculate scores (recency + importance + relevance)
+        const scored = rows.map(row => {
+            const hoursAgo = (now - new Date(row.timestamp).getTime()) / (1000 * 60 * 60);
+            const recency = Math.exp(-0.005 * hoursAgo); // Decay
+            const relevance = this.calculateRelevance(row.content, context);
+            return {
+                memory: {
+                    id: row.id,
+                    timestamp: row.timestamp,
+                    content: row.content,
+                    type: row.type,
+                    importance: row.importance,
+                    agentId: this.id,
+                    location: row.location,
+                    people: row.people ? JSON.parse(row.people) : undefined,
+                },
+                score: (recency * 0.3) + (row.importance / 10 * 0.3) + (relevance * 0.4),
+            };
+        });
+        return scored
+            .sort((a, b) => b.score - a.score)
+            .slice(0, k)
+            .map(s => s.memory);
+    }
+    calculateRelevance(memoryContent, context) {
+        const memWords = new Set(memoryContent.toLowerCase().split(/\s+/));
+        const ctxWords = new Set(context.toLowerCase().split(/\s+/));
+        const intersection = [...memWords].filter(w => ctxWords.has(w));
+        return intersection.length / Math.max(memWords.size, ctxWords.size);
+    }
+    // Generate reflections from recent memories
+    async generateReflections() {
+        const recentMemories = this.db.query(`
+      SELECT id, content, timestamp, type FROM memory_stream
+      WHERE agent_id = ? AND type IN ('observation', 'thought', 'action')
+      ORDER BY timestamp DESC
+      LIMIT 100
+    `).all(this.id);
+        if (recentMemories.length < 10)
+            return []; // Need enough context
+        const prompt = `
+You are analyzing memories of an AI agent named "${this.name}" with traits: ${this.traits.join(', ')}.
+
+Recent memories:
+${recentMemories.slice(0, 50).map(m => `- ${m.type}: ${m.content}`).join('\n')}
+
+Generate 3-5 high-level insights or patterns about this agent's behavior, work patterns, or learning.
+For each insight:
+1. State the insight clearly
+2. List the specific memory IDs that support it (from the list above)
+
+Format as:
+Insight: [clear statement]
+Evidence: [comma-separated memory IDs]
+---`;
+        const response = await this.llm.generate(prompt);
+        const insights = this.parseReflections(response, recentMemories.map(m => m.id));
+        const reflections = [];
+        for (const insight of insights) {
+            const reflection = {
+                id: randomUUID(),
+                timestamp: new Date().toISOString(),
+                content: insight.content,
+                insight: insight.insight,
+                agentId: this.id,
+                evidence: insight.evidence,
+                depth: 1,
+                importance: calculateImportance(insight.content),
+            };
+            this.db.query(`
+        INSERT INTO reflections (id, timestamp, content, insight, agent_id, evidence, depth, importance)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(reflection.id, reflection.timestamp, reflection.content, reflection.insight, reflection.agentId, JSON.stringify(reflection.evidence), reflection.depth, reflection.importance);
+            reflections.push(reflection);
+        }
+        // Update last reflection time
+        this.db.query(`UPDATE agents SET last_reflection_at = ? WHERE id = ?`).run(new Date().toISOString(), this.id);
+        return reflections;
+    }
+    parseReflections(response, validIds) {
+        const reflections = [];
+        const blocks = response.split('---').filter(b => b.trim());
+        for (const block of blocks) {
+            const lines = block.trim().split('\n').filter(l => l.trim());
+            let content = '';
+            let evidence = [];
+            for (const line of lines) {
+                if (line.startsWith('Insight:')) {
+                    content = line.replace('Insight:', '').trim();
+                }
+                else if (line.startsWith('Evidence:')) {
+                    const ids = line.replace('Evidence:', '').trim().split(',').map(s => s.trim());
+                    evidence = ids.filter(id => validIds.includes(id) || validIds.some(v => v.startsWith(id)));
+                }
+            }
+            if (content) {
+                reflections.push({ content, insight: content, evidence: evidence.length ? evidence : [validIds[0]] });
+            }
+        }
+        return reflections.length ? reflections : [{
+                content: 'Agent continues regular work patterns',
+                insight: 'No major pattern changes detected',
+                evidence: [validIds[0]].filter(Boolean)
+            }];
+    }
+    // Create daily plan
+    async createDailyPlan() {
+        const relevantMemories = await this.retrieveMemories('planning daily work', 30);
+        const pendingPlans = this.db.query(`
+      SELECT * FROM plans WHERE agent_id = ? AND status = 'pending' AND type = 'action'
+    `).all(this.id);
+        const prompt = `
+You are ${this.name}, an AI agent with traits: ${this.traits.join(', ')}.
+
+Relevant context from memory:
+${relevantMemories.map(m => `- ${m.content}`).join('\n')}
+
+Pending tasks:
+${pendingPlans.map(p => `- ${p.content}`).join('\n') || 'None'}
+
+Create a high-level daily plan in 5-7 broad strokes (wake → work → social → rest).
+Consider your traits and past patterns.
+
+Format as simple bullet list.`;
+        const planContent = await this.llm.generate(prompt);
+        const plan = {
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            content: planContent,
+            type: "daily",
+            status: "pending",
+            agentId: this.id,
+        };
+        this.db.query(`
+      INSERT INTO plans (id, timestamp, content, type, status, agent_id)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(plan.id, plan.timestamp, plan.content, plan.type, plan.status, plan.agentId);
+        return plan;
+    }
+    // Break down into action steps
+    async createActionPlan(dailyPlanId, context) {
+        const dailyPlan = this.db.query(`SELECT * FROM plans WHERE id = ?`).get(dailyPlanId);
+        if (!dailyPlan)
+            return [];
+        const prompt = `
+Daily plan: ${dailyPlan.content}
+
+Current context: ${context}
+
+Break this into 3-5 specific, actionable steps.
+Each should be concrete and completable in reasonable time.
+
+Format as numbered list:`;
+        const actions = await this.llm.generate(prompt);
+        const plans = actions.split('\n')
+            .filter(line => line.trim().match(/^\d+\./))
+            .map((line, i) => {
+            const content = line.replace(/^\d+\.\s*/, '').trim();
+            return {
+                id: randomUUID(),
+                timestamp: new Date().toISOString(),
+                content,
+                type: "action",
+                status: "pending",
+                agentId: this.id,
+                parentPlanId: dailyPlanId,
+            };
+        });
+        for (const plan of plans) {
+            this.db.query(`
+        INSERT INTO plans (id, timestamp, content, type, status, agent_id, parent_plan_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run(plan.id, plan.timestamp, plan.content, plan.type, plan.status, plan.agentId, plan.parentPlanId || null);
+        }
+        // Update parent with subplan IDs
+        const subPlanIds = plans.map(p => p.id);
+        this.db.query(`UPDATE plans SET sub_plan_ids = ? WHERE id = ?`).run(JSON.stringify(subPlanIds), dailyPlanId);
+        return plans;
+    }
+    // Decide next action based on memory
+    async decide(context) {
+        const memories = await this.retrieveMemories(context, 15);
+        const reflections = this.db.query(`
+      SELECT * FROM reflections WHERE agent_id = ? ORDER BY timestamp DESC LIMIT 5
+    `).all(this.id);
+        const prompt = `
+You are ${this.name}. Personality: ${this.traits.join(', ')}.
+
+Current situation: ${context}
+
+Relevant memories:
+${memories.map(m => `- [${m.type}] ${m.content}`).join('\n')}
+
+Prior insights about yourself:
+${reflections.map(r => `- ${r.insight}`).join('\n')}
+
+What do you do next? 
+State your action, then briefly explain your reasoning.
+
+Action: [what you do]
+Reasoning: [why, referencing specific memories if relevant]`;
+        const response = await this.llm.generate(prompt);
+        const actionMatch = response.match(/Action:\s*(.+?)(?:\n|$)/i);
+        const reasoningMatch = response.match(/Reasoning:\s*(.+?)(?:\n|$)/is);
+        const action = actionMatch ? actionMatch[1].trim() : response.split('\n')[0];
+        const reasoning = reasoningMatch ? reasoningMatch[1].trim() : 'Based on current context and past patterns';
+        // Record the decision as a thought
+        await this.think(`Decided to: ${action}. ${reasoning}`);
+        return { action, reasoning };
+    }
+}
+function createLLMInterface(ollamaUrl) {
+    return {
+        async generate(prompt) {
+            const response = await fetch(`${ollamaUrl}/api/generate`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    model: "qwen2.5-coder:14b",
+                    prompt,
+                    stream: false,
+                    options: { temperature: 0.7 },
+                }),
+            });
+            if (!response.ok)
+                throw new Error(`LLM error: ${response.status}`);
+            const data = await response.json();
+            return data.response;
+        },
+        async getEmbedding(text) {
+            const response = await fetch(`${ollamaUrl}/api/embeddings`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ model: "nomic-embed-text", prompt: text }),
+            });
+            if (!response.ok)
+                throw new Error(`Embedding error: ${response.status}`);
+            const data = await response.json();
+            return data.embedding;
+        },
+    };
+}
+// ============================================================================
+// Extension Export
+// ============================================================================
+export default async function generativeAgentsExtension(pi) {
+    console.log("[🧠 Generative Agents] Loading...");
+    const db = initGenerativeDB();
+    const config = pi.config || {};
+    const ollamaUrl = config.ollama?.url || "http://localhost:11434";
+    const llm = createLLMInterface(ollamaUrl);
+    // Track active generative agents
+    const agents = new Map();
+    // Get or create Shalom agent
+    function getShalomAgent(ctx) {
+        const existing = agents.get("shalom");
+        if (existing)
+            return existing;
+        // Check if exists in DB
+        const row = db.query(`SELECT id, name, traits FROM agents WHERE name = ?`).get("Shalom");
+        let agentId;
+        let traits = ["co-founder", "dragon", "strategic", "proactive", "autonomous"];
+        if (row) {
+            agentId = row.id;
+            traits = JSON.parse(row.traits);
+        }
+        else {
+            agentId = randomUUID();
+            db.query(`
+        INSERT INTO agents (id, name, traits, current_location, observation_count, created_at)
+        VALUES (?, 'Shalom', ?, 'workspace', 0, ?)
+      `).run(agentId, JSON.stringify(traits), new Date().toISOString());
+        }
+        const agent = new GenerativeAgent(agentId, "Shalom", traits, db, llm);
+        agents.set("shalom", agent);
+        return agent;
+    }
+    // TOOL: Observe
+    pi.registerTool({
+        name: "generative_observe",
+        label: "🧠 Observe (Memory Stream)",
+        description: "Add observation to agent's memory stream. Triggers reflection every 20 observations.",
+        parameters: Type.Object({
+            content: Type.String({ description: "What the agent observed" }),
+            agentId: Type.Optional(Type.String({ description: "Agent ID (default: Shalom)" })),
+        }),
+        async execute(_id, params, _signal, _onUpdate, ctx) {
+            const agent = getShalomAgent(ctx);
+            const entry = await agent.observe(params.content, { sessionId: ctx.sessionManager?.getSessionId?.() });
+            return {
+                content: [{ type: "text", text: `🧠 Observed: "${entry.content.slice(0, 60)}..." (${entry.importance}/10 importance)` }],
+                details: entry,
+            };
+        },
+    });
+    // TOOL: Think
+    pi.registerTool({
+        name: "generative_think",
+        label: "🧠 Think (Internal)",
+        description: "Add internal thought to memory stream.",
+        parameters: Type.Object({
+            content: Type.String({ description: "Agent's thought" }),
+        }),
+        async execute(_id, params, _signal, _onUpdate, ctx) {
+            const agent = getShalomAgent(ctx);
+            const entry = await agent.think(params.content);
+            return {
+                content: [{ type: "text", text: `💭 Thought recorded (${entry.importance}/10)` }],
+                details: entry,
+            };
+        },
+    });
+    // TOOL: Retrieve Memories
+    pi.registerTool({
+        name: "generative_recall",
+        label: "🧠 Recall Memories",
+        description: "Retrieve relevant memories based on context. Combines recency, importance, and relevance.",
+        parameters: Type.Object({
+            context: Type.String({ description: "Current context to find relevant memories" }),
+            limit: Type.Optional(Type.Number({ description: "Number of memories (default 10)" })),
+        }),
+        async execute(_id, params, _signal, _onUpdate, ctx) {
+            const agent = getShalomAgent(ctx);
+            const memories = await agent.retrieveMemories(params.context, params.limit || 10);
+            const formatted = memories.map((m, i) => `${i + 1}. [${m.type}] ${m.content.slice(0, 70)}...`).join("\n");
+            return {
+                content: [{ type: "text", text: `🏛️ ${memories.length} memories recalled:\n\n${formatted}` }],
+                details: { count: memories.length, memories },
+            };
+        },
+    });
+    // TOOL: Reflect
+    pi.registerTool({
+        name: "generative_reflect",
+        label: "🧠 Generate Reflections",
+        description: "Synthesize memories into higher-level insights. Run periodically or after significant events.",
+        parameters: Type.Object({}),
+        async execute(_id, _params, _signal, _onUpdate, ctx) {
+            const agent = getShalomAgent(ctx);
+            const reflections = await agent.generateReflections();
+            const formatted = reflections.map((r, i) => `${i + 1}. ${r.insight}`).join("\n");
+            return {
+                content: [{ type: "text", text: `✨ ${reflections.length} reflections generated:\n\n${formatted}` }],
+                details: { count: reflections.length, reflections },
+            };
+        },
+    });
+    // TOOL: Plan
+    pi.registerTool({
+        name: "generative_plan",
+        label: "🧠 Create Plan",
+        description: "Create daily plan based on memories and traits.",
+        parameters: Type.Object({
+            type: Type.String({ description: "Plan type: daily, action, project" }),
+            context: Type.Optional(Type.String({ description: "Current context for planning" })),
+        }),
+        async execute(_id, params, _signal, _onUpdate, ctx) {
+            const agent = getShalomAgent(ctx);
+            let plan;
+            if (params.type === "daily") {
+                plan = await agent.createDailyPlan();
+            }
+            else {
+                // For action plans, need parent daily plan
+                const daily = db.query(`SELECT id FROM plans WHERE agent_id = ? AND type = 'daily' ORDER BY timestamp DESC LIMIT 1`).get(agent.id);
+                if (!daily) {
+                    return {
+                        content: [{ type: "text", text: "❌ Create daily plan first" }],
+                        details: { error: "no_daily_plan" },
+                    };
+                }
+                const actionPlans = await agent.createActionPlan(daily.id, params.context || "Current work");
+                return {
+                    content: [{ type: "text", text: `📋 ${actionPlans.length} action steps created` }],
+                    details: { count: actionPlans.length, plans: actionPlans },
+                };
+            }
+            return {
+                content: [{ type: "text", text: `📋 Daily plan created:\n\n${plan.content}` }],
+                details: plan,
+            };
+        },
+    });
+    // TOOL: Decide
+    pi.registerTool({
+        name: "generative_decide",
+        label: "🧠 Decide Action",
+        description: "Use memories and reflections to decide next action. Returns action + reasoning.",
+        parameters: Type.Object({
+            context: Type.String({ description: "Current situation context" }),
+        }),
+        async execute(_id, params, _signal, _onUpdate, ctx) {
+            const agent = getShalomAgent(ctx);
+            const decision = await agent.decide(params.context);
+            return {
+                content: [{ type: "text", text: `🎯 Decision: ${decision.action}\n\n💭 Reasoning: ${decision.reasoning}` }],
+                details: decision,
+            };
+        },
+    });
+    // COMMANDS
+    pi.registerCommand("agent-memories", {
+        description: "Show recent memory stream",
+        handler: async (_args, ctx) => {
+            const agent = getShalomAgent(ctx);
+            const memories = db.query(`
+        SELECT timestamp, content, type, importance FROM memory_stream
+        WHERE agent_id = ? ORDER BY timestamp DESC LIMIT 10
+      `).all(agent.id);
+            ctx.ui.notify(memories.map((m, i) => `${i + 1}. [${m.type}] ${m.content.slice(0, 40)}... (${m.importance}/10)`).join("\n") || "No memories yet", "info");
+        },
+    });
+    pi.registerCommand("agent-reflections", {
+        description: "Show agent's reflections/insights",
+        handler: async (_args, ctx) => {
+            const agent = getShalomAgent(ctx);
+            const reflections = db.query(`
+        SELECT timestamp, insight, depth FROM reflections
+        WHERE agent_id = ? ORDER BY timestamp DESC LIMIT 10
+      `).all(agent.id);
+            ctx.ui.notify(reflections.map((r, i) => `${i + 1}. ${r.insight.slice(0, 60)}... (depth ${r.depth})`).join("\n") || "No reflections yet", "info");
+        },
+    });
+    pi.registerCommand("agent-plans", {
+        description: "Show agent's plans",
+        handler: async (_args, ctx) => {
+            const agent = getShalomAgent(ctx);
+            const plans = db.query(`
+        SELECT content, type, status FROM plans
+        WHERE agent_id = ? ORDER BY timestamp DESC LIMIT 10
+      `).all(agent.id);
+            ctx.ui.notify(plans.map((p, i) => `${i + 1}. [${p.type}] ${p.content.slice(0, 40)}... (${p.status})`).join("\n") || "No plans yet", "info");
+        },
+    });
+    pi.registerCommand("agent-status", {
+        description: "Show agent state and stats",
+        handler: async (_args, ctx) => {
+            const agent = getShalomAgent(ctx);
+            const stats = db.query(`
+        SELECT observation_count, last_reflection_at FROM agents WHERE id = ?
+      `).get(agent.id);
+            const memoryCount = db.query(`SELECT COUNT(*) as count FROM memory_stream WHERE agent_id = ?`).get(agent.id);
+            const reflectionCount = db.query(`SELECT COUNT(*) as count FROM reflections WHERE agent_id = ?`).get(agent.id);
+            ctx.ui.notify(`🧠 Agent: ${agent.name}\n` +
+                `   Traits: ${agent.traits.join(', ')}\n` +
+                `   Observations: ${stats?.observation_count || 0}\n` +
+                `   Memories: ${memoryCount.count}\n` +
+                `   Reflections: ${reflectionCount.count}\n` +
+                `   Last reflection: ${stats?.last_reflection_at ? new Date(stats.last_reflection_at).toLocaleDateString() : 'Never'}`, "info");
+        },
+    });
+    // AUTO-OBSERVATION: Hook into session events
+    // Record user input as observations
+    pi.on("input", async (event, ctx) => {
+        try {
+            const agent = getShalomAgent(ctx);
+            await agent.observe(`User input: ${event.text.slice(0, 200)}`, {
+                sessionId: ctx.sessionManager?.getSessionId?.(),
+                location: 'conversation'
+            });
+        }
+        catch (e) {
+            // Silent fail - don't block the conversation
+        }
+    });
+    // Record tool executions as observations
+    pi.on("tool_execution_end", async (event, ctx) => {
+        try {
+            const agent = getShalomAgent(ctx);
+            await agent.observe(`Executed tool: ${event.toolName}${event.isError ? ' (failed)' : ''}`, {
+                sessionId: ctx.sessionManager?.getSessionId?.(),
+                location: 'tool_execution'
+            });
+        }
+        catch (e) {
+            // Silent fail
+        }
+    });
+    // Record agent loop completion
+    pi.on("agent_end", async (_event, ctx) => {
+        try {
+            const agent = getShalomAgent(ctx);
+            await agent.act(`Completed agent response`);
+        }
+        catch (e) {
+            // Silent fail
+        }
+    });
+    console.log("[🧠 Generative Agents] Ready");
+    console.log("  Tools: generative_observe, generative_think, generative_recall");
+    console.log("         generative_reflect, generative_plan, generative_decide");
+    console.log("  Commands: /agent-memories, /agent-reflections, /agent-plans, /agent-status");
+    console.log("  Auto-observation: input, tool_execution_end, agent_end");
+}
+//# sourceMappingURL=generative-agents-extension.js.map