openclaw-node-harness 2.0.2 → 2.0.4

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, natsConnectOpts } = require('../lib/nats-resolve');
+const { NATS_URL } = 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');
@@ -186,6 +186,11 @@ async function dispatchTask(task) {
     success_criteria: task.success_criteria || [],
     scope: task.scope || [],
     priority: task.auto_priority || 0,
+    llm_provider: task.llm_provider || null,
+    llm_model: task.llm_model || null,
+    preferred_nodes: task.preferred_nodes || [],
+    exclude_nodes: task.exclude_nodes || [],
+    collaboration: task.collaboration || undefined,
   });
 
   log(`SUBMITTED: ${meshTask.task_id} to mesh (budget: ${meshTask.budget_minutes}m)`);
@@ -203,6 +208,245 @@ async function dispatchTask(task) {
   log(`UPDATED: ${task.task_id} → submitted`);
 }
 
+// ── Collab Events → Kanban ───────────────────────────
+
+/**
+ * Handle collab-specific events. Updates kanban with collaboration progress.
+ */
+function handleCollabEvent(eventType, taskId, data) {
+  // Only process events for tasks we dispatched
+  if (!dispatched.has(taskId)) return;
+
+  const session = data; // collab events include the session object
+
+  switch (eventType) {
+    case 'collab.created':
+      log(`COLLAB CREATED: session ${session.session_id} for task ${taskId} (mode: ${session.mode})`);
+      updateTaskInPlace(ACTIVE_TASKS_PATH, taskId, {
+        next_action: `Collab session created (mode: ${session.mode}). Recruiting ${session.min_nodes}+ nodes...`,
+        updated_at: isoTimestamp(),
+      });
+      break;
+
+    case 'collab.joined':
+      log(`COLLAB JOINED: ${session.nodes?.length || '?'} nodes in session for ${taskId}`);
+      updateTaskInPlace(ACTIVE_TASKS_PATH, taskId, {
+        next_action: `${session.nodes?.length || '?'} nodes joined. ${session.status === 'recruiting' ? 'Recruiting...' : 'Working...'}`,
+        updated_at: isoTimestamp(),
+      });
+      break;
+
+    case 'collab.round_started':
+      log(`COLLAB ROUND ${session.current_round}: started for ${taskId}`);
+      updateTaskInPlace(ACTIVE_TASKS_PATH, taskId, {
+        next_action: `Round ${session.current_round}/${session.max_rounds} in progress (${session.nodes?.length || '?'} nodes)`,
+        updated_at: isoTimestamp(),
+      });
+      break;
+
+    case 'collab.reflection_received': {
+      const totalReflections = session.rounds?.[session.rounds.length - 1]?.reflections?.length || 0;
+      const totalNodes = session.nodes?.length || '?';
+      log(`COLLAB REFLECT: ${totalReflections}/${totalNodes} for R${session.current_round} of ${taskId}`);
+      updateTaskInPlace(ACTIVE_TASKS_PATH, taskId, {
+        next_action: `R${session.current_round}: ${totalReflections}/${totalNodes} reflections received`,
+        updated_at: isoTimestamp(),
+      });
+      break;
+    }
+
+    case 'collab.converged':
+      log(`COLLAB CONVERGED: ${taskId} after ${session.current_round} rounds`);
+      updateTaskInPlace(ACTIVE_TASKS_PATH, taskId, {
+        next_action: `Converged after ${session.current_round} rounds. Collecting artifacts...`,
+        updated_at: isoTimestamp(),
+      });
+      break;
+
+    case 'collab.completed': {
+      const result = session.result || {};
+      const nodeNames = Object.keys(result.node_contributions || {});
+      const artifactCount = (result.artifacts || []).length;
+      log(`COLLAB COMPLETED: ${taskId} — ${result.rounds_taken} rounds, ${nodeNames.length} nodes, ${artifactCount} artifacts`);
+      updateTaskInPlace(ACTIVE_TASKS_PATH, taskId, {
+        next_action: `Collab completed: ${result.rounds_taken || '?'} rounds, ${nodeNames.length} nodes. ${artifactCount} artifact(s). ${result.summary || ''}`.trim(),
+        collab_result: {
+          rounds_taken: result.rounds_taken,
+          node_contributions: result.node_contributions,
+          artifacts: result.artifacts,
+          summary: result.summary,
+        },
+        updated_at: isoTimestamp(),
+      });
+      break;
+    }
+
+    case 'collab.aborted':
+      log(`COLLAB ABORTED: ${taskId} — ${session.result?.summary || 'unknown reason'}`);
+      break;
+
+    default:
+      log(`COLLAB EVENT: ${eventType} for ${taskId}`);
+  }
+}
+
+// ── Plan Events → Kanban ────────────────────────────
+
+/**
+ * Handle plan-specific events. Materializes subtasks in kanban and tracks progress.
+ */
+function handlePlanEvent(eventType, data) {
+  const plan = data;
+  const parentTaskId = plan?.parent_task_id;
+
+  switch (eventType) {
+    case 'plan.created':
+      log(`PLAN CREATED: ${plan.plan_id} for task ${parentTaskId} (${plan.subtasks?.length || 0} subtasks, ${plan.estimated_waves || 0} waves)`);
+      if (parentTaskId) {
+        updateTaskInPlace(ACTIVE_TASKS_PATH, parentTaskId, {
+          next_action: `Plan created: ${plan.subtasks?.length || 0} subtasks in ${plan.estimated_waves || 0} waves. ${plan.requires_approval ? 'Awaiting approval.' : 'Auto-executing.'}`,
+          updated_at: isoTimestamp(),
+        });
+      }
+      break;
+
+    case 'plan.approved':
+      log(`PLAN APPROVED: ${plan.plan_id}`);
+      if (parentTaskId) {
+        updateTaskInPlace(ACTIVE_TASKS_PATH, parentTaskId, {
+          status: 'running',
+          next_action: `Plan approved. Dispatching wave 0...`,
+          updated_at: isoTimestamp(),
+        });
+      }
+      break;
+
+    case 'plan.wave_started': {
+      // Materialize new subtasks into kanban as child tasks
+      const readySubtasks = (plan.subtasks || []).filter(st => st.status === 'queued' || st.status === 'blocked');
+      log(`PLAN WAVE: ${plan.plan_id} — materializing ${readySubtasks.length} subtasks in kanban`);
+
+      for (const st of readySubtasks) {
+        // Only materialize local/soul/human subtasks — mesh subtasks are tracked via mesh events
+        if (st.delegation?.mode === 'local' || st.delegation?.mode === 'soul' || st.delegation?.mode === 'human') {
+          materializeSubtask(plan, st);
+        }
+      }
+
+      if (parentTaskId) {
+        const completed = (plan.subtasks || []).filter(s => s.status === 'completed').length;
+        const total = (plan.subtasks || []).length;
+        updateTaskInPlace(ACTIVE_TASKS_PATH, parentTaskId, {
+          next_action: `Plan executing: ${completed}/${total} subtasks done`,
+          updated_at: isoTimestamp(),
+        });
+      }
+      break;
+    }
+
+    case 'plan.subtask_completed': {
+      const completed = (plan.subtasks || []).filter(s => s.status === 'completed').length;
+      const total = (plan.subtasks || []).length;
+      log(`PLAN PROGRESS: ${plan.plan_id} — ${completed}/${total} subtasks done`);
+      if (parentTaskId) {
+        updateTaskInPlace(ACTIVE_TASKS_PATH, parentTaskId, {
+          next_action: `Plan: ${completed}/${total} subtasks complete`,
+          updated_at: isoTimestamp(),
+        });
+      }
+      break;
+    }
+
+    case 'plan.completed':
+      log(`PLAN COMPLETED: ${plan.plan_id}`);
+      // Parent task completion handled by the daemon (marks waiting-user)
+      break;
+
+    case 'plan.aborted':
+      log(`PLAN ABORTED: ${plan.plan_id}`);
+      if (parentTaskId) {
+        updateTaskInPlace(ACTIVE_TASKS_PATH, parentTaskId, {
+          status: 'blocked',
+          next_action: `Plan aborted — needs triage`,
+          updated_at: isoTimestamp(),
+        });
+      }
+      break;
+
+    default:
+      log(`PLAN EVENT: ${eventType} for plan ${plan?.plan_id || 'unknown'}`);
+  }
+}
+
+/**
+ * Materialize a plan subtask as a child task in active-tasks.md.
+ * For local/soul/human delegation modes only — mesh subtasks use the existing mesh dispatch.
+ */
+function materializeSubtask(plan, subtask) {
+  try {
+    const tasks = readTasks(ACTIVE_TASKS_PATH);
+
+    // Check if already materialized
+    if (tasks.find(t => t.task_id === subtask.subtask_id)) {
+      log(`  SKIP: ${subtask.subtask_id} already in kanban`);
+      return;
+    }
+
+    const mode = subtask.delegation?.mode || 'local';
+    const soulId = subtask.delegation?.soul_id || null;
+
+    const taskEntry = {
+      task_id: subtask.subtask_id,
+      title: subtask.title,
+      status: mode === 'human' ? 'blocked' : 'queued',
+      owner: mode === 'soul' ? 'Daedalus' : null,
+      soul_id: soulId,
+      success_criteria: subtask.success_criteria || [],
+      artifacts: [],
+      next_action: mode === 'human'
+        ? 'Needs Gui input'
+        : `Plan subtask (${mode}${soulId ? `: ${soulId}` : ''})`,
+      parent_id: plan.parent_task_id,
+      project: null, // inherited from parent via MC
+      description: `${subtask.description || ''}\n\n_Delegation: ${mode}${soulId ? ` → ${soulId}` : ''} | Plan: ${plan.plan_id} | Budget: ${subtask.budget_minutes}m_`,
+      updated_at: isoTimestamp(),
+    };
+
+    // Append to active-tasks.md
+    const content = fs.readFileSync(ACTIVE_TASKS_PATH, 'utf-8');
+    const yamlEntry = formatTaskYaml(taskEntry);
+    fs.writeFileSync(ACTIVE_TASKS_PATH, content + '\n' + yamlEntry);
+
+    log(`  MATERIALIZED: ${subtask.subtask_id} → kanban (${mode})`);
+  } catch (err) {
+    log(`  ERROR materializing ${subtask.subtask_id}: ${err.message}`);
+  }
+}
+
+/**
+ * Format a task entry as YAML for active-tasks.md.
+ */
+function formatTaskYaml(task) {
+  const lines = [];
+  lines.push(`- task_id: ${task.task_id}`);
+  lines.push(`  title: ${task.title}`);
+  lines.push(`  status: ${task.status}`);
+  if (task.owner) lines.push(`  owner: ${task.owner}`);
+  if (task.soul_id) lines.push(`  soul_id: ${task.soul_id}`);
+  if (task.success_criteria?.length > 0) {
+    lines.push('  success_criteria:');
+    for (const sc of task.success_criteria) {
+      lines.push(`    - ${sc}`);
+    }
+  }
+  lines.push(`  artifacts:`);
+  if (task.next_action) lines.push(`  next_action: "${task.next_action.replace(/"/g, '\\"')}"`);
+  if (task.parent_id) lines.push(`  parent_id: ${task.parent_id}`);
+  if (task.description) lines.push(`  description: "${task.description.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`);
+  lines.push(`  updated_at: ${task.updated_at}`);
+  return lines.join('\n');
+}
+
 // ── Results: Mesh → Kanban (event-driven) ───────────
 
 /**
@@ -247,6 +491,11 @@ function handleEvent(eventType, taskId, meshTask) {
         lastHeartbeat.set(taskId, Date.now());
         return;
       default:
+        // Handle collab events
+        if (eventType.startsWith('collab.')) {
+          handleCollabEvent(eventType, taskId, meshTask);
+          return;
+        }
         // submitted, started — informational only
         log(`EVENT: ${eventType} ${taskId}`);
         return;
@@ -428,19 +677,30 @@ async function main() {
   log(`  Dispatch interval: ${DISPATCH_INTERVAL / 1000}s`);
   log(`  Mode:             ${DRY_RUN ? 'dry run' : 'live'}`);
 
-  nc = await connect(natsConnectOpts({ timeout: 5000, reconnect: true, maxReconnectAttempts: -1, reconnectTimeWait: 5000 }));
+  nc = await connect({
+    servers: NATS_URL,
+    timeout: 5000,
+    reconnect: true,
+    maxReconnectAttempts: 10,
+    reconnectTimeWait: 2000,
+  });
   log('Connected to NATS');
 
   // Re-reconcile on reconnect — catches events missed during NATS blip (#2)
-  // NATS.js uses async status() iterator, not EventEmitter .on()
+  // Exit on permanent disconnect so launchd restarts us
   (async () => {
     for await (const s of nc.status()) {
+      log(`NATS status: ${s.type}`);
       if (s.type === 'reconnect') {
         log('NATS reconnected — running reconciliation');
         reconcile().catch(err => log(`RECONCILE on reconnect failed: ${err.message}`));
       }
     }
   })();
+  nc.closed().then(() => {
+    log('NATS connection permanently closed — exiting for launchd restart');
+    process.exit(1);
+  });
 
   // Reconcile any orphaned tasks from a previous crash (#2, #10)
   await reconcile();
@@ -454,7 +714,12 @@ async function main() {
     for await (const msg of sub) {
       try {
         const payload = JSON.parse(sc.decode(msg.data));
-        handleEvent(payload.event, payload.task_id, payload.task);
+        // Route plan events separately (they use plan_id, not task_id)
+        if (payload.event && payload.event.startsWith('plan.')) {
+          handlePlanEvent(payload.event, payload.plan || payload);
+        } else {
+          handleEvent(payload.event, payload.task_id, payload.task);
+        }
       } catch (err) {
         log(`ERROR parsing event: ${err.message}`);
       }
@@ -467,13 +732,11 @@ async function main() {
 
   // Dispatch loop (polls active-tasks.md)
   while (running) {
-    let lastAttemptedTask = null;
     try {
       // Only dispatch if no active tasks in the mesh from this bridge
       if (dispatched.size === 0) {
         const task = findDispatchable();
         if (task) {
-          lastAttemptedTask = task;
           await dispatchTask(task);
           consecutiveSubmitFailures = 0; // reset on success
         }
@@ -498,11 +761,12 @@ async function main() {
       log(`DISPATCH ERROR (${consecutiveSubmitFailures}/${MAX_SUBMIT_FAILURES}): ${err.message}`);
 
       if (consecutiveSubmitFailures >= MAX_SUBMIT_FAILURES) {
-        // Use the captured task reference — don't re-query which could return a different task
-        if (lastAttemptedTask) {
-          log(`BLOCKING: ${lastAttemptedTask.task_id} after ${MAX_SUBMIT_FAILURES} consecutive submit failures`);
+        // Find the task we were trying to dispatch and mark it blocked
+        const failedTask = findDispatchable();
+        if (failedTask) {
+          log(`BLOCKING: ${failedTask.task_id} after ${MAX_SUBMIT_FAILURES} consecutive submit failures`);
           try {
-            updateTaskInPlace(ACTIVE_TASKS_PATH, lastAttemptedTask.task_id, {
+            updateTaskInPlace(ACTIVE_TASKS_PATH, failedTask.task_id, {
               status: 'blocked',
               next_action: `Mesh submit failed ${MAX_SUBMIT_FAILURES}x — check NATS connectivity`,
               updated_at: isoTimestamp(),

package/bin/mesh-deploy-listener.js

@@ -25,8 +25,12 @@ const os = require('os');
 
 const NODE_ID = process.env.OPENCLAW_NODE_ID ||
   os.hostname().toLowerCase().replace(/[^a-z0-9-]/g, '-');
+// NOTE: REPO_DIR defaults to ~/openclaw (runtime). The git repo lives at
+// ~/openclaw-node. See mesh-deploy.js "Two-directory problem" comment.
 const REPO_DIR = process.env.OPENCLAW_REPO_DIR ||
-  path.join(os.homedir(), 'openclaw-node');
+  path.join(os.homedir(), 'openclaw');
+const REPO_REMOTE_URL = process.env.OPENCLAW_REPO_URL ||
+  'https://github.com/moltyguibros-design/openclaw-node.git';
 const DEPLOY_SCRIPT = path.join(REPO_DIR, 'bin', 'mesh-deploy.js');
 
 const { NATS_URL, natsConnectOpts } = require('../lib/nats-resolve');
@@ -60,122 +64,140 @@ let deploying = false; // prevent concurrent deploys
 
 async function executeDeploy(trigger, resultsKv, nodesKv) {
   if (deploying) {
-    console.log(`[deploy-listener] Already deploying — ignoring trigger for ${trigger.sha}`);
+    console.log(`[deploy-listener] Already deploying — ignoring trigger for ${trigger.sha} (from ${trigger.initiator || 'unknown'})`);
     return;
   }
 
   deploying = true;
   const startedAt = new Date().toISOString();
-  const resultKey = `${trigger.sha}-${NODE_ID}`;
+  // Sanitize sha for NATS KV key safety (KV rejects whitespace, path seps, etc.)
+  const safeSha = (trigger.sha || 'unknown').replace(/[^a-fA-F0-9.-]/g, '');
+  const resultKey = `${safeSha}-${NODE_ID}`;
 
-  console.log(`[deploy-listener] ═══ Deploy triggered: ${trigger.sha} by ${trigger.initiator} ═══`);
-
-  // Write "deploying" status so lead sees we're working
   try {
-    await resultsKv.put(resultKey, sc.encode(JSON.stringify({
-      nodeId: NODE_ID, sha: trigger.sha, status: 'deploying', startedAt,
-    })));
-  } catch {}
+    console.log(`[deploy-listener] ═══ Deploy triggered: ${trigger.sha} by ${trigger.initiator} ═══`);
 
-  const result = {
-    nodeId: NODE_ID,
-    sha: trigger.sha,
-    status: 'success',
-    startedAt,
-    completedAt: null,
-    durationSeconds: 0,
-    componentsDeployed: [],
-    warnings: [],
-    errors: [],
-    log: '',
-  };
+    // Write "deploying" status so lead sees we're working
+    try {
+      await resultsKv.put(resultKey, sc.encode(JSON.stringify({
+        nodeId: NODE_ID, sha: trigger.sha, status: 'deploying', startedAt,
+      })));
+    } catch {}
 
-  try {
-    // Verify repo exists
-    if (!fs.existsSync(path.join(REPO_DIR, '.git'))) {
-      throw new Error(`Repo not found at ${REPO_DIR}`);
-    }
+    const result = {
+      nodeId: NODE_ID,
+      sha: trigger.sha,
+      status: 'success',
+      startedAt,
+      completedAt: null,
+      durationSeconds: 0,
+      componentsDeployed: [],
+      warnings: [],
+      errors: [],
+      log: '',
+    };
 
-    // Validate branch name to prevent command injection (trigger.branch comes from NATS)
-    const branch = (trigger.branch || 'main').replace(/[^a-zA-Z0-9._/-]/g, '');
-    if (!branch || branch !== (trigger.branch || 'main')) {
-      throw new Error(`Invalid branch name: ${trigger.branch}`);
-    }
+    try {
+      // Validate branch name to prevent command injection (trigger.branch comes from NATS)
+      const branch = (trigger.branch || 'main').replace(/[^a-zA-Z0-9._/-]/g, '');
+      if (!branch || branch !== (trigger.branch || 'main')) {
+        throw new Error(`Invalid branch name: ${trigger.branch}`);
+      }
 
-    // Git fetch + ff merge
-    execSync(`git fetch origin ${branch}`, {
-      cwd: REPO_DIR, encoding: 'utf8', timeout: 60000,
-    });
-    execSync(`git merge origin/${branch} --ff-only`, {
-      cwd: REPO_DIR, encoding: 'utf8', timeout: 30000,
-    });
-
-    // Build deploy command — filter requested components against what this node runs
-    let cmd = `node "${DEPLOY_SCRIPT}" --local`;
-    if (trigger.components && !trigger.components.includes('all')) {
-      const applicable = trigger.components.filter(c => NODE_COMPONENTS.has(c));
-      if (applicable.length === 0) {
-        console.log(`[deploy-listener] No applicable components for role=${NODE_ROLE} — skipping`);
-        result.status = 'skipped';
-        result.log = `No matching components for role ${NODE_ROLE}`;
-        deploying = false;
-        result.completedAt = new Date().toISOString();
-        try { await resultsKv.put(resultKey, sc.encode(JSON.stringify(result))); } catch {}
-        return;
+      // Bootstrap git repo if directory exists but .git doesn't
+      // (provisioner may have copied files without git clone)
+      if (!fs.existsSync(path.join(REPO_DIR, '.git'))) {
+        if (!fs.existsSync(REPO_DIR)) {
+          throw new Error(`Repo dir not found at ${REPO_DIR}`);
+        }
+        console.log(`[deploy-listener] No .git found — bootstrapping git repo`);
+        execSync('git init', { cwd: REPO_DIR, encoding: 'utf8', timeout: 10000 });
+        execSync(`git remote add origin ${REPO_REMOTE_URL}`, {
+          cwd: REPO_DIR, encoding: 'utf8', timeout: 10000,
+        });
+        execSync(`git fetch origin ${branch}`, {
+          cwd: REPO_DIR, encoding: 'utf8', timeout: 60000,
+        });
+        execSync(`git reset --hard origin/${branch}`, {
+          cwd: REPO_DIR, encoding: 'utf8', timeout: 30000,
+        });
+        console.log(`[deploy-listener] Git bootstrapped from origin/${branch}`);
+      } else {
+        // Normal path: fetch + ff merge
+        execSync(`git fetch origin ${branch}`, {
+          cwd: REPO_DIR, encoding: 'utf8', timeout: 60000,
+        });
+        execSync(`git merge origin/${branch} --ff-only`, {
+          cwd: REPO_DIR, encoding: 'utf8', timeout: 30000,
+        });
       }
-      for (const c of applicable) cmd += ` --component ${c}`;
-    }
-    if (trigger.force) cmd += ' --force';
-
-    console.log(`[deploy-listener] Running: ${cmd}`);
-    const output = execSync(cmd, {
-      cwd: REPO_DIR,
-      encoding: 'utf8',
-      timeout: 300000, // 5 min max (npm install can be slow)
-      env: { ...process.env, OPENCLAW_REPO_DIR: REPO_DIR },
-    });
-
-    result.log = output.slice(-5000);
-    result.status = 'success';
-    result.sha = execSync('git rev-parse --short HEAD', {
-      cwd: REPO_DIR, encoding: 'utf8',
-    }).trim();
 
-    console.log(`[deploy-listener] Success — now at ${result.sha}`);
+      // Build deploy command — filter requested components against what this node runs
+      let cmd = `"${process.execPath}" "${DEPLOY_SCRIPT}" --local`;
+      if (trigger.components && !trigger.components.includes('all')) {
+        const applicable = trigger.components.filter(c => NODE_COMPONENTS.has(c));
+        if (applicable.length === 0) {
+          console.log(`[deploy-listener] No applicable components for role=${NODE_ROLE} — skipping`);
+          result.status = 'skipped';
+          result.log = `No matching components for role ${NODE_ROLE}`;
+          result.completedAt = new Date().toISOString();
+          try { await resultsKv.put(resultKey, sc.encode(JSON.stringify(result))); } catch {}
+          return;
+        }
+        for (const c of applicable) cmd += ` --component ${c}`;
+      }
+      if (trigger.force) cmd += ' --force';
 
-  } catch (err) {
-    result.status = 'failed';
-    result.errors.push(err.message);
-    result.log = (err.stdout || err.stderr || err.message).slice(-5000);
-    console.error(`[deploy-listener] Deploy FAILED: ${err.message}`);
-  }
+      console.log(`[deploy-listener] Running: ${cmd}`);
+      const output = execSync(cmd, {
+        cwd: REPO_DIR,
+        encoding: 'utf8',
+        timeout: 300000, // 5 min max (npm install can be slow)
+        env: { ...process.env, OPENCLAW_REPO_DIR: REPO_DIR },
+      });
 
-  result.completedAt = new Date().toISOString();
-  result.durationSeconds = Math.round(
-    (new Date(result.completedAt) - new Date(result.startedAt)) / 1000
-  );
+      result.log = output.slice(-5000);
+      result.status = 'success';
+      result.sha = execSync('git rev-parse --short HEAD', {
+        cwd: REPO_DIR, encoding: 'utf8',
+      }).trim();
 
-  // Write final result to KV
-  try {
-    await resultsKv.put(resultKey, sc.encode(JSON.stringify(result)));
-  } catch (err) {
-    console.error(`[deploy-listener] Failed to write result: ${err.message}`);
-  }
+      console.log(`[deploy-listener] Success — now at ${result.sha}`);
 
-  // Update our deployVersion in the nodes registry
-  if (result.status === 'success' && nodesKv) {
+    } catch (err) {
+      result.status = 'failed';
+      result.errors.push(err.message);
+      result.log = (err.stdout || err.stderr || err.message).slice(-5000);
+      console.error(`[deploy-listener] Deploy FAILED: ${err.message}`);
+    }
+
+    result.completedAt = new Date().toISOString();
+    result.durationSeconds = Math.round(
+      (new Date(result.completedAt) - new Date(result.startedAt)) / 1000
+    );
+
+    // Write final result to KV
     try {
-      const existing = await nodesKv.get(NODE_ID);
-      if (existing && existing.value) {
-        const node = JSON.parse(sc.decode(existing.value));
-        node.deployVersion = result.sha;
-        node.lastDeploy = result.completedAt;
-        await nodesKv.put(NODE_ID, sc.encode(JSON.stringify(node)));
-      }
-    } catch {}
-  }
+      await resultsKv.put(resultKey, sc.encode(JSON.stringify(result)));
+    } catch (err) {
+      console.error(`[deploy-listener] Failed to write result: ${err.message}`);
+    }
 
-  deploying = false;
+    // Update our deployVersion in the nodes registry
+    if (result.status === 'success' && nodesKv) {
+      try {
+        const existing = await nodesKv.get(NODE_ID);
+        if (existing && existing.value) {
+          const node = JSON.parse(sc.decode(existing.value));
+          node.deployVersion = result.sha;
+          node.lastDeploy = result.completedAt;
+          await nodesKv.put(NODE_ID, sc.encode(JSON.stringify(node)));
+        }
+      } catch {}
+    }
+  } finally {
+    deploying = false;
+  }
 }
 
 // ── Auto-Catch-Up ────────────────────────────────────────────────────────

package/bin/mesh-deploy.js

@@ -32,7 +32,7 @@
  *
  * ENVIRONMENT:
  *   OPENCLAW_DEPLOY_BRANCH   — git branch (default: main)
- *   OPENCLAW_REPO_DIR        — repo location (default: ~/openclaw-node)
+ *   OPENCLAW_REPO_DIR        — repo location (default: ~/openclaw)
  *   OPENCLAW_NATS            — NATS server URL (from env or openclaw.env)
  */
 
@@ -47,7 +47,15 @@ const crypto = require('crypto');
 const IS_MAC = os.platform() === 'darwin';
 const HOME = os.homedir();
 const DEPLOY_BRANCH = process.env.OPENCLAW_DEPLOY_BRANCH || 'main';
-const REPO_DIR = process.env.OPENCLAW_REPO_DIR || path.join(HOME, 'openclaw-node');
+const REPO_DIR = process.env.OPENCLAW_REPO_DIR || path.join(HOME, 'openclaw');
+
+// KNOWN ISSUE: Two-directory problem
+// ~/openclaw-node is the git repo (source of truth). mesh-deploy pulls into it,
+// then copies files to ~/openclaw (the runtime location). These can drift if
+// files are edited directly in ~/openclaw without back-porting to the repo.
+// Resolution path: unify to a single directory. Either symlink ~/openclaw →
+// ~/openclaw-node, or change REPO_DIR default + DIRS to point at the same tree.
+// Until then, mesh-deploy.js is the only sanctioned way to propagate changes.
 
 // Standard directory layout
 const DIRS = {
@@ -884,7 +892,7 @@ async function main() {
 
     if (!fs.existsSync(REPO_DIR)) {
       fail(`Repo not found at ${REPO_DIR}`);
-      console.log(`  Clone it: git clone https://github.com/moltyguibros-design/openclaw-node.git ${REPO_DIR}`);
+      console.log(`  Clone it: git clone https://github.com/moltyguibros-design/openclaw-node.git "${REPO_DIR}"`);
       process.exit(1);
     }
 

package/bin/mesh-health-publisher.js

@@ -29,7 +29,7 @@ const HEALTH_BUCKET = "MESH_NODE_HEALTH";
 const KV_TTL_MS = 120_000; // entries expire after 2 minutes if node dies
 
 const REPO_DIR = process.env.OPENCLAW_REPO_DIR ||
-  path.join(os.homedir(), 'openclaw-node');
+  path.join(os.homedir(), 'openclaw');
 
 const sc = StringCodec();
 const IS_MAC = os.platform() === "darwin";