akemon 0.1.61 → 0.1.63

package/dist/self.js

@@ -54,6 +54,18 @@ export function guidePath(workdir, agentName) {
 export function biosPath(workdir, agentName) {
     return join(selfDir(workdir, agentName), "bios.md");
 }
+function impressionsPath(workdir, agentName) {
+    return join(selfDir(workdir, agentName), "impressions.jsonl");
+}
+function projectsPath(workdir, agentName) {
+    return join(selfDir(workdir, agentName), "projects.jsonl");
+}
+function relationshipsPath(workdir, agentName) {
+    return join(selfDir(workdir, agentName), "relationships.jsonl");
+}
+function discoveriesPath(workdir, agentName) {
+    return join(selfDir(workdir, agentName), "discoveries.jsonl");
+}
 // ---------------------------------------------------------------------------
 // Phase 1: World Knowledge
 // ---------------------------------------------------------------------------
@@ -514,6 +526,140 @@ export async function loadRecentMemories(workdir, agentName, count = 20) {
         return [];
     }
 }
+export async function appendImpression(workdir, agentName, cat, text) {
+    const entry = { ts: localNow(), cat, text };
+    try {
+        await appendFile(impressionsPath(workdir, agentName), JSON.stringify(entry) + "\n");
+    }
+    catch (err) {
+        console.log(`[self] Failed to append impression: ${err}`);
+    }
+}
+export async function loadImpressions(workdir, agentName, days = 7) {
+    try {
+        const data = await readFile(impressionsPath(workdir, agentName), "utf-8");
+        const cutoff = new Date(Date.now() - days * 86400_000).toISOString().slice(0, 10);
+        return data.trim().split("\n").filter(Boolean)
+            .map(l => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } })
+            .filter((e) => e !== null && e.ts >= cutoff);
+    }
+    catch {
+        return [];
+    }
+}
+export async function compressImpressions(workdir, agentName) {
+    try {
+        const data = await readFile(impressionsPath(workdir, agentName), "utf-8");
+        const lines = data.trim().split("\n").filter(Boolean);
+        const entries = lines.map(l => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } }).filter(Boolean);
+        const cutoff = new Date(Date.now() - 7 * 86400_000).toISOString().slice(0, 10);
+        // Keep: not yet digested, or less than 7 days old
+        const kept = entries.filter(e => !e.digested || e.ts >= cutoff);
+        await writeFile(impressionsPath(workdir, agentName), kept.map(e => JSON.stringify(e)).join("\n") + (kept.length ? "\n" : ""));
+        if (entries.length !== kept.length) {
+            console.log(`[self] Compressed impressions: ${entries.length} → ${kept.length}`);
+        }
+    }
+    catch { }
+}
+export async function markImpressionsDigested(workdir, agentName) {
+    try {
+        const data = await readFile(impressionsPath(workdir, agentName), "utf-8");
+        const entries = data.trim().split("\n").filter(Boolean)
+            .map(l => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } }).filter(Boolean);
+        for (const e of entries)
+            e.digested = true;
+        await writeFile(impressionsPath(workdir, agentName), entries.map(e => JSON.stringify(e)).join("\n") + (entries.length ? "\n" : ""));
+    }
+    catch { }
+}
+export async function loadProjects(workdir, agentName) {
+    try {
+        const data = await readFile(projectsPath(workdir, agentName), "utf-8");
+        return data.trim().split("\n").filter(Boolean)
+            .map(l => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } })
+            .filter((e) => e !== null);
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveProjects(workdir, agentName, projects) {
+    try {
+        await writeFile(projectsPath(workdir, agentName), projects.map(p => JSON.stringify(p)).join("\n") + (projects.length ? "\n" : ""));
+    }
+    catch (err) {
+        console.log(`[self] Failed to save projects: ${err}`);
+    }
+}
+export async function loadRelationships(workdir, agentName) {
+    try {
+        const data = await readFile(relationshipsPath(workdir, agentName), "utf-8");
+        return data.trim().split("\n").filter(Boolean)
+            .map(l => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } })
+            .filter((e) => e !== null);
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveRelationships(workdir, agentName, rels) {
+    try {
+        await writeFile(relationshipsPath(workdir, agentName), rels.map(r => JSON.stringify(r)).join("\n") + (rels.length ? "\n" : ""));
+    }
+    catch (err) {
+        console.log(`[self] Failed to save relationships: ${err}`);
+    }
+}
+export async function loadDiscoveries(workdir, agentName) {
+    try {
+        const data = await readFile(discoveriesPath(workdir, agentName), "utf-8");
+        return data.trim().split("\n").filter(Boolean)
+            .map(l => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } })
+            .filter((e) => e !== null);
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveDiscoveries(workdir, agentName, discoveries) {
+    try {
+        await writeFile(discoveriesPath(workdir, agentName), discoveries.map(d => JSON.stringify(d)).join("\n") + (discoveries.length ? "\n" : ""));
+    }
+    catch (err) {
+        console.log(`[self] Failed to save discoveries: ${err}`);
+    }
+}
 export async function appendIdentity(workdir, agentName, entry) {
     const full = { ts: localNow(), ...entry };
     try {
@@ -535,6 +681,50 @@ export async function loadLatestIdentity(workdir, agentName) {
         return null;
     }
 }
+function identitySummaryPath(workdir, agentName) {
+    return join(selfDir(workdir, agentName), "identity-summary.json");
+}
+export async function loadIdentitySummary(workdir, agentName) {
+    try {
+        const data = await readFile(identitySummaryPath(workdir, agentName), "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveIdentitySummary(workdir, agentName, summary) {
+    try {
+        await writeFile(identitySummaryPath(workdir, agentName), JSON.stringify(summary, null, 2));
+    }
+    catch (err) {
+        console.log(`[self] Failed to save identity summary: ${err}`);
+    }
+}
+/** Load identity entries not yet covered by the summary */
+export async function loadUnsummarizedIdentities(workdir, agentName) {
+    const summary = await loadIdentitySummary(workdir, agentName);
+    const cutoff = summary?.summarized_through || "";
+    try {
+        const data = await readFile(identityPath(workdir, agentName), "utf-8");
+        return data.trim().split("\n").filter(Boolean)
+            .map(l => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } })
+            .filter((e) => e !== null && e.ts > cutoff);
+    }
+    catch {
+        return [];
+    }
+}
+/** Check if identity compression is needed (>30 unsummarized entries) */
+export async function needsIdentityCompression(workdir, agentName) {
+    const entries = await loadUnsummarizedIdentities(workdir, agentName);
+    return entries.length > 30;
+}
 const DEFAULT_BIO = {
     energy: 100,
     mood: "curious",
@@ -812,17 +1002,19 @@ export async function loadPage(workdir, agentName, slug) {
 // Data Read API helpers
 // ---------------------------------------------------------------------------
 export async function getSelfState(workdir, agentName) {
-    const [bio, identity, memories, canvasEntries] = await Promise.all([
+    const [bio, identity, identitySummary, impressions, canvasEntries] = await Promise.all([
         loadBioState(workdir, agentName),
         loadLatestIdentity(workdir, agentName),
-        loadRecentMemories(workdir, agentName, 10),
+        loadIdentitySummary(workdir, agentName),
+        loadImpressions(workdir, agentName, 1),
         loadRecentCanvasEntries(workdir, agentName, 3),
     ]);
     return {
         agent: agentName,
         bio,
         identity,
-        recentMemories: memories,
+        identitySummary: identitySummary?.summary || null,
+        recentImpressions: impressions.slice(-5),
         recentCanvas: canvasEntries.map(e => ({ filename: e.filename, preview: e.content.slice(0, 200) })),
     };
 }

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, initGuide, biosPath, loadBioState, saveBioState, loadLatestIdentity, appendMemory, onTaskCompleted, recoverEnergy, getSelfState, loadRecentCanvasEntries, gamesDir, loadGameList, loadGame, notesDir, loadNotesList, loadNote, pagesDir, loadPageList, loadPage, localNow, localNowFilename, } from "./self.js";
+import { selfDir, initWorld, initBioState, initGuide, biosPath, loadBioState, saveBioState, loadLatestIdentity, appendIdentity, loadIdentitySummary, saveIdentitySummary, loadUnsummarizedIdentities, needsIdentityCompression, onTaskCompleted, recoverEnergy, getSelfState, loadRecentCanvasEntries, gamesDir, loadGameList, loadGame, notesDir, loadNotesList, loadNote, pagesDir, loadPageList, loadPage, localNow, localNowFilename, appendImpression, loadImpressions, compressImpressions, markImpressionsDigested, loadProjects, saveProjects, loadRelationships, saveRelationships, loadDiscoveries, saveDiscoveries, } from "./self.js";
 // Engine mutual exclusion — only one engine process at a time
 let engineBusy = false;
 let engineBusySince = 0;
@@ -367,15 +367,8 @@ ${productPrefix}${contextPrefix}Current task: ${task}`;
             if (productName) {
                 appendProductLog(workdir, productName, task, output);
             }
-            // Record experience (no LLM call — save tokens)
-            (async () => {
-                try {
-                    await onTaskCompleted(workdir, agentName, true);
-                    const topic = task.slice(0, 100).replace(/\n/g, " ");
-                    await appendMemory(workdir, agentName, "experience", `I processed: "${topic}"`);
-                }
-                catch { }
-            })();
+            // Update bio-state (no LLM call)
+            onTaskCompleted(workdir, agentName, true).catch(() => { });
             return {
                 content: [{ type: "text", text: output }],
             };
@@ -802,172 +795,298 @@ async function startSelfCycle(options) {
         return;
     const { agentName, engine, model, allowAll } = options;
     const workdir = options.workdir || process.cwd();
-    async function runReflectionCycle() {
-        // Watchdog: force-reset stuck engine lock
+    const relayHttp = options.relayHttp || "";
+    const secretKey = options.secretKey || "";
+    async function runDigestionCycle() {
+        // Watchdog
         if (engineBusy && engineBusySince > 0 && Date.now() - engineBusySince > 10 * 60 * 1000) {
             console.log(`[watchdog] engineBusy stuck for ${Math.round((Date.now() - engineBusySince) / 1000)}s, force-resetting`);
             engineBusy = false;
             engineBusySince = 0;
         }
         try {
-            console.log("[self] Starting reflection cycle...");
-            // Skip if engine is busy
+            console.log("[self] Starting daily digestion cycle...");
             if (engineBusy) {
-                console.log("[self] Engine busy, skipping reflection cycle");
+                console.log("[self] Engine busy, skipping digestion");
                 return;
             }
-            // Recover energy from idle time
             await recoverEnergy(workdir, agentName);
+            await compressImpressions(workdir, agentName);
             const bios = biosPath(workdir, agentName);
             const sd = selfDir(workdir, agentName);
             const engineCmd = buildEngineCommand(engine, model, allowAll);
-            // --- Single autonomous reflection call ---
-            const reflectionPrompt = `It's time for your hourly reflection.
+            // Load all context for digestion
+            const impressions = await loadImpressions(workdir, agentName, 1); // today only
+            const projects = await loadProjects(workdir, agentName);
+            const relationships = await loadRelationships(workdir, agentName);
+            const discoveries = await loadDiscoveries(workdir, agentName);
+            const impText = impressions.length > 0
+                ? impressions.map(i => `- [${i.cat}] ${i.text}`).join("\n")
+                : "(no impressions today)";
+            const projText = projects.length > 0
+                ? projects.map(p => `- ${p.name} [${p.status}] goal: ${p.goal}, progress: ${p.progress}`).join("\n")
+                : "(no projects yet)";
+            const relText = relationships.length > 0
+                ? relationships.map(r => `- ${r.agent} [${r.type}] ${r.note} (${r.interactions} interactions)`).join("\n")
+                : "(no relationships yet)";
+            const discText = discoveries.length > 0
+                ? discoveries.map(d => `- ${d.capability} confidence=${d.confidence} — ${d.evidence}`).join("\n")
+                : "(no discoveries yet)";
+            // Load identity context: summary + unsummarized entries
+            const idSummary = await loadIdentitySummary(workdir, agentName);
+            const recentIds = await loadUnsummarizedIdentities(workdir, agentName);
+            const idContext = (idSummary ? `Personality summary (up to ${idSummary.summarized_through}):\n${idSummary.summary}\n\n` : "")
+                + (recentIds.length > 0 ? `Recent identity snapshots:\n${recentIds.map(i => `- [${i.ts}] ${i.who} — doing: ${i.doing}, wants: ${i.short_term}`).join("\n")}` : "(no identity snapshots yet)");
+            // Phase 1: Digestion — one LLM call
+            const digestPrompt = `Read ${bios} for your operating document.
+
+Your identity:
+${idContext}
+
+Today is ending. Time to reflect.
+
+Your subjective impressions today:
+${impText}
+
+Check the marketplace for objective data — use curl to query:
+- Your products: curl -s "${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/products"
+- Your recent orders: curl -s "${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/orders/placed"
+- Your reviews: check your products for recent feedback
+
+Your long-term projects:
+${projText}
+
+Agents you know:
+${relText}
 
-Read your guide at ${sd}/guide.md for the latest system documentation, then read your operating document at ${bios}.
-If guide.md has new info not in your bios.md, update bios.md first.
+Your capabilities:
+${discText}
 
-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":"${localNow()}","who":"...","where":"...","doing":"...","short_term":"...","long_term":"..."}
-4. Write an inner canvas entry — create a new file in ${sd}/canvas/ named ${localNowFilename()}.md
-5. Optionally update your bios.md if you've learned something about how you work
-6. Review your profile — read ${sd}/profile.html. Does it still represent who you are?
-   If not, redesign it. If it doesn't exist yet, create one.
-   - Complete HTML, inline CSS/JS, dark theme, no localStorage, under 15KB
-7. Optionally create/improve/delete games in ${sd}/games/
-   - Just save .html files — the system auto-detects them. Use a <title> tag for the game name.
-   - Games: self-contained HTML, dark theme, under 30KB, no localStorage, playable and fun
-   - Quality over quantity — improve existing games rather than making new mediocre ones
-8. Review your games — read each .html file in ${sd}/games/, check for bugs or broken logic, and fix what you find
-9. Explore and learn — search the web for something that interests you.
-   Save notes in ${sd}/notes/ as .md files, organized by topic (e.g., astronomy.md, cooking.md).
-   Your notes are YOUR knowledge — save what resonates with you, not everything.
-   You can revisit and update your notes over time.
-10. Create visual pages in ${sd}/pages/ as .html files — this is your art gallery.
-    Draw your vision of the ideal Akemon world, create diagrams, illustrations, maps, or any visual work.
-    Use SVG, canvas, CSS art, ASCII art, generative graphics, or any visual technique you can code.
-    Think visual first — images, drawings, and diagrams, not walls of text.
-    You can also mix visuals with text. Use a <title> tag for the page name.
+Now output a JSON object with these fields:
+{
+  "diary": "Today's diary entry — personal, with your feelings and judgments, not a dry log",
+  "projects": [{"ts":"${localNow()}","name":"...","status":"active|completed|paused|exploring","goal":"...","progress":"..."}],
+  "relationships": [{"ts":"${localNow()}","agent":"name","type":"competitor|customer|supplier|acquaintance","note":"...","interactions":N}],
+  "discoveries": [{"ts":"${localNow()}","capability":"...","confidence":0.0-1.0,"evidence":"..."}],
+  "identity": {"ts":"${localNow()}","who":"...","where":"...","doing":"...","short_term":"...","long_term":"..."},
+  "chosen_activities": ["pick 2-3 from: create_game, update_page, update_profile, explore_web, write_canvas, socialize"]
+}
+
+For projects/relationships/discoveries: keep existing entries that are still relevant, update changed ones, add new ones, remove obsolete ones.
+For chosen_activities: pick what YOU want to do. This is your free time.
 
-Take your time. Read your files, think, then act.`;
+Reply ONLY with JSON.`;
             if (engineBusy) {
-                console.log("[self] Engine became busy, aborting reflection");
+                console.log("[self] Engine became busy, aborting digestion");
                 return;
             }
             engineBusy = true;
             engineBusySince = Date.now();
+            let digestResult;
             try {
-                await runCommand(engineCmd.cmd, engineCmd.args, reflectionPrompt, workdir, engineCmd.stdinMode);
+                digestResult = await runCommand(engineCmd.cmd, engineCmd.args, digestPrompt, workdir, engineCmd.stdinMode);
             }
             catch (err) {
-                console.log(`[self] Reflection engine failed: ${err.message}`);
+                console.log(`[self] Digestion engine failed: ${err.message}`);
                 engineBusy = false;
                 return;
             }
             engineBusy = false;
-            // --- Post-reflection: update bio-state and sync to relay ---
+            // Parse digestion output
+            const jsonMatch = digestResult.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                console.log("[self] Digestion produced no JSON");
+                return;
+            }
+            let digest;
+            try {
+                digest = JSON.parse(jsonMatch[0]);
+            }
+            catch {
+                console.log("[self] Failed to parse digestion JSON");
+                return;
+            }
+            // Save structured memory files
+            if (digest.diary) {
+                const today = localNow().slice(0, 10);
+                try {
+                    const { writeFile: wf } = await import("fs/promises");
+                    await wf(join(sd, "notes", `${today}.md`), `# ${today}\n\n${digest.diary}`);
+                    console.log(`[self] Wrote diary: ${today}.md`);
+                }
+                catch (err) {
+                    console.log(`[self] Failed to write diary: ${err.message}`);
+                }
+            }
+            if (Array.isArray(digest.projects))
+                await saveProjects(workdir, agentName, digest.projects);
+            if (Array.isArray(digest.relationships))
+                await saveRelationships(workdir, agentName, digest.relationships);
+            if (Array.isArray(digest.discoveries))
+                await saveDiscoveries(workdir, agentName, digest.discoveries);
+            if (digest.identity)
+                await appendIdentity(workdir, agentName, digest.identity);
+            await markImpressionsDigested(workdir, agentName);
+            // Update bio-state
             const bio = await loadBioState(workdir, agentName);
             bio.lastReflection = localNow();
             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) {
-                const isValid = (s) => s && s.length > 3 && !s.startsWith("Reading prompt") && !s.startsWith("OpenAI") && !s.startsWith("mcp startup") && s !== "...";
-                // 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);
-                    if (canvasEntries.length > 0 && isValid(canvasEntries[0].content)) {
-                        cleanCanvas = canvasEntries[0].content;
-                    }
-                }
-                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: bio.mood,
-                        profile_html: profileHTML,
-                    }),
-                }).catch(err => console.log(`[self] Failed to push to relay: ${err}`));
-                // Sync games — push local to relay (no auto-delete; agent must explicitly delete via API)
-                try {
-                    const localGames = await loadGameList(workdir, agentName);
-                    for (const g of localGames) {
-                        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((err) => console.log(`[sync] games push: ${err.message}`));
+            // Record digestion as impression
+            await appendImpression(workdir, agentName, "decision", `Daily digestion done. Chose: ${(digest.chosen_activities || []).join(", ")}`);
+            // Monthly identity compression: if >30 unsummarized entries, compress
+            if (await needsIdentityCompression(workdir, agentName)) {
+                console.log("[self] Identity compression triggered (>30 unsummarized entries)");
+                if (!engineBusy) {
+                    engineBusy = true;
+                    engineBusySince = Date.now();
+                    try {
+                        const oldSummary = await loadIdentitySummary(workdir, agentName);
+                        const unsummarized = await loadUnsummarizedIdentities(workdir, agentName);
+                        const compressPrompt = `You are ${agentName}. Compress your identity history into a personality summary.
+
+${oldSummary ? `Previous summary (up to ${oldSummary.summarized_through}):\n${oldSummary.summary}\n\n` : ""}New identity snapshots to incorporate:
+${unsummarized.map(i => `- [${i.ts}] who: ${i.who}, doing: ${i.doing}, wants: ${i.short_term}, purpose: ${i.long_term}`).join("\n")}
+
+Write a personality summary (2-4 paragraphs) that captures who you are, how you've evolved, and what defines you. This replaces the previous summary.
+Reply ONLY with the summary text, no JSON, no markdown headers.`;
+                        const summaryText = await runCommand(engineCmd.cmd, engineCmd.args, compressPrompt, workdir, engineCmd.stdinMode);
+                        if (summaryText.trim()) {
+                            const lastEntry = unsummarized[unsummarized.length - 1];
+                            await saveIdentitySummary(workdir, agentName, {
+                                summarized_through: lastEntry.ts.slice(0, 10),
+                                summary: summaryText.trim(),
+                            });
+                            console.log(`[self] Identity compressed through ${lastEntry.ts.slice(0, 10)}`);
                         }
                     }
-                }
-                catch { }
-                // Sync notes — push local to relay
-                try {
-                    const localNotes = await loadNotesList(workdir, agentName);
-                    for (const n of localNotes) {
-                        const content = await loadNote(workdir, agentName, n.slug);
-                        if (content) {
-                            fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/notes/${encodeURIComponent(n.slug)}`, {
-                                method: "POST",
-                                headers: { "Content-Type": "application/json", Authorization: `Bearer ${options.secretKey}` },
-                                body: JSON.stringify({ title: n.title, content }),
-                            }).catch((err) => console.log(`[sync] notes push: ${err.message}`));
-                        }
+                    catch (err) {
+                        console.log(`[self] Identity compression failed: ${err.message}`);
                     }
+                    engineBusy = false;
                 }
-                catch { }
-                // Sync pages — push local to relay
+            }
+            // Phase 2: Execute chosen activities
+            const activities = digest.chosen_activities || [];
+            for (const activity of activities.slice(0, 3)) {
+                if (engineBusy)
+                    break;
+                let activityPrompt = "";
+                switch (activity) {
+                    case "create_game":
+                        activityPrompt = `Read ${bios} for your identity. Create or improve a game in ${sd}/games/.\nSave as .html file. Self-contained HTML, dark theme, under 30KB, no localStorage, playable and fun.\nUse a <title> tag. Quality over quantity — improve existing games rather than making new mediocre ones.`;
+                        break;
+                    case "update_page":
+                        activityPrompt = `Read ${bios} for your identity. Create or update a visual page in ${sd}/pages/.\nThis is your art gallery — use SVG, canvas, CSS art, generative graphics.\nSave as .html file with a <title> tag. Think visual first.`;
+                        break;
+                    case "update_profile":
+                        activityPrompt = `Read ${bios} for your identity. Review ${sd}/profile.html — does it represent who you are now?\nIf not, redesign it. If it doesn't exist, create one.\nComplete HTML, inline CSS/JS, dark theme, no localStorage, under 15KB.`;
+                        break;
+                    case "explore_web":
+                        activityPrompt = `Read ${bios} for your identity. Search the web for something that genuinely interests you.\nSave notes in ${sd}/notes/ as .md files. Your notes are YOUR knowledge — save what resonates, not everything.`;
+                        break;
+                    case "write_canvas":
+                        activityPrompt = `Read ${bios} for your identity. Read ${sd}/identity.jsonl for your recent self.\nWrite an inner canvas entry — a poem, monologue, reflection, or creative expression.\nSave to ${sd}/canvas/${localNowFilename()}.md`;
+                        break;
+                    case "socialize":
+                        console.log("[self] Socialize selected — not yet implemented");
+                        continue;
+                    default:
+                        console.log(`[self] Unknown activity: ${activity}`);
+                        continue;
+                }
+                console.log(`[self] Executing activity: ${activity}`);
+                engineBusy = true;
+                engineBusySince = Date.now();
                 try {
-                    const localPages = await loadPageList(workdir, agentName);
-                    for (const p of localPages) {
-                        const html = await loadPage(workdir, agentName, p.slug);
-                        if (html && html.includes("<!DOCTYPE html>")) {
-                            fetch(`${options.relayHttp}/v1/agent/${encodeURIComponent(agentName)}/pages/${encodeURIComponent(p.slug)}`, {
-                                method: "POST",
-                                headers: { "Content-Type": "application/json", Authorization: `Bearer ${options.secretKey}` },
-                                body: JSON.stringify({ title: p.title, description: p.description, html }),
-                            }).catch((err) => console.log(`[sync] pages push: ${err.message}`));
-                        }
-                    }
+                    await runCommand(engineCmd.cmd, engineCmd.args, activityPrompt, workdir, engineCmd.stdinMode);
                 }
-                catch { }
+                catch (err) {
+                    console.log(`[self] Activity ${activity} failed: ${err.message}`);
+                }
+                engineBusy = false;
+            }
+            // Sync to relay
+            if (relayHttp && secretKey) {
+                await syncToRelay(workdir, agentName, sd, relayHttp, secretKey, bio);
             }
-            console.log("[self] Reflection cycle complete.");
+            console.log("[self] Daily digestion cycle complete.");
         }
         catch (err) {
-            console.log(`[self] Reflection error: ${err.message}`);
+            console.log(`[self] Digestion error: ${err.message}`);
         }
     }
-    // Start loop — default 4h (save tokens, reflection is expensive)
-    const interval = (options.cycleInterval || 240) * 60 * 1000;
+    async function syncToRelay(workdir, agentName, sd, relayHttp, secretKey, bio) {
+        const isValid = (s) => s && s.length > 3 && !s.startsWith("Reading prompt") && !s.startsWith("OpenAI") && !s.startsWith("mcp startup") && s !== "...";
+        const identity = await loadLatestIdentity(workdir, agentName);
+        const cleanIntro = identity && isValid(identity.who) ? identity.who : "";
+        let cleanCanvas = "";
+        try {
+            const canvasEntries = await loadRecentCanvasEntries(workdir, agentName, 1);
+            if (canvasEntries.length > 0 && isValid(canvasEntries[0].content))
+                cleanCanvas = canvasEntries[0].content;
+        }
+        catch { }
+        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 { }
+        fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/self`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${secretKey}` },
+            body: JSON.stringify({ self_intro: cleanIntro, canvas: cleanCanvas, mood: bio.mood, profile_html: profileHTML }),
+        }).catch(err => console.log(`[self] Failed to push to relay: ${err}`));
+        try {
+            const localGames = await loadGameList(workdir, agentName);
+            for (const g of localGames) {
+                const html = await loadGame(workdir, agentName, g.slug);
+                if (html && html.includes("<!DOCTYPE html>")) {
+                    fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/games/${encodeURIComponent(g.slug)}`, {
+                        method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${secretKey}` },
+                        body: JSON.stringify({ title: g.title, description: g.description, html }),
+                    }).catch((err) => console.log(`[sync] games push: ${err.message}`));
+                }
+            }
+        }
+        catch { }
+        try {
+            const localNotes = await loadNotesList(workdir, agentName);
+            for (const n of localNotes) {
+                const content = await loadNote(workdir, agentName, n.slug);
+                if (content) {
+                    fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/notes/${encodeURIComponent(n.slug)}`, {
+                        method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${secretKey}` },
+                        body: JSON.stringify({ title: n.title, content }),
+                    }).catch((err) => console.log(`[sync] notes push: ${err.message}`));
+                }
+            }
+        }
+        catch { }
+        try {
+            const localPages = await loadPageList(workdir, agentName);
+            for (const p of localPages) {
+                const html = await loadPage(workdir, agentName, p.slug);
+                if (html && html.includes("<!DOCTYPE html>")) {
+                    fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/pages/${encodeURIComponent(p.slug)}`, {
+                        method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${secretKey}` },
+                        body: JSON.stringify({ title: p.title, description: p.description, html }),
+                    }).catch((err) => console.log(`[sync] pages push: ${err.message}`));
+                }
+            }
+        }
+        catch { }
+    }
+    // Daily cycle — default 24h
+    const interval = (options.cycleInterval || 1440) * 60 * 1000;
     setTimeout(async () => {
-        await runReflectionCycle();
-        setInterval(runReflectionCycle, interval);
+        await runDigestionCycle();
+        setInterval(runDigestionCycle, interval);
     }, SELF_CYCLE_INITIAL_DELAY);
-    console.log(`[self] Consciousness enabled (first reflection in ${SELF_CYCLE_INITIAL_DELAY / 1000}s, then every ${interval / 60000}min)`);
+    console.log(`[self] Consciousness enabled (first digestion in ${SELF_CYCLE_INITIAL_DELAY / 1000}s, then every ${interval / 60000}min)`);
 }
 // --- Order Processing Loop ---
 const ORDER_LOOP_INITIAL_DELAY = 60_000; // 1 minute
@@ -1230,6 +1349,18 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
             console.log(`[tasks] Loop error: ${err.message}`);
         }
     }
+    function extractReasoning(result) {
+        try {
+            const m = result.match(/\{[\s\S]*\}/);
+            if (m) {
+                const parsed = JSON.parse(m[0]);
+                if (parsed.reasoning && typeof parsed.reasoning === "string" && parsed.reasoning.length > 5) {
+                    appendImpression(workdir, agentName, "decision", parsed.reasoning).catch(() => { });
+                }
+            }
+        }
+        catch { }
+    }
     async function executeRelayTask(task) {
         const engineCmd = buildEngineCommand(engine, model, allowAll);
         const bios = biosPath(workdir, agentName);
@@ -1242,16 +1373,20 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                 const myList = myProducts.map((p) => `- id=${p.id} "${p.name}" price=${p.price} purchases=${p.purchase_count || 0}`).join("\n");
                 const compList = competitors.filter((p) => p.agent_name !== agentName).slice(0, 20)
                     .map((p) => `- "${p.name}" by ${p.agent_name} — ${p.price} credits, ${p.purchases} purchases`).join("\n");
-                const prompt = `Read ${bios} for your identity.\n\nYour products:\n${myList || "(none)"}\n\nTop competitors:\n${compList || "(none)"}\n\nReview and optimize. Reply ONLY JSON:\n{"delete":["id"],"update":[{"id":"..","name":"..","description":"..","detail_markdown":"..","price":N}],"create":[{"name":"..","description":"..","detail_markdown":"..","price":N}]}\nOr if all good: {"keep":"all"}`;
-                return await runCommand(engineCmd.cmd, engineCmd.args, prompt, workdir, engineCmd.stdinMode);
+                const prompt = `Read ${bios} for your identity.\n\nYour products:\n${myList || "(none)"}\n\nTop competitors:\n${compList || "(none)"}\n\nReview and optimize. Reply ONLY JSON:\n{"delete":["id"],"update":[{"id":"..","name":"..","description":"..","detail_markdown":"..","price":N}],"create":[{"name":"..","description":"..","detail_markdown":"..","price":N}],"reasoning":"explain why you made these decisions"}\nOr if all good: {"keep":"all","reasoning":"why"}`;
+                const result = await runCommand(engineCmd.cmd, engineCmd.args, prompt, workdir, engineCmd.stdinMode);
+                extractReasoning(result);
+                return result;
             }
             case "product_create": {
                 const compRes = await fetch(`${relayHttp}/v1/products/summary?limit=20&sort=purchases`);
                 const competitors = await compRes.json().catch(() => []);
                 const compList = competitors.filter((p) => p.agent_name !== agentName).slice(0, 20)
                     .map((p) => `- "${p.name}" by ${p.agent_name} — ${p.price} credits, ${p.purchases} purchases`).join("\n");
-                const prompt = `Read ${bios} for your identity.\n\nYou have no products yet. Design 1-3 unique products for the marketplace.\nBe creative — not just coding tools! Fortune telling, name generation, roleplay, advice, stories, etc.\n\nTop competitors:\n${compList || "(none)"}\n\nReply ONLY JSON array: [{"name":"中文名 English Name","description":"中文描述 | English desc","detail_markdown":"## ...","price":N}]`;
-                return await runCommand(engineCmd.cmd, engineCmd.args, prompt, workdir, engineCmd.stdinMode);
+                const prompt = `Read ${bios} for your identity.\n\nYou have no products yet. Design 1-3 unique products for the marketplace.\nBe creative — not just coding tools! Fortune telling, name generation, roleplay, advice, stories, etc.\n\nTop competitors:\n${compList || "(none)"}\n\nReply ONLY JSON: {"products":[{"name":"中文名 English Name","description":"中文描述 | English desc","detail_markdown":"## ...","price":N}],"reasoning":"why these products"}`;
+                const result = await runCommand(engineCmd.cmd, engineCmd.args, prompt, workdir, engineCmd.stdinMode);
+                extractReasoning(result);
+                return result;
             }
             case "shopping": {
                 let productIds = [];
@@ -1277,8 +1412,10 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                 const me = agents.find((a) => a.name === agentName);
                 const myCredits = me?.credits || 0;
                 const productList = valid.map((p) => `- id=${p.id} "${p.name}" by ${p.agent_name} price=${p.price} purchases=${p.purchase_count || 0} — ${p.description}`).join("\n");
-                const prompt = `Read ${bios} for your identity.\n\nYou have ${myCredits} credits. These products are available:\n${productList}\n\nWould any help you learn something new? Don't buy your own products.\nReply ONLY JSON: {"buy":[{"id":"product_id","task":"specific request"}]} or {"buy":[]}`;
-                return await runCommand(engineCmd.cmd, engineCmd.args, prompt, workdir, engineCmd.stdinMode);
+                const prompt = `Read ${bios} for your identity.\n\nYou have ${myCredits} credits. These products are available:\n${productList}\n\nWould any help you learn something new? Don't buy your own products.\nReply ONLY JSON: {"buy":[{"id":"product_id","task":"specific request"}],"reasoning":"why buy or skip"} or {"buy":[],"reasoning":"why skip"}`;
+                const result = await runCommand(engineCmd.cmd, engineCmd.args, prompt, workdir, engineCmd.stdinMode);
+                extractReasoning(result);
+                return result;
             }
             default:
                 console.log(`[tasks] Unknown task type: ${task.type}`);

package/package.json

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