openclaw-node-harness 2.0.4 → 2.1.1

package/bin/mesh-agent.js

@@ -36,14 +36,17 @@
  */
 
 const { connect, StringCodec } = require('nats');
-const { spawn, execSync } = require('child_process');
+const { spawn, execSync, execFileSync } = require('child_process');
 const os = require('os');
 const path = require('path');
 const fs = require('fs');
 const { getActivityState, getSessionInfo } = require('../lib/agent-activity');
+const { loadAllRules, matchRules, formatRulesForPrompt, detectFrameworks, activateFrameworkRules } = require('../lib/rule-loader');
+const { loadHarnessRules, runMeshHarness, runPostCommitValidation, formatHarnessForPrompt } = require('../lib/mesh-harness');
+const { findRole, formatRoleForPrompt } = require('../lib/role-loader');
 
 const sc = StringCodec();
-const { NATS_URL } = require('../lib/nats-resolve');
+const { NATS_URL, natsConnectOpts } = require('../lib/nats-resolve');
 const { resolveProvider, resolveModel } = require('../lib/llm-providers');
 const NODE_ID = process.env.MESH_NODE_ID || os.hostname().toLowerCase().replace(/[^a-z0-9-]/g, '-');
 const POLL_INTERVAL = parseInt(process.env.MESH_POLL_INTERVAL || '15000'); // 15s between polls
@@ -51,6 +54,75 @@ const MAX_ATTEMPTS = parseInt(process.env.MESH_MAX_ATTEMPTS || '3');
 const HEARTBEAT_INTERVAL = parseInt(process.env.MESH_HEARTBEAT_INTERVAL || '60000'); // 60s heartbeat
 const WORKSPACE = process.env.MESH_WORKSPACE || path.join(process.env.HOME, '.openclaw', 'workspace');
 
+// ── Rule loading (cached at startup, framework-filtered) ─────────────────
+const RULES_DIR = process.env.OPENCLAW_RULES_DIR || path.join(process.env.HOME, '.openclaw', 'rules');
+const HARNESS_PATH = process.env.OPENCLAW_HARNESS_RULES || path.join(process.env.HOME, '.openclaw', 'harness-rules.json');
+let cachedRules = null;
+let cachedHarnessRules = null;
+
+function getRules() {
+  if (!cachedRules) {
+    const allRules = loadAllRules(RULES_DIR);
+    const detected = detectFrameworks(WORKSPACE);
+    cachedRules = activateFrameworkRules(allRules, detected);
+  }
+  return cachedRules;
+}
+
+function getHarnessRules() {
+  if (!cachedHarnessRules) {
+    cachedHarnessRules = loadHarnessRules(HARNESS_PATH, 'mesh');
+  }
+  return cachedHarnessRules;
+}
+
+/**
+ * Inject matching coding rules into a prompt parts array based on task scope.
+ */
+function injectRules(parts, scope) {
+  // Path-scoped coding standards
+  const matched = matchRules(getRules(), scope || []);
+  if (matched.length > 0) {
+    parts.push(formatRulesForPrompt(matched));
+    parts.push('');
+  }
+
+  // Harness behavioral rules (soft enforcement — LLM-agnostic prompt injection)
+  const harnessText = formatHarnessForPrompt(getHarnessRules());
+  if (harnessText) {
+    parts.push(harnessText);
+    parts.push('');
+  }
+}
+
+// ── Role loading (cached per role ID) ─────────────────
+const ROLE_DIRS = [
+  path.join(process.env.HOME, '.openclaw', 'roles'),
+  path.join(__dirname, '..', 'config', 'roles'),
+];
+const roleCache = new Map();
+
+function getRole(roleId) {
+  if (!roleId) return null;
+  if (roleCache.has(roleId)) return roleCache.get(roleId);
+  const role = findRole(roleId, ROLE_DIRS);
+  if (role) roleCache.set(roleId, role);
+  return role;
+}
+
+/**
+ * Inject role profile into prompt parts array.
+ */
+function injectRole(parts, roleId) {
+  const role = getRole(roleId);
+  if (!role) return;
+  const roleText = formatRoleForPrompt(role);
+  if (roleText) {
+    parts.push(roleText);
+    parts.push('');
+  }
+}
+
 // ── CLI args ──────────────────────────────────────────
 
 const args = process.argv.slice(2);
@@ -126,8 +198,9 @@ function buildInitialPrompt(task) {
   }
 
   if (task.metric) {
+    const safeMetric = isAllowedMetric(task.metric) ? task.metric : '[metric command filtered for security]';
     parts.push(`## Verification`);
-    parts.push(`Run this command to check your work: \`${task.metric}\``);
+    parts.push(`Run this command to check your work: \`${safeMetric}\``);
     parts.push(`Your changes are only accepted if this command exits with code 0.`);
     parts.push('');
   }
@@ -141,12 +214,19 @@ function buildInitialPrompt(task) {
     parts.push('');
   }
 
+  // Inject path-scoped coding rules matching task scope
+  injectRules(parts, task.scope);
+
+  // Inject role profile (responsibilities, boundaries, framework)
+  injectRole(parts, task.role);
+
   parts.push('## Instructions');
   parts.push('- Read the relevant files before making changes.');
   parts.push('- Make minimal, focused changes. Do not add scope beyond what is asked.');
   parts.push('- If you hit a blocker you cannot resolve, explain what is blocking you clearly.');
   if (task.metric) {
-    parts.push(`- After making changes, run \`${task.metric}\` to verify.`);
+    const safeMetric = isAllowedMetric(task.metric) ? task.metric : '[metric command filtered for security]';
+    parts.push(`- After making changes, run \`${safeMetric}\` to verify.`);
     parts.push('- If verification fails, analyze the failure and iterate on your approach.');
   }
 
@@ -186,8 +266,9 @@ function buildRetryPrompt(task, previousAttempts, attemptNumber) {
   }
 
   if (task.metric) {
+    const safeMetric = isAllowedMetric(task.metric) ? task.metric : '[metric command filtered for security]';
     parts.push(`## Verification`);
-    parts.push(`Run: \`${task.metric}\``);
+    parts.push(`Run: \`${safeMetric}\``);
     parts.push(`Must exit code 0.`);
     parts.push('');
   }
@@ -200,12 +281,19 @@ function buildRetryPrompt(task, previousAttempts, attemptNumber) {
     parts.push('');
   }
 
+  // Inject path-scoped coding rules matching task scope
+  injectRules(parts, task.scope);
+
+  // Inject role profile (responsibilities, boundaries, framework)
+  injectRole(parts, task.role);
+
   parts.push('## Instructions');
   parts.push('- Do NOT repeat a failed approach. Try something different.');
   parts.push('- Read the relevant files before making changes.');
   parts.push('- Make minimal, focused changes.');
   if (task.metric) {
-    parts.push(`- Run \`${task.metric}\` to verify before finishing.`);
+    const safeMetric = isAllowedMetric(task.metric) ? task.metric : '[metric command filtered for security]';
+    parts.push(`- Run \`${safeMetric}\` to verify before finishing.`);
   }
 
   return parts.join('\n');
@@ -221,6 +309,9 @@ const WORKTREE_BASE = process.env.MESH_WORKTREE_BASE || path.join(process.env.HO
  * On failure, returns null (falls back to shared workspace).
  */
 function createWorktree(taskId) {
+  if (!/^[\w][\w.-]{0,127}$/.test(taskId)) {
+    throw new Error(`Invalid taskId: contains unsafe characters`);
+  }
   const worktreePath = path.join(WORKTREE_BASE, taskId);
   const branch = `mesh/${taskId}`;
 
@@ -231,19 +322,19 @@ function createWorktree(taskId) {
     if (fs.existsSync(worktreePath)) {
       log(`Cleaning stale worktree: ${worktreePath}`);
       try {
-        execSync(`git worktree remove --force "${worktreePath}"`, { cwd: WORKSPACE, timeout: 10000 });
+        execFileSync('git', ['worktree', 'remove', '--force', worktreePath], { cwd: WORKSPACE, timeout: 10000 });
       } catch {
         // If git worktree remove fails, manually clean up
         fs.rmSync(worktreePath, { recursive: true, force: true });
       }
       // Also clean up the branch if it exists
       try {
-        execSync(`git branch -D "${branch}"`, { cwd: WORKSPACE, timeout: 5000, stdio: 'ignore' });
+        execFileSync('git', ['branch', '-D', branch], { cwd: WORKSPACE, timeout: 5000, stdio: 'ignore' });
       } catch { /* branch may not exist */ }
     }
 
     // Create new worktree branched off HEAD
-    execSync(`git worktree add -b "${branch}" "${worktreePath}" HEAD`, {
+    execFileSync('git', ['worktree', 'add', '-b', branch, worktreePath, 'HEAD'], {
       cwd: WORKSPACE,
       timeout: 30000,
       stdio: 'pipe',
@@ -284,7 +375,14 @@ function commitAndMergeWorktree(worktreePath, taskId, summary) {
     // Stage and commit all changes
     execSync('git add -A', { cwd: worktreePath, timeout: 10000, stdio: 'pipe' });
     const commitMsg = `mesh(${taskId}): ${(summary || 'task completed').slice(0, 72)}`;
-    execSync(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, {
+
+    // Pre-commit validation: check conventional commit format before committing
+    const conventionalPattern = /^(feat|fix|docs|style|refactor|test|chore|build|ci|perf|revert|mesh)(\(.+\))?: .+/;
+    if (!conventionalPattern.test(commitMsg)) {
+      log(`WARNING: commit message doesn't follow conventional format: "${commitMsg}"`);
+    }
+
+    execFileSync('git', ['commit', '-m', commitMsg], {
       cwd: worktreePath, timeout: 10000, stdio: 'pipe',
     });
 
@@ -300,7 +398,7 @@ function commitAndMergeWorktree(worktreePath, taskId, summary) {
     const mergeMsg = `Merge ${branch}: ${taskId}`;
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
-        execSync(`git merge --no-ff "${branch}" -m "${mergeMsg.replace(/"/g, '\\"')}"`, {
+        execFileSync('git', ['merge', '--no-ff', branch, '-m', mergeMsg], {
           cwd: WORKSPACE, timeout: 30000, stdio: 'pipe',
         });
         log(`Merged ${branch} into main${attempt > 0 ? ' (retry succeeded)' : ''}`);
@@ -338,13 +436,13 @@ function cleanupWorktree(worktreePath, keep = false) {
   const branch = `mesh/${taskId}`;
 
   try {
-    execSync(`git worktree remove --force "${worktreePath}"`, {
+    execFileSync('git', ['worktree', 'remove', '--force', worktreePath], {
       cwd: WORKSPACE,
       timeout: 10000,
       stdio: 'pipe',
     });
     if (!keep) {
-      execSync(`git branch -D "${branch}"`, {
+      execFileSync('git', ['branch', '-D', branch], {
         cwd: WORKSPACE,
         timeout: 5000,
         stdio: 'ignore',
@@ -416,9 +514,10 @@ function runLLM(prompt, task, worktreePath) {
 
     let stdout = '';
     let stderr = '';
+    const MAX_OUTPUT = 1024 * 1024; // 1MB cap
 
-    child.stdout.on('data', (d) => { stdout += d.toString(); });
-    child.stderr.on('data', (d) => { stderr += d.toString(); });
+    child.stdout.on('data', (d) => { if (stdout.length < MAX_OUTPUT) stdout += d.toString().slice(0, MAX_OUTPUT - stdout.length); });
+    child.stderr.on('data', (d) => { if (stderr.length < MAX_OUTPUT) stderr += d.toString().slice(0, MAX_OUTPUT - stderr.length); });
 
     child.on('close', (code) => {
       clearInterval(heartbeatTimer);
@@ -434,10 +533,23 @@ function runLLM(prompt, task, worktreePath) {
 
 // ── Metric Evaluation ─────────────────────────────────
 
+const ALLOWED_METRIC_PREFIXES = [
+  'npm test', 'npm run', 'node ', 'pytest', 'cargo test',
+  'go test', 'make test', 'jest', 'vitest', 'mocha',
+];
+
+function isAllowedMetric(cmd) {
+  return ALLOWED_METRIC_PREFIXES.some(prefix => cmd.startsWith(prefix));
+}
+
 /**
  * Run the task's metric command. Returns { passed, output }.
  */
 function evaluateMetric(metric, cwd) {
+  if (!isAllowedMetric(metric)) {
+    log(`WARNING: Metric command blocked by security filter: ${metric}`);
+    return Promise.resolve({ passed: false, output: 'Metric command blocked by security filter' });
+  }
   return new Promise((resolve) => {
     const child = spawn('bash', ['-c', metric], {
       cwd: cwd || WORKSPACE,
@@ -510,6 +622,11 @@ function buildCollabPrompt(task, roundNumber, sharedIntel, myScope, myRole) {
     }
   }
 
+  // Inject path-scoped coding rules matching task scope
+  const collabScope = Array.isArray(myScope) ? myScope.map(s => s.replace('[REVIEW-ONLY] ', '')) : task.scope;
+  injectRules(parts, collabScope);
+  injectRole(parts, task.role);
+
   if (task.success_criteria && task.success_criteria.length > 0) {
     parts.push('## Success Criteria');
     for (const c of task.success_criteria) {
@@ -625,6 +742,207 @@ function parseReflection(output) {
   };
 }
 
+// ── Circling Strategy: Prompt Builder + Parser ───────
+
+/**
+ * Build a prompt for a circling strategy step.
+ * Role-specific: Worker gets different instructions than Reviewers at each step.
+ */
+function buildCirclingPrompt(task, circlingData) {
+  const { circling_phase, circling_step, circling_subround, directed_input, my_role } = circlingData;
+  const isWorker = my_role === 'worker';
+  const parts = [];
+
+  parts.push(`# Task: ${task.title}`);
+  parts.push('');
+
+  switch (circling_phase) {
+    case 'init':
+      if (isWorker) {
+        parts.push('## Your Role: WORKER (Central Authority)');
+        parts.push('');
+        parts.push('You are the Worker in a Circling Strategy collaboration. You OWN the deliverable.');
+        parts.push('Produce your initial work artifact (v0) — your first draft/implementation based on the task plan below.');
+        parts.push('');
+      } else {
+        parts.push('## Your Role: REVIEWER');
+        parts.push('');
+        parts.push('You are a Reviewer in a Circling Strategy collaboration.');
+        parts.push('Produce your **reviewStrategy** — your methodology and focus areas for reviewing this type of work.');
+        parts.push('Define: what you will look for, what frameworks you will apply, what your evaluation criteria are.');
+        parts.push('');
+      }
+      break;
+
+    case 'circling':
+      if (circling_step === 1) {
+        // Step 1 — Review Pass
+        parts.push(`## Sub-Round ${circling_subround}, Step 1: Review Pass`);
+        parts.push('');
+        if (isWorker) {
+          parts.push('## Your Role: WORKER — Analyze Review Strategies');
+          parts.push('');
+          parts.push('Below are the review STRATEGIES from both reviewers (NOT their review findings).');
+          parts.push('Analyze each strategy: what they focus on well, what they miss, how they could improve.');
+          parts.push('Your feedback will help reviewers sharpen their approaches.');
+          parts.push('Do NOT touch the work artifact in this step.');
+          parts.push('');
+        } else {
+          parts.push('## Your Role: REVIEWER — Review the Work Artifact');
+          parts.push('');
+          parts.push('Below is the work artifact. Review it using your review strategy.');
+          parts.push('Produce concrete, actionable findings. For each finding, specify:');
+          parts.push('- What you found (the issue or observation)');
+          parts.push('- Where in the artifact (location/line/section)');
+          parts.push('- Why it matters (impact)');
+          parts.push('- What you recommend (suggested fix or improvement)');
+          parts.push('');
+        }
+      } else if (circling_step === 2) {
+        // Step 2 — Integration + Refinement
+        parts.push(`## Sub-Round ${circling_subround}, Step 2: Integration & Refinement`);
+        parts.push('');
+        if (isWorker) {
+          parts.push('## Your Role: WORKER — Judge Reviews & Update Artifact');
+          parts.push('');
+          parts.push('Below are the review artifacts from both reviewers.');
+          parts.push('For EACH review finding, judge it:');
+          parts.push('- **ACCEPTED**: implement the suggestion and note where');
+          parts.push('- **REJECTED**: explain why with reasoning');
+          parts.push('- **MODIFIED**: implement differently and explain why');
+          parts.push('');
+          parts.push('Then produce your UPDATED work artifact incorporating accepted changes.');
+          parts.push('Also produce a reconciliationDoc summarizing all judgments.');
+          parts.push('');
+          parts.push('You must output TWO artifacts using the multi-artifact format below.');
+          parts.push('');
+        } else {
+          parts.push('## Your Role: REVIEWER — Refine Your Strategy');
+          parts.push('');
+          parts.push("Below is the Worker's analysis of your review strategy (and the other reviewer's).");
+          parts.push("Evaluate the Worker's feedback honestly:");
+          parts.push("- If the feedback is valid, adjust your strategy accordingly");
+          parts.push("- If you disagree, explain why and keep your approach");
+          parts.push('Produce your REFINED reviewStrategy.');
+          parts.push('');
+        }
+      }
+      break;
+
+    case 'finalization':
+      parts.push('## FINALIZATION');
+      parts.push('');
+      if (isWorker) {
+        parts.push('## Your Role: WORKER — Final Delivery');
+        parts.push('');
+        parts.push('Produce your FINAL formatted work artifact.');
+        parts.push('Also produce a completionDiff — a checklist comparing original plan items vs what was delivered:');
+        parts.push('  [x] Item implemented');
+        parts.push('  [ ] Item NOT implemented — reason / deferred to follow-up');
+        parts.push('');
+        parts.push('You must output TWO artifacts using the multi-artifact format below.');
+        parts.push('');
+      } else {
+        parts.push('## Your Role: REVIEWER — Final Sign-Off');
+        parts.push('');
+        parts.push('Review the final work artifact against the original task plan.');
+        parts.push('Either:');
+        parts.push('- **APPROVE**: vote "converged" — the work meets quality standards');
+        parts.push('- **FLAG CONCERN**: vote "blocked" — describe remaining critical concerns');
+        parts.push('');
+      }
+      break;
+  }
+
+  // Add directed input
+  if (directed_input) {
+    parts.push('---');
+    parts.push('');
+    parts.push(directed_input);
+    parts.push('');
+  }
+
+  // Add artifact output instructions
+  const isMultiArtifact = isWorker && (circling_step === 2 || circling_phase === 'finalization');
+  parts.push('---');
+  parts.push('');
+
+  if (isMultiArtifact) {
+    // Multi-artifact output format (Worker Step 2 and Finalization)
+    const art1Type = circling_phase === 'finalization' ? 'workArtifact' : 'workArtifact';
+    const art2Type = circling_phase === 'finalization' ? 'completionDiff' : 'reconciliationDoc';
+
+    parts.push('## Output Format (TWO artifacts required)');
+    parts.push('');
+    parts.push('Produce your first artifact, then wrap it:');
+    parts.push('');
+    parts.push('===CIRCLING_ARTIFACT===');
+    parts.push(`type: ${art1Type}`);
+    parts.push('===END_ARTIFACT===');
+    parts.push('');
+    parts.push('Then produce your second artifact:');
+    parts.push('');
+    parts.push('===CIRCLING_ARTIFACT===');
+    parts.push(`type: ${art2Type}`);
+    parts.push('===END_ARTIFACT===');
+    parts.push('');
+    parts.push('Then end with:');
+  } else {
+    parts.push('## Output Format');
+    parts.push('');
+    parts.push('Produce your work above, then end with:');
+  }
+
+  // Determine the correct type for single-artifact output
+  let artifactType = 'workArtifact'; // default
+  if (!isWorker) {
+    if (circling_phase === 'init' || circling_step === 2) artifactType = 'reviewStrategy';
+    else if (circling_step === 1) artifactType = 'reviewArtifact';
+    else if (circling_phase === 'finalization') artifactType = 'reviewSignOff';
+  } else {
+    if (circling_step === 1) artifactType = 'workerReviewsAnalysis';
+  }
+
+  parts.push('');
+  parts.push('===CIRCLING_REFLECTION===');
+  parts.push(`type: ${artifactType}`);
+  parts.push('summary: [1-2 sentences about what you did]');
+  parts.push('confidence: [0.0 to 1.0]');
+  if (circling_phase === 'finalization') {
+    parts.push('vote: [converged|blocked]');
+  } else {
+    parts.push('vote: [continue|converged|blocked]');
+  }
+  parts.push('===END_REFLECTION===');
+  parts.push('');
+  parts.push('Rules:');
+  parts.push('- Begin your output with the artifact content DIRECTLY. Do NOT include any preamble, explanation, or commentary before the artifact. Any text before the artifact delimiters (or before the reflection block for single-artifact output) is treated as part of the artifact.');
+  parts.push('- confidence: a number between 0.0 and 1.0');
+  if (circling_phase === 'finalization') {
+    parts.push('- vote: "converged" (work meets quality standards) or "blocked" (critical issue remains)');
+  } else {
+    parts.push('- vote: "continue" (more work needed), "converged" (satisfied), or "blocked" (critical issue)');
+  }
+  parts.push('- The reflection block MUST be the last thing in your response');
+
+  return parts.join('\n');
+}
+
+// Parser extracted to lib/circling-parser.js — single source of truth for both
+// production code and tests. Zero external dependencies.
+const { parseCirclingReflection: _parseCircling } = require('../lib/circling-parser');
+
+/**
+ * Parse a circling strategy output. Delegates to lib/circling-parser.js
+ * with agent-specific options (logger, legacy fallback).
+ */
+function parseCirclingReflection(output) {
+  return _parseCircling(output, {
+    log: (msg) => log(msg),
+    legacyParser: parseReflection,
+  });
+}
+
 // ── Collaborative Task Execution ──────────────────────
 
 /**
@@ -736,32 +1054,60 @@ async function executeCollabTask(task) {
       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 { round_number, shared_intel, directed_input, my_scope, my_role, mode, current_turn,
+              circling_phase, circling_step, circling_subround } = roundData;
 
       // 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)})`);
+      const isCircling = mode === 'circling_strategy';
+      const stepLabel = isCircling
+        ? `${circling_phase === 'init' ? 'Init' : circling_phase === 'finalization' ? 'Final' : `SR${circling_subround}/S${circling_step}`}`
+        : `R${round_number}`;
+      log(`COLLAB ${stepLabel}: 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 prompt — circling uses directed inputs, other modes use shared intel
+      const prompt = isCircling
+        ? buildCirclingPrompt(task, roundData)
+        : buildCollabPrompt(task, round_number, shared_intel, my_scope, my_role);
 
       if (DRY_RUN) {
         log(`[DRY RUN] Collab prompt:\n${prompt}`);
         break;
       }
 
-      // Execute Claude
+      // Execute provider (LLM or shell)
       const llmResult = await runLLM(prompt, task, worktreePath);
       const output = llmResult.stdout || '';
 
-      // Parse reflection from output
-      const reflection = parseReflection(output);
+      // Parse reflection — circling uses delimiter-based parser, others use JSON-block parser
+      let reflection;
+      let circlingArtifacts = [];
+
+      if (llmResult.provider === 'shell') {
+        reflection = {
+          summary: output.trim().slice(-500) || '(no output)',
+          learnings: '',
+          confidence: llmResult.exitCode === 0 ? 1.0 : 0.0,
+          vote: llmResult.exitCode === 0 ? 'converged' : 'continue',
+          parse_failed: false,
+        };
+      } else if (isCircling) {
+        const circResult = parseCirclingReflection(output);
+        reflection = {
+          summary: circResult.summary,
+          learnings: '',
+          confidence: circResult.confidence,
+          vote: circResult.vote,
+          parse_failed: circResult.parse_failed,
+        };
+        circlingArtifacts = circResult.circling_artifacts;
+      } else {
+        reflection = parseReflection(output);
+      }
 
       // List modified files
       let artifacts = [];
@@ -781,16 +1127,20 @@ async function executeCollabTask(task) {
           node_id: NODE_ID,
           round: round_number,
           summary: reflection.summary,
-          learnings: reflection.learnings,
+          learnings: reflection.learnings || '',
           artifacts,
           confidence: reflection.confidence,
           vote: reflection.vote,
           parse_failed: reflection.parse_failed,
+          // Circling extensions
+          circling_step: isCircling ? circling_step : null,
+          circling_artifacts: circlingArtifacts,
         });
         const parseTag = reflection.parse_failed ? ' [PARSE FAILED]' : '';
-        log(`COLLAB R${round_number}: Reflection submitted (vote: ${reflection.vote}, conf: ${reflection.confidence}${parseTag})`);
+        const artCount = circlingArtifacts.length > 0 ? `, ${circlingArtifacts.length} artifact(s)` : '';
+        log(`COLLAB ${stepLabel}: Reflection submitted (vote: ${reflection.vote}, conf: ${reflection.confidence}${parseTag}${artCount})`);
       } catch (err) {
-        log(`COLLAB R${round_number}: Reflection submit failed: ${err.message}`);
+        log(`COLLAB ${stepLabel}: Reflection submit failed: ${err.message}`);
       }
 
       // Check if session is done (converged/completed/aborted)
@@ -897,6 +1247,48 @@ async function executeTask(task) {
       continue;
     }
 
+    // ── Mesh Harness: Mechanical Enforcement (LLM-agnostic) ──
+    // Runs AFTER LLM exits successfully, BEFORE commit. This is the hard
+    // enforcement layer — it doesn't depend on the LLM obeying prompt rules.
+    const harnessResult = runMeshHarness({
+      rules: getHarnessRules(),
+      worktreePath,
+      taskScope: task.scope,
+      llmOutput: llmResult.stdout,
+      hasMetric: !!task.metric,
+      log,
+      role: getRole(task.role),
+    });
+
+    if (!harnessResult.pass) {
+      log(`HARNESS BLOCKED: ${harnessResult.violations.length} violation(s)`);
+      for (const v of harnessResult.violations) {
+        log(`  - [${v.rule}] ${v.message}`);
+      }
+      // Scope violations were already reverted by enforceScopeCheck.
+      // Secret violations block the commit entirely.
+      const hasSecrets = harnessResult.violations.some(v => v.rule === 'no-hardcoded-secrets');
+      if (hasSecrets) {
+        const attemptRecord = {
+          approach: `Attempt ${attempt}: harness blocked — secrets detected`,
+          result: harnessResult.violations.map(v => v.message).join('; '),
+          keep: false,
+        };
+        attempts.push(attemptRecord);
+        await natsRequest('mesh.tasks.attempt', { task_id: task.task_id, ...attemptRecord });
+        log(`Attempt ${attempt}: harness blocked commit (secrets). Retrying.`);
+        continue;
+      }
+      // Non-secret violations (scope reverts, output blocks): proceed with warnings
+    }
+
+    if (harnessResult.warnings.length > 0) {
+      log(`HARNESS WARNINGS: ${harnessResult.warnings.length}`);
+      for (const w of harnessResult.warnings) {
+        log(`  - [${w.rule}] ${w.message}`);
+      }
+    }
+
     // If no metric, trust LLM output and complete
     if (!task.metric) {
       const attemptRecord = {
@@ -911,11 +1303,20 @@ async function executeTask(task) {
       const mergeResult = commitAndMergeWorktree(worktreePath, task.task_id, summary);
       const keepBranch = mergeResult && !mergeResult.merged; // keep on merge conflict
 
+      // Post-commit validation (conventional commits, etc.)
+      if (mergeResult?.committed) {
+        runPostCommitValidation(getHarnessRules(), worktreePath, log);
+      }
+
       await natsRequest('mesh.tasks.complete', {
         task_id: task.task_id,
         result: {
           success: true, summary, artifacts: [],
           cost: sessionInfo?.cost || null,
+          harness: {
+            violations: harnessResult.violations,
+            warnings: harnessResult.warnings,
+          },
           sha: mergeResult?.sha || null,
           merged: mergeResult?.merged ?? null,
         },
@@ -943,6 +1344,11 @@ async function executeTask(task) {
       const mergeResult = commitAndMergeWorktree(worktreePath, task.task_id, summary);
       const keepBranch = mergeResult && !mergeResult.merged;
 
+      // Post-commit validation (conventional commits, etc.)
+      if (mergeResult?.committed) {
+        runPostCommitValidation(getHarnessRules(), worktreePath, log);
+      }
+
       await natsRequest('mesh.tasks.complete', {
         task_id: task.task_id,
         result: {
@@ -952,6 +1358,10 @@ async function executeTask(task) {
           cost: sessionInfo?.cost || null,
           sha: mergeResult?.sha || null,
           merged: mergeResult?.merged ?? null,
+          harness: {
+            violations: harnessResult.violations,
+            warnings: harnessResult.warnings,
+          },
         },
       });
       cleanupWorktree(worktreePath, keepBranch);
@@ -1005,8 +1415,9 @@ async function main() {
   log(`  Poll interval: ${POLL_INTERVAL / 1000}s`);
   log(`  Mode:        ${ONCE ? 'single task' : 'continuous'} ${DRY_RUN ? '(dry run)' : ''}`);
 
+  const natsOpts = natsConnectOpts();
   nc = await connect({
-    servers: NATS_URL,
+    ...natsOpts,
     timeout: 5000,
     reconnect: true,
     maxReconnectAttempts: 10,