[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-83437":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":9,"language":10,"languages":9,"totalLinesOfCode":9,"stars":11,"forks":12,"watchers":13,"openIssues":14,"contributorsCount":15,"subscribersCount":15,"size":15,"stars1d":16,"stars7d":17,"stars30d":17,"stars90d":15,"forks30d":15,"starsTrendScore":18,"compositeScore":19,"rankGlobal":9,"rankLanguage":9,"license":20,"archived":21,"fork":21,"defaultBranch":22,"hasWiki":23,"hasPages":21,"topics":24,"createdAt":9,"pushedAt":9,"updatedAt":25,"readmeContent":26,"aiSummary":9,"trendingCount":15,"starSnapshotCount":15,"syncStatus":27,"lastSyncTime":28,"discoverSource":29},83437,"supergoal","robzilla1738\u002Fsupergoal","robzilla1738","Plan and autonomously build a software task end-to-end. One ready-to-paste \u002Fgoal, adaptive phase count, memory preload + writeback, 3-strike self-healing recovery. Works on Claude Code and Codex.",null,"Shell",327,21,123,1,0,5,204,79,84.03,"MIT License",false,"main",true,[],"2026-06-12 04:01:41","# Supergoal\n\nPlan deeply, then autonomously build until it's done.\n\n`\u002Fsupergoal \u003Cwhat you want>` recons your codebase, applies your saved preferences from memory, decomposes the work into the right number of phases for the task, gets one confirmation from you, then prints a **single ready-to-paste `\u002Fgoal` command**. Paste it once and the rest is autonomous: every phase runs sequentially with built-in retry, fix-spec recovery, and per-phase memory writeback until `SUPERGOAL_RUN_COMPLETE`.\n\nWorks on **Claude Code** and **Codex** (Codex CLI).\n\n## How it works (at a glance)\n\n```mermaid\nflowchart TD\n    Start([\"\u002Fsupergoal <your task>\"]) --> S0[\"Stage 0\u003Cbr\u002F>Load memory + detect tools\"]\n    S0 --> S1{Greenfield\u003Cbr\u002F>or brownfield?}\n    S1 -->|Greenfield| Q1[\"Stage 1\u003Cbr\u002F>walk full category checklist\u003Cbr\u002F>(platform, stack, design,\u003Cbr\u002F>integrations, scope, audience...)\"]\n    S1 -->|Brownfield| Q2[\"Stage 1\u003Cbr\u002F>0–2 questions\u003Cbr\u002F>(recon answers most)\"]\n    Q1 --> S2[\"Stage 2\u003Cbr\u002F>Recon (parallel)\"]\n    Q2 --> S2\n    S2 --> S3[\"Stage 3\u003Cbr\u002F>Risks + best practices\"]\n    S3 --> S4[\"Stage 4\u003Cbr\u002F>Decompose into N phases\u003Cbr\u002F>(adaptive — no fixed count)\"]\n    S4 --> S5[\"Stage 5\u003Cbr\u002F>Write ROADMAP, STATE,\u003Cbr\u002F>phase-N.md specs to disk\"]\n    S5 --> S6{\"Stage 6\u003Cbr\u002F>Self-critique +\u003Cbr\u002F>plan review +\u003Cbr\u002F>revision menu\"}\n    S6 -->|Revise| S4\n    S6 -->|Start now| S65{\"Stage 6.5\u003Cbr\u002F>Pre-flight\u003Cbr\u002F>smoke check\"}\n    S65 -->|Green| S7[\"Stage 7\u003Cbr\u002F>Print ready-to-paste \u002Fgoal\"]\n    S65 -->|Red| S6\n    S7 --> PASTE([\"You paste \u002Fgoal — once\"])\n    PASTE --> LOOP[\"Autonomous loop per phase:\u003Cbr\u002F>read spec → do work →\u003Cbr\u002F>SUPERGOAL_PHASE_VERIFY\u003Cbr\u002F>(includes cleanliness grep) →\u003Cbr\u002F>write memory → SUPERGOAL_PHASE_DONE\"]\n    LOOP --> CHECK{Failure?}\n    CHECK -->|None| NEXT{More phases?}\n    NEXT -->|Yes| LOOP\n    NEXT -->|No| AUDIT[\"FINAL AUDIT\u003Cbr\u002F>re-verify against ROADMAP\u003Cbr\u002F>re-run mandatory commands\u003Cbr\u002F>spot-check criteria\u003Cbr\u002F>+ check deliverables vs Baseline ref\u003Cbr\u002F>(full working tree)\"]\n    CHECK -->|1st| R1[\"Auto-retry\u003Cbr\u002F>with probe injected\"]\n    R1 --> LOOP\n    CHECK -->|2nd| R2[\"Write fix-spec,\u003Cbr\u002F>execute inline\"]\n    R2 --> LOOP\n    CHECK -->|3rd| HANDOFF([\"STOP — handoff with\u003Cbr\u002F>full probe history\"])\n    AUDIT --> AGAPS{Gaps?}\n    AGAPS -->|None| DONE([\"AUDIT_COMPLETE ✓\u003Cbr\u002F>+ coverage %\u003Cbr\u002F>SUPERGOAL_RUN_COMPLETE ✓\"])\n    AGAPS -->|Round 1 or 2| AFIX[\"Write audit-fix-N.md,\u003Cbr\u002F>execute inline\"]\n    AFIX --> AUDIT\n    AGAPS -->|Round 3| AHO([\"STOP — AUDIT_HANDOFF\u003Cbr\u002F>persistent gaps\"])\n\n    classDef human fill:#fef3c7,stroke:#d97706,color:#000\n    classDef done fill:#d1fae5,stroke:#059669,color:#000\n    classDef stop fill:#fee2e2,stroke:#dc2626,color:#000\n    classDef audit fill:#dbeafe,stroke:#2563eb,color:#000\n    class Start,PASTE human\n    class DONE done\n    class HANDOFF,AHO stop\n    class AUDIT,AFIX audit\n```\n\nYellow = the only steps you do. Blue = the final audit that re-checks against your original plan. Green = success terminal (audit clean). Red = blocker handoff. Everything else is autonomous.\n\n## How it's different\n\n```mermaid\nflowchart LR\n    subgraph Traditional[\"Traditional planning\"]\n        direction TB\n        A1[\"Ask for a plan\"] --> A2[\"Plan returned\"]\n        A2 --> A3[\"You execute step 1\"]\n        A3 --> A4[\"Re-prompt\"]\n        A4 --> A5[\"Execute step 2\"]\n        A5 --> A6[\"Re-prompt\"]\n        A6 --> A7[\"... every step ...\"]\n        A7 --> A8[\"Done — many turns\"]\n    end\n\n    subgraph Supergoal[\"With Supergoal\"]\n        direction TB\n        B1[\"\u002Fsupergoal <task>\"] --> B2[\"Plan + per-phase specs\u003Cbr\u002F>+ risks + memory hits\"]\n        B2 --> B3[\"Approve once\"]\n        B3 --> B4[\"Paste \u002Fgoal once\"]\n        B4 --> B5[\"Autonomous run\u003Cbr\u002F>self-heals failures\u003Cbr\u002F>writes memories\"]\n        B5 --> B6[\"Done\"]\n    end\n\n    classDef toil fill:#fee2e2,stroke:#dc2626,color:#000\n    classDef ease fill:#d1fae5,stroke:#059669,color:#000\n    class A3,A4,A5,A6,A7 toil\n    class B5 ease\n```\n\nTwo human touches total: one approval, one paste. The plan is **deeper** than a one-shot plan (recon, risk list, memory-informed phase shaping, validated specs) and the execution is **autonomous** instead of step-by-step babysitting.\n\n## Why one `\u002Fgoal` (not a chain)\n\n`\u002Fgoal` on both hosts takes a short **end-state condition** that an evaluator checks against the transcript after each turn — not a long task body. Supergoal leverages this directly: one `\u002Fgoal` covers the whole run; phase work lives in files the agent reads from disk. No char budget, no inter-session chain, no fragility.\n\nSlash commands only fire from user input, so Stage 7 is an honest one-paste handoff: the planner prepares the `\u002Fgoal` line, you paste it, the autonomous run starts. From there it drives itself to completion.\n\n## Install — Claude Code\n\nThree commands inside a Claude Code session:\n\n```text\n\u002Fplugin marketplace add https:\u002F\u002Fgithub.com\u002Frobzilla1738\u002Fsupergoal.git\n\u002Fplugin install supergoal@supergoal\n\u002Freload-plugins\n```\n\nThat's it. `\u002Fsupergoal` is available immediately. Plugin install was verified end-to-end against the live repo (installs as `supergoal@supergoal`, ~307 tokens always-on + ~10k on-invoke).\n\n> **Tip:** the `owner\u002Frepo` shorthand (`\u002Fplugin marketplace add robzilla1738\u002Fsupergoal`) also works **only if you have GitHub SSH keys configured**, since it defaults to `git@github.com:` cloning. If you hit \"SSH authentication failed\" or \"Permission denied (publickey)\", use the HTTPS URL form above instead.\n\nIf `\u002Fplugin install` errors with \"not found\", run `\u002Fplugin marketplace update supergoal` and try again.\n\n**Manual install** (if you'd rather skip the marketplace flow entirely):\n\n```bash\nmkdir -p ~\u002F.claude\u002Fskills\ngit clone https:\u002F\u002Fgithub.com\u002Frobzilla1738\u002Fsupergoal \u002Ftmp\u002Fsupergoal-clone\ncp -R \u002Ftmp\u002Fsupergoal-clone\u002Fskills\u002Fsupergoal ~\u002F.claude\u002Fskills\u002F\nrm -rf \u002Ftmp\u002Fsupergoal-clone\n```\n\nThen run `\u002Freload-plugins` (or restart Claude Code) and `\u002Fsupergoal` is available.\n\n## Install — Codex CLI\n\nCodex doesn't have a plugin marketplace, so the install is a manual clone-and-copy:\n\n```bash\nmkdir -p ~\u002F.codex\u002Fskills\ngit clone https:\u002F\u002Fgithub.com\u002Frobzilla1738\u002Fsupergoal \u002Ftmp\u002Fsupergoal-clone\ncp -R \u002Ftmp\u002Fsupergoal-clone\u002Fskills\u002Fsupergoal ~\u002F.codex\u002Fskills\u002F\nrm -rf \u002Ftmp\u002Fsupergoal-clone\n```\n\nRestart Codex and `\u002Fsupergoal` is available. To update later, re-run the clone-and-copy.\n\n## Use\n\n```text\n\u002Fsupergoal build me an Expo app that converts photos to ASCII art\n```\n\nWhat happens:\n\n1. **Stage 0 — Available context.** Detects your memory directory, preloads relevant feedback\u002Fuser\u002Fproject memories, senses which tools\u002FMCPs are available this session.\n2. **Stage 1 — Intake.** Greenfield (no codebase to scan): walks the full category checklist (platform, stack, design direction, integrations, scope, audience, perf, data model) in batches of up to 4 until every material gap is filled. Brownfield (existing repo): 0–2 questions for true gaps only — recon answers most.\n3. **Stage 2 — Recon.** Parallel codebase\u002Fenvironment scan.\n4. **Stage 3 — Deep think.** Identifies top-3 risks + dependencies. Uses Context7\u002FWebSearch if available (optional, not required).\n5. **Stage 4 — Decompose.** Phase count derived from the task — no fixed cap. Small change = 2 phases; full-stack greenfield = 8–12+.\n6. **Stage 5 — Write specs.** `ROADMAP.md` + `STATE.md` + one `phase-N.md` work spec per phase, all under the run's namespaced `.supergoal\u002F\u003Crun-id>\u002F` dir.\n7. **Stage 6 — Self-critique + plan review.** Before showing the summary, the planner runs **one** self-critique pass that flags vague criteria, mis-sliced phases, and weak dependencies — rewriting falsifiability issues in place so the user sees the post-critique version. Then it shows the plan with assumptions, risks, applied memories, and a concrete revision menu: **Start now \u002F Adjust assumption \u002F Tweak a phase \u002F Restructure phases.**\n8. **Stage 6.5 — Pre-flight smoke check.** Before the `\u002Fgoal` line is printed, the planner runs the deduplicated mandatory commands once. `PREFLIGHT_GREEN` → proceed to Stage 7. `PREFLIGHT_RED` → re-show Stage 6 with a \"Skip pre-flight, dispatch anyway\" option (for cases where the baseline being broken is exactly what phase 1 will fix). Catches \"we'd thrash 3-strike loops against a broken baseline\" before it happens.\n9. **Stage 7 — Hand off.** Captures `Baseline ref:` (the current `HEAD` sha) into `STATE.md` so the final audit can diff deliverables against the working tree. Prints a ready-to-paste `\u002Fgoal` line. You paste it once; the chain runs phases sequentially with 3-strike auto-retry → fix-spec → handoff, writing a memory at each phase boundary so future runs start smarter. Each `SUPERGOAL_PHASE_VERIFY` also includes a **cleanliness pass** — grep-based counts for debug prints, session TODOs, and dead imports added across this phase's **complete working-tree changes** (committed + staged + unstaged + untracked, via `repo-state.sh`), so uncommitted debug output is caught too (non-zero counts triggering 3-strike unless the spec sets `Cleanliness override:`).\n10. **Final audit (after the last phase, before `SUPERGOAL_RUN_COMPLETE`).** Re-reads the original ROADMAP, re-runs the deduplicated mandatory commands (build \u002F typecheck \u002F lint \u002F tests) once at the end to catch cross-phase regressions a per-phase VERIFY can miss, spot-checks every acceptance criterion, and **checks every declared deliverable against `Baseline ref` across the complete working tree** (committed, staged, unstaged, deleted, and untracked — not just commits) so an \"agent said done but didn't ship\" case becomes a gap even when the run never committed. On gaps it writes `audit-fix-\u003Cround>.md` and self-heals inline; up to 3 audit rounds before stopping. Only after `AUDIT_COMPLETE` does it print `SUPERGOAL_RUN_COMPLETE` — with an honest **audit coverage** line. If more than 30% of checks were `trust-prior-verify` (subjective UI\u002FUX criteria the audit can't re-run), `SUPERGOAL_RUN_COMPLETE` prepends a warning banner asking the user to eyeball before merging.\n\n## Self-healing failure recovery\n\nBuilt into every run:\n\n- **First failure** of any acceptance criterion → `FAILURE_PROBE` printed, probe injected as feedback, **auto-retry once**.\n- **Second failure** → `FAILURE_ESCALATE`, write a focused fix spec at `phase-N.fix.md`, execute inline.\n- **Third failure** → `FAILURE_HANDOFF`, mark state `BLOCKED`, stop. You take the wheel.\n\nFlaky envs, typos, and missed deps self-resolve. Only real blockers escalate.\n\n## Memory writeback\n\nEach phase ends with a \"non-obvious learnings\" check. If anything a future run on a similar task would benefit from was learned (an API quirk, a confirmed user preference, a project-level fact, a failure-and-fix pattern), it's saved to your memory directory using the standard `name`\u002F`description`\u002F`metadata.type` frontmatter. The final phase always writes a `project_\u003Cslug>.md` memory pointing at the new\u002Fchanged project.\n\nThe memory directory is auto-detected from a cascade: `$HOME\u002F.claude\u002Fprojects\u002F-Users-$(whoami)\u002Fmemory`, `$HOME\u002F.claude\u002Fmemory`, `$PWD\u002F.claude\u002Fmemory`, `\u003Crun-root>\u002Fmemory`. The skill works with or without a memory directory; it just starts smarter when one is present.\n\n## Artifacts a run produces\n\nEach run gets its **own** namespaced subdirectory under `.supergoal\u002F` (e.g. `.supergoal\u002Fadd-dark-mode-Ab3Kx9\u002F`), claimed atomically at start, so two runs in the same working tree never overwrite each other:\n\n```\n.supergoal\u002F\n└── \u003Ctask-slug>-\u003Cid>\u002F         one isolated dir per run\n    ├── ROADMAP.md            full plan\n    ├── STATE.md              live progress (incl. Run root + Baseline ref), updated per phase\n    ├── THINKING.md           risks, dependencies, applied memories, best practices\n    ├── PROTOCOL.md           execution loop + failure recovery (copied at dispatch)\n    ├── repo-state.sh         complete working-tree-vs-baseline helper (copied at dispatch)\n    ├── context.md            recon output\n    ├── repo-map.md           brownfield only\n    ├── applied-memories.md   memory hits that informed the plan\n    ├── tools.md              detected MCPs \u002F skills \u002F hosts\n    └── phases\u002F\n        ├── phase-1.md\n        ├── phase-2.md\n        ├── ...\n        └── phase-N.md\n```\n\nTwo `\u002Fsupergoal` **planning** sessions can safely share a working tree — their artifacts are isolated. Running two `\u002Fgoal` **executions** in the same tree is still unsafe (they edit the same source files), so use a separate `git worktree` per task for true parallel builds.\n\n## Skill internals\n\n```\nskills\u002Fsupergoal\u002F\n├── SKILL.md\n├── references\u002F\n│   ├── planning-depth.md          what makes a plan deep enough to deserve \"Super\"\n│   ├── phase-design.md            how to slice phases (adaptive count, no cap)\n│   ├── goal-format.md             \u002Fgoal mechanics on CC + Codex, required transcript blocks\n│   └── repo-state-comparison.md   the one comparison strategy (working tree vs baseline)\n├── scripts\u002F\n│   ├── claim-run.sh           atomically claims a unique per-run dir (concurrent-run isolation)\n│   ├── detect-env.sh          greenfield env recon\n│   ├── detect-stack.sh        brownfield stack recon\n│   ├── summarize-repo.sh      repo map\n│   ├── repo-state.sh          complete working-tree-vs-baseline comparison (audit + cleanliness)\n│   └── validate-phase.sh      checks phase spec structure\n└── templates\u002F\n    ├── ROADMAP.md\n    ├── STATE.md\n    ├── phase-goal.txt         phase spec skeleton\n    └── PROTOCOL.md            execution loop + failure recovery\n```\n\n## Requirements\n\n- **Claude Code**: `\u002Fgoal` is a built-in command (no extra plugin). Available in current Claude Code releases. See [code.claude.com\u002Fdocs\u002Fen\u002Fgoal](https:\u002F\u002Fcode.claude.com\u002Fdocs\u002Fen\u002Fgoal).\n- **Codex CLI**: `\u002Fgoal` is a built-in slash command. See [developers.openai.com\u002Fcodex\u002Fcli\u002Fslash-commands](https:\u002F\u002Fdevelopers.openai.com\u002Fcodex\u002Fcli\u002Fslash-commands).\n\n## Version\n\nCurrent: **v0.7.0**. See [CHANGELOG.md](CHANGELOG.md) for release notes.\n\nMarketplace consumers can pin a specific version via the `\u002Fplugin` UI. Auto-updates are off by default for third-party marketplaces — enable per-marketplace via `\u002Fplugin` → **Marketplaces** if you want them.\n\n## License\n\nMIT. See [LICENSE](LICENSE).\n",2,"2026-06-11 04:11:09","CREATED_QUERY"]