tuna-agent 0.1.68 → 0.1.69

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,15 +215,20 @@ 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})`);
+                currentTaskAbort = abort;
+                console.log(`[Daemon] Received task: ${task.id} agent=${agentId} — ${task.description.slice(0, 80)} (attachments: ${task.attachments?.length ?? 0}) [active: ${activeTasks}]`);
                 // Update MCP config with the task's agent ID so knowledge server uses correct attribution
                 if (task.agentId) {
                     try {
@@ -227,35 +238,42 @@ export async function startDaemon(config) {
                         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`);
+                // Run task in background (non-blocking) to allow parallel agent execution
+                (async () => {
+                    try {
+                        await adapter.handleTask(task, ws, pendingInputResolvers, abort.signal, pendingPermissionResolvers);
                     }
-                    else {
-                        ws.sendTaskFailed(task.id, errMsg);
-                        console.error(`[Daemon] Task ${task.id} error:`, errMsg);
+                    catch (err) {
+                        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);
+                        }
                     }
-                }
-                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' });
-                }
+                    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 });
+                    }
+                })();
                 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 +473,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 +483,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 +643,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 +667,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 +694,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 +728,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 +738,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 +754,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 +792,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 +906,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 +916,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.69",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"