openclaw-node-harness 2.0.4 → 2.1.1

package/lib/mesh-tasks.js

@@ -22,14 +22,28 @@ const KV_BUCKET = 'MESH_TASKS';
  *   released  — automation exhausted all retries, needs human triage
  *   cancelled — manually cancelled
  */
+/**
+ * Task statuses:
+ *   queued         — available for claiming
+ *   claimed        — agent has claimed, not yet started work
+ *   running        — agent is actively working
+ *   pending_review — work done, awaiting human approval (requires_review gate)
+ *   completed      — agent reports success (or human approved)
+ *   failed         — agent reports failure or budget exceeded
+ *   released       — automation exhausted all retries, needs human triage
+ *   cancelled      — manually cancelled
+ */
 const TASK_STATUS = {
   QUEUED: 'queued',
   CLAIMED: 'claimed',
   RUNNING: 'running',
+  PENDING_REVIEW: 'pending_review',
   COMPLETED: 'completed',
   FAILED: 'failed',
   RELEASED: 'released',
   CANCELLED: 'cancelled',
+  PROPOSED: 'proposed',
+  REJECTED: 'rejected',
 };
 
 /**
@@ -53,6 +67,10 @@ function createTask({
   exclude_nodes = [],
   llm_provider = null,
   llm_model = null,
+  plan_id = null,
+  subtask_id = null,
+  role = null,
+  requires_review = null,     // null = auto-compute from mode + metric
 }) {
   return {
     task_id,
@@ -64,6 +82,8 @@ function createTask({
     metric,                   // mechanical success check (e.g. "tests pass", "val_bpb < 0.99")
     on_fail,                  // what to do on failure
     scope,                    // which files/paths the agent can touch
+    role,                     // role profile ID (e.g. "solidity-dev") for prompt injection + output validation
+    requires_review,          // null = auto-computed by daemon; true/false = explicit override
 
     // Standard fields
     success_criteria,
@@ -94,6 +114,10 @@ function createTask({
     budget_deadline: null,    // set when claimed: claimed_at + budget_minutes
     last_activity: null,      // updated by agent heartbeats — stall detection key
 
+    // Plan back-reference (O(1) lookup in checkPlanProgress)
+    plan_id,                  // parent plan ID (null if standalone task)
+    subtask_id,               // subtask ID within the plan (null if standalone task)
+
     // Result (filled by agent)
     result: null,             // { success, summary, artifacts, attempts }
     attempts: [],             // log of approaches tried
@@ -118,6 +142,28 @@ class TaskStore {
     return JSON.parse(sc.decode(entry.value));
   }
 
+  /**
+   * Compare-and-swap helper: read → mutate → write with optimistic concurrency.
+   * Re-reads and retries on conflict (up to maxRetries).
+   * mutateFn receives the parsed data and must return the updated object, or falsy to skip.
+   */
+  async _updateWithCAS(key, mutateFn, maxRetries = 3) {
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      const entry = await this.kv.get(key);
+      if (!entry) return null;
+      const data = JSON.parse(sc.decode(entry.value));
+      const updated = mutateFn(data);
+      if (!updated) return null;
+      try {
+        await this.kv.put(key, sc.encode(JSON.stringify(updated)), { previousSeq: entry.revision });
+        return updated;
+      } catch (err) {
+        if (attempt === maxRetries - 1) throw err;
+        // conflict — retry
+      }
+    }
+  }
+
   async delete(taskId) {
     await this.kv.delete(taskId);
   }
@@ -189,67 +235,106 @@ class TaskStore {
     if (claimable.length === 0) return null;
 
     const task = claimable[0];
-    task.status = TASK_STATUS.CLAIMED;
-    task.owner = nodeId;
-    task.claimed_at = new Date().toISOString();
-    const budgetMs = (task.budget_minutes || 30) * 60 * 1000;
-    task.budget_deadline = new Date(Date.now() + budgetMs).toISOString();
-
-    await this.put(task);
-    return task;
+    const result = await this._updateWithCAS(task.task_id, (t) => {
+      // Re-check status under CAS — another node may have claimed it
+      if (t.status !== TASK_STATUS.QUEUED) return null;
+      t.status = TASK_STATUS.CLAIMED;
+      t.owner = nodeId;
+      t.claimed_at = new Date().toISOString();
+      const budgetMs = (t.budget_minutes || 30) * 60 * 1000;
+      t.budget_deadline = new Date(Date.now() + budgetMs).toISOString();
+      return t;
+    });
+    return result;
   }
 
   /**
    * Mark a task as running (agent started work).
    */
   async markRunning(taskId) {
-    const task = await this.get(taskId);
-    if (!task) return null;
-    task.status = TASK_STATUS.RUNNING;
-    task.started_at = new Date().toISOString();
-    await this.put(task);
-    return task;
+    return this._updateWithCAS(taskId, (task) => {
+      task.status = TASK_STATUS.RUNNING;
+      task.started_at = new Date().toISOString();
+      return task;
+    });
   }
 
   /**
    * Mark a task as completed with result.
    */
   async markCompleted(taskId, result) {
-    const task = await this.get(taskId);
-    if (!task) return null;
-    task.status = TASK_STATUS.COMPLETED;
-    task.completed_at = new Date().toISOString();
-    task.result = result;
-    await this.put(task);
-    return task;
+    return this._updateWithCAS(taskId, (task) => {
+      task.status = TASK_STATUS.COMPLETED;
+      task.completed_at = new Date().toISOString();
+      task.result = result;
+      return task;
+    });
+  }
+
+  /**
+   * Mark a task as pending_review (work done, needs human approval).
+   * Stores the result but doesn't transition to completed.
+   */
+  async markPendingReview(taskId, result) {
+    return this._updateWithCAS(taskId, (task) => {
+      task.status = TASK_STATUS.PENDING_REVIEW;
+      task.result = result;
+      task.review_requested_at = new Date().toISOString();
+      return task;
+    });
+  }
+
+  /**
+   * Approve a pending_review task → completed.
+   */
+  async markApproved(taskId) {
+    return this._updateWithCAS(taskId, (task) => {
+      if (task.status !== TASK_STATUS.PENDING_REVIEW) return null;
+      task.status = TASK_STATUS.COMPLETED;
+      task.completed_at = new Date().toISOString();
+      task.reviewed_by = 'human';
+      return task;
+    });
+  }
+
+  /**
+   * Reject a pending_review task → re-queue with reason.
+   */
+  async markRejected(taskId, reason) {
+    return this._updateWithCAS(taskId, (task) => {
+      if (task.status !== TASK_STATUS.PENDING_REVIEW) return null;
+      task.status = TASK_STATUS.QUEUED;
+      task.rejection_reason = reason;
+      task.result = null;
+      task.review_requested_at = null;
+      return task;
+    });
   }
 
   /**
    * Mark a task as failed with reason.
    */
   async markFailed(taskId, reason, attempts = []) {
-    const task = await this.get(taskId);
-    if (!task) return null;
-    task.status = TASK_STATUS.FAILED;
-    task.completed_at = new Date().toISOString();
-    task.result = { success: false, summary: reason };
-    task.attempts = attempts;
-    await this.put(task);
-    return task;
+    return this._updateWithCAS(taskId, (task) => {
+      task.status = TASK_STATUS.FAILED;
+      task.completed_at = new Date().toISOString();
+      task.result = { success: false, summary: reason };
+      task.attempts = attempts;
+      return task;
+    });
   }
 
   /**
    * Log an attempt on a task (agent tried something, may or may not have worked).
    */
   async logAttempt(taskId, attempt) {
-    const task = await this.get(taskId);
-    if (!task) return null;
-    task.attempts.push({
-      ...attempt,
-      timestamp: new Date().toISOString(),
+    return this._updateWithCAS(taskId, (task) => {
+      task.attempts.push({
+        ...attempt,
+        timestamp: new Date().toISOString(),
+      });
+      return task;
     });
-    await this.put(task);
-    return task;
   }
 
   /**
@@ -257,25 +342,23 @@ class TaskStore {
    * Distinct from failed: failed = "didn't work", released = "we tried everything."
    */
   async markReleased(taskId, reason, attempts = []) {
-    const task = await this.get(taskId);
-    if (!task) return null;
-    task.status = TASK_STATUS.RELEASED;
-    task.completed_at = new Date().toISOString();
-    task.result = { success: false, summary: reason, released: true };
-    if (attempts.length > 0) task.attempts = attempts;
-    await this.put(task);
-    return task;
+    return this._updateWithCAS(taskId, (task) => {
+      task.status = TASK_STATUS.RELEASED;
+      task.completed_at = new Date().toISOString();
+      task.result = { success: false, summary: reason, released: true };
+      if (attempts.length > 0) task.attempts = attempts;
+      return task;
+    });
   }
 
   /**
    * Update last_activity timestamp (agent heartbeat).
    */
   async touchActivity(taskId) {
-    const task = await this.get(taskId);
-    if (!task) return null;
-    task.last_activity = new Date().toISOString();
-    await this.put(task);
-    return task;
+    return this._updateWithCAS(taskId, (task) => {
+      task.last_activity = new Date().toISOString();
+      return task;
+    });
   }
 
   /**

package/lib/nats-resolve.js

@@ -37,7 +37,7 @@ function resolveNatsUrl() {
     if (fs.existsSync(envFile)) {
       const content = fs.readFileSync(envFile, 'utf8');
       const match = content.match(/^\s*OPENCLAW_NATS\s*=\s*(.+)/m);
-      if (match && match[1].trim()) return match[1].trim();
+      if (match && match[1].trim()) return match[1].trim().replace(/^["']|["']$/g, '');
     }
   } catch {
     // File unreadable — fall through silently
@@ -49,7 +49,7 @@ function resolveNatsUrl() {
     if (fs.existsSync(meshConfig)) {
       const content = fs.readFileSync(meshConfig, 'utf8');
       const match = content.match(/^\s*OPENCLAW_NATS\s*=\s*(.+)/m);
-      if (match && match[1].trim()) return match[1].trim();
+      if (match && match[1].trim()) return match[1].trim().replace(/^["']|["']$/g, '');
     }
   } catch {
     // File unreadable — fall through silently
@@ -73,7 +73,7 @@ function resolveNatsToken() {
     if (fs.existsSync(envFile)) {
       const content = fs.readFileSync(envFile, 'utf8');
       const match = content.match(/^\s*OPENCLAW_NATS_TOKEN\s*=\s*(.+)/m);
-      if (match && match[1].trim()) return match[1].trim();
+      if (match && match[1].trim()) return match[1].trim().replace(/^["']|["']$/g, '');
     }
   } catch {}
 
@@ -83,7 +83,7 @@ function resolveNatsToken() {
     if (fs.existsSync(meshConfig)) {
       const content = fs.readFileSync(meshConfig, 'utf8');
       const match = content.match(/^\s*OPENCLAW_NATS_TOKEN\s*=\s*(.+)/m);
-      if (match && match[1].trim()) return match[1].trim();
+      if (match && match[1].trim()) return match[1].trim().replace(/^["']|["']$/g, '');
     }
   } catch {}
 

package/lib/plan-templates.js

@@ -0,0 +1,226 @@
+/**
+ * plan-templates.js — Load, validate, and instantiate plan templates.
+ *
+ * Templates are YAML files in .openclaw/plan-templates/ that define
+ * reusable multi-phase pipelines. Instantiation substitutes context
+ * variables and produces a plan ready for mesh.plans.create.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+const { autoRoutePlan, createPlan } = require('./mesh-plans');
+
+// ── Template Loading ──────────────────────────────
+
+/**
+ * Load a single template from a YAML file.
+ */
+function loadTemplate(templatePath) {
+  const content = fs.readFileSync(templatePath, 'utf-8');
+  const template = yaml.load(content);
+
+  if (!template.id) {
+    template.id = path.basename(templatePath, '.yaml');
+  }
+
+  return template;
+}
+
+/**
+ * List all available templates in a directory.
+ * Returns array of { id, name, description, file }.
+ */
+function listTemplates(templatesDir) {
+  if (!fs.existsSync(templatesDir)) return [];
+
+  return fs.readdirSync(templatesDir)
+    .filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))
+    .map(file => {
+      try {
+        const template = loadTemplate(path.join(templatesDir, file));
+        return {
+          id: template.id,
+          name: template.name || template.id,
+          description: template.description || '',
+          file,
+        };
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+// ── Template Validation ───────────────────────────
+
+/**
+ * Validate a template for structural correctness.
+ * Returns { valid: boolean, errors: string[] }.
+ */
+function validateTemplate(template) {
+  const errors = [];
+
+  if (!template.id) errors.push('Missing template id');
+  if (!template.phases || !Array.isArray(template.phases)) {
+    errors.push('Missing or invalid phases array');
+    return { valid: false, errors };
+  }
+
+  const allIds = new Set();
+  const allSubtasks = [];
+
+  for (let i = 0; i < template.phases.length; i++) {
+    const phase = template.phases[i];
+    if (!phase.subtasks || !Array.isArray(phase.subtasks)) {
+      errors.push(`Phase ${i}: missing subtasks array`);
+      continue;
+    }
+
+    for (const st of phase.subtasks) {
+      if (!st.id) {
+        errors.push(`Phase ${i}: subtask missing id`);
+        continue;
+      }
+      if (allIds.has(st.id)) {
+        errors.push(`Duplicate subtask id: ${st.id}`);
+      }
+      allIds.add(st.id);
+      allSubtasks.push(st);
+    }
+  }
+
+  // Check dependency references
+  for (const st of allSubtasks) {
+    if (st.depends_on) {
+      for (const dep of st.depends_on) {
+        if (!allIds.has(dep)) {
+          errors.push(`Subtask ${st.id}: depends on unknown subtask '${dep}'`);
+        }
+      }
+    }
+  }
+
+  // Check for circular dependencies (simple DFS)
+  const visiting = new Set();
+  const visited = new Set();
+  const stMap = new Map(allSubtasks.map(st => [st.id, st]));
+
+  function hasCycle(id) {
+    if (visiting.has(id)) return true;
+    if (visited.has(id)) return false;
+    visiting.add(id);
+    const st = stMap.get(id);
+    if (st && st.depends_on) {
+      for (const dep of st.depends_on) {
+        if (hasCycle(dep)) return true;
+      }
+    }
+    visiting.delete(id);
+    visited.add(id);
+    return false;
+  }
+
+  for (const id of allIds) {
+    if (hasCycle(id)) {
+      errors.push(`Circular dependency detected involving subtask '${id}'`);
+      break;
+    }
+  }
+
+  // Validate delegation modes
+  const validModes = ['solo_mesh', 'collab_mesh', 'local', 'soul', 'human', 'auto'];
+  for (const st of allSubtasks) {
+    if (st.delegation && st.delegation.mode && !validModes.includes(st.delegation.mode)) {
+      errors.push(`Subtask ${st.id}: invalid delegation mode '${st.delegation.mode}'`);
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+// ── Template Instantiation ────────────────────────
+
+/**
+ * Substitute {{context}} and {{vars.key}} in all string fields.
+ */
+function substituteVars(obj, context, vars = {}) {
+  if (typeof obj === 'string') {
+    let result = obj.replace(/\{\{context\}\}/g, context);
+    for (const [key, val] of Object.entries(vars)) {
+      result = result.replace(new RegExp(`\\{\\{vars\\.${key}\\}\\}`, 'g'), String(val));
+    }
+    return result;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(item => substituteVars(item, context, vars));
+  }
+  if (obj && typeof obj === 'object') {
+    const result = {};
+    for (const [key, val] of Object.entries(obj)) {
+      result[key] = substituteVars(val, context, vars);
+    }
+    return result;
+  }
+  return obj;
+}
+
+/**
+ * Instantiate a template into a plan-ready object.
+ *
+ * @param {object} template — loaded template
+ * @param {string} context — main context string (substituted into {{context}})
+ * @param {object} opts — { parent_task_id, vars, planner }
+ * @returns {object} — plan object ready for mesh.plans.create
+ */
+function instantiateTemplate(template, context, opts = {}) {
+  const { parent_task_id, vars = {}, planner = 'daedalus' } = opts;
+
+  // Flatten phases into subtask array with dependency wiring
+  const subtasks = [];
+
+  for (const phase of template.phases) {
+    for (const stSpec of phase.subtasks) {
+      const substituted = substituteVars(stSpec, context, vars);
+
+      const subtask = {
+        subtask_id: substituted.id,
+        title: substituted.title || substituted.id,
+        description: substituted.description || '',
+        delegation: substituted.delegation || { mode: 'auto' },
+        budget_minutes: parseInt(substituted.budget_minutes) || 15,
+        metric: substituted.metric || null,
+        scope: substituted.scope || [],
+        success_criteria: substituted.success_criteria || [],
+        depends_on: substituted.depends_on || [],
+        critical: substituted.critical || false,
+      };
+
+      subtasks.push(subtask);
+    }
+  }
+
+  // Create the plan
+  const plan = createPlan({
+    parent_task_id: parent_task_id || `TEMPLATE-${template.id}-${Date.now()}`,
+    title: substituteVars(template.name || template.id, context, vars),
+    description: substituteVars(template.description || '', context, vars),
+    planner,
+    failure_policy: template.failure_policy || 'continue_best_effort',
+    requires_approval: template.requires_approval !== false, // default true
+    subtasks,
+  });
+
+  // Auto-route any subtasks with mode: 'auto'
+  autoRoutePlan(plan);
+
+  return plan;
+}
+
+module.exports = {
+  loadTemplate,
+  listTemplates,
+  validateTemplate,
+  instantiateTemplate,
+  substituteVars,
+};