tuna-agent 0.1.71 → 0.1.73

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

@@ -79,14 +79,14 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     private static extractKeyPhrases;
     /** Check if two rules are semantically similar (>40% key phrase overlap). */
     private static isSimilarRule;
-    runSelfImprovement(cwd: string): Promise<void>;
+    runSelfImprovement(cwd: string, agentId?: string): Promise<void>;
     /**
      * Parse "## Learned Rules" section from CLAUDE.md and store in learnedRulesMap.
      * Rule format: `- Rule text (confidence: 0.7)`
      */
     private parseLearnedRules;
     /** Track task completion metrics (public for daemon resume path). */
-    trackMetricsPublic(status: 'done' | 'failed', durationMs: number): void;
+    trackMetricsPublic(status: 'done' | 'failed', durationMs: number, agentId?: string): void;
     /** Track task completion metrics. */
     private trackMetrics;
     dispose(): Promise<void>;

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

@@ -149,13 +149,16 @@ export class ClaudeCodeAdapter {
             : undefined;
         // Default mode: direct chat with Claude CLI (no PM layer)
         // Only use PM planning when mode is explicitly 'tuna'
-        // Set current agent context (metrics + Mem0 identity)
-        this.currentAgentId = task.agentId || '';
+        // Capture agent context as LOCAL variables for parallel-safety
+        const localAgentId = task.agentId || '';
         const defaultWorkspaceEarly = path.join(os.homedir(), 'tuna-workspace');
-        this.currentAgentName = path.basename(task.repoPath || defaultWorkspaceEarly);
+        const localAgentName = path.basename(task.repoPath || defaultWorkspaceEarly);
+        // Also set instance vars for backward compat (metrics getter, heartbeat, etc.)
+        this.currentAgentId = localAgentId;
+        this.currentAgentName = localAgentName;
         // Track agent folder for rules parsing in heartbeat
         const cwd = task.repoPath || defaultWorkspaceEarly;
-        this.agentFolderMap.set(this.currentAgentId, cwd);
+        this.agentFolderMap.set(localAgentId, cwd);
         if (task.mode !== 'tuna') {
             console.log(`[ClaudeCode] Agent Team mode — direct chat with Claude CLI`);
             ws.sendProgress(task.id, 'executing', { startedAt: new Date().toISOString() });
@@ -179,7 +182,7 @@ export class ClaudeCodeAdapter {
             if (process.env.MEM0_SSH_HOST && task.description.length >= 20) {
                 try {
                     const { callMem0SearchMemory } = await import('../mcp/setup.js');
-                    const memories = await callMem0SearchMemory(task.description, this.currentAgentName, 5);
+                    const memories = await callMem0SearchMemory(task.description, localAgentName, 5);
                     if (memories.length > 0) {
                         const memoryContext = memories.map(m => `- ${m}`).join('\n');
                         userMessage = `${task.description}\n\n<past_learnings>\nRelevant lessons from previous tasks:\n${memoryContext}\n</past_learnings>`;
@@ -207,10 +210,11 @@ export class ClaudeCodeAdapter {
                     if (round === 0) {
                         writeAgentFolderMcpConfig(cwd, this.agentConfig);
                         // Seed memoryCount from Mem0 so it survives daemon restarts (non-blocking)
-                        fetchMem0Count(this.currentAgentName).then(count => {
-                            if (count > this.metrics.memoryCount) {
-                                this.metrics.memoryCount = count;
-                                console.log(`[Metrics] Seeded memoryCount=${count} from Mem0 for "${this.currentAgentName}"`);
+                        fetchMem0Count(localAgentName).then(count => {
+                            const m = this.getMetricsForAgent(localAgentId);
+                            if (count > m.memoryCount) {
+                                m.memoryCount = count;
+                                console.log(`[Metrics] Seeded memoryCount=${count} from Mem0 for "${localAgentName}"`);
                             }
                         }).catch(() => { });
                     }
@@ -328,7 +332,7 @@ export class ClaudeCodeAdapter {
                             startedAt: firstChunkIso || undefined,
                         });
                         ws.sendTaskFailed(task.id, result.result);
-                        this.trackMetrics('failed', totalDurationMs);
+                        this.trackMetrics('failed', totalDurationMs, localAgentId);
                         console.log(`[ClaudeCode] Agent Team task ${task.id} failed in round ${round + 1}`);
                         this.runReflection(task, result.result, 'failed', cwd).catch(() => { });
                         return;
@@ -389,10 +393,10 @@ export class ClaudeCodeAdapter {
                                 durationMs: totalDurationMs,
                                 sessionId,
                             });
-                            this.trackMetrics('done', totalDurationMs);
+                            this.trackMetrics('done', totalDurationMs, localAgentId);
                             const timeoutOutput = lastTaskOutput || 'Task completed (no follow-up)';
                             this.runReflection(task, timeoutOutput, 'done', task.repoPath)
-                                .then(() => this.runSelfImprovement(task.repoPath))
+                                .then(() => this.runSelfImprovement(task.repoPath, task.agentId))
                                 .catch(() => { });
                             return;
                         }
@@ -423,11 +427,11 @@ export class ClaudeCodeAdapter {
                 });
                 await new Promise(resolve => setTimeout(resolve, 150));
                 ws.sendPMMessage(task.id, { sender: 'pm', content: 'Task completed.' });
-                this.trackMetrics('done', totalDurationMs);
+                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)
-                    .then(() => this.runSelfImprovement(task.repoPath))
+                    .then(() => this.runSelfImprovement(task.repoPath, task.agentId))
                     .catch(() => { });
             }
             finally {
@@ -903,7 +907,7 @@ export class ClaudeCodeAdapter {
         const overlap = phrasesA.filter(p => phrasesB.has(p)).length;
         return overlap / phrasesA.length > 0.4;
     }
-    async runSelfImprovement(cwd) {
+    async runSelfImprovement(cwd, agentId) {
         if (!process.env.MEM0_SSH_HOST)
             return;
         this.taskCount++;
@@ -982,14 +986,15 @@ export class ClaudeCodeAdapter {
                 const separator = existingContent.endsWith('\n') ? '\n' : '\n\n';
                 fs.writeFileSync(claudeMdPath, existingContent + separator + `${SECTION_HEADER}\n${rulesBlock}\n`);
             }
-            this.metrics.patternsLearnedCount += toAdd.length;
-            this.metrics.rulesCount += toAdd.length;
-            this.metrics.lastPatternAt = new Date().toISOString();
-            this.metrics.latestLearnedRule = toAdd[toAdd.length - 1].rule.substring(0, 500);
+            const m = agentId ? this.getMetricsForAgent(agentId) : this.metrics;
+            m.patternsLearnedCount += toAdd.length;
+            m.rulesCount += toAdd.length;
+            m.lastPatternAt = new Date().toISOString();
+            m.latestLearnedRule = toAdd[toAdd.length - 1].rule.substring(0, 500);
             console.log(`[Self-Improve] Added ${toAdd.length} new rules to CLAUDE.md:`);
             toAdd.forEach(p => console.log(`[Self-Improve]   - ${p.rule}`));
             // Sync learned rules to heartbeat metrics
-            this.parseLearnedRules(claudeMdPath);
+            this.parseLearnedRules(claudeMdPath, agentId);
         }
         catch (err) {
             console.warn(`[Self-Improve] Failed:`, err instanceof Error ? err.message : err);
@@ -999,7 +1004,7 @@ export class ClaudeCodeAdapter {
      * Parse "## Learned Rules" section from CLAUDE.md and store in learnedRulesMap.
      * Rule format: `- Rule text (confidence: 0.7)`
      */
-    parseLearnedRules(claudeMdPath) {
+    parseLearnedRules(claudeMdPath, agentId) {
         try {
             if (!fs.existsSync(claudeMdPath))
                 return;
@@ -1044,8 +1049,9 @@ export class ClaudeCodeAdapter {
                 });
             }
             if (rules.length > 0) {
-                this.learnedRulesMap.set(this.currentAgentId, rules);
-                this.metrics.rulesCount = rules.length;
+                const resolvedAgentId = agentId || this.currentAgentId;
+                this.learnedRulesMap.set(resolvedAgentId, rules);
+                this.getMetricsForAgent(resolvedAgentId).rulesCount = rules.length;
                 console.log(`[Self-Improve] Parsed ${rules.length} rules from CLAUDE.md for heartbeat sync`);
             }
         }
@@ -1054,20 +1060,21 @@ export class ClaudeCodeAdapter {
         }
     }
     /** Track task completion metrics (public for daemon resume path). */
-    trackMetricsPublic(status, durationMs) {
-        this.trackMetrics(status, durationMs);
+    trackMetricsPublic(status, durationMs, agentId) {
+        this.trackMetrics(status, durationMs, agentId);
     }
     /** Track task completion metrics. */
-    trackMetrics(status, durationMs) {
-        this.metrics.taskCount++;
+    trackMetrics(status, durationMs, agentId) {
+        const m = agentId ? this.getMetricsForAgent(agentId) : this.metrics;
+        m.taskCount++;
         if (status === 'done')
-            this.metrics.successCount++;
+            m.successCount++;
         else
-            this.metrics.failCount++;
-        this.metrics.totalDurationMs += durationMs;
-        this.metrics.avgDurationMs = Math.round(this.metrics.totalDurationMs / this.metrics.taskCount);
-        this.metrics.lastTaskAt = new Date().toISOString();
-        console.log(`[Metrics] Tasks: ${this.metrics.successCount}✓ ${this.metrics.failCount}✗ | Avg: ${(this.metrics.avgDurationMs / 1000).toFixed(0)}s | Reflections: ${this.metrics.reflectionCount} | Patterns: ${this.metrics.patternsLearnedCount}`);
+            m.failCount++;
+        m.totalDurationMs += durationMs;
+        m.avgDurationMs = Math.round(m.totalDurationMs / m.taskCount);
+        m.lastTaskAt = new Date().toISOString();
+        console.log(`[Metrics] Tasks: ${m.successCount}✓ ${m.failCount}✗ | Avg: ${(m.avgDurationMs / 1000).toFixed(0)}s | Reflections: ${m.reflectionCount} | Patterns: ${m.patternsLearnedCount}`);
     }
     async dispose() {
         // No persistent resources to clean up

package/dist/daemon/index.js

@@ -778,7 +778,7 @@ ${skillContent.slice(0, 15000)}`;
                     outputFormat: 'stream-json',
                     includePartialMessages: true,
                     agentTeam: true,
-                    maxTurns: 50,
+                    maxTurns: 200,
                     resumeSessionId: sessionId,
                     signal: abort.signal,
                     inputFiles: currentInputFiles,
@@ -813,6 +813,24 @@ ${skillContent.slice(0, 15000)}`;
                         if (data.type === 'system' && data.subtype === 'init') {
                             sessionId = data.session_id;
                         }
+                        // Patch missing stream chunks from assistant message (same as handleTask)
+                        if (data.type === 'assistant' && data.message) {
+                            const msg = data.message;
+                            const content = msg.content;
+                            if (content) {
+                                const fullText = content
+                                    .filter(b => b.type === 'text' && b.text)
+                                    .map(b => b.text)
+                                    .join('');
+                                if (fullText && fullText.length > turnAccumulatedText.length) {
+                                    const missed = fullText.slice(turnAccumulatedText.length);
+                                    if (missed.length > 0) {
+                                        turnAccumulatedText = fullText;
+                                        wsClient.sendPMStream(taskId, missed);
+                                    }
+                                }
+                            }
+                        }
                     },
                 });
                 wsClient.sendPMStreamEnd(taskId, streamMsgId);
@@ -867,8 +885,8 @@ ${skillContent.slice(0, 15000)}`;
                         // Track metrics + reflection on the adapter
                         if (adapter.type === 'claude-code') {
                             const ccAdapter = adapter;
-                            ccAdapter.trackMetricsPublic('done', totalDurationMs);
-                            ccAdapter.runReflection({ id: taskId, description: firstMessage, repoPath: cwd, enableReflection: true }, lastResumeOutput || 'Task completed (no follow-up)', 'done', cwd).then(() => ccAdapter.runSelfImprovement(cwd)).catch(() => { });
+                            ccAdapter.trackMetricsPublic('done', totalDurationMs, savedState.agentId);
+                            ccAdapter.runReflection({ id: taskId, description: firstMessage, repoPath: cwd, enableReflection: true }, lastResumeOutput || 'Task completed (no follow-up)', 'done', cwd).then(() => ccAdapter.runSelfImprovement(cwd, savedState.agentId)).catch(() => { });
                         }
                         return;
                     }

package/package.json

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