openclaw-node-harness 2.0.0

package/workspace-bin/soul-prompt

@@ -0,0 +1,251 @@
+#!/usr/bin/env bash
+# soul-prompt — Assemble a soul-enriched preamble for Task tool spawning
+#
+# Usage:
+#   bin/soul-prompt <soul-id> [--task-id T-xxx] [--extra-context "..."]
+#
+# Outputs:
+#   stdout: the assembled prompt preamble
+#   stderr: the recommended subagent_type (general-purpose or Explore)
+
+set -euo pipefail
+
+SOULS_DIR="${HOME}/.openclaw/souls"
+HANDOFFS_DIR="${HOME}/.openclaw/workspace/memory-vault/handoffs"
+
+# --- Parse args ---
+SOUL_ID=""
+TASK_ID=""
+EXTRA_CONTEXT=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --extra-context)
+      EXTRA_CONTEXT="$2"
+      shift 2
+      ;;
+    -*)
+      echo "Unknown option: $1" >&2
+      exit 1
+      ;;
+    *)
+      SOUL_ID="$1"
+      shift
+      ;;
+  esac
+done
+
+if [[ -z "$SOUL_ID" ]]; then
+  echo "Usage: soul-prompt <soul-id> [--task-id T-xxx] [--extra-context \"...\"]" >&2
+  exit 1
+fi
+
+SOUL_DIR="${SOULS_DIR}/${SOUL_ID}"
+
+if [[ ! -d "$SOUL_DIR" ]]; then
+  echo "ERROR: Soul '${SOUL_ID}' not found at ${SOUL_DIR}" >&2
+  exit 1
+fi
+
+# --- Parse all JSON + determine subagent_type in a single subprocess ---
+CAPS_FILE="${SOUL_DIR}/capabilities.json"
+GENES_FILE="${SOUL_DIR}/evolution/genes.json"
+
+# Single Python call: outputs subagent_type to fd3, genes markdown + constraints markdown to stdout
+PARSED=$(python3 -c "
+import json, sys, os
+
+caps_file = '${CAPS_FILE}'
+genes_file = '${GENES_FILE}'
+out = []
+
+# --- Subagent type from capabilities ---
+subagent_type = 'general-purpose'
+caps = {}
+if os.path.isfile(caps_file):
+    caps = json.load(open(caps_file))
+    tools = caps.get('tools', [])
+    if not any(t in tools for t in ['Write', 'Edit', 'Bash']):
+        subagent_type = 'Explore'
+
+print('SUBAGENT_TYPE=' + subagent_type, file=sys.stderr)
+
+# --- Genes markdown ---
+if os.path.isfile(genes_file):
+    data = json.load(open(genes_file))
+    genes = data.get('genes', [])
+    if genes:
+        out.append('---')
+        out.append('')
+        out.append('# Learned Patterns (apply these during analysis)')
+        out.append('')
+        for gene in genes:
+            out.append(f'## {gene[\"id\"]}')
+            out.append(f'**Category:** {gene.get(\"category\", \"unknown\")}')
+            out.append(f'**Signal:** {gene.get(\"signal\", \"\")}')
+            for p in gene.get('preconditions', []):
+                out.append(f'  - {p}')
+            strategy = gene.get('strategy', [])
+            if strategy:
+                out.append('**Strategy:**')
+                for s in strategy:
+                    out.append(f'  1. {s}')
+            out.append('')
+
+# --- Capabilities / constraints markdown ---
+if caps:
+    perms = caps.get('permissions', {})
+    memory = perms.get('memory', {})
+    restricted = perms.get('restrictedActions', [])
+    tools = caps.get('tools', [])
+
+    if memory or restricted or tools:
+        out.append('---')
+        out.append('')
+        out.append('# Operational Constraints')
+        out.append('')
+        if memory:
+            out.append('## Memory Access')
+            for k, v in memory.items():
+                out.append(f'- **{k}:** {v}')
+            out.append('')
+        if restricted:
+            out.append('## Restricted Actions (DO NOT execute these)')
+            for r in restricted:
+                out.append(f'- {r}')
+            out.append('')
+        if tools:
+            out.append('## Available Tools')
+            out.append(', '.join(tools))
+            out.append('')
+
+print('\n'.join(out))
+" 2>"${TMPDIR:-/tmp}/soul-prompt-meta.$$" || true)
+
+# Extract subagent type from stderr output (portable: no grep -P on macOS)
+SUBAGENT_TYPE=$(sed -n 's/^SUBAGENT_TYPE=//p' "${TMPDIR:-/tmp}/soul-prompt-meta.$$" 2>/dev/null || echo "general-purpose")
+rm -f "${TMPDIR:-/tmp}/soul-prompt-meta.$$"
+echo "$SUBAGENT_TYPE" >&2
+
+# --- Assemble preamble ---
+
+# 1. Identity (SOUL.md) — static
+SOUL_MD="${SOUL_DIR}/SOUL.md"
+if [[ -f "$SOUL_MD" ]]; then
+  echo "# Soul Identity"
+  echo ""
+  cat "$SOUL_MD"
+  echo ""
+fi
+
+# 2. Principles (PRINCIPLES.md) — static
+PRINCIPLES_MD="${SOUL_DIR}/PRINCIPLES.md"
+if [[ -f "$PRINCIPLES_MD" ]]; then
+  echo "---"
+  echo ""
+  echo "# Decision Principles"
+  echo ""
+  cat "$PRINCIPLES_MD"
+  echo ""
+fi
+
+# 3-4. Genes + Constraints (from single Python call above)
+if [[ -n "$PARSED" ]]; then
+  echo "$PARSED"
+fi
+
+# 5. Handoff context (if task-id provided)
+if [[ -n "$TASK_ID" ]]; then
+  HANDOFF_DOC="${HANDOFFS_DIR}/${TASK_ID}-handoff.md"
+  if [[ -f "$HANDOFF_DOC" ]]; then
+    echo "---"
+    echo ""
+    echo "# Task Handoff Context"
+    echo ""
+    cat "$HANDOFF_DOC"
+    echo ""
+  fi
+fi
+
+# 6. Extra context
+if [[ -n "$EXTRA_CONTEXT" ]]; then
+  echo "---"
+  echo ""
+  echo "# Additional Context"
+  echo ""
+  echo "$EXTRA_CONTEXT"
+  echo ""
+fi
+
+# 7. Trust tier + autonomy level (from trust-registry)
+WORKSPACE="$(cd "$(dirname "$0")/.." && pwd)"
+TRUST_REGISTRY="${WORKSPACE}/.tmp/trust-registry.json"
+if [[ -f "$TRUST_REGISTRY" ]]; then
+  TRUST_INFO=$(python3 -c "
+import json, sys
+reg = json.load(open('${TRUST_REGISTRY}'))
+s = reg.get('souls', {}).get('${SOUL_ID}', {})
+total = s.get('tasks_total', 0)
+succeeded = s.get('tasks_succeeded', 0)
+if total == 0:
+    trust = 0.5
+else:
+    success_rate = succeeded / total
+    verified = s.get('tasks_verified', 0)
+    avg_turns = s.get('avg_turns', 10.0)
+    ver_rate = verified / max(1, succeeded)
+    eff = max(0.0, 1.0 - min(1.0, avg_turns / 20.0))
+    trust = round(success_rate * 0.50 + ver_rate * 0.30 + eff * 0.20, 3)
+if total >= 25 and trust >= 0.80: tier = 'expert'
+elif total >= 10 and trust >= 0.65: tier = 'proven'
+elif total >= 3 and trust >= 0.50: tier = 'developing'
+else: tier = 'new'
+autonomy = {'new': 'atomic', 'developing': 'guided', 'proven': 'open-ended', 'expert': 'full'}[tier]
+print(f'Trust: {trust} | Tier: {tier} | Autonomy: {autonomy} | Track record: {succeeded}/{total}')
+" 2>/dev/null || echo "Trust: 0.500 | Tier: new | Autonomy: atomic | Track record: 0/0")
+  echo "---"
+  echo ""
+  echo "# Delegation Trust"
+  echo ""
+  echo "$TRUST_INFO"
+  echo ""
+fi
+
+# 7b. Circuit breaker check
+CB_OUT=$("$WORKSPACE/bin/trust-registry" check "${SOUL_ID}" 2>/dev/null) || true
+if echo "$CB_OUT" | grep -q "OPEN"; then
+  echo "---"
+  echo ""
+  echo "# ⚡ Circuit Breaker Warning"
+  echo ""
+  echo "This soul's circuit breaker is OPEN due to consecutive failures."
+  echo "Delegation is not recommended. Consider using an alternative soul."
+  echo ""
+fi
+
+# 8. Standard completion protocol + contract template
+echo "---"
+echo ""
+echo "# Completion Protocol"
+echo ""
+echo "- When done: report what was accomplished concisely"
+echo "- If blocked: surface the blocker immediately — do not spiral or guess"
+echo "- Do not add scope beyond what was asked"
+echo "- Prefer editing existing files over creating new ones"
+echo "- Security-first: no secrets in output, no destructive commands without confirmation"
+echo "- No writing to genome files (SOUL.md, PRINCIPLES.md, AGENTS.md, MEMORY.md)"
+echo ""
+echo "## Contract (delegator fills this in)"
+echo ""
+echo "- **Deliverable:** [to be specified]"
+echo "- **Verification:** [to be specified] + \`bin/quality-gate --files <changed-files>\` exits 0 or 2"
+echo "- **Boundaries:** [to be specified]"
+echo "- **Budget:** 15 turns max (default)"
+echo "- **Criticality:** normal | high"
+echo "- **Escalation:** Report blocker immediately, do not retry more than once"
+echo "- **Quality Gate:** Run \`bin/quality-gate --files <changed-files>\` before reporting done"
+echo "- **Screenshot Gate:** If modifying UI files (*.tsx/*.jsx in components/pages/app/, *.css), include visual evidence in artifacts"

package/workspace-bin/subagent-audit.mjs

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+/**
+ * subagent-audit.mjs — Scan JSONL transcripts for sub-agent delegation patterns
+ *
+ * Extracts Task tool invocations from session transcripts, classifies outcomes,
+ * and auto-updates the trust registry + lessons file.
+ *
+ * Usage:
+ *   node bin/subagent-audit.mjs [--dry-run] <jsonl-path>    # audit one file
+ *   node bin/subagent-audit.mjs --health-check               # trust registry health
+ *
+ * Called by memory-daemon:
+ *   - Phase 0 (bootstrap): audit previous session's JSONL
+ *   - Phase 2 (throttled): --health-check every 30min
+ */
+
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import path from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { createInterface } from 'readline';
+
+const execFileAsync = promisify(execFile);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const WORKSPACE = process.env.OPENCLAW_WORKSPACE || path.dirname(__dirname);
+const TRUST_REGISTRY = path.join(WORKSPACE, 'bin/trust-registry');
+const LESSONS_FILE = path.join(WORKSPACE, '.learnings/lessons.md');
+
+// ============================================================
+// JSONL PARSER — Extract Task tool invocations
+// ============================================================
+
+/**
+ * Audit a JSONL file for sub-agent delegations.
+ * @param {string} jsonlPath
+ * @returns {Promise<DelegationResult[]>}
+ */
+export async function auditSession(jsonlPath) {
+  if (!fs.existsSync(jsonlPath)) return [];
+
+  const results = [];
+  const pendingTasks = new Map(); // tool_use_id → { soulId, description, timestamp, lineNum }
+
+  const rl = createInterface({
+    input: fs.createReadStream(jsonlPath, { encoding: 'utf-8' }),
+    crlfDelay: Infinity,
+  });
+
+  let lineNum = 0;
+
+  for await (const line of rl) {
+    lineNum++;
+    if (!line.trim()) continue;
+
+    let obj;
+    try { obj = JSON.parse(line); } catch { continue; }
+
+    // Look for assistant messages with tool_use blocks
+    const content = obj.message?.content;
+    if (!Array.isArray(content)) continue;
+
+    for (const block of content) {
+      // Task tool invocation
+      if (block.type === 'tool_use' && block.name === 'Task') {
+        const input = block.input || {};
+        const soulId = input.name || input.subagent_type || 'unknown';
+        pendingTasks.set(block.id, {
+          soulId,
+          description: input.description || input.prompt?.slice(0, 100) || 'no description',
+          timestamp: obj.timestamp || new Date().toISOString(),
+          lineNum,
+        });
+      }
+
+      // Tool result — match to pending Task
+      if (block.type === 'tool_result' && pendingTasks.has(block.tool_use_id)) {
+        const task = pendingTasks.get(block.tool_use_id);
+        pendingTasks.delete(block.tool_use_id);
+
+        const resultText = extractResultText(block);
+        const result = classifyResult(resultText, block.is_error);
+        const errorPattern = result === 'failure' ? extractErrorPattern(resultText) : null;
+        const turnsEstimate = Math.max(1, Math.floor((lineNum - task.lineNum) / 3));
+
+        results.push({
+          soulId: task.soulId,
+          taskDescription: task.description,
+          turnsConsumed: turnsEstimate,
+          result,
+          errorPattern,
+          timestamp: task.timestamp,
+        });
+      }
+    }
+
+    // Also check top-level tool_result entries (Claude Code format)
+    if (obj.type === 'tool_result' && obj.tool_use_id && pendingTasks.has(obj.tool_use_id)) {
+      const task = pendingTasks.get(obj.tool_use_id);
+      pendingTasks.delete(obj.tool_use_id);
+
+      const resultText = typeof obj.content === 'string' ? obj.content : JSON.stringify(obj.content || '');
+      const result = classifyResult(resultText, obj.is_error);
+      const errorPattern = result === 'failure' ? extractErrorPattern(resultText) : null;
+
+      results.push({
+        soulId: task.soulId,
+        taskDescription: task.description,
+        turnsConsumed: Math.max(1, Math.floor((lineNum - task.lineNum) / 3)),
+        result,
+        errorPattern,
+        timestamp: task.timestamp,
+      });
+    }
+  }
+
+  return results;
+}
+
+function extractResultText(block) {
+  if (typeof block.content === 'string') return block.content;
+  if (Array.isArray(block.content)) {
+    return block.content
+      .filter(b => b.type === 'text')
+      .map(b => b.text)
+      .join(' ');
+  }
+  return JSON.stringify(block.content || '');
+}
+
+function classifyResult(text, isError) {
+  if (isError) return 'failure';
+  if (!text) return 'unknown';
+
+  const lower = text.toLowerCase();
+
+  // Explicit failure markers
+  if (lower.includes('error:') || lower.includes('failed') ||
+      lower.includes('could not') || lower.includes('blocked') ||
+      lower.includes('permission denied') || lower.includes('is_error')) {
+    return 'failure';
+  }
+
+  // Explicit success markers
+  if (lower.includes('completed') || lower.includes('done') ||
+      lower.includes('success') || lower.includes('finished')) {
+    return 'success';
+  }
+
+  // Heuristic: long output without error markers is likely success
+  if (text.length > 500 && !lower.includes('error') && !lower.includes('fail')) {
+    return 'success';
+  }
+
+  return 'unknown';
+}
+
+function extractErrorPattern(text) {
+  if (!text) return null;
+  // First meaningful sentence
+  const sentences = text.split(/[.!?\n]/).filter(s => s.trim().length > 10);
+  return sentences[0]?.trim().slice(0, 200) || null;
+}
+
+// ============================================================
+// RESULT PROCESSING — Update trust registry + lessons
+// ============================================================
+
+/**
+ * Process audit results: update trust-registry, append failures to lessons.
+ */
+export async function processResults(resultsList, dryRun = false) {
+  for (const r of resultsList) {
+    if (r.result === 'unknown') continue;
+
+    if (!dryRun) {
+      // Update trust registry
+      try {
+        await execFileAsync('python3', [
+          TRUST_REGISTRY, 'update', r.soulId,
+          '--result', r.result,
+          '--turns', String(r.turnsConsumed),
+          '--task', r.taskDescription.slice(0, 200),
+        ], { cwd: WORKSPACE, timeout: 10000 });
+      } catch (e) {
+        // Trust registry might not exist yet — that's OK
+        if (!e.message.includes('ENOENT')) {
+          console.error(`Trust registry update failed for ${r.soulId}: ${e.message}`);
+        }
+      }
+
+      // Append failures to lessons
+      if (r.result === 'failure' && r.errorPattern) {
+        const today = new Date().toISOString().split('T')[0];
+        const entry = `[error] Sub-agent ${r.soulId} failed: ${r.errorPattern} (auto-extracted, ${today})\n`;
+        try {
+          fs.appendFileSync(LESSONS_FILE, entry);
+        } catch { /* lessons file might not exist */ }
+      }
+    }
+  }
+}
+
+/**
+ * Trust registry health check — report open circuits and stale entries.
+ */
+export async function healthCheck(dryRun = false) {
+  if (!fs.existsSync(TRUST_REGISTRY)) {
+    console.log('Trust registry not found — skipping health check');
+    return;
+  }
+
+  try {
+    const { stdout } = await execFileAsync('python3', [TRUST_REGISTRY, 'status'], {
+      cwd: WORKSPACE, timeout: 10000,
+    });
+    if (stdout.trim()) {
+      console.log('Trust registry status:');
+      console.log(stdout);
+    }
+  } catch (e) {
+    console.error(`Trust registry health check failed: ${e.message}`);
+  }
+}
+
+// ============================================================
+// CLI
+// ============================================================
+
+const isMain = process.argv[1] && fs.realpathSync(process.argv[1]) === fs.realpathSync(__filename);
+if (isMain) {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes('--dry-run');
+  const doHealthCheck = args.includes('--health-check');
+  const jsonlPath = args.find(a => !a.startsWith('--'));
+
+  if (doHealthCheck) {
+    healthCheck(dryRun).catch(e => { console.error(e.message); process.exit(1); });
+  } else if (jsonlPath) {
+    auditSession(jsonlPath)
+      .then(async results => {
+        console.log(`Found ${results.length} delegations:`);
+        for (const r of results) {
+          const icon = r.result === 'success' ? '+' : r.result === 'failure' ? '!' : '?';
+          console.log(`  [${icon}] ${r.soulId}: ${r.taskDescription} (${r.turnsConsumed} turns, ${r.result})`);
+          if (r.errorPattern) console.log(`      Error: ${r.errorPattern}`);
+        }
+
+        const actionable = results.filter(r => r.result !== 'unknown');
+        if (actionable.length > 0) {
+          if (dryRun) {
+            console.log(`\nDry run: would update ${actionable.length} trust registry entries`);
+          } else {
+            await processResults(results);
+            console.log(`\nUpdated ${actionable.length} trust registry entries`);
+          }
+        }
+      })
+      .catch(e => { console.error(e.message); process.exit(1); });
+  } else {
+    console.log('Usage:');
+    console.log('  node bin/subagent-audit.mjs [--dry-run] <jsonl-path>');
+    console.log('  node bin/subagent-audit.mjs --health-check');
+  }
+}

package/workspace-bin/test-multi-soul-workflow

@@ -0,0 +1,130 @@
+#!/usr/bin/env bash
+# Multi-Soul Workflow Test Script
+# Tests: soul registry, task handoff, evolution
+
+set -euo pipefail
+
+API_BASE="http://localhost:3000/api"
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+echo "=== Multi-Soul Workflow Test ==="
+echo
+
+# Test 1: Soul Registry
+echo "Test 1: Soul Registry"
+SOUL_COUNT=$(curl -s ${API_BASE}/souls | jq '. | length')
+if [[ "$SOUL_COUNT" -ge 3 ]]; then
+  echo -e "${GREEN}✓ Soul registry has $SOUL_COUNT souls${NC}"
+else
+  echo -e "${RED}✗ Expected at least 3 souls, got $SOUL_COUNT${NC}"
+  exit 1
+fi
+
+# Test 2: Task Handoff
+echo
+echo "Test 2: Task Handoff"
+TASK_ID="TEST-$(date +%s)"
+curl -s -X POST ${API_BASE}/tasks -H "Content-Type: application/json" -d "{
+  \"id\": \"$TASK_ID\",
+  \"title\": \"Test handoff workflow\",
+  \"status\": \"running\",
+  \"kanbanColumn\": \"in_progress\",
+  \"owner\": \"daedalus\",
+  \"soulId\": \"daedalus\"
+}" > /dev/null
+
+HANDOFF_RESULT=$(curl -s -X POST ${API_BASE}/tasks/${TASK_ID}/handoff \
+  -H "Content-Type: application/json" \
+  -d '{"toSoul":"blockchain-auditor","reason":"Test handoff"}' | jq -r '.success')
+
+if [[ "$HANDOFF_RESULT" == "true" ]]; then
+  echo -e "${GREEN}✓ Task handoff successful${NC}"
+else
+  echo -e "${RED}✗ Task handoff failed${NC}"
+  exit 1
+fi
+
+# Verify handoff document created
+HANDOFF_DOC="${HOME}/.openclaw/workspace/memory-vault/handoffs/${TASK_ID}-handoff.md"
+if [[ -f "$HANDOFF_DOC" ]]; then
+  echo -e "${GREEN}✓ Handoff document created${NC}"
+else
+  echo -e "${RED}✗ Handoff document not found${NC}"
+  exit 1
+fi
+
+# Test 3: Evolution Event
+echo
+echo "Test 3: Evolution System"
+EVENT_ID="evt_test_$(date +%s)"
+curl -s -X POST ${API_BASE}/souls/blockchain-auditor/evolution \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"eventId\": \"$EVENT_ID\",
+    \"soulId\": \"blockchain-auditor\",
+    \"category\": \"test\",
+    \"trigger\": \"test\",
+    \"summary\": \"Test evolution event\",
+    \"proposedChange\": {
+      \"target\": \"genes.json\",
+      \"action\": \"add\",
+      \"content\": {
+        \"id\": \"gene_test\",
+        \"category\": \"test\"
+      }
+    },
+    \"reviewStatus\": \"pending\"
+  }" > /dev/null
+
+PENDING_COUNT=$(curl -s "${API_BASE}/souls/blockchain-auditor/evolution?status=pending" | jq '. | length')
+if [[ "$PENDING_COUNT" -ge 1 ]]; then
+  echo -e "${GREEN}✓ Evolution event created (${PENDING_COUNT} pending)${NC}"
+else
+  echo -e "${RED}✗ Evolution event not found${NC}"
+  exit 1
+fi
+
+# Test 4: Evolution Approval
+echo
+echo "Test 4: Evolution Approval"
+APPROVAL_RESULT=$(curl -s -X PATCH "${API_BASE}/souls/blockchain-auditor/evolution?eventId=${EVENT_ID}" \
+  -H "Content-Type: application/json" \
+  -d '{"action":"approve","reviewedBy":"daedalus"}' | jq -r '.success')
+
+if [[ "$APPROVAL_RESULT" == "true" ]]; then
+  echo -e "${GREEN}✓ Evolution approved${NC}"
+else
+  echo -e "${RED}✗ Evolution approval failed${NC}"
+  exit 1
+fi
+
+# Verify git commit created
+cd ~/.openclaw/souls
+if git log --oneline | grep -q "$EVENT_ID"; then
+  echo -e "${GREEN}✓ Git commit created${NC}"
+else
+  echo -e "${RED}✗ Git commit not found${NC}"
+  exit 1
+fi
+
+# Test 5: Memory Isolation
+echo
+echo "Test 5: Memory Isolation"
+if ${HOME}/.openclaw/workspace/bin/clawvault-access-control blockchain-auditor "private/blockchain-auditor" read | grep -q "GRANTED"; then
+  echo -e "${GREEN}✓ Soul can access own private memory${NC}"
+else
+  echo -e "${RED}✗ Access control failed${NC}"
+  exit 1
+fi
+
+if ${HOME}/.openclaw/workspace/bin/clawvault-access-control blockchain-auditor "private/lore-writer" read | grep -q "DENIED"; then
+  echo -e "${GREEN}✓ Soul cannot access other's private memory${NC}"
+else
+  echo -e "${RED}✗ Access control failed (should deny)${NC}"
+  exit 1
+fi
+
+echo
+echo -e "${GREEN}=== All Tests Passed ===${NC}"