---
name: clawdna-generator
description: Extract a DNA document from the current openclaw instance. Captures L0 (gateway, providers) and L1 (agents, skills, channels, workspace identity) into a portable YAML file with a unique hardware-anchored fingerprint.
---

# ClawDNA Generator

Extracts the current openclaw instance's core characteristics into a portable DNA document. The DNA encodes the instance's agent team, model routing, skills, channel integrations, and workspace identity — everything needed to reproduce or combine this instance elsewhere.

The fingerprint in the generated DNA is anchored to the physical hardware's UUID, ensuring uniqueness even if two instances share the same agent name.

## When to use

Run this skill when you want to:
- Archive the current state of this openclaw instance
- Prepare a DNA for cloning onto another machine (`clawclone`)
- Prepare a parent DNA for genetic recombination (`clawreprodu`)

## Prerequisites

The following tools must be installed: `jq`, `yq`

Check with:
```bash
which jq yq
```

If missing on macOS: `brew install jq yq`
If missing on Linux: `apt install jq` + [yq install guide](https://github.com/mikefarah/yq#install)

## Workflow

**Step 1 — Ask the user for a DNA name**

Prompt: "Please provide a short name for this DNA snapshot (e.g. `macmini-main`, `deepeye-v2`). This will be used as the filename prefix."

- Name should be alphanumeric + hyphens only
- No spaces, no special characters

**Step 2 — Run extraction**

Determine the absolute path to the clawdna project scripts directory. The script is at:
`<clawdna_project_root>/scripts/extract.sh`

Run:
```bash
bash <clawdna_project_root>/scripts/extract.sh <dna_name> 2>/tmp/clawdna-extract-err.log
```

Capture stdout. If the exit code is non-zero, read `/tmp/clawdna-extract-err.log` and report the error to the user.

**Step 3 — Parse output**

From stdout:
- Lines matching `^\{\{[A-Z0-9_]+\}\}$` are placeholder keys
- The last line starting with `OUTPUT_PATH:` contains the output file path

Parse the output file path:
```bash
OUTPUT_PATH=$(grep '^OUTPUT_PATH:' <stdout> | cut -d: -f2-)
```

**Step 4 — Read the fingerprint**

Read the fingerprint ID from the generated DNA file:
```bash
yq -r '.fingerprint.id' "$OUTPUT_PATH"
yq -r '.fingerprint.source_hardware.hostname' "$OUTPUT_PATH"
yq -r '.fingerprint.source_hardware.hw_uuid' "$OUTPUT_PATH"
```

**Step 5 — Report to user**

Show the user:
1. The fingerprint ID (e.g. `deepeye-main-agent-a17fffc4-b5c4d3e2`)
2. The source hardware: hostname + hw_uuid prefix
3. The list of placeholder keys (the sensitive values that were anonymized)
4. The DNA file path

Example output:
```
✓ DNA extracted successfully

Fingerprint: deepeye-main-agent-a17fffc4-b5c4d3e2
  Primary index : DeepEye Main Agent
  Hardware UUID : A17FFFC4-6378-58A9-A94C-9BC312C71F33
  Host          : macmini

Anonymized placeholders (24 total):
  {{ENV_BRAVE_API_KEY}}
  {{PROVIDER_LOVBROWSER_API_KEY}}
  {{CHANNEL_TELEGRAM_BOT_TOKEN}}
  ... (full list)

DNA saved to: ~/.openclaw/dna/macmini-main-20260317.dna.yaml

Use clawclone to install this DNA on another machine.
Use clawreprodu to combine it with another DNA.
```

## Notes

- The DNA does **not** contain session history, delivery queue, or logs
- Sensitive values (API keys, tokens, secrets) are replaced with `{{PLACEHOLDER}}` — the DNA is safe to share
- The `content_hash` field in the fingerprint is a SHA256 of the full DNA content, allowing integrity verification
- To verify integrity later: `shasum -a 256 <dna_file>` should match `fingerprint.content_hash` (after setting that field to "pending")


---

# CLAWCLONE


---
name: clawclone
description: Install an openclaw instance from a DNA document. Guides the user through filling placeholder values, dependency checks, and installation onto the current machine. Supports merge (agent-level) or full-replace modes.
---

# ClawClone

Installs a complete openclaw instance from a DNA document. The DNA may come from `clawdna-generator` (direct clone) or `clawreprodu` (hybrid). The install wizard guides you through filling in all anonymized placeholders (API keys, tokens, etc.) before writing any files.

## When to use

- Setting up openclaw on a new machine using an existing DNA
- Reproducing a tested agent configuration from a DNA snapshot
- Installing a hybrid DNA generated by `clawreprodu`

## Prerequisites

Required tools: `yq`, `jq`
Optional (recommended): `check-jsonschema` — validates DNA format before install

```bash
# Install check-jsonschema (Python)
pip install check-jsonschema
```

## Workflow

**Step 1 — List available DNA files**

```bash
ls -1t ~/.openclaw/dna/*.dna.yaml 2>/dev/null
```

For each DNA file, show the fingerprint summary:
```bash
yq -r '"  ID     : " + .fingerprint.id + "\n  Agent  : " + .fingerprint.primary_index + "\n  Host   : " + .fingerprint.source_hardware.hostname + "\n  HW UUID: " + .fingerprint.source_hardware.hw_uuid + "\n  Date   : " + .fingerprint.generated_at' <dna_file>
```

Ask the user to select which DNA to install.

**Step 2 — Conflict check**

Check if `~/.openclaw/openclaw.json` already exists:
```bash
[ -f ~/.openclaw/openclaw.json ] && echo "EXISTS" || echo "FRESH"
```

If EXISTS, ask the user:
> An existing openclaw.json was found. How would you like to proceed?
> - **merge**: DNA agents overwrite same-ID agents; existing agents not in DNA are kept. Other fields (gateway, providers, channels) are replaced by the DNA.
> - **replace**: Current openclaw.json is backed up first (with timestamp), then fully replaced by the DNA.
> - **cancel**: Abort installation.

Record the chosen mode (`merge` or `replace`).

If FRESH, use `replace` mode automatically.

**Step 3 — Dependency check**

Run the scanner to see what placeholders need filling:
```bash
bash <clawdna_project_root>/scripts/clone.sh --scan <selected_dna_file>
```

Also check:
1. For any `custom` skills with `type: reference` — verify that `source` URLs are accessible
2. If any provider has `id: local` or `baseUrl` containing `localhost:11434` — check if Ollama is installed:
   ```bash
   which ollama && ollama list
   ```
   If Ollama is missing, inform the user: "This DNA requires a local Ollama instance. Install from https://ollama.ai before proceeding."

**Step 4 — Fill placeholders interactively**

Display the placeholder list grouped by category:
- `{{ENV_*}}` — Environment variables (API keys for external services)
- `{{PROVIDER_*}}` — Model provider credentials
- `{{CHANNEL_*}}` — Messaging channel tokens and user IDs

For each placeholder:
- Show the placeholder key
- Ask the user for the actual value
- If the user wants to skip, keep the `{{KEY}}` string (will remain unfilled with a warning)

Write collected values to a temporary YAML file at `/tmp/clawclone-values.yaml`:
```yaml
placeholders:
  ENV_BRAVE_API_KEY: "actual-value-here"
  PROVIDER_LOVBROWSER_API_KEY: "actual-key"
  CHANNEL_TELEGRAM_BOT_TOKEN: "123456:ABC..."
```

**Step 5 — Install**

Run the install script:
```bash
bash <clawdna_project_root>/scripts/clone.sh \
  --install <selected_dna_file> /tmp/clawclone-values.yaml \
  --mode <merge|replace>
```

If exit code is non-zero, report the error. Do not retry automatically — ask the user how to proceed.

**Step 6 — Show installation summary**

Parse and display the summary from stdout:
- Source fingerprint ID and origin host
- Install mode used
- Number of agents installed
- Number of skills installed
- Any unfilled placeholder warnings

Example:
```
✓ ClawDNA Clone Complete

Source fingerprint : deepeye-main-agent-a17fffc4-b5c4d3e2
Source host        : macmini (A17FFFC4-6378-58A9-A94C-9BC312C71F33)
Install mode       : replace (backup saved)
Agents installed   : 13
Skills installed   : 5

⚠ 2 placeholder(s) were not filled and remain in openclaw.json:
  {{CHANNEL_FEISHU_BOT3_APP_SECRET}}
  {{PROVIDER_KIMI_CODING_API_KEY}}
  → Edit ~/.openclaw/openclaw.json to fill these before starting the gateway.

Next step: restart the openclaw gateway to activate the new configuration.
```

## Notes

- The `/tmp/clawclone-values.yaml` file is deleted automatically after install
- The SOUL.md files for each agent are written to `~/.openclaw/agents/<agent_id>/workspace/SOUL.md`
- Main workspace soul and memory digest are written to `~/.openclaw/workspace/`
- Embedded custom skills are installed to `~/.openclaw/skills/<skill_name>/SKILL.md`
- The backup file (replace mode) is named `openclaw.json.backup.YYYYMMDDHHMMSS`


---

# CLAWREPRODU


---
name: clawreprodu
description: Combine two DNA documents through randomized genetic recombination, producing a new hybrid DNA that inherits traits from both parents. Each gene locus (agent, provider, skill, channel) is randomly assigned to come from Parent A or Parent B based on a user-specified mixing ratio.
---

# ClawReprodu

Creates a new openclaw DNA through genetic recombination of two parent DNAs. Like biological sexual reproduction, each gene locus is randomly assigned from one parent or the other. The result is a new entity that is neither parent A nor B, but carries traits from both.

**Orphan genes** (loci present in only one parent) are randomly included or excluded based on the mixing ratio. **Dependency repair** ensures the resulting DNA is always installable — missing skills and providers are automatically patched.

The new DNA carries its own unique fingerprint anchored to the hardware where `clawreprodu` runs, with full lineage tracing both parent IDs.

## When to use

- Combining a coding-focused instance with a finance-focused instance
- Creating experimental hybrid agent configurations
- Exploring emergent capabilities from two evolved lineages

## Prerequisites

Required: `yq`, `jq`, `awk`

## Workflow

**Step 1 — List and select parent DNAs**

```bash
ls -1t ~/.openclaw/dna/*.dna.yaml 2>/dev/null
```

For each file, show:
```bash
yq -r '"[" + .fingerprint.id + "]  " + .fingerprint.primary_index + "  (" + .fingerprint.source_hardware.hostname + ")"' <dna_file>
```

Ask the user to select:
- **Parent A (dominant)**: the DNA whose traits are more likely to appear
- **Parent B (recessive)**: the DNA whose traits appear less frequently

A and B can be the same file (self-recombination — produces variation within a single lineage).

**Step 2 — Show chromosome summaries**

For each selected DNA, display:
```bash
echo "=== Parent A: $(yq -r '.fingerprint.id' "$DNA_A") ==="
echo "  Agents   : $(yq -r '.agents | keys | length' "$DNA_A")"
echo "  Providers: $(yq -r '.providers | length' "$DNA_A")"
echo "  Skills   : $(yq -r '.skills.bundled_allowed | length' "$DNA_A") bundled + $(yq -r '.skills.custom | length' "$DNA_A") custom"
echo "  Channels : $(yq -r '.channels | keys | join(", ")' "$DNA_A")"
```

Show the same for Parent B.

Show a table of agent IDs present in each:

| Agent ID | In A | In B |
|----------|------|------|
| main     | ✓   | ✓   |
| architect| ✓   | ✗   |
| ...      | ...  | ...  |

**Step 3 — Ask for mixing ratio**

Prompt:
> What mixing ratio do you want? Enter as A:B (e.g. `6:4` means 60% chance of inheriting from A at each locus).
> Default is `5:5` (equal probability).

Parse to `ratio_a` float (e.g. `6:4` → `0.6`):
```bash
# If user enters "6:4":
ratio_a=$(echo "6:4" | awk -F: '{printf "%.4f", $1/($1+$2)}')
# Result: 0.6000
```

**Step 4 — Run recombination**

```bash
bash <clawdna_project_root>/scripts/reprodu.sh \
  <dna_a_path> <dna_b_path> <ratio_a> \
  2>/tmp/clawdna-reprodu-err.log
```

Capture stdout. If exit code is non-zero, read the error log and report to user.

**Step 5 — Parse and display the recombination report**

From stdout:
- Parse the section between `═══ ClawDNA Reproduction Report ═══` and `═══════`
- Display the full report to the user
- Extract `OUTPUT_PATH:` line for the new DNA file path

Example display:
```
✓ Recombination complete

New fingerprint: reprodu-a17fffc4-9f3e7a1c
  Parent A: deepeye-main-agent-a17fffc4-b5c4d3e2 (DeepEye Main Agent)
  Parent B: serverb-assistant-c4f2e1d0-9d8e7f6a  (ServerB Assistant)
  Ratio   : 60% A / 40% B

Agents inherited: 9
  agents.main      : from A
  agents.architect : from A
  agents.frontend  : from B (orphan B, inherited)
  agents.qa        : from B
  agents.devops    : SKIP (orphan A, rejected by random)
  agents.wealth-cio: from A

Dependency repair:
  auto-repair: added provider 'kimi-coding' from B (required by agent frontend)

New DNA saved to: ~/.openclaw/dna/reprodu-20260317143022.dna.yaml
```

**Step 6 — Offer to proceed with installation**

Ask the user:
> The new DNA is ready. Would you like to install it now using clawclone?
> - **Yes**: proceed with clawclone workflow on the new DNA
> - **No**: the DNA is saved and can be installed later with the `clawclone` skill

If yes, invoke the `clawclone` skill with the new DNA file path as context.

## Recombination rules reference

| Locus situation | Inheritance rule |
|-----------------|-----------------|
| Present in both A and B | Randomly pick A (ratio_a) or B (1-ratio_a) |
| Only in A (orphan) | Include with probability = ratio_a |
| Only in B (orphan) | Include with probability = 1 - ratio_a |
| Neither (impossible) | N/A |
| Result: empty agents | Force-include highest-probability orphan agent |
| Result: empty providers | Force-include highest-probability orphan provider |

Chromosomes recombined independently:
1. `infrastructure` — selected as a unit (A or B)
2. `providers` — per-provider-id locus recombination
3. `agents` — per-agent-id locus recombination
4. `skills.bundled_allowed` — per-skill union recombination
5. `skills.custom` — per-skill-name locus recombination
6. `channels` — selected as a unit (A or B)
7. `workspace` — selected as a unit (A or B)

After recombination, two dependency repair passes run automatically:
- **Round 1**: ensures all agent skills exist in the skills chromosome
- **Round 2**: ensures all agent model providers exist in the providers chromosome

## Notes

- Each run of `clawreprodu` produces a different result (true random seed)
- To reproduce a specific combination, save and reuse the output DNA file
- The new DNA still contains `{{PLACEHOLDER}}` values inherited from parents — use `clawclone` to fill them in during installation
- `lineage.parents` in the fingerprint records both parent IDs with their hardware UUID segments, enabling full ancestry tracing