tuna-agent 0.1.70 → 0.1.72

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

@@ -47,6 +47,8 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     getMetrics(): Record<string, unknown>;
     /** Register an agent folder path for rules parsing (called from daemon). */
     registerAgentFolder(agentId: string, folderPath: string): void;
+    /** Get folder path for an agent by ID (returns undefined if not registered). */
+    getAgentFolder(agentId: string): string | undefined;
     /** Seed memoryCount from Mem0 for all registered agents (called once on daemon startup). */
     seedMemoryCounts(): Promise<void>;
     checkHealth(): Promise<{
@@ -77,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

@@ -92,6 +92,10 @@ export class ClaudeCodeAdapter {
     registerAgentFolder(agentId, folderPath) {
         this.agentFolderMap.set(agentId, folderPath);
     }
+    /** Get folder path for an agent by ID (returns undefined if not registered). */
+    getAgentFolder(agentId) {
+        return this.agentFolderMap.get(agentId);
+    }
     /** Seed memoryCount from Mem0 for all registered agents (called once on daemon startup). */
     async seedMemoryCounts() {
         for (const [agentId, folder] of this.agentFolderMap) {
@@ -145,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() });
@@ -175,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>`;
@@ -203,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(() => { });
                     }
@@ -324,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;
@@ -364,6 +372,7 @@ export class ClaudeCodeAdapter {
                         savedAt: new Date().toISOString(),
                         mode: 'agent_team',
                         agentTeamSessionId: sessionId,
+                        agentId: task.agentId,
                     });
                     console.log(`[ClaudeCode] Agent Team round ${round + 1} done — waiting for follow-up (60s timeout)`);
                     // Wait for follow-up message with timeout — free agent if no reply
@@ -384,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;
                         }
@@ -418,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 {
@@ -486,7 +495,7 @@ export class ClaudeCodeAdapter {
             const MAX_CHAT_ROUNDS = 50;
             let pmSessionId = planResult.pmSessionId || '';
             // Persist PM state for recovery after agent restart
-            savePMState({ taskId: task.id, pmSessionId, repoPath: task.repoPath, savedAt: new Date().toISOString() });
+            savePMState({ taskId: task.id, pmSessionId, repoPath: task.repoPath, savedAt: new Date().toISOString(), agentId: task.agentId });
             // Track the latest PM message to use as context for needs_input
             let latestPMMessage = firstMsg;
             for (let round = 0; round < MAX_CHAT_ROUNDS; round++) {
@@ -529,7 +538,7 @@ export class ClaudeCodeAdapter {
                 console.log(`[ClaudeCode] ⏱ chat total: ${chatDoneMs - inputReceivedMs}ms | first chunk: ${firstChunkSentMs ? firstChunkSentMs - inputReceivedMs : 'none'}ms | chunks: ${chunkCount}`);
                 pmSessionId = chatResult.sessionId || pmSessionId;
                 // Update persisted PM session ID
-                savePMState({ taskId: task.id, pmSessionId, repoPath: task.repoPath, savedAt: new Date().toISOString() });
+                savePMState({ taskId: task.id, pmSessionId, repoPath: task.repoPath, savedAt: new Date().toISOString(), agentId: task.agentId });
                 // PM produced a plan with subtasks → break out to execution
                 if (chatResult.plan && chatResult.plan.subtasks.length > 0) {
                     planResult = { plan: chatResult.plan, pmSessionId };
@@ -779,6 +788,7 @@ export class ClaudeCodeAdapter {
                     pmSessionId: planResult.pmSessionId,
                     repoPath: task.repoPath,
                     savedAt: new Date().toISOString(),
+                    agentId: task.agentId,
                 });
             }
             ws.sendTaskDone(task.id, {
@@ -897,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++;
@@ -983,7 +993,7 @@ export class ClaudeCodeAdapter {
             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);
@@ -993,7 +1003,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;
@@ -1038,8 +1048,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`);
             }
         }
@@ -1048,20 +1059,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

@@ -134,9 +134,7 @@ export async function startDaemon(config) {
     const activeAgentTasks = new Map();
     // Track abort controllers per task
     const taskAbortControllers = new Map();
-    // Legacy single-task tracking (for functions that still use it)
-    let currentTaskId = null;
-    let currentTaskAbort = null;
+    // Note: currentTaskId/currentTaskAbort removed — use taskAbortControllers + activeAgentTasks instead
     const onAuthFailed = (code, reason) => {
         console.error(`\n[Daemon] Authentication failed (code: ${code}, reason: ${reason}).`);
         console.error('[Daemon] Your machine token is invalid or expired.');
@@ -203,7 +201,7 @@ export async function startDaemon(config) {
                 }
                 // Recover orphaned tasks — pass active task IDs so API won't fail tasks we're still running
                 const activeTaskIds = Array.from(taskAbortControllers.keys());
-                ws.send({ action: 'recover_orphaned_tasks', activeTaskId: currentTaskId ?? undefined, activeTaskIds });
+                ws.send({ action: 'recover_orphaned_tasks', activeTaskIds });
                 break;
             case 'task_assigned': {
                 const task = msg.task;
@@ -226,11 +224,7 @@ export async function startDaemon(config) {
                 activeAgentTasks.set(agentId, task.id);
                 const abort = new AbortController();
                 taskAbortControllers.set(task.id, abort);
-                currentTaskId = task.id;
-                currentTaskAbort = abort;
                 console.log(`[Daemon] Received task: ${task.id} agent=${agentId} — ${task.description.slice(0, 80)} (attachments: ${task.attachments?.length ?? 0}) [active: ${activeTasks}]`);
-                // MCP config per-agent is handled by writeAgentFolderMcpConfig in adapter
-                // (writes per-agent .mcp.json in agent folder — safe for parallel execution)
                 // Run task in background (non-blocking) to allow parallel agent execution
                 (async () => {
                     try {
@@ -250,10 +244,6 @@ export async function startDaemon(config) {
                         activeTasks--;
                         activeAgentTasks.delete(agentId);
                         taskAbortControllers.delete(task.id);
-                        if (currentTaskId === task.id) {
-                            currentTaskId = null;
-                            currentTaskAbort = null;
-                        }
                         pendingInputResolvers.delete(task.id);
                         ws.send({ action: 'agent_ready', agentId });
                     }
@@ -435,13 +425,14 @@ ${skillContent.slice(0, 15000)}`;
                     // 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');
+                        const agentFolder = agentId ? ccAdapter.getAgentFolder(agentId) : undefined;
+                        const cwd = agentFolder || path.join(os.homedir(), 'tuna-workspace');
                         ccAdapter.storeRatingMemory({
                             taskTitle,
                             taskDescription,
                             score,
                             comment: comment || undefined,
-                            cwd: defaultCwd,
+                            cwd,
                         }).catch((err) => {
                             console.warn(`[Daemon] Rating→Mem0 failed:`, err instanceof Error ? err.message : err);
                         });
@@ -467,6 +458,13 @@ ${skillContent.slice(0, 15000)}`;
                     // No resolver — check if we have a persisted session to resume
                     const savedState = loadPMState(taskId);
                     if (savedState) {
+                        // Check per-agent concurrency before resuming
+                        const resumeAgentId = savedState.agentId || '__default__';
+                        if (activeAgentTasks.has(resumeAgentId)) {
+                            console.warn(`[Daemon] Cannot resume task ${taskId} — agent ${resumeAgentId} is busy with task ${activeAgentTasks.get(resumeAgentId)}`);
+                            ws.send({ action: 'task_rejected', taskId, reason: 'agent_busy' });
+                            break;
+                        }
                         if (savedState.mode === 'agent_team') {
                             console.log(`[Daemon] Resuming agent_team for task ${taskId} (session: ${savedState.agentTeamSessionId?.substring(0, 12) ?? 'none'})`);
                             resumeAgentTeamChat(taskId, answer, attachments, savedState, ws, pendingInputResolvers);
@@ -635,11 +633,11 @@ ${skillContent.slice(0, 15000)}`;
      * Loads persisted pmSessionId and runs a chat loop.
      */
     async function resumePMChat(taskId, firstMessage, firstAttachments, pmState, wsClient, resolvers) {
+        const agentId = pmState.agentId || '__default__';
         activeTasks++;
+        activeAgentTasks.set(agentId, taskId);
         const abort = new AbortController();
         taskAbortControllers.set(taskId, abort);
-        currentTaskId = taskId;
-        currentTaskAbort = abort;
         let pmSessionId = pmState.pmSessionId;
         const MAX_RESUMED_ROUNDS = 50;
         try {
@@ -667,7 +665,7 @@ ${skillContent.slice(0, 15000)}`;
                 }, inputFiles);
                 wsClient.sendPMStreamEnd(taskId, streamMsgId);
                 pmSessionId = chatResult.sessionId || pmSessionId;
-                savePMState({ taskId, pmSessionId, repoPath: pmState.repoPath, savedAt: new Date().toISOString() });
+                savePMState({ taskId, pmSessionId, repoPath: pmState.repoPath, savedAt: new Date().toISOString(), agentId: pmState.agentId });
                 // PM produced a plan → execute it using shared helper
                 if (chatResult.plan && chatResult.plan.subtasks.length > 0) {
                     const plan = chatResult.plan;
@@ -731,14 +729,11 @@ ${skillContent.slice(0, 15000)}`;
         }
         finally {
             activeTasks--;
+            activeAgentTasks.delete(agentId);
             taskAbortControllers.delete(taskId);
-            if (currentTaskId === taskId) {
-                currentTaskId = null;
-                currentTaskAbort = null;
-            }
             resolvers.delete(taskId);
             cleanupAttachments(taskId);
-            wsClient.send({ action: 'agent_ready' });
+            wsClient.send({ action: 'agent_ready', agentId });
         }
     }
     /**
@@ -746,11 +741,11 @@ ${skillContent.slice(0, 15000)}`;
      * Uses saved Claude CLI session ID to resume with --resume flag.
      */
     async function resumeAgentTeamChat(taskId, firstMessage, firstAttachments, savedState, wsClient, resolvers) {
+        const agentId = savedState.agentId || '__default__';
         activeTasks++;
+        activeAgentTasks.set(agentId, taskId);
         const abort = new AbortController();
         taskAbortControllers.set(taskId, abort);
-        currentTaskId = taskId;
-        currentTaskAbort = abort;
         let sessionId = savedState.agentTeamSessionId;
         let totalDurationMs = 0;
         try {
@@ -849,6 +844,7 @@ ${skillContent.slice(0, 15000)}`;
                     savedAt: new Date().toISOString(),
                     mode: 'agent_team',
                     agentTeamSessionId: sessionId,
+                    agentId: savedState.agentId,
                 });
                 // Wait for follow-up with timeout
                 const FOLLOW_UP_TIMEOUT_MS = 60_000;
@@ -871,7 +867,7 @@ ${skillContent.slice(0, 15000)}`;
                         // Track metrics + reflection on the adapter
                         if (adapter.type === 'claude-code') {
                             const ccAdapter = adapter;
-                            ccAdapter.trackMetricsPublic('done', totalDurationMs);
+                            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)).catch(() => { });
                         }
                         return;
@@ -909,14 +905,11 @@ ${skillContent.slice(0, 15000)}`;
         }
         finally {
             activeTasks--;
+            activeAgentTasks.delete(agentId);
             taskAbortControllers.delete(taskId);
-            if (currentTaskId === taskId) {
-                currentTaskId = null;
-                currentTaskAbort = null;
-            }
             resolvers.delete(taskId);
             cleanupAttachments(taskId);
-            wsClient.send({ action: 'agent_ready' });
+            wsClient.send({ action: 'agent_ready', agentId });
         }
     }
     // Wire up agent metrics to heartbeat

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

@@ -7,6 +7,8 @@ export interface PMSessionState {
     mode?: 'tuna' | 'agent_team';
     /** Claude CLI session ID for agent_team resume */
     agentTeamSessionId?: string;
+    /** Agent ID for per-agent concurrency tracking during resume */
+    agentId?: string;
 }
 /** Save PM session state for a task (survives agent restart). */
 export declare function savePMState(state: PMSessionState): void;

package/package.json

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