tuna-agent 0.1.69 → 0.1.71

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;
@@ -45,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<{

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;
@@ -88,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) {
@@ -360,6 +368,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
@@ -482,7 +491,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++) {
@@ -525,7 +534,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 };
@@ -775,6 +784,7 @@ export class ClaudeCodeAdapter {
                     pmSessionId: planResult.pmSessionId,
                     repoPath: task.repoPath,
                     savedAt: new Date().toISOString(),
+                    agentId: task.agentId,
                 });
             }
             ws.sendTaskDone(task.id, {
@@ -810,22 +820,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 +850,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 +873,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 +912,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

@@ -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,18 +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}]`);
-                // Update MCP config with the task's agent ID so knowledge server uses correct attribution
-                if (task.agentId) {
-                    try {
-                        setupMcpConfig({ ...config, agentId: task.agentId });
-                    }
-                    catch (err) {
-                        console.warn(`[Daemon] MCP config update for task failed (non-fatal):`, err);
-                    }
-                }
                 // Run task in background (non-blocking) to allow parallel agent execution
                 (async () => {
                     try {
@@ -257,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 });
                     }
@@ -442,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);
                         });
@@ -474,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);
@@ -642,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 {
@@ -674,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;
@@ -738,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 });
         }
     }
     /**
@@ -753,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 {
@@ -856,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;
@@ -916,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.69",
+  "version": "0.1.71",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"