tuna-agent 0.1.8 → 0.1.10

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

@@ -11,5 +11,20 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
         message: string;
     }>;
     handleTask(task: TaskAssignment, ws: AgentWebSocketClient, pendingInputResolvers: Map<string, (response: InputResponse) => void>, signal?: AbortSignal, pendingPermissionResolvers?: Map<string, (approved: boolean) => void>): Promise<void>;
+    /**
+     * 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>;
+    /**
+     * Store user rating feedback into Mem0.
+     */
+    storeRatingMemory(data: {
+        taskTitle: string;
+        taskDescription: string;
+        score: number;
+        comment?: string;
+        cwd: string;
+    }): Promise<void>;
     dispose(): Promise<void>;
 }

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

@@ -47,8 +47,9 @@ export class ClaudeCodeAdapter {
                 });
             }
             : undefined;
-        // Agent team mode: direct chat with Claude CLI (no PM layer)
-        if (task.mode === 'agent_team') {
+        // Default mode: direct chat with Claude CLI (no PM layer)
+        // Only use PM planning when mode is explicitly 'tuna'
+        if (task.mode !== 'tuna') {
             console.log(`[ClaudeCode] Agent Team mode — direct chat with Claude CLI`);
             ws.sendProgress(task.id, 'executing', { startedAt: new Date().toISOString() });
             ws.sendSubtaskStart(task.id, { id: 'agent-team', role: 'agent', description: task.description });
@@ -184,6 +185,7 @@ export class ClaudeCodeAdapter {
                         });
                         ws.sendTaskFailed(task.id, result.result);
                         console.log(`[ClaudeCode] Agent Team task ${task.id} failed in round ${round + 1}`);
+                        this.runReflection(task, result.result, 'failed', cwd).catch(() => { });
                         return;
                     }
                     // Send finalized message for the last turn's remaining text
@@ -261,6 +263,8 @@ export class ClaudeCodeAdapter {
                 await new Promise(resolve => setTimeout(resolve, 150));
                 ws.sendPMMessage(task.id, { sender: 'pm', content: 'Task completed.' });
                 console.log(`[ClaudeCode] Agent Team task ${task.id} completed (${(totalDurationMs / 1000).toFixed(1)}s)`);
+                // Post-task reflection (non-blocking — runs after task is marked done)
+                this.runReflection(task, 'Agent Team task completed', 'done', task.repoPath).catch(() => { });
             }
             finally {
                 cleanupAttachments(task.id);
@@ -635,6 +639,78 @@ export class ClaudeCodeAdapter {
                 content: `Task completed.`,
             });
             console.log(`[ClaudeCode] Task ${task.id} completed`);
+            // Post-task reflection
+            this.runReflection(task, plan.summary, 'done', task.repoPath).catch(() => { });
+        }
+    }
+    /**
+     * Run post-task self-reflection via Mem0.
+     * Agent reviews what it did and stores lessons learned.
+     */
+    async runReflection(task, resultSummary, status, cwd) {
+        if (task.enableReflection === false)
+            return;
+        if (!process.env.MEM0_SSH_HOST)
+            return; // Mem0 not configured
+        // Skip trivial tasks (< 30s would have no meaningful reflection)
+        const MIN_DESCRIPTION_LENGTH = 20;
+        if (task.description.length < MIN_DESCRIPTION_LENGTH)
+            return;
+        const truncatedDesc = task.description.substring(0, 300);
+        const truncatedResult = resultSummary.substring(0, 500);
+        const reflectionPrompt = `You just completed a task. Briefly reflect on what happened and store your reflection using the mem0 add_memory tool.
+
+Task: ${truncatedDesc}
+Status: ${status}
+Result summary: ${truncatedResult}
+
+Instructions:
+1. Think about what went well and what could be improved (2-3 sentences max)
+2. Call the mem0 add_memory tool to store your reflection
+3. Do NOT do anything else — no file edits, no other tool calls`;
+        try {
+            console.log(`[Reflection] Starting reflection for task ${task.id} (${status})`);
+            await runClaude({
+                prompt: reflectionPrompt,
+                cwd,
+                maxTurns: 3,
+                outputFormat: 'json',
+                timeoutMs: 30000,
+                permissionMode: 'bypassPermissions',
+            });
+            console.log(`[Reflection] Reflection complete for task ${task.id}`);
+        }
+        catch (err) {
+            // Non-fatal — don't let reflection failure affect task flow
+            console.warn(`[Reflection] Failed for task ${task.id}:`, err instanceof Error ? err.message : err);
+        }
+    }
+    /**
+     * Store user rating feedback into Mem0.
+     */
+    async storeRatingMemory(data) {
+        if (!process.env.MEM0_SSH_HOST)
+            return;
+        const sentiment = data.score > 0 ? 'approved (thumbs up)' : 'rejected (thumbs down)';
+        const commentPart = data.comment ? ` User feedback: "${data.comment}"` : '';
+        const memoryText = `User ${sentiment} task "${data.taskTitle}".${commentPart} Task description: ${data.taskDescription.substring(0, 200)}`;
+        const prompt = `Store this user feedback in your memory using the mem0 add_memory tool. Do NOT do anything else.
+
+Memory to store: ${memoryText}`;
+        try {
+            console.log(`[Rating→Mem0] Storing rating for task "${data.taskTitle}" (${data.score > 0 ? '👍' : '👎'})`);
+            await runClaude({
+                prompt,
+                cwd: data.cwd,
+                maxTurns: 2,
+                outputFormat: 'json',
+                timeoutMs: 20000,
+                permissionMode: 'bypassPermissions',
+            });
+            console.log(`[Rating→Mem0] Rating stored successfully`);
+        }
+        catch (err) {
+            console.warn(`[Rating→Mem0] Failed:`, err instanceof Error ? err.message : err);
         }
     }
     async dispose() {

package/dist/daemon/index.js

@@ -276,6 +276,28 @@ ${skillContent.slice(0, 15000)}`;
                         }
                     })();
                 }
+                else if (command === 'task_rated') {
+                    const score = msg.score;
+                    const comment = msg.comment;
+                    const taskTitle = msg.taskTitle || '';
+                    const taskDescription = msg.taskDescription || '';
+                    const agentId = msg.agentId || '';
+                    console.log(`[Daemon] Task rated: ${score > 0 ? '👍' : '👎'} "${taskTitle}"`);
+                    // Store rating in Mem0 via adapter (fire-and-forget)
+                    if (adapter.type === 'claude-code') {
+                        const ccAdapter = adapter;
+                        const defaultCwd = path.join(os.homedir(), 'tuna-workspace');
+                        ccAdapter.storeRatingMemory({
+                            taskTitle,
+                            taskDescription,
+                            score,
+                            comment: comment || undefined,
+                            cwd: defaultCwd,
+                        }).catch((err) => {
+                            console.warn(`[Daemon] Rating→Mem0 failed:`, err instanceof Error ? err.message : err);
+                        });
+                    }
+                }
                 else {
                     console.log(`[Daemon] Unknown command: ${command}`);
                 }

package/dist/daemon/pm-state.d.ts

@@ -3,7 +3,7 @@ export interface PMSessionState {
     pmSessionId: string;
     repoPath: string;
     savedAt: string;
-    /** Task mode — defaults to 'tuna' for backward compat */
+    /** Task mode — defaults to 'agent_team' (direct Claude CLI) */
     mode?: 'tuna' | 'agent_team';
     /** Claude CLI session ID for agent_team resume */
     agentTeamSessionId?: string;

package/dist/mcp/setup.js

@@ -37,7 +37,7 @@ function buildMem0McpConfig(agentName) {
             env: envWithUser,
         };
     }
-    const envString = Object.entries(envWithUser).map(([k, v]) => `${k}=${v}`).join(' ');
+    const envString = Object.entries(envWithUser).map(([k, v]) => `${k}='${String(v).replace(/'/g, "'\\''")}'`).join(' ');
     const args = ['-p', MEM0_SSH_PORT, '-o', 'StrictHostKeyChecking=no'];
     if (MEM0_SSH_KEY) {
         args.push('-i', MEM0_SSH_KEY);

package/dist/types/index.d.ts

@@ -43,6 +43,7 @@ export interface TaskAssignment {
     attachments?: ChatAttachment[];
     source?: 'manual' | 'skill' | 'scheduled' | 'workflow' | 'api';
     agentId?: string;
+    enableReflection?: boolean;
 }
 export interface ConnectResponse {
     machine_id: string;

package/package.json

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