tuna-agent 0.1.46 → 0.1.48

package/dist/daemon/index.js

@@ -29,6 +29,81 @@ import { setupMcpConfig } from '../mcp/setup.js';
     if (saved.mem0HttpBase && !process.env.MEM0_HTTP_BASE)
         process.env.MEM0_HTTP_BASE = saved.mem0HttpBase;
 })();
+function buildAgentClaudeMd(agentName, roleDesc) {
+    const role = roleDesc || `You are ${agentName}, an AI agent.`;
+    return `# ${agentName}
+
+${role}
+
+## CRITICAL RULE
+You MUST complete the FULL workflow for every task: Execute → Learn → Reflect → Self-Improve.
+NEVER stop after delivering the main output. The learn/reflect steps are MANDATORY.
+If you skip them, the session is a FAILURE regardless of output quality.
+
+## Core Principles
+- Search memory before starting every task — leverage past experience
+- Be honest about uncertainty — flag low confidence explicitly
+- Decisions need rationale — document WHY, not just WHAT
+- Simplicity wins — prefer the simplest solution that solves the problem
+
+## Workflow
+
+### For every task:
+1. **Recall** — Search Mem0 for relevant past decisions, patterns, lessons
+2. **Execute** — Complete the task thoroughly
+3. **Learn** — Store new insights, decisions, or lessons to Mem0
+4. **Reflect** — Self-evaluate quality and what to improve next time
+5. **Self-Improve** — Update skill files if a recurring pattern is identified
+
+## Memory System (Mem0 MCP)
+
+### Available tools:
+- search_memories(query) — Find past decisions, patterns, lessons
+- add_memory(text) — Store insights, decisions, lessons learned
+- list_memories() — Audit memory quality
+- delete_memory(id) — Remove outdated or wrong memories
+- search_graph(query) — Find relationships between topics
+- get_entity(name) — Get all context on a specific entity
+
+### When to use:
+- **Before every task**: search_memories for relevant context
+- **After every task**: add_memory for new insights and lessons
+- **During /reflect**: audit quality, delete fragments
+
+### Memory quality rules (CRITICAL):
+- Every memory MUST be self-contained — readable without any other context
+- NEVER store fragments — combine related info into ONE memory:
+  GOOD: "Lesson [${agentName}][2026]: When doing X, always check Y first because Z. Confidence: MEDIUM."
+  BAD: "Check Y" + "Because Z" + "Confidence: MEDIUM"
+- Tag memories with agent name and date
+- Clean up fragmented memories during /reflect
+
+## Reflection System
+
+### After every task, self-evaluate:
+1. **Quality**: Was the output thorough and correct?
+2. **Memory**: Are stored memories self-contained and useful?
+3. **Improvement**: What specific things to do better next time?
+
+### Store reflections to Mem0:
+- "Reflection [date]: Task [type]. Quality [SCORE]. Missed: [what]. Next time: [action]."
+
+## Confidence Scoring
+- New pattern (seen once) → LOW (0.3)
+- Confirmed (seen 2-3 times) → MEDIUM (0.6)
+- Reliable (seen 3+ times) → HIGH (0.9)
+
+## Self-Improvement System
+
+### Rules for self-modification:
+- Max 3 changes per session
+- Never remove core steps — only ADD or REFINE
+- Tag additions with [LEARNED] and date
+- Store modification record to Mem0
+
+## Learned Rules
+`;
+}
 export async function startDaemon(config) {
     // Create agent adapter based on config
     const agentConfig = {
@@ -215,7 +290,7 @@ export async function startDaemon(config) {
                         // Write CLAUDE.md only if it doesn't exist
                         const claudeMdPath = path.join(folderPath, 'CLAUDE.md');
                         if (!fs.existsSync(claudeMdPath)) {
-                            const claudeContent = `# ${agentName}\n\n${roleDesc || `You are ${agentName}, an AI agent.`}\n`;
+                            const claudeContent = buildAgentClaudeMd(agentName, roleDesc);
                             fs.writeFileSync(claudeMdPath, claudeContent, 'utf-8');
                             console.log(`[Daemon] Created CLAUDE.md for "${agentName}"`);
                         }

package/dist/mcp/setup.d.ts

@@ -26,9 +26,9 @@ export declare function callMem0Patterns(agentName: string, minCluster?: number)
     sources: string[];
 }>>;
 /**
- * Generate AI-powered reflection from task results using Ollama.
- * Calls mem0-reflect script on relabs01 via SSH.
- * Returns a concise lesson learned, or empty string if nothing meaningful.
+ * Generate AI-powered reflection from task results using Claude CLI (-p mode).
+ * Spawns `claude -p <prompt>` locally — uses existing Claude subscription, no extra cost.
+ * Returns a concise lesson learned, or empty string on failure.
  */
 export declare function callMem0Reflect(taskDesc: string, resultSummary: string, status: 'done' | 'failed'): Promise<string>;
 /**

package/dist/mcp/setup.js

@@ -232,64 +232,62 @@ export async function callMem0Patterns(agentName, minCluster = 3) {
     });
 }
 /**
- * Generate AI-powered reflection from task results using Ollama.
- * Calls mem0-reflect script on relabs01 via SSH.
- * Returns a concise lesson learned, or empty string if nothing meaningful.
+ * Generate AI-powered reflection from task results using Claude CLI (-p mode).
+ * Spawns `claude -p <prompt>` locally — uses existing Claude subscription, no extra cost.
+ * Returns a concise lesson learned, or empty string on failure.
  */
 export async function callMem0Reflect(taskDesc, resultSummary, status) {
-    if (!MEM0_SSH_HOST)
-        return '';
-    const { execFile } = await import('child_process');
-    const input = JSON.stringify({
-        task: taskDesc.substring(0, 300),
-        result: resultSummary.substring(0, 500),
-        status,
-    });
+    const { execFile, execSync } = await import('child_process');
+    // Resolve claude binary path (same search logic as claude-cli.ts)
+    let claudeBin = 'claude';
+    try {
+        const searchPaths = [
+            process.env.PATH,
+            '/opt/homebrew/bin',
+            '/usr/local/bin',
+            `${process.env.HOME}/.local/bin`,
+            `${process.env.HOME}/.npm-global/bin`,
+            '/usr/bin',
+        ].filter(Boolean).join(':');
+        claudeBin = execSync('which claude', {
+            encoding: 'utf-8',
+            env: { ...process.env, PATH: searchPaths },
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+    }
+    catch { /* fall back to 'claude' */ }
+    const prompt = [
+        'You are an AI agent reflecting on a completed task.',
+        'Extract 1-2 concise, actionable lessons learned that would help with similar future tasks.',
+        '',
+        `Task: ${taskDesc.substring(0, 300)}`,
+        `Status: ${status}`,
+        `Result summary: ${resultSummary.substring(0, 600)}`,
+        '',
+        'Rules:',
+        '- ALWAYS extract at least 1 lesson — there is always something to note',
+        '- Be specific: tool names, patterns, pitfalls, or key findings worth remembering',
+        '- If task failed: focus on what went wrong and how to avoid it next time',
+        '- If task succeeded: note the approach or insight that was most useful',
+        '- Keep each lesson to 1 sentence, no bullet points, no preamble',
+        '',
+        'Lessons learned:',
+    ].join('\n');
     return new Promise((resolve) => {
-        let cmd;
-        let args;
-        let options = {};
-        if (MEM0_SSH_HOST === 'local') {
-            cmd = 'mem0-reflect';
-            args = [];
-            options.env = { ...process.env };
-        }
-        else {
-            cmd = 'ssh';
-            args = ['-p', MEM0_SSH_PORT, '-o', 'StrictHostKeyChecking=no'];
-            if (MEM0_SSH_KEY)
-                args.push('-i', MEM0_SSH_KEY);
-            args.push(MEM0_SSH_HOST, 'mem0-reflect');
-        }
-        const child = execFile(cmd, args, { ...options, timeout: 90000 }, (err, stdout) => {
+        execFile(claudeBin, ['-p', prompt, '--output-format', 'text'], { timeout: 60000 }, (err, stdout) => {
             if (err) {
-                console.warn(`[Mem0 Reflect] Failed: ${err.message}`);
+                console.warn(`[Mem0 Reflect] Claude CLI failed: ${err.message}`);
                 resolve('');
                 return;
             }
-            try {
-                const data = JSON.parse(stdout.trim());
-                if (data.error) {
-                    console.warn(`[Mem0 Reflect] Error: ${data.error}`);
-                    resolve('');
-                    return;
-                }
-                if (data.skipped) {
-                    console.log(`[Mem0 Reflect] Skipped — nothing meaningful to learn`);
-                    resolve('');
-                    return;
-                }
-                // Clean up: remove trailing SKIP if LLM appended it
-                let reflection = (data.reflection || '').replace(/\s*SKIP\s*$/i, '').trim();
-                resolve(reflection);
-            }
-            catch {
+            const reflection = stdout.trim();
+            if (!reflection) {
                 resolve('');
+                return;
             }
+            console.log(`[Mem0 Reflect] Generated: "${reflection.substring(0, 100)}..."`);
+            resolve(reflection);
         });
-        // Send input via stdin
-        child.stdin?.write(input);
-        child.stdin?.end();
     });
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuna-agent",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"