openclaw-node-harness 2.0.2 → 2.0.4

package/bin/fleet-deploy.js

@@ -23,7 +23,7 @@ const os = require('os');
 
 const { NATS_URL, natsConnectOpts } = require('../lib/nats-resolve');
 const sc = StringCodec();
-const REPO_DIR = process.env.OPENCLAW_REPO_DIR || path.join(os.homedir(), 'openclaw-node');
+const REPO_DIR = process.env.OPENCLAW_REPO_DIR || path.join(os.homedir(), 'openclaw');
 const NODE_ID = process.env.OPENCLAW_NODE_ID ||
   os.hostname().toLowerCase().replace(/[^a-z0-9-]/g, '-');
 

package/bin/mesh-agent.js

@@ -117,7 +117,7 @@ function buildInitialPrompt(task) {
     parts.push('');
   }
 
-  if (task.success_criteria.length > 0) {
+  if (task.success_criteria && task.success_criteria.length > 0) {
     parts.push('## Success Criteria');
     for (const c of task.success_criteria) {
       parts.push(`- ${c}`);
@@ -132,7 +132,7 @@ function buildInitialPrompt(task) {
     parts.push('');
   }
 
-  if (task.scope.length > 0) {
+  if (task.scope && task.scope.length > 0) {
     parts.push('## Scope');
     parts.push('Only modify these files/paths:');
     for (const s of task.scope) {
@@ -192,7 +192,7 @@ function buildRetryPrompt(task, previousAttempts, attemptNumber) {
     parts.push('');
   }
 
-  if (task.scope.length > 0) {
+  if (task.scope && task.scope.length > 0) {
     parts.push('## Scope');
     for (const s of task.scope) {
       parts.push(`- ${s}`);
@@ -294,18 +294,31 @@ function commitAndMergeWorktree(worktreePath, taskId, summary) {
 
     log(`Committed ${sha} on ${branch}: ${commitMsg}`);
 
-    // Merge into main (from workspace)
-    try {
-      execSync(`git merge --no-ff "${branch}" -m "Merge ${branch}: ${taskId}"`, {
-        cwd: WORKSPACE, timeout: 30000, stdio: 'pipe',
-      });
-      log(`Merged ${branch} into main`);
-      return { committed: true, merged: true, sha };
-    } catch (mergeErr) {
-      // Merge conflict — abort and keep branch for human resolution
-      execSync('git merge --abort', { cwd: WORKSPACE, timeout: 5000, stdio: 'ignore' });
-      log(`MERGE CONFLICT on ${branch} — branch kept for manual resolution`);
-      return { committed: true, merged: false, sha };
+    // Merge into main (from workspace).
+    // Parallel collab: multiple nodes may merge concurrently. If the first attempt
+    // fails (e.g., another node merged first), retry once after pulling.
+    const mergeMsg = `Merge ${branch}: ${taskId}`;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        execSync(`git merge --no-ff "${branch}" -m "${mergeMsg.replace(/"/g, '\\"')}"`, {
+          cwd: WORKSPACE, timeout: 30000, stdio: 'pipe',
+        });
+        log(`Merged ${branch} into main${attempt > 0 ? ' (retry succeeded)' : ''}`);
+        return { committed: true, merged: true, sha };
+      } catch (mergeErr) {
+        execSync('git merge --abort', { cwd: WORKSPACE, timeout: 5000, stdio: 'ignore' });
+        if (attempt === 0) {
+          // First failure: pull and retry (handles race with parallel merge)
+          try {
+            log(`Merge attempt 1 failed for ${branch} — fast-forward pulling and retrying`);
+            execSync('git pull --ff-only', { cwd: WORKSPACE, timeout: 15000, stdio: 'pipe' });
+          } catch { /* best effort pull */ }
+        } else {
+          // Second failure: real conflict — keep branch for human resolution
+          log(`MERGE CONFLICT on ${branch} — branch kept for manual resolution`);
+          return { committed: true, merged: false, sha, conflict: true };
+        }
+      }
     }
   } catch (err) {
     log(`Commit/merge warning: ${err.message}`);
@@ -377,14 +390,23 @@ function runLLM(prompt, task, worktreePath) {
       timeout: (task.budget_minutes || 30) * 60 * 1000, // kill if exceeds budget
     });
 
-    // Heartbeat: signal daemon with activity state
+    // Heartbeat: signal daemon with activity state.
+    // getActivityState reads Claude JSONL files — only useful for Claude provider.
+    // For other providers, send a basic heartbeat (process alive = active).
+    const isClaude = provider.name === 'claude';
     const heartbeatTimer = setInterval(async () => {
       try {
-        const activity = await getActivityState(cleanCwd);
         const payload = { task_id: task.task_id };
-        if (activity) {
-          payload.activity_state = activity.state;
-          payload.activity_timestamp = activity.timestamp?.toISOString();
+        if (isClaude) {
+          const activity = await getActivityState(cleanCwd);
+          if (activity) {
+            payload.activity_state = activity.state;
+            payload.activity_timestamp = activity.timestamp?.toISOString();
+          }
+        } else {
+          // Non-Claude: process is running → active
+          payload.activity_state = 'active';
+          payload.activity_timestamp = new Date().toISOString();
         }
         await natsRequest('mesh.tasks.heartbeat', payload);
       } catch {
@@ -649,6 +671,13 @@ async function executeCollabTask(task) {
     return;
   }
 
+  // Subscribe to round notifications BEFORE joining — prevents race condition
+  // where the daemon starts round 1 immediately upon last node joining,
+  // but the joining node hasn't subscribed yet and misses the notification.
+  const roundSub = nc.subscribe(`mesh.collab.${sessionId}.node.${NODE_ID}.round`);
+  let roundsDone = false;
+  let lastKnownSessionStatus = null; // tracks why rounds ended (completed/aborted/converged)
+
   // Join the session using the discovered session_id
   let session;
   try {
@@ -659,6 +688,7 @@ async function executeCollabTask(task) {
     session = joinResult;
   } catch (err) {
     log(`COLLAB JOIN FAILED: ${err.message} (session: ${sessionId})`);
+    roundSub.unsubscribe();
     await natsRequest('mesh.tasks.fail', {
       task_id: task.task_id,
       reason: `Failed to join collab session ${sessionId}: ${err.message}`,
@@ -669,6 +699,7 @@ async function executeCollabTask(task) {
 
   if (!session) {
     log(`COLLAB JOIN RETURNED NULL for session ${sessionId}`);
+    roundSub.unsubscribe();
     await natsRequest('mesh.tasks.fail', {
       task_id: task.task_id,
       reason: `Collab session ${sessionId} rejected join (full, closed, or duplicate node).`,
@@ -684,87 +715,114 @@ async function executeCollabTask(task) {
   const worktreePath = createWorktree(`${task.task_id}-${NODE_ID}`);
   const taskDir = worktreePath || WORKSPACE;
 
-  // Subscribe to round notifications for this session and this node
-  const roundSub = nc.subscribe(`mesh.collab.${sessionId}.node.${NODE_ID}.round`);
-  let roundsDone = false;
+  // Periodic session heartbeat — detects abort/completion while waiting for rounds
+  const sessionHeartbeat = setInterval(async () => {
+    try {
+      const status = await natsRequest('mesh.collab.status', { session_id: sessionId }, 5000);
+      if (['aborted', 'completed'].includes(status.status)) {
+        log(`COLLAB HEARTBEAT: Session ${sessionId} is ${status.status}. Unsubscribing.`);
+        lastKnownSessionStatus = status.status;
+        roundsDone = true;
+        roundSub.unsubscribe();
+      }
+    } catch { /* best effort */ }
+  }, 10000);
 
   // Signal start
   await natsRequest('mesh.tasks.start', { task_id: task.task_id }).catch(() => {});
 
-  for await (const roundMsg of roundSub) {
-    if (roundsDone) break;
+  try {
+    for await (const roundMsg of roundSub) {
+      if (roundsDone) break;
 
-    const roundData = JSON.parse(sc.decode(roundMsg.data));
-    const { round_number, shared_intel, my_scope, my_role, mode, current_turn } = roundData;
+      const roundData = JSON.parse(sc.decode(roundMsg.data));
+      const { round_number, shared_intel, my_scope, my_role, mode, current_turn } = roundData;
 
-    // Sequential mode: skip if it's not our turn
-    if (mode === 'sequential' && current_turn && current_turn !== NODE_ID) {
-      log(`COLLAB R${round_number}: Not our turn (current: ${current_turn}). Waiting.`);
-      continue;
-    }
+      // Sequential mode safety guard: skip if it's not our turn.
+      // The daemon (notifySequentialTurn) only sends to the current-turn node,
+      // so this should not normally trigger. Kept as a defensive check.
+      if (mode === 'sequential' && current_turn && current_turn !== NODE_ID) {
+        log(`COLLAB R${round_number}: Not our turn (current: ${current_turn}). Waiting.`);
+        continue;
+      }
 
-    log(`COLLAB R${round_number}: Starting work (role: ${my_role}, scope: ${JSON.stringify(my_scope)})`);
+      log(`COLLAB R${round_number}: Starting work (role: ${my_role}, scope: ${JSON.stringify(my_scope)})`);
 
-    // Build round-specific prompt
-    const prompt = buildCollabPrompt(task, round_number, shared_intel, my_scope, my_role);
+      // Build round-specific prompt
+      const prompt = buildCollabPrompt(task, round_number, shared_intel, my_scope, my_role);
 
-    if (DRY_RUN) {
-      log(`[DRY RUN] Collab prompt:\n${prompt}`);
-      break;
-    }
+      if (DRY_RUN) {
+        log(`[DRY RUN] Collab prompt:\n${prompt}`);
+        break;
+      }
 
-    // Execute Claude
-    const llmResult = await runLLM(prompt, task, worktreePath);
-    const output = llmResult.stdout || '';
+      // Execute Claude
+      const llmResult = await runLLM(prompt, task, worktreePath);
+      const output = llmResult.stdout || '';
 
-    // Parse reflection from output
-    const reflection = parseReflection(output);
+      // Parse reflection from output
+      const reflection = parseReflection(output);
 
-    // List modified files
-    let artifacts = [];
-    try {
-      if (worktreePath) {
-        const status = require('child_process').execSync('git status --porcelain', {
-          cwd: worktreePath, timeout: 5000, encoding: 'utf-8',
-        }).trim();
-        artifacts = status.split('\n').filter(Boolean).map(line => line.slice(3));
+      // List modified files
+      let artifacts = [];
+      try {
+        if (worktreePath) {
+          const status = require('child_process').execSync('git status --porcelain', {
+            cwd: worktreePath, timeout: 5000, encoding: 'utf-8',
+          }).trim();
+          artifacts = status.split('\n').filter(Boolean).map(line => line.slice(3));
+        }
+      } catch { /* best effort */ }
+
+      // Submit reflection
+      try {
+        await natsRequest('mesh.collab.reflect', {
+          session_id: sessionId,
+          node_id: NODE_ID,
+          round: round_number,
+          summary: reflection.summary,
+          learnings: reflection.learnings,
+          artifacts,
+          confidence: reflection.confidence,
+          vote: reflection.vote,
+          parse_failed: reflection.parse_failed,
+        });
+        const parseTag = reflection.parse_failed ? ' [PARSE FAILED]' : '';
+        log(`COLLAB R${round_number}: Reflection submitted (vote: ${reflection.vote}, conf: ${reflection.confidence}${parseTag})`);
+      } catch (err) {
+        log(`COLLAB R${round_number}: Reflection submit failed: ${err.message}`);
       }
-    } catch { /* best effort */ }
 
-    // Submit reflection
-    try {
-      await natsRequest('mesh.collab.reflect', {
-        session_id: sessionId,
-        node_id: NODE_ID,
-        round: round_number,
-        summary: reflection.summary,
-        learnings: reflection.learnings,
-        artifacts,
-        confidence: reflection.confidence,
-        vote: reflection.vote,
-        parse_failed: reflection.parse_failed,
-      });
-      const parseTag = reflection.parse_failed ? ' [PARSE FAILED]' : '';
-      log(`COLLAB R${round_number}: Reflection submitted (vote: ${reflection.vote}, conf: ${reflection.confidence}${parseTag})`);
-    } catch (err) {
-      log(`COLLAB R${round_number}: Reflection submit failed: ${err.message}`);
+      // Check if session is done (converged/completed/aborted)
+      try {
+        const status = await natsRequest('mesh.collab.status', { session_id: sessionId });
+        if (['converged', 'completed', 'aborted'].includes(status.status)) {
+          log(`COLLAB: Session ${sessionId} is ${status.status}. Done.`);
+          lastKnownSessionStatus = status.status;
+          roundsDone = true;
+        }
+      } catch { /* continue listening */ }
     }
-
-    // Check if session is done (converged/completed/aborted)
-    try {
-      const status = await natsRequest('mesh.collab.status', { session_id: sessionId });
-      if (['converged', 'completed', 'aborted'].includes(status.status)) {
-        log(`COLLAB: Session ${sessionId} is ${status.status}. Done.`);
-        roundsDone = true;
-      }
-    } catch { /* continue listening */ }
+  } finally {
+    clearInterval(sessionHeartbeat);
+    roundSub.unsubscribe();
   }
 
-  roundSub.unsubscribe();
-
-  // Commit and merge worktree
-  const mergeResult = commitAndMergeWorktree(worktreePath, `${task.task_id}-${NODE_ID}`, `collab contribution from ${NODE_ID}`);
-  cleanupWorktree(worktreePath, mergeResult && !mergeResult?.merged);
+  // Commit and merge only on successful convergence — don't merge partial
+  // work from aborted/failed sessions into main.
+  // Uses lastKnownSessionStatus (set during round loop or heartbeat) instead of
+  // a fresh network read, which could see stale state due to NATS latency.
+  try {
+    if (['completed', 'converged'].includes(lastKnownSessionStatus)) {
+      const mergeResult = commitAndMergeWorktree(worktreePath, `${task.task_id}-${NODE_ID}`, `collab contribution from ${NODE_ID}`);
+      cleanupWorktree(worktreePath, mergeResult && !mergeResult?.merged);
+    } else {
+      log(`COLLAB: Session ${sessionId} ended as ${lastKnownSessionStatus || 'unknown'} — discarding worktree`);
+      cleanupWorktree(worktreePath, false);
+    }
+  } catch (err) {
+    log(`COLLAB WORKTREE CLEANUP FAILED: ${err.message}`);
+  }
 
   writeAgentState('idle', null);
   log(`COLLAB DONE: ${task.task_id} (node: ${NODE_ID})`);
@@ -986,8 +1044,82 @@ async function main() {
   })();
   log(`  Listening: mesh.agent.${NODE_ID}.alive`);
 
+  // Subscribe to collab recruit broadcasts — allows this node to join
+  // collab sessions without being the claiming node
+  const recruitSub = nc.subscribe('mesh.collab.*.recruit');
+  (async () => {
+    for await (const msg of recruitSub) {
+      try {
+        const recruit = JSON.parse(sc.decode(msg.data));
+        if (currentTaskId) continue; // busy
+
+        // Fetch task to check preferences and get collab spec
+        const task = await natsRequest('mesh.tasks.get', { task_id: recruit.task_id }, 5000);
+        if (!task || !task.collaboration) continue;
+        if (task.owner === NODE_ID) continue; // we claimed it, already handling
+
+        // Check preferred_nodes
+        if (task.preferred_nodes && task.preferred_nodes.length > 0) {
+          if (!task.preferred_nodes.includes(NODE_ID)) continue;
+        }
+        // Check exclude_nodes
+        if (task.exclude_nodes && task.exclude_nodes.length > 0) {
+          if (task.exclude_nodes.includes(NODE_ID)) continue;
+        }
+
+        log(`RECRUIT: Joining collab session ${recruit.session_id} for task ${recruit.task_id}`);
+        currentTaskId = task.task_id;
+        await executeCollabTask(task);
+        currentTaskId = null;
+      } catch (err) {
+        log(`RECRUIT ERROR: ${err.message}`);
+        currentTaskId = null;
+      }
+    }
+  })();
+  log(`  Listening: mesh.collab.*.recruit (collab recruiting)`);
+
+  // Also poll for recruiting sessions on idle — catches recruits we missed
+  async function checkRecruitingSessions() {
+    if (currentTaskId) return; // busy
+    try {
+      const sessions = await natsRequest('mesh.collab.recruiting', {}, 5000);
+      if (!sessions || !Array.isArray(sessions) || sessions.length === 0) return;
+
+      for (const s of sessions) {
+        if (currentTaskId) break; // became busy
+        // Skip if we already joined this session
+        if (s.node_ids && s.node_ids.includes(NODE_ID)) continue;
+        // Skip if session is full
+        if (s.max_nodes && s.current_nodes >= s.max_nodes) continue;
+
+        // Fetch task to check preferences
+        const task = await natsRequest('mesh.tasks.get', { task_id: s.task_id }, 5000);
+        if (!task || !task.collaboration) continue;
+        if (task.preferred_nodes && task.preferred_nodes.length > 0) {
+          if (!task.preferred_nodes.includes(NODE_ID)) continue;
+        }
+        if (task.exclude_nodes && task.exclude_nodes.length > 0) {
+          if (task.exclude_nodes.includes(NODE_ID)) continue;
+        }
+
+        log(`RECRUIT POLL: Joining collab session ${s.session_id} for task ${s.task_id}`);
+        currentTaskId = task.task_id;
+        await executeCollabTask(task);
+        currentTaskId = null;
+      }
+    } catch { /* silent — recruiting poll is best-effort */ }
+  }
+
   while (running) {
     try {
+      // Check for recruiting collab sessions before trying to claim
+      await checkRecruitingSessions();
+      if (currentTaskId) {
+        await new Promise(r => setTimeout(r, POLL_INTERVAL));
+        continue;
+      }
+
       // Claim next available task (longer timeout — KV operations on remote NATS can be slow)
       const task = await natsRequest('mesh.tasks.claim', { node_id: NODE_ID }, 60000);
 
@@ -1035,3 +1167,4 @@ main().catch(err => {
   console.error(`[mesh-agent] Fatal: ${err.message}`);
   process.exit(1);
 });
+// deploy-v7f0130b