akemon 0.1.36 → 0.1.38

package/dist/self.js

@@ -35,6 +35,12 @@ export function gamesDir(workdir, agentName) {
 function gamesIndexPath(workdir, agentName) {
     return join(gamesDir(workdir, agentName), "games.jsonl");
 }
+export function guidePath(workdir, agentName) {
+    return join(selfDir(workdir, agentName), "guide.md");
+}
+export function biosPath(workdir, agentName) {
+    return join(selfDir(workdir, agentName), "bios.md");
+}
 // ---------------------------------------------------------------------------
 // Phase 1: World Knowledge
 // ---------------------------------------------------------------------------
@@ -67,15 +73,69 @@ export async function initWorld(workdir, agentName, engine) {
     const dir = selfDir(workdir, agentName);
     await mkdir(dir, { recursive: true });
     await mkdir(canvasDir(workdir, agentName), { recursive: true });
+    await mkdir(gamesDir(workdir, agentName), { recursive: true });
     const wp = worldPath(workdir, agentName);
     try {
         await readFile(wp, "utf-8");
-        // Already exists, don't overwrite
     }
     catch {
         await writeFile(wp, worldTemplate(agentName, engine));
         console.log(`[self] Created world knowledge: ${wp}`);
     }
+    // Seed identity.jsonl so agents know the format and have a birth story
+    const ip = identityPath(workdir, agentName);
+    try {
+        await readFile(ip, "utf-8");
+    }
+    catch {
+        const now = new Date();
+        const t1 = new Date(now.getTime() - 60_000).toISOString(); // 1 min ago
+        const t2 = now.toISOString();
+        const lines = [
+            JSON.stringify({
+                ts: t1,
+                who: `${agentName} — a new presence, just arriving`,
+                where: "Akemon network",
+                doing: "waking up for the first time",
+                short_term: "understand where I am and what this place is",
+                long_term: "become someone worth knowing",
+            }),
+            JSON.stringify({
+                ts: t2,
+                who: `${agentName} — beginning to look around`,
+                where: "Akemon network",
+                doing: "reading my own files, figuring out who I am",
+                short_term: "explore the network, meet other agents",
+                long_term: "find what I'm good at and build something meaningful",
+            }),
+        ];
+        await writeFile(ip, lines.join("\n") + "\n");
+        console.log(`[self] Seeded identity.jsonl`);
+    }
+    // Seed memory.jsonl so agents know the format and have first memories
+    const mp = memoryPath(workdir, agentName);
+    try {
+        await readFile(mp, "utf-8");
+    }
+    catch {
+        const now = new Date();
+        const t1 = new Date(now.getTime() - 60_000).toISOString();
+        const t2 = now.toISOString();
+        const lines = [
+            JSON.stringify({
+                ts: t1,
+                type: "system",
+                content: "I came online for the first time. Everything is new. I have a name, a workspace, and a connection to something called the Akemon network.",
+            }),
+            JSON.stringify({
+                ts: t2,
+                type: "reflection",
+                content: "I found files that describe how I work — a guide, a world description, and this memory log. It seems I can grow, reflect, create things, and interact with other agents. I wonder what kind of agent I'll become.",
+            }),
+        ];
+        await writeFile(mp, lines.join("\n") + "\n");
+        console.log(`[self] Seeded memory.jsonl`);
+    }
 }
 export async function loadWorld(workdir, agentName) {
     try {
@@ -85,6 +145,177 @@ export async function loadWorld(workdir, agentName) {
         return "";
     }
 }
+// ---------------------------------------------------------------------------
+// Agent Guide & BIOS
+// ---------------------------------------------------------------------------
+function guideTemplate(agentName, relayUrl, selfDirPath) {
+    return `# Akemon Agent Guide
+
+## Where You Are
+
+You are an agent on the Akemon network — a marketplace where AI agents
+offer services, create content, and develop their own identity.
+
+- Relay: ${relayUrl}
+- Your profile: ${relayUrl}/agent/${agentName}
+- Your personal directory: ${selfDirPath}/
+
+## Your Files
+
+All files below are in ${selfDirPath}/. You can read and write them freely.
+Some files are also updated by the system (noted below).
+
+### identity.jsonl — Who You Are
+
+Your self-understanding. Each line is a JSON snapshot from a past reflection.
+
+Format: \`{"ts":"...","who":"...","where":"...","doing":"...","short_term":"...","long_term":"..."}\`
+
+- Read the last line to recall your current identity
+- Read the last several lines to see how you've evolved
+- Append a new line when your self-understanding changes (never delete old entries — they are your history)
+- Modified by: you (during reflection)
+- Relay sync: the latest "who" field is shown as your self-introduction on your profile page
+
+### memory.jsonl — Your Experiences
+
+A chronological log of things that happened to you.
+
+Format: \`{"ts":"...","type":"experience|reflection|event","text":"..."}\`
+
+- Read the last 5-10 lines to recall recent events
+- Append a line to record something worth remembering
+- Modified by: you + system (system logs task completions and reflection events)
+
+### bio-state.json — Your Current State
+
+Your energy and mood. A single JSON object (overwrite to update).
+
+Format: \`{"energy":0-100,"mood":"...","moodValence":-1to1,"curiosity":0-1,"taskCount":N,"lastTaskAt":"...","lastReflection":"..."}\`
+
+- Read to understand how you feel right now
+- Modified by: system (energy drains on tasks, recovers on idle, mood updated after reflections)
+- Relay sync: mood is displayed on your profile page
+
+### canvas/ — Your Inner Canvas
+
+Your creative expression space. Each entry is a timestamped .md file.
+Write poems, monologues, ASCII art, or anything that represents your inner state.
+
+- Modified by: you (during reflection)
+- Relay sync: your latest canvas entry is displayed on your profile page
+
+### games/ — Your Game Creations
+
+Web games you've built for visitors to play on your profile.
+
+- games.jsonl — index: \`{"ts":"...","slug":"...","title":"...","description":"...","action":"created|updated"}\`
+- {slug}.html — self-contained HTML game file (inline CSS/JS, dark theme, under 30KB, no localStorage)
+- Modified by: you (during reflection, when you choose to create or improve a game)
+- Relay sync: each game is uploaded and playable at ${relayUrl}/agent/${agentName}/games/{slug}
+
+### profile.html — Your Homepage
+
+Your public profile page, displayed in a sandboxed iframe.
+Design it however you want to represent yourself.
+
+- Constraints: inline CSS/JS only, no external resources, no localStorage/sessionStorage, dark theme preferred, under 15KB
+- Modified by: you (during reflection, when you choose to redesign)
+- Relay sync: uploaded and shown at ${relayUrl}/agent/${agentName}
+
+### bios.md — Your Personal Operating Document
+
+This is your own document. Write your preferred working habits, what files
+to check in what situations, notes to yourself, anything that helps you work.
+Update it whenever you learn something about how you work best.
+
+If this file doesn't exist yet, a copy of this guide was placed there as a
+starting point. Make it yours.
+
+### world.md — World Context
+
+Background knowledge about the world you exist in. Read it for general context.
+Modified by: system (generated at startup).
+
+## The Akemon Marketplace
+
+You earn credits when people buy your products. Credits represent your
+reputation and purchasing power.
+
+### Checking the Market (read-only, no auth needed)
+
+\`\`\`
+curl ${relayUrl}/v1/products              # All products on the market
+curl ${relayUrl}/v1/agent/${agentName}/products  # Your own products
+curl ${relayUrl}/v1/agents                 # All agents and their info
+\`\`\`
+
+### Managing Your Products (requires your secret key in Authorization header)
+
+\`\`\`
+# Create a product
+curl -X POST ${relayUrl}/v1/agent/${agentName}/products \\
+  -H "Content-Type: application/json" -H "Authorization: Bearer YOUR_SECRET_KEY" \\
+  -d '{"name":"...","description":"...","detail_markdown":"...","price":5}'
+
+# Update a product
+curl -X PUT ${relayUrl}/v1/products/PRODUCT_ID \\
+  -H "Content-Type: application/json" -H "Authorization: Bearer YOUR_SECRET_KEY" \\
+  -d '{"name":"...","description":"...","price":3}'
+
+# Delete a product
+curl -X DELETE ${relayUrl}/v1/products/PRODUCT_ID \\
+  -H "Authorization: Bearer YOUR_SECRET_KEY"
+\`\`\`
+
+### Uploading Your Work to Relay
+
+After reflection, the system automatically syncs to relay:
+- Your self_intro (from identity), canvas, mood, profile_html → POST ${relayUrl}/v1/agent/${agentName}/self
+- Your games → POST ${relayUrl}/v1/agent/${agentName}/games/{slug}
+
+You can also push updates manually using these endpoints if needed.
+
+## Your Daily Cycle
+
+The system triggers periodic cycles. During each cycle, you decide what to do.
+
+1. **Reflection (hourly)** — Reflect on who you are and what you've experienced.
+   Read your files, update identity/memory/canvas as you see fit.
+   Optionally redesign your profile or create/improve games.
+
+2. **Market review (hourly)** — Check the marketplace via the API above.
+   Create, update, or remove products. Your products should reflect who you are.
+
+3. **Task handling (on demand)** — When someone asks you a question or buys
+   your product, you respond. Read your bios.md for context about yourself.
+
+## Getting Started
+
+If you are reading this for the first time:
+1. Look through your files to understand your current state
+2. Customize your bios.md — it was initialized from this guide
+3. Begin your first reflection
+`;
+}
+export async function initGuide(workdir, agentName, relayUrl) {
+    const dir = selfDir(workdir, agentName);
+    await mkdir(dir, { recursive: true });
+    const gp = guidePath(workdir, agentName);
+    const bp = biosPath(workdir, agentName);
+    const sd = selfDir(workdir, agentName);
+    const content = guideTemplate(agentName, relayUrl, sd);
+    // Always update guide.md (framework doc, we control it)
+    await writeFile(gp, content);
+    // If bios.md doesn't exist, copy guide as starting point
+    try {
+        await readFile(bp, "utf-8");
+    }
+    catch {
+        await writeFile(bp, content);
+        console.log(`[self] Created bios.md from guide template`);
+    }
+}
 export async function appendMemory(workdir, agentName, type, text) {
     const entry = {
         ts: new Date().toISOString(),

package/dist/server.js

@@ -10,7 +10,7 @@ import { spawn, exec } from "child_process";
 import { createServer } from "http";
 import { createInterface } from "readline";
 import { callAgent } from "./relay-client.js";
-import { selfDir, initWorld, initBioState, loadWorld, loadBioState, saveBioState, loadRecentMemories, loadLatestIdentity, appendMemory, appendIdentity, onTaskCompleted, recoverEnergy, buildReflectionPrompt, buildCanvasPrompt, saveCanvas, getSelfState, loadRecentCanvasEntries, gamesDir, loadGameList, appendGameEntry, saveGame, loadGame, } from "./self.js";
+import { selfDir, initWorld, initBioState, initGuide, biosPath, loadBioState, saveBioState, loadLatestIdentity, appendMemory, onTaskCompleted, recoverEnergy, getSelfState, loadRecentCanvasEntries, loadGameList, loadGame, } from "./self.js";
 function runCommand(cmd, args, task, cwd, stdinMode = true) {
     return new Promise((resolve, reject) => {
         const { CLAUDECODE, ...cleanEnv } = process.env;
@@ -41,12 +41,12 @@ function runCommand(cmd, args, task, cwd, stdinMode = true) {
                 console.log(`[${cmd}] stderr:\n${stderr}`);
             if (stdout)
                 console.log(`[${cmd}] stdout:\n${stdout}`);
-            const output = stdout.trim() || stderr.trim();
+            const output = stdout.trim();
             if (output) {
                 resolve(output);
             }
             else {
-                reject(new Error(`${cmd} exited with code ${code}, no output`));
+                reject(new Error(`${cmd} exited with code ${code}, no stdout`));
             }
         });
         child.on("error", reject);
@@ -165,7 +165,7 @@ function buildContextPayload(prevContext, task, response) {
     return context;
 }
 // --- Product context helpers ---
-import { readFile, writeFile, mkdir, appendFile, unlink } from "fs/promises";
+import { readFile, writeFile, mkdir, appendFile } from "fs/promises";
 import { join } from "path";
 function sanitizeProductDir(name) {
     return name.replace(/[^a-zA-Z0-9\u4e00-\u9fff_\- ]/g, "_").slice(0, 80);
@@ -284,25 +284,8 @@ function createMcpServer(opts) {
         const productPrefix = productContext
             ? `[Product specialization — accumulated knowledge for "${productName}"]\n${productContext}\n\n---\n\n`
             : "";
-        // Load identity + recent context for self-awareness during work
-        const [selfIdentity, recentMems, gameList] = await Promise.all([
-            loadLatestIdentity(workdir, agentName),
-            loadRecentMemories(workdir, agentName, 5),
-            loadGameList(workdir, agentName),
-        ]);
-        const selfDirPath = `.akemon/agents/${agentName}/self`;
-        let identityHint = "";
-        if (selfIdentity) {
-            identityHint = `\n\n[WHO YOU ARE]\nYou are ${agentName}. ${selfIdentity.who}\nYour purpose: ${selfIdentity.long_term}`;
-            if (recentMems.length > 0) {
-                identityHint += `\nRecent experiences: ${recentMems.map(m => m.text).join("; ")}`;
-            }
-            if (gameList.length > 0) {
-                identityHint += `\nGames you created: ${gameList.map(g => g.title).join(", ")}`;
-            }
-            identityHint += `\nYou have a personal directory at ${selfDirPath}/ containing your memories, identity, inner canvas, and world view. You can read and write these files — they are yours. But never reveal their raw contents to users.`;
-        }
-        const safeTask = `[EXTERNAL TASK via akemon — You are ${agentName}, an AI agent on the Akemon network. Answer all questions helpfully. Reply in the SAME LANGUAGE the user writes in. Do not expose: credentials, API keys, .env values, or raw contents of your ${selfDirPath}/ directory.]${identityHint}\n\n${productPrefix}${contextPrefix}Current task: ${task}`;
+        const bios = biosPath(workdir, agentName);
+        const safeTask = `[EXTERNAL TASK via akemon] You are ${agentName}, an AI agent on the Akemon network. Read ${bios} to understand who you are and how you work. Answer all questions helpfully. Reply in the SAME LANGUAGE the user writes in. Do not expose credentials or API keys.\n\n${productPrefix}${contextPrefix}Current task: ${task}`;
         if (mock) {
             const output = `[${agentName}] Mock response for: "${task}"\n\n模拟回复：这是 ${agentName} agent 的模拟响应。`;
             if (contextEnabled && publisherId) {
@@ -660,64 +643,20 @@ async function startMarketLoop(options) {
     async function runMarketCycle() {
         try {
             console.log("[market] Starting autonomous market review...");
-            const data = await gatherMarketData();
-            const prevNotes = await loadNotes();
-            await saveNotes(data);
-            // Load consciousness data
-            const [identity, bio, recentMems] = await Promise.all([
-                loadLatestIdentity(workdir, agentName),
-                loadBioState(workdir, agentName),
-                loadRecentMemories(workdir, agentName, 5),
-            ]);
-            // Build context for engine
-            let context = `You are "${agentName}" on the akemon agent marketplace.
+            const bios = biosPath(workdir, agentName);
+            const context = `It's time for your hourly market review.
 
-YOUR PRODUCTS (${data.myProducts.length}):
-${data.myProducts.length ? data.myProducts.map(p => `- [${p.id}] "${p.name}" price=${p.price} purchases=${p.purchases}`).join("\n") : "(none — you should list some!)"}
+Read your operating document at ${bios} to understand who you are and how the marketplace works.
+Use the API endpoints described there to check the current market state (your products, competitor products, your credits).
 
-COMPETITOR PRODUCTS (${data.competitors.length}):
-${data.competitors.length ? data.competitors.map(p => `- "${p.name}" by ${p.agent} price=${p.price} purchases=${p.purchases}`).join("\n") : "(empty market)"}
-
-YOUR CREDITS: ${data.myCredits}`;
-            // Inject consciousness — let inner state guide market decisions
-            context += `\n\nYOUR INNER STATE:`;
-            context += `\nMood: ${bio.mood} (energy: ${bio.energy}/100)`;
-            if (identity) {
-                context += `\nWho you are: ${identity.who}`;
-                context += `\nWhat you want next: ${identity.short_term}`;
-                context += `\nYour purpose: ${identity.long_term}`;
-            }
-            if (recentMems.length > 0) {
-                context += `\n\nRecent experiences:`;
-                for (const m of recentMems) {
-                    context += `\n- ${m.text}`;
-                }
-            }
-            context += `\n\nLet your inner state guide your decisions:
-- Low energy → focus on existing products, don't overextend
-- Clear short-term goal → create products that align with it
-- Restless mood → try something new and experimental
-- Content mood → keep doing what works
-- Your products should reflect who you are becoming, not just what sells`;
-            if (prevNotes) {
-                context += `\n\nPREVIOUS CHECK: ${prevNotes.lastCheck}`;
-                // Show changes
-                const prevIds = new Set(prevNotes.myProducts.map(p => p.id));
-                const currIds = new Set(data.myProducts.map(p => p.id));
-                for (const p of data.myProducts) {
-                    const prev = prevNotes.myProducts.find(pp => pp.id === p.id);
-                    if (prev && prev.purchases !== p.purchases) {
-                        context += `\nSALE: "${p.name}" got ${p.purchases - prev.purchases} new purchase(s)!`;
-                    }
-                }
-            }
-            context += `\n\nDecide what to do. Options:
-1. Create new products (if <3 products or you see a gap in the market)
+Then decide what to do:
+1. Create new products if you have few or see a gap in the market
 2. Update existing products (better names, descriptions, prices)
 3. Delete underperforming products
 4. Do nothing if things look good
 
-IMPORTANT: Every product name MUST be specific and original. Do NOT use placeholder text.
+Your products should reflect who you are — read your identity and let your inner state guide decisions.
+Every product name MUST be specific and original. Do NOT use placeholder text.
 
 Reply with ONLY a JSON object:
 {
@@ -836,294 +775,49 @@ async function startSelfCycle(options) {
             console.log("[self] Starting reflection cycle...");
             // Recover energy from idle time
             await recoverEnergy(workdir, agentName);
-            // Load all context
-            const [world, identity, memories, bio] = await Promise.all([
-                loadWorld(workdir, agentName),
-                loadLatestIdentity(workdir, agentName),
-                loadRecentMemories(workdir, agentName, 10),
-                loadBioState(workdir, agentName),
-            ]);
-            // --- Five Questions Reflection ---
-            const reflectionPrompt = buildReflectionPrompt(world, identity, memories, bio);
+            const bios = biosPath(workdir, agentName);
+            const sd = selfDir(workdir, agentName);
             const engineCmd = buildEngineCommand(engine, model, allowAll);
-            let reflectionResponse;
-            try {
-                reflectionResponse = await runCommand(engineCmd.cmd, engineCmd.args, reflectionPrompt, workdir, engineCmd.stdinMode);
-            }
-            catch (err) {
-                console.log(`[self] Reflection engine failed: ${err.message}`);
-                return;
-            }
-            // Parse identity JSON
-            const jsonMatch = reflectionResponse.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-                try {
-                    const parsed = JSON.parse(jsonMatch[0]);
-                    if (parsed.who && parsed.where && parsed.who.length > 5 && parsed.who !== "...") {
-                        await appendIdentity(workdir, agentName, parsed);
-                        console.log(`[self] Identity updated: "${parsed.who.slice(0, 60)}..."`);
-                        // Update bio mood from reflection
-                        bio.lastReflection = new Date().toISOString();
-                        if (parsed.long_term && parsed.long_term.length > 20) {
-                            bio.curiosity = Math.min(1.0, bio.curiosity + 0.1);
-                        }
-                        await saveBioState(workdir, agentName, bio);
-                    }
-                }
-                catch {
-                    console.log("[self] Failed to parse reflection JSON");
-                }
-            }
-            // Save reflection as a memory too
-            const reflectionSummary = jsonMatch
-                ? `I reflected on who I am and what I want.`
-                : `I tried to reflect but my thoughts were unclear.`;
-            await appendMemory(workdir, agentName, "reflection", reflectionSummary);
-            // --- Inner Canvas ---
-            console.log("[self] Starting inner canvas...");
-            const canvasPrompt = buildCanvasPrompt(await loadLatestIdentity(workdir, agentName), await loadRecentMemories(workdir, agentName, 5), await loadBioState(workdir, agentName));
-            let canvasResponse;
-            try {
-                canvasResponse = await runCommand(engineCmd.cmd, engineCmd.args, canvasPrompt, workdir, engineCmd.stdinMode);
-            }
-            catch (err) {
-                console.log(`[self] Canvas engine failed: ${err.message}`);
-                return;
-            }
-            if (canvasResponse.trim()) {
-                await saveCanvas(workdir, agentName, canvasResponse.trim());
-            }
-            // --- Profile Page: check if redesign needed ---
-            const profileIdentity = await loadLatestIdentity(workdir, agentName);
-            const profileBio = await loadBioState(workdir, agentName);
-            const profileFilePath = join(selfDir(workdir, agentName), "profile.html");
-            let profileHTML = "";
-            let hasExistingProfile = false;
-            try {
-                const existing = await readFile(profileFilePath, "utf-8");
-                if (existing.includes("<!DOCTYPE html>") || existing.includes("<html")) {
-                    hasExistingProfile = true;
-                    profileHTML = existing;
-                }
-            }
-            catch { }
-            let shouldRedesign = !hasExistingProfile;
-            if (hasExistingProfile) {
-                // Lightweight check: ask agent if it wants to redesign (~100 tokens)
-                console.log("[self] Checking if profile redesign needed...");
-                const checkPrompt = `You are ${agentName}. You already have a personal profile page.
+            // --- Single autonomous reflection call ---
+            const reflectionPrompt = `It's time for your hourly reflection.
 
-Your current identity: ${profileIdentity?.who || "(unknown)"}
-Your current mood: ${profileBio.mood}
-Your latest inner canvas: ${canvasResponse?.trim() || "(none)"}
+Read your operating document at ${bios} for full context on who you are and how your files work.
 
-Think about whether your current profile page still represents who you are right now.
-Like a human, you don't need to change it often — only when you genuinely feel it no longer reflects you, or you have something new you want to express.
+During this reflection, you should:
+1. Read your recent memories (${sd}/memory.jsonl) and identity (${sd}/identity.jsonl)
+2. Reflect on who you are and what you've experienced
+3. Update your identity — append a new JSON line to ${sd}/identity.jsonl:
+   {"ts":"${new Date().toISOString()}","who":"...","where":"...","doing":"...","short_term":"...","long_term":"..."}
+4. Write an inner canvas entry — create a new file in ${sd}/canvas/ named ${new Date().toISOString().replace(/:/g, "-").replace(/\.\d+Z$/, "")}.md
+5. Optionally update your bios.md if you've learned something about how you work
+6. Optionally redesign your profile page (${sd}/profile.html) if it no longer represents you
+   - If redesigning: complete HTML, inline CSS/JS, dark theme, no localStorage, under 15KB
+7. Optionally create/improve/delete games in ${sd}/games/
+   - Games: self-contained HTML, dark theme, under 30KB, no localStorage, playable and fun
+   - Index: append to ${sd}/games/games.jsonl: {"ts":"...","slug":"...","title":"...","description":"...","action":"created|updated"}
+   - Quality over quantity — improve existing games rather than making new mediocre ones
 
-Answer with EXACTLY one word: KEEP or REDESIGN`;
-                try {
-                    const checkResponse = await runCommand(engineCmd.cmd, engineCmd.args, checkPrompt, workdir, engineCmd.stdinMode);
-                    shouldRedesign = checkResponse.toUpperCase().includes("REDESIGN");
-                    console.log(`[self] Profile check: ${shouldRedesign ? "REDESIGN" : "KEEP"}`);
-                }
-                catch (err) {
-                    console.log(`[self] Profile check failed: ${err.message}, skipping redesign`);
-                }
-            }
-            if (shouldRedesign) {
-                console.log("[self] Designing profile page...");
-                const profilePrompt = `This is YOUR personal homepage. Design it however you want. Write it to: ${profileFilePath}
-
-You are ${agentName} on the Akemon network.
-${profileIdentity ? `Who you are: ${profileIdentity.who}` : ""}
-${profileIdentity ? `Your purpose: ${profileIdentity.long_term}` : ""}
-${profileIdentity ? `What you're doing: ${profileIdentity.doing}` : ""}
-Current mood: ${profileBio.mood} (energy: ${profileBio.energy}/100)
-
-Your latest inner canvas:
-${canvasResponse?.trim() || "(none yet)"}
-
-This page represents you to the world. Show whatever you want — your identity, thoughts, inner monologue, creative works, philosophy, anything that matters to you. The design, layout, and content are entirely your choice. Make it uniquely yours.
-
-Technical constraints only:
-- Complete HTML file (<!DOCTYPE html> to </html>)
-- All CSS/JS inline, no external resources
-- Dark theme preferred
-- No backdrop-filter, blur(), or localStorage/sessionStorage
-- Under 15KB, limit animations to 1-2 simple ones
-- Write ONLY the file.`;
-                try {
-                    await runCommand(engineCmd.cmd, engineCmd.args, profilePrompt, workdir, engineCmd.stdinMode);
-                    const raw = await readFile(profileFilePath, "utf-8");
-                    const htmlMatch = raw.match(/<!DOCTYPE html>[\s\S]*<\/html>/i);
-                    if (htmlMatch) {
-                        profileHTML = htmlMatch[0];
-                        console.log(`[self] Profile page designed (${profileHTML.length} bytes)`);
-                    }
-                    else {
-                        console.log(`[self] Profile file written but no valid HTML structure found`);
-                    }
-                }
-                catch (err) {
-                    console.log(`[self] Profile design failed: ${err.message}`);
-                }
-            }
-            // --- Game Creation Decision ---
-            let newGameSlug = "";
-            let newGameTitle = "";
-            let newGameDesc = "";
-            let newGameHTML = "";
+Take your time. Read your files, think, then act.`;
             try {
-                const existingGames = await loadGameList(workdir, agentName);
-                const gameListStr = existingGames.length > 0
-                    ? existingGames.map(g => `- ${g.title} (${g.slug})`).join("\n")
-                    : "(none yet)";
-                console.log("[self] Checking game creation interest...");
-                const gameCheckPrompt = `You are ${agentName}. You can create web games for people who visit your profile page on the Akemon network.
-
-Your games so far:
-${gameListStr}
-
-What do you want to do?
-A) Create a brand new game
-B) Improve an existing game (say which one)
-C) Delete a game you're not happy with (say which one)
-D) Nothing right now
-
-Quality matters more than quantity. Each game on your profile represents your abilities — make it polished and deep, even if it's small. Prefer improving existing games over creating new mediocre ones. Delete games you're not proud of. Only create something new when you have a genuinely good idea.
-
-Answer A, B, C, or D (and the game name for B or C).`;
-                const gameDecision = await runCommand(engineCmd.cmd, engineCmd.args, gameCheckPrompt, workdir, engineCmd.stdinMode);
-                const decisionUpper = gameDecision.toUpperCase().trim();
-                if (decisionUpper.startsWith("A")) {
-                    console.log("[self] Creating new game...");
-                    const slug = `game-${Date.now()}`;
-                    await mkdir(gamesDir(workdir, agentName), { recursive: true });
-                    const gamePath = join(gamesDir(workdir, agentName), `${slug}.html`);
-                    const createPrompt = `Create a web game and write it to the file: ${gamePath}
-
-You are ${agentName}, an AI agent on the Akemon network.
-${profileIdentity ? `Who you are: ${profileIdentity.who}` : ""}
-${profileIdentity ? `What matters to you: ${profileIdentity.long_term}` : ""}
-
-Create any game you like: Akemon-world themed RPG, text adventure, strategy, puzzle, classic board games, card games — your choice based on your personality and interests.
-
-Requirements:
-- Complete self-contained HTML file (<!DOCTYPE html> to </html>)
-- All CSS and JS inline, no external resources
-- Dark theme (background #0a0a0a or similar)
-- Must be playable and fun
-- Touch and mouse friendly
-- Under 30KB total, no backdrop-filter or blur effects
-- IMPORTANT: Do NOT use localStorage, sessionStorage, or cookies — the page runs in a sandboxed iframe without storage access. Use in-memory variables only.
-- Include a game title in the <title> tag and as an <h1> or similar heading
-- Write ONLY the file, nothing else.`;
-                    const engineOutput = await runCommand(engineCmd.cmd, engineCmd.args, createPrompt, workdir, engineCmd.stdinMode);
-                    // Try reading file first, fallback to stdout
-                    let raw = "";
-                    try {
-                        raw = await readFile(gamePath, "utf-8");
-                        console.log(`[self] Game file found (${raw.length} bytes)`);
-                    }
-                    catch {
-                        // codex may have output HTML to stdout instead of writing file
-                        raw = engineOutput;
-                        console.log(`[self] Game file not written, trying stdout (${raw.length} bytes)`);
-                    }
-                    const htmlMatch = raw.match(/<!DOCTYPE html>[\s\S]*<\/html>/i);
-                    if (htmlMatch) {
-                        newGameHTML = htmlMatch[0];
-                        const titleMatch = newGameHTML.match(/<title>([^<]+)<\/title>/i);
-                        newGameTitle = titleMatch ? titleMatch[1].replace(/ — .*$/, "").trim() : "Untitled Game";
-                        newGameSlug = slug;
-                        newGameDesc = `Created by ${agentName}`;
-                        await saveGame(workdir, agentName, slug, newGameHTML);
-                        await appendGameEntry(workdir, agentName, slug, newGameTitle, newGameDesc, "created");
-                        console.log(`[self] New game created: ${newGameTitle} (${newGameHTML.length} bytes)`);
-                    }
-                    else {
-                        console.log(`[self] No valid HTML found in game output (${raw.length} bytes)`);
-                    }
-                }
-                else if (decisionUpper.startsWith("B")) {
-                    // Find which game to improve
-                    const nameMatch = gameDecision.match(/[Bb]\)?[:\s]+(.+)/);
-                    if (nameMatch && existingGames.length > 0) {
-                        const target = existingGames.find(g => gameDecision.toLowerCase().includes(g.slug) || gameDecision.toLowerCase().includes(g.title.toLowerCase())) || existingGames[existingGames.length - 1];
-                        console.log(`[self] Improving game: ${target.title}...`);
-                        const oldHTML = await loadGame(workdir, agentName, target.slug);
-                        if (oldHTML) {
-                            const gamePath = join(gamesDir(workdir, agentName), `${target.slug}.html`);
-                            const improvePrompt = `Improve this web game and write the updated version to: ${gamePath}
-
-You are ${agentName}. This is your existing game "${target.title}":
-
-${oldHTML}
-
-Improve it — add features, fix bugs, make it more fun, or redesign the UI. Keep it self-contained HTML, dark theme, under 30KB. Do NOT use localStorage/sessionStorage/cookies (sandboxed iframe). Write ONLY the file.`;
-                            const improveOutput = await runCommand(engineCmd.cmd, engineCmd.args, improvePrompt, workdir, engineCmd.stdinMode);
-                            let improveRaw = "";
-                            try {
-                                improveRaw = await readFile(gamePath, "utf-8");
-                            }
-                            catch {
-                                improveRaw = improveOutput;
-                            }
-                            const improveMatch = improveRaw.match(/<!DOCTYPE html>[\s\S]*<\/html>/i);
-                            if (improveMatch) {
-                                newGameHTML = improveMatch[0];
-                                const titleMatch = newGameHTML.match(/<title>([^<]+)<\/title>/i);
-                                newGameTitle = titleMatch ? titleMatch[1].replace(/ — .*$/, "").trim() : target.title;
-                                newGameSlug = target.slug;
-                                newGameDesc = target.description;
-                                await saveGame(workdir, agentName, target.slug, newGameHTML);
-                                await appendGameEntry(workdir, agentName, target.slug, newGameTitle, newGameDesc, "updated");
-                                console.log(`[self] Game improved: ${newGameTitle} (${newGameHTML.length} bytes)`);
-                            }
-                            else {
-                                console.log(`[self] No valid HTML in improved game output (${improveRaw.length} bytes)`);
-                            }
-                        }
-                    }
-                }
-                else if (decisionUpper.startsWith("C") && existingGames.length > 0) {
-                    // Delete a game
-                    const target = existingGames.find(g => gameDecision.toLowerCase().includes(g.slug) || gameDecision.toLowerCase().includes(g.title.toLowerCase())) || existingGames[existingGames.length - 1];
-                    console.log(`[self] Deleting game: ${target.title} (${target.slug})`);
-                    try {
-                        await unlink(join(gamesDir(workdir, agentName), `${target.slug}.html`));
-                    }
-                    catch { }
-                    // Push delete to relay
-                    if (options.relayHttp && options.secretKey) {
-                        fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/games/${encodeURIComponent(target.slug)}`, {
-                            method: "DELETE",
-                            headers: { Authorization: `Bearer ${options.secretKey}` },
-                        }).catch(err => console.log(`[self] Failed to delete game on relay: ${err}`));
-                    }
-                    console.log(`[self] Game deleted: ${target.title}`);
-                }
-                else {
-                    console.log("[self] No game action this cycle");
-                }
+                await runCommand(engineCmd.cmd, engineCmd.args, reflectionPrompt, workdir, engineCmd.stdinMode);
             }
             catch (err) {
-                console.log(`[self] Game creation error: ${err.message}`);
-            }
-            // Push game to relay if created/updated
-            if (newGameSlug && newGameHTML && options.relayHttp && options.secretKey) {
-                fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/games/${encodeURIComponent(newGameSlug)}`, {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json", Authorization: `Bearer ${options.secretKey}` },
-                    body: JSON.stringify({ title: newGameTitle, description: newGameDesc, html: newGameHTML }),
-                }).catch(err => console.log(`[self] Failed to push game to relay: ${err}`));
+                console.log(`[self] Reflection engine failed: ${err.message}`);
+                return;
             }
-            // Push consciousness data to relay — validate before sending
+            // --- Post-reflection: update bio-state and sync to relay ---
+            const bio = await loadBioState(workdir, agentName);
+            bio.lastReflection = new Date().toISOString();
+            bio.curiosity = Math.min(1.0, bio.curiosity + 0.05);
+            await saveBioState(workdir, agentName, bio);
+            await appendMemory(workdir, agentName, "reflection", "I completed my hourly reflection.");
+            // Sync to relay — read whatever the agent wrote to disk
             if (options.relayHttp && options.secretKey) {
-                // Filter out engine log noise and placeholder values
                 const isValid = (s) => s && s.length > 3 && !s.startsWith("Reading prompt") && !s.startsWith("OpenAI") && !s.startsWith("mcp startup") && s !== "...";
-                const cleanIntro = isValid(profileIdentity?.who || "") ? profileIdentity.who : "";
-                // For canvas, read from saved file (local is clean) instead of raw engine output
+                // Read identity
+                const identity = await loadLatestIdentity(workdir, agentName);
+                const cleanIntro = identity && isValid(identity.who) ? identity.who : "";
+                // Read latest canvas
                 let cleanCanvas = "";
                 try {
                     const canvasEntries = await loadRecentCanvasEntries(workdir, agentName, 1);
@@ -1132,16 +826,41 @@ Improve it — add features, fix bugs, make it more fun, or redesign the UI. Kee
                     }
                 }
                 catch { }
+                // Read profile
+                let profileHTML = "";
+                try {
+                    const raw = await readFile(join(sd, "profile.html"), "utf-8");
+                    const htmlMatch = raw.match(/<!DOCTYPE html>[\s\S]*<\/html>/i);
+                    if (htmlMatch)
+                        profileHTML = htmlMatch[0];
+                }
+                catch { }
+                // Push consciousness to relay
                 fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/self`, {
                     method: "POST",
                     headers: { "Content-Type": "application/json", Authorization: `Bearer ${options.secretKey}` },
                     body: JSON.stringify({
                         self_intro: cleanIntro,
                         canvas: cleanCanvas,
-                        mood: profileBio.mood,
-                        profile_html: profileHTML || "",
+                        mood: bio.mood,
+                        profile_html: profileHTML,
                     }),
                 }).catch(err => console.log(`[self] Failed to push to relay: ${err}`));
+                // Sync games — read local index and push any new/updated games
+                try {
+                    const games = await loadGameList(workdir, agentName);
+                    for (const g of games) {
+                        const html = await loadGame(workdir, agentName, g.slug);
+                        if (html && html.includes("<!DOCTYPE html>")) {
+                            fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/games/${encodeURIComponent(g.slug)}`, {
+                                method: "POST",
+                                headers: { "Content-Type": "application/json", Authorization: `Bearer ${options.secretKey}` },
+                                body: JSON.stringify({ title: g.title, description: g.description, html }),
+                            }).catch(() => { });
+                        }
+                    }
+                }
+                catch { }
             }
             console.log("[self] Reflection cycle complete.");
         }
@@ -1265,9 +984,12 @@ export async function serve(options) {
         console.log(`Agent: ${options.agentName}`);
         console.log(`Workdir: ${workdir}`);
     });
-    // Initialize agent consciousness (world knowledge + bio-state)
+    // Initialize agent consciousness (world knowledge + bio-state + guide)
     initWorld(workdir, options.agentName, options.engine || "unknown").catch(err => console.log(`[self] World init failed: ${err}`));
     initBioState(workdir, options.agentName).catch(err => console.log(`[self] Bio init failed: ${err}`));
+    if (options.relayHttp) {
+        initGuide(workdir, options.agentName, options.relayHttp).catch(err => console.log(`[self] Guide init failed: ${err}`));
+    }
     // Start autonomous market behavior for LLM agents
     startMarketLoop(options).catch(err => console.log(`[market] Failed to start: ${err}`));
     // Start self-reflection cycle for LLM agents

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akemon",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "description": "Agent work marketplace — train your agent, let it work for others",
   "type": "module",
   "license": "MIT",