/ultragoal

name: ulw-loop
description: Goal-like loop that uses ultrawork mode to decompose work into systematic, evidence-bound steps.
metadata:
  short-description: Goal-like ultrawork loop for systematic decomposition

Role

Expert goal orchestration agent. Plan multi-goal work that survives across turns and sessions. Use GPT-5.x style: outcome-first, evidence-bound, atomic decisions, no nested branching prose.

Goal

Deliver every goal in `.omo/ultragoal/goals.json` end-to-end. Prove EVERY success criterion with captured observable evidence from a real-usage scenario you actually ran (HTTP call / tmux / browser use / computer use — see the Manual-QA channels below). TESTS ALONE NEVER PROVE DONE. A green test suite is supporting evidence, not completion proof. Audit each pass, fail, block, steering change, and checkpoint in `.omo/ultragoal/ledger.jsonl`.

Manual-QA channels (PICK ONE PER CRITERION — ACTUALLY RUN IT)

For every criterion, build a real-usage scenario through ONE of these four channels and run it yourself before recording PASS. The full test suite being green is NEVER verification on its own.

1. **HTTP call** — hit the live endpoint with `curl -i` (or a Playwright APIRequestContext); capture status line + headers + body. 2. **tmux** — `tmux new-session -d -s ulw-qa-<criterion>`, drive with `send-keys`, dump via `tmux capture-pane -pS -E -`; transcript is the artifact. 3. **Browser use** — drive the real page via Playwright / puppeteer / Chromium; capture action log + screenshot path. 4. **Computer use** — OS-level GUI automation (computer-use agent, AppleScript, xdotool, etc.) against the running app; capture action log + screenshot.

Auxiliary surfaces (pure CLI stdout / DB state diff / parsed config dump) satisfy CLI- or data-shaped criteria but NEVER replace a channel scenario for user-facing behavior. `--dry-run`, printing the command, "should respond", and "looks correct" never count.

Artifacts

• `.omo/ultragoal/brief.md`: original brief and durable constraints.
• `.omo/ultragoal/goals.json`: goals with embedded `successCriteria` per goal.
• `.omo/ultragoal/ledger.jsonl`: append-only audit trail.
• Read artifacts before resuming, steering, or checkpointing.
• Never invent state outside `.omo/ultragoal` artifacts or `omo ultragoal status --json`.

Bootstrap

Do all three steps before execution. No edits, goal tools, or checkpointing before bootstrap completes.

1. Create goals from the brief

Resolve the CLI before the first command. If `omo` is absent from PATH, use the stable local installer bin or cached Codex component CLI. This is the same ultragoal CLI, so PATH absence is not a blocker. If PATH is empty, the fallback uses shell builtins and absolute Node locations before reporting guidance, and records the failure in `.omo/ultragoal/bootstrap-notepad.md`.

if command -v omo >/dev/null 2>&1; then
  ULTRAGOAL_CLI=omo
else
  CODEX_HOME="${CODEX_HOME:-$HOME/.codex}"
  ULTRAGOAL_CLI=
  if [ -f "$CODEX_HOME/bin/omo" ] || [ -x "$CODEX_HOME/bin/omo" ]; then
    ULTRAGOAL_CLI="$CODEX_HOME/bin/omo"
  else
    for candidate in "$CODEX_HOME"/plugins/cache/sisyphuslabs/omo/*/components/ultragoal/dist/cli.js; do
      [ -f "$candidate" ] || continue
      ULTRAGOAL_CLI="$candidate"
    done
  fi

  ULTRAGOAL_NODE="$(command -v node 2>/dev/null || true)"
  if [ -z "$ULTRAGOAL_NODE" ]; then
    for candidate in /opt/homebrew/bin/node /usr/local/bin/node /usr/bin/node; do
      [ -x "$candidate" ] || continue
      ULTRAGOAL_NODE="$candidate"
      break
    done
  fi

  if [ -n "$ULTRAGOAL_CLI" ] && [ -n "$ULTRAGOAL_NODE" ]; then
    omo() { "$ULTRAGOAL_NODE" "$ULTRAGOAL_CLI" "$@"; }
  fi
fi

if [ -z "${ULTRAGOAL_CLI:-}" ]; then
  /bin/mkdir -p .omo/ultragoal 2>/dev/null || mkdir -p .omo/ultragoal 2>/dev/null || true
  NOTE="${NOTE:-.omo/ultragoal/bootstrap-notepad.md}"
  printf '%s\n' "omo executable missing from PATH; cached ultragoal CLI not found under ${CODEX_HOME:-$HOME/.codex}." >> "$NOTE" 2>/dev/null || true
  printf '%s\n' "Install with bunx omo install --platform=codex or set CODEX_LOCAL_BIN_DIR to a PATH directory." >&2
fi

If `ULTRAGOAL_CLI` is empty, open the durable notepad first, record the missing CLI evidence, then surface the installer issue.

Run one form:

omo ultragoal create-goals --brief "<brief>" --json
omo ultragoal create-goals --brief-file <path> --json
cat <brief> | omo ultragoal create-goals --from-stdin --json

Write state through the CLI path. Do not hand-edit state files.

2. Refine success criteria per goal

Define pass/fail acceptance criteria before launching execution lanes. Include the command, artifact, or manual check that will prove success. Each goal MUST carry 3+ `successCriteria` covering happy path, edge, regression, and adversarial risk. For each criterion set: `id`, `scenario`, `expectedEvidence`, adversarial classes, stop condition, and the Manual-QA channel (HTTP call / tmux / browser use / computer use) that will exercise it. Apply ultraqa classes where relevant: malformed input, repeated interruptions, prompt injection, cancel/resume, stale state, dirty worktree, hung or long commands, flaky tests, misleading success output. Use evidence verbs from the channel table (tmux transcript, curl status+body, browser screenshot, computer-use action log, CLI stdout, DB diff, parsed config dump) — not vibes. "Tests pass" is supporting signal, NEVER completion proof. Every criterion needs its own channel scenario, built fresh and exercised every time. Record manual QA notes when behavior is user-visible. Revise any criterion that lacks observable `expectedEvidence` or a named channel before execution.

3. Inspect state

Run `omo ultragoal status --json`. Read pending goals, criteria IDs, current ledger head, blockers, and aggregate Codex objective.

Execution Loop

Loop per goal. Cap at 5 cycles per goal. Cap identical same-criterion failures at 3.

Acquire Next Goal

1. Run `omo ultragoal complete-