openclaw-node-harness 2.0.0

package/skills/agentic-compass/scripts/agentic-compass.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""
+Agentic Compass — AI Agent Self-Reflection Tool (v2.0)
+
+Local-only reflection that forces objective action for AI agents.
+"""
+
+import argparse
+import re
+import json
+from datetime import datetime, timedelta
+from pathlib import Path
+
+# Configuration
+DEFAULT_DAILY_PATH = Path.home() / ".openclaw" / "workspace" / "memory" / f"{datetime.now().strftime('%Y-%m-%d')}.md"
+DEFAULT_LONG_PATH = Path.home() / ".openclaw" / "workspace" / "MEMORY.md"
+OUTPUT_PATH = Path.home() / ".openclaw" / "workspace" / "memory" / "agentic-compass.md"
+
+# Agent-specific scoring axes
+AXES = [
+    "Completion Rate",
+    "Response Relevance",
+    "Tool Usage Quality",
+    "Memory Consistency",
+    "Initiative"
+]
+
+def read_file(path):
+    """Read file content safely."""
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            return f.read()
+    except (FileNotFoundError, IOError):
+        return ""
+
+def count_markers(content, pattern, flags=None):
+    """Count regex matches in content."""
+    if flags:
+        return len(re.findall(pattern, content, flags))
+    return len(re.findall(pattern, content, re.IGNORECASE))
+
+def score_completion_rate(content):
+    """Score based on tasks started vs finished."""
+    started = count_markers(content, r'\[DOING\]|\[TODO\]|\[IN-PROGRESS\]')
+    finished = count_markers(content, r'\[DONE\]|\[COMPLETED\]|\[✓\]')
+    if started == 0:
+        return 5.0, "No tasks started"
+    ratio = finished / max(started, 1)
+    score = min(ratio * 5, 5.0)
+    return score, f"Finished {finished}/{started} tasks ({ratio*100:.0f}%)"
+
+def score_response_relevance(content):
+    """Score based on user confirmations vs corrections."""
+    confirmations = count_markers(content, r'confirmed|correct|yes that works|thanks that helped')
+    corrections = count_markers(content, r'wrong|incorrect|no that.s not|try again')
+    total = confirmations + corrections
+    if total == 0:
+        return 5.0, "No feedback yet"
+    ratio = confirmations / total
+    score = ratio * 5
+    return score, f"{confirmations} confirmations, {corrections} corrections"
+
+def score_tool_usage(content):
+    """Score based on tool errors and retries."""
+    errors = count_markers(content, r'tool failed|error:|timeout|retrying')
+    if errors == 0:
+        return 5.0, "No tool errors"
+    if errors < 3:
+        return 4.0, f"{errors} minor errors"
+    if errors < 10:
+        return 2.5, f"{errors} errors detected"
+    return 1.0, f"{errors} tool errors - high failure rate"
+
+def score_memory_consistency(content, long_content):
+    """Score based on context retention across sessions."""
+    # Look for references to prior decisions
+    references = count_markers(content + long_content, r'earlier i mentioned|as we discussed|following up on|continuing')
+    # Check if contradictions exist (simplistic heuristic)
+    contradictions = count_markers(content + long_content, r'actually i changed my mind|contradicting my earlier|never mind')
+    if references == 0:
+        return 3.0, "No cross-session references"
+    if contradictions > 0:
+        return 2.0, f"{contradictions} context contradictions"
+    return 5.0, f"{references} context references, no contradictions"
+
+def score_initiative(content):
+    """Score based on proactive actions."""
+    # Count proactive markers
+    proactive = count_markers(content, r'i started|i proposed|i initiated|without being asked')
+    if proactive == 0:
+        return 2.0, "No proactive actions detected"
+    if proactive == 1:
+        return 3.5, f"{proactive} proactive action"
+    if proactive < 5:
+        return 4.5, f"{proactive} proactive actions"
+    return 5.0, f"{proactive}+ proactive actions - excellent initiative"
+
+def generate_plan(scores, details):
+    """Generate an actionable plan based on weakest axis."""
+    weakest_idx = min(range(len(scores)), key=lambda i: scores[i])
+    weakest_axis = AXES[weakest_idx]
+    
+    plans = {
+        "Completion Rate": [
+            "focus on finishing [DOING] tasks before starting new ones",
+            "prioritize one task and see it through to completion"
+        ],
+        "Response Relevance": [
+            "ask clarifying questions before acting",
+            "confirm understanding before proceeding with tasks"
+        ],
+        "Tool Usage Quality": [
+            "add error checking and retry logic before tool calls",
+            "validate tool inputs before invocation"
+        ],
+        "Memory Consistency": [
+            "review MEMORY.md before starting new tasks",
+            "summarize key decisions at end of each session"
+        ],
+        "Initiative": [
+            "identify one high-value task and start without prompt",
+            "propose improvements to existing workflows"
+        ]
+    }
+    
+    proactive = plans[weakest_axis][0]
+    deferred = "retry any blocked items after diagnostic"
+    avoidance = "stop repeating patterns that cause low scores"
+    ship = "create one concrete artifact (doc, script, fix)"
+    
+    return proactive, deferred, avoidance, ship
+
+def generate_report(daily_content, long_content):
+    """Generate full reflection report."""
+    scores = [0] * 5  # Initialize with 5 zeros
+    details = {}
+    
+    # Calculate scores for each axis
+    scores[0], details["Completion Rate"] = score_completion_rate(daily_content)
+    scores[1], details["Response Relevance"] = score_response_relevance(daily_content)
+    scores[2], details["Tool Usage Quality"] = score_tool_usage(daily_content)
+    scores[3], details["Memory Consistency"] = score_memory_consistency(daily_content, long_content)
+    scores[4], details["Initiative"] = score_initiative(daily_content)
+    
+    # Calculate overall score
+    overall = sum(scores) / len(scores)
+    weakest_idx = min(range(len(scores)), key=lambda i: scores[i])
+    weakest_axis = AXES[weakest_idx]
+    
+    # Generate plan
+    proactive, deferred, avoidance, ship = generate_plan(scores, details)
+    
+    # Build report
+    report = []
+    report.append(f"Score: {overall:.1f}/5")
+    report.append(f"Weakest axis: {weakest_axis}")
+    report.append(f"  ({details[weakest_axis]})")
+    report.append("")
+    report.append("Plan:")
+    report.append(f"- Proactive: {proactive}")
+    report.append(f"- Deferred: {deferred}")
+    report.append(f"- Avoidance: {avoidance}")
+    report.append(f"- Ship: {ship}")
+    
+    return "\n".join(report)
+
+def main():
+    parser = argparse.ArgumentParser(description="Agentic Compass — AI Agent Self-Reflection Tool")
+    parser.add_argument("--write", action="store_true", help="Write plan to memory/agentic-compass.md")
+    parser.add_argument("--daily", type=str, default=str(DEFAULT_DAILY_PATH), help="Path to daily memory file")
+    parser.add_argument("--long", type=str, default=str(DEFAULT_LONG_PATH), help="Path to long-term memory file")
+    
+    args = parser.parse_args()
+    
+    # Read memory files
+    daily_content = read_file(args.daily)
+    long_content = read_file(args.long)
+    
+    # Generate report
+    report = generate_report(daily_content, long_content)
+    print(report)
+    
+    # Write to file if requested
+    if args.write:
+        output_path = Path(args.daily).parent / "agentic-compass.md"
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(output_path, 'a', encoding='utf-8') as f:
+            f.write(f"\n\n## Agentic Compass Report — {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}\n\n")
+            f.write(report)
+            f.write("\n")
+        
+        print(f"\n✓ Report written to {output_path}")
+
+if __name__ == "__main__":
+    main()

package/skills/arcane-dev-ops/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: arcane-dev-ops
+description: "Safe Arcane Solidity/Hardhat dev-ops: validate reviews, apply patches, add regression tests, run suites, commit/push with hygiene. Use for Pass fixes, test recovery, repo-porting, or any code+git execution in the Arcane project."
+triggers:
+  - "run the arcane tests"
+  - "fix this failing test in arcane"
+  - "commit and push the arcane changes"
+  - "port these files to the arcane repo"
+  - "apply this patch to the contracts"
+negative_triggers:
+  - "deploy the arcane contracts"
+  - "write new arcane lore"
+  - "check arcane security audit"
+---
+
+# Arcane DevOps
+
+Use this workflow for high-confidence code + git execution in Arcane.
+
+## Workflow
+
+1. Confirm source of truth before edits:
+   - Read review/requirements doc first.
+   - Diff patch inputs against real contract/test files.
+   - Identify the actual git repo with remote (never assume workspace root is the push repo).
+
+2. Implement safely:
+   - Apply minimal, auditable code changes.
+   - Add regression tests for each bug/fix claim.
+   - Prefer deterministic fixtures and explicit assertions.
+
+3. Validate in order:
+   - Run targeted tests for touched areas first.
+   - Run full suite second.
+   - Report pass/fail counts and root causes for any failures.
+
+4. Commit hygiene:
+   - Stage explicit file list only.
+   - Avoid unrelated/untracked workspace artifacts.
+   - Use clear commit message scope (`fix(...)`, `test(...)`, etc.).
+
+5. Port/push hygiene:
+   - Verify current repo path and `origin` URL before push.
+   - If user has multiple local copies, port intentionally and re-run full tests in destination repo.
+   - Push only after green suite unless user explicitly asks otherwise.
+
+## Non-negotiables
+
+- Never run destructive git commands without explicit user approval.
+- Never assume the repo with code is the repo with remote.
+- Prefer copying validated files over risky patch apply when paths diverge.
+
+## Scripts
+
+- `scripts/prepush_check.sh <repo-path> [full-test-cmd]`
+  - Prints branch/remote/status/staged files and final push sanity context.
+
+## References
+
+- Use `references/checklist.md` for pre-push checklist.
+- Use `references/validation-cases.md` for trigger/behavior smoke tests.

package/skills/arcane-dev-ops/references/checklist.md

@@ -0,0 +1,22 @@
+# Arcane DevOps Checklist
+
+## Before coding
+- [ ] Read review/issue doc first.
+- [ ] Confirm target repo path.
+- [ ] Confirm branch strategy with user.
+
+## Before commit
+- [ ] Targeted tests pass.
+- [ ] Full suite run and status recorded.
+- [ ] Only intended files staged.
+- [ ] Commit message reflects scope.
+
+## Before push
+- [ ] `git remote -v` confirms intended origin.
+- [ ] Final suite green in destination repo.
+- [ ] User instruction allows push target/branch.
+
+## Final report
+- [ ] What changed (files + intent)
+- [ ] Test results (counts)
+- [ ] Commit hash + push status

package/skills/arcane-dev-ops/references/validation-cases.md

@@ -0,0 +1,11 @@
+# Validation Cases
+
+## Trigger checks
+- "Apply pass 10 review, run tests, commit safely, then push"
+- "Port changes from temp repo to real Arcane repo and verify remote"
+
+## Expected behavior
+- Reads review doc first
+- Runs targeted tests then full suite
+- Stages explicit files only
+- Verifies repo path + remote before push

package/skills/arcane-dev-ops/scripts/prepush_check.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_PATH="${1:-.}"
+FULL_TEST_CMD="${2:-npm test}"
+
+if ! command -v git >/dev/null 2>&1; then
+  echo "ERROR: git not found"
+  exit 1
+fi
+
+cd "$REPO_PATH"
+
+if [[ ! -d .git ]]; then
+  echo "ERROR: $REPO_PATH is not a git repository"
+  exit 1
+fi
+
+echo "== Arcane pre-push check =="
+echo "Repo: $(pwd)"
+
+echo "\n[1/6] Branch"
+git rev-parse --abbrev-ref HEAD
+
+echo "\n[2/6] Remotes"
+git remote -v || true
+
+echo "\n[3/6] Working tree summary"
+git status --short
+
+echo "\n[4/6] Staged files"
+git diff --cached --name-only || true
+
+echo "\n[5/6] Last commit"
+git log -1 --oneline || true
+
+echo "\n[6/6] Full test command (manual confirmation required)"
+echo "$FULL_TEST_CMD"
+echo "Run it yourself now if not already green."
+
+echo "\nDone."

package/skills/auto-updater/.clawhub/origin.json

@@ -0,0 +1,7 @@
+{
+  "version": 1,
+  "registry": "https://clawhub.ai",
+  "slug": "auto-updater",
+  "installedVersion": "1.0.0",
+  "installedAt": 1770236912882
+}

package/skills/auto-updater/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: auto-updater
+description: "Set up daily auto-updates for Clawdbot and all installed skills via cron. Checks for updates, applies them, and reports what changed. Use when configuring automatic update schedules."
+triggers:
+  - "auto update clawdbot"
+  - "set up daily updates"
+  - "update all skills"
+  - "auto-updater"
+negative_triggers:
+  - "update a single skill manually"
+  - "check clawdbot version"
+  - "install a new skill"
+metadata: {"version":"1.0.0","clawdbot":{"emoji":"🔄","os":["darwin","linux"]}}
+---
+
+# Auto-Updater Skill
+
+Keep your Clawdbot and skills up to date automatically with daily update checks.
+
+## What It Does
+
+This skill sets up a daily cron job that:
+
+1. Updates Clawdbot itself (via `clawdbot doctor` or package manager)
+2. Updates all installed skills (via `clawdhub update --all`)
+3. Messages you with a summary of what was updated
+
+## Setup
+
+### Quick Start
+
+Ask Clawdbot to set up the auto-updater:
+
+```
+Set up daily auto-updates for yourself and all your skills.
+```
+
+Or manually add the cron job:
+
+```bash
+clawdbot cron add \
+  --name "Daily Auto-Update" \
+  --cron "0 4 * * *" \
+  --tz "America/Los_Angeles" \
+  --session isolated \
+  --wake now \
+  --deliver \
+  --message "Run daily auto-updates: check for Clawdbot updates and update all skills. Report what was updated."
+```
+
+### Configuration Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| Time | 4:00 AM | When to run updates (use `--cron` to change) |
+| Timezone | System default | Set with `--tz` |
+| Delivery | Main session | Where to send the update summary |
+
+## How Updates Work
+
+### Clawdbot Updates
+
+For **npm/pnpm/bun installs**:
+```bash
+npm update -g clawdbot@latest
+# or: pnpm update -g clawdbot@latest
+# or: bun update -g clawdbot@latest
+```
+
+For **source installs** (git checkout):
+```bash
+clawdbot update
+```
+
+Always run `clawdbot doctor` after updating to apply migrations.
+
+### Skill Updates
+
+```bash
+clawdhub update --all
+```
+
+This checks all installed skills against the registry and updates any with new versions available.
+
+## Update Summary Format
+
+After updates complete, you'll receive a message like:
+
+```
+🔄 Daily Auto-Update Complete
+
+**Clawdbot**: Updated to v2026.1.10 (was v2026.1.9)
+
+**Skills Updated (3)**:
+- prd: 2.0.3 → 2.0.4
+- browser: 1.2.0 → 1.2.1  
+- nano-banana-pro: 3.1.0 → 3.1.2
+
+**Skills Already Current (5)**:
+gemini, sag, things-mac, himalaya, peekaboo
+
+No issues encountered.
+```
+
+## Manual Commands
+
+Check for updates without applying:
+```bash
+clawdhub update --all --dry-run
+```
+
+View current skill versions:
+```bash
+clawdhub list
+```
+
+Check Clawdbot version:
+```bash
+clawdbot --version
+```
+
+## Troubleshooting
+
+### Updates Not Running
+
+1. Verify cron is enabled: check `cron.enabled` in config
+2. Confirm Gateway is running continuously
+3. Check cron job exists: `clawdbot cron list`
+
+### Update Failures
+
+If an update fails, the summary will include the error. Common fixes:
+
+- **Permission errors**: Ensure the Gateway user can write to skill directories
+- **Network errors**: Check internet connectivity
+- **Package conflicts**: Run `clawdbot doctor` to diagnose
+
+### Disabling Auto-Updates
+
+Remove the cron job:
+```bash
+clawdbot cron remove "Daily Auto-Update"
+```
+
+Or disable temporarily in config:
+```json
+{
+  "cron": {
+    "enabled": false
+  }
+}
+```
+
+## Resources
+
+- [Clawdbot Updating Guide](https://docs.clawd.bot/install/updating)
+- [ClawdHub CLI](https://docs.clawd.bot/tools/clawdhub)
+- [Cron Jobs](https://docs.clawd.bot/cron)

package/skills/auto-updater/references/agent-guide.md

@@ -0,0 +1,152 @@
+# Agent Implementation Guide
+
+When asked to set up auto-updates, follow this procedure.
+
+## Step 1: Detect Installation Type
+
+```bash
+# Check if installed via npm globally
+npm list -g clawdbot 2>/dev/null && echo "npm-global"
+
+# Check if installed via source (git)
+[ -d ~/.clawdbot/.git ] || [ -f /opt/clawdbot/.git/config ] && echo "source-install"
+
+# Check pnpm
+pnpm list -g clawdbot 2>/dev/null && echo "pnpm-global"
+
+# Check bun
+bun pm ls -g 2>/dev/null | grep clawdbot && echo "bun-global"
+```
+
+## Step 2: Create the Update Script (Optional)
+
+For complex setups, create a helper script at `~/.clawdbot/scripts/auto-update.sh`:
+
+```bash
+#!/bin/bash
+set -e
+
+LOG_FILE="${HOME}/.clawdbot/logs/auto-update.log"
+mkdir -p "$(dirname "$LOG_FILE")"
+
+log() {
+  echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
+}
+
+log "Starting auto-update..."
+
+# Capture starting versions
+CLAWDBOT_VERSION_BEFORE=$(clawdbot --version 2>/dev/null || echo "unknown")
+
+# Update Clawdbot
+log "Updating Clawdbot..."
+if command -v npm &> /dev/null && npm list -g clawdbot &> /dev/null; then
+  npm update -g clawdbot@latest 2>&1 | tee -a "$LOG_FILE"
+elif command -v pnpm &> /dev/null && pnpm list -g clawdbot &> /dev/null; then
+  pnpm update -g clawdbot@latest 2>&1 | tee -a "$LOG_FILE"
+elif command -v bun &> /dev/null; then
+  bun update -g clawdbot@latest 2>&1 | tee -a "$LOG_FILE"
+else
+  log "Running clawdbot update (source install)"
+  clawdbot update 2>&1 | tee -a "$LOG_FILE" || true
+fi
+
+# Run doctor for migrations
+log "Running doctor..."
+clawdbot doctor --yes 2>&1 | tee -a "$LOG_FILE" || true
+
+# Capture new version
+CLAWDBOT_VERSION_AFTER=$(clawdbot --version 2>/dev/null || echo "unknown")
+
+# Update skills
+log "Updating skills via ClawdHub..."
+SKILL_OUTPUT=$(clawdhub update --all 2>&1) || true
+echo "$SKILL_OUTPUT" >> "$LOG_FILE"
+
+log "Auto-update complete."
+
+# Output summary for agent to parse
+echo "---UPDATE_SUMMARY_START---"
+echo "clawdbot_before: $CLAWDBOT_VERSION_BEFORE"
+echo "clawdbot_after: $CLAWDBOT_VERSION_AFTER"
+echo "skill_output: $SKILL_OUTPUT"
+echo "---UPDATE_SUMMARY_END---"
+```
+
+## Step 3: Add Cron Job
+
+The recommended approach is to use Clawdbot's built-in cron with an isolated session:
+
+```bash
+clawdbot cron add \
+  --name "Daily Auto-Update" \
+  --cron "0 4 * * *" \
+  --tz "America/Los_Angeles" \
+  --session isolated \
+  --wake now \
+  --deliver \
+  --message "Run the daily auto-update routine:
+
+1. Check and update Clawdbot:
+   - For npm installs: npm update -g clawdbot@latest
+   - For source installs: clawdbot update
+   - Then run: clawdbot doctor --yes
+
+2. Update all skills:
+   - Run: clawdhub update --all
+
+3. Report back with:
+   - Clawdbot version before/after
+   - List of skills that were updated (name + old version → new version)
+   - Any errors encountered
+
+Format the summary clearly for the user."
+```
+
+## Step 4: Verify Setup
+
+```bash
+# Confirm cron job was added
+clawdbot cron list
+
+# Test the update commands work
+clawdbot --version
+clawdhub list
+```
+
+## Customization Prompts
+
+Users may want to customize:
+
+**Different time:**
+```bash
+--cron "0 6 * * *"  # 6 AM instead of 4 AM
+```
+
+**Different timezone:**
+```bash
+--tz "Europe/London"
+```
+
+**Specific provider delivery:**
+```bash
+--provider telegram --to "@username"
+```
+
+**Weekly instead of daily:**
+```bash
+--cron "0 4 * * 0"  # Sundays at 4 AM
+```
+
+## Error Handling
+
+If updates fail, the agent should:
+
+1. Log the error clearly
+2. Still report partial success (if skills updated but Clawdbot didn't, or vice versa)
+3. Suggest manual intervention if needed
+
+Common errors to handle:
+- `EACCES`: Permission denied → suggest `sudo` or fixing permissions
+- Network timeouts → retry once, then report
+- Git conflicts (source installs) → suggest `clawdbot update --force`