tuna-agent 0.1.28 → 0.1.30

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

@@ -1,13 +1,28 @@
 import type { AgentAdapter, AgentType } from './types.js';
 import type { AgentConfig, TaskAssignment, InputResponse } from '../types/index.js';
 import type { AgentWebSocketClient } from '../daemon/ws-client.js';
+export interface AgentMetrics {
+    taskCount: number;
+    successCount: number;
+    failCount: number;
+    totalDurationMs: number;
+    avgDurationMs: number;
+    reflectionCount: number;
+    reflectionSkipCount: number;
+    patternsLearnedCount: number;
+    lastTaskAt: string | null;
+    upSince: string;
+}
 export declare class ClaudeCodeAdapter implements AgentAdapter {
     readonly type: AgentType;
     readonly displayName = "Claude Code";
     private readonly agentConfig;
     private taskCount;
     private static readonly PATTERN_CHECK_INTERVAL;
+    private metrics;
     constructor(config: AgentConfig);
+    /** Get current agent metrics snapshot. */
+    getMetrics(): Record<string, unknown>;
     checkHealth(): Promise<{
         ok: boolean;
         message: string;
@@ -33,5 +48,7 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
      * Runs every N tasks to evolve the agent's permanent knowledge.
      */
     runSelfImprovement(cwd: string): Promise<void>;
+    /** Track task completion metrics. */
+    private trackMetrics;
     dispose(): Promise<void>;
 }

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

@@ -14,9 +14,26 @@ 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,
+        patternsLearnedCount: 0,
+        lastTaskAt: null,
+        upSince: new Date().toISOString(),
+    };
     constructor(config) {
         this.agentConfig = config;
     }
+    /** Get current agent metrics snapshot. */
+    getMetrics() {
+        return { ...this.metrics };
+    }
     async checkHealth() {
         try {
             execSync('which claude', { stdio: 'ignore' });
@@ -202,6 +219,7 @@ export class ClaudeCodeAdapter {
                             startedAt: firstChunkIso || undefined,
                         });
                         ws.sendTaskFailed(task.id, result.result);
+                        this.trackMetrics('failed', totalDurationMs);
                         console.log(`[ClaudeCode] Agent Team task ${task.id} failed in round ${round + 1}`);
                         this.runReflection(task, result.result, 'failed', cwd).catch(() => { });
                         return;
@@ -256,6 +274,12 @@ export class ClaudeCodeAdapter {
                         if (err instanceof Error && err.message === '__FOLLOW_UP_TIMEOUT__') {
                             console.log(`[ClaudeCode] No follow-up after ${FOLLOW_UP_TIMEOUT_MS / 1000}s — closing task`);
                             pendingInputResolvers.delete(task.id);
+                            ws.sendTaskDone(task.id, {
+                                result: 'Agent Team task completed',
+                                durationMs: totalDurationMs,
+                                sessionId,
+                            });
+                            this.trackMetrics('done', totalDurationMs);
                             const timeoutOutput = lastTaskOutput || 'Task completed (no follow-up)';
                             this.runReflection(task, timeoutOutput, 'done', task.repoPath)
                                 .then(() => this.runSelfImprovement(task.repoPath))
@@ -289,6 +313,7 @@ export class ClaudeCodeAdapter {
                 });
                 await new Promise(resolve => setTimeout(resolve, 150));
                 ws.sendPMMessage(task.id, { sender: 'pm', content: 'Task completed.' });
+                this.trackMetrics('done', totalDurationMs);
                 console.log(`[ClaudeCode] Agent Team task ${task.id} completed (${(totalDurationMs / 1000).toFixed(1)}s)`);
                 // Post-task reflection with actual output (non-blocking)
                 this.runReflection(task, lastTaskOutput || 'Task completed without text output', 'done', task.repoPath)
@@ -690,12 +715,14 @@ export class ClaudeCodeAdapter {
             const { callMem0Reflect, callMem0AddMemory } = await import('../mcp/setup.js');
             const aiReflection = await callMem0Reflect(task.description, resultSummary, status);
             if (!aiReflection) {
+                this.metrics.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.agentConfig.name);
+            this.metrics.reflectionCount++;
             console.log(`[Reflection] Stored for task ${task.id}`);
         }
         catch (err) {
@@ -783,6 +810,7 @@ export class ClaudeCodeAdapter {
                 const separator = existingContent.endsWith('\n') ? '\n' : '\n\n';
                 fs.writeFileSync(claudeMdPath, existingContent + separator + `${SECTION_HEADER}\n${rulesBlock}\n`);
             }
+            this.metrics.patternsLearnedCount += newPatterns.length;
             console.log(`[Self-Improve] Added ${newPatterns.length} new rules to CLAUDE.md:`);
             newPatterns.forEach(p => console.log(`[Self-Improve]   - ${p.rule}`));
         }
@@ -790,6 +818,18 @@ export class ClaudeCodeAdapter {
             console.warn(`[Self-Improve] Failed:`, err instanceof Error ? err.message : err);
         }
     }
+    /** Track task completion metrics. */
+    trackMetrics(status, durationMs) {
+        this.metrics.taskCount++;
+        if (status === 'done')
+            this.metrics.successCount++;
+        else
+            this.metrics.failCount++;
+        this.metrics.totalDurationMs += durationMs;
+        this.metrics.avgDurationMs = Math.round(this.metrics.totalDurationMs / this.metrics.taskCount);
+        this.metrics.lastTaskAt = new Date().toISOString();
+        console.log(`[Metrics] Tasks: ${this.metrics.successCount}✓ ${this.metrics.failCount}✗ | Avg: ${(this.metrics.avgDurationMs / 1000).toFixed(0)}s | Reflections: ${this.metrics.reflectionCount} | Patterns: ${this.metrics.patternsLearnedCount}`);
+    }
     async dispose() {
         // No persistent resources to clean up
     }

package/dist/agents/types.d.ts

@@ -24,6 +24,10 @@ export interface AgentAdapter {
      * plan → execute → report progress/results via ws.
      */
     handleTask(task: TaskAssignment, ws: AgentWebSocketClient, pendingInputResolvers: Map<string, (response: InputResponse) => void>, signal?: AbortSignal, pendingPermissionResolvers?: Map<string, (approved: boolean) => void>): Promise<void>;
+    /**
+     * Get current agent performance metrics.
+     */
+    getMetrics?(): Record<string, unknown>;
     /**
      * Clean up resources on shutdown.
      */

package/dist/daemon/index.js

@@ -750,6 +750,10 @@ ${skillContent.slice(0, 15000)}`;
             wsClient.send({ action: 'agent_ready' });
         }
     }
+    // Wire up agent metrics to heartbeat
+    if (adapter.getMetrics) {
+        ws.setMetricsProvider(() => adapter.getMetrics());
+    }
     ws.connect();
     const shutdown = () => {
         console.log('\n[Daemon] Shutting down...');

package/dist/daemon/ws-client.d.ts

@@ -10,11 +10,14 @@ export declare class AgentWebSocketClient {
     private running;
     private onMessage;
     private onAuthFailed?;
+    private getAgentMetrics?;
     /** Pending flow command callbacks keyed by request ID */
     private _flowCallbacks;
     constructor(config: AgentConfig, onMessage: MessageHandler, onAuthFailed?: (code: number, reason: string) => void);
     connect(): void;
     disconnect(): void;
+    /** Register a callback to get agent metrics for heartbeat. */
+    setMetricsProvider(fn: () => Record<string, unknown>): void;
     /**
      * Send a message to the API server.
      */

package/dist/daemon/ws-client.js

@@ -15,6 +15,7 @@ export class AgentWebSocketClient {
     running = false;
     onMessage;
     onAuthFailed;
+    getAgentMetrics;
     /** Pending flow command callbacks keyed by request ID */
     _flowCallbacks = new Map();
     constructor(config, onMessage, onAuthFailed) {
@@ -41,6 +42,10 @@ export class AgentWebSocketClient {
             this.ws = null;
         }
     }
+    /** Register a callback to get agent metrics for heartbeat. */
+    setMetricsProvider(fn) {
+        this.getAgentMetrics = fn;
+    }
     /**
      * Send a message to the API server.
      */
@@ -273,11 +278,15 @@ export class AgentWebSocketClient {
         this._stopHeartbeat();
         this.heartbeatTimer = setInterval(() => {
             const agentType = this.config.agentType || 'claude-code';
-            this.send({
+            const heartbeat = {
                 action: 'heartbeat',
                 system_load: getSystemLoad(),
                 capabilities: detectCapabilities(agentType),
-            });
+            };
+            if (this.getAgentMetrics) {
+                heartbeat.agent_metrics = this.getAgentMetrics();
+            }
+            this.send(heartbeat);
         }, 30000);
     }
     _stopHeartbeat() {

package/package.json

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