tuna-agent 0.1.181 → 0.1.182

package/dist/agents/claude-code-adapter.d.ts

@@ -57,7 +57,7 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
      * Run post-task self-reflection via Mem0.
      * Agent reviews what it did and stores lessons learned.
      */
-    runReflection(task: TaskAssignment, resultSummary: string, status: 'done' | 'failed', cwd: string): Promise<void>;
+    runReflection(task: TaskAssignment, resultSummary: string, status: 'done' | 'failed', cwd: string, conversation?: string[]): Promise<void>;
     /**
      * Store user rating feedback into Mem0.
      */

package/dist/agents/claude-code-adapter.js

@@ -181,6 +181,7 @@ export class ClaudeCodeAdapter {
                 }
             }
             let lastTaskOutput = ''; // Track last output for reflection
+            const convo = []; // User/Agent transcript → conversation memory (Mem0)
             try {
                 for (let round = 0; round < MAX_ROUNDS; round++) {
                     let streamMsgId = `team-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
@@ -204,6 +205,7 @@ export class ClaudeCodeAdapter {
                         return false;
                     };
                     console.log(`[ClaudeCode] Agent Team round ${round + 1}: ${userMessage.substring(0, 80)}${currentInputFiles?.length ? ` (+${currentInputFiles.length} images)` : ''}`);
+                    convo.push(`User: ${userMessage}`);
                     const defaultWorkspace = path.join(os.homedir(), 'tuna-workspace');
                     const cwd = task.repoPath || defaultWorkspace;
                     if (!fs.existsSync(cwd))
@@ -346,6 +348,8 @@ export class ClaudeCodeAdapter {
                     }
                     // Track last output for reflection (fallback to result.result if no streaming text)
                     lastTaskOutput = turnAccumulatedText.trim() || result.result;
+                    if (lastTaskOutput)
+                        convo.push(`Agent: ${lastTaskOutput}`);
                     if (lastTaskOutput) {
                         console.log(`[Reflection] Captured ${lastTaskOutput.length} chars of task output for reflection`);
                     }
@@ -415,7 +419,7 @@ export class ClaudeCodeAdapter {
                             });
                             this.trackMetrics('done', totalDurationMs, localAgentId);
                             const timeoutOutput = lastTaskOutput || 'Task completed (no follow-up)';
-                            this.runReflection(task, timeoutOutput, 'done', task.repoPath)
+                            this.runReflection(task, timeoutOutput, 'done', task.repoPath, convo)
                                 .then(() => this.runSelfImprovement(task.repoPath, localAgentId))
                                 .catch(() => { });
                             return;
@@ -448,7 +452,7 @@ export class ClaudeCodeAdapter {
                 this.trackMetrics('done', totalDurationMs, localAgentId);
                 console.log(`[ClaudeCode] Agent Team task ${task.id} completed (${(totalDurationMs / 1000).toFixed(1)}s)`);
                 // Post-task reflection with actual output (non-blocking)
-                this.runReflection(task, lastTaskOutput || 'Task completed without text output', 'done', task.repoPath)
+                this.runReflection(task, lastTaskOutput || 'Task completed without text output', 'done', task.repoPath, convo)
                     .then(() => this.runSelfImprovement(task.repoPath, localAgentId))
                     .catch(() => { });
             }
@@ -810,7 +814,7 @@ export class ClaudeCodeAdapter {
      * Run post-task self-reflection via Mem0.
      * Agent reviews what it did and stores lessons learned.
      */
-    async runReflection(task, resultSummary, status, cwd) {
+    async runReflection(task, resultSummary, status, cwd, conversation) {
         if (task.enableReflection === false)
             return;
         if (!process.env.MEM0_SSH_HOST)
@@ -820,6 +824,16 @@ export class ClaudeCodeAdapter {
             return;
         const agentName = path.basename(cwd);
         const agentId = task.agentId || '';
+        // Conversation memory: distill what was DISCUSSED (topics, decisions, user
+        // preferences) into Mem0 — independent of the lesson reflection below, so the
+        // agent remembers past conversations without manually writing .md notes.
+        if (conversation && conversation.length >= 2) {
+            import('../mcp/setup.js')
+                .then(({ storeConversationFacts }) => storeConversationFacts(conversation, agentName))
+                .then((n) => { if (n)
+                this.getMetricsForAgent(agentId).memoryCount += n; })
+                .catch(() => { });
+        }
         // Record a quality score for this task — the signal the self-improvement loop
         // optimizes against (closes the loop: score in -> trend gates rule changes out).
         const runScore = ClaudeCodeAdapter.deriveScore(status, resultSummary);

package/dist/daemon/index.js

@@ -745,6 +745,7 @@ ${skillContent.slice(0, 15000)}`;
         taskAbortControllers.set(taskId, abort);
         let pmSessionId = pmState.pmSessionId;
         const MAX_RESUMED_ROUNDS = 50;
+        const convo = []; // User/Agent transcript → conversation memory (Mem0)
         try {
             let userMessage = firstMessage;
             let currentAttachments = firstAttachments;
@@ -761,6 +762,7 @@ ${skillContent.slice(0, 15000)}`;
                     }
                 }
                 console.log(`[Daemon] Resumed PM chat round ${round + 1}: ${userMessage.substring(0, 80)}${inputFiles?.length ? ` (+${inputFiles.length} images)` : ''}`);
+                convo.push(`User: ${userMessage}`);
                 const streamMsgId = `pm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
                 let firstChunkIso = '';
                 const chatResult = await chatWithPM(pmSessionId, pmState.repoPath, userMessage, abort.signal, (chunk) => {
@@ -774,6 +776,7 @@ ${skillContent.slice(0, 15000)}`;
                 // PM produced a plan → execute it using shared helper
                 if (chatResult.plan && chatResult.plan.subtasks.length > 0) {
                     const plan = chatResult.plan;
+                    convo.push(`Agent: (bắt tay thực hiện) ${plan.summary}`);
                     // (No "Got it! <summary>" — plan_ready already conveys the summary.)
                     wsClient.sendPlanReady(taskId, {
                         summary: plan.summary,
@@ -808,6 +811,8 @@ ${skillContent.slice(0, 15000)}`;
                     return;
                 }
                 // Send final PM message
+                if (chatResult.response?.trim())
+                    convo.push(`Agent: ${chatResult.response}`);
                 wsClient.sendPMMessage(taskId, { sender: 'pm', content: chatResult.response, startedAt: firstChunkIso || undefined });
                 if (round === MAX_RESUMED_ROUNDS - 1)
                     break;
@@ -831,6 +836,12 @@ ${skillContent.slice(0, 15000)}`;
             }
         }
         finally {
+            // Conversation memory: remember what was discussed across sessions (non-blocking).
+            if (convo.length >= 2) {
+                import('../mcp/setup.js')
+                    .then(({ storeConversationFacts }) => storeConversationFacts(convo, path.basename(pmState.repoPath)))
+                    .catch(() => { });
+            }
             activeTasks--;
             taskAbortControllers.delete(taskId);
             resolvers.delete(taskId);
@@ -850,6 +861,7 @@ ${skillContent.slice(0, 15000)}`;
         taskAbortControllers.set(taskId, abort);
         let sessionId = savedState.agentTeamSessionId;
         let totalDurationMs = 0;
+        const convo = []; // User/Agent transcript → conversation memory (Mem0)
         try {
             let userMessage = firstMessage;
             let currentInputFiles;
@@ -873,6 +885,7 @@ ${skillContent.slice(0, 15000)}`;
                 let turnAccumulatedText = '';
                 let messageCount = 0;
                 console.log(`[Daemon] Resumed agent_team round ${round + 1}: ${userMessage.substring(0, 80)}${currentInputFiles?.length ? ` (+${currentInputFiles.length} images)` : ''}`);
+                convo.push(`User: ${userMessage}`);
                 let result;
                 try {
                     result = await runClaude({
@@ -999,6 +1012,8 @@ ${skillContent.slice(0, 15000)}`;
                     });
                 }
                 lastResumeOutput = turnAccumulatedText.trim() || resultText || lastResumeOutput;
+                if (turnAccumulatedText.trim() || resultText)
+                    convo.push(`Agent: ${turnAccumulatedText.trim() || resultText}`);
                 if (result.isError) {
                     wsClient.sendTaskFailed(taskId, result.result);
                     return;
@@ -1076,6 +1091,12 @@ ${skillContent.slice(0, 15000)}`;
             }
         }
         finally {
+            // Conversation memory: remember what was discussed across sessions (non-blocking).
+            if (convo.length >= 2) {
+                import('../mcp/setup.js')
+                    .then(({ storeConversationFacts }) => storeConversationFacts(convo, path.basename(savedState.repoPath)))
+                    .catch(() => { });
+            }
             activeTasks--;
             taskAbortControllers.delete(taskId);
             resolvers.delete(taskId);

package/dist/mcp/setup.d.ts

@@ -21,12 +21,14 @@ export declare function callMem0Patterns(agentName: string, minCluster?: number)
     sources: string[];
 }>>;
 export declare function callOllamaEmbedBatch(texts: string[]): Promise<number[][] | null>;
+export declare function callMem0Reflect(taskDesc: string, resultSummary: string, status: 'done' | 'failed'): Promise<string>;
 /**
- * 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.
+ * Distill a finished conversation into durable facts (topics discussed, decisions,
+ * user preferences/interests) and store them in Mem0 — so the agent "remembers"
+ * past conversations in future sessions WITHOUT relying on it manually writing
+ * notes to a .md file. Returns the number of facts stored.
  */
-export declare function callMem0Reflect(taskDesc: string, resultSummary: string, status: 'done' | 'failed'): Promise<string>;
+export declare function storeConversationFacts(transcript: string[], agentName: string): Promise<number>;
 /**
  * Generate MCP server config file for Claude Code.
  * This file is auto-detected by runClaude and passed via --mcp-config.

package/dist/mcp/setup.js

@@ -328,8 +328,9 @@ export async function callOllamaEmbedBatch(texts) {
  * 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) {
-    const { execSync } = await import('child_process');
+/** Run a one-shot `claude -p` text prompt (used for reflection/distillation). */
+async function claudeTextOnce(prompt, tag, timeoutMs = 60000) {
+    const { execSync, spawn } = await import('child_process');
     // Resolve claude binary path (same search logic as claude-cli.ts)
     let claudeBin = 'claude';
     try {
@@ -348,25 +349,7 @@ export async function callMem0Reflect(taskDesc, resultSummary, status) {
         }).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');
     // Use spawn with stdin='ignore' — execFile keeps stdin pipe open which causes claude to hang/SIGTERM
-    const { spawn } = await import('child_process');
     return new Promise((resolve) => {
         const child = spawn(claudeBin, ['-p', prompt, '--output-format', 'text'], { stdio: ['ignore', 'pipe', 'pipe'] });
         let stdout = '';
@@ -375,31 +358,99 @@ export async function callMem0Reflect(taskDesc, resultSummary, status) {
         child.stderr.on('data', (d) => { stderr += d.toString(); });
         const timer = setTimeout(() => {
             child.kill();
-            console.warn('[Mem0 Reflect] Claude CLI timed out after 60s');
+            console.warn(`[${tag}] Claude CLI timed out after ${timeoutMs / 1000}s`);
             resolve('');
-        }, 60000);
+        }, timeoutMs);
         child.on('close', (code) => {
             clearTimeout(timer);
             if (code !== 0) {
-                console.warn(`[Mem0 Reflect] Claude CLI exited ${code}: ${stderr.substring(0, 200)}`);
-                resolve('');
-                return;
-            }
-            const reflection = stdout.trim();
-            if (!reflection) {
+                console.warn(`[${tag}] Claude CLI exited ${code}: ${stderr.substring(0, 200)}`);
                 resolve('');
                 return;
             }
-            console.log(`[Mem0 Reflect] Generated: "${reflection.substring(0, 100)}..."`);
-            resolve(reflection);
+            resolve(stdout.trim());
         });
         child.on('error', (err) => {
             clearTimeout(timer);
-            console.warn(`[Mem0 Reflect] Spawn error: ${err.message}`);
+            console.warn(`[${tag}] Spawn error: ${err.message}`);
             resolve('');
         });
     });
 }
+export async function callMem0Reflect(taskDesc, resultSummary, status) {
+    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');
+    const reflection = await claudeTextOnce(prompt, 'Mem0 Reflect');
+    if (reflection)
+        console.log(`[Mem0 Reflect] Generated: "${reflection.substring(0, 100)}..."`);
+    return reflection;
+}
+/**
+ * Distill a finished conversation into durable facts (topics discussed, decisions,
+ * user preferences/interests) and store them in Mem0 — so the agent "remembers"
+ * past conversations in future sessions WITHOUT relying on it manually writing
+ * notes to a .md file. Returns the number of facts stored.
+ */
+export async function storeConversationFacts(transcript, agentName) {
+    if (!process.env.MEM0_SSH_HOST)
+        return 0;
+    if (!transcript || transcript.length < 2)
+        return 0; // need at least one exchange
+    // Cap each message and the total so the distill prompt stays small.
+    const capped = transcript.map((m) => m.length > 400 ? m.slice(0, 400) + '…' : m);
+    let convoText = capped.join('\n');
+    if (convoText.length > 6000)
+        convoText = convoText.slice(-6000);
+    const prompt = [
+        'Below is a conversation between a user ("User") and you, an AI agent ("Agent").',
+        'Extract the facts worth remembering LONG-TERM about this conversation: topics the user cares about, decisions made, user preferences, plans/projects mentioned, key conclusions.',
+        '',
+        'Rules:',
+        '- Output 0 to 5 facts, ONE PER LINE, no bullets, no numbering, no preamble.',
+        '- Each fact must be self-contained and understandable months later (include subject/app/project names).',
+        '- Write facts in Vietnamese.',
+        '- Skip small talk, greetings, transient status ("task done", "đang chạy...").',
+        '- If nothing is worth remembering, output exactly: NONE',
+        '',
+        'Conversation:',
+        convoText,
+        '',
+        'Facts:',
+    ].join('\n');
+    const out = await claudeTextOnce(prompt, 'Mem0 Convo', 90000);
+    if (!out || /^NONE$/im.test(out.trim()))
+        return 0;
+    const facts = out.split('\n')
+        .map((l) => l.replace(/^[-*\d.\s]+/, '').trim())
+        .filter((l) => l.length > 15 && !/^NONE$/i.test(l))
+        .slice(0, 5);
+    let stored = 0;
+    for (const fact of facts) {
+        try {
+            await callMem0AddMemory(`[Hội thoại] ${fact}`, agentName);
+            stored++;
+        }
+        catch { /* best-effort */ }
+    }
+    if (stored)
+        console.log(`[Mem0 Convo] Stored ${stored} conversation fact(s) for "${agentName}"`);
+    return stored;
+}
 /**
  * Build Mem0 MCP server config for an agent.
  * - MEM0_SSH_HOST="local": run mem0-mcp directly (Mem0 infra on same machine)

package/package.json

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