tuna-agent 0.1.40 → 0.1.42

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() });

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.42",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"