tuna-agent 0.1.175 → 0.1.177

package/dist/daemon/index.js

@@ -132,15 +132,15 @@ export async function startDaemon(config) {
         console.log(`[Daemon] Agent ready: ${adapter.displayName} (${health.message})`);
     }
     let activeTasks = 0;
-    const MAX_CONCURRENT_PER_AGENT = 1; // Each agent can run 1 task at a time
+    // Concurrency is capped machine-wide, NOT per agent — multiple claude sessions in
+    // the same agent folder are fine (subtasks already run in parallel there). A single
+    // waiting/slow session no longer blocks other sessions.
+    const MAX_CONCURRENT = 5;
     const pendingInputResolvers = new Map();
     const pendingPermissionResolvers = new Map();
-    // Track active tasks per agent (agentId → taskId)
-    const activeAgentTasks = new Map();
     const agentQueues = new Map();
     // Track abort controllers per task
     const taskAbortControllers = new Map();
-    // 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.');
@@ -219,18 +219,18 @@ export async function startDaemon(config) {
                 if (task.repoPath?.startsWith('~/')) {
                     task.repoPath = path.join(os.homedir(), task.repoPath.slice(2));
                 }
-                // Per-agent concurrency: if busy, queue instead of rejecting.
                 const agentId = task.agentId || '__default__';
-                // Dedup: the API sweep re-dispatches queued tasks every 30s. Without this,
-                // a task sent repeatedly while the agent is busy piles up as duplicates in
-                // the queue (and would run N times). Ignore if already running or queued.
-                const alreadyRunning = Array.from(activeAgentTasks.values()).includes(task.id);
+                // Dedup: the API sweep re-dispatches queued tasks every 30s. Ignore if this
+                // task is already running (has an abort controller) or already queued.
+                const alreadyRunning = taskAbortControllers.has(task.id);
                 const alreadyQueued = (agentQueues.get(agentId) || []).some((it) => it.kind === 'task' && it.task.id === task.id);
                 if (alreadyRunning || alreadyQueued) {
                     console.log(`[Daemon] Task ${task.id} already running/queued — ignoring duplicate dispatch`);
                     break;
                 }
-                if (activeAgentTasks.has(agentId)) {
+                // Concurrency cap is machine-wide (not per agent). Only queue when the whole
+                // machine is saturated — otherwise run concurrently.
+                if (activeTasks >= MAX_CONCURRENT) {
                     enqueueForAgent(agentId, { kind: 'task', task });
                     break;
                 }
@@ -461,15 +461,14 @@ ${skillContent.slice(0, 15000)}`;
                     // No resolver — check if we have a persisted session to resume
                     const savedState = loadPMState(taskId);
                     if (savedState) {
-                        // Per-agent concurrency: if busy, queue the reply instead of dropping it.
                         const resumeAgentId = savedState.agentId || '__default__';
-                        if (activeAgentTasks.has(resumeAgentId)) {
-                            const busyTask = activeAgentTasks.get(resumeAgentId);
-                            console.log(`[Daemon] Agent ${resumeAgentId} busy with ${busyTask} — queuing reply for task ${taskId}`);
+                        // Only queue when the machine is saturated — otherwise resume concurrently.
+                        if (activeTasks >= MAX_CONCURRENT) {
+                            console.log(`[Daemon] Machine at capacity (${activeTasks}) — queuing reply for task ${taskId}`);
                             enqueueForAgent(resumeAgentId, { kind: 'input', taskId, answer, attachments, savedState });
                             ws.sendPMMessage(taskId, {
                                 sender: 'pm',
-                                content: '⏳ Đang xử lý việc khác, sẽ trả lời ngay khi xong.',
+                                content: '⏳ Nhiều việc quá, em xử lý xong việc đang làm rồi quay lại ngay nha anh.',
                             });
                             break;
                         }
@@ -685,30 +684,30 @@ ${skillContent.slice(0, 15000)}`;
         q.push(item);
         console.log(`[Daemon] Agent ${agentId} busy — queued ${item.kind} (queue: ${q.length})`);
     }
-    /** Start the next queued item for an agent, if any and the agent is free. */
-    function processNextForAgent(agentId) {
-        if (activeAgentTasks.has(agentId))
-            return; // still busy
-        const q = agentQueues.get(agentId);
-        if (!q || q.length === 0)
-            return;
-        const item = q.shift();
-        console.log(`[Daemon] Dequeue ${item.kind} for agent ${agentId} (remaining: ${q.length})`);
-        if (item.kind === 'task') {
-            runTaskNow(item.task);
-        }
-        else if (item.savedState.mode === 'agent_team') {
-            resumeAgentTeamChat(item.taskId, item.answer, item.attachments, item.savedState, ws, pendingInputResolvers);
-        }
-        else {
-            resumePMChat(item.taskId, item.answer, item.attachments, item.savedState, ws, pendingInputResolvers);
+    /** Drain queued work (any agent) while below the machine-wide concurrency cap. */
+    function drainQueues() {
+        for (const [, q] of agentQueues) {
+            while (q.length && activeTasks < MAX_CONCURRENT) {
+                const item = q.shift();
+                console.log(`[Daemon] Dequeue ${item.kind} (remaining: ${q.length})`);
+                if (item.kind === 'task') {
+                    runTaskNow(item.task);
+                }
+                else if (item.savedState.mode === 'agent_team') {
+                    resumeAgentTeamChat(item.taskId, item.answer, item.attachments, item.savedState, ws, pendingInputResolvers);
+                }
+                else {
+                    resumePMChat(item.taskId, item.answer, item.attachments, item.savedState, ws, pendingInputResolvers);
+                }
+            }
+            if (activeTasks >= MAX_CONCURRENT)
+                break;
         }
     }
-    /** Run a task immediately (agent assumed free). Drains the queue when done. */
+    /** Run a task now. Drains the queue when it finishes. */
     function runTaskNow(task) {
         const agentId = task.agentId || '__default__';
         activeTasks++;
-        activeAgentTasks.set(agentId, task.id);
         const abort = new AbortController();
         taskAbortControllers.set(task.id, abort);
         console.log(`[Daemon] Received task: ${task.id} agent=${agentId} — ${task.description.slice(0, 80)} (attachments: ${task.attachments?.length ?? 0}) [active: ${activeTasks}]`);
@@ -728,11 +727,10 @@ ${skillContent.slice(0, 15000)}`;
             }
             finally {
                 activeTasks--;
-                activeAgentTasks.delete(agentId);
                 taskAbortControllers.delete(task.id);
                 pendingInputResolvers.delete(task.id);
                 ws.send({ action: 'agent_ready', agentId });
-                processNextForAgent(agentId);
+                drainQueues();
             }
         })();
     }
@@ -743,7 +741,6 @@ ${skillContent.slice(0, 15000)}`;
     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);
         let pmSessionId = pmState.pmSessionId;
@@ -837,12 +834,11 @@ ${skillContent.slice(0, 15000)}`;
         }
         finally {
             activeTasks--;
-            activeAgentTasks.delete(agentId);
             taskAbortControllers.delete(taskId);
             resolvers.delete(taskId);
             cleanupAttachments(taskId);
             wsClient.send({ action: 'agent_ready', agentId });
-            processNextForAgent(agentId);
+            drainQueues();
         }
     }
     /**
@@ -852,7 +848,6 @@ ${skillContent.slice(0, 15000)}`;
     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);
         let sessionId = savedState.agentTeamSessionId;
@@ -1084,12 +1079,11 @@ ${skillContent.slice(0, 15000)}`;
         }
         finally {
             activeTasks--;
-            activeAgentTasks.delete(agentId);
             taskAbortControllers.delete(taskId);
             resolvers.delete(taskId);
             cleanupAttachments(taskId);
             wsClient.send({ action: 'agent_ready', agentId });
-            processNextForAgent(agentId);
+            drainQueues();
         }
     }
     // Wire up agent metrics to heartbeat

package/dist/utils/execution-helpers.js

@@ -156,6 +156,12 @@ export async function executePlanAndReport(task, plan, ws, resolvers, signal, co
     if (status === 'waiting_input') {
         return { sessions, status };
     }
+    // Single 'self' task: the result was already delivered by onSubtaskDone (in the
+    // agent's own voice). Complete directly — no robotic "All sessions completed /
+    // continue?" wrapper. Follow-up happens naturally via a thread reply.
+    if (plan.subtasks.length <= 1) {
+        return { sessions, status };
+    }
     const totalDuration = sessions.reduce((sum, s) => sum + (s.durationMs ?? 0), 0);
     const durationStr = (totalDuration / 1000).toFixed(1);
     // Announce result

package/package.json

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