tuna-agent 0.1.40 → 0.1.43

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

@@ -24,9 +24,12 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     private readonly agentConfig;
     private taskCount;
     private static readonly PATTERN_CHECK_INTERVAL;
-    private metrics;
+    private metricsMap;
+    private currentAgentId;
+    /** Returns metrics for the currently active agent, initializing if needed. */
+    private get metrics();
     constructor(config: AgentConfig);
-    /** Get current agent metrics snapshot. */
+    /** Get all per-agent metrics for heartbeat. */
     getMetrics(): Record<string, unknown>;
     checkHealth(): Promise<{
         ok: boolean;

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

@@ -14,30 +14,42 @@ export class ClaudeCodeAdapter {
     agentConfig;
     taskCount = 0;
     static PATTERN_CHECK_INTERVAL = 5; // Check patterns every N tasks
-    // Agent performance metrics
-    metrics = {
-        taskCount: 0,
-        successCount: 0,
-        failCount: 0,
-        totalDurationMs: 0,
-        avgDurationMs: 0,
-        reflectionCount: 0,
-        reflectionSkipCount: 0,
-        memoryCount: 0,
-        patternsLearnedCount: 0,
-        rulesCount: 0,
-        lastTaskAt: null,
-        lastReflectionAt: null,
-        lastPatternAt: null,
-        latestLearnedRule: null,
-        upSince: new Date().toISOString(),
-    };
+    // Per-agent metrics keyed by agentId (one daemon can handle multiple agents)
+    metricsMap = new Map();
+    currentAgentId = '';
+    /** Returns metrics for the currently active agent, initializing if needed. */
+    get metrics() {
+        if (!this.metricsMap.has(this.currentAgentId)) {
+            this.metricsMap.set(this.currentAgentId, {
+                taskCount: 0,
+                successCount: 0,
+                failCount: 0,
+                totalDurationMs: 0,
+                avgDurationMs: 0,
+                reflectionCount: 0,
+                reflectionSkipCount: 0,
+                memoryCount: 0,
+                patternsLearnedCount: 0,
+                rulesCount: 0,
+                lastTaskAt: null,
+                lastReflectionAt: null,
+                lastPatternAt: null,
+                latestLearnedRule: null,
+                upSince: new Date().toISOString(),
+            });
+        }
+        return this.metricsMap.get(this.currentAgentId);
+    }
     constructor(config) {
         this.agentConfig = config;
     }
-    /** Get current agent metrics snapshot. */
+    /** Get all per-agent metrics for heartbeat. */
     getMetrics() {
-        return { ...this.metrics };
+        const agentMetricsMap = {};
+        this.metricsMap.forEach((m, agentId) => {
+            agentMetricsMap[agentId] = { ...m };
+        });
+        return { agentMetricsMap };
     }
     async checkHealth() {
         try {
@@ -73,6 +85,8 @@ 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 for per-agent metrics tracking
+        this.currentAgentId = task.agentId || '';
         if (task.mode !== 'tuna') {
             console.log(`[ClaudeCode] Agent Team mode — direct chat with Claude CLI`);
             ws.sendProgress(task.id, 'executing', { startedAt: new Date().toISOString() });
@@ -93,10 +107,12 @@ export class ClaudeCodeAdapter {
                 }
             }
             // Pre-task Memory Recall: search Mem0 for relevant past learnings
+            const defaultWorkspaceForRecall = path.join(os.homedir(), 'tuna-workspace');
+            const recallAgentName = path.basename(task.repoPath || defaultWorkspaceForRecall);
             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.agentConfig.name, 5);
+                    const memories = await callMem0SearchMemory(task.description, recallAgentName, 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>`;
@@ -733,8 +749,9 @@ export class ClaudeCodeAdapter {
                 return;
             }
             // Step 2: Store the AI-generated reflection in Mem0
+            const agentFolderNameForReflection = path.basename(cwd);
             console.log(`[Reflection] Storing: "${aiReflection.substring(0, 100)}..."`);
-            await callMem0AddMemory(aiReflection, this.agentConfig.name);
+            await callMem0AddMemory(aiReflection, agentFolderNameForReflection);
             this.metrics.reflectionCount++;
             this.metrics.memoryCount++;
             this.metrics.lastReflectionAt = new Date().toISOString();
@@ -748,7 +765,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.agentConfig.name);
+                await callMem0AddMemory(fallback, path.basename(cwd));
             }
             catch {
                 // Both AI and fallback failed — give up silently
@@ -771,7 +788,7 @@ 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.agentConfig.name);
+            await callMem0AddMemory(memoryText, path.basename(data.cwd));
             console.log(`[Rating→Mem0] Rating stored successfully`);
         }
         catch (err) {
@@ -791,7 +808,7 @@ 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.agentConfig.name, 3);
+            const patterns = await callMem0Patterns(path.basename(cwd), 3);
             if (patterns.length === 0) {
                 console.log(`[Self-Improve] No patterns detected yet`);
                 return;

package/dist/daemon/index.d.ts

@@ -1,6 +1,2 @@
 import type { AgentConfig } from '../types/index.js';
-/**
- * Start the agent daemon.
- * Connects to API via WebSocket, receives tasks, delegates to agent adapter.
- */
 export declare function startDaemon(config: AgentConfig): Promise<void>;

package/dist/daemon/index.js

@@ -17,6 +17,18 @@ import { setupMcpConfig } from '../mcp/setup.js';
  * Start the agent daemon.
  * Connects to API via WebSocket, receives tasks, delegates to agent adapter.
  */
+// Load persisted Mem0 config into process.env before any dynamic imports read it
+(function loadMem0FromConfig() {
+    const saved = loadConfig();
+    if (!saved)
+        return;
+    if (saved.mem0SshHost && !process.env.MEM0_SSH_HOST)
+        process.env.MEM0_SSH_HOST = saved.mem0SshHost;
+    if (saved.mem0SshPort && !process.env.MEM0_SSH_PORT)
+        process.env.MEM0_SSH_PORT = saved.mem0SshPort;
+    if (saved.mem0HttpBase && !process.env.MEM0_HTTP_BASE)
+        process.env.MEM0_HTTP_BASE = saved.mem0HttpBase;
+})();
 export async function startDaemon(config) {
     // Create agent adapter based on config
     const agentConfig = {
@@ -67,6 +79,33 @@ export async function startDaemon(config) {
         switch (type) {
             case 'connected':
                 console.log(`[Daemon] Connected as "${msg.name}" (${msg.agentId})`);
+                // Persist Mem0 config pushed from server so it survives daemon restarts
+                if (msg.mem0Config && typeof msg.mem0Config === 'object') {
+                    const m = msg.mem0Config;
+                    const current = loadConfig();
+                    if (current) {
+                        let changed = false;
+                        if (m.sshHost) {
+                            current.mem0SshHost = m.sshHost;
+                            process.env.MEM0_SSH_HOST = m.sshHost;
+                            changed = true;
+                        }
+                        if (m.sshPort) {
+                            current.mem0SshPort = m.sshPort;
+                            process.env.MEM0_SSH_PORT = m.sshPort;
+                            changed = true;
+                        }
+                        if (m.httpBase) {
+                            current.mem0HttpBase = m.httpBase;
+                            process.env.MEM0_HTTP_BASE = m.httpBase;
+                            changed = true;
+                        }
+                        if (changed) {
+                            saveConfig(current);
+                            console.log('[Daemon] Mem0 config saved from server');
+                        }
+                    }
+                }
                 // 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 });
                 break;

package/dist/types/index.d.ts

@@ -11,6 +11,9 @@ export interface AgentConfig {
         openclawGatewayUrl?: string;
     };
     extensionCodes?: string[];
+    mem0SshHost?: string;
+    mem0SshPort?: string;
+    mem0HttpBase?: string;
 }
 export interface AgentCapabilities {
     supports_teams: boolean;

package/package.json

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