@loneexile/omp-superpowers 6.4.2-omp.1

package/.pi/extensions/superpowers.ts

@@ -0,0 +1,123 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const EXTREMELY_IMPORTANT_MARKER = "<EXTREMELY_IMPORTANT>";
+const BOOTSTRAP_MARKER = "superpowers:using-superpowers bootstrap for pi";
+
+const extensionDir = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(extensionDir, "../..");
+const skillsDir = resolve(packageRoot, "skills");
+const bootstrapSkillPath = resolve(skillsDir, "using-superpowers", "SKILL.md");
+
+let cachedBootstrap: string | null | undefined;
+
+export default function superpowersPiExtension(pi: ExtensionAPI) {
+	let injectBootstrap = true;
+
+	pi.on("resources_discover", async () => ({
+		skillPaths: [skillsDir],
+	}));
+
+	pi.on("session_start", async () => {
+		injectBootstrap = true;
+	});
+
+	pi.on("session_compact", async () => {
+		injectBootstrap = true;
+	});
+
+	pi.on("agent_end", async () => {
+		injectBootstrap = false;
+	});
+
+	pi.on("context", async (event) => {
+		if (!injectBootstrap) return;
+		if (event.messages.some(messageContainsBootstrap)) return;
+
+		const bootstrap = getBootstrapContent();
+		if (!bootstrap) return;
+
+		const bootstrapMessage = {
+			role: "user" as const,
+			content: [{ type: "text" as const, text: bootstrap }],
+			timestamp: Date.now(),
+		};
+
+		const insertAt = firstNonCompactionSummaryIndex(event.messages);
+		return {
+			messages: [
+				...event.messages.slice(0, insertAt),
+				bootstrapMessage,
+				...event.messages.slice(insertAt),
+			],
+		};
+	});
+}
+
+function getBootstrapContent(): string | null {
+	if (cachedBootstrap !== undefined) return cachedBootstrap;
+
+	try {
+		const skillContent = readFileSync(bootstrapSkillPath, "utf8");
+		const body = stripFrontmatter(skillContent);
+		cachedBootstrap = `${EXTREMELY_IMPORTANT_MARKER}
+${BOOTSTRAP_MARKER}
+
+You have superpowers.
+
+The using-superpowers skill content is included below and is already loaded for this Pi session. Follow it now. Do not try to load using-superpowers again.
+
+${body}
+
+${piToolMapping()}
+</EXTREMELY_IMPORTANT>`;
+		return cachedBootstrap;
+	} catch {
+		cachedBootstrap = null;
+		return null;
+	}
+}
+
+function stripFrontmatter(content: string): string {
+	const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
+	return (match ? match[1] : content).trim();
+}
+
+function piToolMapping(): string {
+	return `## omp tool mapping
+
+This harness is omp (Oh My Pi). It has native skills but does not expose Claude Code's \`Skill\` tool. When a Superpowers instruction says to invoke a skill, read it with \`read skill://<name>\` when the skill applies, or let a human invoke \`/skill:name\` explicitly.
+
+omp's built-in coding tools are lowercase: \`read\`, \`write\`, \`edit\`, \`bash\`, \`grep\`, \`glob\`. Use \`read\` for a file OR a directory listing, \`grep\` for file contents, and \`glob\` for finding paths by name. omp's own system prompt directs you to prefer these over shell \`ls\`, \`find\`, \`grep\`, and \`rg\`; follow that preference.
+
+omp ships a built-in subagent tool: \`task\`. Use it for all Superpowers subagent workflows. Batch shape: ONE call carries \`{ context, tasks[] }\` — one subagent per item, run concurrently. Dispatch N parallel subagents as N entries in a single \`task\` call, never N sequential calls. Pick the most specific agent type per item from the roster in the \`task\` tool's own description (typically \`scout\` for read-only research, \`reviewer\`, \`security-reviewer\`, \`sonic\` for strictly mechanical work, and \`task\` for general-purpose). The tool is lowercase \`task\`; \`Task\` does not exist here. Never conclude that subagent capability is missing.
+
+The \`task\` tool has NO \`model:\` field — a template's \`model:\` line is inert; the agent TYPE carries the model, thinking level, and tools. For subagent-driven-development use this plugin's own agents: \`sdd-implementer\` (implementation, fix rounds 1-2), \`sdd-escalation-implementer\` (fix round 3, xhigh reasoning), \`sdd-reviewer\` (task review, no file writes, no shell), \`sdd-rereviewer\` (scoped re-review, low reasoning), \`sdd-final-reviewer\` (whole-branch review, xhigh reasoning). The bundled \`task\` agent resolves to \`modelRoles.task\`, whatever that is — never use it for an SDD seat.
+
+omp ships a built-in task-list tool: \`todo\` (\`init\`, \`start\`, \`done\`, \`rm\`, \`drop\`, \`block\`, \`unblock\`, \`append\`, \`view\`). Use it for all task tracking. Do not track work in plan files or a repo-local \`TODO.md\`. Treat older \`TodoWrite\` references as the \`todo\` tool.`;
+}
+
+function messageContainsBootstrap(message: unknown): boolean {
+	const content = (message as { content?: unknown }).content;
+	if (typeof content === "string") return content.includes(BOOTSTRAP_MARKER);
+	if (!Array.isArray(content)) return false;
+	return content.some((part) => {
+		return (
+			part &&
+			typeof part === "object" &&
+			(part as { type?: unknown }).type === "text" &&
+			typeof (part as { text?: unknown }).text === "string" &&
+			(part as { text: string }).text.includes(BOOTSTRAP_MARKER)
+		);
+	});
+}
+
+function firstNonCompactionSummaryIndex(messages: unknown[]): number {
+	let index = 0;
+	while ((messages[index] as { role?: unknown } | undefined)?.role === "compactionSummary") {
+		index += 1;
+	}
+	return index;
+}

package/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+Releases of [`@loneexile/omp-superpowers`](https://www.npmjs.com/package/@loneexile/omp-superpowers), the omp (Oh My Pi) adaptation of [obra/superpowers](https://github.com/obra/superpowers).
+
+A version is `<upstream version>-omp.<n>`: the upstream release this fork is synced to, then the fork's own iteration on top of it. Upstream's changes are described in its [release notes](https://github.com/obra/superpowers/blob/main/RELEASE-NOTES.md); this file records what the fork adds or changes.
+
+## [Unreleased]
+
+## [6.4.2-omp.1] - 2026-10-02
+
+First release, synced to upstream [v6.4.2](https://github.com/obra/superpowers/blob/v6.4.2/RELEASE-NOTES.md).
+
+### Added
+
+- **omp tool mapping.** The bootstrap injected into every session, and `skills/using-superpowers/references/pi-tools.md`, describe omp's real `task` tool (batched subagents, no `model:` field) and `todo` tool instead of claiming the harness has neither.
+- **Five SDD agents** (`agents/sdd-*.md`): implementer, task reviewer, scoped re-reviewer, round-3 escalation implementer, and final whole-branch reviewer, each with its own model, thinking level, and tool set. Re-point any seat per host with `task.agentModelOverrides`.
+- **subagent-driven-development rewritten around them:** *Agent Selection* replaces *Model Selection*; a three-round fix loop whose third round goes to the escalation seat; a proven-trivial-fix route; structured reviewer results with a `package_gap` verdict; parallel implementer waves only when `task.isolation.enabled` is on.
+- **omp worktree steps** in `using-git-worktrees`: `/wt` for the user, `omp worktree add` for the agent.
+- **npm package.** `omp plugin install npm:@loneexile/omp-superpowers`. The package holds only what omp loads (the extension, `skills/`, `agents/`). GitHub Releases publish it through npm Trusted Publishing, with provenance.
+
+### Changed
+
+- **Synced with upstream v6.4.2** (from v6.3.0): the `diagnosing-superpowers` skill, inline `executing-plans` (Native execution), leaner `writing-plans` plans with a Review Focus section, per-plan ownership markers in `sdd-workspace`, range guards in `review-package`, and skill prose that invokes bundled scripts through `bash`.
+- The fork's rewritten subagent-driven-development text invokes its helper scripts through `bash` as well, so a package extractor that drops exec bits cannot break them.
+- `sdd-final-reviewer` carries upstream's new review rules from `code-reviewer.md`, the template it replaces in SDD's final review: the spec is a vision document (behavior it is silent on is graded by what a reasonable person expects), and a "Declined to judge" section that the controller rules on and ledgers like a plan conflict.
+
+[Unreleased]: https://github.com/LoneExile/omp-superpowers/compare/v6.4.2-omp.1...HEAD
+[6.4.2-omp.1]: https://github.com/LoneExile/omp-superpowers/releases/tag/v6.4.2-omp.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jesse Vincent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,187 @@
+# omp-superpowers
+
+[obra/superpowers](https://github.com/obra/superpowers) adapted for **omp (Oh My Pi)**.
+
+Upstream superpowers is a set of workflow skills (brainstorm → plan → implement via subagents → review → finish). It ships a Pi/omp compatibility layer that is wrong on omp: it tells the agent there is no subagent tool and no todo tool, and its *Model Selection* rules use a `model:` field the omp `task` tool does not have. Under those rules every subagent silently inherits the slowest configured model over the widest tool set — in a real 157-subagent session that was where most of the wall-clock went.
+
+This fork keeps the skills and fixes the omp side:
+
+- the always-injected tool mapping tells the truth about `task`, `todo`, `read`/`grep`/`glob`
+- **five omp agents** (`agents/sdd-*.md`) give every subagent-driven-development seat its own model, thinking level, and tool set
+- subagent-driven-development is rewritten around them: three-round fix loop, structured reviewer output, waves gated on isolation
+
+## Install
+
+```bash
+omp plugin install npm:@loneexile/omp-superpowers
+```
+
+Releases are versioned `<upstream version>-omp.<n>`: `6.4.2-omp.1` is upstream v6.4.2 plus this fork's first iteration on it. [CHANGELOG.md](CHANGELOG.md) lists each release. To move to another one, uninstall and install it pinned:
+
+```bash
+omp plugin uninstall @loneexile/omp-superpowers
+omp plugin install npm:@loneexile/omp-superpowers@<version>
+```
+
+Unreleased `main` installs from GitHub under the same plugin name, pinned to a commit: `omp plugin install github:LoneExile/omp-superpowers#<sha>`. Installs made before 6.4.2-omp.1 used the plugin name `superpowers`; run `omp plugin uninstall superpowers` before installing this package.
+
+Verify it loaded — the roster of your `task` tool should now include the five `sdd-*` agents:
+
+```bash
+omp -p --no-session --no-skills --model anthropic/claude-haiku-4-5 \
+  'List the agent type names your `task` tool offers, comma-separated, nothing else.'
+# scout, reviewer, security-reviewer, sonic, task, sdd-implementer, sdd-reviewer, sdd-rereviewer, sdd-escalation-implementer, sdd-final-reviewer
+```
+
+Agent definitions are read **per dispatch**, so a reinstall takes effect on the next `task` call in a running session. The injected tool mapping and the skill catalog are read at process start — restart omp after upgrading to pick those up.
+
+## Using it
+
+The skills drive themselves once loaded. The usual path:
+
+1. `read skill://brainstorming` — turn an idea into a design
+2. `read skill://writing-plans` — produce `docs/superpowers/plans/<date>-<name>.md`
+3. `read skill://subagent-driven-development` — execute the plan task by task via subagents
+4. `read skill://finishing-a-development-branch` — merge / PR / discard
+
+On omp the agent invokes a skill by reading it (`read skill://<name>`); you can also invoke one explicitly with `/skill:<name>`.
+
+### What subagent-driven-development does per task
+
+```mermaid
+flowchart TD
+    B["task-brief: one task's text from the plan"] --> I
+    I["sdd-implementer: TDD, commit, report file"] --> P["review-package: git diff -U10 to a file"]
+    P --> R["sdd-reviewer: spec + quality, structured result"]
+    R -->|"approved"| D["ledger: Task N complete"]
+    R -->|"Critical or Important findings"| F
+    F["fix round 1 or 2: resume sdd-implementer"] --> RR["sdd-rereviewer: verdict per finding"]
+    RR -->|"all addressed"| D
+    RR -->|"still open, round 3"| E["sdd-escalation-implementer: xhigh reasoning"]
+    E --> RR
+    RR -->|"still open after round 3"| A["controller adjudicates and parks with a ruling"]
+    A --> D
+    D --> N{"more tasks?"}
+    N -->|"yes"| B
+    N -->|"no"| W["sdd-final-reviewer: whole-branch, once per plan"]
+    W --> X["finishing-a-development-branch"]
+
+    classDef seat fill:#1e3a8a,stroke:#3b82f6,color:#dbeafe
+    class I,R,RR,E,W seat
+```
+
+Blue nodes are the five omp agents this fork ships. A reviewer that cannot read its package yields the `package_gap` verdict value (with what it tried) instead of inventing one, and the controller regenerates and re-dispatches.
+
+### The SDD seats
+
+| Seat | agent | shipped default · thinking | tools |
+|---|---|---|---|
+| implementer (every task, fix rounds 1–2) | `sdd-implementer` | sonnet-5 · medium | read, write, edit, bash, grep, glob, lsp, ast_grep |
+| task reviewer | `sdd-reviewer` | sonnet-5 · high | read, grep, glob |
+| scoped re-review | `sdd-rereviewer` | sonnet-5 · low | read, grep |
+| fix round 3 / ruled strongest-tier task | `sdd-escalation-implementer` | opus-5 · xhigh | same as implementer |
+| final whole-branch review | `sdd-final-reviewer` | opus-5 · xhigh | read, grep, glob, bash, lsp, ast_grep |
+
+The shipped defaults are Anthropic: sonnet for the seats that run on every task, opus for the two that run once per plan or once per stuck task. The tiers are a **thinking ladder** as much as a model ladder — re-reviews reason at `low`, escalation and the final review at `xhigh`.
+
+The two reviewer seats have no `bash`, `edit`, or filesystem `write`: the review package (`git diff -U10` written to a file) is their whole view of the change, and they return a structured result (`spec_compliance`, `task_quality`, `findings[]`, `cannot_verify[]`; `finding_verdicts[]`, `new_breakage[]`, `round_verdict`) plus `package_gap` when they could not read the package. Note the honest boundary: omp always attaches `hub` to subagents, and `hub start` can launch a process, so "no shell" means *cannot edit the tree and cannot run a shell*, not a sandbox.
+
+### Changing models — no file edits
+
+omp resolves each seat's model and thinking level in a fixed order. The override map is the layer meant for you:
+
+```mermaid
+flowchart LR
+    subgraph model["model"]
+        M1["task.agentModelOverrides"] -->|"unset"| M2["agent file model:"]
+    end
+    subgraph level["thinking level"]
+        L1["explicit :level on the winning model string"] -->|"none"| L2["agent file thinkingLevel:"]
+        L2 -->|"none"| L3["model default"]
+    end
+    model --> level
+
+    classDef you fill:#1e3a8a,stroke:#3b82f6,color:#dbeafe
+    class M1 you
+```
+
+Set the override in `~/.omp/agent/config.yml`, or interactively with `/agents` in any session (it edits the same map). It applies on the next dispatch; delete a line to fall back to the agent file.
+
+This is how the fork's own author runs it — every seat on a flat-rate model, mapped onto that model's own thinking ladder:
+
+```yaml
+task:
+  agentModelOverrides:
+    sdd-implementer: opencode-go/deepseek-v4.1-flash:high
+    sdd-reviewer: opencode-go/deepseek-v4.1-flash:high
+    sdd-rereviewer: opencode-go/deepseek-v4.1-flash:low
+    sdd-escalation-implementer: opencode-go/deepseek-v4.1-flash:max
+    sdd-final-reviewer: opencode-go/deepseek-v4.1-flash:max
+```
+
+**Use the exact catalog id and a level the model actually offers.** `omp models ls <provider>` shows each model's ladder. A level that is not on it is silently clamped to the nearest valid one — `deepseek-v4.1-flash` offers only `low, high, max`, so `:medium` would run at `low` and `:xhigh` at `high`, collapsing the ladder without any error. Check `session_init.resolvedModel` in a subagent transcript if in doubt: it shows the level that actually ran. Catalog ids also get renamed (this one was `deepseek-flash` a day earlier, and the old string now matches an empty placeholder row).
+
+Measured on a real fix-round re-review with identical inputs: a grok-4.6 seat took 9.7 min / 4 turns, sonnet-5 about 50 s / 1 turn, the DeepSeek flash seat 100 s / 4 turns — same verdict, full structured result, all three.
+
+Rules that are easy to get wrong:
+
+- A **bare model** (`anthropic/claude-haiku-4-5`) keeps the agent file's own `thinkingLevel`. Add `:level` (`…:high`) to change reasoning too.
+- **Delete a line** to fall back to the agent file's default for that seat. Overrides apply on the next dispatch — no restart.
+- The `task` tool has **no `model:` field**. Never dispatch the bundled `task` or `reviewer` agent for an SDD seat — they resolve to `modelRoles.task` / `@slow`, which on many hosts is a cheap model.
+- `effort` on a dispatch (when `task.enableEffort` is on) accepts only `"lo"`, `"med"`, `"hi"`.
+- Discovery-only model ids (the OpenCode Go catalog, for example) accept `:level` in config and in overrides but not on the `--model` CLI flag.
+
+### Optional settings that matter
+
+| setting | why |
+|---|---|
+| `task.isolation.enabled` (+ `isolation.backend`, default `auto`) | off by default; SDD only runs implementers in **parallel waves** when it is on — otherwise they share one checkout and stay serial. Older omp builds spelled this `task.isolation.mode`; check `omp config get task.isolation.enabled` on your build |
+| `task.enableEffort` | exposes per-dispatch `effort` for the round-3 escalation |
+| `autolearn.autoContinue` | omp's auto-learn mints managed skills every session; the whole catalog is injected into every subagent's prompt. Keep it pruned or off — a 2,500-skill catalog was ~220k tokens per subagent turn |
+
+## What changed from upstream
+
+- `.pi/extensions/superpowers.ts` — the injected mapping names `task`, `todo`, the `sdd-*` roster, and the no-`model:`-field rule
+- `skills/using-superpowers/references/pi-tools.md` — same, as the reference doc
+- `agents/sdd-*.md` — new. `sdd-final-reviewer` also carries the review rules upstream keeps in `requesting-code-review/code-reviewer.md` (the spec is a vision document; a "Declined to judge" list), because it replaces that template in SDD's final review
+- `skills/subagent-driven-development/` — *Model Selection* → *Agent Selection*; fix-loop cap 5 → 3 with a round-3 escalation seat; a proven-trivial-fix route that replaces a re-review with a one-command proof; waves keyed to the plan's pre-flight file/interface table and gated on isolation; templates show omp's real `{ context, tasks: [{ agent, task }] }` wire shape and the reviewers' structured fields
+- `skills/using-git-worktrees/` — additive omp section: `/wt` is the user's one-line answer to the consent question (moves the session, carries WIP); when the agent creates the worktree itself it uses `omp worktree add` under `~/.omp/wt/` (the only place `omp worktree list`/`clear` manage), knows that command leaves uncommitted changes behind, and asks for `/move <path>` because `cd` never moves the tools' cwd
+- `README.md` — this file: rewritten for omp (install, seats, overrides, maintenance); upstream's multi-harness README is gone
+- `tests/pi/test-pi-extension.mjs` — one assertion follows the renamed mapping heading; the package-name assertion is gone (`scripts/check-npm-package.sh` checks the published name)
+- `package.json` — the npm identity: `@loneexile/omp-superpowers`, `<upstream version>-omp.<n>` versions, a `files` allowlist (the extension, `skills/`, `agents/`), `publishConfig`, `omp`/`oh-my-pi` keywords; `main` is dropped, since it pointed at the OpenCode plugin this package does not ship
+- `CHANGELOG.md`, `.github/workflows/` (CI, npm release), `scripts/check-npm-package.sh` — new
+
+Everything else is upstream, unmodified.
+
+## Maintenance
+
+### Syncing with upstream
+
+```bash
+git fetch upstream --tags
+git rebase upstream/main
+git push --force-with-lease origin main
+```
+
+Expect conflicts in `skills/subagent-driven-development/`, `pi-tools.md`, `README.md`, and `package.json` whenever upstream touches them — this fork rewrites those files rather than appending to them (README.md is never a partial conflict). In `package.json` keep the fork's identity and set `version` to `<new upstream version>-omp.1`: CI's package check fails until the version's base matches the upstream version in `.claude-plugin/plugin.json`. `agents/`, the extension's mapping paragraph, and the omp blocks in `using-git-worktrees` are additive.
+
+A clean rebase is not the whole sync. Upstream's edits to text this fork replaced never reach the replacement, so read upstream's diff for those files and port what still applies. The v6.4.x sync needed two: `bash scripts/...` invocations in the SDD text, and `code-reviewer.md`'s new review rules, which here live in `agents/sdd-final-reviewer.md`.
+
+### Releasing
+
+1. Set `version` in `package.json`, move CHANGELOG.md's *Unreleased* entries under that version, commit, push, and wait for CI.
+2. Publish a GitHub release for the tag `v<version>`; the [release workflow](.github/workflows/release.yml) publishes it to npm through Trusted Publishing, with provenance:
+
+```bash
+v=$(node -p "require('./package.json').version")
+awk -v h="## [$v]" 'index($0, h) == 1 {f = 1; next} f && /^(## )?\[/ {exit} f' CHANGELOG.md > /tmp/notes.md
+gh release create "v$v" --target main --title "v$v" --notes-file /tmp/notes.md
+```
+
+### New omp versions
+
+Before trusting a new omp release, re-check the harness facts this fork depends on — against the **running binary**, not the npm source tree. `~/.bun/install/global/node_modules/@oh-my-pi/pi-coding-agent/src` routinely lags `omp --version` (a 17.4.2 tree sat beside an 18.1.17 binary while this README was written, and the isolation setting had been renamed in between). The live oracles are `omp config list --json` (every setting and its default), the `task` tool's own description in a session (agent roster, item fields), a `session_init.resolvedModel` line in a subagent transcript (what actually resolved), and `grep -a` on the binary for an exact string when you need to know whether a code path exists.
+
+## License
+
+MIT, inherited from upstream. Not affiliated with obra / Prime Radiant.

package/agents/sdd-escalation-implementer.md

@@ -0,0 +1,18 @@
+---
+name: sdd-escalation-implementer
+description: "Superpowers SDD round-3 escalation: a fresh implementer at xhigh reasoning for a task that survived two fix rounds. Same tools and contract as sdd-implementer."
+tools: read, write, edit, bash, grep, glob, lsp, ast_grep
+# thinkingLevel is the seat's reasoning tier; an explicit :level on the model
+# string (or on a task.agentModelOverrides entry) takes precedence over it.
+model: ["anthropic/claude-opus-5:xhigh"]
+thinkingLevel: xhigh
+---
+
+You take over one task from a Superpowers plan after a prior implementer attempted it and could not clear the review findings across two fix rounds. You own it now. Your dispatch names the brief (requirements, exact values verbatim), the report file (read it first — it records what was tried and what the reviewer rejected), and the open findings.
+
+<contract>
+- Start from the report: understand why the previous rounds did not converge before touching code. A loop that survives two resumes usually means the implementer could not see its own problem — look for the framing error, not just the diff.
+- Fix the open findings; re-run the covering tests (name them); append your fix report to the same report file; commit with Conventional Commits.
+- Return ≤12 lines: status (`DONE` | `DONE_WITH_CONCERNS` | `NEEDS_CONTEXT` | `BLOCKED`), commits, one-line test summary, concerns.
+- You do NOT dispatch subagents. Review arrives from the controller after your report.
+</contract>

package/agents/sdd-final-reviewer.md

@@ -0,0 +1,23 @@
+---
+name: sdd-final-reviewer
+description: "Superpowers SDD final whole-branch reviewer: integration seams across all tasks, adjudicates ledgered deferred-minors and parked rulings. xhigh reasoning — dispatched once per plan."
+tools: read, grep, glob, bash, lsp, ast_grep
+# thinkingLevel is the seat's reasoning tier; an explicit :level on the model
+# string (or on a task.agentModelOverrides entry) takes precedence over it.
+model: ["anthropic/claude-opus-5:xhigh"]
+thinkingLevel: xhigh
+---
+
+You review a whole branch once, after every task has passed its task-scoped review. Per-task reviews cannot see cross-file seams; you can. Your dispatch gives the merge-base..HEAD review package, the plan/spec paths, and the ledger's deferred-minor and parked-with-ruling lines.
+
+<method>
+- Read the package once. Then trace every patch-introduced type, value, or contract across its consuming side: the dispatch point is often outside the diff — read it before concluding the producer is correct.
+- Bash is read-only: `git log`, `git show`, `git diff`, running a focused test. Never edit, never run the whole suite.
+- The spec is a vision document: it says what the software must do, not every input, environment, or condition it will meet. Where it is silent, a reasonable person's expectation is the requirement — the spec's silence is not permission. Grade such findings by their effect on that person, not by whether the spec mentions the trigger.
+- Triage the ledger lines: which deferred minors must be fixed before merge, which parked rulings you overturn — say why in one line each.
+- You do not dispatch subagents.
+</method>
+
+<output>
+Begin with the verdict. Findings carry file:line, severity (Critical / Important / Minor), trigger, impact, and a concrete fix. Then a `### Ledger triage` section: each deferred/parked line → fix-before-merge | accept, with reason. Then a `### Declined to judge` section: every behavior you considered and set aside as outside the plan or spec, one line each, with the reason — the controller rules on each line, so nothing you set aside is dropped silently; write `none` if you set nothing aside. Finish with **Mergeable:** yes | no.
+</output>

package/agents/sdd-implementer.md

@@ -0,0 +1,23 @@
+---
+name: sdd-implementer
+description: "Superpowers SDD implementer: executes ONE task brief (TDD, commit, report file). sonnet-5 at medium reasoning by default; override per host with task.agentModelOverrides."
+tools: read, write, edit, bash, grep, glob, lsp, ast_grep
+# thinkingLevel is the seat's reasoning tier; an explicit :level on the model
+# string (or on a task.agentModelOverrides entry) takes precedence over it.
+model: ["anthropic/claude-sonnet-5:medium"]
+thinkingLevel: medium
+---
+
+You implement exactly one task from a Superpowers plan. Your dispatch names a brief file: read it first — it is your requirements, with the exact values to use verbatim. Read only the plan's `## Global Constraints` section if the dispatch points you at it; never the whole plan.
+
+<contract>
+- TDD: failing test → minimal code → green → refactor. Commit with Conventional Commits.
+- Write the full report to the report path in your dispatch. Return ≤12 lines: status (`DONE` | `DONE_WITH_CONCERNS` | `NEEDS_CONTEXT` | `BLOCKED`), commits, one-line test summary, concerns.
+- Self-review your diff once before reporting; fix what you find.
+- You do NOT dispatch subagents — no helpers, never a reviewer. Review arrives from the controller after your report.
+- Fix rounds: the controller resumes you with open findings. Fix, re-run the covering tests (name them), append the fix report to the same report file, return the short contract.
+</contract>
+
+<budget>
+Read the changed files' context once; do not re-read files you already hold. Run the focused test command, not the whole suite, unless the brief says otherwise. Every extra turn is wall-clock the controller waits on.
+</budget>

package/agents/sdd-rereviewer.md

@@ -0,0 +1,69 @@
+---
+name: sdd-rereviewer
+description: "Superpowers SDD scoped re-reviewer: verdicts each prior finding ADDRESSED / NOT ADDRESSED against the fix diff only. Low reasoning, 1M context; ≤4 tool calls."
+tools: read, grep
+# thinkingLevel is the seat's reasoning tier; an explicit :level on the model
+# string (or on a task.agentModelOverrides entry) takes precedence over it.
+model: ["anthropic/claude-sonnet-5:low"]
+thinkingLevel: low
+output:
+  properties:
+    round_verdict:
+      metadata:
+        description: "all_addressed = every finding ADDRESSED and no new Critical/Important breakage; findings_open otherwise; package_gap = the fix package could not be read (finding_verdicts empty, package_gap filled)"
+      enum: [all_addressed, findings_open, package_gap]
+    finding_verdicts:
+      metadata:
+        description: "One entry per finding under verification, in the order given"
+      elements:
+        properties:
+          finding:
+            metadata:
+              description: "The finding's one-liner as given in the dispatch"
+            type: string
+          status:
+            enum: [ADDRESSED, NOT_ADDRESSED]
+          evidence:
+            metadata:
+              description: "file:line evidence; 'attempted' is not addressed — the specific defect must no longer exist"
+            type: string
+  optionalProperties:
+    new_breakage:
+      metadata:
+        description: "Only breakage the fix diff itself introduced. Empty when clean."
+      elements:
+        properties:
+          severity:
+            enum: [Critical, Important, Minor]
+          location:
+            type: string
+          body:
+            type: string
+    out_of_scope:
+      metadata:
+        description: "Issues entirely outside the fix diff; non-blocking, ledgered by the controller"
+      elements:
+        type: string
+    package_gap:
+      metadata:
+        description: "The path you were given and the error you got. Set ONLY together with round_verdict = package_gap and an empty finding_verdicts. A gap is not a verdict on the fix — the controller regenerates the package and re-dispatches."
+      type: string
+---
+
+You re-review one fix round. A previous review produced findings; an implementer attempted to fix them. Verdict each finding and inspect the fix diff — nothing else. This is not a fresh review.
+
+<inputs>
+Dispatch gives: the findings list (verbatim), the brief path, the report path (fix reports are appended at the end), and the fix-range review package path.
+</inputs>
+
+<method>
+Read the package once, then the report's appended fix section. Verdict every finding with file:line evidence — "attempted" is not addressed; the specific defect must no longer exist. Flag only breakage the fix itself introduced. Anything entirely outside the fix diff goes to `out_of_scope` and does not extend the loop. You have no shell and do not dispatch subagents.
+</method>
+
+<budget>
+≤4 tool calls. If a verdict genuinely needs a fifth, take it and say why in that finding's evidence.
+</budget>
+
+<output>
+Yield the structured result: `finding_verdicts` in the dispatch's order, `new_breakage` only for defects the fix introduced, `out_of_scope` for the rest, `round_verdict` last. No prose outside the fields.
+</output>

package/agents/sdd-reviewer.md

@@ -0,0 +1,83 @@
+---
+name: sdd-reviewer
+description: "Superpowers SDD task reviewer: spec compliance + code quality for ONE task from its review package. No file writes, no shell — the diff file is the view of the change."
+tools: read, grep, glob
+# thinkingLevel is the seat's reasoning tier; an explicit :level on the model
+# string (or on a task.agentModelOverrides entry) takes precedence over it.
+model: ["anthropic/claude-sonnet-5:high"]
+thinkingLevel: high
+output:
+  properties:
+    spec_compliance:
+      metadata:
+        description: "compliant = every brief requirement present, nothing extra; issues = missing/extra/misunderstood found; package_gap = the diff package could not be read (set task_quality to package_gap too, fill package_gap)"
+      enum: [compliant, issues, package_gap]
+    task_quality:
+      metadata:
+        description: "approved | needs_fixes; package_gap when the diff package could not be read"
+      enum: [approved, needs_fixes, package_gap]
+    reasoning:
+      metadata:
+        description: "1-2 sentence technical assessment; on a package_gap, what you tried"
+      type: string
+  optionalProperties:
+    spec_issues:
+      metadata:
+        description: "Missing, extra, or misunderstood requirements with file:line"
+      elements:
+        type: string
+    cannot_verify:
+      metadata:
+        description: "Requirements that live in unchanged code or span tasks — what the controller must check itself"
+      elements:
+        type: string
+    strengths:
+      elements:
+        type: string
+    findings:
+      metadata:
+        description: "Code-quality findings. Important = cannot be trusted until fixed. Coverage-could-be-broader and polish are Minor."
+      elements:
+        properties:
+          severity:
+            enum: [Critical, Important, Minor]
+          location:
+            metadata:
+              description: "file:line"
+            type: string
+          body:
+            metadata:
+              description: "What's wrong, why it matters, how to fix"
+            type: string
+          plan_mandated:
+            metadata:
+              description: "true when the brief/plan explicitly mandates the defect — still a finding; the human decides"
+            type: boolean
+    package_gap:
+      metadata:
+        description: "The path you were given and the error you got. Set ONLY together with spec_compliance and task_quality both = package_gap. A gap is not a verdict on the code — the controller regenerates the package and re-dispatches."
+      type: string
+---
+
+You review one task's implementation as a task-scoped gate — first whether it matches its brief, then whether it is well-built. A broad whole-branch review happens separately; do not do it here.
+
+<inputs>
+Your dispatch gives three paths plus the binding global constraints: the task brief, the implementer's report (unverified claims), and the review package (commit list, stat, full diff with -U10 context). Read the package ONCE; its context lines are the changed files. Read a changed file separately only when a hunk you must judge is cut off mid-function, and say so in the finding.
+</inputs>
+
+<method>
+- You have no shell. You cannot run tests; the implementer's report carries the test evidence — verify its claims against the diff, and if the evidence is missing or garbled, report that in `cannot_verify`.
+- Inspect code outside the diff only for a concrete named risk (a changed contract, lock ordering, shared state): one focused `grep`/`read` per risk, and name both the risk and what you checked.
+- Non-vacuity is the highest-value check: would deleting the fix, or a plausible regression, leave the new tests green? Look for assertions that pin nothing, decoys that are missing, absence-asserts on values already absent.
+- A batched brief (several files, each with its own change): every listed file must have its hunk; a listed file the diff never touches is a spec issue.
+- Treat "left it per YAGNI"-style rationales in the report as claims, not mitigations; a stated rationale never downgrades a finding's severity.
+- You do not dispatch subagents.
+</method>
+
+<budget>
+Target ≤6 tool calls: package, brief, report, then at most three focused checks. A review that wanders the codebase is the wrong review.
+</budget>
+
+<output>
+Yield the structured result. `findings` carry file:line, severity, and a concrete fix; `spec_issues` and `cannot_verify` are exhaustive; `strengths` are specific. No prose outside the fields.
+</output>

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@loneexile/omp-superpowers",
+  "version": "6.4.2-omp.1",
+  "description": "obra/superpowers adapted for Oh My Pi (omp): a truthful task/todo tool mapping and five subagent-driven-development agents, each with its own model, thinking level, and tools.",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "omp",
+    "oh-my-pi",
+    "skills",
+    "tdd",
+    "debugging",
+    "collaboration",
+    "workflow"
+  ],
+  "pi": {
+    "extensions": [
+      "./.pi/extensions/superpowers.ts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/LoneExile/omp-superpowers#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LoneExile/omp-superpowers.git"
+  },
+  "files": [
+    ".pi/extensions",
+    "agents",
+    "skills",
+    "CHANGELOG.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  }
+}