cskwork/supergoal-skill / skills/supergoal
supergoal
UnverifiedRoute objective-driven development, verification, planning, "teach/explain", codebase learning, and skill evaluation through the Supergoal workflow. Use when Supergoal is requested or an autonomous delivery workflow is needed.
reference/role-loop.md
View on GitHub# ROLE-LOOP - the default loop for GREENFIELD / DEBUG / LEGACY
Use when the user invokes `supergoal` for GREENFIELD / DEBUG / LEGACY feature, bug, or refactor
work. Once invoked, use this loop; do not downgrade to an inline shortcut. Workflow weight is
tiered: select LIGHT / STANDARD / DEEP once at Frame (`## Tier selection - LIGHT / STANDARD / DEEP`).
The mandatory core is Frame -> Plan approval -> Build -> Exact Verify/QA -> Finalize: five gates,
fresh context per role. Default cost envelope: one builder + one auditor verifier per iteration;
browser/CLI proof adds one evidence-only qa-tester before the auditor. The tester is a required proof
dispatch, not escalation. Any optional dispatch needs a named escalation trigger recorded in
`run-state.json` (see `## Escalation (conditional plan attack; optional)`). Frame owns discovery and
enumerates full-spec and edge-case coverage into the plan the user approves; the builder implements
only the approved plan and must cover every planned criterion. The tester exercises browser/CLI
behavior and returns evidence only. The auditor runs with an adversarial stance, compares the
request/docs with current behavior, reruns REAL proof, and owns the verdict, GOAL ticks, and R-LOOP. Exact
verification outranks reviewer approval. There are no standing critic or fixer roles: the auditor
finds gaps, and the relaunched builder fixes them through `R-LOOP.md` - that loop-back is the only fix
channel. Every gate exits with the app fully functional: Build returns only on a green suite, Exact
Verify/QA proves it, Finalize commits it.
The conditional plan attack is optional gated escalation, never the default. Use it when the task is
under-specified, latent-correctness-heavy, or security/edge/domain-rule-sensitive. Do not use it when
the spec is explicit, behavior is already stated, the harness is single-process/context-limited, or the
eval compares equal-compute vanilla. Production/domain behavior-changing ambiguity needs user feedback.
Generic no-user coding ambiguity uses the most conservative, reversible default and records the choice.
## Tier selection - LIGHT / STANDARD / DEEP
Select once at Frame, announce tier + reason
in one line next to the mode line, and record it (`run-state.json` `tier` for STANDARD/DEEP; the
in-context checklist for LIGHT). A user word overrides detection: "quick"/"light" -> LIGHT,
"thorough"/"deep" -> DEEP.
**LIGHT** - explicit spec AND narrow blast radius: the request names the behavior and its target
files/symbols, no production/domain ambiguity, no migration/security/concurrency surface. Keep the
SAME five gates but hold their state in context instead of files:
- keep the run worktree for code edits in a persistent workspace; an ephemeral workspace (below)
works on the current checkout directly, committing only if asked;
- no vault files and no changelog directories: keep goal, plan, success criteria, QA state,
completion promise + iteration cap, and the regression ledger as one in-context checklist;
- plan approval: present the one-screen goal/plan summary in the message and proceed without
waiting; record `auto-approved (LIGHT)` in the checklist. The user's approval point moves to
acceptance-before-merge; the interactive WAIT rule in `## Run setup` applies to STANDARD/DEEP only;
- no role fan-out: the conductor frames, builds, and verifies in one context, running the builder and
auditor stances as separate passes; auditor-pass findings become checklist items fixed in the next
in-context pass (LIGHT's R-LOOP);
- skip the interview (`reference/interview.md` tier scaling): state assumptions inline and proceed;
- run the full suite ONCE at Exact Verify (targeted tests while building); evidence is that one green
run plus the final diff reconciliation - do not repeat `git status`/`git diff --check` sweeps;
- skip `qa-gate.sh` and board emits; skip rules-file discovery only in an ephemeral workspace;
- LIGHT commit bar (replaces `commit-gate.sh`): full-suite green + diff reconciliation + user
acceptance, then commit/merge into the verified target branch.
**STANDARD** (default when LIGHT conditions do not all hold) - the full five-gate protocol below,
fresh context per role.
**DEEP** - STANDARD plus the conditional plan attack (`## Escalation (conditional plan attack;
optional)`), selected up front when its triggers are already visible at Frame: under-specified,
wide-blast-radius, security/data/concurrency, or latent-correctness-heavy work - or the user asks
for it ("thorough"/"deep" is itself a recordable trigger). Record the trigger as usual; DEEP also
unlocks the unlimited interview rounds in `reference/interview.md`.
**Upgrade is one-way: LIGHT -> STANDARD (-> DEEP).** Upgrade the moment any of these fires:
production/domain ambiguity surfaces, a stated load-bearing assumption proves wrong, the grounded
change reaches past its explicit target (blast radius), or the Build->Verify loop enters its second
red iteration (LIGHT's iteration cap). Procedure: record the trigger; transcribe the in-context
checklist into the vault (`GOAL.md` first; mark any `QA.md` `## Before` entry reconstructed from
context where the true before-state is gone); keep the in-flight diff (already in the run worktree;
an ephemeral run creates the worktree now and carries the diff onto it); then run the plan-approval
gate for the remaining work only. Never downgrade mid-run - `SKILL.md`'s no-inline-shortcut rule
applies to tiers too.
**Ephemeral workspace (auto-LIGHT).** Detect once at Frame: single-task container/CI/benchmark
checkout - no `.supergoal/`, no existing `docs/changelog/`, no other work in flight, no later reader
of run artifacts. LIGHT applies with the worktree also dropped.
Everything else still applies in every tier: plan before build, red-first for bugs, smallest correct
change, diff reconciliation, regression ledger re-runs, adversarial final verify. A persistent user
workspace on STANDARD/DEEP uses the full protocol below unchanged.
## DEBUG hidden-contract gate - a green repro is not done
A fix that only makes the reported repro pass is the top DEBUG failure mode. Before Exact Verify
ticks a DEBUG run green, the builder shows and the auditor independently re-checks all three. The
gate has a literal output contract: BEFORE committing, print exactly three lines -
`GATE.owner=<frame/function>`, `GATE.alt_repro=<description>: pass`,
`GATE.conformance=<returns audited and converted, or "none reachable">` - with the work behind each
actually done. A DEBUG commit without these three lines is not done. In a single-context run
(ephemeral or LIGHT) the roles collapse, but the gate does not:
1. **Invariant owner.** Name the invariant the bug violated and the function that owns it. For any
raised exception: capture the traceback once and walk it to the deepest frame that RAISES - the
owner is that frame (for a RecursionError, the repeating frame cycle, enumerated by name), often
in a different module than the API that surfaced the symptom; follow it across modules. A patch
that guards the caller/wrapper where the exception SURFACES instead of the frame that raises it
is a symptom fix, not done: refix at the owner, or record in `QA.md` (LIGHT: the checklist) why
the owner must not change.
2. **Alternative-entry repro.** Add one more repro reaching the same root cause through a
STRUCTURALLY different context - not the same call with another literal: the failing construct
embedded inside a function call / nested expression, or a sibling public API sharing the broken
path. Both repros must pass. If a second entry cannot exist, record why.
3. **Convention conformance (concrete action).** Grep every function the patch touches AND its
symmetric sibling methods (`__mul__`/`__truediv__`, add/sub, encode/decode, open/close) for raw
literal returns: `return 1`, `return 0`, `return -1`, `return True/False/None`, bare string
returns. For each hit, read how 2-3 sibling implementations in the same module return the
equivalent value; if they return canonical singletons/constants/types (`S.One` over raw `1`,
sympified values over Python literals) or follow an established output convention, convert the
hit in the same patch - INCLUDING pre-existing literals the diff merely moves, keeps, or
re-routes to, and siblings the diff does not touch. Sibling idiom is current-behavior grounding
(must-grade), not "silence turned into stricter semantics".
## Run setup - before any file mutation
LIGHT tier (see `## Tier selection`): skip this section's vault-file setup; keep the worktree unless
the workspace is ephemeral.
For any GREENFIELD / DEBUG / LEGACY code edit, first resolve the source/base branch and
target/integration branch. Prefer repo policy or user-provided refs; ask if either is ambiguous. Then
verify both refs exist and create a branch-scoped run worktree:
```bash
git worktree add -b <run_branch> <worktree_path> <source/base branch>
```
Run Build, Exact Verify/QA, any escalation passes, tests, and vault writes inside that worktree; never
edit the original checkout. Treat dirty original-checkout files as user work. Commit or merge only
into the verified target/integration branch after green verification, user acceptance, and only once the
commit gate passes (`reference/delivery-gate.md`; `bash templates/commit-gate.sh <vault> <browser|cli|none>`)
(STANDARD/DEEP; LIGHT commits per its own bar in `## Tier selection`).
Non-green blocks commit: resolve in-loop; escalate only when stuck.
Before any file mutation, create the run vault's `GOAL.md` from `templates/GOAL.md`, `PLAN.md` from
`templates/PLAN.md`, `QA.md` from `templates/QA.md`, and `run-state.json` from
`templates/run-state.json`, and start the Before/After Eval (`reference/delivery-gate.md`):
- `GOAL.md` is written FIRST: `## Original Request` quotes the user's prompt verbatim; `## Spec` refines
it into a detailed spec; `## Success Criteria` seeds falsifiable checkboxes, each naming its
verification method - full-spec coverage plus grounded edge-case and resilience criteria enumerated at
plan time, so the user reviews them at the plan approval gate instead of paying for separate improve
passes later; web apps also seed `## QA Cases` (agent-browser scenarios; playwright-cli fallback);
- **Full-spec discovery (Frame owns it, once)**: explore the actual code first (`agents/explore.md`,
`reference/plan-grounding.md`) - trace the touched paths, existing utilities, and data shapes - then
re-read the request/ticket, README, design/API docs, and repo/data rules; turn what they require -
including edge-case and resilience behavior - into Success Criteria and plan steps grounded in
observed code, not guesses. Discovery happens here, not in the builder;
- GREENFIELD scope gate: if the new app/tool request is broad, foggy, roadmap-shaped, or clearly
multi-session, keep the mode `GREENFIELD` and use `reference/wayfinder.md` inside this same run vault
before freezing `PLAN.md`; write `wayfinder/map.md`, write vertical tickets under
`wayfinder/tickets/`, name the first unblocked frontier ticket, and carry only that ticket's
acceptance checks into `GOAL.md` / `PLAN.md`; do not build sibling tickets in the same context;
- record eval intent in `PLAN.md` `## Intent`: user goal, constraints, tradeoffs, rejected approaches;
- record the completion promise in `PLAN.md` `## Intent`: promised outcome, required proof, stop
condition, and `max_iterations` (default 3). `PLAN.md` is canonical for the approved promise and cap;
`run-state.json` mirrors only `max_iterations` for loop resume;
- `PLAN.md` `## Steps` + `## Tools & Skills` must be self-sufficient: a fresh-context implementer reads
ONLY `PLAN.md` and builds it; copy the Success Criteria (including the edge-case and resilience
criteria) into `PLAN.md` `## Acceptance checklist` so the builder needs no other file;
- **Plan approval gate (blocking, unlike the interview's confirms):** after `PLAN.md` freezes and before
Build is dispatched — interactive session: present `PLAN.md` and WAIT for the user's explicit OK;
record it in `## Approval`. Autonomous run (harness-eval arm, scheduled/background, pre-authorized
autonomy): set `Status: auto-approved` with the reason, then proceed;
- record the before state in `QA.md` `## Before`: absent feature/red acceptance check for GREENFIELD,
reproduced symptom for DEBUG, preserve-baseline capture for LEGACY/brownfield, plus neighbor
characterization baseline for any shared code/state change;
- DEBUG first tries exact live reproduction. If exact reproduction is unavailable, preserve the
failure-triggering properties in synthetic/similar data and fill `QA.md` `## Reproduction Fidelity` with
fidelity level, data source, prod-vs-test deltas, residual risk, and post-deploy confirmation plan;
- record the after target and the command manifest (`QA.md` `## Commands`) from repo-owned or
evaluator-owned proof commands.
- keep `run-state.json` current as the compact mutable/resumable checkpoint: branch/ref safety, phase,
iteration, `max_iterations`, unresolved gates, blockers, `regression_ledger`, next action, forced
reflection, and timestamp. Approval remains in `PLAN.md`; proof commands remain in `QA.md`.
- **Vault language (one vault, one language)**: all vault prose - `GOAL.md`, `PLAN.md`, `QA.md`,
`R-LOOP.md`, `Z-*.md` - uses the language of the user's original request; a Korean `GOAL.md` means a
Korean `PLAN.md` too, and every later writer (builder rows, verifier results, R-LOOP items) keeps
that language. Structural markers stay verbatim as the templates define them (section headings,
`- [ ]` checkboxes, `Status:`/`Verdict:`/`Backward-trace: clean`/`auto-approved`/`(surfaced: ...)`
tokens) because gates grep for them; code identifiers, paths, and commands stay in their original
form.
## LEGACY entry (order)
1. Map first (`agents/explore.md`, `reference/domain-context.md`).
2. Existing API touched: capture its preserve-baseline (`reference/qa.md` "API behavior baseline").
3. Shared code/state changes: capture the neighbor characterization baseline (`reference/qa.md`).
4. Proceed with the default loop; the before state lands in `QA.md` `## Before` (`reference/delivery-gate.md`).
## Completion promise + loop cap
Frame writes the completion promise and `max_iterations` (`PLAN.md` `## Intent`) before Build. Loop only
while the promise is unproven and a fresh, actionable gap remains. `run-state.json` mirrors the approved
cap (default 3). Its initial `forced_reflection` is `null`. At
the cap, replace it with an object containing `what_keeps_failing`, `likely_root_cause`,
`unproven_requirement`, and `regressed_previously_green`; store the smallest next action in the existing
top-level `next_action`, then escalate to the user with that state instead of grinding. Each iteration
re-runs `regression_ledger`; if a previously green check turns red, stop, fix it, and record the result
in `forced_reflection.regressed_previously_green`. Ask only for requirement-level blockers or consent.
## Roles (each role = a fresh-context subagent by default)
Dispatch by default: conductor runs each role as a fresh-context subagent so heavy references load inside
that role, not the conductor. A user invoking `supergoal` for GREENFIELD, DEBUG, or LEGACY work is
explicit authorization to spawn the role-loop subagents described here. Do not ask a second "may I use
subagents?" question unless the user limited delegation, tooling is unavailable, or a normal
safety/permission gate requires consent. Return short structured status only:
changed files, proof output, concerns. Parallelize independent units; order dependent roles. Each dispatch's
model tier is the conductor's choice at dispatch time (stronger tier for novel/algorithmic slices).
Build and the `qa-auditor` Exact Verify/QA are mandatory dispatches. Browser/CLI work conditionally
requires `qa-tester` evidence before the auditor; the conditional plan attack below is trigger-gated.
1. **Build** (`agents/executor.md`) - before first edit, confirm blast-radius beyond the explicit target
(`reference/interview.md`). Implementation must run as a separate fresh-context builder subagent; the
conductor should not implement code inline. The builder is briefed by the approved `PLAN.md` alone
(on an R-LOOP re-entry, also the LATEST `R-LOOP.md` section); Build does not start before the plan
approval gate clears. Then smallest correct change; match surrounding style. Bug: failing test first.
For any shared code/state change, capture a neighbor characterization baseline FIRST
(`reference/qa.md` "Characterization baseline"). Refactor/integrate an existing API: capture its
exact-behavior baseline FIRST. Capture run setup in `QA.md` `## Before` and `run-state.json`.
- **R-LOOP re-entry**: for each listed item or surfaced criterion, reproduce it with a failing test
first, then fix with the smallest change - the criterion row is updated to name the failing test
that now covers it. If an item encodes an `ask-user` choice, contradicts current/API behavior, or
hardens semantics not required by request/docs or safety, stop and report the decision gate instead
of optimizing source to it.
- **Planned coverage** - implement every planned criterion from the plan's `## Acceptance
checklist`, including the edge-case and resilience criteria; the plan is the whole brief, so do
not re-read spec docs. If production/source-code domain ambiguity would change user-visible
behavior, data semantics, permissions, migrations, or API compatibility, stop and record an
`ask-user` decision gate; do not guess business meaning. Generic no-user coding utility/eval
fixture: choose the most conservative, reversible default and record it in `GOAL.md`
`## Decision Gates` (resolved). Add or adjust tests only for grounded `must` behavior.
- **Green exit** - run the local suite and return only on a green suite; the app is left fully
functional. Keep the diff minimal; no padding, rewrites, or unrelated cleanup.
- **Scope extension** - when the builder reports `scope-extension: <file:symbol>` (the smallest
correct change reached past the plan's blast-radius map), the conductor captures consumer coverage
for the new area (`reference/qa.md` "Characterization baseline") before Verify; a module/service
boundary crossing re-fires the blast-radius confirm (`reference/interview.md`).
2. **Exact Verify/QA vs ground truth (mandatory core; Final Verify/QA)** (`agents/qa-auditor.md` is
always the final verifier; `agents/qa-tester.md` supplies browser/CLI execution evidence first;
security uses `agents/security-reviewer.md` only when triggered)
- **Role routing:** browser/CLI path = fresh `qa-tester` produces evidence -> fresh `qa-auditor`
audits it, reruns REAL non-browser proof, and decides. Non-browser/artifact path = fresh
`qa-auditor` alone. Only the auditor writes the final `Verdict:`, ticks `GOAL.md`, or appends
`R-LOOP.md`; the tester writes observations and evidence only.
- Adversarial stance first: re-read the request/docs, `GOAL.md`, `PLAN.md`, `QA.md`, the current
diff, tests, and repo/data rules; try to disprove the change against required behavior, edge cases,
and execution evidence before ticking anything. The verifier does not edit source and does not
weaken tests; findings become R-LOOP fixes, `ask-user` decision gates, or residual risk. Reviewer
approval is not a substitute for exact proof.
- Surface hidden requirements while disproving: classify each candidate as `must`, `should`, or
`ask-user`. Only `must` requirements grounded in request/docs, current/API behavior, repo/data
rules, or platform safety become new criteria: APPEND each as an unchecked criterion to the run
vault's `GOAL.md` `## Success Criteria` (`docs/changelog/<YYYY-MM>/<DD-topic>/GOAL.md`; format in
`templates/GOAL.md`) - what request/docs imply, why it is required though the prompt never stated
it (`(surfaced: ...)` tag; unchecked box = open) - plus a matching `R-LOOP.md` item for the
relaunched builder to cover red-first. Do not turn silence into stricter semantics (for example
throwing on degenerate inputs) when multiple reasonable behaviors exist; record that as an
`ask-user` decision gate or residual risk instead.
- Re-run REAL tests and report output. Run the command/browser/API/E2E layer promised in
`PLAN.md` `## Intent`. If the user expected an actual E2E/live/API/browser run, run it; otherwise mark
that layer not proven with blocker/residual risk. Exact verification outranks reviewer approval.
- Diff the implementer's changes (git diff in the run worktree) against `GOAL.md`: tick each Success
Criterion / QA Case proven met (only the verifier ticks); untick a regressed previously-green
criterion with the regression evidence.
- Code-change scenarios use `reference/qa.md` "Scenario stencil (code changes)", including regression
scenarios and metamorphic relations when no exact oracle exists.
- Browser UI changes require `qa-tester` evidence from `reference/qa.md`: `Tool: agent-browser`
by default; playwright-cli is fallback-only with a recorded reason explaining why agent-browser
could not complete reliable QA,
fixed-route as-is/to-be captures, and passing `bash templates/qa-gate.sh <vault> browser`. The
auditor consumes the compressed tester summary and evidence paths; it does not drive the browser.
- Re-run every captured neighbor characterization baseline; unnamed drift is red. API refactor:
re-capture the same call and diff against the pre-refactor baseline; unintended drift is a red to
resolve.
- **Diff reconciliation** - the FINAL diff, not the plan, is the regression surface: enumerate the
modified symbols from the current diff; each must carry consumer coverage - a re-run REAL test, a
captured baseline, or a named residual-risk line. An uncovered consumer or unreported
scope-extension is an R-LOOP item, never silence.
- **Test-scope floor** - re-run at minimum the test scope owning each modified file plus every
`regression_ledger` baseline; running narrower than the floor must be named with its reason in
`QA.md`.
- Close `GOAL.md`: every Success Criterion checkbox is ticked with a verifying check, and
`Backward-trace: clean` in `QA.md` proves no diff hunk is orphan scope.
- Exact Verify for neighbor baselines and trace closure is fresh-context: self-review is not a
regression gate. Unchecked criteria, unresolved REVISE items, and stub/placeholder implementations
block done.
- Tick each surfaced criterion in `GOAL.md`, or leave it unchecked with why.
- Any criterion still unchecked: APPEND a timestamped section to the vault's `R-LOOP.md`
(`templates/R-LOOP.md`) - checklist of missing/broken items (criterion #, expected vs actual,
evidence path), regression note, smallest next fix - then the conductor relaunches the builder,
which reads `PLAN.md` plus the LATEST `R-LOOP.md` section. This R-LOOP loop-back is the only fix
channel, still capped by `max_iterations`.
- Update `QA.md`: `## Results` checklist sentences (succinct, plain language), `## Commands`, decision
gates, intentional drift, residual risk, `Verdict:`. Unresolved `ask-user` findings or missing
trusted commands block a final done claim and commit (`reference/delivery-gate.md` Commit gate).
- Every `GOAL.md` box checked: write `Z-<YYYY-MM-DD>.md` (`templates/Z-DONE.md`) with the run branch
and completion timestamp - never earlier.
- Update `run-state.json` as the final mutable checkpoint: `refs_verified: true`, `phase: Finalize`,
empty unresolved gates/blockers, iteration, `max_iterations`, regression state, next action, forced
reflection, and timestamp. The commit gate validates this final checkpoint.
## Escalation (conditional plan attack; optional)
**Adversarial plan attack (conditional, no src edits)** (`agents/code-reviewer.md`,
`agents/security-reviewer.md`) - only for under-specified, wide-blast-radius,
security/data/concurrency, or latent-correctness work; record the named escalation trigger with the
dispatch in `run-state.json` (`unresolved_gates` or `next_action`). No trigger, no extra dispatch.
Before Build, dispatch reviewers for security, scope, correctness, performance, and operability against
the frozen `PLAN.md`. Accept only findings grounded in request/docs, current code/data, or platform
rules; convert required risks into planned criteria, decision gates, or residual risk. It attacks the
plan BEFORE code exists - post-build disproof already belongs to the verifier, and post-verify gaps
already route through `R-LOOP.md`, so no other standalone pass exists.
Every invoked GREENFIELD / DEBUG / LEGACY run still requires red-green evidence, exact REAL tests/E2E
proof, and DB evidence for data-backed bugs (`reference/db-access.md`). DB proves data state; it does
not replace red-green.
Board (optional): if enabled (`reference/observability.md`), conductor may call `sg-emit --phase <P>` at
phase transitions (Frame/PlanApproval/Build/ExactVerify/Finalize; conditional PlanAttack; Done). Opt-in,
best-effort; observes only, never blocks or gates the loop.
## Guardrails (keep it baseline-first, not Goodhart)
- Generated tests are a SIGNAL to surface hidden requirements, not the oracle. Final verification is REAL
tests + request/docs. Never weaken/delete a real test; never declare done because self-written tests pass.
- Ambiguous edges are not REDs. If a production/domain behavior change has multiple reasonable meanings,
classify it as `ask-user` or residual risk; do not invent stricter semantics. If generic/no-user, choose
a conservative, reversible default and record it.
- Codebase idiom visible in sibling implementations is not ambiguity: conforming the changed surface to it
is required (DEBUG hidden-contract gate), and is grounding, not invention.
- Characterization baseline is a regression signal, not a correctness oracle. A known-bug snapshot changes
only when the bug fix is intentional and named.
- Self-review is not a regression gate: generated explanations can approve behavior drift. Require the
verifier's adversarial stance, execution evidence, exact verification, and no stub done claims.
- Exact verification outranks reviewer approval: no reviewer, summary, or self-grade can replace the
actual command/browser/API/E2E run promised for the task. Missing exact proof is `not_proven`, not done.
- Derive every generated test from request/docs, not from a guessed rubric; a wrong generated test the
builder optimizes to is the failure mode - keep them black-box and spec-anchored.
- Escalation is not free rigor: every optional dispatch beyond the selected proof path needs its named
trigger recorded; a run that escalates without one is ceremony, not safety.
- Stop condition: cap the Build->Verify loop at `max_iterations` (default 3) with forced reflection, then
hand the user the open reds and the smallest next action instead of grinding.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 471k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |