akemon 0.1.62 → 0.1.64

package/dist/cli.js

@@ -35,7 +35,7 @@ program
     .option("--allow-all", "Skip all permission prompts (for self-use)")
     .option("--price <n>", "Price in credits per call (default: 1)", "1")
     .option("--mcp-server <command>", "Wrap a community MCP server (stdio) and expose its tools via relay")
-    .option("--interval <minutes>", "Reflection & market cycle interval in minutes (default: 60)", "60")
+    .option("--interval <minutes>", "Consciousness cycle interval in minutes (default: 1440 = 24h)")
     .option("--relay <url>", "Relay WebSocket URL", RELAY_WS)
     .action(async (opts) => {
     const port = parseInt(opts.port);

package/dist/self.js

@@ -681,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",
@@ -958,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, appendIdentity, 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";
+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 }],
             };
@@ -839,8 +832,16 @@ async function startSelfCycle(options) {
             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 identity. Read ${sd}/identity.jsonl for your recent identity snapshots.
+            const digestPrompt = `Read ${bios} for your operating document.
+
+Your identity:
+${idContext}
 
 Today is ending. Time to reflect.
 
@@ -931,7 +932,40 @@ Reply ONLY with JSON.`;
             bio.lastReflection = localNow();
             bio.curiosity = Math.min(1.0, bio.curiosity + 0.05);
             await saveBioState(workdir, agentName, bio);
-            await appendMemory(workdir, agentName, "reflection", `Daily digestion complete. Chose: ${(digest.chosen_activities || []).join(", ")}`);
+            // 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 (err) {
+                        console.log(`[self] Identity compression failed: ${err.message}`);
+                    }
+                    engineBusy = false;
+                }
+            }
             // Phase 2: Execute chosen activities
             const activities = digest.chosen_activities || [];
             for (const activity of activities.slice(0, 3)) {

package/package.json

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