openclaw-skills

name: openclaw-skills description: Canonical master skill for The Nine Skills that configure OpenClaw instances deterministically across Claude, Hermes, Gemini, Codex, Cursor, WindSurf, Antigravity, OpenCode, and 8gent.dev. version: "1.0" agent_compatibility: - Claude - Hermes - Gemini - Codex - Cursor - WindSurf - Antigravity - OpenCode - 8gent.dev layer: "1 — Operations (builds on Layer 0: v1/OpenRouter.md)" upstream: https://github.com/rahulsub-be/cc-openclaw upstream_license: MIT upstream_path: bin/orama-system/skills/openclaw-skills/cc-openclaw

OpenClaw Skills

This folder is the canonical home for The Nine Skills used to operate OpenClaw configuration. These skills are executable standards, not passive docs: every supported agent must use the relevant skill instead of reconstructing OpenClaw procedures from memory.

The skills are designed for deterministic use through direct skill loading, MCP middleware, CLI wrappers, editor rules, or Perpetua-Tools dispatch. They must produce the same files, naming, model routing, stow behavior, and restart flow regardless of the invoking agent.

The Nine Skills

Upstream Initialization

Before resolving any of The Nine Skills directly, ensure the upstream submodule is present:

bash scripts/install-openclaw-skills.sh

This is idempotent and is also called by start.sh. Orama-normalized Nine Skill overlays live under skills/<skill-id>/SKILL.md; each overlay declares the upstream cc-openclaw card it extends under cc-openclaw/.claude/skills/<skill-id>/SKILL.md.

Universal Invocation Protocol

All agents must follow references/universal-skill-protocol.md.

The required invocation envelope is:

{
  "skill_id": "openclaw-add-secret",
  "args": {
    "secret_name": "telegram-bot-token"
  },
  "agent_id": "codex",
  "openclaw_home": "/absolute/path/to/openclaw-home"
}

The required result shape is:

{
  "status": "ok",
  "files_modified": [],
  "follow_up_actions": []
}

Wrappers may add transport metadata, but they must preserve the envelope fields and the result fields. Skill chaining is allowed only when the parent skill declares the internal call and preserves the same openclaw_home.

OpenClaw CLI Resolution (when openclaw seems broken)

Before concluding "openclaw is not installed" or acting on a Cannot find module '.../.local/openclaw/openclaw.mjs' error, look at the right places. That error is a known false alarm: ~/.local/bin/openclaw is a pnpm cmd-shim reached through a symlink, and its $0-derived basedir resolves to a path that never existed. Meanwhile up to three openclaw installs can coexist on one machine:

Always resolve through the canonical resolver rather than trusting the bare command blindly:

# one-liner (echoes "<node>\t<entrypoint>")
"$(orama_git_root)/scripts/openclaw/resolve-openclaw.sh" --which

# or source the lib and use the helpers
source bin/orama-system/scripts/lib/openclaw-env.sh
openclaw_cmd plugins list        # runs canonical openclaw, never the stale one
resolve_openclaw_cli             # prints node + entrypoint of the canonical install

The resolver prefers the install that actually runs the gateway (parsed from the launchd plist), falls back to npm-global then the AlphaClaw repo copy, blacklists the stale ~/.alphaclaw install, and verifies --version before returning. setup_macos.py installs ~/.local/bin/openclaw as a thin wrapper around it, so the bare openclaw command self-heals on every start.sh. Full rationale: scripts/openclaw/resolve-openclaw.sh header.

Note the active config may be written by a newer OpenClaw than a given on-disk CLI (e.g. config 2026.6.8 vs a pnpm 2026.5.6). Prefer the gateway's own version for config writes; config patch/config set from the canonical CLI is the gateway-aware, validated, atomic path (never hand-edit live openclaw.json).

Default Model Routing

Use references/openrouter-defaults.md as the source of truth for default model routing.

Local-first on Mac:

1. ollama/qwen3.5:9b-nvfp4
2. qwen3-coder:480b-cloud when loaded for heavy code work
3. OpenRouter fallback stack

OpenRouter fallback stack:

Gemini is specialized only and is not the default fallback. Reserve it for visual diff, screenshot comparison, whole-repo architecture mapping, stale-doc detection, or explicit second-opinion review.

PT-Orama Recursive Spawn

OpenClaw deployment is recursive across three layers:

Standard L3 to L1 dispatch:

orama-system
  -> Perpetua-Tools skill dispatcher
  -> openclaw-skills/{skill_id}
  -> target OpenClaw home
  -> files changed, stowed, restarted, verified

Nested OpenClaw recursion:

parent OpenClaw agent
  -> emits universal skill envelope
  -> Perpetua-Tools resolves child openclaw_home
  -> child OpenClaw invokes the same canonical skill
  -> child may later repeat the same pattern for its own sub-instance

Recursive spawn constraints:

1. Every invocation must carry an explicit openclaw_home.
2. A nested call must use the same skill IDs listed in this master file.
3. A sub-agent must be wired to its parent's allowAgents list in openclaw.json.
4. The parent may delegate, but the skill remains authoritative for naming, file layout, stow, restart, and verification.
5. Results must bubble upward in the universal output format so L3, L2, and L1 can audit the same record.

Naming Conventions Enforced

Every generated agent requires:

Every secret touches all three files:

Operational Rules

1. Never freestyle OpenClaw configuration. Use the relevant skill for every configuration change.
2. Run openclaw-status before changes to understand current gateway, launchd, channel, agent, cron, and error state.
3. Run openclaw-restart after config changes. Do not use raw launchctl kickstart as the operational restart path.
4. Treat ~/.openclaw/cron/jobs.json as transient. The gateway regenerates it on startup; never treat it as source of truth.
5. Never echo secrets to terminal, files, logs, prompts, result envelopes, or git history.
6. When creating a sub-agent, wire it to the parent's allowAgents list in openclaw.json.
7. Use stow --no-folding for all stow operations so the symlink structure is preserved.
8. After updating the source skill distribution, re-run stow if new skills were added.

Quick Reference

Agent Compatibility Notes

Hermes support is intentionally cross-harness: use ../hermes-harness/SKILL.md for Hermes installation, Nous Portal/LM Studio provider setup, and ECC skill-import rules. Use this OpenClaw skill pack for OpenClaw configuration and gateway operations.

If an agent cannot load markdown skills directly, it must use Perpetua-Tools or an equivalent wrapper that reads this folder and executes the same procedures.

Attribution

The Nine Skills originate from cc-openclaw (MIT, Rahul Subramanian). The upstream lives at cc-openclaw/ (git submodule), with canonical upstream skill cards in cc-openclaw/.claude/skills/.

Extensions in this directory (references/, templates/, scripts/, this SKILL.md) are orama-system additions and are NOT in the upstream repo.

Layer 0 (provider substrate): v1/OpenRouter.md — free model stack, openclaw.json shape, rate limits. See references/openrouter-defaults.md for the distilled routing table.

cc-openclaw = v1/OpenRouter.md (Layer 0 substrate) + .claude/skills/ (Layer 1 ops). The Orama-normalized overlay cards are in openclaw-skills/skills/. Shared extensions live at openclaw-skills/ root.

Search Frugality Rule

RULE: Never guess when information is scarce. Search in this order — stop at the first satisfying result:

1. /sync-gbrain + gbrain query "<question>" — local semantic memory, zero cost
2. code-review-graph: semantic_search_nodes — structural code context
3. Brave Search API — web facts, current state
4. Perplexity API (inline) — deep web synthesis
5. Grok API — last resort only

NEVER: parallel-fire all search tools. Use the cheapest first. ALWAYS: AskUserQuestion for decisions — never auto-select between ambiguous options.

Windows Coder Policy

RULE: Every available Windows coder MUST be given work as soon as it is idle.

Endpoint pool: $WIN_CODER_ENDPOINTS (default: 192.168.254.103:1234)

Dispatch protocol:

1. Before routing any task to Mac-only paths, check if a Windows coder is free.
2. If free AND task is compatible (Python, Go, TypeScript, general coding): → dispatch to Windows coder FIRST.
3. If offline or no model loaded: skip silently, log WARN, do not fail.
4. As more Windows coders are added to $WIN_CODER_ENDPOINTS, they join the pool automatically — same rule applies to all.

Never leave a Windows coder idle if pending compatible work exists.