tuna-agent 0.1.68 → 0.1.70

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

@@ -38,6 +38,8 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     private currentAgentName;
     /** Returns metrics for the currently active agent, initializing if needed. */
     private get metrics();
+    /** Returns metrics for a specific agent by ID (safe for parallel execution). */
+    getMetricsForAgent(agentId: string): AgentMetrics;
     constructor(config: AgentConfig);
     /** Resolve CLAUDE.md path — check root first, then .claude/ subfolder. */
     static resolveClaudeMdPath(folder: string): string;

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

@@ -23,8 +23,12 @@ export class ClaudeCodeAdapter {
     currentAgentName = '';
     /** Returns metrics for the currently active agent, initializing if needed. */
     get metrics() {
-        if (!this.metricsMap.has(this.currentAgentId)) {
-            this.metricsMap.set(this.currentAgentId, {
+        return this.getMetricsForAgent(this.currentAgentId);
+    }
+    /** Returns metrics for a specific agent by ID (safe for parallel execution). */
+    getMetricsForAgent(agentId) {
+        if (!this.metricsMap.has(agentId)) {
+            this.metricsMap.set(agentId, {
                 taskCount: 0,
                 successCount: 0,
                 failCount: 0,
@@ -42,7 +46,7 @@ export class ClaudeCodeAdapter {
                 upSince: new Date().toISOString(),
             });
         }
-        return this.metricsMap.get(this.currentAgentId);
+        return this.metricsMap.get(agentId);
     }
     constructor(config) {
         this.agentConfig = config;
@@ -810,22 +814,26 @@ export class ClaudeCodeAdapter {
         const MIN_DESCRIPTION_LENGTH = 20;
         if (task.description.length < MIN_DESCRIPTION_LENGTH)
             return;
+        // Derive agent name from cwd (safe for parallel execution — no shared state)
+        const agentName = path.basename(cwd) || this.currentAgentName;
+        const agentId = task.agentId || this.currentAgentId;
         try {
             // Step 1: Generate AI-powered reflection via Ollama
             console.log(`[Reflection] Generating AI reflection for task ${task.id} (${status}), input: ${resultSummary.substring(0, 150)}...`);
             const { callMem0Reflect, callMem0AddMemory } = await import('../mcp/setup.js');
             const aiReflection = await callMem0Reflect(task.description, resultSummary, status);
             if (!aiReflection) {
-                this.metrics.reflectionSkipCount++;
+                this.getMetricsForAgent(agentId).reflectionSkipCount++;
                 console.log(`[Reflection] No meaningful lesson — skipping storage for task ${task.id}`);
                 return;
             }
             // Step 2: Store the AI-generated reflection in Mem0
             console.log(`[Reflection] Storing: "${aiReflection.substring(0, 100)}..."`);
-            await callMem0AddMemory(aiReflection, this.currentAgentName);
-            this.metrics.reflectionCount++;
-            this.metrics.memoryCount++;
-            this.metrics.lastReflectionAt = new Date().toISOString();
+            await callMem0AddMemory(aiReflection, agentName);
+            const m = this.getMetricsForAgent(agentId);
+            m.reflectionCount++;
+            m.memoryCount++;
+            m.lastReflectionAt = new Date().toISOString();
             console.log(`[Reflection] Stored for task ${task.id}`);
         }
         catch (err) {
@@ -836,7 +844,7 @@ export class ClaudeCodeAdapter {
                     ? `Task failed: "${task.description.substring(0, 150)}". Error: ${resultSummary.substring(0, 200)}`
                     : `Task completed: "${task.description.substring(0, 150)}". Result: ${resultSummary.substring(0, 200)}`;
                 const { callMem0AddMemory } = await import('../mcp/setup.js');
-                await callMem0AddMemory(fallback, this.currentAgentName);
+                await callMem0AddMemory(fallback, agentName);
             }
             catch {
                 // Both AI and fallback failed — give up silently
@@ -859,7 +867,8 @@ export class ClaudeCodeAdapter {
         try {
             console.log(`[Rating→Mem0] Storing rating for task "${data.taskTitle}" (${data.score > 0 ? '👍' : '👎'})`);
             const { callMem0AddMemory } = await import('../mcp/setup.js');
-            await callMem0AddMemory(memoryText, this.currentAgentName);
+            const agentName = path.basename(data.cwd) || this.currentAgentName;
+            await callMem0AddMemory(memoryText, agentName);
             console.log(`[Rating→Mem0] Rating stored successfully`);
         }
         catch (err) {
@@ -897,7 +906,8 @@ export class ClaudeCodeAdapter {
         try {
             console.log(`[Self-Improve] Running pattern detection (every ${ClaudeCodeAdapter.PATTERN_CHECK_INTERVAL} tasks, count=${this.taskCount})`);
             const { callMem0Patterns } = await import('../mcp/setup.js');
-            const patterns = await callMem0Patterns(this.currentAgentName, 2);
+            const agentName = path.basename(cwd) || this.currentAgentName;
+            const patterns = await callMem0Patterns(agentName, 2);
             if (patterns.length === 0) {
                 console.log(`[Self-Improve] No patterns detected yet`);
                 return;

package/dist/daemon/index.js

@@ -127,9 +127,14 @@ export async function startDaemon(config) {
         console.log(`[Daemon] Agent ready: ${adapter.displayName} (${health.message})`);
     }
     let activeTasks = 0;
-    const MAX_CONCURRENT = 1;
+    const MAX_CONCURRENT_PER_AGENT = 1; // Each agent can run 1 task at a time
     const pendingInputResolvers = new Map();
     const pendingPermissionResolvers = new Map();
+    // Track active tasks per agent (agentId → taskId)
+    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;
     const onAuthFailed = (code, reason) => {
@@ -196,8 +201,9 @@ export async function startDaemon(config) {
                     // Seed memory counts from Mem0 so they appear on agent detail immediately
                     ccAdapter.seedMemoryCounts().catch(() => { });
                 }
-                // Recover orphaned tasks — pass activeTaskId so API won't fail a task we're still running
-                ws.send({ action: 'recover_orphaned_tasks', activeTaskId: currentTaskId ?? undefined });
+                // 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 });
                 break;
             case 'task_assigned': {
                 const task = msg.task;
@@ -209,53 +215,58 @@ export async function startDaemon(config) {
                 if (task.repoPath?.startsWith('~/')) {
                     task.repoPath = path.join(os.homedir(), task.repoPath.slice(2));
                 }
-                if (activeTasks >= MAX_CONCURRENT) {
-                    console.log(`[Daemon] Busy — rejecting task ${task.id}`);
+                // Check per-agent concurrency (each agent can run 1 task at a time)
+                const agentId = task.agentId || '__default__';
+                if (activeAgentTasks.has(agentId)) {
+                    console.log(`[Daemon] Agent ${agentId} busy — rejecting task ${task.id}`);
                     ws.send({ action: 'task_rejected', taskId: task.id, reason: 'agent_busy' });
                     break;
                 }
                 activeTasks++;
+                activeAgentTasks.set(agentId, task.id);
+                const abort = new AbortController();
+                taskAbortControllers.set(task.id, abort);
                 currentTaskId = task.id;
-                currentTaskAbort = new AbortController();
-                console.log(`[Daemon] Received task: ${task.id} agentId=${task.agentId || '(none)'} — ${task.description.slice(0, 80)} (attachments: ${task.attachments?.length ?? 0})`);
-                // Update MCP config with the task's agent ID so knowledge server uses correct attribution
-                if (task.agentId) {
+                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 {
-                        setupMcpConfig({ ...config, agentId: task.agentId });
+                        await adapter.handleTask(task, ws, pendingInputResolvers, abort.signal, pendingPermissionResolvers);
                     }
                     catch (err) {
-                        console.warn(`[Daemon] MCP config update for task failed (non-fatal):`, err);
-                    }
-                }
-                try {
-                    await adapter.handleTask(task, ws, pendingInputResolvers, currentTaskAbort.signal, pendingPermissionResolvers);
-                }
-                catch (err) {
-                    const errMsg = err instanceof Error ? err.message : String(err);
-                    if (currentTaskAbort?.signal.aborted) {
-                        console.log(`[Daemon] Task ${task.id} cancelled`);
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        if (abort.signal.aborted) {
+                            console.log(`[Daemon] Task ${task.id} cancelled`);
+                        }
+                        else {
+                            ws.sendTaskFailed(task.id, errMsg);
+                            console.error(`[Daemon] Task ${task.id} error:`, errMsg);
+                        }
                     }
-                    else {
-                        ws.sendTaskFailed(task.id, errMsg);
-                        console.error(`[Daemon] Task ${task.id} error:`, errMsg);
+                    finally {
+                        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 });
                     }
-                }
-                finally {
-                    activeTasks--;
-                    currentTaskId = null;
-                    currentTaskAbort = null;
-                    pendingInputResolvers.delete(task.id);
-                    // Notify API that agent is available to pick up queued tasks
-                    ws.send({ action: 'agent_ready' });
-                }
+                })();
                 break;
             }
             case 'task_cancelled': {
                 const taskId = msg.taskId;
                 console.log(`[Daemon] Task cancelled: ${taskId}`);
                 clearPMState(taskId);
-                if (currentTaskId === taskId && currentTaskAbort) {
-                    currentTaskAbort.abort();
+                const taskAbort = taskAbortControllers.get(taskId);
+                if (taskAbort) {
+                    taskAbort.abort();
                     console.log(`[Daemon] Aborted running task ${taskId}`);
                 }
                 // Also resolve any pending input to unblock waitForInput
@@ -455,7 +466,7 @@ ${skillContent.slice(0, 15000)}`;
                 else {
                     // No resolver — check if we have a persisted session to resume
                     const savedState = loadPMState(taskId);
-                    if (savedState && activeTasks < MAX_CONCURRENT) {
+                    if (savedState) {
                         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);
@@ -465,9 +476,6 @@ ${skillContent.slice(0, 15000)}`;
                             resumePMChat(taskId, answer, attachments, savedState, ws, pendingInputResolvers);
                         }
                     }
-                    else if (savedState) {
-                        console.warn(`[Daemon] Cannot resume — agent busy (active: ${activeTasks})`);
-                    }
                     else {
                         console.warn(`[Daemon] No pending input resolver for task ${taskId}`);
                     }
@@ -628,8 +636,10 @@ ${skillContent.slice(0, 15000)}`;
      */
     async function resumePMChat(taskId, firstMessage, firstAttachments, pmState, wsClient, resolvers) {
         activeTasks++;
+        const abort = new AbortController();
+        taskAbortControllers.set(taskId, abort);
         currentTaskId = taskId;
-        currentTaskAbort = new AbortController();
+        currentTaskAbort = abort;
         let pmSessionId = pmState.pmSessionId;
         const MAX_RESUMED_ROUNDS = 50;
         try {
@@ -650,7 +660,7 @@ ${skillContent.slice(0, 15000)}`;
                 console.log(`[Daemon] Resumed PM chat round ${round + 1}: ${userMessage.substring(0, 80)}${inputFiles?.length ? ` (+${inputFiles.length} images)` : ''}`);
                 const streamMsgId = `pm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
                 let firstChunkIso = '';
-                const chatResult = await chatWithPM(pmSessionId, pmState.repoPath, userMessage, currentTaskAbort.signal, (chunk) => {
+                const chatResult = await chatWithPM(pmSessionId, pmState.repoPath, userMessage, abort.signal, (chunk) => {
                     if (!firstChunkIso)
                         firstChunkIso = new Date().toISOString();
                     wsClient.sendPMStream(taskId, chunk);
@@ -677,7 +687,7 @@ ${skillContent.slice(0, 15000)}`;
                         repoPath: pmState.repoPath,
                         mode: 'tuna',
                     };
-                    const result = await executePlanAndReport(task, plan, wsClient, resolvers, currentTaskAbort.signal);
+                    const result = await executePlanAndReport(task, plan, wsClient, resolvers, abort.signal);
                     if (result.status === 'done' && !result.followUpMessage) {
                         const totalDuration = result.sessions.reduce((sum, s) => sum + (s.durationMs ?? 0), 0);
                         wsClient.sendTaskDone(taskId, { result: plan.summary, durationMs: totalDuration });
@@ -711,7 +721,7 @@ ${skillContent.slice(0, 15000)}`;
             }
         }
         catch (err) {
-            if (currentTaskAbort?.signal.aborted) {
+            if (abort.signal.aborted) {
                 console.log(`[Daemon] Resumed PM chat cancelled for task ${taskId}`);
             }
             else {
@@ -721,8 +731,11 @@ ${skillContent.slice(0, 15000)}`;
         }
         finally {
             activeTasks--;
-            currentTaskId = null;
-            currentTaskAbort = null;
+            taskAbortControllers.delete(taskId);
+            if (currentTaskId === taskId) {
+                currentTaskId = null;
+                currentTaskAbort = null;
+            }
             resolvers.delete(taskId);
             cleanupAttachments(taskId);
             wsClient.send({ action: 'agent_ready' });
@@ -734,8 +747,10 @@ ${skillContent.slice(0, 15000)}`;
      */
     async function resumeAgentTeamChat(taskId, firstMessage, firstAttachments, savedState, wsClient, resolvers) {
         activeTasks++;
+        const abort = new AbortController();
+        taskAbortControllers.set(taskId, abort);
         currentTaskId = taskId;
-        currentTaskAbort = new AbortController();
+        currentTaskAbort = abort;
         let sessionId = savedState.agentTeamSessionId;
         let totalDurationMs = 0;
         try {
@@ -770,7 +785,7 @@ ${skillContent.slice(0, 15000)}`;
                     agentTeam: true,
                     maxTurns: 50,
                     resumeSessionId: sessionId,
-                    signal: currentTaskAbort.signal,
+                    signal: abort.signal,
                     inputFiles: currentInputFiles,
                     onStreamLine: (data) => {
                         if (data.type === 'stream_event') {
@@ -884,7 +899,7 @@ ${skillContent.slice(0, 15000)}`;
             });
         }
         catch (err) {
-            if (currentTaskAbort?.signal.aborted) {
+            if (abort.signal.aborted) {
                 console.log(`[Daemon] Resumed agent_team cancelled for task ${taskId}`);
             }
             else {
@@ -894,8 +909,11 @@ ${skillContent.slice(0, 15000)}`;
         }
         finally {
             activeTasks--;
-            currentTaskId = null;
-            currentTaskAbort = null;
+            taskAbortControllers.delete(taskId);
+            if (currentTaskId === taskId) {
+                currentTaskId = null;
+                currentTaskAbort = null;
+            }
             resolvers.delete(taskId);
             cleanupAttachments(taskId);
             wsClient.send({ action: 'agent_ready' });

package/package.json

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