clawmatrix 0.4.1 → 0.5.0

package/src/handoff.ts

@@ -1,6 +1,8 @@
 import type { PeerManager } from "./peer-manager.ts";
 import type { ClawMatrixConfig } from "./config.ts";
 import type { GatewayInfo } from "./tool-proxy.ts";
+import type { Store } from "./store.ts";
+import type { LogReplicator } from "./log-replication.ts";
 import type {
   HandoffRequest,
   HandoffResponse,
@@ -12,6 +14,7 @@ import type {
   HandoffInput,
   HandoffStatus,
 } from "./types.ts";
+import { nanoid } from "nanoid";
 import { TaskActivityBroadcaster } from "./task-activity.ts";
 
 const DEFAULT_HANDOFF_TIMEOUT = 600_000; // 10 minutes (resets on each stream chunk)
@@ -30,6 +33,7 @@ interface PendingHandoff {
   context?: string;
   accumulated: string;
   onStream?: (delta: string) => void;
+  excludeNodes: Set<string>;
 }
 
 interface ActiveHandoff {
@@ -51,6 +55,10 @@ export class HandoffManager {
   private inputRequiredTargets = new Map<string, string>(); // handoffId → targetNodeId
   private staleCleanupTimer: ReturnType<typeof setInterval> | null = null;
   private taskActivity: TaskActivityBroadcaster;
+  /** Optional SQLite store for handoff history persistence. */
+  store: Store | null = null;
+  /** Optional log replicator for cross-node sync. */
+  logReplicator: LogReplicator | null = null;
   // Multi-device sync: track which nodes are watching each handoff session (by sessionId)
   private sessionWatchers = new Map<string, Set<string>>();
 
@@ -92,6 +100,27 @@ export class HandoffManager {
     watchers.add(nodeId);
   }
 
+  /** Record a completed/failed handoff to SQLite for history tracking. */
+  private recordHistory(taskId: string, from: string, agent: string, startedAt: number, status: string, error?: string) {
+    if (!this.store) return;
+    try {
+      this.store.insertHandoff({
+        nodeId: this.config.nodeId,
+        ts: Date.now(),
+        taskId,
+        fromNode: from,
+        toNode: this.config.nodeId,
+        agent,
+        duration: Date.now() - startedAt,
+        status,
+        error,
+      });
+      this.logReplicator?.notifyLocalInsert("handoff_history");
+    } catch {
+      // Non-fatal
+    }
+  }
+
   /** Send a handoff frame to all session watchers except the specified node. */
   private sendToOtherWatchers(sessionId: string, exclude: string, frame: HandoffStreamChunk | HandoffResponse | HandoffInputRequired) {
     const watchers = this.sessionWatchers.get(sessionId);
@@ -148,7 +177,7 @@ export class HandoffManager {
   ): Promise<HandoffResponse["payload"]> {
     if (options?.nodeId) {
       // Direct node targeting (e.g. from web UI) — skip router resolution
-      return this.sendHandoff(options.nodeId, target, task, context, 0, options.onStream);
+      return this.sendHandoff(options.nodeId, target, task, context, 0, options.onStream, new Set());
     }
 
     const route = this.peerManager.router.resolveAgent(target);
@@ -160,7 +189,7 @@ export class HandoffManager {
       throw new Error(`Target "${target}" resolves to self (${this.config.nodeId}). Cannot handoff to own node.`);
     }
 
-    return this.sendHandoff(route.nodeId, target, task, context, MAX_RETRIES, options?.onStream);
+    return this.sendHandoff(route.nodeId, target, task, context, MAX_RETRIES, options?.onStream, new Set());
   }
 
   private sendHandoff(
@@ -170,13 +199,14 @@ export class HandoffManager {
     context: string | undefined,
     retriesLeft: number,
     onStream?: (delta: string) => void,
+    excludeNodes: Set<string> = new Set(),
   ): Promise<HandoffResponse["payload"]> {
-    const id = crypto.randomUUID();
+    const id = nanoid();
 
     return new Promise<HandoffResponse["payload"]>((resolve, reject) => {
-      const timer = this.createTimeout(id, targetNodeId, target, task, context, retriesLeft, resolve, reject, onStream);
+      const timer = this.createTimeout(id, targetNodeId, target, task, context, retriesLeft, resolve, reject, onStream, excludeNodes);
 
-      this.pending.set(id, { resolve, reject, timer, target, targetNodeId, retriesLeft, task, context, accumulated: "", onStream });
+      this.pending.set(id, { resolve, reject, timer, target, targetNodeId, retriesLeft, task, context, accumulated: "", onStream, excludeNodes });
 
       const frame: HandoffRequest = {
         type: "handoff_req",
@@ -192,11 +222,12 @@ export class HandoffManager {
         this.pending.delete(id);
         clearTimeout(timer);
 
-        // Retry immediately with another node
+        // Retry immediately with another node, excluding the failed one
         if (retriesLeft > 0) {
-          const nextRoute = this.peerManager.router.resolveAgent(target);
-          if (nextRoute && nextRoute.nodeId !== targetNodeId) {
-            this.sendHandoff(nextRoute.nodeId, target, task, context, retriesLeft - 1, onStream)
+          excludeNodes.add(targetNodeId);
+          const nextRoute = this.peerManager.router.resolveAgent(target, excludeNodes);
+          if (nextRoute) {
+            this.sendHandoff(nextRoute.nodeId, target, task, context, retriesLeft - 1, onStream, excludeNodes)
               .then(resolve)
               .catch(reject);
             return;
@@ -217,16 +248,18 @@ export class HandoffManager {
     resolve: (result: HandoffResponse["payload"]) => void,
     reject: (error: Error) => void,
     onStream?: (delta: string) => void,
+    excludeNodes: Set<string> = new Set(),
   ): ReturnType<typeof setTimeout> {
     return setTimeout(() => {
       this.pending.delete(id);
       this.peerManager.router.markFailed(id);
 
-      // Retry with failover
+      // Retry with failover, excluding the timed-out node
       if (retriesLeft > 0) {
-        const nextRoute = this.peerManager.router.resolveAgent(target);
-        if (nextRoute && nextRoute.nodeId !== targetNodeId) {
-          this.sendHandoff(nextRoute.nodeId, target, task, context, retriesLeft - 1, onStream)
+        excludeNodes.add(targetNodeId);
+        const nextRoute = this.peerManager.router.resolveAgent(target, excludeNodes);
+        if (nextRoute) {
+          this.sendHandoff(nextRoute.nodeId, target, task, context, retriesLeft - 1, onStream, excludeNodes)
             .then(resolve)
             .catch(reject);
           return;
@@ -262,6 +295,7 @@ export class HandoffManager {
       pending.resolve,
       pending.reject,
       pending.onStream,
+      pending.excludeNodes,
     );
   }
 
@@ -310,6 +344,7 @@ export class HandoffManager {
     // avoiding repeated Session Startup (bootstrap file loading).
     const sessionId = payload.sessionId ?? `handoff-${from}`;
     const sessionKey = `agent:${agent.id}:clawmatrix-handoff:${sessionId}`;
+
     const message = payload.context
       ? `${payload.task}\n\nContext:\n${payload.context}`
       : payload.task;
@@ -423,6 +458,9 @@ export class HandoffManager {
       this.active.delete(id);
       this.sessionWatchers.delete(activeEntry.sessionId);
 
+      // Record handoff history
+      this.recordHistory(id, from, agent, activeEntry.startedAt, "completed");
+
       // Broadcast task completed
       this.taskActivity.broadcast(id, "handoff", "completed", agent, activeEntry.startedAt);
 
@@ -452,10 +490,14 @@ export class HandoffManager {
       this.active.delete(id);
       this.sessionWatchers.delete(activeEntry.sessionId);
 
+      // Record handoff history
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      this.recordHistory(id, from, agent, activeEntry.startedAt, "failed", errorMsg);
+
       // Broadcast task failed
       this.taskActivity.broadcast(
         id, "handoff", "failed", agent, activeEntry.startedAt,
-        err instanceof Error ? err.message : String(err),
+        errorMsg,
       );
 
       this.peerManager.sendTo(from, {
@@ -491,6 +533,35 @@ export class HandoffManager {
     // Cache active entry lookup outside the hot loop — stable during the stream
     const activeEntry = this.active.get(handoffId);
 
+    // Stream coalescing: micro-batch deltas to reduce per-frame overhead
+    let pendingDelta = "";
+    const COALESCE_INTERVAL = 10; // ms
+    const COALESCE_MAX_SIZE = 4096; // bytes
+
+    const flush = () => {
+      if (!pendingDelta) return;
+      const delta = pendingDelta;
+      pendingDelta = "";
+      const streamFrame: HandoffStreamChunk = {
+        type: "handoff_stream",
+        id: handoffId,
+        from: this.config.nodeId,
+        to,
+        timestamp: Date.now(),
+        payload: { delta, done: false, sessionId },
+      };
+      this.peerManager.sendTo(to, streamFrame);
+      if (sessionId) this.sendToOtherWatchers(sessionId, to, streamFrame);
+      // Broadcast progress to mobile nodes (throttled inside broadcaster already)
+      if (activeEntry) {
+        this.taskActivity.broadcast(
+          handoffId, "handoff", "progress", activeEntry.agent, activeEntry.startedAt,
+        );
+      }
+    };
+
+    const coalesceTimer = setInterval(flush, COALESCE_INTERVAL);
+
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -510,24 +581,8 @@ export class HandoffManager {
             const delta = parsed.choices?.[0]?.delta?.content;
             if (delta) {
               chunks.push(delta);
-              const streamFrame: HandoffStreamChunk = {
-                type: "handoff_stream",
-                id: handoffId,
-                from: this.config.nodeId,
-                to,
-                timestamp: Date.now(),
-                payload: { delta, done: false, sessionId },
-              };
-              this.peerManager.sendTo(to, streamFrame);
-              if (sessionId) this.sendToOtherWatchers(sessionId, to, streamFrame);
-
-              // Broadcast progress to mobile nodes (throttled, detail is just
-              // a heartbeat — don't send token-level deltas as they're meaningless fragments)
-              if (activeEntry) {
-                this.taskActivity.broadcast(
-                  handoffId, "handoff", "progress", activeEntry.agent, activeEntry.startedAt,
-                );
-              }
+              pendingDelta += delta;
+              if (pendingDelta.length >= COALESCE_MAX_SIZE) flush();
             }
           } catch {
             // skip malformed SSE lines
@@ -535,6 +590,8 @@ export class HandoffManager {
         }
       }
     } finally {
+      clearInterval(coalesceTimer);
+      flush();
       reader.releaseLock();
     }
 
@@ -590,6 +647,7 @@ export class HandoffManager {
         resolve, reject, timer,
         target: "", targetNodeId,
         retriesLeft: 0, task: message, accumulated: "",
+        excludeNodes: new Set(),
       });
 
       this.peerManager.sendTo(targetNodeId, {