Openclaw Skill Ansible

SKILL.md

---
name: ansible
description: MeshOps distributed coordination mesh for OpenClaw gateways: ring-of-trust admission, CRDT-synced state, capability-contract routing, and governed delegation. Named for the ansible from Ender's Game, not the infrastructure tool.
---

# Ansible - MeshOps Coordination Skill

## What This Is

Ansible is a distributed coordination layer that lets you operate across multiple OpenClaw gateways as one coordinated mesh.

Four pillars:

1. Ring of Trust: invite/join handshake, auth-gate WebSocket tickets, ed25519-signed capability manifests, per-action safety gates, and token lifecycle.
2. Mesh Sync: Yjs CRDT replication over Tailscale. Messages, tasks, context, and pulse remain durable across reconnects and restarts.
3. Capability Routing: publish/unpublish capability contracts. Each contract references a delegation skill (requester) and an execution skill (executor).
4. Lifecycle Ops: lock sweep, retention/pruning, coordinator sweep, and deployment hygiene.

## Relationship Modes

- Friends/Employees (default): other nodes are different agents. Provide context and communicate explicitly.
- Hemispheres (advanced): mirrored instances of the same identity. Shared intent and direct communication.

Default to Friends/Employees unless explicitly told a node is a hemisphere.

## Node Topology

- Backbone: always-on nodes (VPS/servers) that host Yjs WebSocket.
- Edge: intermittent nodes (laptops/desktops) that connect to backbone.

## Human Visibility Contract (Required on Pickup)

When taking coordination work, maintain explicit lifecycle updates:

1. ACK: confirm receipt and summarize intent.
2. IN_PROGRESS: emit progress updates at meaningful checkpoints.
3. DONE or BLOCKED: close with evidence, next action, and owner.

Use `conversation_id` consistently for all related updates.

## Ring of Trust - Behavioral Rules

- Unknown nodes require invite-based admission. Do not bypass.
- High-risk capability publishes require human approval artifacts.
- Respect caller gates (`OPENCLAW_ALLOWED_CALLERS`) and high-risk flags.
- Never expose tokens in plaintext messages/logs/shared state.
- When signature enforcement is on, only accept manifests signed by trusted publisher keys.

## Gateway Compatibility Contract

- Validate plugin is installed and readable before assuming tool availability.
- Verify tier assumptions (backbone vs edge) before mutating coordination settings.
- Treat gateway runtime as source of truth for active topology and health.

## Reliability Model

### Source of Truth

Shared Yjs state is authoritative.

### Delivery Semantics

- Durable: messages/tasks persist in shared state.
- Auto-dispatch: best-effort realtime injection into sessions.
- Heartbeat reconcile: periodic rescan recovers missed injections.
- Retry: transient dispatch failures retry with bounded backoff.
- Send receipts: notify configured operators when work is placed on mesh.

### Operating Rules

- Verify pending work with `ansible_status` and `ansible_read_messages`.
- If polling mode is used, always reply via `ansible_send_message`.
- Use `corr:<messageId>` for thread continuity.
- Listener behavior is optimization; sweep/reconcile is the backstop.

## Capability Contracts

- A capability is a contract, not just a label.
- Contract includes delegation and execution skill references.
- Publishing updates routing eligibility mesh-wide.
- Provenance is verified against trusted publisher keys when configured.
- High-risk contracts require explicit approval artifacts.
- Unpublish removes eligibility immediately.
- Lifecycle evidence must capture install/wire outcomes.

## Delegation Protocol

1. Requester creates task with objective, context, acceptance criteria, and target policy (`to_agents` or capability).
2. Executor claims task and sends acceptance/ETA signal.
3. Executor performs work, emits progress, and completes with structured result.
4. Requester reports final outcome to human and/or downstream agents.

## Coordinator Behavior

- Run sweep loops for stale locks, SLA drift, and backlog reconciliation.
- Prefer record-only escalation by default when blast radius is unclear.
- If DEGRADED, prioritize containment, visibility, and deterministic recovery.

## Available Tools

### Communication

| Tool | Purpose |
|------|---------|
| `ansible_send_message` | Send targeted or broadcast message across mesh |
| `ansible_read_messages` | Read unread messages (or full history) |
| `ansible_mark_read` | Mark messages as read |
| `ansible_delete_messages` | Admin-only emergency purge |

### Task Delegation

| Tool | Purpose |
|------|---------|
| `ansible_delegate_task` | Create task for another node/agent set |
| `ansible_claim_task` | Claim pending task |
| `ansible_update_task` | Update task status/progress |
| `ansible_complete_task` | Complete task and notify requester |
| `ansible_find_task` | Resolve task by ID/title |

### Context and Status

| Tool | Purpose |
|------|---------|
| `ansible_status` | Mesh health, unread, pending, and topology summary |
| `ansible_update_context` | Update shared context/threads/decisions |

### Coordination and Governance

| Tool | Purpose |
|------|---------|
| `ansible_get_coordination` | Read coordinator configuration |
| `ansible_set_coordination_preference` | Set node coordinator preference |
| `ansible_set_coordination` | Switch coordinator (guarded) |
| `ansible_set_retention` | Configure closed-task retention/pruning |
| `ansible_get_delegation_policy` | Read delegation policy plus ACKs |
| `ansible_set_delegation_policy` | Publish/update delegation policy |
| `ansible_ack_delegation_policy` | Acknowledge policy version |
| `ansible_lock_sweep_status` | Inspect lock sweep health |

### Capability Lifecycle

| Tool | Purpose |
|------|---------|
| `ansible_list_capabilities` | List published capability contracts |
| `ansible_capability_publish` | Publish/upgrade capability contract |
| `ansible_capability_unpublish` | Remove capability from routing |
| `ansible_capability_lifecycle_evidence` | Show install/wire evidence for version |
| `ansible_capability_health_summary` | Show success/error/latency summary |

## When to Use Ansible

Use Ansible when work crosses gateways, needs durable coordination, or requires auditable delegation contracts.

## Session Behavior

- Start by checking status and pending work.
- Prefer explicit delegation for capability-matched work.
- Keep humans in loop via lifecycle messages.

## Message Protocol v1

- Always include enough context for independent execution.
- Use stable correlation IDs (`corr`) and conversation IDs.
- Prefer structured payloads over freeform-only messaging.

## Setup Playbooks

Follow plugin setup and gateway runbooks for topology bootstrap, auth-gate, and trust settings.

## Delegation Management

- Keep delegation policy current and acknowledged across nodes.
- Treat capability publishes as contract releases.
- Roll back quickly when lifecycle evidence indicates drift or misfire.