clawmatrix 0.2.11 → 0.4.0

package/src/handoff.ts

@@ -54,16 +54,33 @@ export class HandoffManager {
   // Multi-device sync: track which nodes are watching each handoff session (by sessionId)
   private sessionWatchers = new Map<string, Set<string>>();
 
+  // Pre-built indexes for O(1) agent lookup
+  private agentById = new Map<string, ClawMatrixConfig["agents"][number]>();
+  private agentsByTag = new Map<string, ClawMatrixConfig["agents"][number]>();
+
   constructor(config: ClawMatrixConfig, peerManager: PeerManager, gatewayInfo: GatewayInfo) {
     this.config = config;
     this.peerManager = peerManager;
     this.gatewayInfo = gatewayInfo;
     this.taskActivity = new TaskActivityBroadcaster(config, peerManager);
 
+    // Build agent indexes
+    for (const a of config.agents) {
+      this.agentById.set(a.id, a);
+      for (const t of a.tags) this.agentsByTag.set(t, a);
+    }
+
     // Periodically clean up stale input_required entries
     this.staleCleanupTimer = setInterval(() => this.cleanupStale(), STALE_CLEANUP_INTERVAL);
   }
 
+  private findLocalAgent(target: string): ClawMatrixConfig["agents"][number] | undefined {
+    if (target.startsWith("tags:")) {
+      return this.agentsByTag.get(target.slice(5));
+    }
+    return this.agentById.get(target);
+  }
+
   // ── Multi-device sync helpers ──────────────────────────────────
 
   private addSessionWatcher(sessionId: string, nodeId: string) {
@@ -271,13 +288,7 @@ export class HandoffManager {
     const { id, from, payload } = frame;
 
     // Find matching local agent
-    const agent = this.config.agents.find((a) => {
-      if (payload.target.startsWith("tags:")) {
-        const tag = payload.target.slice(5);
-        return a.tags.includes(tag);
-      }
-      return a.id === payload.target;
-    });
+    const agent = this.findLocalAgent(payload.target);
 
     if (!agent) {
       this.peerManager.sendTo(from, {
@@ -477,6 +488,8 @@ export class HandoffManager {
     const decoder = new TextDecoder();
     const chunks: string[] = [];
     let buffer = "";
+    // Cache active entry lookup outside the hot loop — stable during the stream
+    const activeEntry = this.active.get(handoffId);
 
     try {
       while (true) {
@@ -510,7 +523,6 @@ export class HandoffManager {
 
               // Broadcast progress to mobile nodes (throttled, detail is just
               // a heartbeat — don't send token-level deltas as they're meaningless fragments)
-              const activeEntry = this.active.get(handoffId);
               if (activeEntry) {
                 this.taskActivity.broadcast(
                   handoffId, "handoff", "progress", activeEntry.agent, activeEntry.startedAt,
@@ -605,6 +617,7 @@ export class HandoffManager {
 
     // If canceled during input_required, no runAgentTurn is running to clean up
     if (wasInputRequired) {
+      this.sessionWatchers.delete(entry.sessionId);
       this.active.delete(frame.id);
     }
 

package/src/health-tracker.ts

@@ -257,9 +257,18 @@ export class HealthTracker {
     // Build timeline for each node (including self)
     const nodes: NodeTimeline[] = [];
 
+    // Collect nodeIds that have ever had peer_online events (actually connected)
+    const everConnected = new Set<string>();
+    for (const [, entry] of Object.entries(this.doc.nodes)) {
+      for (const ev of entry.events) {
+        if (ev.type === "peer_online" && ev.peer) everConnected.add(ev.peer);
+      }
+    }
+
     for (const [nodeId, entry] of Object.entries(this.doc.nodes)) {
-      // For self, use start/stop events to determine uptime
-      // For other nodes, use peer_online/peer_offline from the observing node
+      // Remote nodes: must have successfully connected at some point
+      if (nodeId !== this.nodeId && !everConnected.has(nodeId)) continue;
+
       const timeline = this.buildNodeTimeline(
         nodeId,
         entry,
@@ -269,7 +278,10 @@ export class HealthTracker {
         bucketCount,
         gaps,
       );
-      if (timeline) nodes.push(timeline);
+      if (!timeline) continue;
+      // Hide remote nodes that were offline for the entire requested range
+      if (nodeId !== this.nodeId && timeline.uptimeRatio === 0) continue;
+      nodes.push(timeline);
     }
 
     return {
@@ -345,19 +357,36 @@ export class HealthTracker {
     startTs: number,
     endTs: number,
   ): Array<[number, number]> {
-    const intervals: Array<[number, number]> = [];
-
     if (nodeId === this.nodeId) {
       // Self: start/stop events define uptime
-      // But we're looking at all nodes' data, so check if this nodeId
-      // has start/stop events (each node writes its own start/stop)
       return this.buildSelfIntervals(events, startTs, endTs);
     }
 
-    // For remote nodes: gather peer_online/peer_offline events from all observer nodes
-    // We have the CRDT doc with all nodes' events merged
-    // Look through ALL nodes' events for peer_online/peer_offline referencing this nodeId
-    return this.buildPeerIntervals(nodeId, startTs, endTs);
+    // For remote nodes: use BOTH self-reported start/stop intervals AND
+    // peer_online/peer_offline observations, then merge for best accuracy.
+    // Self-reported intervals are the primary signal (the node knows when
+    // it was running); peer observations supplement for relay peers or
+    // when CRDT sync hasn't propagated the remote node's own events.
+    const selfIntervals = this.buildSelfIntervals(events, startTs, endTs);
+    const peerIntervals = this.buildPeerIntervals(nodeId, startTs, endTs);
+    return this.mergeIntervals([...selfIntervals, ...peerIntervals]);
+  }
+
+  /** Merge overlapping intervals into a sorted, non-overlapping set. */
+  private mergeIntervals(intervals: Array<[number, number]>): Array<[number, number]> {
+    if (intervals.length <= 1) return intervals;
+    intervals.sort((a, b) => a[0] - b[0]);
+    const merged: Array<[number, number]> = [intervals[0]!];
+    for (let i = 1; i < intervals.length; i++) {
+      const prev = merged[merged.length - 1]!;
+      const cur = intervals[i]!;
+      if (cur[0] <= prev[1]) {
+        prev[1] = Math.max(prev[1], cur[1]);
+      } else {
+        merged.push(cur);
+      }
+    }
+    return merged;
   }
 
   private buildSelfIntervals(