openclaw-node-harness 2.0.4 → 2.1.1

package/bin/mesh-bridge.js

@@ -21,7 +21,7 @@ const path = require('path');
 const { readTasks, updateTaskInPlace, isoTimestamp, ACTIVE_TASKS_PATH } = require('../lib/kanban-io');
 
 const sc = StringCodec();
-const { NATS_URL } = require('../lib/nats-resolve');
+const { NATS_URL, natsConnectOpts } = require('../lib/nats-resolve');
 const DISPATCH_INTERVAL = parseInt(process.env.BRIDGE_DISPATCH_INTERVAL || '10000'); // 10s
 const LOG_DIR = path.join(process.env.HOME, '.openclaw', 'workspace', 'memory', 'mesh-logs');
 const WORKSPACE = path.join(process.env.HOME, '.openclaw', 'workspace');
@@ -285,6 +285,55 @@ function handleCollabEvent(eventType, taskId, data) {
       log(`COLLAB ABORTED: ${taskId} — ${session.result?.summary || 'unknown reason'}`);
       break;
 
+    // Circling Strategy events
+    case 'collab.circling_step_started': {
+      if (!dispatched.has(taskId)) {
+        // Auto-track CLI-submitted circling tasks
+        try {
+          const tasks = readTasks(ACTIVE_TASKS_PATH);
+          if (tasks.find(t => t.task_id === taskId && t.execution === 'mesh')) {
+            dispatched.add(taskId);
+            lastHeartbeat.set(taskId, Date.now());
+            log(`CIRCLING AUTO-TRACK: ${taskId} (CLI-submitted)`);
+          } else { break; }
+        } catch { break; }
+      }
+      const c = session.circling || {};
+      const stepName = c.phase === 'init' ? 'Init'
+        : c.phase === 'finalization' ? 'Finalization'
+        : `SR${c.current_subround}/${c.max_subrounds} Step${c.current_step}`;
+      log(`CIRCLING ${stepName}: started for ${taskId}`);
+      updateTaskInPlace(ACTIVE_TASKS_PATH, taskId, {
+        circling_phase: c.phase || null,
+        circling_subround: c.current_subround || 0,
+        circling_step: c.current_step || 0,
+        next_action: `${stepName} in progress (${session.nodes?.length || '?'} nodes)`,
+        updated_at: isoTimestamp(),
+      });
+      break;
+    }
+
+    case 'collab.circling_gate': {
+      const cg = session.circling || {};
+      // Extract blocked reviewer summaries from the last round (if any)
+      const lastRound = session.rounds?.[session.rounds.length - 1];
+      const blockedVotes = lastRound?.reflections?.filter(r => r.vote === 'blocked') || [];
+      let gateMsg;
+      if (blockedVotes.length > 0) {
+        const reason = blockedVotes.map(r => r.summary).filter(Boolean).join('; ').slice(0, 150);
+        gateMsg = `[GATE] SR${cg.current_subround} blocked — ${reason || 'reviewer flagged concern'}`;
+      } else {
+        gateMsg = `[GATE] SR${cg.current_subround} complete — review reconciliationDoc and approve/reject`;
+      }
+      log(`CIRCLING GATE: ${taskId} — SR${cg.current_subround} waiting for approval`);
+      updateTaskInPlace(ACTIVE_TASKS_PATH, taskId, {
+        status: 'waiting-user',
+        next_action: gateMsg,
+        updated_at: isoTimestamp(),
+      });
+      break;
+    }
+
     default:
       log(`COLLAB EVENT: ${eventType} for ${taskId}`);
   }
@@ -677,8 +726,9 @@ async function main() {
   log(`  Dispatch interval: ${DISPATCH_INTERVAL / 1000}s`);
   log(`  Mode:             ${DRY_RUN ? 'dry run' : 'live'}`);
 
+  const natsOpts = natsConnectOpts();
   nc = await connect({
-    servers: NATS_URL,
+    ...natsOpts,
     timeout: 5000,
     reconnect: true,
     maxReconnectAttempts: 10,
@@ -730,6 +780,16 @@ async function main() {
   const stalenessTimer = setInterval(checkStaleness, HEARTBEAT_CHECK_INTERVAL);
   log(`Heartbeat staleness check: every ${HEARTBEAT_CHECK_INTERVAL / 1000}s (warn at ${STALE_WARNING_MS / 60000}m)`);
 
+  // Wake signal — MC publishes mesh.bridge.wake after creating a mesh task
+  // so the bridge picks it up in ~1s instead of waiting for the next poll cycle
+  let wakeResolve = null;
+  const wakeSub = nc.subscribe('mesh.bridge.wake', {
+    callback: () => {
+      log('WAKE: received wake signal, triggering immediate poll');
+      if (wakeResolve) { wakeResolve(); wakeResolve = null; }
+    },
+  });
+
   // Dispatch loop (polls active-tasks.md)
   while (running) {
     try {
@@ -779,10 +839,16 @@ async function main() {
       }
     }
 
-    await new Promise(r => setTimeout(r, DISPATCH_INTERVAL));
+    // Sleep until next poll OR wake signal, whichever comes first
+    await Promise.race([
+      new Promise(r => setTimeout(r, DISPATCH_INTERVAL)),
+      new Promise(r => { wakeResolve = r; }),
+    ]);
+    wakeResolve = null;
   }
 
   clearInterval(stalenessTimer);
+  wakeSub.unsubscribe();
   sub.unsubscribe();
   await nc.drain();
   log('Bridge stopped.');

package/bin/mesh-health-publisher.js

@@ -36,6 +36,12 @@ const IS_MAC = os.platform() === "darwin";
 
 const { ROLE_COMPONENTS } = require('../lib/mesh-roles');
 
+// ── Circuit Breaker State ───────────────────────────────────────────────
+let consecutiveFailures = 0;
+let skipTicksRemaining = 0;
+let lastErrorMsg = '';
+let lastErrorRepeatCount = 0;
+
 // ── Health Gathering ─────────────────────────────────────────────────────
 // All the expensive execSync calls happen here, on our own schedule.
 // No request timeout to race against.
@@ -226,11 +232,45 @@ async function main() {
 
   // Publish immediately, then every interval
   async function publish() {
+    // Circuit breaker: skip ticks during backoff
+    if (skipTicksRemaining > 0) {
+      skipTicksRemaining--;
+      return;
+    }
+
     try {
       const health = gatherHealth();
       await kv.put(NODE_ID, sc.encode(JSON.stringify(health)));
+      // Reset on success
+      if (consecutiveFailures > 0) {
+        console.log(`[health-publisher] recovered after ${consecutiveFailures} consecutive failures`);
+      }
+      consecutiveFailures = 0;
+      lastErrorMsg = '';
+      lastErrorRepeatCount = 0;
     } catch (err) {
-      console.error("[health-publisher] publish failed:", err.message);
+      consecutiveFailures++;
+      const msg = err.message;
+
+      // Log dedup: after 3 identical consecutive errors, log every 10th
+      if (msg === lastErrorMsg) {
+        lastErrorRepeatCount++;
+        if (lastErrorRepeatCount === 3) {
+          console.error(`[health-publisher] suppressing repeated errors (${lastErrorRepeatCount} occurrences): ${msg}`);
+        } else if (lastErrorRepeatCount > 3 && lastErrorRepeatCount % 10 === 0) {
+          console.error(`[health-publisher] suppressing repeated errors (${lastErrorRepeatCount} occurrences): ${msg}`);
+        }
+        // Silently skip logs between dedup thresholds
+      } else {
+        lastErrorMsg = msg;
+        lastErrorRepeatCount = 1;
+        console.error("[health-publisher] publish failed:", msg);
+      }
+
+      // Exponential backoff: skip 2^min(N,6) ticks (max ~64 ticks / ~16 min at 15s)
+      const backoffTicks = Math.pow(2, Math.min(consecutiveFailures, 6));
+      skipTicksRemaining = backoffTicks;
+      console.error(`[health-publisher] backoff: skipping next ${backoffTicks} ticks (failures=${consecutiveFailures})`);
     }
   }