Ralph

#!/usr/bin/env bash
# ooo-state.sh — ralph-ooo state file manager
#
# Manages .omc/state/ralph-ooo-state.json for the ralph-ooo persistent loop.
#
# Usage:
#   bash ooo-state.sh <subcommand> [args]
#
# Subcommands:
#   init <request> [max_iterations]  Create a new state file
#   status                           Print current state summary
#   checkpoint [note]                Increment iteration counter
#   reset                            Clear state file (sets status: cancelled)
#   resume                           Print resume instructions
#   history                          Print verification history

set -euo pipefail

STATE_DIR=".omc/state"
STATE_FILE="$STATE_DIR/ralph-ooo-state.json"

RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
GRAY='\033[0;37m'
CYAN='\033[0;36m'
NC='\033[0m'

# ── Helpers ──────────────────────────────────────────────────────────────────
require_python() {
  if ! command -v python3 &>/dev/null; then
    echo -e "${RED}✗ python3 required but not found${NC}" >&2
    exit 1
  fi
}

require_state() {
  if [ ! -f "$STATE_FILE" ]; then
    echo -e "${RED}✗ No state file at ${STATE_FILE}${NC}" >&2
    echo -e "${GRAY}  Run: bash ooo-state.sh init \"your task\"${NC}" >&2
    exit 1
  fi
}

generate_uuid() {
  if command -v python3 &>/dev/null; then
    python3 -c "import uuid; print(str(uuid.uuid4()))"
  elif command -v uuidgen &>/dev/null; then
    uuidgen | tr '[:upper:]' '[:lower:]'
  else
    echo "$(date +%s)-$$-$(od -An -N4 -tx4 /dev/urandom 2>/dev/null | tr -d ' ' || echo 'rand')"
  fi
}

now_iso() {
  date -u +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || date +"%Y-%m-%dT%H:%M:%SZ"
}

# ── Subcommands ───────────────────────────────────────────────────────────────

cmd_init() {
  local request="${1:-unnamed task}"
  local max_iter="${2:-10}"
  local session_id
  session_id="$(generate_uuid)"
  local timestamp
  timestamp="$(now_iso)"

  require_python
  mkdir -p "$STATE_DIR"

  python3 - "$STATE_FILE" "$session_id" "$request" "$max_iter" "$timestamp" <<'PYEOF'
import json, sys

path, sid, req, max_it, ts = sys.argv[1], sys.argv[2], sys.argv[3], int(sys.argv[4]), sys.argv[5]

state = {
    "mode": "ralph-ooo",
    "session_id": sid,
    "request": req,
    "status": "running",
    "iteration": 0,
    "max_iterations": max_it,
    "last_checkpoint": None,
    "seed_path": None,
    "created_at": ts,
    "updated_at": ts,
    "verification_history": []
}

with open(path, "w") as f:
    json.dump(state, f, indent=2)
    f.write("\n")

print(f"session_id: {sid}")
PYEOF

  echo ""
  echo -e "${GREEN}✓ State file initialized: ${STATE_FILE}${NC}"
  echo -e "  session_id:     $(python3 -c "import json; d=json.load(open('$STATE_FILE')); print(d['session_id'])")"
  echo -e "  request:        ${request}"
  echo -e "  max_iterations: ${max_iter}"
  echo -e "  status:         running"
  echo ""
}

cmd_status() {
  require_state
  require_python

  python3 - "$STATE_FILE" <<'PYEOF'
import json, sys

with open(sys.argv[1]) as f:
    d = json.load(f)

status = d.get("status", "unknown")
color = {
    "running": "\033[0;33m",
    "complete": "\033[0;32m",
    "failed": "\033[0;31m",
    "cancelled": "\033[0;37m"
}.get(status, "\033[0m")
NC = "\033[0m"

print(f"\n{color}Status: {status}{NC}")
print(f"  Session:    {d.get('session_id', 'N/A')}")
print(f"  Request:    {d.get('request', 'N/A')}")
print(f"  Iteration:  {d.get('iteration', 0)} / {d.get('max_iterations', 10)}")
print(f"  Checkpoint: {d.get('last_checkpoint', 'none')}")
print(f"  Seed:       {d.get('seed_path', 'none')}")

history = d.get("verification_history", [])
if history:
    print(f"\n  Verification history ({len(history)} entries):")
    for h in history[-5:]:  # last 5
        marker = "✓" if h.get("passed") else "✗"
        score = h.get("score", "?")
        print(f"    [{marker}] Iter {h.get('iteration', '?')}: score={score}")
print()
PYEOF
}

cmd_checkpoint() {
  require_state
  require_python
  local note="${1:-}"
  local timestamp
  timestamp="$(now_iso)"

  python3 - "$STATE_FILE" "$timestamp" "$note" <<'PYEOF'
import json, sys

path, ts, note = sys.argv[1], sys.argv[2], sys.argv[3]

with open(path) as f:
    d = json.load(f)

old_iter = d.get("iteration", 0)
d["iteration"] = old_iter + 1
d["last_checkpoint"] = f"iteration_{d['iteration']}"
d["updated_at"] = ts

with open(path, "w") as f:
    json.dump(d, f, indent=2)
    f.write("\n")

print(f"Iteration {old_iter} → {d['iteration']} (checkpoint: {d['last_checkpoint']})")
PYEOF

  echo -e "${GREEN}✓ Checkpoint saved: iteration $(python3 -c "import json; d=json.load(open('$STATE_FILE')); print(d['iteration'])")${NC}"
}

cmd_complete() {
  require_state
  require_python
  local timestamp
  timestamp="$(now_iso)"

  python3 - "$STATE_FILE" "$timestamp" <<'PYEOF'
import json, sys

path, ts = sys.argv[1], sys.argv[2]

with open(path) as f:
    d = json.load(f)

d["status"] = "complete"
d["last_checkpoint"] = "complete"
d["updated_at"] = ts

with open(path, "w") as f:
    json.dump(d, f, indent=2)
    f.write("\n")

print(f"Marked complete at iteration {d.get('iteration', 0)}")
PYEOF

  echo -e "${GREEN}✓ State marked complete${NC}"
}

cmd_reset() {
  if [ ! -f "$STATE_FILE" ]; then
    echo -e "${YELLOW}⚠ No state file to reset${NC}"
    exit 0
  fi

  require_python
  local timestamp
  timestamp="$(now_iso)"

  python3 - "$STATE_FILE" "$timestamp" <<'PYEOF'
import json, sys

path, ts = sys.argv[1], sys.argv[2]

with open(path) as f:
    d = json.load(f)

d["status"] = "cancelled"
d["last_checkpoint"] = "cancelled"
d["updated_at"] = ts

with open(path, "w") as f:
    json.dump(d, f, indent=2)
    f.write("\n")

print("State reset (status: cancelled)")
PYEOF

  echo -e "${YELLOW}✓ State reset (status: cancelled)${NC}"
  echo -e "${GRAY}  File kept at ${STATE_FILE} — run 'init' to start fresh${NC}"
}

cmd_resume() {
  require_state
  require_python

  local session_id iter max_iter request status
  session_id="$(python3 -c "import json; d=json.load(open('$STATE_FILE')); print(d.get('session_id','?'))")"
  iter="$(python3 -c "import json; d=json.load(open('$STATE_FILE')); print(d.get('iteration',0))")"
  max_iter="$(python3 -c "import json; d=json.load(open('$STATE_FILE')); print(d.get('max_iterations',10))")"
  request="$(python3 -c "import json; d=json.load(open('$STATE_FILE')); print(d.get('request','?'))")"
  status="$(python3 -c "import json; d=json.load(open('$STATE_FILE')); print(d.get('status','?'))")"

  echo ""
  echo -e "${CYAN}ralph-ooo Resume Instructions${NC}"
  echo -e "══════════════════════════════"
  echo -e "  Session:    ${session_id}"
  echo -e "  Request:    ${request}"
  echo -e "  Iteration:  ${iter}/${max_iter}"
  echo -e "  Status:     ${status}"
  echo ""
  echo -e "${BLUE}To resume, say one of:${NC}"
  echo -e "  ooo ralph continue"
  echo -e "  ooo ralph continue --session-id=${session_id}"
  echo -e "  /ralph \"${request}\" --max-iterations=${max_iter}"
  echo ""
}

cmd_history() {
  require_state
  require_python

  python3 - "$STATE_FILE" <<'PYEOF'
import json, sys

with open(sys.argv[1]) as f:
    d = json.load(f)

history = d.get("verification_history", [])
if not history:
    print("No verification history yet.")
    sys.exit(0)

print(f"\nVerification History ({len(history)} entries):")
print("─" * 50)
for h in history:
    marker = "PASS ✓" if h.get("passed") else "FAIL ✗"
    score  = h.get("score", "?")
    itr    = h.get("iteration", "?")
    ts     = h.get("timestamp", "?")
    issues = h.get("issues", [])
    print(f"  Iteration {itr}: {marker} (score={score}) [{ts}]")
    for issue in issues:
        print(f"    - {issue}")
print()
PYEOF
}

# ── Dispatch ──────────────────────────────────────────────────────────────────
SUBCOMMAND="${1:-help}"
shift || true

case "$SUBCOMMAND" in
  init)       cmd_init "$@" ;;
  status)     cmd_status ;;
  checkpoint) cmd_checkpoint "${1:-}" ;;
  complete)   cmd_complete ;;
  reset)      cmd_reset ;;
  resume)     cmd_resume ;;
  history)    cmd_history ;;
  help|--help|-h)
    echo ""
    echo -e "${BLUE}ooo-state.sh — ralph-ooo state manager${NC}"
    echo ""
    echo "Usage: bash ooo-state.sh <subcommand> [args]"
    echo ""
    echo "Subcommands:"
    echo "  init <request> [max]  Create new state file (default max: 10)"
    echo "  status                Print current state summary"
    echo "  checkpoint [note]     Increment iteration counter + save checkpoint"
    echo "  complete              Mark loop as complete"
    echo "  reset                 Set status to cancelled (keeps file)"
    echo "  resume                Print resume instructions"
    echo "  history               Print full verification history"
    echo ""
    echo "State file: ${STATE_FILE}"
    echo ""
    ;;
  *)
    echo -e "${RED}Unknown subcommand: ${SUBCOMMAND}${NC}" >&2
    echo "Run: bash ooo-state.sh help" >&2
    exit 1
    ;;
esac

#!/usr/bin/env bash
# ralph-ooo (Ouroboros) - Codex CLI setup helper
# Configures Codex for the full Ouroboros specification-first workflow:
#
#  1) developer_instructions  → ~/.codex/config.toml
#  2) ~/.codex/prompts/ralph-ooo.md      (load via /prompts:ralph-ooo)
#  3) ~/.codex/prompts/ouroboros.md      (load via /prompts:ouroboros)
#
# Usage:
#   bash setup-codex-hook.sh [--dry-run] [--help]

set -euo pipefail

RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
GRAY='\033[0;37m'
NC='\033[0m'

DRY_RUN=false
for arg in "$@"; do
  case "$arg" in
    --dry-run) DRY_RUN=true ;;
    -h|--help)
      echo "Usage: $0 [--dry-run]"
      echo ""
      echo "Configures Codex CLI for ralph-ooo / Ouroboros workflows:"
      echo "  1. Adds ooo command contract to ~/.codex/config.toml developer_instructions"
      echo "  2. Creates ~/.codex/prompts/ralph-ooo.md  (load via /prompts:ralph-ooo)"
      echo "  3. Creates ~/.codex/prompts/ouroboros.md  (load via /prompts:ouroboros)"
      echo ""
      echo "Options:"
      echo "  --dry-run   Show what would change without writing"
      echo "  -h, --help  Show this help"
      exit 0
      ;;
    *) ;;
  esac
done

CODEX_DIR="$HOME/.codex"
CODEX_CONFIG="$CODEX_DIR/config.toml"
CODEX_PROMPTS="$CODEX_DIR/prompts"
RALPH_OOO_PROMPT="$CODEX_PROMPTS/ralph-ooo.md"
OUROBOROS_PROMPT="$CODEX_PROMPTS/ouroboros.md"

echo ""
echo -e "${BLUE}╔════════════════════════════════════════════════╗${NC}"
echo -e "${BLUE}║  ralph-ooo × Codex setup                      ║${NC}"
echo -e "${BLUE}║  Stop prompting. Start specifying.             ║${NC}"
echo -e "${BLUE}╚════════════════════════════════════════════════╝${NC}"
echo ""

if ! command -v codex &>/dev/null; then
  echo -e "${YELLOW}⚠ codex CLI not found in PATH${NC}"
  echo -e "${GRAY}  Install via: npm install -g @openai/codex${NC}"
  echo -e "${GRAY}  Continuing setup anyway (config and prompts will be prepared).${NC}"
  echo ""
fi

mkdir -p "$CODEX_DIR" "$CODEX_PROMPTS"

# ── developer_instructions ──────────────────────────────────────────────────
OOO_INSTRUCTION='ralph-ooo / Ouroboros specification-first workflow active.

COMMANDS:
  ooo interview [topic]   - Socratic questioning until Ambiguity<=0.2
  ooo seed                - Crystallize into immutable YAML spec
  ooo run [seed.yaml]     - Execute via Double Diamond (Discover/Define/Design/Deliver)
  ooo evaluate <id>       - 3-stage: Mechanical->Semantic->Consensus; drift threshold<=0.3
  ooo evolve [topic]      - Evolutionary loop until Similarity>=0.95 or 30 generations
  ooo unstuck [persona]   - Lateral thinking: simplifier|hacker|contrarian|researcher|architect
  ooo status [id]         - Drift check: Goal(50%)+Constraint(30%)+Ontology(20%)
  ooo ralph "task"        - Persistent loop until verified; boulder never stops

RALPH LOOP CONTRACT:
  /ralph "<task>" [--completion-promise=TEXT] [--max-iterations=N]
  1) Keep original task unchanged across all retries
  2) Detect completion: <promise>DONE</promise> in output
  3) If promise missing and iteration < max: continue immediately
  4) Default promise: DONE. Default max: 10.
  5) State file: .omc/state/ralph-ooo-state.json (updated each iteration)

AMBIGUITY GATE: Ambiguity = 1 - SUM(clarity_i x weight_i) must be <=0.2 before seed
CONVERGENCE: Similarity = 0.5*name_overlap + 0.3*type_match + 0.2*exact_match >= 0.95'

# ── Step 1: config.toml ──────────────────────────────────────────────────────
echo -e "${BLUE}Step 1: config.toml developer_instructions${NC}"
if [ -f "$CODEX_CONFIG" ] && grep -q "ralph-ooo\|ooo interview\|ouroboros" "$CODEX_CONFIG" 2>/dev/null; then
  echo -e "${YELLOW}⚠ developer_instructions already contains ralph-ooo/Ouroboros reference${NC}"
  echo -e "${GRAY}  No changes made to config.toml.${NC}"
else
  if [ "$DRY_RUN" = true ]; then
    echo -e "${YELLOW}[DRY RUN] Would add ralph-ooo ooo contract to developer_instructions in ${CODEX_CONFIG}${NC}"
  else
    if [ -f "$CODEX_CONFIG" ] && grep -q "^developer_instructions" "$CODEX_CONFIG" 2>/dev/null; then
      if command -v python3 &>/dev/null; then
        python3 - "$CODEX_CONFIG" "$OOO_INSTRUCTION" <<'PYEOF'
import sys, re

path, addition = sys.argv[1], sys.argv[2]

def escape_toml(v):
    return v.replace("\\", "\\\\").replace('"', '\\"')

with open(path) as f:
    content = f.read()

pattern = re.compile(r'^(developer_instructions\s*=\s*")(.+?)(")', re.MULTILINE | re.DOTALL)
match = pattern.search(content)
if match:
    current = match.group(2)
    if "ralph-ooo" not in current and "ooo interview" not in current:
        new_val = current + " " + addition
        content = (content[:match.start()]
                   + f'developer_instructions = "{escape_toml(new_val)}"'
                   + content[match.end():])
        with open(path, "w") as out:
            out.write(content)
        print("Updated existing developer_instructions.")
    else:
        print("developer_instructions already includes ralph-ooo contract.")
else:
    with open(path, "a") as out:
        out.write(f'\ndeveloper_instructions = "{escape_toml(addition)}"\n')
    print("Appended developer_instructions.")
PYEOF
      else
        printf '\ndeveloper_instructions = "%s"\n' "$OOO_INSTRUCTION" >> "$CODEX_CONFIG"
      fi
    else
      printf 'developer_instructions = "%s"\n' "$OOO_INSTRUCTION" > "$CODEX_CONFIG"
    fi
    echo -e "${GREEN}✓ Updated ${CODEX_CONFIG}${NC}"
  fi
fi

# ── Step 2: ralph-ooo prompt ─────────────────────────────────────────────────
echo ""
echo -e "${BLUE}Step 2: ralph-ooo prompt file (${RALPH_OOO_PROMPT})${NC}"

RALPH_OOO_CONTENT='# ralph-ooo — Ouroboros Completion Loop

The boulder never stops. This prompt configures Codex for ralph-ooo loop execution.

## Loop Contract

```
/ralph "task" [--completion-promise=TEXT] [--max-iterations=N]
```

1. Keep original task unchanged across all retries
2. Completion detected as: `<promise>DONE</promise>` in output
3. If not found and iteration < max → continue immediately
4. Default promise: `DONE` | Default max iterations: `10`

## State File

Create `.omc/state/ralph-ooo-state.json` at loop start:
```json
{
  "mode": "ralph-ooo",
  "session_id": "<uuid>",
  "request": "<original request>",
  "status": "running",
  "iteration": 0,
  "max_iterations": 10,
  "last_checkpoint": null,
  "seed_path": null,
  "verification_history": []
}
```

## Progress Report Format

```
[Ralph-OOO Iteration N/max]
Executing in parallel...

Verification: FAILED | PASSED
Score: 0.0 – 1.0
Issues:
  - <issue 1>

The boulder never stops. Continuing...
```

## Completion

```
<promise>DONE</promise>

Ralph-OOO COMPLETE
==================
Request: <original>
Duration: <time>
Iterations: <count>
```

## Full ooo Workflow

```
ooo interview "topic"   → Socratic interview (Ambiguity≤0.2)
ooo seed                → Generate spec
ooo run [seed.yaml]     → Execute spec
ooo evaluate <id>       → 3-stage verification
ooo evolve "topic"      → Evolutionary loop (Similarity≥0.95)
ooo unstuck [persona]   → Lateral thinking
ooo ralph "task"        → Persistent loop
```

See /prompts:ouroboros for the complete Ouroboros reference.
'

if [ -f "$RALPH_OOO_PROMPT" ]; then
  echo -e "${YELLOW}⚠ ${RALPH_OOO_PROMPT} already exists — overwriting${NC}"
fi
if [ "$DRY_RUN" = true ]; then
  echo -e "${YELLOW}[DRY RUN] Would create/update ${RALPH_OOO_PROMPT}${NC}"
else
  printf '%s\n' "$RALPH_OOO_CONTENT" > "$RALPH_OOO_PROMPT"
  echo -e "${GREEN}✓ Created ${RALPH_OOO_PROMPT}${NC}"
fi

# ── Step 3: ouroboros prompt ─────────────────────────────────────────────────
echo ""
echo -e "${BLUE}Step 3: ouroboros prompt file (${OUROBOROS_PROMPT})${NC}"

OUROBOROS_CONTENT='# Ouroboros — Specification-First AI Development

> Stop prompting. Start specifying.
> The serpent does not repeat — it evolves.

## The Loop

```
Interview → Seed → Execute → Evaluate
    ↑                           ↓
    └──── Evolutionary Loop ────┘
```

## Commands

| Command | What It Does |
|---------|--------------|
| `ooo interview "topic"` | Socratic questioning → Ambiguity≤0.2 |
| `ooo seed` | Crystallize into immutable YAML spec |
| `ooo run [seed.yaml]` | Execute via Double Diamond |
| `ooo evaluate <id>` | 3-stage: Mechanical→Semantic→Consensus |
| `ooo evolve "topic"` | Evolutionary loop → Similarity≥0.95 |
| `ooo unstuck [persona]` | Lateral thinking: simplifier|hacker|contrarian|researcher|architect |
| `ooo status [id]` | Drift check (threshold ≤ 0.3) |
| `ooo ralph "task"` | Persistent loop until verified |

## Ambiguity Gate

```
Ambiguity = 1 − Σ(clarityᵢ × weightᵢ)
Greenfield: Goal(40%) + Constraint(30%) + Success(30%)
Brownfield: Goal(35%) + Constraint(25%) + Success(25%) + Context(15%)
Threshold: ≤ 0.2 → ready for Seed
```

## Convergence Gate

```
Similarity = 0.5×name_overlap + 0.3×type_match + 0.2×exact_match
Threshold: ≥ 0.95 → CONVERGED → loop stops
```

## Nine Minds (On-Demand)

socratic-interviewer | ontologist | seed-architect | evaluator |
contrarian | hacker | simplifier | researcher | architect

## Cancellation

- `/ouroboros:cancel` — save checkpoint, exit
- `/ouroboros:cancel --force` — clear all state
- `/ralph-ooo:cancel` — alias
- `ooo ralph continue` — resume from checkpoint

Source: https://github.com/Q00/ouroboros — MIT License
'

if [ -f "$OUROBOROS_PROMPT" ]; then
  echo -e "${YELLOW}⚠ ${OUROBOROS_PROMPT} already exists — overwriting${NC}"
fi
if [ "$DRY_RUN" = true ]; then
  echo -e "${YELLOW}[DRY RUN] Would create/update ${OUROBOROS_PROMPT}${NC}"
else
  printf '%s\n' "$OUROBOROS_CONTENT" > "$OUROBOROS_PROMPT"
  echo -e "${GREEN}✓ Created ${OUROBOROS_PROMPT}${NC}"
fi

# ── Summary ───────────────────────────────────────────────────────────────────
echo ""
echo -e "${GREEN}ralph-ooo × Codex setup complete.${NC}"
echo ""
echo -e "${BLUE}Next steps:${NC}"
echo -e "  1. Restart Codex session"
echo -e "  2. Load ralph-ooo context:  ${GREEN}/prompts:ralph-ooo${NC}"
echo -e "  3. Load full reference:     ${GREEN}/prompts:ouroboros${NC}"
echo -e "  4. Start specification:     ${GREEN}ooo interview \"your idea\"${NC}"
echo -e "  5. Start persistent loop:   ${GREEN}/ralph \"your task\" --max-iterations=10${NC}"
echo ""
echo -e "${GRAY}Note: Codex has no native AfterAgent hooks.${NC}"
echo -e "${GRAY}Ralph loop relies on <promise>DONE</promise> detection.${NC}"
echo ""

#!/usr/bin/env bash
# ralph-ooo (Ouroboros) - Gemini CLI AfterAgent hook setup
#
# Configures Gemini CLI to run the ralph-ooo loop continuation hook after each agent turn.
#
# What it does:
#   1) Creates ~/.gemini/hooks/ralph-ooo-check.sh (AfterAgent hook script)
#   2) Patches ~/.gemini/settings.json with the AfterAgent hook entry
#   3) Creates ~/.gemini/extensions/ralph-ooo/ context directory
#
# ⚠️  Gemini v0.30.0 bug: stop_hook_active is always false in hook JSON.
#     This script uses direct state file reading as workaround.
#
# Usage:
#   bash setup-gemini-hook.sh [--dry-run] [--help]

set -euo pipefail

RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
GRAY='\033[0;37m'
NC='\033[0m'

DRY_RUN=false
for arg in "$@"; do
  case "$arg" in
    --dry-run) DRY_RUN=true ;;
    -h|--help)
      echo "Usage: $0 [--dry-run]"
      echo ""
      echo "Configures Gemini CLI for ralph-ooo loop continuation:"
      echo "  1. Creates ~/.gemini/hooks/ralph-ooo-check.sh (AfterAgent hook)"
      echo "  2. Patches ~/.gemini/settings.json (adds AfterAgent hook entry)"
      echo "  3. Creates ~/.gemini/extensions/ralph-ooo/ (context directory)"
      echo ""
      echo "After setup, run Gemini with:"
      echo "  gemini -s -y   # sandbox + YOLO mode (no confirmation prompts)"
      echo ""
      echo "NOTE: Gemini v0.30.0 bug — stop_hook_active always false."
      echo "      This script reads .omc/state/ralph-ooo-state.json directly."
      echo ""
      echo "Options:"
      echo "  --dry-run   Show what would change without writing"
      echo "  -h, --help  Show this help"
      exit 0
      ;;
    *) ;;
  esac
done

GEMINI_DIR="$HOME/.gemini"
GEMINI_SETTINGS="$GEMINI_DIR/settings.json"
GEMINI_HOOKS="$GEMINI_DIR/hooks"
GEMINI_EXT="$GEMINI_DIR/extensions/ralph-ooo"
HOOK_SCRIPT="$GEMINI_HOOKS/ralph-ooo-check.sh"

echo ""
echo -e "${BLUE}╔════════════════════════════════════════════════╗${NC}"
echo -e "${BLUE}║  ralph-ooo × Gemini CLI setup                 ║${NC}"
echo -e "${BLUE}║  AfterAgent hook for loop continuation        ║${NC}"
echo -e "${BLUE}╚════════════════════════════════════════════════╝${NC}"
echo ""

if ! command -v gemini &>/dev/null; then
  echo -e "${YELLOW}⚠ gemini CLI not found in PATH${NC}"
  echo -e "${GRAY}  Install: npm install -g @google/generative-ai-cli${NC}"
  echo -e "${GRAY}  Continuing setup anyway.${NC}"
  echo ""
fi

mkdir -p "$GEMINI_DIR" "$GEMINI_HOOKS" "$GEMINI_EXT"

# ── Step 1: AfterAgent hook script ───────────────────────────────────────────
echo -e "${BLUE}Step 1: AfterAgent hook script (${HOOK_SCRIPT})${NC}"

HOOK_CONTENT='#!/usr/bin/env bash
# ralph-ooo AfterAgent hook for Gemini CLI
#
# Reads .omc/state/ralph-ooo-state.json to decide whether to continue the loop.
# Workaround for Gemini v0.30.0 bug: stop_hook_active is always false in hook JSON.
# We read the state file directly instead of relying on the hook field.
#
# Exit 0  → agent stops (loop complete or not running)
# Exit 1  → agent continues (loop still running)

STATE_FILE=".omc/state/ralph-ooo-state.json"

# Not running ralph-ooo
if [ ! -f "$STATE_FILE" ]; then
  exit 0
fi

if ! command -v python3 &>/dev/null; then
  exit 0
fi

STATUS=$(python3 -c "
import json, sys
try:
    with open(\"$STATE_FILE\") as f:
        d = json.load(f)
    print(d.get(\"status\", \"\"))
except Exception:
    print(\"\")
")

ITER=$(python3 -c "
import json, sys
try:
    with open(\"$STATE_FILE\") as f:
        d = json.load(f)
    print(d.get(\"iteration\", 0))
except Exception:
    print(0)
")

MAX=$(python3 -c "
import json, sys
try:
    with open(\"$STATE_FILE\") as f:
        d = json.load(f)
    print(d.get(\"max_iterations\", 10))
except Exception:
    print(10)
")

# Loop is done
if [ "$STATUS" = "complete" ] || [ "$STATUS" = "cancelled" ] || [ "$STATUS" = "failed" ]; then
  exit 0
fi

# Iteration cap reached
if [ "$ITER" -ge "$MAX" ]; then
  echo "ralph-ooo: max_iterations ($MAX) reached. Loop stopping." >&2
  exit 0
fi

# Loop still running — inject continuation context
echo "RALPH_OOO_CONTINUE: Iteration $ITER/$MAX still running. Continue the ooo ralph loop. The boulder never stops." >&2
exit 1
'

if [ -f "$HOOK_SCRIPT" ]; then
  echo -e "${YELLOW}⚠ ${HOOK_SCRIPT} already exists — overwriting${NC}"
fi

if [ "$DRY_RUN" = true ]; then
  echo -e "${YELLOW}[DRY RUN] Would create ${HOOK_SCRIPT}${NC}"
else
  printf '%s\n' "$HOOK_CONTENT" > "$HOOK_SCRIPT"
  chmod +x "$HOOK_SCRIPT"
  echo -e "${GREEN}✓ Created ${HOOK_SCRIPT}${NC}"
fi

# ── Step 2: Patch settings.json ───────────────────────────────────────────────
echo ""
echo -e "${BLUE}Step 2: Patch ~/.gemini/settings.json${NC}"

if [ "$DRY_RUN" = true ]; then
  echo -e "${YELLOW}[DRY RUN] Would patch ${GEMINI_SETTINGS} with AfterAgent hook${NC}"
elif command -v python3 &>/dev/null; then
  python3 - "$GEMINI_SETTINGS" "$HOOK_SCRIPT" "$GEMINI_EXT" <<'PYEOF'
import json, sys, os

settings_path = sys.argv[1]
hook_script   = sys.argv[2]
ext_dir       = sys.argv[3]

# Load or create settings
if os.path.exists(settings_path):
    with open(settings_path) as f:
        try:
            settings = json.load(f)
        except json.JSONDecodeError:
            settings = {}
else:
    settings = {}

# hooksConfig
settings.setdefault("hooksConfig", {})["enabled"] = True

# context includeDirectories
ctx = settings.setdefault("context", {})
dirs = ctx.setdefault("includeDirectories", [])
if ext_dir not in dirs:
    dirs.append(ext_dir)

# AfterAgent hook entry
hook_entry = {
    "matcher": "*",
    "hooks": [{
        "type": "command",
        "command": f"bash {hook_script}",
        "timeout": 10
    }]
}

hooks = settings.setdefault("hooks", {})
after_agent = hooks.setdefault("AfterAgent", [])

# Check if already present
already = any(
    any(h.get("command", "").endswith("ralph-ooo-check.sh")
        for h in entry.get("hooks", []))
    for entry in after_agent
)
if not already:
    after_agent.append(hook_entry)
    print("Added AfterAgent hook entry.")
else:
    print("AfterAgent hook already present.")

with open(settings_path, "w") as f:
    json.dump(settings, f, indent=2)
    f.write("\n")
print(f"Updated {settings_path}")
PYEOF
  echo -e "${GREEN}✓ Patched ${GEMINI_SETTINGS}${NC}"
else
  echo -e "${YELLOW}⚠ python3 not found — skipping settings.json patch${NC}"
  echo -e "${GRAY}  Add manually to ${GEMINI_SETTINGS}:${NC}"
  echo -e "${GRAY}  {\"hooks\": {\"AfterAgent\": [{\"matcher\": \"*\", \"hooks\": [{\"type\": \"command\", \"command\": \"bash ${HOOK_SCRIPT}\", \"timeout\": 10}]}]}}${NC}"
fi

# ── Step 3: Extensions context directory ─────────────────────────────────────
echo ""
echo -e "${BLUE}Step 3: Extensions context directory (${GEMINI_EXT})${NC}"

EXT_CONTEXT="$GEMINI_EXT/CONTEXT.md"
EXT_CONTENT='# ralph-ooo — Ouroboros for Gemini CLI

Ouroboros specification-first workflow is active.

## ooo Commands

| Command | What It Does |
|---------|--------------|
| `ooo interview "topic"` | Socratic questioning until Ambiguity≤0.2 |
| `ooo seed` | Crystallize into immutable YAML spec |
| `ooo run [seed.yaml]` | Execute via Double Diamond |
| `ooo evaluate <id>` | 3-stage: Mechanical→Semantic→Consensus |
| `ooo evolve "topic"` | Evolutionary loop until Similarity≥0.95 |
| `ooo unstuck [persona]` | Lateral thinking |
| `ooo status [id]` | Drift check |
| `ooo ralph "task"` | Persistent loop — the boulder never stops |

## Ralph Loop State

State file: `.omc/state/ralph-ooo-state.json`
Completion signal: `<promise>DONE</promise>`

## Cancellation

`/ouroboros:cancel` — save checkpoint and exit
`/ouroboros:cancel --force` — clear all state
`ooo ralph continue` — resume from checkpoint

Source: https://github.com/Q00/ouroboros — MIT License
'

if [ "$DRY_RUN" = true ]; then
  echo -e "${YELLOW}[DRY RUN] Would create ${EXT_CONTEXT}${NC}"
else
  printf '%s\n' "$EXT_CONTENT" > "$EXT_CONTEXT"
  echo -e "${GREEN}✓ Created ${EXT_CONTEXT}${NC}"
fi

# ── Summary ───────────────────────────────────────────────────────────────────
echo ""
echo -e "${GREEN}ralph-ooo × Gemini CLI setup complete.${NC}"
echo ""
echo -e "${BLUE}Next steps:${NC}"
echo -e "  1. Restart Gemini session"
echo -e "  2. Run with sandbox + YOLO mode: ${GREEN}gemini -s -y${NC}"
echo -e "  3. Start specification: ${GREEN}ooo interview \"your idea\"${NC}"
echo -e "  4. Start persistent loop: ${GREEN}ooo ralph \"your task\"${NC}"
echo ""
echo -e "${YELLOW}⚠  Known issue: Gemini v0.30.0 — stop_hook_active always false.${NC}"
echo -e "${GRAY}   Workaround: hook reads .omc/state/ralph-ooo-state.json directly.${NC}"
echo ""

N:ralph
D:Ouroboros specification-first AI development — complete system. Socratic interview (Ambiguity≤0.2) → immutable YAML seed → Double Diamond execute → 3-stage evaluate → evolutionary evolve (Similarity≥0.95). Nine Minds agents on-demand. Ralph persistent loop with state persistence. The boulder never stops.
G:ralph ouroboros specification-first socratic interview seed evaluate evolve loop completion nine-minds double-diamond convergence drift boulder ooo multi-platform
U[7]:
1:Before writing any code — expose hidden assumptions via Socratic interview (Ambiguity≤0.2 required gate)
2:Vague requirements — crystallize into immutable YAML seed spec before any implementation
3:Long-running tasks requiring autonomous iteration until verification passes
4:Guaranteed completion — Ralph loop persists across session boundaries with state checkpointing
5:When stuck after repeated failures — Nine Minds lateral thinking personas break stagnation
6:Drift detection — measure how far execution deviates from original seed specification
7:Ontological convergence — evolutionary loop until consecutive generations ≥0.95 similar
S[10]{n,action,details}:
1:interview,Socratic interview,ooo interview "topic" → ask questions until Ambiguity≤0.2; Greenfield: Goal×40%+Constraint×30%+Success×30%; Brownfield adds Context×15%
2:seed,Crystallize spec,ooo seed → generate immutable YAML with goal/constraints/acceptance_criteria/ontology_schema; blocks at Ambiguity>0.2
3:run,Execute Double Diamond,ooo run [seed.yaml] → Discover→Define→Design→Deliver pipeline; uses seed from context if no path given
4:evaluate,3-stage verification,ooo evaluate <id> → Mechanical(free)→Semantic(standard)→Consensus(frontier); drift 0.0-0.15 excellent / 0.15-0.30 monitor / 0.30+ correct
5:evolve,Evolutionary loop,ooo evolve "topic" → Wonder→Reflect→Seed(Oₙ)→Execute→Evaluate until Similarity≥0.95 or 30 gens; --no-execute for ontology-only fast mode
6:ralph,Persistent loop,ooo ralph "task" → Execute(parallel)→Verify→Loop; saves .omc/state/ralph-ooo-state.json; resumes after interruption
7:unstuck,Lateral thinking,ooo unstuck [simplifier|hacker|contrarian|researcher|architect]; auto-select if no persona given
8:status,Drift check,ooo status [id] → measure Goal(50%)+Constraint(30%)+Ontology(20%) drift; warn at >0.3
9:setup,One-time setup,ooo setup → register MCP server globally; required for run/evaluate/evolve/status
10:cancel,Stop loop,/ouroboros:cancel (save checkpoint) or /ouroboros:cancel --force (clear all state); /ralph-ooo:cancel also works
R[9]:
1:Ambiguity≤0.2 is a hard gate — interview until the math says ready, not when you feel ready
2:The seed is immutable — never modify it after generation; all drift is measured against the original
3:Ontology convergence: Similarity=0.5×name_overlap+0.3×type_match+0.2×exact_match; threshold ≥0.95
4:Ralph state survives session resets in .omc/state/ralph-ooo-state.json — resume with "ooo ralph continue"
5:Each failure is data — verification_history drives next iteration strategy; do not give up under max_iterations
6:Completion promise syntax: <promise>DONE</promise> — default promise DONE; default max_iterations 10
7:4 stagnation signals: Similarity≥0.95 for 3 gens | Gen N≈Gen N-2 oscillation | 70% question overlap | hard cap 30 gens
8:Nine Minds loaded on-demand only — do not preload; match mind to situation (repeated failures→contrarian; no info→researcher; paralysis→hacker; structural→architect; too complex→simplifier)
9:Drift formula: Goal(50%)+Constraint(30%)+Ontology(20%); above 0.30 requires course correction before continuing
E[4]{desc,in,out}:
1:{Full ouroboros workflow from idea to verified delivery,ooo interview "build a REST API for todos" → ambiguity scored → ooo seed → YAML spec generated → ooo run → Double Diamond executes → ooo evaluate <id>,Socratic questions reduce Ambiguity from 0.82→0.16; seed YAML generated with 4 acceptance criteria; all 4 phases complete; 3-stage evaluation PASSED score 0.94}
2:{Ralph persistent loop until all tests pass,ooo ralph "fix all failing tests in the auth module" --max-iterations=10,Iteration 1 FAILED(0.65) 3 tests failing → Iteration 2 FAILED(0.85) 1 test failing → Iteration 3 PASSED(1.0); Ralph-OOO COMPLETE in 9m12s; state checkpointed at each step}
3:{Evolutionary ontology convergence,ooo evolve "design a notification system",Gen1 {Notification Event Channel} sim=N/A → Gen2 {Notification Event Channel Recipient Priority} sim=0.72 CONTINUE → Gen3 same sim=1.00 CONVERGED; ontology stabilized; Ralph stops}
4:{Breaking stagnation with unstuck personas,ooo unstuck contrarian (after 3 identical failures on DB schema),Contrarian challenges: "What if we don't need a relational schema at all?" → Reveals root assumption; new approach: event-sourced log → unblocked}