postcheck-verifier

Files (1)

• SKILL.md

SKILL.md (first lines)

# postcheck-verifier

**P0 — Reality-Proven Outcome Verification**
**Seal:** DITEMPA BUKAN DIBERI · 2026-03-27

---

## Purpose

Every agent reports success too easily. `exit code 0` means the command ran, not that the goal was achieved. The `postcheck-verifier` exists because:

> **"The map is not the territory. The exit code is not the outcome."**

The opencode catastrophe is a textbook example: every git command returned success, every merge reported completion, and the final state was catastrophic destruction. Success was assumed from the command's return code, not from the system's actual state.

**Why this is P0:** Closing this gap adds an estimated +20% to AGI readiness (the single largest jump in the P0 set). `postcheck-verifier` is what separates a tool-using automaton from an AGI agent.

---

## The Verification Hierarchy

Not all verification is equal. Use the right level:

| Level | What It Proves | Example |
|-------|---------------|---------|
| **L0 — Exit Code** | Command ran | `grep` found something |
| **L1 — Output Check** | Output matches expectation | `docker ps` shows running container |
| **L2 — State Probe** | System state changed as intended | HTTP endpoint responds correctly |
| **L3 — Functional Test** | The feature actually works | User can log in, API returns correct data |
| **L4 — Reality Proof** | The change achieved the goal in the real world | The system does what Arif asked |

**Minimum standard for arifOS:** L2 for routine ops. L3 for code changes. L4 for sovereign decisions.

---

## Verification Protocol

### After Every Action — Run This

```bash
postcheck-verifier() {
  local action="$1"
  local expected="$2"
  local actual="$(eval "$action" 2>/dev/null)"
  local exit_code=$?

  # L0: Command ran
  if [ $exit_code -ne 0 ]; then
    echo "[L0 FAIL] Command exited with code $exit_code"
    echo "[ACTUAL] $actual"
    return 1
  fi
  echo "[L0 PASS] Command exited 0"

  # L1: Output matches expectation
  if [ -n "$expected" ] && ! echo "$actual" | grep -q "$expected"; then
    echo "[L1 FAIL] Output did not contain expected: $expected"
    echo "[ACTUAL] $actual"
    return 1
  fi
  echo "[L1 PASS] Output matches expected"

  # L2: State probe (when applicable)
  case "$action" in
    docker\ start*)
      container_name=$(echo "$action" | awk '{print $3}')
      state=$(docker inspect -f '{{.State.Running}}' "$container_name" 2>/dev/null)
      [ "$state" = "true" ] && echo "[L2 PASS] Container $container_name is running" || {
        echo "[L2 FAIL] Container $container_name not running"
        return 1
      }
      ;;
    curl\ -sf\ http://localhost:*)
      endpoint="${action#curl -sf }"
      curl -sf "$endpoint" > /dev/null 2>&1 && echo "[L2 PASS] $endpoint responds" || {
        echo "[L2 FAIL] $endpoint not reachable"
        return 1
      }
      ;;
    git\ push*)
      # Check remote actually has the commits
      git fetch origin 2>/dev/null
      local_sha=$(git rev-parse HEAD)
      remote_sha=$(git rev-parse origin/main 2>/dev/null)
      [ "$local_sha" = "$remote_sha" ] && echo "[L2 PASS] Commit on remote" || {
        echo "[L2 FAIL] Commit not on remote. Local=$local_sha Remote=$remote_sha"
        return 1
      }
      ;;
  esac

  echo "[VERIFIED] Action verified to L2. For L3/L4, manual verification recommended."
  return 0
}
```

### L3 — Functional Test Template

```bash
# For code changes — run actual functional proof
test_functional() {
  local feature="$1"
  case "$feature" in
    mcp_health)
      # Real probe: does the MCP actually process a request?
      response=$(curl -sf -X POST http://localhost:8080/mcp \
        -H "Content-Type: application/json" \
        -d '{"method":"tools/call","params":{"name":"health_probe"}}' 2>/dev/null)
      echo "$response" | grep -q "healthy" && echo "[L3 PASS] MCP functional" || {
        echo "[L3 FAIL] MCP responded but not healthy"
        return 1
      }
      ;;
    docker_compose)
      # Real probe: are all critical services reachable?
      for service in arifosmcp traefik postgres; do
        docker ps --filter "name=$service" --filter "status=running" | grep -q "$service" || {
          echo "[L3 FAIL] $service not running"
          return 1

From ariffazil/arifOS, AGPL-3.0.

More from ariffazil/arifOS