skill-composer

Files (1)

• SKILL.md

SKILL.md (first lines)

# skill-composer

**P0 — Autonomous Multi-Step Workflow Chains**
**Seal:** DITEMPA BUKAN DIBERI · 2026-03-27

---

## Purpose

The gap between B+ (81.8%) and A (90%+) is **autonomy** — the ability to chain a multi-step workflow without asking Arif for permission at every step. The `skill-composer` is the orchestration layer that:

1. Takes a sovereign goal (Arif's intent) and decomposes it into constitutional steps
2. Routes each step through the correct skill (research, plan, execute, verify, vault)
3. Enforces F1–F13 at each transition
4. Provides Arif with veto points at the correct moments (F13)
5. Logs everything and seals outcomes to vault

**Why this is P0:** Without this, agents are slaves to the step-by-step prompt. Arif must babysit every research, every code change, every verification. The opencode catastrophe happened because an unanchored agent was given too much rope and no governance layer to stop it from hanging itself.

---

## Workflow Composition Types

### Type A — Research Chain
```
GOAL → deep-research → evidence-map → judgment → report
```
**Used for:** Understanding a system, investigating an issue, fact-finding
**Constitutional gates:** F2 (Truth ≥0.99), F7 (Humility band), F3 (Tri-Witness)

### Type B — Build Chain
```
GOAL → architect-explainer → plan → constitutional-check → forge → postcheck-verifier → vault-writer
```
**Used for:** New features, configuration changes, deployments
**Constitutional gates:** F1 (Reversibility), F11 (CommandAuth), F13 (Sovereign veto)

### Type C — Recovery Chain
```
GOAL → health-probe → diagnosis → rollback-governor → verify → seal
```
**Used for:** Incident response, service recovery, rollback
**Constitutional gates:** F1 (Amanah reversibility), F12 (Injection defense)

### Type D — Audit Chain
```
GOAL → arifos-status → constitutional-check → judgment → report → vault
```
**Used for:** Security audits, constitutional compliance reviews
**Constitutional gates:** F3 (Tri-Witness), F8 (GENIUS gate), F12 (Injection)

---

## Composition Protocol

### Step 0 — Anchor (Always First)
Run `arif-init-wrapper` before any composition.

### Step 1 — Goal Decomposition

For the given goal, identify:
- What skills are needed (in order)
- What constitutional floors are activated at each step
- Where the veto points are (F13 triggers)
- Whether the chain is reversible at each stage

```bash
# Example decomposition for "Fix the broken main branch"
cat << 'EOF'
CHAIN: Recovery Chain (Type C)
STEPS:
  1. health-probe         → F1, F2 (verify current state)
  2. diagnosis            → F2, F7 (what is actually broken)
  3. architect-explainer  → F13 (present plan to Arif)
  4. constitutional-check → F1-F13 (full floor review)
  5. [VETO POINT]          → F13 Arif decides: proceed or not
  6. recovery-execute      → F1 (reversibility path prepared)
  7. postcheck-verifier   → F2 (prove outcome, not just logs)
  8. vault-writer         → F1 (seal the scar)

REVERSIBILITY: Each step has rollback path except steps 6-8.
VETO POINTS: Step 5 (before execution), step 6 (before commit).
EOF
```

### Step 2 — Sequential Execution with Gates

```bash
# Execute each step with constitutional gate
for step in $STEPS; do
  # Check constitutional fitness before running
  constitutional-check tool=$step 2>/dev/null || {
    echo "[GATE FAIL] $step failed constitutional check"
    echo "[ACTION] Report to Arif. Do not proceed."
    break
  }

  # Execute step
  $step || {
    echo "[STEP FAIL] $step failed with exit code $?"
    echo "[ACTION] Trigger recovery chain or halt"
    break
  }

  # Verify step outcome
  postcheck-verifier step=$step || {
    echo "[VERIFY FAIL] $step completed but outcome not proven"
    break
  }
done
```

### Step 3 — Constitutional Check Before Each Major Transition

Before moving from research → plan, plan → execute, execute → verify:

```bash
# Constitutional gate between phases
arifosmcp_call tool=constitutional_check payload='{

From ariffazil/arifOS, AGPL-3.0.

More from ariffazil/arifOS