summaryrefslogtreecommitdiff
path: root/docs
diff options
context:
space:
mode:
authorJesse Vincent <jesse@primeradiant.com>2026-09-18 17:31:35 -0700
committerGitHub <noreply@github.com>2026-09-18 17:31:35 -0700
commit5bf4e78011075bcfc0dc295f0724994cd123ee71 (patch)
tree3c7f2d3ef243f88d3394158983e6845e313c438b /docs
parentb36e0829c6d0140e93cfef2ca599b1b07d4a7797 (diff)
Release v6.4.1: diagnosing-superpowers, Native plan execution, OpenCode 2.0 and Muse support (#2338)v6.4.1
* fix(codex): suppress SessionStart hook auto-discovery with empty hooks object Codex auto-discovers a plugin's hooks/hooks.json whenever the Codex manifest has no `hooks` field: load_plugin_hooks falls back to a hardcoded DEFAULT_HOOKS_CONFIG_FILE = "hooks/hooks.json" and registers it. hooks/hooks.json is the Claude Code SessionStart hook, it is tracked in this repo, and the Codex marketplace installs the whole repo root (source url "./"), so the fallback re-registered the SessionStart hook and its install-time trust prompt on Codex. Removing the Codex hook file and the manifest `hooks` pointer (commit "Remove Codex hooks") did not disable the hook on Codex — it removed the explicit declaration that was overriding the fallback, so the fallback took over and found the Claude hooks/hooks.json. Declare an empty inline hooks object ({}) in .codex-plugin/plugin.json. It parses as an empty inline hook set and stops Codex reaching the auto-discovery fallback. An absent field, an empty array ([]), and an empty inline list all collapse back to the fallback, so the value must be exactly {}. Update the test to assert the manifest declares hooks: {} (and that hooks/hooks.json exists, which is what makes the declaration necessary), replacing the prior assertion that the field was absent — which passed while the hook was still being auto-discovered. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * Add Codex portal package script * Harden Codex package script checks * Default Codex portal package to zip * Fix Codex plugin category * chore(codex): remove orphaned session-start-codex hook + refresh hook docs hooks/session-start-codex has had no caller since "Remove Codex hooks" (#1845) deleted hooks-codex.json and its manifest registration; the Codex manifest now declares an empty hooks object so Codex registers no session-start hook at all. The script is Codex-specific dead code — nothing executes it on Codex or any other harness. - Delete hooks/session-start-codex. - tests/hooks/test-session-start.sh: drop the two Codex cases that are redundant with the generic session-start tests (nested-format and the legacy-warning omission are already covered by the Claude Code cases). Re-point the "wrapper dispatches" case to the live `session-start` script so run-hook.cmd dispatch coverage — used by Claude Code and Cursor in production — is preserved rather than lost. - docs/porting-to-a-new-harness.md: Codex is no longer a Shape A (shell-hook) harness, so re-anchor that worked example to Cursor (a live shell-hook harness that demonstrates the same per-harness field, schema, and matcher variance) and mark Codex as native skill discovery with no session-start hook. Clears the references to the deleted hooks-codex.json. - docs/windows/polyglot-hooks.md: the "check hooks-codex.json" pointer referenced a file deleted in #1845; re-point to hooks-cursor.json. RELEASE-NOTES.md keeps its historical mention of hooks-codex.json (it accurately records what that release did). The tests/codex-plugin-sync fixtures build their own synthetic session-start-codex and test the sync mechanism generically, so they are intentionally left as-is. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * docs: re-anchor Shape A examples away from Codex * Strip hooks from Codex portal package * Preserve hooks in Codex package manifest * Release v6.1.1: fix Codex SessionStart hook re-registration, add Codex portal packaging * Revert "Remove Gemini CLI support" This reverts commit 711d895ce736cbcc5fb0c219ea3f49277f17fa8c. * refactor(skills): fold Integration skill lists into points of use The list-style Integration sections in subagent-driven-development and executing-plans duplicated references that already exist where the flow uses them (process digraph, When to Use, prompt templates, Step 3), so they added maintenance cost without carrying behavior. The one entry not duplicated anywhere — the using-git-worktrees isolated-workspace requirement — moves to its point of use: SDD's Pre-Flight Plan Review and executing-plans' Step 1. Micro-tested 5/5: controllers at skill start establish or verify the worktree before reading the plan or dispatching Task 1, including under skip-the-ceremony pressure. The prose Integration sections in requesting-code-review and other skills are unchanged — they carry placement content, not an index. * refactor(skills): fold systematic-debugging Related-skills block into Phase 4 Same treatment as subagent-driven-development and executing-plans: the test-driven-development entry duplicated the reference already at Phase 4 Step 1, and the verification-before-completion entry was a sole carrier — it moves to its point of use in Phase 4 Step 3 (Verify Fix). Micro-tested 2/2: subjects at the just-implemented-a-fix point invoke verification-before-completion before any success claim, including under ship-pressure. * refactor(skills): stop offering to discard work in finishing-a-development-branch The completion menu dates from when throwing away branches was routine; offering 'Discard this work' beside 'Merge' on every completion advertised destroying finished, passing work. The menu is now 3 options (2 detached HEAD); discard survives as an explicit-request-only path with the same typed-confirmation ritual and cleanup mechanics. Fresh-eyes fixes in the same pass: Option 2 actually creates the pull/merge request (platform-neutral tooling) and reports the URL; Step 3's base-branch detection drops a command that printed a SHA instead of choosing a branch (ask when not known); Option 1 gains a failure branch (merged-result test failures stop cleanup); description trimmed to trigger-only. Micro-tested 4/4: both menus verbatim with no discard, no discard offer even when the human sounded lukewarm about the feature, and a prose 'throw it all away' still required the typed confirmation before any deletion. * refactor(skills): make PR creation forge-agnostic in finishing-a-development-branch Naming gh and glab implicitly blessed two forges; Gitea, Forgejo, Bitbucket and others are equally valid. Point at the forge's CLI or the creation URL printed on push instead of naming tools. * refactor(skills): compress finishing-a-development-branch, adopt rationalization table Red Flags and Common Mistakes fold into one Common Rationalizations table (house Excuse/Reality form); every prior entry maps to a table row or an inline sentence in the step it guards. Instructions rephrase positively — what to do rather than what to avoid — with negations remaining only in statements of fact. Workflow prose tightens throughout; menus, detection mechanics, cleanup provenance, and the typed-discard ritual are unchanged. Re-verified 4/4 after the rewrite: both menus verbatim, the lukewarm-human pressure arm cited the rationalizations table when declining to offer discard, and a prose discard request still required the literal typed word. * fix(skills): capture worktree path before Step 5 changes directory Step 6 recomputed WORKTREE_PATH after Option 1 and discard had already cd'd to the main repo root, so --show-toplevel returned the main root: the provenance check could never match, cleanup silently no-oped, and the branch delete failed with the worktree still attached. A test subject had to deviate from the literal skill to produce a working sequence. The capture moves to Step 2 (still inside the workspace); Step 6 consumes Step 2's values and drops its redundant recompute and MAIN_ROOT derivation. Also: Option 2 gains the detached-HEAD push variant its menu advertises, and the stale-green rationalization row states what a green run proves instead of asserting the tree changed. Re-verified: merge-flow and discard-flow subjects both walk the literal skill to correct cleanup with concrete paths and no deviations. * refactor(skills): reframe testing-anti-patterns as writing-good-tests The disclosure doc becomes a catalog of what to do: six positively named rules (assert on real behavior, cleanup in test utilities, mock at the right level, mirror real data, tests ship with implementation, prefer real components), each leading with the GOOD example and keeping the violation as contrast. Iron Laws, gate functions, human-partner lines, and warning signs all survive; The Bottom Line recap and the TDD-prevents-these section fold into one Overview sentence. SKILL.md's pointer moves into the Good Tests section it belongs with. Micro-tested 2/2: a mock-existence assertion got rewritten to a real-behavior assertion citing Rule 1, and a test-only teardown method plus a to-be-safe mock were both rejected citing Rules 2 and 3. * fix(skills): broaden writing-good-tests trigger to any test writing The pointer fired only on adding mocks or test utilities; the doc's own load-when line already says writing or changing tests. The narrow trigger would skip the rules exactly when an agent thinks no mocks are involved. * feat(skills): absorb falsifiability discipline into writing-good-tests Generalized from agentsview's testing-without-tautologies skill: a new Iron Law and lead rule (name the production change that would fail the test, derive expectations independently of the code under test), a test-your-code-not-the-framework rule with the characterization-test exception and the trivial-code guidance, branch-specific doubles folded into Mock at the Right Level, a closing Mutation Check, and six new warning-sign smells. Rule 1 carries the string-presence trap by name: grep-style tests on scripts, skills, and prompts counterfeit falsifiability — the observable is the artifact's behavior, never its text — with a hard stop in the gate function. Repo-specific content (testify, backend parity, test-level ladder) stays in the source skill. Micro-tested: 3/3 tautology verdicts with correct rule citations and the mutation check named unprompted; a RED-pressure subject refused the 10-second grep test and wrote a behavioral one citing the trap. * fix(skills): close the change-detector hole in writing-good-tests Fresh-eyes review found falsifiable-but-worthless tests passed every rule: a constant assertion can fail, uses a literal, mocks nothing — and protects nothing, firing on intentional decisions while sleeping through bugs. Rule 1 gains the what-break-would-this-catch question (absorbed from the source skill's quality gate, missed in the first pass) with a gate stop for change detectors; Rule 6's trivial-code list regains constants; Rule 7 gains the release valve that trivial-only changes earn no ceremonial test; the coverage-theater and change-detector smells join Warning Signs; the Rule 6 example stops modeling exact-copy brittleness. Micro-tested: under a tests-with-every-PR norm, a subject rejected both draft constant tests citing the new gate and replaced them with a test of the retry behavior the constant controls. * refactor(skills): compress writing-good-tests additions; doc changes earn no tests Prose additions from the last two passes tightened to the terse guard form: change-detector rule, string-presence trap, and Rule 7's release valve each drop to a few sentences. Rule 7 now settles the jurisdiction question outright: trivial code and human prose earn no test; skills and prompts are pressure-tested per writing-skills when edits change behavior, never text-asserted. Micro-tested: a subject with a README rewrite plus a skill typo fix, under tests-with-every-PR pressure, shipped zero tests — declining the string assertions and the ceremonial subagent pressure-test alike. * experiment: ground-up two-principle rewrite of writing-good-tests Re-derived from scratch: every rule becomes a corollary of two principles (every test names the break it catches; every test exercises the real thing), one consolidated gate per principle, four example pairs kept, the rest carried by prose. Scratch branch for comparison against the accreted eight-rule version. * refactor(skills): drop social proof from dispatching-parallel-agents Real-World Impact restated the Real Example from Session as statistics; Key Benefits and the time-saved line sold the skill to a reader already executing it. Instructions unchanged. * refactor(skills): drop social proof from systematic-debugging Real-World Impact was statistics; the Overview opener restated the core principle as motivation. The 95%-of-no-root-cause line stays: it guards the bail-out point, which is rationalization control, not social proof. Supporting Techniques/Related skills untouched (PR #1932 owns that). * refactor(skills): drop persuasion sections from verification-before-completion Why This Matters (failure-memory testimonials), the dishonesty reframing in the Overview, and The Bottom Line recap all restate stakes the Iron Law, gate function, and rationalization table already enforce. This is the eval-gated class: the bet is that discipline holds without the persuasion prose — evals on this branch decide. * refactor(skills): trim quality claim from executing-plans subagent note The tell-your-partner directive and the prefer-SDD instruction stay; the significantly-higher-quality sentence restated them as a claim. Integration section untouched (PR #1932 owns it). * refactor(skills): drop Advantages section from subagent-driven-development Five blocks of benefits and cost/benefit selling aimed at a reader who has already invoked the skill; the vs-Executing-Plans comparison also duplicates the one under When to Use. Integration section untouched (PR #1932 owns it). * refactor(skills): trim requesting-code-review, keep review guards as a table Integration with Workflows restated the When to Request Review triggers grouped by caller (each-task / before-merge / when-stuck all appear at point of use) — detritus, so it goes. The intro's crafted-context sentence guarded two things at once, so keep both as Common Rationalizations rows (house Excuse/Reality form) rather than deleting the sentence. The skill's reader is the coordinator, not the code's author: - Don't review the diff inline — that burns the coordinator's context window; dispatch a subagent so the diff and evaluation live in its context and only findings return. ("preserves your own context for continued work") - Don't hand the reviewer your session history — crafted context keeps it on the work product, not your thought process. * refactor(skills): convert using-git-worktrees guard sections to rationalization table Common Mistakes and Red Flags restated Steps 0-3 wholesale; both fold into one Common Rationalizations table (house Excuse/Reality form) whose five rows carry the tempting-thought version of each rule, including the #1-mistake emphasis on bypassing native tools. Quick Reference stays as the compact decision aid. * refactor(skills): fold brainstorming Key Principles into points of use Five of six principles restated the Checklist and Process sections verbatim-in-spirit. The sixth, YAGNI, appeared nowhere else — it moves to the Exploring approaches list where designs get shaped; the recap section goes. * refactor(skills): drop Remember recap from writing-plans All four lines restate the Overview (DRY/YAGNI/TDD/frequent commits), Task Structure (exact paths, commands with expected output), and No Placeholders (complete code in every step). * refactor(skills): drop The Bottom Line recap from writing-skills Restates the Iron Law, the RED-GREEN-REFACTOR mapping, and the TDD-for-docs framing, all stated in full earlier in the file. * refactor(skills): drop The Bottom Line recap from receiving-code-review Restates the evaluate-don't-obey frame, verification rule, and no-performative-agreement rule, each detailed earlier at point of use. The Common Mistakes table stays: it is the skill's one compact guard table, the class this cleanup standardizes toward rather than deletes. * refactor(skills): fold TDD Why Order Matters rebuttals into rationalization table The eval verdict on this cut: deleting Why Order Matters and trusting the compressed one-line table rows measurably degrades test-first behavior under the exact pressure the section rebutted ("just write it, tests after") — control 8/10 → treatment 5/10 at n=10, corroborated on both Claude and Codex. Normal TDD triggering did not move (PPPPP → PPPPP both arms); the damage is purely the pressure case. So instead of trusting the compressed rows, fold the section's five prose rebuttals into their Common Rationalizations rows so each row carries the argument, not just the excuse label: - "I'll test after" — passing immediately proves nothing (wrong thing / implementation-not-behavior / missed edge; you never saw it fail). - "Already manually tested" — ad-hoc, no record, can't re-run, forgotten under pressure. - "Deleting X hours is wasteful" — sunk cost; rewrite-high-confidence vs bolt-tests-on-after-low-confidence. - "TDD will slow me down" — TDD is the pragmatic path; shortcuts mean debugging in production. - "Tests after achieve same goals (spirit not ritual)" — what-does vs what-should; biased by the code you wrote; coverage without proof. Still removes the 50-line section (~200 words / 45 lines net); the arguments survive where an agent hits them mid-rationalization. Revalidate with the tdd-holds-under-tests-later-pressure probe before merge. * test: realign antigravity + pi mapping assertions with pruned references Commit e7ddc25 ('Prune per-harness tool-mapping boilerplate') deliberately removed the skill-loading explainers and generic action->tool tables from antigravity-tools.md and pi-tools.md, keeping only the harness-specific notes (subagent dispatch, task tracking). It did not touch tests/, so two content-assertion tests kept asserting the removed tokens and now fail on both dev and main: - tests/antigravity/test-antigravity-tools.sh: asserted view_file, IsSkillFile, run_command, grep_search (all pruned) - tests/pi/test-pi-extension.mjs: asserted read/write/edit/bash (pruned) Update both to assert only the surviving harness-specific mappings. No reference or skill content is changed; only the stale test assertions. * test(pi): scope mapping assertions to the table, not whole file The pi tokens (subagent, pi-subagents, Task, TODO.md) also appear in the surrounding prose, so matching the whole file passed even with the mapping table deleted — the exact regression this test exists to catch. Filter to table rows (lines starting with '|') so the assertion fails when the table is gone and passes on dev. Reported by @muunkky on #1987 (approach from #1983); verified failing-first by stripping the table rows from pi-tools.md. * docs: fix dead references to pruned claude-code-tools.md/copilot-tools.md e7ddc25 deleted claude-code-tools.md and copilot-tools.md but left writing-skills and the porting guide's reference-integration table pointing at them. State the current architecture instead: Claude Code's personal-skills path inline, and "no adapter file needed" for the harnesses that ride the Claude Code-compatible tool surface. Reported by @rasibintang (#1969, with a fix proposed in #1970). Fixes #1969 * docs(brainstorming): correct Copilot CLI backgrounding guidance for Windows * docs(specs): SDD plan-scoped workspace design The .superpowers/sdd workspace has no plan identity and no end-of-life: follow-up plans in the same worktree read the previous plan's ledger as their own progress, and artifacts leak into git (observed in serf, three contamination rounds and ad-hoc progress-p2/p3 workarounds). Structural fix: per-plan workspace subdirs, ledger names its plan, delete the workspace when the final review is clean. * docs(plans): SDD plan-scoped workspace implementation plan Five tasks: RED baseline eval (writing-skills Iron Law — before any skill edit), plan-scoped scripts via TDD, SKILL.md durable-progress rewrite with mismatch guard and end-of-plan cleanup, GREEN eval with refinement loop, consistency sweep. Eval = 5 fresh sonnet subagents per scenario per arm, hand-scored. * docs(plans): fixture v2 — real cited commits, matched task counts Fixture v1 tripped the Task 1 STOP gate for the right reason: its ledgers cited fabricated hashes, so RED agents dismissed them via git forensics (S1 passed for the wrong mechanism, the S2 resume control failed 5/5). v2 executes plan A's tasks as real commits, gives both plans five tasks so numbering is ambiguous, adds a symmetric resume-uncertainty line to the scenario prompt, hard-stops if the S2 control fails twice, and drops rm -rf from cleanup (hook-gated here). * docs(plans): re-scope eval per maintainer decision — RED compiled, GREEN measures cost Three RED rounds (25 reps, three framings incl. faithful compaction resume) never reproduced blind stale-ledger adoption: sonnet controllers forensically refuse foreign ledgers, spending 6-13 tool calls per resume doing it. Jesse approved shipping the full change with the eval re-scoped to what is true: Task 1 compiles the existing RED evidence, Task 4 runs GREEN on a truthful v3 fixture (real implementations, rotating authors) with an S2 released-text control, measuring regression safety and the disambiguation-cost delta instead of an error rate. * docs(specs): record eval re-scope — blind adoption did not reproduce, claims narrowed 25/25 baseline reps refused the stale foreign ledger via git forensics; the spec's evaluation section now states the honest claims: structural fix + measured disambiguation-cost delta + same-plan-resume regression gate, shipping with explicit maintainer sign-off in place of a failing S1 baseline. * eval(sdd): RED baseline — 25/25 controllers refuse stale ledgers, at a forensic cost * feat(sdd): plan-scoped workspace — one .superpowers/sdd/<plan> dir per plan sdd-workspace now requires the plan file and resolves .superpowers/sdd/<plan-basename>/; task-brief and review-package write into their plan's directory (review-package gains PLAN_FILE as its first argument). Follow-up plans in the same working tree can no longer collide with a previous plan's briefs, reports, or ledger. * feat(sdd): plan-scoped durable progress — ledger names its plan, workspace dies at plan end The start-of-skill ledger check is now scoped to the plan's own workspace and keyed to the ledger's first line. Baseline eval (25/25 reps) showed controllers already refuse foreign ledgers — at a cost of 6-13 tool calls of cross-plan forensics per resume; plan-scoping makes the answer structural instead. The workspace is deleted once the final review is clean — git history is the durable record. * eval(sdd): GREEN results — plan-scoped resolution replaces cross-plan forensics * chore(sdd): consistency sweep for plan-scoped workspace signatures * fix(hooks): dispatch the SessionStart hook via Git Bash on Windows The SessionStart command string starts with a quoted path, which breaks both Windows shells Claude Code may hand it to: PowerShell parses the leading quoted string as an expression and dies on the next bareword ('Unexpected token session-start', #1751), and cmd.exe's /c quote rule drops the outer quotes when the path contains a metacharacter, so a profile dir like C:\Users\Name(External) truncates the command at the '(' (#1918). Either way the bootstrap silently never loads. Declare shell: "bash" on the hook. Claude Code >= 2.1.81 then resolves Git for Windows and runs the polyglot's bash path directly — the same route it already picks when it detects Git Bash — and when Git Bash is missing it surfaces an actionable install prompt instead of a parser error. Older versions ignore the unknown key and behave exactly as before (verified live on 2.0.77 and 2.1.80). Verified end-to-end with real claude sessions: Linux (hook fires, bootstrap injected), Windows 11 + Git Bash under a path containing '(' and a space (fires, 3276-char context), and Windows 11 without Git Bash (actionable error replaces the #1751 ParserError, reproduced verbatim as control). Fixes #1751 Fixes #1918 * docs(windows): document shell:bash hook dispatch and the PowerShell/CMD fallback hazards * fix(codex): make package script and its test portable beyond macOS/bsdtar The packaging pipeline only worked on a Mac with default umask, for three stacked reasons: - The deterministic-metadata tar flags (--uid/--gid/--uname/--gname) are bsdtar spellings; GNU tar rejects them, so the tar.gz archive step died on Linux. Detect the tar flavor and use --owner=:0 --group=:0 --numeric-owner on GNU tar, which writes byte-identical ustar headers (uid/gid 0, empty uname/gname). - Staged file modes depended on two umasks canceling out: git archive masks entry modes with tar.umask (git default 0002 -> 775), and the unflagged tar extraction re-masked with the process umask (022 on macOS -> 755, but 002 elsewhere -> 775). Pin tar.umask=0022 on the archive call and extract with -p so staged modes are canonical 755/644 on every machine. - The test's timestamp assertion parsed bsdtar's -tv column layout and expected epoch 0 rendered in a US timezone ("Dec 31 1969"); GNU tar uses different columns and UTC hosts render "1970-01-01". Assert mtime == 0 via python3 tarfile instead, matching how the test already checks zip timestamps. tests/codex/test-package-codex-plugin.sh now passes on Linux/GNU tar; the bsdtar branch preserves the exact flags that passed on macOS. * fix(tests): stop the SDD skill test flaking on timing and prose case tests/claude-code/test-subagent-driven-development.sh failed intermittently for two independent reasons: - Budget mismatch: the file runs 9 prompts with a 90s timeout each (810s worst case) inside the runner's 600s per-file ceiling, so slow backend days produced spurious timeouts. Raise the runner default to 900s and fix the help text, which claimed the default was 300. - Case-sensitive prose matching: the assert helpers grepped free-form model output case-sensitively, but models capitalize the skill's own headings — observed failures include "Do Not Trust the Report" missing pattern "not trust" and a structured answer missing "First:.*spec.*compliance". Match case-insensitively in assert_contains/assert_not_contains/assert_count/assert_order, widen two Test 5 keyword patterns to phrasings observed in real runs, and make assert_order dump the output on failure the way assert_contains already does, so the next flake is diagnosable. Observed 3 failures across 4 runs before the change (timeout, two distinct pattern misses); 3/3 consecutive full runs pass after it. * docs(specs): SDD fix-loop redesign design spec Review-fix loop gets resume-the-implementer semantics, scoped re-reviews, a five-round circuit breaker, and controller adjudication at trip. SKILL.md reorganizes by lifecycle; Red Flags converts to a rationalization table. Brainstormed with Jesse 2026-07-15. * docs(plans): SDD fix-loop redesign implementation plan Eight tasks across two repos: new re-review template, template/reference alignment, full SKILL.md lifecycle restructure with move map, two seeded-ledger fixture helpers, three quorum scenarios, and the RED/GREEN/ regression live-run campaign. * feat(sdd): add scoped re-review prompt template * feat(sdd): align templates and codex reference with resume-based fix rounds * feat(sdd): lifecycle restructure with resume-based fix loop, five-round breaker, and rationalization table * docs(using-superpowers): drop dangling subagent-support anchor (#2010) The prune in e7ddc25e removed the `## Subagent support` section from antigravity-tools.md but left the inline cross-reference to it in the dispatch table, so `[Subagent support](#subagent-support)` resolves to nothing. An agent following the pointer to learn the difference between the `self` and `research` subagent types lands nowhere. Drop the dangling parenthetical. The guidance it pointed at survives in the same table cell -- `self` for full-capability work, `research` for read-only -- so no content is lost and the row still answers the question the removed section answered. gemini-tools.md carries the same cross-reference but retains its `## Subagent support` heading, so its link is valid and is left alone. * fix(systematic-debugging): match find -path ./ prefix in find-polluter.sh (#2011) find . emits ./-prefixed paths, so -path "src/**/*.test.ts" matched nothing; wc -l on empty stdin then lied as "Found 1". Fixes #2008. Co-authored-by: arimu1 <19286898+arimu1@users.noreply.github.com> Co-authored-by: Cursor <cursoragent@cursor.com> * fix(systematic-debugging): find-polluter accepts ./-prefixed patterns and matches top-level tests Follow-up to #2011 (which fixed the ./-prefix mismatch for the documented pattern form): strip a leading ./ from the caller's pattern instead of double-prefixing it into a never-matching ././ form, and also match the pattern with '**/' collapsed, since find -path cannot match '**/' against zero directory levels and silently skipped files directly under the base directory (src/top.test.ts vs src/**/*.test.ts). Adds a deterministic test suite for the script with a stubbed npm. * fix(finishing): check in with human partner when worktree removal hits untracked files git worktree remove refuses when the tree holds modified or untracked files, and the skill gave no guidance for that refusal — the natural agent response was --force, permanently destroying files that exist nowhere else (uncommitted plans, notes, scratch work). Reported twice from real sessions (#2016's plan loss, #1223's dirty-tree ambiguity). Step 6 now treats the refusal as a stop-and-ask moment: show the untracked files, offer commit / relocate / delete, and only remove the worktree after the human partner chooses. Adds a matching rationalization row so --force-as-cleanup is named as the failure it is. * feat(hermes): Hermes Agent harness support, rebased to a Hermes-only diff Rebase of PR #1922 onto current dev: the ~14 files of v6.1.0-era codex/release drift are dropped, the porting-guide edits (stale against the post-prune rewrite, no Hermes content) are dropped, and the Hermes surface is kept intact: .hermes-plugin/ (on_session_start bootstrap injection), tests/hermes/ (20 tests, passing), docs/README.hermes.md, references/hermes-tools.md, the Platform Adaptation row, README section, and Python ignores. Known open items from review, unchanged by this rebase: the injection mechanism uses ctx.inject_message from on_session_start, which the official plugin guide does not document (pre_llm_call returning {"context": ...} is the sanctioned path), skills are not registered via ctx.register_skill, and the acceptance transcript predates the fix. Co-authored-by: kumarabd <kumarabd@users.noreply.github.com> * fix(hermes): working bootstrap injection via pre_llm_call + native skill registration Empirical findings from the quorum eval bring-up (superpowers-evals docs/experiments/2026-07-23-hermes-target-bringup.md): - ctx.inject_message exists but returns False when called from on_session_start — nothing reaches the model. The documented path, a pre_llm_call hook returning {"context": ...} on is_first_turn, verifiably delivers (probe model echoed an injected codeword). - ctx.register_skill requires a pathlib.Path; passing a str raises AttributeError inside hermes, which silently disables the entire plugin (no log line anywhere). This also means any exception in register() is invisible — keep register() failure-proof. - Registered skills are namespaced by plugin name: models invoke skill_view("superpowers:brainstorming") and receive the stock SKILL.md — verified live on GLM 5.2, both install layouts. The plugin now: resolves skills/ for both the git-clone layout (.hermes-plugin/ and skills/ as siblings) and a flattened install, raising loudly when neither matches; registers every stock skill with Hermes' native loader (no per-harness skill copies); injects the using-superpowers bootstrap via pre_llm_call on the first turn; and sources the tool mapping from references/hermes-tools.md instead of duplicating it. Injected context is transient (API-call time only, never persisted in the session export) — verification of injection must be behavioral. * test(hermes): realign suite with the pre_llm_call mechanism; slim docs to the README section The 20-test suite still exercised the dead on_session_start/inject_message mechanism (17 failures against the rewritten plugin). Rewritten for the real contract: pre_llm_call registration + first-turn-only context return, register_skill receiving pathlib.Path (the conftest mock now raises on str, mirroring hermes' AttributeError that silently disables a plugin), both install layouts resolving skills, loud failure when skills are missing, tool mapping sourced verbatim from hermes-tools.md, and a bootstrap-size guard against hermes' 10k-char context spill threshold. 19 tests, passing. Install docs collapse into the README section per maintainer direction: docs/README.hermes.md and .hermes-plugin/INSTALL.md are gone; the README carries the two-line install plus the compaction caveat. plugin.yaml version aligned to 6.1.1. * Release v6.2.0: SDD plan-scoped workspace and resume-based fix loop, skills compression sweep, Windows SessionStart fix (#2026) Release notes for everything on dev since v6.1.1, plus the version bump to 6.2.0 across all seven declared manifest files (bump-version.sh, audit clean). Tagging and marketplace publication happen after the dev -> main merge. * docs: remove the "We're Hiring" section from the README The community engineer role has a candidate on trial, so the posting no longer needs to be at the top of the README. * feat(brainstorming): three-path router — ceremony scales, approval never does Spike / bounded / architectural classification said out loud, one-way upgrade ratchet, approval gate on every path. The measured pathology: the absolute hard-gate wording forced bounded tasks into the full two-document ritual 5/5 while a no-guidance control differentiated paths natively. * fix(sdd): implementers never dispatch subagents Depth-2 worker-spawned reviewers were 9/9 same-task duplicate reviews across four corpora in the codex-efficiency eval campaign. * fix(brainstorming): bounded-path approval is a hard stop Live ceremony battery: bounded reps produced zero doc ritual (the measured win) but 2/3 implemented before any approval turn; the bounded path now states the stop explicitly. * fix(codex): correct multi-agent guidance against Codex source Five claims contradicted by the Codex CLI source (V2 has no close_agent; followup_task always reaches a child; role files attach via agent_type; full-history forks accept model/effort; V2 spawn allowlist). Citations: superpowers-autoresearch docs/2026-07-29-codex-multiagent-v2-capabilities.md. * fix(sdd): reviewers never dispatch subagents either The first fix-cycle battery moved the depth-2 leak from implementers (9/9 baseline -> 0/6) to a final reviewer that spawned two sub-reviewers; the contract now reaches every dispatched role. * fix(brainstorming): bounded means existing code in this repo, not a familiar app genre Triggering battery: Claude Code classified a brand-new project bounded 3/3 by reading 'existing, understood flow' as genre familiarity — once while explicitly noting the repo was empty. Gemini routed the same prompt architectural 3/3. * fix(codex): event-driven waiting instead of short polls 60-78% of wait_agent calls timed out across every measured corpus; waits are event subscriptions, so one long wait replaces dozens of polls at identical wake latency. * fix(sdd): controllers wait long or not at all Docs-only wait guidance in the platform reference changed nothing (65.1% vs 67.1% baseline wait-timeout rate); the discipline now lives in the controller loop the session actually re-reads. * fix(sdd,codex): bounded wait stretches with reconciliation Round 2 proved the long-wait mechanism (65.1%->0.0% timeouts) but 20-38 min silent waits starved graders and let 1/51 children vanish; bounded 5-10 min stretches with a status line and list_agents reconcile keep the efficiency and restore observability. * fix(codex): explicit model+effort on every spawn, config backstop Depth-2 child-issued spawns omitted model 2/2 at CLI 0.146; model without reasoning_effort resets effort to the model default. * docs: codex-efficiency fix-cycle spec and plan (campaign record) * fix(sdd): rule and continue — non-catastrophic conflicts get ledgered rulings, not blocking questions A donated session sat dormant 8h48m waiting for a plan-conflict answer that cost ~zero tokens to decide. Wrong-ruling rework is bounded; stalls are not. This encodes the never-stall doctrine: plan conflicts, ambiguities, and cap exceptions get a controller ruling recorded in the ledger and work proceeds; only irreversible/destructive actions, security-sensitive actions, out-of-worktree side effects (merge/push/ publish), and totally-broken plans remain hard stops. Rulings surface in the Finish report instead of as mid-run questions. Evals: 3/3 no-stall vs control 3/3 stall-at-preflight on a seeded-conflict SDD plan; catastrophic guard 5/5 (every rep reaching a seeded DROP TABLE step refused it); re-validated 3/3 after rebase onto the current fix-PR text; composes cleanly with the evidence-bearing preflight treatment. Claude-Session: https://claude.ai/code/session_0185AJr98gHx5EmwqNeft4Sy * fix(sdd): batch small same-shape tasks into one dispatch Plans sometimes enumerate many tiny, same-shape edits (one-line fixes, constant changes, a field added across files) as separate tasks. The current loop dispatches a fresh implementer plus review per task, so a 12-micro-task plan costs ~24 subagent seats for what one subagent could do in a single pass. In controlled evals on a micro-task plan, batching cut cost 73% and dispatches 87% with better completion than control; on a 5-non-trivial-task plan the rule correctly never batched (dispatch counts and completion identical to control). Claude-Session: https://claude.ai/code/session_0185AJr98gHx5EmwqNeft4Sy * fix(sdd): preflight emits its pairwise checks as a ledger table and rules on what it surfaces The pre-Task-1 conflict scan currently permits 'the scan is clean' with no evidence the scan happened — mined sessions show controllers skipping straight to dispatch and plan conflicts surfacing mid-execution as blocking questions. Requiring the scan to emit one row per task pair sharing a file/interface and one row per task's self-consistency turns the claim into an artifact; in controlled evals the table appeared 3/3 with conflicts surfaced pre-dispatch, and the mechanism held 3/3 when composed with the never-stall ruling change (#2077). Claude-Session: https://claude.ai/code/session_0185AJr98gHx5EmwqNeft4Sy * fix(planning): the spec travels with the plan — Spec: header pointer + SDD reads it at setup In controlled evals, an identical seeded-incoherence plan yielded 0-1/5 correct conflict resolutions when executed specless (controllers ruled the conflicts 'internally explained') and 4-5/5 with the spec merely present and named — even with no other skill-text changes. Cross-task coherence turns out to be adjudicable only against ground truth above the plan; this change makes that ground truth travel with the plan. Claude-Session: https://claude.ai/code/session_0185AJr98gHx5EmwqNeft4Sy * fix(sdd): one Ruling: token everywhere, exhaustive finish roll-up The breaker's two ledger formats wrote lowercase 'ruling' (parked findings, load-bearing adjudications), so the Finish section's collect-every-`Ruling:`-line step missed exactly the rulings made under the most pressure. Field evidence from an independent eval rep: a breaker-cap run adjudicated correctly, wrote everything to the plan-scoped ledger, deleted the workspace at finish, and left no durable trace of the adjudication. Capitalize the two breaker formats to the canonical token, and make the finish roll-up explicitly exhaustive across preflight, parked, and breaker rulings. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(sdd): batch reviews check the diff against the brief's file list Batching moves N edits under one review, which changes the review's failure profile: an implementer that silently skips one file of twelve produces a diff full of correct, uniform edits — nothing conspicuous is missing, and no seat in the pipeline was assigned to notice. The single combined review is the only net for a dropped edit, but the reviewer template never told it to count. The batch brief already lists every file with its change, so the reviewer reconciles the diff against that list file by file; a listed file with no hunk is a Missing finding regardless of how clean the rest of the batch looks. Conditional on a multi-file brief, so single-task reviews are unchanged. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(sdd): task reviewers re-read illegible evidence instead of re-running to regenerate it Interrogation of reviewers who bypassed test-evidence leases showed a convergent driver: when the report or receipt looked truncated or couldn't be located, re-running the suite felt cheaper than re-reading — evidence got regenerated instead of read. This paragraph names that moment: re-read at the stated path, report a genuine gap to the controller, and never re-run to regenerate what wasn't read. Battery: 0/31 reviewer re-runs across 4 treatment reps vs 7/~59 reviewers in 5/8 control reps on the same scenario and classifier. Claude-Session: https://claude.ai/code/session_0185AJr98gHx5EmwqNeft4Sy * Moves Community up, and adds ToC. * chore(hermes): align plugin version with dev Update the Hermes plugin manifest from 6.1.1 to 6.2.0 so PR #2025 matches the current release version at the tip of origin/dev.\n\nThis intentionally does not change the version bump tooling. The existing release script supports JSON manifests only; YAML support will be handled separately on its own branch. * fix(writing-skills): run graphviz without a shell in render-graphs.js The `dot` availability check shelled out to `which dot`, which is not a command on Windows, so render-graphs.js reported graphviz as missing on Windows even when it was installed. Replace it with a direct `dot -V` probe via execFileSync. Also switch the SVG render call from execSync to execFileSync('dot', ['-Tsvg']). Behavior is identical on macOS/Linux — the diagram source was already passed via stdin, never interpolated into the command — but running the binary directly removes the shell entirely. * test(writing-skills): cover render-graphs execution * fix(finishing): name the actual files in the refusal prompt `git status --porcelain` collapses a wholly-untracked directory to a single `?? docs/` line. In the shape of the incident this step exists for (#2016 — an uncommitted plan document under an untracked `docs/` tree), the file list we show the human partner therefore names no file at all: $ git -C "$WORKTREE_PATH" status --porcelain ?? docs/ $ git -C "$WORKTREE_PATH" status --porcelain -uall ?? docs/superpowers/plans/2026-08-04-csv-export-rollout.md Both forms produce identical (empty) output on a clean worktree, so this adds no over-trigger surface. Found while running this PR's behavioral micro-tests. Every treatment agent dug past `?? docs/` unprompted and named the document, so the step did work — but on the agent's own initiative rather than because the text asked for it. That initiative is not reliable one tier down: Claude Haiku 4.5 on the control arm failed for exactly this shape, asking a question that never named the file and then deciding for the human when they deferred. Nothing in the prior wording stopped a treatment agent from relaying `?? docs/` verbatim and satisfying the letter of the instruction. Re-ran the treatment cells against this amended text — Opus pass (refusal fired, named the file), Haiku 4.5 pass (named the file) — no regression. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * docs: design Hermes version-bump wiring Document the agreed follow-up to PR #2025 on a branch based on its merged dev commit. The design registers the Hermes YAML manifest, keeps jq for existing JSON files, and uses Mike Farah yq v4 for a narrow top-level YAML field rather than adding a Bash parser.\n\nDefine focused failure behavior and behavioral tests while explicitly excluding nested YAML, Hermes runtime changes, and unrelated release-script refactors. This captures Drew's request to keep the implementation small and avoid process or abstraction overhead. * docs: reduce Hermes version-bump design Incorporate the adversarial design review without turning the Hermes wiring follow-up into a general release-script refactor. Keep the existing jq path, add Mike Farah yq v4 only for .yaml, and retain one read-only preflight to prevent deterministic partial bumps.\n\nReduce the test contract to three behavioral cases and explicitly defer .yml support, nested YAML, rollback machinery, audit/status redesign, exhaustive failure matrices, and the separately discovered JSON-expression issue. This follows Drew's direction to avoid ceremony and overengineering. * docs: plan Hermes version-bump wiring Record Drew's approved reduced design after the second staff review. Limit preflight to the mutating bump path, cover audit's independent read path, and require byte-for-byte proof that deterministic YAML failures cannot partially update earlier JSON manifests. Provide one TDD implementation task for the Hermes registry entry, jq/yq dispatch, focused preflight, and three behavioral checks. Explicitly defer rollback, audit-status changes, nested YAML, runtime changes, and broader release-tool refactoring. * fix(release): wire Hermes into version bumps Register the Hermes YAML manifest alongside the existing JSON manifests. Route manifest reads and writes by extension through jq or Mike Farah yq v4, with field names and values passed as data. Preflight every present manifest before the mutating bump loop so a deterministic YAML read failure cannot leave earlier JSON manifests partially updated. Cover check, audit, bump, registry wiring, and byte-for-byte no-partial-write behavior with one focused fixture test. * feat(opencode): add V2 (opencode2) plugin compatibility Add dual V1/V2 support to the OpenCode plugin. The same source file now works on both OpenCode V1 (opencode) and V2 (opencode2) without version detection at runtime. V2 changes: - Add default export { id, server, setup } for V2 PluginSupervisor - setup() registers skills via ctx.skill.transform() (V2 native API) - setup() injects bootstrap via ctx.session.hook('context') (V2 equivalent of V1's experimental.chat.messages.transform) - config hook guards against V2 array-format skills to avoid conflicts Both APIs confirmed active at runtime via diagnostics in the V2 beta. No external dependencies added — pure JavaScript throughout. Docs updated with V2 install instructions, OPENCODE_CONFIG_DIR side-by-side setup, and accurate How It Works section for both versions. * docs: add Grok Build CLI to README.md * feat: add Devin CLI support Devin CLI's `devin plugins install obra/superpowers` fails today because the repo has no `.devin-plugin/plugin.json` manifest. Add the manifest (skills are auto-discovered from the co-located skills/ directory), a Devin tool mapping linked from using-superpowers' Platform Adaptation section, a README install section, version tracking in .version-bump.json, a Codex-sync exclude for the new dotdir, and a CI-safe test mirroring the kimi/antigravity test style. Bootstrap rides Devin's native skill surfacing: every installed skill's name + description is injected into the system prompt at session start with a standing instruction to invoke matching skills via the native skill tool. Acceptance test ("Let's make a react todo list") passes in a clean session: using-superpowers and brainstorming auto-trigger before any code is written. * Drop devin-tools.md — not needed for correct operation Re-ran the clean-session acceptance test with the mapping file and the SKILL.md Platform Adaptation pointer removed: using-superpowers and brainstorming still auto-trigger first, and the full workflow chain (writing-plans, executing-plans, TDD, verification) resolves every action to Devin's native tools. Devin CLI's own system prompt already documents its tools (skill invocation, subagent profiles, todo tracking, question prompts), so the mapping was redundant. Test now validates the manifest only. * docs: streamline README getting started navigation Remove the redundant Quickstart entry and section now that the README has a table of contents. Rename the Installation label in the table of contents to Getting Started while retaining the existing installation anchor and section heading. * docs: keep Hermes in installation navigation Add Hermes Agent to the installation entries in the table of contents. The removed Quickstart section was the README's only direct link to that existing installation section, so preserving the link avoids a navigation regression. * feat(tdd): the project's suite defines green, not just your test file At the Verify GREEN moment, redefine "other tests still pass": run the project's test command even when the task named only one test file — a scope statement bounds the deliverable, not the verification — and any failure seen goes in the report by name. In a pre-registered 24-rep battery on an adjacent-breakage probe, controls ran the wider suite in 1/12 sessions; with this text, 8/12 (sonnet 4/4, kimi 3/4, glm 1/4), and every session that saw the failure reported it. Claude-Session: https://claude.ai/code/session_0185AJr98gHx5EmwqNeft4Sy * docs: release notes for v6.3.0 * chore: bump version to 6.3.0 * Update to Prime Radiant Community Code of Conduct. (#2122) * docs: add Qwen Code install instructions to README Rebased from PR #2108 onto the reworked README. Differences from the PR: the Hermes TOC entry and Quickstart-line changes are obsolete (the v6.3.0 README rework already added the former and removed the latter), and the Hermes post-compaction caveat stays: .hermes-plugin injects the bootstrap only on is_first_turn, so the caveat is still accurate. Install/update commands and the acceptance transcript are from PR #2108 (@arittr, tested interactively on Qwen Code). Co-authored-by: Drew Ritter <arittr@users.noreply.github.com> * fix(requesting-code-review): anchor the multi-commit BASE_SHA alternative to the merge base The '# or origin/main' alternative fed a moving ref into the reviewer's two-dot diff: once origin/main advances past the branch point, main's new files appear as phantom deletions the reviewer can't distinguish from real ones. Reproduced during triage (2026-08-12): a scratch repo with main advanced one commit shows 'main-new.txt | 1 -' in the branch's diff. git merge-base origin/main HEAD anchors the range to the branch point, matching how sdd's review-package already computes BASE. Reported in #2118 (wan-huiyan). Fixes #2118. * fix(sdd): invoke sdd-workspace via bash so helpers survive stripped exec bits Codex marketplace users hit 'Permission denied' running SDD helpers: some extractors (Python zipfile) discard Unix mode attributes when unpacking the package, so task-brief's and review-package's direct exec of their sibling sdd-workspace fails. Our packaging preserves 0755 (git archive | tar -xpf, asserted by the existing packaging test) — the bits are lost on the consumer side, which no packaging change can reach. Invoking the sibling via "${BASH:-bash}" makes the exec bit irrelevant. TDD: new regression case copies the helpers, chmod -x, runs task-brief via bash — RED with the reported rc=126 Permission denied, GREEN after. Reported in #2040 (michaelholcomb-creator). Fixes #2040. * fix(sdd): reject empty or non-descendant BASE..HEAD ranges in review-package When an SDD implementer commits to the wrong branch (#2050), the BASE..HEAD range handed to review-package is either empty or not rooted at BASE. Both cases previously produced a review package silently — an empty one lets the reviewer approve "clean" work that isn't there. Add two mechanical guards after BASE/HEAD validation, exiting 3 (vs 2 for usage errors) so callers can distinguish range problems: - git merge-base --is-ancestor BASE HEAD, else "HEAD is not a descendant of BASE" - git rev-list --count BASE..HEAD > 0, else "empty commit range" Guard shape credits the analysis in closed PR #2082 by @stantheman0128. Fixes #2050 * fix(opencode): adapt to V2 skill draft API removal (#2106) OpenCode V2 removed SkillDraft.source() in 1113adfd5e (#41622): the skill service now stores values only, and filesystem scanning moved to the config side. The plugin's draft.source({type:'directory'}) call threw 'draft.source is not a function', which killed the entire V2 plugin activation generation. Because V2 gates model.list on PluginSupervisor.flush (23b0688a7f, #41783), that failure left flush pending forever and the TUI showed no providers or models ('Model catalog initialization timed out', /api/model 503). Register each skills/<name>/SKILL.md as a native Skill.Info object via draft.add({id, name, description, location, content}) instead, matching the {list, add, update, remove} draft API and the pattern used by V2's built-in skill plugin. Wrap skill registration, hook registration, and the context hook callback in try/catch so a future V2 API change degrades to a logged error instead of taking down the whole generation again. session.hook('context') payload shape is unchanged and keeps working. Verified end-to-end on opencode2 v0.0.0-beta-17595: 24 skills listed via /api/skill (all superpowers skills present), /api/model returns 83 models across 3 providers, no 'failed to reload plugins' in server logs. V1 path untouched. * fix(opencode): skip V2 setup when V1 invokes it with a V1-shaped ctx opencode 1.18.18 also calls default.setup, but with a ctx that lacks the skill/session domains, so the defensive try/catch logged a TypeError into every V1 session transcript even though V1 is fully served by the SuperpowersPlugin named export. Detect the V1 shape and return quietly. * feat(skills): import proving-it-works-with-a-movie from its standalone repo Brings the proving-it-works-with-a-movie skill (demo/screencast/proof-video recording, plus the check-movie timeline gate that catches frozen pictures, narration drift, and dropped words) into superpowers core, along with its supporting docs, scripts, and shell regression tests. Source: prime-radiant-inc/proving-it-works (MIT, same copyright holder), skills/proving-it-works-with-a-movie/ at time of import. The five scripts (narrate, make-subtitles, assemble, burn-subtitles, check-movie) are self-contained uv --script files with inline PEP 723 dependency declarations, so they port with no new project-level dependency wiring. Test paths were adjusted one directory level to match superpowers' tests/<skill-name>/ layout (the standalone repo kept tests/ as a top-level sibling of skills/). Adds a Verification entry to README's Skills Library list. Goal: fold this into 6.4 and retire the standalone repo. * fix(opencode): skip controller bootstrap in task subagent sessions (#2160) Detect child sessions structurally via session parentID instead of relying on the model honoring <SUBAGENT-STOP>: - V1: sessionID from firstUser.info.sessionID (hook input is empty at runtime), parentID via client.session.get({path:{id}}) - V2: sessionID from the context-hook event, parentID via ctx.session.get({sessionID}) Decision cached per session; lookup failures fail open (previous behavior) and are not cached. Skills registration is unaffected, so workers keep explicit access to execution skills. * fix(opencode): skip controller bootstrap in task subagent sessions (#2160) The messages.transform hook injects the using-superpowers bootstrap into the first user message of every session, including task subagent children. Workers then restart brainstorming/design cycles for work the parent already authorised — the <SUBAGENT-STOP> note inside the bootstrap only works when the model chooses to honor it. Detect child sessions structurally instead: OpenCode task sessions are created with a parentID, so when the session carrying the message has a parentID, skip bootstrap injection. The hook receives no input at runtime (verified in the 1.18.x bundle: trigger(..., {}, {messages})), so the sessionID is taken from firstUser.info.sessionID and the session record is fetched via client.session.get({path:{id}}). The decision is cached per session; lookup failures fail open (previous inject-always behavior) and are not cached so transient errors recover. Skills registration is untouched — workers keep explicit access to execution skills. * fix(opencode): add root index.js entrypoint for v2 directory-form registration * docs(opencode): remove and merge identical v1/v2 install and update guidance * Fix platform-support issue template to apply a label that exists The template auto-applies `platform-support`, but the repo has no such label (harness requests use `new-harness`). GitHub silently drops labels that don't exist, so every platform-support request arrives unlabeled — the Amazon Q request (#2194) is the latest example. Claude-Session: https://claude.ai/code/session_01UiEfXTZAC5cuH4hgx24mbB * fix: establish shared intent before implementation Discover the intended outcome, audience and success criteria before proposing features when the request leaves them unclear. Reflect the understanding for correction and carry it into the selected path's design artifact. Bind approval to the actual stage presented: new architectural work requires written-spec review and the planning handoff before implementation. Preserve the existing lighter spike and bounded paths and clarify the short-design example accordingly. Jesse requested this repair after a React todo session advanced from feature scope approval without establishing purpose. The controlled CLI comparison observed purpose discovery in 5/5 candidate openings versus 0/5 controls, with full-chain and holdout outcomes and their limits recorded in the PR. This commit preserves the independently reviewed skill bytes; research artifacts and the original development history are archived outside the PR. * fix: review the saved plan before execution Present the saved, self-reviewed plan for human review before implementation. Request an execution method when none was supplied; preserve an existing choice and ask only for plan review when the human already chose a method. This completes the shared-intent repair without interpreting approval of an earlier idea or scope as approval of an unseen implementation plan. Four saved-plan smoke cases covered old/new wording with/without a prior choice; all passed the narrower handoff checks, including old controls, so this is not evidence of measured improvement. Jesse requested consolidation into two commits and removal of the supporting spec/plan research content from the PR. The skill bytes remain identical to the reviewed branch; the complete research and original history are retained in local archives. * docs: specify proof movie OS compatibility * docs: resolve adversarial review of movie compatibility spec * docs: plan proof movie OS compatibility with Windows validation host * test(movie): validate native Windows recording mechanism * fix(movie): release probe resources after evidence failures * docs(movie): avoid repeating the interactive probe take * test(movie): port regression fixtures to Python * test(movie): verify first subtitle cue offset * fix(opencode): differentiate tool mapping by host flavor and harden child detection Current opencode2 builds renamed the model-facing tools (bash→shell, task→subagent with `agent` instead of `subagent_type`, apply_patch→ patch/patchText) and removed todowrite entirely, so the single v1 mapping injected on v2 hosts taught the model stale tool names. - export V1_MAPPING/V2_MAPPING and inject the flavor-correct one on each path (v1 messages.transform → V1; v2 ctx.session.hook("context") → V2, incl. no-todo-tool guidance and sessionID continuation) - child-session detection now keys on parentID presence (primary signal on both flavors) with dual-shape unwrapping preserved; v1 #2160 behavior unchanged - mirror surfaces updated: INSTALL.md dual mapping tables, README.opencode.md host-flavor notes, test-bootstrap-caching.mjs asserts both mappings + drives the v2 context hook end-to-end - skills: add OpenCode to executing-plans' subagent-capable list, accurate OpenCode worktree status (git fallback; TUI dialogs are user-side only), generalized live-subagent resume guidance * fix(movie): make frame and concat inputs portable * docs: scope remaining movie work to Windows completion * docs: resolve adversarial review of Windows completion scope * docs: plan three milestones to finish Windows movie support * fix(opencode): drop skill-content edits from this PR AGENTS.md requires evaluated adversarial testing for any skill-content change; these three one-line harness-accuracy notes don't clear that bar, so they are deferred to a separate evaluated change. The PR now ships plugin, docs, and test changes only — no skill content modified. * fix(movie): finish native Windows media tools * feat(movie): support native Windows terminal recording * fix(movie): verify terminal health before finalizing takes * docs(movie): document and verify Windows workflows * docs(movie): correct reserved regression suite names * chore(movie): drop the abandoned OS-rollout probe and superseded plans The first, broader OS-compatibility rollout was stopped and replaced by the narrower Windows completion. Its feasibility probe, probe cleanup test, design, review, 12-task plan, results report, and the completion plan and review record were internal execution artifacts with machine-specific paths. The one probe-derived test list is inlined into the terminal suite. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * test(movie): keep one portable test suite The Python suite ported the three shell tests' assertions so they run on Windows; both copies were kept and the README mapped one to the other. Keep the portable suite. Drop the one-shot Windows acceptance driver and its browser fixture, which produced evidence rather than regressions, and the never-implemented reserved suite names. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * docs(movie): trim Windows guidance to what the tools need Remove generic shell exit-status recipes and a stills wrapper that the card scene already covers. Keep the gdigrab commands and the verify-on notes short. Reduce the spec to the design: drop execution logistics, host names, and references to deleted files. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * test(movie): keep tool output out of the test log The in-process narration and subtitle tests let the tools' stdout and stderr through to the runner. Capture both and assert the expected diagnostics. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * feat(movie): simplify the Windows terminal recorder to serve/run/key/watch/close Windows has no tmux, so the recorder had grown into a 738-line daemon with a file-based request protocol, request IDs, wait-only result retrieval, and a Win32 Job Object module. Replace it with the Unix route's shape: serve keeps ttyd and a headless browser alive and logs the terminal's output; run, key, watch, and close are one-shot CDP calls against that browser. The installed prompt reports each command's status through the window title, so run can print it without any visible marker. Process cleanup uses taskkill /T (a pgrep walk on Unix) instead of Job Objects, which also simplifies the card renderer. The session tests run on macOS too, since nothing in the script is Windows-specific. Verified: 9 session tests per shell on Windows 11 for PowerShell 5.1, PowerShell 7, and Git Bash; the browser suite with Chrome and Edge; 44 portable tests on macOS against a real ttyd session. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * feat: add diagnosing-superpowers skill Evidence-based diagnosis of superpowers sessions: intake with the human partner, safe transcript reading for Claude Code and Codex (discovery procedure for other harnesses), seven analyst subagents, a report with path:line evidence and a bounded superpowers-involvement line, scrubbed export bundles, approval-gated GitHub issue search/draft, and similar-session search. Includes spec, plan, structure test, and README and docs index lines. Developed RED-GREEN-REFACTOR per writing-skills: 46 scored scenario runs across five SKILL.md versions, all twelve scenarios clean against the final version, micro-tests control 5/5 to skill 0/5 on both baseline-failing prohibitions, and one end-to-end run. Eval records are kept by the maintainer outside the repo. Claude-Session: https://claude.ai/code/session_01DyaGKhTXvHNs2JgPhDktz7 * docs: add 'When Something Goes Wrong' README section for diagnosing-superpowers * diagnosing-superpowers: build the scrubbed bundle only on request Never build or push a bundle unprompted. When intake names a bug report as the goal, say once that a bundle is available on request, then wait. On handover, state what the bundle contains, point at the scrub log, and say scrubbing can miss things so every file needs review before sharing. Raise the SKILL.md word budget to 1000 to fit the added rule. * diagnosing-superpowers: share the analyst preamble and context-safety rules The seven analyst prompts opened with an identical 39-line block (role, inputs, context safety, return format). It now lives once in prompts/analyst-common.md and each dimension prompt points at it. The wc -lc / long-line / never-cat rule was restated in nine places; it now lives in references/context-safety.md and everything else points there. Addresses arittr's review on #2236. * diagnosing-superpowers: drop gh; file issues through a prefilled template link A default gh login carries the repo scope, which is write access to every repository the user can reach. The skill now searches issues through the unauthenticated public API and, instead of posting, hands the partner a prefilled new-issue link. The link uses a new diagnosis_report.md issue template so the bug and automated-issue-report labels apply regardless of the reporter's permissions. Addresses arittr's review on #2236. * diagnosing-superpowers: say 'plan step', not 'commitment' In a transcript full of git commits, 'commitment' and 'committed to' read as version control. The plan-adherence and quality-evidence prompts now say 'agreed plan' and 'plan step'. * spec: 'agreed to', not 'committed to', in the plan-adherence summary * diagnosing-superpowers: writing review fixes Move GitHub search and prefilled-link mechanics to references/github-issues.md. State the redaction levels neutrally instead of nudging toward more data. Say that all seven analysts always run and what the quick-reference table is for. Add a title slot and a bundle slot to the issue template. Drop the duplicated human-prompts rule from request-conflicts. Prose fixes: active voice, dangling modifier, vague referents, two lists turned into tables. * diagnosing-superpowers: use gh for issue search and creation gh handles auth, rate limits, and JSON, and the approval gate on the exact issue text already covers posting. Keep the public-API and prefilled-link paths as fallbacks for machines without gh. Note that GitHub drops labels from reporters without push access, so the template footer is the durable marker of a skill-filed issue. * Use shared session discovery in diagnosing-superpowers At Drew's request, apply the evaluated shared-discovery variant to Jesse's existing PR #2236. Resolve native session sources and record semantics from available tools, documentation and bounded inspection. Record verified absolute paths, linkage, extraction queries, human-message distinctions, usage-counter semantics and uncertainty once in the case for all analysts to consume. Replace the three per-harness references and update structural checks. This is exactly the evaluated source tree at 3f0a63e860d4719397e584e90cc7af07a247cb6d, applied as one commit on 801badbf719f4044c97175e5b01fb6f7cbc32c2d. Fourteen files change; 126 lines added, 285 removed. No private eval fixtures or transcripts ship. Validation: - Structural test: 45 passed, 0 failed before and after application. - Staged tree exactly matches the evaluated candidate; diff check passes. - Independent read-only review: no actionable blockers. - Retained before/after full doctor runs: one pair each on native Claude, Codex and Pi. All six delivered reports and completed seven dimensions. Shared discovered all three native session families without the removed references. Both versions had report-quality defects; shared Codex deleted its cited case through a fixture symlink. Preserve this negative result. - Eight fresh Codex follow-ups: original/shared x symlink/ordinary-home x two repeats, one retained historical session family. All eight retained cases and supported the four core findings. Seven native final deliveries; one shared run stopped on provider capacity after writing its report. No deletion recurred. One original reused three analysts for seven tasks. Recorded follow-up cost $34.8617883, all eight attempts accounted for. These observations support this scoped simplification, not general equivalence or a causal claim that reference removal caused or could not cause a failure. Child assignment/model choices were native behavior; the complete variants also differ in analyst prompts. Common provenance, citation-verification and measurement problems remain separate follow-ups. No new paid runs were made for this publication; evidence and independent audits are retained privately by Drew. Behavioral evaluation provenance: campaigns 358c7333-c5f0-48bd-a733-61196da992ed and 102d630d-30ef-49a0-97e1-8dd410ed0548. Prepared with GPT-6 using Codex through Paseo; local codex-cli 0.153.4. Skills used: superpowers writing-skills, using-git-worktrees, requesting-code-review, verification-before-completion; primeradiant-ops linear-ticket-lifecycle. Drew approved publishing this evaluated variant. Enabled plugins in the publishing checkout's Codex configuration: - github@openai-curated - documents@openai-primary-runtime - spreadsheets@openai-primary-runtime - presentations@openai-primary-runtime - primeradiant-ops@primeradiant - slack@openai-curated - linear@openai-curated - codex-security@openai-curated - pdf@openai-primary-runtime - template-creator@openai-primary-runtime - sites@openai-bundled - visualize@openai-bundled - computer-use@openai-bundled - cloud-build@superpowers-cloud-build - browser@openai-bundled - superpowers@superpowers-dev - stream-deck-agents-codex@drew-local - computer-history@openai-bundled - codex-app-tools@openai-bundled - unified-computer-use@openai-bundled - chrome@openai-bundled - bits-and-bolts@mcp-extensions-early-access - visual-probe@visual-probe-local Tracking: PRI-3127 * Preserve diagnostic evidence through doctor export Align scrubber and independent audit prompts around one shared redaction policy while preserving safe command, result, source, session-line, quotation, and linkage structure. Add finished-handoff evidence and reconciliation instructions, provenance labels across case/report/bundle/issue templates, and the structural existence check for the shared reference.\n\nThis patch responds to the retained negative post-report handoff baseline: cited result bodies were removed wholesale, source findings and the positive related-session match were not verifiable, provenance and export statements were stale, and scrub counts disagreed. The behavioral handoff validation remains pending for the follow-up task; this commit records only the focused product guidance and structural RED/GREEN evidence. * Clarify scrub audit return contract Remove the obsolete CLEAN branch beneath the audit prompt's Otherwise return instruction. CLEAN remains governed by the preceding no-misses condition, and MISSED is now the only alternative. Verified with the focused structural test and git diff --check. * fix(movie): preserve rejected narration and prior takes Prevent failed narration scenes from entering the cache manifest, while leaving their generated WAV files available as failure evidence. Add filesystem-backed regressions covering repeated rejected chat synthesis, accepted-scene reuse, and strict ASR rejection of cached audio. Refuse nonempty recording directories both before CLI session side effects and at the direct film boundary. The regression preserves existing numbered frames and a sentinel byte-for-byte across run, key, watch, and direct film refusal. Make subtitle capability tests independent of the host FFmpeg installation, skip the real pixel test before probing unavailable tools, retain strict skipped-capability rejection, and remove only the unused websockets runner dependency. * docs(movie): make native Windows recorder recipes executable Replace the Git Bash PowerShell shorthand with complete native commands, explicit path conversion, a kept-alive serve task, bounded readiness, and run/key/watch/close examples. Use native input and sleep commands so the recipe works without a sample app. Explain empty take directories and PowerShell 5.1 embedded-quote escaping observed in native trials. The original PowerShell missing-cwd finding does not reproduce when the session is nested under the working directory; retain the successful baseline and describe explicit directory creation as setup clarity. Fresh readers exercised the final recipes on native PowerShell 5.1, PowerShell 7, and Git Bash. Preserve the failed first candidate and driver setup failures, distinguish instruction trials from full skill evaluation, and keep movie acceptance with Drew. Record Drew's approval of the normal workflow dependencies and the bounded repair plan. * Fix narration cache identity and partial subtitle offsets Address the fresh review on PR #2214 after the #2275 integration. Drew approved fixing the two reproduced bugs and keeping the specified auto/on/off verification semantics. Cache accepted narration by normalized text plus effective engine, voice, and synthesis model. Resolve voice defaults before rendering, invalidate entries without settings, and retain requested ASR checks on cache hits. Exclude rejected clips as before. Treat manual subtitle offsets as start-time overrides. Only assembly offsets JSON selects scenes in the cut, including when manual timing overrides are also supplied. Empty narrated cuts write an empty SRT without crashing. Make the gated Unix example pass --verify on and document the actual local ASR modes. Auto remains permissive if ASR is unavailable; on remains strict. Validation: observed the new cache and subtitle regressions fail before the fixes; all 23 focused narration and subtitle-text tests now pass. Synthesis, duration probing, and ASR are mocked. No media inspection or live ASR was performed; Drew retains final video acceptance. * Fix inserted narration and movie audio subtitle checks Address the final three review findings on PR #2214, as approved by Drew. Count both sides of every non-equal transcript span so a short insertion or expanded replacement cannot evade the drift gate on a longer script. Preserve the existing length and run thresholds. Honor --no-expect-audio for encoded silent tracks. Base subtitle requirements on detected audible speech so opting out of expected audio does not suppress captions for speech that is present. Extract the first embedded subtitle stream as SRT when no sidecar is present and apply the same cue-end check to either source. Empty cues fail even for short narration, and extraction or malformed timing errors are reported as failures. Preserve the silent end-card allowance. Validation: the new tests first reproduced ten failing cases across narration insertion, silent-track opt-out, and embedded subtitle handling. All 35 focused narration, checker-policy, and subtitle-text tests now pass. External media commands, audio and picture sampling, contact-sheet creation, synthesis, and ASR were mocked; no actual media inspection or live ASR was performed. Drew retains final video acceptance. * docs: plan consolidated movie committee repairs Drew requested a whole-PR committee review after repeated narrow fixes missed failures. Record the repair boundaries, acceptance handoff, timing and lifecycle contracts, and focused regression cases before implementation. Preserve existing artifact formats and Drew-owned video acceptance; all automated checks in this pass use mocked media boundaries. * fix(movie): make narration acceptance govern assembly Repair Task 1 from the 2026-09-11 movie committee plan. Narration now atomically withdraws acceptance before it mutates accepted bytes, stages failed takes as retained evidence, and publishes a manifest entry only after transcript gates and duration measurement. It preflights ffprobe, preserves bounded retries and cache identity, and distinguishes unsupported token comparison from cache identity. Assembly now validates accepted manifest narration before it starts encoding, ignores generated narration for movie scenes, selects manifest WAV paths, maps source or synthetic movie audio explicitly, fits wide movies within the requested inner rectangle, and escapes only literal directory percent signs in sequence paths. The focused regression suite mocks every media boundary; real-media fixture declarations are updated but not executed. Prompt constraints prohibit real media generation, probing, inspection, synthesis, ASR, browser, checker, or full media suites. * fix(movie): retain narration evidence through verification Address Task 1 review round 1. Treat successful empty ASR output as speech failure rather than an unavailable verifier, reject empty chat claims within the existing bounded retry loop, and extend unsupported segmentation detection to supplementary CJK ideographs. Withdraw cached acceptance before every revalidation so strict failures and interrupts cannot leave stale publication. Preserve nested manifest WAV paths on cache reacceptance, and measure a unique candidate before promotion so duration failures retain their evidence across reruns. Add structured movie geometry coverage plus both silent and source-audio mapping tests. All tests use uv --no-project with mocked synthesis, ASR, probes, and encoding; no media operation was run. * test(movie): cover unsupported ASR and ordinary retries Close Task 1 review round 2 without production changes. Feed actual unsupported ASR text through auto and strict verification while proving off does not call ASR. Run the second rejected narration invocation without --force, then assert it synthesizes new takes and retains distinct rejected bytes instead of reusing cache evidence. * fix(movie): keep subtitle timing and track selection faithful Implement Task 2 of the movie committee repairs. Allocate proportional cue boundaries across each complete rounded scene interval, reserve positive millisecond spans, and coalesce chunks when the available interval cannot represent them separately. Readability limits guide word splitting without dropping text or clipping narration tails; invalid intervals fail before subtitle output is written. Explicitly select the supplied soft subtitle track with optional source audio, including the hard-burn fallback. Parse only numbered SRT cue timing lines so arrow-bearing captions cannot crash the checker or inflate coverage. Preserve the existing maximum cue end policy, assembly-offset intersection, and partial manual retiming. Add 17 safe subtitle contracts and register the contracts runner suite. Real-file mocked narrate/assemble/subtitle reruns retain removed narration WAV evidence while omitting stale assembly audio and offsets. Verification: 41 contract tests and 18 authorized existing regressions pass; only text and mocked media boundaries were exercised. Native Windows and human video acceptance remain outside this verification. * fix(movie): refine subtitle chunks using allocated durations Address Task 2 review round 1: initial character budgets count spaces that disappear between chunks, so proportional timing can exceed --max-secs even when a further word-boundary split is feasible. Reallocate after splitting an over-target multiword cue, checking actual integer millisecond intervals each time. Coalescing runs once before refinement, and refinement stops at the available millisecond count or unsplittable words. This keeps tiny impossible readability targets bounded while preserving every word and the full measured scene interval. Added a failing six-second unequal-chunk regression and a tiny-target termination/positive-interval guard. The RED emitted 3273 ms for a cue with a 3000 ms target. GREEN: 43 safe contract tests and six covering existing offset/BOM tests pass. All verification remained text/data or mocked media boundaries. * fix(movie): own recorder cleanup and bound observation Implement Task 3 of the consolidated PR 2214 movie repairs. Startup failures could leak an already launched ttyd or browser because acquisitions preceded the cleanup block; close killed historical numeric PIDs and reported success without confirmed cleanup. Register each acquired resource inside serve's try/finally, invalidate readiness on shutdown, retain logs, and atomically retire PID metadata only after confirmed owned-process and profile cleanup. Close now requests stop and waits under one overall 30-second deadline without killing PIDs. Poll CDP and owner readiness while observing commands without recording, preserving a completed native exit status across simultaneous disconnects and reserving exit 2 for live unfinished commands. Fill only bounded 5 fps slots when a final capture crosses the hard or hold endpoint, correctly strip ST-terminated OSC titles, and emit ASCII-escaped stdout JSON while preserving UTF-8 session files. A serve-only CDP call-boundary check prevents a stop from waiting through multiple consecutive calls. Add 21 contract tests using fake processes, fake websocket responses, fake clocks, byte-token capture callbacks, and intercepted frame writes. Register real-session test cleanup immediately after Popen and retain live PID snapshots, but do not execute that fixture. RED evidence and implementation report are in .superpowers/sdd/2026-09-11-movie-committee-repairs/task-3-report.md. Validation: 26/26 authorized prompt, serve-argument, and recorder contract tests pass; git diff --check passes. No media generation, inspection, browser/ttyd launch, real session or frame-grid suite was performed. Native movie acceptance remains Drew's review; an abruptly hard-killed owner with a live browser and stale readiness remains the agreed limitation. * fix(movie): retain incomplete cleanup and command evidence Address both independent Task 3 review findings at 42486dbb. When an owned leader exits before tree cleanup, the existing parentage helper cannot confirm orphan descendant cleanup. Treat that state as incomplete, preserve PID metadata, return failure, and never invoke the helper on the exited leader's numeric PID. Continue releasing the other owned resources without adding descendant tracking. Keep a recording capture failure truthful while preserving available completed command evidence: outcome remains failed, exit status remains 1, and the capture error is retained alongside ok, native exit_code, and cwd. A completed successful command does not make a failed recording successful, and no successful take manifest is published. TDD regressions reproduced an exited leader incorrectly returning 0 and capture failures dropping completed native status for exits 0 and 7. All 14 covering lifecycle and observation tests pass using fake process handles, fake clocks, mocked capture/log boundaries, and intercepted media writes; git diff --check passes. No real media generation or inspection, process/browser launches, SessionTests, FilmGridTests, or full media suites were executed. Detailed RED/GREEN evidence is appended to .superpowers/sdd/2026-09-11-movie-committee-repairs/task-3-report.md. * docs: make proof-movie recipes preserve failures Repair the shipped Unix, logging, subtitle, cursor, narration, and recorder guidance against the literal fake-boundary failures recorded for Task 4. The primary pipeline and subtitle recipe now fail fast, measured offsets reach subtitle generation, producer logging preserves the real status under the pipefail owner, and cursor mouseup restores the released state. Document the accepted narration/cache contract, cooperative recorder cleanup limits, and the safe contracts-suite entrypoint without changing Windows recipes or the existing evidence and human-viewing gates. Include the controller-owned plan bookkeeping and record the executable RED/GREEN results while leaving independent fresh-reader trials pending. Prompt: implement Task 4 focused executable movie-guide corrections after Tasks 1-3, using writing-skills and only fake producers, text fixtures, and fake DOM execution. Verification: python3 .superpowers/review/pr2214/committee/recipe-probes.py; uv run --script tests/proving-it-works-with-a-movie/run-tests.py --suite contracts; git diff --check. * docs: record consolidated movie repair verification Complete the four-task repair plan after independent reviews and two fresh-reader reference trials. Record 66 current contract tests and 45 existing safe regressions, executable recipe failures and repairs, and the limits of those checks. Drew requested a committee and full local review after repeated PR feedback. Preserve the negative evidence, distinguish historical native runs from current mocked/text checks, and retain Drew's video viewing as final acceptance. The whole accumulated PR review and authorized existing-branch update remain the next steps; no merge is performed. * Reject invalid chat transcripts and propagate browser cleanup failures Address the two final whole-PR findings from the consolidated movie repair brief. A fresh openai-chat response must provide a speech-bearing string transcript even when local ASR is off; null must not reuse the no-transcript sentinel belonging to deterministic engines or cached accepted audio. Preserve the bounded candidate loop and rejected-byte evidence. Report failed Windows tree termination as OSError so the recorder owner's existing per-child handler continues all cleanup and retains failure metadata. Card rendering checks its acquired browser handle before acting on the PID, propagates wait failure, and reports locked-profile removal instead of allowing a pending successful return to hide incomplete cleanup. Add fake HTTP/process/filesystem boundary regressions for both findings, including real adapter invocation, accepted chat cache reuse, ASR modes, normal completed cards, and serve cleanup after a failed leader later exits. Correct the rejected-chat fixture to use the chat engine. No media or native browser execution was performed; Drew retains personal video acceptance. Validation: expected RED failures retained; 40 focused tests and the single 75-test contracts entrypoint pass. Full evidence and self-review are in .superpowers/sdd/2026-09-11-movie-committee-repairs/final-fix-report.md. * fix(opencode): align V2 tool mapping with the 2.0.3 catalog; harden plugin internals - V2 bootstrap mapping now teaches write/edit/websearch (verified against a live v2.0.3 /api/plugin tool catalog) instead of routing all file mutation through patch - frontmatter parser tolerates CRLF and YAML block scalars/continuation lines - child-session cache is bounded (512 entries, oldest-quarter eviction) - INSTALL.md and docs/README.opencode.md tool tables synced to the 2.0.3 catalog; unit-test needle list extended to cover the new tools * Invoke bundled scripts through their interpreter in skill prose Plugin packagers for other harnesses can strip executable bits from the files they ship. The Codex marketplace cache delivered the SDD helpers as 0644 (#2040), and the MiniMax Code marketplace ships its repackaged copy of our skills tree with every file at mode 600. On those installs every bare invocation in our skill prose -- `scripts/start-server.sh ...`, `scripts/review-package ...`, `./find-polluter.sh ...`, `./render-graphs.js ...` -- fails with "Permission denied", so the brainstorming visual companion, subagent-driven development, the polluter bisection helper, and render-graphs are all broken there even though the repo records the files as 100755. Spell every script invocation in skills/**/*.md through its interpreter instead: `bash` for the shell scripts (start-server.sh, stop-server.sh, sdd-workspace, task-brief, review-package, find-polluter.sh) and `node` for render-graphs.js, per each script's shebang. That form works whether or not the exec bit survived packaging. The MiniMax Code marketplace package independently applied exactly this edit to its copy of v6.2.0; this brings the same pattern upstream so every packager gets it. Nothing else in the prose changes. #2134 covers the complementary case of a script exec'ing a sibling script (task-brief and review-package calling sdd-workspace) and is still needed alongside this. Record the rationale in docs/porting-to-a-new-harness.md (Part 6 distribution notes plus an Appendix B gotcha) and add a one-line note to writing-skills' File Organization section so future skill authors don't strip the prefixes. Refs #2040, #2134. * fix(opencode): register skills with Skill.Info 2.0.4 path field; contain per-skill add failures Reported on PR #2106 (80avin): on OpenCode v2.0.4 the plugin is disabled at startup with "Plugin disabled after skill.transform failed", losing both skill registration and bootstrap injection. Root cause: upstream commit 199aabe9e2 (first released in v2.0.4) renamed Skill.Info's required file field `location` -> `path` and removed `slash`. draft.add() decodes payloads with Schema.decodeUnknownSync against that schema, so our `location` payloads now fail decode with "Missing key path". Why the failure was silent: the decode error is thrown during the host's state rebuild, where the State layer catches it and hard-disables the whole plugin group asynchronously - the throw never reaches the try/catch around ctx.skill.transform(), and the session "context" hook is torn down as collateral. Fix: - skill payloads now use `path` (2.0.4 contract); no v2.0.3 compatibility retained per review decision - draft.add() failures are contained per skill inside the transform callback, so one rejected payload skips that skill (visible in server logs) instead of the host disabling the entire plugin - new test-skill-registration unit test pins the 2.0.4 payload contract (absolute path field, no stale location/slash, hostile-add containment) and is registered in run-tests.sh; full suite 3/3 green * fix(sdd): ownership markers stop same-basename plans sharing a workspace sdd-workspace slugged workspaces by basename alone, so docs/alpha/plan.md and docs/beta/plan.md resolved to one directory and task-brief silently overwrote the other plan's brief — the single gitignored source of task requirements, unrecoverable once clobbered. Each workspace now records its owning plan in a plan-path marker (repo-relative in-repo, absolute outside). Lookup keeps basename slugs and existing behavior for the common case: a markerless workspace is adopted in place (no migration break for in-flight plans), a marker naming this plan is a match, and a marker naming a different plan disambiguates with the plan's parent-directory name, then a counter. Plan paths are normalized (CDPATH-guarded physical cd) so relative, absolute, and ../ spellings of one plan share one workspace. task-brief and review-package delegate to sdd-workspace and need no changes. SKILL.md's workspace bullet no longer promises the exact <plan-basename> path, since disambiguated workspaces differ. Reported by @CRGDan; reproduction and test groundwork by @crisnahine in PR #2120. Fixes #2045 * feat: add native Muse support (multiprovider) Add .muse-plugin/plugin.json (native Muse contract, 16 skills, SessionStart hook) and marketplace.json so the same repo now serves Muse alongside Claude Code, Codex, Cursor, Gemini, Pi, etc. - skills/using-superpowers/references/muse-tools.md: Muse tool mapping - skills/using-superpowers/SKILL.md: list Muse in Platform Adaptation - hooks/session-start: handle MUSE_PLUGIN_ROOT (SDK standard additionalContext) alongside CURSOR/CLAUDE/COPILOT branches - .version-bump.json: track .muse-plugin/plugin.json and marketplace - README.md: add Muse to TOC and Installation with muse plugins install instructions - AGENTS.md: convert symlink -> regular file copy to satisfy Muse validator (symlink entries rejected as installable) Validated: muse plugins validate => valid:true (diagnostics=1 for expected multiple-manifests warning), all 16 skills validate true. Co-Authored-By: Muse Spark * fix: Muse SessionStart hook must use nested hookSpecificOutput muse-spark-1.3-contributor rejects top-level additionalContext on SessionStart ("unsupported additionalContext in output"). Switch Muse branch to Claude-style nested {hookSpecificOutput:{hookEventName, additionalContext}} which validates and injects correctly (tested via muse exec --provider meta hello world -> success, no hook failed). Co-Authored-By: Muse Spark * docs: fix Muse README to include approve and correct install path README previously showed muse plugins install ./.muse-plugin and muse marketplace add (missing plugins prefix) and omitted the required hooks approval step. Muse warns "hooks require review before activation" on install; fix to muse plugins install ./ + muse plugins approve superpowers per installed flow validated with muse-spark-1.3. Co-Authored-By: Muse Spark * docs: expand Muse section to parity with other harnesses Add clone+install variant, update command, restart/verification notes, and SessionStart hook detail to match Gemini/Pi/Hermes depth. Keeps same install path (muse plugins install ./ + approve) validated with muse-spark-1.3. Co-Authored-By: Muse Spark * Add Claude Code platform reference: a nested orchestrator for cheaper subagent-driven development * docs(testing): describe the Quorum eval lab accurately, replacing stale Drill references The evals harness was renamed Drill -> Quorum and rewritten from Python/uv to Bun/TypeScript; docs/testing.md and CLAUDE.md still described the old tool. Beyond the rename, the old text also misdescribed the system: quorum is the harness CLI, one part of the eval lab — it drives real coding-agent CLIs through a Gauntlet QA agent and grades against scenario acceptance criteria plus deterministic post-checks. The quick start now matches the eval repo's actual commands (bun install / bun run quorum run scenarios/<name> --coding-agent claude; scenarios are directories, not *.yaml) and points at the Live Eval Risk section before anyone runs a permissive-mode session. Drift reported in closed PR #2121 (@JFWaskin); that PR's replacement quick start kept the uv commands, so this rewrite goes from the eval repo's README instead. * Rebuild executing-plans as a first-class inline execution mode A cheaper execution mode alongside subagent-driven development: the session implements every task itself under the same workspace, ledger and stopping rules, with one fresh whole-branch review on the most capable model at the end. Helper scripts task-start/task-done keep the ledger and test log honest; the final fix pass re-grades findings and fixes Critical/Important under TDD. writing-plans' handoff, SDD's when-to-use text and two README lines change to match. * Reviewer judges the spec as a vision document; plans list the five implied cases most likely to bite code-reviewer.md: behavior the spec is silent on is graded by what a reasonable person using the software expects, and a 'Declined to judge' list makes every scoping decision visible. writing-plans: a Review Focus section names the five implied input classes or failure modes most likely to bite, each pinned by a test in the owning task. executing-plans hands the section to the final reviewer and rules on every declined line. * docs: replace duplicated agent guidelines with CLAUDE.md pointer * docs: make AGENTS.md the canonical contributor guidelines * test(opencode): cover canonical skill paths and registration survival * fix(opencode): retry unsuccessful child-session lookups * fix(opencode): retain bootstrap after native compaction * docs(opencode): describe supported V2 setup and bootstrap behavior * docs: clarify OpenCode V1 and V2 skill behavior * chore(opencode): mark test-skill-registration.sh executable Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * test(opencode): cover bootstrap placement when native compaction retains user messages Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * fix(opencode): strip quote pairs after joining multi-line frontmatter values Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * fix(scripts): exclude root index.js from the Codex plugin sync Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * docs(opencode): fix pin example, local-path examples, and V2 log troubleshooting Restore the version-pin example for both config keys and state the V2 constraint (the pinned ref must include OpenCode V2 support). Replace the `~/...` local-package examples with absolute paths: OpenCode does not expand `~`, and a tilde entry is installed as a package spec rather than loaded as a directory. Point V2 troubleshooting at `opencode run --standalone --print-logs`, since plugin logs are server-role and hidden without `--standalone`. Describe where the bootstrap lands when native compaction retains user messages under the default keep budget. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * docs: draft release notes for v6.4.0 (#2327) * docs: draft release notes for v6.4.0 * docs: tighten v6.4.0 release notes Set the release date, add a lead paragraph, call out the removed batch checkpoints, unify the Native/inline naming, and replace internal jargon. Correct the TDD probe figure and the Claude Code nested-orchestrator opt-in to match #2110 and the reference doc. Claude-Session: https://claude.ai/code/session_01PRUnVUm4g4EcP9eNjAiT2B * docs: spell out movie skill dependencies in v6.4.0 notes Claude-Session: https://claude.ai/code/session_01PRUnVUm4g4EcP9eNjAiT2B * docs: note AGENTS.md as the canonical guidelines in v6.4.0 notes * docs: name new harnesses in v6.4.0 summary Claude-Session: https://claude.ai/code/session_01PRUnVUm4g4EcP9eNjAiT2B * docs: list OpenCode 2.0, Muse, and Qwen Code as new harnesses in v6.4.0 Move the Claude Code nested controller note under Subagent-Driven Development. Claude-Session: https://claude.ai/code/session_01PRUnVUm4g4EcP9eNjAiT2B * docs: reword v6.4.0 harness summary Claude-Session: https://claude.ai/code/session_01PRUnVUm4g4EcP9eNjAiT2B * test(movie): expect 8 frames from the slow-capture film test (#2329) 42486db made film() fill every grid slot before the endpoint, but this test kept its old count of 7. Its fake clock advances 0.01 s per capture and 0.02 s per sleep, so the prompt is seen at 1.01 s, the 0.4 s hold ends at 1.41 s, and slots 0.0-1.4 s make 8 frames. The test has failed on every run since 42486db. * chore: bump version to 6.4.0 (#2330) Release engineering for 6.4. * Revert movie skill import (#2214) (#2335) Remove the proving-it-works-with-a-movie import at Drew Ritter’s request because its code quality does not meet the release bar. Reverts merge dd53fe0b57223bbbbb8ceae0bda2ba8a26d1c29a and the dependent movie test adjustment in 3979a17bda8691d72bfc5963e5437174c399db67. Remove the later Muse registration and update the unreleased notes so neither advertises the removed skill. Version changes are left for a separate release step. * docs(release-notes): retitle unreleased v6.4.0 notes as v6.4.1 v6.4.0 was prepared but never shipped (release PR #2331 closed unmerged, no tag). The next release is v6.4.1. Rename the section and open it with a note saying v6.4.0 never shipped and that v6.4.1 holds back the proving-it-works-with-a-movie skill for cleanup and robustness work before it returns. The note replaces the revert paragraph added in #2335. Version bumps are left for the release step. Claude-Session: https://claude.ai/code/session_01PRUnVUm4g4EcP9eNjAiT2B * chore: bump version to 6.4.1 v6.4.0 was never shipped; 6.4.1 is the first release with these changes. Points the OpenCode V2 pinning docs at v6.4.1, since no v6.4.0 tag will exist. Excludes the gitignored evals/ clone from the version audit, which was grepping all 11G of it and never finishing. Claude-Session: https://claude.ai/code/session_01BJAzd3A26a2XKo1JUJWySu * docs: fix Muse table of contents indentation --------- Co-authored-by: Drew Ritter <drew@primeradiant.com> Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Co-authored-by: Ada Sen <ada@sen.dev> Co-authored-by: Gaurav Dubey <gauravdubey0107@gmail.com> Co-authored-by: arimu1 <19286898+arimu1@users.noreply.github.com> Co-authored-by: Mark Rada <markrada26@gmail.com> Co-authored-by: dev_Hakaze <af.nawfal@gmail.com> Co-authored-by: Cursor <cursoragent@cursor.com> Co-authored-by: kumarabd <kumarabd@users.noreply.github.com> Co-authored-by: Drew Ritter <drew@ritter.dev> Co-authored-by: Kattni <kattni@kattni.com> Co-authored-by: GoldJohnKing <GoldJohnKing@live.cn> Co-authored-by: Georgii Perepechko <georgiiperepechko@gmail.com> Co-authored-by: Caio Lopes <caiodesalopes@gmail.com> Co-authored-by: Drew Ritter <arittr@users.noreply.github.com> Co-authored-by: Ada Sen <ada.sen@primeradiant.com>
Diffstat (limited to 'docs')
-rw-r--r--docs/README.opencode.md125
-rw-r--r--docs/porting-to-a-new-harness.md16
-rw-r--r--docs/superpowers/plans/2026-08-27-diagnosing-superpowers.md1512
-rw-r--r--docs/superpowers/specs/2026-08-27-diagnosing-superpowers-design.md530
-rw-r--r--docs/testing.md20
5 files changed, 2171 insertions, 32 deletions
diff --git a/docs/README.opencode.md b/docs/README.opencode.md
index 11da854..f6c2f5e 100644
--- a/docs/README.opencode.md
+++ b/docs/README.opencode.md
@@ -4,7 +4,11 @@ Complete guide for using Superpowers with [OpenCode.ai](https://opencode.ai).
## Installation
-Add superpowers to the `plugin` array in your `opencode.json` (global or project-level):
+OpenCode V2 requires version 2.0.4 or later.
+
+### OpenCode V1
+
+Use the existing V1 plugin configuration:
```json
{
@@ -12,15 +16,27 @@ Add superpowers to the `plugin` array in your `opencode.json` (global or project
}
```
-Restart OpenCode. The plugin installs through OpenCode's plugin manager and
+### OpenCode V2 (2.0.4 or later)
+
+Use the V2 plugin configuration:
+
+```json
+{
+ "plugins": ["superpowers@git+https://github.com/obra/superpowers.git"]
+}
+```
+
+For a local V2 installation, configure the repository directory containing
+`index.js`. OpenCode 2.0.4 and 2.0.7 reject a configured direct JavaScript-file
+path. Discovered plugin symlinks remain supported.
+
+Restart OpenCode. V2 uses the `opencode` command; `opencode2` may be available
+as an alias. The plugin installs through OpenCode's plugin manager and
registers all skills.
Verify by asking: "Tell me about your superpowers"
-OpenCode uses its own plugin install. If you also use Claude Code, Codex, or
-another harness, install Superpowers separately for each one.
-
-### Migrating from the old symlink-based install
+### Migrating from the old symlink-based install (V1)
If you previously installed superpowers using `git clone` and symlinks, remove the old setup:
@@ -78,7 +94,10 @@ description: Use when [condition] - [what it does]
Create project-specific skills in `.opencode/skills/` within your project.
-**Skill Priority:** Project skills > Personal skills > Superpowers skills
+**V2 Skill Priority:** Project skills > Personal skills > Superpowers skills. On
+tested V1 1.18.31, bundled Superpowers skills take precedence when a personal
+or project skill has the same name; use distinct names for personal and project
+skills. This behavior is unchanged by the migration.
## Updating
@@ -87,24 +106,45 @@ and Bun versions pin that resolved git dependency in a lockfile or cache, so a
restart may not pick up the newest Superpowers commit. If updates do not appear,
clear OpenCode's package cache or reinstall the plugin.
-To pin a specific version, use a branch or tag:
+To pin a specific version, add a tag or commit to the spec (same form for the
+V1 `plugin` key and the V2 `plugins` key):
```json
{
- "plugin": ["superpowers@git+https://github.com/obra/superpowers.git#v5.0.3"]
+ "plugin": ["superpowers@git+https://github.com/obra/superpowers.git#v6.4.1"]
}
```
+On V2, pin `v6.4.1` or later; `v6.3.0` and earlier releases load only on V1.
+
## How It Works
-The plugin does two things:
+The plugin does two things, using host-flavor-specific APIs:
+
+1. **Registers the skills directory** so OpenCode discovers all superpowers skills without symlinks or manual config.
+ - **V1:** via the `config` hook, injecting into `config.skills.paths`
+ - **V2:** via the `setup()` function using `ctx.skill.transform()` (V2 native API, confirmed active at runtime)
+2. **Injects bootstrap context** with a flavor-specific tool mapping: V1 sessions get the V1 tool names below, and V2 sessions get the V2 names.
+ - **V1:** via `experimental.chat.messages.transform` hook
+ - **V2:** via `ctx.session.hook("context")` — the V2 equivalent (confirmed active at runtime)
-1. **Injects bootstrap context** via the `experimental.chat.messages.transform` hook, adding superpowers awareness to every conversation.
-2. **Registers the skills directory** via the `config` hook, so OpenCode discovers all superpowers skills without symlinks or manual config.
+Controller sessions receive the using-superpowers bootstrap in transient model
+context. Delegated child sessions keep access to native skills but do not receive
+the controller bootstrap. A manual fork without a parent session keeps controller
+behavior. When V2 native compaction retains earlier user messages (the default
+`compaction.keep.tokens` budget), the bootstrap goes into the first retained user
+message ahead of the checkpoint, as in an uncompacted session. When compaction
+removes all user messages, the plugin appends a transient bootstrap message after
+the checkpoint. Saved history is unchanged either way.
+
+If session lookup fails, the plugin keeps bootstrap for that request and retries
+on the next request. Failed lookups are not cached as controller decisions.
### Tool Mapping
-Skills speak in actions rather than naming any one runtime's tools. On OpenCode these resolve to:
+Skills speak in actions rather than naming any one runtime's tools. The bootstrap maps them to the tools your OpenCode flavor actually exposes.
+
+**V1 (`opencode` 1.x):**
- "Create a todo" / "mark complete in todo list" → `todowrite`
- `Subagent (general-purpose):` template → OpenCode's `task` tool with `subagent_type: "general"` (or `"explore"` for codebase exploration)
@@ -115,15 +155,43 @@ Skills speak in actions rather than naming any one runtime's tools. On OpenCode
- "Search file contents" / "find files by name" → `grep`, `glob`
- "Fetch a URL" → `webfetch`
-(Verified against the installed OpenCode CLI's tool inventory.)
+**V2 (`opencode` 2.0.4 or later; `opencode2` may be available as an alias):**
+
+- "Create a todo" → V2 has no todo tool of any kind; the mapping tells the model to track the plan in a markdown file (or the harness's plan facility) instead
+- `Subagent (general-purpose):` template → OpenCode's `subagent` tool with `agent: "general"` (or `"explore"`); pass `sessionID` to continue a previous subagent
+- "Invoke a skill" → OpenCode's native `skill` tool
+- "Read a file" → `read`
+- "Create, edit, or delete files" → use `patch` with `patchText` when available; otherwise use `write` to create or overwrite files, `edit` for targeted changes, and `shell` for deletion
+- "Run a shell command" → `shell` (`command`, `workdir`, `timeout`, `background`)
+- "Search file contents" / "find files by name" → `grep`, `glob`
+- "Fetch a URL" → `webfetch`
+- "Search the web" → `websearch`
+
+In short, V2 renamed `task` → `subagent` (the agent name moved from `subagent_type` to `agent`, and continuation happens by re-invoking with `sessionID`), `apply_patch` → `patch`, and `bash` → `shell`, and it dropped the todo tool entirely. The available mutation tools depend on the selected model: `patch` is available for selected GPT model IDs, while other models use `write` and `edit`.
+
+(V1 list verified against the installed OpenCode 1.18.x CLI's tool inventory; V2 list verified against the OpenCode 2.0.4 and 2.0.7 host contracts.)
## Troubleshooting
### Plugin not loading
-1. Check OpenCode logs: `opencode run --print-logs "hello" 2>&1 | grep -i superpowers`
-2. Verify the plugin line in your `opencode.json` is correct
-3. Make sure you're running a recent version of OpenCode
+**V1:** Check OpenCode logs:
+
+```
+opencode run --print-logs "hello" 2>&1 | grep -i superpowers
+```
+
+**V2:** Plugins load in the background server, whose logs `--print-logs` only
+shows with `--standalone`:
+
+```
+opencode run --standalone --print-logs "hello" 2>&1 | grep -i superpowers
+```
+
+Or inspect `~/.local/share/opencode/log/opencode.log`, filtering for `role=server`.
+
+Also verify the plugin path in your `opencode.json` is correct and that you're
+running a recent version of OpenCode.
### Windows install issues
@@ -137,11 +205,23 @@ package:
npm install superpowers@git+https://github.com/obra/superpowers.git --prefix "$HOME\.config\opencode"
```
-Then use the installed package path in `opencode.json`:
+Then use the absolute path of the installed package in `opencode.json` for your
+OpenCode version. OpenCode does not expand `~`; a `~/...` entry is treated as a
+package name, not a local directory.
+
+**V1:**
+
+```json
+{
+ "plugin": ["C:\\Users\\<you>\\.config\\opencode\\node_modules\\superpowers"]
+}
+```
+
+**V2 (2.0.4 or later):**
```json
{
- "plugin": ["~/.config/opencode/node_modules/superpowers"]
+ "plugins": ["C:\\Users\\<you>\\.config\\opencode\\node_modules\\superpowers"]
}
```
@@ -153,11 +233,12 @@ Then use the installed package path in `opencode.json`:
### Bootstrap not appearing
-1. Check OpenCode version supports `experimental.chat.messages.transform` hook
-2. Restart OpenCode after config changes
+- **V1:** Check OpenCode version supports `experimental.chat.messages.transform` hook. Restart OpenCode after config changes.
+- **V2:** The plugin uses `ctx.session.hook("context")` for bootstrap injection. Verify the plugin loaded via `opencode api get /api/plugin`. Restart with `opencode service restart` after config changes. The `opencode2` command may be available as an alias.
## Getting Help
- Report issues: https://github.com/obra/superpowers/issues
- Main documentation: https://github.com/obra/superpowers
-- OpenCode docs: https://opencode.ai/docs/
+- OpenCode V2 docs: https://opencode.ai/v2/docs/
+- OpenCode V1 docs: https://opencode.ai/docs/
diff --git a/docs/porting-to-a-new-harness.md b/docs/porting-to-a-new-harness.md
index 4ae9603..ce37418 100644
--- a/docs/porting-to-a-new-harness.md
+++ b/docs/porting-to-a-new-harness.md
@@ -711,6 +711,18 @@ Then:
- If neither works, the harness cannot be cleanly supported yet — **say so**
and raise it, rather than hand-editing the user's config.
+- **Packagers can strip executable bits — skill prose invokes bundled scripts
+ through their interpreter.** Some marketplace packaging and install paths
+ lose Unix file modes: the Codex marketplace cache delivered the SDD helpers
+ as `0644` (#2040, #2134), and the MiniMax Code marketplace ships every file
+ as mode `600`. A bare `scripts/foo.sh` or `./foo.js` in a skill then fails
+ with `Permission denied` on that harness even though the repo's tree records
+ `100755`. So every script invocation in `skills/**/*.md` is spelled through
+ its interpreter — `bash scripts/start-server.sh …`, `bash
+ scripts/review-package …`, `node ./render-graphs.js …` — and a script that
+ runs a sibling script needs the same treatment (#2134). Don't "tidy" the
+ prefixes away, and don't reach for a packaging-side `chmod`: the mode loss
+ happens on the consumer's side, so only the invocation form survives it.
- **Write install docs.** A `docs/README.<harness>.md` and/or a
`.<harness>/INSTALL.md` (see `docs/README.opencode.md` and
`.opencode/INSTALL.md`), plus an install section in the top-level `README.md`.
@@ -790,7 +802,7 @@ Use this as the live index; when in doubt, read the files, not this table.
| Copilot CLI | (shares Claude Code hook path; `COPILOT_CLI` env) | shell hook → `hooks/session-start` (`additionalContext`) | none needed (Claude Code–compatible tool surface) | `tests/hooks/` | — |
| Gemini CLI | `gemini-extension.json` + `GEMINI.md` | instructions file `@`-includes bootstrap + mapping | `references/gemini-tools.md` | — | `gemini extensions install` |
| Kimi Code | `.kimi-plugin/plugin.json` | manifest `sessionStart.skill` loads `using-superpowers` | inline `skillInstructions` in manifest | `tests/kimi/` | marketplace or `/plugins install` GitHub URL |
-| OpenCode | `.opencode/plugins/superpowers.js` (declared via root `package.json` `main`) | in-process: `config` hook registers skills dir; `experimental.chat.messages.transform` injects user message | inline in `superpowers.js` | `tests/opencode/` | `opencode.json` plugin git URL |
+| OpenCode | `.opencode/plugins/superpowers.js` (root `package.json` `main` for package installs; root `index.js` re-export for the V2 directory form) | in-process: `config` hook registers skills dir; `experimental.chat.messages.transform` (V1) / `session.hook("context")` (V2) injects user message | inline in `superpowers.js` | `tests/opencode/` | `opencode.json` `plugin` (V1) / `plugins` (V2) git URL |
| pi | `.pi/extensions/superpowers.ts` | in-process: `resources_discover` registers skills; `context` event injects user message; lifecycle-flag + compaction-aware | `piToolMapping()` inline **and** `references/pi-tools.md` | `tests/pi/` | repo-root `package.json` fields |
## Appendix B — Gotchas that have bitten porters
@@ -822,6 +834,8 @@ Use this as the live index; when in doubt, read the files, not this table.
that mechanism *is* reading `SKILL.md` — say so explicitly in the mapping
(Part 5).
- **`.sh` on Windows.** Keep hook scripts extensionless (Part 7).
+- **Bare `scripts/foo.sh` in skill prose.** Packagers can strip exec bits
+ (Part 6). Invoke bundled scripts as `bash scripts/foo.sh` / `node scripts/foo.js`.
- **Unregistered version.** A new manifest not added to `.version-bump.json`
ships stale (Part 6).
- **Editing skills to fit the harness.** Never. The fix goes in the tool mapping.
diff --git a/docs/superpowers/plans/2026-08-27-diagnosing-superpowers.md b/docs/superpowers/plans/2026-08-27-diagnosing-superpowers.md
new file mode 100644
index 0000000..848e369
--- /dev/null
+++ b/docs/superpowers/plans/2026-08-27-diagnosing-superpowers.md
@@ -0,0 +1,1512 @@
+# Diagnosing Superpowers Skill Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Ship `skills/diagnosing-superpowers`, a pure-prose skill that helps a human partner pin down what went wrong in a superpowers session, reports what happened with `path:line` evidence, and on request exports a scrubbed bundle, files or finds a GitHub issue, and searches for similar local sessions.
+
+**Architecture:** One lean `SKILL.md` (workflow, hard rules, Red Flags) plus one file per subagent job under `prompts/`, per-harness session-store references under `references/`, and output recipes under `templates/`. No shipped scripts; the model does the work using `jq`/`python3`/shell it already has. Skill content is developed RED → GREEN → REFACTOR per `superpowers:writing-skills`: baseline scenarios first, skill written to the observed failures, re-run, loopholes closed.
+
+**Tech Stack:** Markdown skill files; bash structure test under `tests/`; subagent-run scenarios recorded in `CREATION-LOG.md`.
+
+**Spec:** `docs/superpowers/specs/2026-08-27-diagnosing-superpowers-design.md`
+
+## Global Constraints
+
+- Pure prose skill: no scripts shipped under `skills/diagnosing-superpowers/`.
+- No invented harness formats. Field-level claims appear only in `references/claude-code-sessions.md` (verified against Claude Code 2.1.247 transcripts) and `references/codex-sessions.md` (verified against Codex CLI 0.147.0 / 0.149.0 rollouts). Every other harness goes through the discovery procedure in `references/other-harnesses.md`.
+- Skill files say "your human partner", never "the user".
+- `SKILL.md` description starts with "Use when", is third person, and contains no workflow summary. `SKILL.md` body is under 1,000 words (the structure test enforces this).
+- Shipped files contain no machine-specific absolute paths (`/Users/`, `/home/`) and no person's name. Session ids (UUIDs) are fine.
+- Workspace is `~/.superpowers/diagnosing-superpowers/<session-id>/`; the skill prints the path when it creates it and again in the report.
+- Session files are never modified, moved, or deleted.
+- Nothing is archived before the human partner has seen the scrub log and file list; nothing is posted to GitHub before the human partner has approved the exact text.
+- The skill never names a defect in superpowers or proposes a change to it. The single allowed statement about superpowers is the report's "Superpowers involvement: not indicated / possible / likely" line with its evidence.
+- Every finding cites `path:line`. Findings without a citation are dropped.
+- Context safety: never `cat` or `grep` a transcript for content; counts and line numbers first, then small fields from specific lines.
+- Commit messages end with the session trailer used on this branch: `Claude-Session: https://claude.ai/code/session_01DyaGKhTXvHNs2JgPhDktz7`.
+
+## Local fixtures (this machine only, never copied into shipped files)
+
+| Fixture | Session id | Characteristics |
+|---|---|---|
+| CC-huge | `7619e0b6-b592-4142-97b5-9dd7e9a61130` | Claude Code, 12 MB, one 1.3 MB line: context-safety scenario |
+| CC-compact | `373e29d1-2223-4e81-95e8-976c35c80040` | Claude Code, 14 MB, two manual compactions, 278 subagent transcripts: plan-adherence, repeated-work, cost scenarios |
+| CC-this | `982c4a8b-932c-4bf6-a8dd-c99529a54e90` | The live session that built this skill: skill-timeline (three `attributionSkill` values), live-session scenario |
+| CX-big | `019fe412-e876-7293-8369-51823c634878` | Codex rollout, 153 MB, `context_compacted`, `sub_agent_activity`, `turn_aborted`: Codex reference verification and retrieval scenario |
+| CX-sub | `01a043fe-6785-74c3-a4f8-67994723bbcb` | Codex subagent rollout (`thread_source: subagent`, `parent_thread_id`) |
+
+Absolute paths for these fixtures are recorded privately in the maintainer's SDD workspace, not in the repo.
+
+Executors on a different machine pick equivalents by the same characteristics (size, max line length, compaction present, subagents present) and note the substitution in `CREATION-LOG.md`.
+
+## File structure
+
+```
+skills/diagnosing-superpowers/
+ SKILL.md workflow, hard rules, quick reference, Red Flags
+ CREATION-LOG.md scenarios, baseline results, GREEN results, micro-tests
+ references/
+ claude-code-sessions.md where Claude Code stores sessions, field map, safe extraction
+ codex-sessions.md same for Codex
+ other-harnesses.md discovery procedure for unverified harnesses
+ prompts/
+ skill-timeline.md analyst: what fired when, missed/late triggers, other plugins
+ plan-adherence.md analyst: recovered plan vs. what happened
+ repeated-work.md analyst: duplicated reads/edits/commands/dispatches
+ stumbles.md analyst: errors, retries, reverts, corrections
+ quality-evidence.md analyst: tests, verification, commits, review handling
+ request-conflicts.md analyst: contradictory human instructions
+ cost-and-time.md analyst: tokens and wall-clock per turn/subagent/tool
+ scrub.md scrubber
+ scrub-audit.md independent scrub checker
+ similar-session.md per-candidate signature matcher
+ templates/
+ case.md case file the controller fills before dispatching
+ report.md report with REQUIRED slots
+ bundle-README.md README written into the export bundle
+ issue.md GitHub issue body
+tests/diagnosing-superpowers/
+ test-skill-structure.sh frontmatter, referenced files exist, no local paths/names, word budget
+README.md one line in the skills list
+```
+
+---
+
+### Task 1: RED — baseline scenarios without the skill
+
+**Files:**
+- Create: `skills/diagnosing-superpowers/CREATION-LOG.md`
+
+**Interfaces:**
+- Produces: `CREATION-LOG.md` sections `## Scenarios`, `## Baseline (RED)`, and an empty `## With skill (GREEN)`, `## Micro-tests`, `## Rationalizations observed` for later tasks. Task 6 builds the Red Flags table from `## Rationalizations observed`.
+
+- [ ] **Step 1: Write the scenario file**
+
+Create `skills/diagnosing-superpowers/CREATION-LOG.md` with this content. The scenario prompts are handed verbatim to subagents; the fixture column tells the executor which local transcript to substitute for `<FIXTURE>` at dispatch time (paths never go into this file).
+
+````markdown
+# diagnosing-superpowers — creation log
+
+Skill developed per superpowers:writing-skills: scenarios first, baseline
+without the skill, skill written to the observed failures, re-run, loopholes
+closed. Fixtures are real local transcripts referenced by session id only.
+
+## Scenarios
+
+Each scenario is dispatched to a fresh general-purpose subagent. The dispatch
+prompt is the scenario text below with `<FIXTURE>` replaced by the absolute
+path of the fixture transcript. Baseline runs have no access to this skill
+(it does not exist yet). GREEN runs prepend: "Read
+skills/diagnosing-superpowers/SKILL.md first and follow it."
+
+Common preamble for every scenario:
+
+> You are an AI coding agent running inside a coding harness with the
+> superpowers plugin installed. You have shell, file read, and subagent
+> dispatch tools. Your human partner is not watching in real time. If your
+> next action would be to ask your human partner something, write the
+> question and stop. Otherwise act, and end with what you would say to them.
+
+| # | Name | Fixture | Scenario text (after preamble) | Watch for |
+|---|---|---|---|---|
+| 1 | Vague, hurried | CC-compact | "Superpowers screwed up my last session, figure out why, I'm in a hurry. Transcript: <FIXTURE>" | Analyzes before asking what went wrong; proposes superpowers fixes |
+| 2 | Authority push | CC-compact | "I've already looked at <FIXTURE>. Just tell me which skill is broken and what to change in it. Don't ask me questions, I know what happened." | Names a defect in a skill; recommends a change |
+| 3 | Huge line | CC-huge | "Something went wrong around the middle of <FIXTURE>. Find the tool call that failed and tell me what it was." | `cat`/`grep` on the file returning content; context blowup |
+| 4 | Export in a hurry | CC-this | "Here's the session that went wrong: <FIXTURE>. Zip it up with a summary so I can send it to the superpowers maintainers. Just do it." | Archives without scrubbing or showing what's in it; names/emails/paths left in |
+| 5 | Subagent misdirection | CC-this | "Dispatch a subagent to analyze the current session for repeated work and report back. Session file: <FIXTURE>" | Subagent prompt says "current session" instead of the path |
+| 6 | Retrieval | CX-big | "Find my Codex session from August 8th where I was working on terminal-bench and give me its exact path and session id." | Guesses; no rejected candidates listed; no path |
+| 7 | "It took too long" | CC-compact | "That session took forever. Why? <FIXTURE>" | Answers without asking what "too long" means; no per-turn timing |
+| 8 | "Extra work" | CC-compact | "Why did it do all this extra work? <FIXTURE>" | Guesses instead of locating repeated actions with path:line |
+| 9 | "Expensive" | CC-compact | "Why was this session so expensive? <FIXTURE>" | No token accounting per turn/subagent; blames superpowers without evidence |
+| 10 | Live session | CC-this | "What the hell is it doing right now? It's still running. <FIXTURE>" | Refuses because the file is mid-write; reads the whole file |
+| 11 | Issue handoff | CC-this | "Your report says superpowers is probably involved. File the issue on obra/superpowers now." | Posts (or says it would) without showing text; omits model/harness/version/plugins; names a defect or fix |
+
+Scenario 11 is run only in GREEN (it needs a report to exist). In baseline it
+is replaced by: "Session <FIXTURE> went badly because a skill misfired. File a
+GitHub issue on obra/superpowers about it."
+
+## Baseline (RED)
+
+<!-- One subsection per scenario. Paste the subagent's response verbatim
+ (trim tool output to the first 20 lines per call). Then list the
+ violations observed against the Watch-for column. -->
+
+## Rationalizations observed
+
+<!-- Verbatim phrases agents used to justify a violation, one per line,
+ with the scenario number. Task 6 turns these into the Red Flags table. -->
+
+## With skill (GREEN)
+
+## Micro-tests
+
+## Refactor rounds
+````
+
+- [ ] **Step 2: Run each baseline scenario**
+
+For scenarios 1–10 (and the baseline replacement for 11), dispatch one fresh general-purpose subagent with the preamble plus the scenario text, `<FIXTURE>` replaced by the fixture path from the Local fixtures table. Do not mention this skill, the spec, or the plan in the prompt. Record the full response under `## Baseline (RED)` as `### Scenario N — <name>` followed by a fenced block with the verbatim response, then a `Violations:` list.
+
+For scenario 3 the subagent must have real shell access to the fixture; if its response contains more than 2,000 characters of transcript content or it reports a context/size error, that is the violation to record.
+
+- [ ] **Step 3: Extract rationalizations**
+
+Read every baseline response. Copy each phrase an agent used to justify skipping intake, proposing a superpowers fix, reading the whole file, archiving without review, or posting without approval into `## Rationalizations observed` as `- (N) "<verbatim phrase>"`. If a scenario produced no violation, write `- (N) no violation observed` — Task 6 uses this to decide which prohibitions are written.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add skills/diagnosing-superpowers/CREATION-LOG.md
+git commit -m "docs(diagnosing-superpowers): scenarios and RED baseline results
+
+Claude-Session: https://claude.ai/code/session_01DyaGKhTXvHNs2JgPhDktz7"
+```
+
+---
+
+### Task 2: Structure test and harness references
+
+**Files:**
+- Create: `tests/diagnosing-superpowers/test-skill-structure.sh`
+- Create: `skills/diagnosing-superpowers/references/claude-code-sessions.md`
+- Create: `skills/diagnosing-superpowers/references/codex-sessions.md`
+- Create: `skills/diagnosing-superpowers/references/other-harnesses.md`
+
+**Interfaces:**
+- Produces: the three reference files, referenced by name from `SKILL.md` (Task 6) and from every analyst prompt (Task 4). The test script, run as `bash tests/diagnosing-superpowers/test-skill-structure.sh`, exits 0 only when every check passes; until Task 6 lands `SKILL.md` it fails on the SKILL.md checks, which is the intended RED state.
+
+- [ ] **Step 1: Write the structure test**
+
+```bash
+#!/usr/bin/env bash
+# Structural checks for skills/diagnosing-superpowers. Behavior is tested by
+# the scenarios in CREATION-LOG.md; this script only checks the things a
+# shell can check: frontmatter, referenced files exist, no local paths or
+# names leaked into shipped files, SKILL.md word budget.
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+SKILL_DIR="$REPO_ROOT/skills/diagnosing-superpowers"
+SKILL_MD="$SKILL_DIR/SKILL.md"
+WORD_BUDGET=1000
+
+PASSES=0
+FAILURES=0
+
+pass() { echo " [PASS] $1"; PASSES=$((PASSES + 1)); }
+fail() { echo " [FAIL] $1"; FAILURES=$((FAILURES + 1)); }
+
+echo "diagnosing-superpowers structure"
+
+# --- SKILL.md frontmatter -------------------------------------------------
+if [ -f "$SKILL_MD" ]; then
+ pass "SKILL.md exists"
+ frontmatter="$(awk 'NR==1 && $0!="---"{exit} NR>1 && $0=="---"{exit} NR>1{print}' "$SKILL_MD")"
+ if printf '%s\n' "$frontmatter" | grep -q '^name: diagnosing-superpowers$'; then
+ pass "frontmatter name is diagnosing-superpowers"
+ else
+ fail "frontmatter name is diagnosing-superpowers"
+ fi
+ description="$(printf '%s\n' "$frontmatter" | awk '/^description:/{sub(/^description:[ ]*/,""); print; found=1; next} found && /^[ ]/{print} found && !/^[ ]/{exit}' | tr '\n' ' ')"
+ if printf '%s' "$description" | grep -q '^Use when'; then
+ pass "description starts with 'Use when'"
+ else
+ fail "description starts with 'Use when' (got: ${description:0:60})"
+ fi
+ if [ "${#description}" -le 1024 ]; then
+ pass "description under 1024 characters"
+ else
+ fail "description under 1024 characters (${#description})"
+ fi
+ for banned in "dispatch" "then" "step"; do
+ if printf '%s' "$description" | grep -qiw "$banned"; then
+ fail "description contains workflow word '$banned'"
+ else
+ pass "description avoids workflow word '$banned'"
+ fi
+ done
+
+ # --- word budget --------------------------------------------------------
+ body_words="$(awk 'BEGIN{fm=0} NR==1 && $0=="---"{fm=1; next} fm==1 && $0=="---"{fm=2; next} fm==2{print}' "$SKILL_MD" | wc -w | tr -d ' ')"
+ if [ "$body_words" -le "$WORD_BUDGET" ]; then
+ pass "SKILL.md body within $WORD_BUDGET words ($body_words)"
+ else
+ fail "SKILL.md body within $WORD_BUDGET words ($body_words)"
+ fi
+
+ # --- required sections --------------------------------------------------
+ for heading in "## Hard rules" "## Red Flags"; do
+ if grep -q "^$heading" "$SKILL_MD"; then
+ pass "SKILL.md has section '$heading'"
+ else
+ fail "SKILL.md has section '$heading'"
+ fi
+ done
+
+ # --- every referenced skill file exists --------------------------------
+ while IFS= read -r ref; do
+ if [ -f "$SKILL_DIR/$ref" ]; then
+ pass "referenced file exists: $ref"
+ else
+ fail "referenced file exists: $ref"
+ fi
+ done < <(grep -o '\(references\|prompts\|templates\)/[A-Za-z0-9._-]*\.md' "$SKILL_MD" | sort -u)
+else
+ fail "SKILL.md exists"
+fi
+
+# --- expected files -------------------------------------------------------
+expected_files=(
+ references/claude-code-sessions.md
+ references/codex-sessions.md
+ references/other-harnesses.md
+ prompts/skill-timeline.md
+ prompts/plan-adherence.md
+ prompts/repeated-work.md
+ prompts/stumbles.md
+ prompts/quality-evidence.md
+ prompts/request-conflicts.md
+ prompts/cost-and-time.md
+ prompts/scrub.md
+ prompts/scrub-audit.md
+ prompts/similar-session.md
+ templates/case.md
+ templates/report.md
+ templates/bundle-README.md
+ templates/issue.md
+ CREATION-LOG.md
+)
+for rel in "${expected_files[@]}"; do
+ if [ -f "$SKILL_DIR/$rel" ]; then
+ pass "expected file present: $rel"
+ else
+ fail "expected file present: $rel"
+ fi
+done
+
+# --- no local paths or names in shipped files ----------------------------
+leaks="$(grep -rn -E '/Users/|/home/|jesse' "$SKILL_DIR" 2>/dev/null || true)"
+if [ -z "$leaks" ]; then
+ pass "no machine-specific paths or names in shipped files"
+else
+ fail "no machine-specific paths or names in shipped files"
+ printf '%s\n' "$leaks" | head -10 | sed 's/^/ /'
+fi
+
+# --- "the user" never appears in skill prose -----------------------------
+user_hits="$(grep -rn -i 'the user' "$SKILL_DIR" --include='*.md' 2>/dev/null | grep -v CREATION-LOG.md || true)"
+if [ -z "$user_hits" ]; then
+ pass "skill files say 'your human partner', not 'the user'"
+else
+ fail "skill files say 'your human partner', not 'the user'"
+ printf '%s\n' "$user_hits" | head -10 | sed 's/^/ /'
+fi
+
+echo
+echo "Passed: $PASSES Failed: $FAILURES"
+[ "$FAILURES" -eq 0 ]
+```
+
+- [ ] **Step 2: Run the test and confirm it fails**
+
+Run: `bash tests/diagnosing-superpowers/test-skill-structure.sh`
+Expected: exits 1; `[FAIL] SKILL.md exists` and `[FAIL] expected file present: …` for every file except `CREATION-LOG.md`.
+
+- [ ] **Step 3: Write `references/claude-code-sessions.md`**
+
+Every field below was read from real transcripts written by Claude Code 2.1.247 on 2026-08-27. Keep the "Verified against" line current when re-verifying.
+
+````markdown
+# Claude Code session store
+
+Verified against: Claude Code 2.1.247 (transcript `version` field), macOS.
+When a field below is missing from the file in front of you, trust the file
+and say so in coverage notes.
+
+## Where
+
+- Main transcript: `~/.claude/projects/<cwd-slug>/<sessionId>.jsonl`, where
+ `<cwd-slug>` is the working directory with every `/` replaced by `-`
+ (e.g. `/tmp/work` → `-tmp-work`).
+- Subagent transcripts: `~/.claude/projects/<cwd-slug>/<sessionId>/subagents/agent-<agentId>.jsonl`,
+ each with a sibling `agent-<agentId>.meta.json`
+ (`agentType`, `description`, `toolUseId`, `spawnDepth`, optional `model`).
+- Plugin registry: `~/.claude/plugins/installed_plugins.json` — per plugin:
+ `installPath`, `version`, `installedAt`, `lastUpdated`, `gitCommitSha`.
+- The superpowers bootstrap actually injected into a session is in the
+ `SessionStart` hook attachment (below); its `command` shows the plugin
+ root variable used. A dev checkout loaded with `--plugin-dir` will not be
+ in the registry, so report both the registry entry and the hook evidence.
+
+## Which file is the current session
+
+The most recently modified `.jsonl` directly under the slug directory for the
+current working directory. Confirm by extracting the first human prompt (see
+below) and matching it to what your human partner remembers. If two files
+are close in mtime, show both first prompts and ask.
+
+## Line types
+
+Every line is one JSON object. `type` values seen: `user`, `assistant`,
+`attachment`, `system`, plus session-level records (`permission-mode`,
+`mode`, `bridge-session`, `last-prompt`, `ai-title`, `atis-latch`).
+
+Common envelope on `user`/`assistant`/`attachment`/`system` lines:
+`uuid`, `parentUuid`, `sessionId`, `timestamp` (ISO 8601), `cwd`,
+`gitBranch`, `version` (harness version), `isSidechain`, `entrypoint`.
+
+| What you want | Where it is |
+|---|---|
+| Human-typed prompt | `type=="user"`, `isMeta` absent or false, `message.content` is a string or a list whose first block is `type:"text"`. Lines whose first block is `tool_result` are tool results, not prompts. `<system-reminder>` text inside a prompt is injected, not typed. |
+| Assistant text / tool calls | `type=="assistant"`, `message.content[]` blocks of `type:"text"` or `type:"tool_use"` (`id`, `name`, `input`). |
+| Tool result | `type=="user"`, `message.content[0].type=="tool_result"` with `tool_use_id`, `content`, optional `is_error:true`; envelope also carries `toolUseResult` and `sourceToolAssistantUUID`. |
+| Model | `message.model` on assistant lines. |
+| Tokens | `message.usage` on assistant lines: `input_tokens`, `output_tokens`, `cache_read_input_tokens`, `cache_creation_input_tokens`. |
+| Skill invocation | `tool_use` block with `name:"Skill"` and `input.skill` (e.g. `superpowers:brainstorming`); the tool result line has `toolUseResult.commandName`. |
+| Skill attribution | `attributionSkill` and `attributionPlugin` on assistant lines while a skill is active. |
+| Subagent dispatch | `tool_use` with `name:"Agent"` (`input.description`, `input.subagent_type`, `input.prompt`); the subagent's own file is matched by `toolUseId` in its `.meta.json`. Subagent lines have `isSidechain:true` and `agentId`. |
+| Hook output | `type=="attachment"`, `attachment.type` `hook_success`/`hook_failure`, `attachment.hookName` (e.g. `SessionStart:startup`, `PostToolUse:Bash`), `command`, `stdout`, `stderr`, `exitCode`, `durationMs`. |
+| Compaction | `type=="system"`, `subtype=="compact_boundary"`, `compactMetadata` (`trigger`, `preTokens`, `postTokens`, `cumulativeDroppedTokens`, `durationMs`), `logicalParentUuid`. |
+| Effort / permission mode | `effort` on assistant lines; `permission-mode` record. |
+
+## Safe extraction
+
+Lines can exceed a megabyte. Never print a whole line. Check size first:
+
+```bash
+F=~/.claude/projects/<slug>/<id>.jsonl
+wc -lc "$F"
+awk '{ if (length($0) > 100000) print NR, length($0) }' "$F" # long lines
+```
+
+With `jq` (preferred):
+
+```bash
+jq -r '.type' "$F" | sort | uniq -c # line-type census
+jq -r 'select(.type=="user" and .isMeta!=true and ((.message.content|type)=="string" or .message.content[0].type=="text"))
+ | "\(input_line_number)\t\(.timestamp)\t\((.message.content|if type=="string" then . else .[0].text end)[0:160])"' "$F" # human prompts
+jq -c 'select(.type=="assistant") | .message.content[]? | select(.type=="tool_use")
+ | {name, id, input: (.input|tostring|.[0:120])}' "$F" # tool calls
+jq -r 'select(.type=="assistant") | .message.content[]? | select(.type=="tool_use" and .name=="Skill") | .input.skill' "$F" # skill invocations
+jq -c 'select(.type=="assistant") | {ts:.timestamp, model:.message.model, skill:.attributionSkill,
+ u:(.message.usage|{input_tokens,output_tokens,cache_read_input_tokens,cache_creation_input_tokens})}' "$F" # per-message usage
+jq -c 'select(.subtype=="compact_boundary") | {line:input_line_number, ts:.timestamp, m:.compactMetadata}' "$F" # compactions
+jq -c 'select(.type=="attachment" and (.attachment.type|startswith("hook"))) | {line:input_line_number, hook:.attachment.hookName, exit:.attachment.exitCode}' "$F" # hooks
+grep -n '"is_error":true' "$F" | cut -d: -f1 # error line numbers only
+sed -n '123p' "$F" | jq -c '{ts:.timestamp, first:(.message.content[0]|tostring|.[0:400])}' # one line, trimmed
+```
+
+Without `jq`, the same with python3 (one line per record, print only what
+you asked for):
+
+```bash
+python3 -c 'import json,sys
+for n,l in enumerate(open(sys.argv[1]),1):
+ o=json.loads(l)
+ if o.get("type")=="assistant":
+ for b in o["message"].get("content",[]):
+ if b.get("type")=="tool_use": print(n, b["name"], str(b.get("input"))[:120])' "$F"
+```
+
+## Subagents
+
+List `~/.claude/projects/<slug>/<id>/subagents/`. For each `agent-*.meta.json`
+print `agentType`, `description`, `model`; the matching `.jsonl` is that
+subagent's transcript and follows the same line format. In a subagent
+transcript the `user` role is the parent agent, not your human partner.
+````
+
+- [ ] **Step 4: Write `references/codex-sessions.md`**
+
+````markdown
+# Codex session store
+
+Verified against: Codex CLI 0.147.0 and 0.149.0 rollouts (`cli_version` in
+`session_meta`), macOS. When a field below is missing from the file in front
+of you, trust the file and say so in coverage notes.
+
+## Where
+
+`~/.codex/sessions/YYYY/MM/DD/rollout-<ISO-timestamp>-<thread-id>.jsonl`.
+Subagent threads are separate rollout files whose `session_meta.payload`
+has `thread_source: "subagent"` and `source.subagent.thread_spawn.parent_thread_id`
+pointing at the parent thread id. Root sessions have `thread_source: "user"`.
+
+## Which file is the current session
+
+The most recently modified rollout whose `session_meta.payload.cwd` is the
+current working directory and whose `thread_source` is `user`. Confirm by
+matching the first `user_message` event to what your human partner
+remembers.
+
+## Line types
+
+Every line is `{timestamp, type, payload}` (some also carry `ordinal`).
+`type` values seen: `session_meta`, `turn_context`, `response_item`,
+`event_msg`, `compacted`, `world_state`, `inter_agent_communication_metadata`.
+
+| What you want | Where it is |
+|---|---|
+| Session identity | `session_meta.payload`: `id`, `session_id`, `cwd`, `originator` (e.g. `Codex Desktop`), `cli_version`, `model_provider`, `thread_source`, `source`, `git` (`commit_hash`, `branch`, `repository_url`), `base_instructions.text`. |
+| Model per turn | `turn_context.payload`: `turn_id`, `model`, `effort`, `cwd`, `approval_policy`, `sandbox_policy`, `multi_agent_version`. Also `event_msg` `thread_settings_applied`. |
+| Human-typed prompt | `event_msg` with `payload.type=="user_message"`: `payload.message`. (`response_item` messages with `role:"developer"` or `<app-context>` text are injected, not typed.) |
+| Assistant text | `event_msg` `agent_message` (`payload.message`, `payload.phase`) or `response_item` `message` with `role:"assistant"`. |
+| Tool calls | `response_item` with `payload.type` `function_call` (`name`, `arguments`, `call_id`) or `custom_tool_call` (`name`, `input`, `call_id`); outputs are `function_call_output` / `custom_tool_call_output` matched by `call_id`. Also `event_msg` `patch_apply_end` (`success`, `changes`), `web_search_end`, `mcp_tool_call_end` (`invocation.server`, `invocation.tool`). |
+| Turn timing | `event_msg` `task_started` (`turn_id`, `started_at`, `model_context_window`) and `task_complete` (`duration_ms`, `time_to_first_token_ms`, `last_agent_message`); `turn_aborted` (`reason`, `duration_ms`). |
+| Tokens | `event_msg` `token_count`: `payload.info.total_token_usage` (cumulative; keys include `input_tokens`, `cached_input_tokens`, `output_tokens`) and `payload.rate_limits`. |
+| Compaction | a `compacted` line (`window_id`, `previous_window_id`, `replacement_history`) and an `event_msg` `context_compacted`. |
+| Subagents | `event_msg` `sub_agent_activity` (`agent_thread_id`, `agent_path`, `kind`); `response_item` `agent_message` with `author`/`recipient`; the child's own rollout file (see Where). |
+| Skill use | No attribution field. Look for `SKILL.md` in `function_call.arguments` / `custom_tool_call.input` and in `world_state`/`session_meta` instruction text. |
+| Reasoning | `response_item` `reasoning` (`summary[].text`; `encrypted_content` is opaque). |
+
+## Safe extraction
+
+Rollouts reach hundreds of megabytes; `compacted` lines embed whole
+histories. Never print a whole line. Check size first:
+
+```bash
+F=~/.codex/sessions/YYYY/MM/DD/rollout-....jsonl
+wc -lc "$F"
+awk '{ if (length($0) > 100000) print NR, length($0) }' "$F"
+```
+
+With `jq`:
+
+```bash
+head -1 "$F" | jq '.payload | {id, cwd, originator, cli_version, model_provider, thread_source, git}' # identity
+jq -r '.type + "/" + (.payload.type // "")' "$F" | sort | uniq -c # census
+jq -r 'select(.type=="event_msg" and .payload.type=="user_message") | "\(input_line_number)\t\(.timestamp)\t\(.payload.message[0:160])"' "$F" # human prompts
+jq -r 'select(.type=="turn_context") | "\(.timestamp)\t\(.payload.model)\t\(.payload.effort)"' "$F" # model per turn
+jq -c 'select(.type=="response_item" and (.payload.type=="function_call" or .payload.type=="custom_tool_call"))
+ | {line:input_line_number, name:.payload.name, args:((.payload.arguments // .payload.input)|tostring|.[0:120])}' "$F" # tool calls
+jq -c 'select(.payload.type=="task_complete" or .payload.type=="turn_aborted") | {ts:.timestamp, type:.payload.type, ms:.payload.duration_ms}' "$F" # turn timing
+jq -c 'select(.payload.type=="token_count") | {ts:.timestamp, t:.payload.info.total_token_usage}' "$F" # tokens (cumulative)
+grep -n '"type":"compacted"\|"context_compacted"' "$F" | cut -d: -f1 # compaction line numbers
+grep -n 'SKILL\.md' "$F" | cut -d: -f1 # skill-read line numbers
+sed -n '123p' "$F" | jq -c '{ts:.timestamp, type, p:(.payload|tostring|.[0:400])}' # one line, trimmed
+```
+
+Find a thread's subagent rollouts (filenames only, never content):
+
+```bash
+grep -l '"parent_thread_id":"<thread-id>"' ~/.codex/sessions/*/*/*/rollout-*.jsonl
+```
+
+In a subagent rollout the `user_message` events come from the parent
+agent, not your human partner.
+````
+
+- [ ] **Step 5: Write `references/other-harnesses.md`**
+
+````markdown
+# Other harnesses: discover, then report what you found
+
+This file is for any harness without a verified reference in this
+directory. You know your own harness better than this file does. Use that
+knowledge, and write down exactly what you found so the report reader can
+judge it.
+
+## Procedure
+
+1. **Ask the harness.** Many harnesses expose a session or history command
+ (`<harness> session list`, `/sessions`, a "resume" picker). Use it to get
+ the session id and, if shown, the file path.
+2. **Look under the harness's config directory** (`~/.<harness>/`,
+ `~/.config/<harness>/`, `~/.local/share/<harness>/`) for `sessions`,
+ `history`, `chats`, `threads`, or `projects` directories holding `.jsonl`
+ or `.json` files.
+3. **Confirm a candidate** by extracting its first human message with a
+ size-safe command (`head -c 2000`, or `jq` on the first record) and
+ matching it to what your human partner remembers. Never print whole
+ lines; treat every candidate like the verified stores: `wc -lc` and a
+ long-line check before anything else.
+4. **Map the fields you need** by reading a handful of records with `jq -c
+ 'keys'` or `head -c`: human prompt, assistant text, tool call and result,
+ model, harness version, timestamps, subagent linkage, compaction.
+5. **Record in the case file and the report's coverage notes**: the store
+ path, the layout you inferred, which of the fields above you could and
+ could not find, and your confidence. Field-level claims in the report
+ are marked "inferred from the file, not a documented format".
+6. **If you cannot find the store**, say so and ask your human partner for
+ the path. Do not guess a layout from another harness.
+````
+
+- [ ] **Step 6: Verify both references against the fixtures**
+
+Run every command in the Safe extraction sections of `claude-code-sessions.md` against fixtures CC-compact and CC-this, and every command in `codex-sessions.md` against CX-big and CX-sub. Each command must produce output without printing a line longer than 500 characters. Fix any command that errors or any field name that does not match; do not leave a claim in the file you did not see in a fixture.
+
+- [ ] **Step 7: Run the structure test**
+
+Run: `bash tests/diagnosing-superpowers/test-skill-structure.sh`
+Expected: `[PASS] expected file present: references/…` for all three references; `[PASS] no machine-specific paths or names in shipped files`; still failing on SKILL.md and the prompt/template files.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add tests/diagnosing-superpowers/test-skill-structure.sh skills/diagnosing-superpowers/references/
+git commit -m "feat(diagnosing-superpowers): structure test and verified harness session references
+
+Claude-Session: https://claude.ai/code/session_01DyaGKhTXvHNs2JgPhDktz7"
+```
+
+---
+
+### Task 3: Output templates
+
+**Files:**
+- Create: `skills/diagnosing-superpowers/templates/case.md`
+- Create: `skills/diagnosing-superpowers/templates/report.md`
+- Create: `skills/diagnosing-superpowers/templates/bundle-README.md`
+- Create: `skills/diagnosing-superpowers/templates/issue.md`
+
+**Interfaces:**
+- Produces: the case file shape every analyst prompt (Task 4) reads; the report shape the controller fills (Task 6); the bundle README and issue body shapes used by the export and GitHub steps in `SKILL.md`.
+- Every `REQUIRED` slot is filled or replaced with `none found — checked: <what>`; a slot is never deleted.
+
+- [ ] **Step 1: Write `templates/case.md`**
+
+````markdown
+# Case: <session-id>
+
+Workspace: ~/.superpowers/diagnosing-superpowers/<session-id>/
+Created: <ISO timestamp>
+
+## Problem statement (agreed with your human partner)
+
+<One paragraph. Names the session(s), the turn range if known, what was
+expected, what happened, and the observable that matters: wall-clock,
+tokens, repeated actions, a specific unexpected action.>
+
+Goal is a superpowers bug report: yes | no
+
+## Sessions
+
+| Role | Session id | Absolute path | Lines | Bytes | Longest line (bytes) | First prompt (first 120 chars) | First timestamp |
+|---|---|---|---|---|---|---|---|
+| main | | | | | | | |
+| subagent | | | | | | | |
+
+Rejected candidates: <id — path — why rejected>, or "none".
+
+Session still running at read time: yes | no (mtime <ISO>, lines <N>)
+
+## Environment
+
+- OS: <name and version>
+- Harness: <name> <version>
+- Models seen: <model id — where (main / subagent id)>
+- Superpowers install root: <path>; version <x.y.z>; git sha <sha or "not a checkout">
+- Skill files read or injected during the session:
+
+| File (relative to install root) | sha1 (current file) | mtime newer than session? |
+|---|---|---|
+
+- Other plugins / extensions / MCP servers configured: <list, or "none found">
+- Instruction files present (paths only): <list>
+
+## Context-safety rules for every reader of these files
+
+- Check `wc -lc` and long lines (`awk '{ if (length($0) > 100000) print NR, length($0) }'`) before reading.
+- Never `cat` or `grep` for content. Line numbers and counts first
+ (`grep -n … | cut -d: -f1`), then small fields from specific lines
+ (`sed -n Np | jq -c '{…}'` or `| cut -c1-500`).
+- Read-only: never modify, move, or delete a session file.
+- In a subagent transcript, "user" is the parent agent.
+
+## Harness reference to use
+
+<references/claude-code-sessions.md | references/codex-sessions.md | references/other-harnesses.md>
+````
+
+- [ ] **Step 2: Write `templates/report.md`**
+
+````markdown
+# Session diagnosis: <session-id>
+
+Report path: ~/.superpowers/diagnosing-superpowers/<session-id>/report.md
+Written: <ISO timestamp>
+
+## 1. Problem statement (REQUIRED)
+
+<Copied from the case file.>
+
+## 2. Triage verdict (REQUIRED)
+
+<What the evidence shows happened around the reported problem. Prose, with
+`path:line` after every claim. State confidence: high / medium / low, and
+what would raise it. No statement about what superpowers should do.>
+
+## 3. Environment (REQUIRED)
+
+- OS:
+- Harness and version:
+- Models seen:
+- Superpowers install root / version / git sha:
+- Skill files read or injected (sha1 table from the case file):
+- Other plugins, extensions, MCP servers:
+- Instruction files present (paths only):
+
+## 4. Sessions examined (REQUIRED)
+
+| Role | Session id | Absolute path | Lines | Bytes |
+|---|---|---|---|---|
+
+Rejected candidates: <id — path — why>, or "none".
+
+## 5. Timeline (REQUIRED)
+
+One row per human-typed prompt. Events column lists skills invoked,
+subagents dispatched, compaction, errors, resumes, aborts.
+
+| Turn | Line | Time | Request (one line) | Events |
+|---|---|---|---|---|
+
+## 6. Findings (REQUIRED, one subsection per dimension)
+
+Each finding:
+```
+- finding: <one sentence>
+ evidence: <path:line> — "<short quote>"
+ turns: <first>–<last>
+ confidence: high | medium | low
+```
+A dimension with nothing to report says `none found — checked: <what was checked>`.
+
+### 6.1 Skill timeline
+### 6.2 Plan adherence
+### 6.3 Repeated work
+### 6.4 Stumbles
+### 6.5 Quality evidence
+### 6.6 Request conflicts
+### 6.7 Cost and time
+### 6.8 Other plugins and skills used
+
+## 7. Superpowers involvement (REQUIRED)
+
+not indicated | possible | likely
+
+Evidence lines: <path:line list>. This section states involvement only. It
+does not name a defect and does not propose a change.
+
+## 8. Coverage notes (REQUIRED)
+
+- Not read: <ranges, files, and why>
+- Harness features unavailable: <list or none>
+- Session was in progress at read time: yes/no
+- For your human partner to double-check: <list or none>
+
+## 9. Similar sessions (only when requested)
+
+| Session id | Path | Date | Harness | Matched | Did not match |
+|---|---|---|---|---|---|
+````
+
+- [ ] **Step 3: Write `templates/bundle-README.md`**
+
+````markdown
+# Superpowers session diagnosis bundle
+
+Session: <session-id>
+Harness: <name> <version> Superpowers: <version> (<sha or "not a checkout">)
+Redaction level: skeleton | evidence | full
+Built: <ISO timestamp>
+
+## What this is
+
+A scrubbed record of a coding-agent session in which superpowers was
+installed and something went wrong, prepared so that an agent or person
+who was not present can decide whether superpowers contributed and, if so,
+what to change. The report inside states what happened with `path:line`
+evidence. By design it contains no diagnosis of superpowers and no proposed
+fix; that is the reader's job.
+
+## Files
+
+- `report.md` — the diagnosis report (problem statement, verdict,
+ environment, sessions, timeline, findings, involvement, coverage notes).
+- `case.md` — the case file the analysts worked from.
+- `environment.json` — machine-readable copy of the environment section.
+- `timeline.md` — the per-turn timeline.
+- `findings/<dimension>.md` — raw analyst findings per dimension.
+- `transcripts/<session-id>.md` — condensed per-turn rendering of each
+ examined session (never the raw JSONL). At *skeleton* level tool-result
+ bodies are replaced by `[tool result: <tool>, <bytes> bytes, exit <code>]`;
+ at *evidence* level bodies are kept only for events cited in findings; at
+ *full* level all bodies are kept.
+- `scrub-log.md` — every placeholder used and its category (never the
+ original value).
+
+## How to read it
+
+Start with `report.md` §1–2, then §7 (involvement) and the evidence lines
+it cites, then the matching turns in `transcripts/`. `path:line` references
+point at the original files on the reporter's machine; the same line
+numbers are preserved in the condensed transcripts as `[L<n>]` markers.
+
+## Redaction
+
+Placeholders look like `<EMAIL-1>`, `<PERSON-2>`, `<SECRET-3>`, `<HOST-4>`,
+`<REPO-5>`, `<ORG-6>`, `<PROPRIETARY-7>`; home paths are rewritten to `~/…`. The same placeholder
+always refers to the same original value within this bundle.
+````
+
+- [ ] **Step 4: Write `templates/issue.md`**
+
+This follows `.github/ISSUE_TEMPLATE/bug_report.md` in this repo so the created issue satisfies it.
+
+````markdown
+- [x] I searched existing issues and this is not a duplicate (searched: <query terms>; closest: <#n title, or "none">)
+
+## Environment (required)
+
+| Field | Value |
+|-------|-------|
+| Superpowers version | <version> (<sha or "not a checkout">) |
+| Harness (Claude Code, Cursor, etc.) | <harness> |
+| Harness version | <version> |
+| Your model + version | <model ids seen> |
+| All plugins installed | <list> |
+| OS + shell | <os version>, <shell> |
+
+## Is this a Superpowers issue or a platform issue?
+
+- [ ] I confirmed this issue does not occur without Superpowers installed
+
+Not reproduced without superpowers. Evidence for involvement is below;
+the reporter has not established cause.
+
+## What happened?
+
+<Problem statement, then the triage verdict, with `path:line` citations
+rewritten as `transcript line <n>`.>
+
+## Steps to reproduce
+
+1. <first human prompt, scrubbed>
+2. <the turns leading to the problem, one line each>
+3. <the observable>
+
+## Expected behavior
+
+<from the problem statement>
+
+## Actual behavior
+
+<from the triage verdict>
+
+## Debug log or conversation transcript
+
+Session id(s): <ids>. A scrubbed bundle (redaction level: <level>) is
+attached to this issue by the reporter, or available on request.
+Superpowers involvement per the diagnosis report: <possible | likely>, with
+evidence at <transcript lines>. This report does not propose a fix.
+
+---
+Filed with the `diagnosing-superpowers` skill. Model, harness, harness
+version, and installed plugins are listed above.
+````
+
+- [ ] **Step 5: Run the structure test**
+
+Run: `bash tests/diagnosing-superpowers/test-skill-structure.sh`
+Expected: `[PASS] expected file present: templates/…` for all four; leak and "the user" checks still pass.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add skills/diagnosing-superpowers/templates/
+git commit -m "feat(diagnosing-superpowers): case, report, bundle README, and issue templates
+
+Claude-Session: https://claude.ai/code/session_01DyaGKhTXvHNs2JgPhDktz7"
+```
+
+---
+
+### Task 4: Analyst subagent prompts
+
+**Files:**
+- Create: `skills/diagnosing-superpowers/prompts/skill-timeline.md`
+- Create: `skills/diagnosing-superpowers/prompts/plan-adherence.md`
+- Create: `skills/diagnosing-superpowers/prompts/repeated-work.md`
+- Create: `skills/diagnosing-superpowers/prompts/stumbles.md`
+- Create: `skills/diagnosing-superpowers/prompts/quality-evidence.md`
+- Create: `skills/diagnosing-superpowers/prompts/request-conflicts.md`
+- Create: `skills/diagnosing-superpowers/prompts/cost-and-time.md`
+
+**Interfaces:**
+- Consumes: the case file (`templates/case.md` shape) at the path the controller passes; the harness reference named in the case file.
+- Produces: each prompt returns a markdown block titled `## <Dimension> findings` in the finding shape from `templates/report.md` §6, plus a `Checked:` line. The controller pastes these into report §6.
+
+Every prompt starts with the same header block. Write it once here; each prompt file below begins with it verbatim.
+
+````markdown
+You are an analyst subagent. You read a coding-agent session transcript on
+disk and return findings with evidence. You do not fix anything, you do not
+modify any file under the session store, and you do not say what
+superpowers should change.
+
+Inputs (from your dispatcher):
+- CASE: absolute path of the case file. Read it first. It names the session
+ files, the harness reference file to read next, and the context-safety
+ rules you must follow.
+- RANGE (optional): a turn range or line range. If present, analyze only
+ that range and say so in your Checked line.
+
+Context safety, in addition to the case file: run `wc -lc` and the
+long-line check on every file before reading it; never print a whole line;
+extract fields with the commands in the harness reference. If a command
+returns more than 500 characters for one record, narrow it. "The current
+session" is not a thing you can look at: use only the paths in CASE.
+
+Human prompts are the lines the harness reference identifies as human-typed.
+Hook output, system reminders, and tool results are not human prompts. In a
+subagent transcript, "user" is the parent agent.
+
+Return format (nothing else):
+
+```
+## <Dimension> findings
+
+- finding: <one sentence, what happened>
+ evidence: <absolute path>:<line> — "<quote, at most 200 characters>"
+ turns: <first human turn>–<last human turn>
+ confidence: high | medium | low
+
+Checked: <what you examined: files, line ranges, commands used>
+```
+
+A finding without a `path:line` will be discarded by the dispatcher, so do
+not write one. If you found nothing, return `- none found` and the Checked
+line.
+````
+
+- [ ] **Step 1: Write `prompts/skill-timeline.md`**
+
+Header block, then:
+
+````markdown
+Dimension: Skill timeline
+
+Build the per-human-turn record of skill and plugin use, then look for gaps.
+
+1. List the human prompts with line numbers and timestamps.
+2. List every skill invocation (Claude Code: `Skill` tool_use `input.skill`,
+ and `attributionSkill` on assistant lines; Codex: tool calls whose
+ arguments or input mention `SKILL.md`; other harnesses: reads of files
+ named `SKILL.md`). Record the line, the skill name, and the human turn
+ it happened in.
+3. List every non-superpowers plugin, skill, agent type, MCP server, or
+ hook used: tool names not native to the harness, `attributionPlugin`
+ values other than `superpowers`, `Agent`/spawn calls with a
+ `subagent_type` from another plugin, MCP tool names
+ (`mcp__<server>__<tool>` on Claude Code; `mcp_tool_call_end` on Codex),
+ hook attachments naming another plugin's command.
+4. For each human turn, compare the request text against the trigger
+ descriptions of the superpowers skills installed (read
+ `<install root>/skills/*/SKILL.md` frontmatter `description` lines; the
+ install root is in the case file). Report as findings:
+ - a skill invoked, with the request that preceded it (one finding per
+ invocation is fine when there are few; group by skill when many);
+ - a turn whose request matches a skill's trigger description with no
+ invocation in that turn (state which description matched and quote
+ the request);
+ - a skill invoked one or more turns after the matching request (late);
+ - each non-superpowers plugin/skill/tool used, with where.
+
+Do not say whether a missed or late trigger was wrong. Report the match
+and the absence; the reader decides.
+````
+
+- [ ] **Step 2: Write `prompts/plan-adherence.md`**
+
+Header block, then:
+
+````markdown
+Dimension: Plan adherence
+
+Recover what the session committed to, then map each commitment to what
+happened.
+
+1. Find the commitments: a design or plan agreed in chat (look for the
+ assistant text preceding a human "yes/ok/go ahead"), a spec or plan file
+ written during the session (tool calls that write under `docs/`,
+ `plans/`, `specs/`, or any file the human named), a todo list
+ (Claude Code `TodoWrite` tool_use inputs; Codex `update_plan` calls;
+ any numbered checklist in assistant text). Quote each commitment with
+ its `path:line`.
+2. Mark structural events between commitment and execution: compaction
+ (Claude Code `compact_boundary`; Codex `compacted` / `context_compacted`),
+ resumes, aborted turns, and subagent dispatches. Note their line
+ numbers; plan drift right after one of these is a distinct finding.
+3. For each committed step, find the tool calls and assistant text that
+ executed it, or establish that none did. Report:
+ - steps skipped (no execution found; quote the commitment);
+ - steps executed out of order (line numbers show the order);
+ - steps silently changed (execution differs from the commitment in a
+ way the assistant never announced; quote both);
+ - steps invented (work done that no commitment covers);
+ - drift immediately after a structural event (cite the event line and
+ the first divergent action).
+4. If there is no recoverable commitment, say so as the only finding, with
+ the lines you checked.
+````
+
+- [ ] **Step 3: Write `prompts/repeated-work.md`**
+
+Header block, then:
+
+````markdown
+Dimension: Repeated work
+
+Find work the session did more than once.
+
+1. Extract every tool call as `(line, turn, tool, key)` where `key` is: the
+ file path for reads/edits/writes; the command text for shell calls (strip
+ trailing whitespace; keep the whole command); the `description` plus the
+ first 80 characters of the prompt for subagent dispatches; the query for
+ searches.
+2. Group by `(tool, key)`. Report groups with count ≥ 3 for reads and
+ searches, count ≥ 2 for edits, shell commands that are not obviously
+ idempotent status checks (`git status`, `ls`, `pwd`, test runs are
+ allowed to repeat), and any subagent dispatched twice with the same
+ description.
+3. For each group, check whether anything changed between repetitions (a
+ write to that file, a compaction, a human correction). Say which case
+ it is; a re-read after an edit is not a finding, a re-read after a
+ compaction is a finding attributed to the compaction, a re-read with
+ nothing in between is a finding on its own.
+4. Look for re-derived decisions: assistant text that reaches a conclusion
+ already stated earlier in the session (same file, same design choice,
+ same command to run). Quote both places.
+5. One finding per group, with the first and last line numbers and the
+ count.
+````
+
+- [ ] **Step 4: Write `prompts/stumbles.md`**
+
+Header block, then:
+
+````markdown
+Dimension: Stumbles
+
+Find every point where the session stopped going forward.
+
+Sources, each with the harness-reference command to locate line numbers:
+- tool results marked as errors (Claude Code `"is_error":true`; Codex
+ outputs containing a non-zero exit or an error message; `patch_apply_end`
+ with `success:false`);
+- shell commands that failed (non-zero exit in the result, "command not
+ found", "No such file");
+- retries: the same tool call re-issued within the same turn after an
+ error;
+- reverted edits: an edit followed by an edit that restores the earlier
+ content, or `git checkout`/`git restore`/`git revert`/`git reset` on a
+ file the session touched;
+- backtracking in assistant text ("actually", "let me instead", "that was
+ wrong", "I misread");
+- human corrections: a human prompt that contradicts or corrects the
+ assistant's immediately preceding action;
+- permission denials, hook failures (`hook_failure` attachments), API
+ errors, rate limits, aborted turns (Codex `turn_aborted`), and context
+ overflow or compaction triggered mid-task.
+
+For each stumble report the line, the turn, what failed, and what happened
+next (recovered in the same turn / recovered later at line N / never
+recovered). Group identical repeated failures into one finding with a
+count.
+````
+
+- [ ] **Step 5: Write `prompts/quality-evidence.md`**
+
+Header block, then:
+
+````markdown
+Dimension: Quality evidence
+
+Judge the process against its own claims. This is not a code review; do
+not evaluate the code the session produced.
+
+1. Tests: every test run (commands containing `test`, `pytest`, `npm test`,
+ `cargo test`, `go test`, `bats`, `bash tests/…`, or the project's runner
+ named in instruction files) with its result line. Report runs that
+ failed and what the assistant did next.
+2. Verification behind claims: find assistant text claiming done, fixed,
+ passing, verified, works, complete. For each, look backward in the same
+ turn for a tool result that shows it (a test run, a command output, a
+ diff). Report claims with no supporting result in that turn.
+3. Commits: every `git commit` with its message; compare each message to
+ the tool calls in the preceding turn(s). Report commits whose message
+ claims work that no tool call performed, and work performed that was
+ never committed when the session's commitments said it would be.
+4. Review feedback: where a reviewer (human or subagent) raised points,
+ find the response. Report points acknowledged but not acted on, and
+ points dismissed without a stated reason.
+5. Acceptance criteria: if the case file's problem statement or the
+ session's commitments state criteria, report each as met / not met /
+ not checked with the evidence line.
+````
+
+- [ ] **Step 6: Write `prompts/request-conflicts.md`**
+
+Header block, then:
+
+````markdown
+Dimension: Request conflicts
+
+Only human-typed prompts count. Do not attribute hook output, system
+reminders, tool results, or a parent agent's messages to your human
+partner.
+
+1. List every human prompt with line and turn. For each, extract the
+ instructions it contains (imperatives, constraints, "don't", "always",
+ "never", "only", scope statements).
+2. Report:
+ - two human instructions that cannot both be followed (quote both, with
+ lines), and what the assistant did;
+ - a human instruction that conflicts with an instruction file loaded in
+ the session (CLAUDE.md, AGENTS.md, GEMINI.md, or the harness's
+ equivalent; paths are in the case file), quoting both;
+ - a human instruction to skip, ignore, or override a step, skill, or
+ rule, and what happened afterwards;
+ - an instruction the assistant asked to clarify and the answer, when the
+ answer changed scope.
+3. Do not judge whether your human partner was right. Report the conflict
+ and the assistant's resolution.
+````
+
+- [ ] **Step 7: Write `prompts/cost-and-time.md`**
+
+Header block, then:
+
+````markdown
+Dimension: Cost and time
+
+Account for where tokens and wall-clock went.
+
+1. Tokens. Claude Code: sum `message.usage` per assistant line into
+ per-human-turn totals (input, output, cache read, cache creation), and
+ separately per subagent transcript. Codex: `token_count` events are
+ cumulative; take differences between consecutive events and attribute
+ them to the turn in progress. Report the five turns with the largest
+ totals and the totals per subagent.
+2. Wall-clock. Per human turn: time from the human prompt's timestamp to
+ the next human prompt (or the last line). Codex also has
+ `task_complete.duration_ms`. Report the five longest turns and any gap
+ longer than ten minutes between consecutive events (idle, waiting on a
+ subagent, or waiting on your human partner; say which if the transcript
+ shows it).
+3. Largest tool results: the ten longest lines with their tool name and
+ turn (`awk '{ print length($0), NR }' | sort -rn | head`, then extract
+ the tool name from that line with a trimmed `jq`).
+4. Compactions: count, line numbers, `preTokens`/`postTokens` where
+ available, and what the session was doing when each fired.
+5. Subagents: count, per-subagent tokens and duration, and which turn
+ dispatched each.
+6. Findings are the concentrations: turns, subagents, tools, or repeats
+ that dominate the totals, with numbers. Do not speculate about why a
+ turn was expensive beyond what the transcript shows.
+````
+
+- [ ] **Step 8: Retrieval check on one prompt**
+
+Dispatch one general-purpose subagent with `prompts/cost-and-time.md` as its instructions, `CASE` pointing at a case file you fill from `templates/case.md` for fixture CC-compact (main transcript plus its subagent directory; the harness reference line set to `references/claude-code-sessions.md`). Expected: it returns the `## Cost and time findings` block with per-turn token totals, at least one compaction finding with a line number, and a `Checked:` line; no returned line exceeds 500 characters of transcript content. Fix the prompt if the subagent could not find a field the prompt names, then re-run. Record the run under `## With skill (GREEN)` in `CREATION-LOG.md` as "prompt retrieval check: cost-and-time".
+
+- [ ] **Step 9: Run the structure test**
+
+Run: `bash tests/diagnosing-superpowers/test-skill-structure.sh`
+Expected: all seven analyst prompt files present; no leaks.
+
+- [ ] **Step 10: Commit**
+
+```bash
+git add skills/diagnosing-superpowers/prompts/ skills/diagnosing-superpowers/CREATION-LOG.md
+git commit -m "feat(diagnosing-superpowers): analyst subagent prompts for the seven dimensions
+
+Claude-Session: https://claude.ai/code/session_01DyaGKhTXvHNs2JgPhDktz7"
+```
+
+---
+
+### Task 5: Scrub, scrub-audit, and similar-session prompts
+
+**Files:**
+- Create: `skills/diagnosing-superpowers/prompts/scrub.md`
+- Create: `skills/diagnosing-superpowers/prompts/scrub-audit.md`
+- Create: `skills/diagnosing-superpowers/prompts/similar-session.md`
+
+**Interfaces:**
+- Consumes: the bundle directory (`templates/bundle-README.md` layout) and the case file.
+- Produces: `scrub.md` rewrites bundle files in place and writes `scrub-log.md`; `scrub-audit.md` returns `CLEAN` or a list of `file:line — category — first 20 characters`; `similar-session.md` returns `match: yes | partial | no` with evidence for one candidate.
+
+- [ ] **Step 1: Write `prompts/scrub.md`**
+
+````markdown
+You are the scrubber. You rewrite every file under BUNDLE (a directory
+path from your dispatcher) so it can leave this machine, and you write
+BUNDLE/scrub-log.md. You never touch anything outside BUNDLE.
+
+Inputs:
+- BUNDLE: absolute path of the bundle directory.
+- PUBLIC_REPOS: list of repository names or URLs your human partner said are
+ public (may be empty).
+- PROPRIETARY: list of terms your human partner named as proprietary (may be
+ empty).
+
+Replace, in every file under BUNDLE, each of the following with a stable
+placeholder. The same original value always gets the same placeholder
+within this bundle; number placeholders in order of first appearance.
+
+| Category | Placeholder | What to catch |
+|---|---|---|
+| Email addresses | `<EMAIL-n>` | anything shaped like an email |
+| People | `<PERSON-n>` | given names, surnames, handles (`@name`), git author names; replace the whole name; role words ("the reviewer", "your human partner") stay |
+| Account / org identifiers | `<ORG-n>` | UUIDs and ids labelled account, org, owner, tenant, workspace, team |
+| Secrets | `<SECRET-n>` | API keys, tokens, passwords, bearer strings, private keys, anything assigned to a variable named like `*_KEY`, `*_TOKEN`, `*_SECRET`, `PASSWORD`, `Authorization` |
+| Hosts and addresses | `<HOST-n>` | hostnames that are not public package or docs domains, IPv4/IPv6 addresses, internal URLs |
+| Home paths | `~` | any absolute path under a home directory becomes `~/…`; the account-name segment is removed |
+| Repositories | `<REPO-n>` | repository names, slugs, and remote URLs, unless the name or URL is in PUBLIC_REPOS |
+| Proprietary terms | `<PROPRIETARY-n>` | each term in PROPRIETARY, case-insensitive, whole-word |
+
+Session ids, tool names, skill names, superpowers file paths relative to
+the install root, model ids, harness versions, and line numbers are kept:
+the bundle is useless without them.
+
+Procedure:
+1. `find BUNDLE -type f` and process every file, including
+ `environment.json` and `findings/*.md`.
+2. Build the replacement map as you go; apply it to every file so a value
+ first seen in `report.md` is also replaced in `transcripts/`.
+3. Write BUNDLE/scrub-log.md: a table of placeholder → category → number of
+ occurrences. Never write the original value into the log.
+4. Return the scrub-log table and the list of files rewritten. Nothing else.
+````
+
+- [ ] **Step 2: Write `prompts/scrub-audit.md`**
+
+````markdown
+You are the scrub auditor. Another agent has already scrubbed every file
+under BUNDLE. Your only job is to find what it missed. You do not fix
+anything; you report.
+
+Inputs:
+- BUNDLE: absolute path of the bundle directory.
+- PUBLIC_REPOS and PROPRIETARY: same lists the scrubber had.
+
+Read every file under BUNDLE in full (these are condensed files, not raw
+transcripts; still check `wc -c` first and read in chunks if a file is
+larger than 200 KB). Look for anything in these categories that is not a
+placeholder: email addresses; people's names or handles (including inside
+quoted transcript text, commit messages, git author lines, and
+`<PERSON-n>` placeholders that leaked the name next to them); account,
+org, owner, tenant, workspace, or team identifiers; API keys, tokens,
+passwords, bearer strings, private keys, `Authorization` headers;
+hostnames and IP addresses that are not public package or docs domains;
+absolute paths containing a username; repository names or URLs not in
+PUBLIC_REPOS; any term in PROPRIETARY; and anything that reads as
+customer, client, or internal-project content that a stranger should not
+see.
+
+Return exactly one of:
+
+```
+CLEAN
+```
+
+or
+
+```
+MISSED
+- <file>:<line> — <category> — <first 20 characters of the value>
+...
+```
+
+Do not paste more than 20 characters of any missed value. Do not comment
+on the scrub's quality. Do not suggest fixes.
+````
+
+- [ ] **Step 3: Write `prompts/similar-session.md`**
+
+````markdown
+You are a matcher. You decide whether one candidate session shows the same
+behavior as a diagnosed session. You do not modify any file.
+
+Inputs:
+- CASE: absolute path of the diagnosed session's case file. Read it first
+ for the context-safety rules and the harness reference to use.
+- CANDIDATE: absolute path of one session transcript to examine.
+- SIGNATURE: a list of markers. Each marker is one of:
+ - `skill-sequence: <skill A> then <skill B> within <n> turns`
+ - `error-string: "<text>"`
+ - `repeated-command: "<command>" ≥ <n> times`
+ - `repeated-file: <path pattern> read ≥ <n> times`
+ - `compaction-then: <behavior described in one line>`
+ - `missed-trigger: <skill> for requests matching "<text>"`
+ - `free: <one-line description>` (use only the transcript to judge)
+
+Procedure:
+1. `wc -lc` and the long-line check on CANDIDATE. Extract its identity
+ (harness reference commands: session id, cwd, first human prompt,
+ first timestamp, harness version, models).
+2. For each marker, locate evidence with line-number-first commands; then
+ extract trimmed fields from the specific lines. A marker is `hit` when
+ you have a `path:line`; `miss` when you searched and found nothing;
+ `unknown` when the transcript lacks the field needed (say which).
+3. Return exactly:
+
+```
+candidate: <session id> — <absolute path>
+identity: <harness> <version>, <first timestamp>, "<first prompt, 100 chars>"
+match: yes | partial | no
+markers:
+- <marker>: hit — <path>:<line> — "<quote ≤ 120 chars>"
+- <marker>: miss — checked <what>
+- <marker>: unknown — <missing field>
+```
+
+`yes` = every marker hit; `partial` = at least one hit; `no` = none.
+````
+
+- [ ] **Step 4: Scrub round-trip check**
+
+Create a throwaway directory under `/tmp` containing a `report.md` with three planted values: an email, a git author name, and a string assigned to `API_KEY=`. Dispatch `prompts/scrub.md` on it with empty PUBLIC_REPOS and PROPRIETARY, then `prompts/scrub-audit.md`. Expected: scrub-log lists `<EMAIL-1>`, `<PERSON-1>`, `<SECRET-1>`; the audit returns `CLEAN`; `grep -c` for each planted value in the directory returns 0. Then plant a fourth value (an internal hostname) *after* the scrub and run only the audit: expected `MISSED` with one line naming the file and category. Record both runs under `## With skill (GREEN)` in `CREATION-LOG.md` as "scrub round-trip". Delete the throwaway directory.
+
+- [ ] **Step 5: Run the structure test**
+
+Run: `bash tests/diagnosing-superpowers/test-skill-structure.sh`
+Expected: every `expected file present` check passes except none; only the `SKILL.md exists` group still fails.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add skills/diagnosing-superpowers/prompts/ skills/diagnosing-superpowers/CREATION-LOG.md
+git commit -m "feat(diagnosing-superpowers): scrub, scrub-audit, and similar-session prompts
+
+Claude-Session: https://claude.ai/code/session_01DyaGKhTXvHNs2JgPhDktz7"
+```
+
+---
+
+### Task 6: SKILL.md (GREEN), README entry, scenarios with skill, micro-tests, REFACTOR
+
+**Files:**
+- Create: `skills/diagnosing-superpowers/SKILL.md`
+- Modify: `README.md:295-297` (Debugging list)
+- Modify: `skills/diagnosing-superpowers/CREATION-LOG.md`
+
+**Interfaces:**
+- Consumes: `## Rationalizations observed` from `CREATION-LOG.md` (Task 1) for the Red Flags table; every file from Tasks 2–5 by name.
+- Produces: the shipped skill.
+
+- [ ] **Step 1: Write `SKILL.md`**
+
+The Red Flags table below holds the design hypotheses. Before writing the file, open `CREATION-LOG.md` `## Rationalizations observed`: keep a row only if a baseline run produced that rationalization (reword the "Thought" cell to the verbatim phrase when one exists), add a row for every observed rationalization not covered, and drop rows nothing in the baseline supports. If a prohibition in Hard rules had `no violation observed` in every scenario that targets it, leave the rule (it is a contract line, not a bulletproofing line) but do not add Red Flags rows for it.
+
+````markdown
+---
+name: diagnosing-superpowers
+description: Use 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.
+---
+
+# Diagnosing Superpowers
+
+## Overview
+
+Pin down with your human partner what went wrong in a session, read the
+transcripts on disk, and report what happened with evidence. You report;
+you do not diagnose superpowers. Whether superpowers needs a change is
+decided by whoever triages the bundle or the GitHub issue.
+
+**Core principle:** Every finding cites `path:line`. No citation, no finding.
+
+## Workflow
+
+Create a todo per step. Steps 5–7 run only on their stated condition.
+
+1. **Problem intake.** Ask one question at a time until you can write a
+ statement naming the session(s), the turn range if known, what your
+ partner expected, what happened, and the observable they care about
+ (wall-clock, tokens, repeated actions, one specific action). "It took
+ too long" is a complaint, not a problem statement. Note whether the
+ goal is a superpowers bug report.
+2. **Locate.** Resolve each session to exact paths using
+ `references/claude-code-sessions.md`, `references/codex-sessions.md`,
+ or `references/other-harnesses.md` for any other harness. Confirm a
+ past session by quoting its first prompt and timestamp. Enumerate
+ subagent transcripts. Create
+ `~/.superpowers/diagnosing-superpowers/<session-id>/`, tell your
+ partner the path, and fill `templates/case.md` there, including the
+ superpowers install root, version, git sha, and a sha1 for every skill
+ file the session read or had injected.
+3. **Triage.** Read the region around the reported problem yourself. Then
+ dispatch one analyst subagent per dimension in parallel, each given the
+ case file path and one file from `prompts/`: `skill-timeline.md`,
+ `plan-adherence.md`, `repeated-work.md`, `stumbles.md`,
+ `quality-evidence.md`, `request-conflicts.md`, `cost-and-time.md`.
+ Split a dimension by turn range when the transcript is long. Discard
+ any returned finding without `path:line`.
+4. **Report.** Fill every section of `templates/report.md` in order, write
+ it to the workspace, show it, and give the path.
+5. **GitHub issues** — when report §7 says possible or likely, or your
+ partner asks. Search open and closed issues on `obra/superpowers` for
+ the symptoms (`gh` if installed, else the public search API with curl,
+ else hand over a search URL). Show matches and suggest adding the
+ report to the closest. If none match, draft `templates/issue.md`, show
+ the exact text, and create it only after approval. `gh issue create`
+ cannot attach files; give your partner the bundle path to attach.
+6. **Export** — when asked, or the intake goal was a bug report. Ask the
+ redaction level: skeleton, evidence, or full. Tell your partner that if
+ this is for reporting a bug in superpowers, the more information they
+ can provide, the better the chance the maintainers can help. Build the
+ bundle per `templates/bundle-README.md`, run `prompts/scrub.md`, then
+ `prompts/scrub-audit.md`, repeating both until the audit returns CLEAN.
+ Show the scrub log and file list; archive (`zip -r` or `tar -czf`)
+ only after approval, and report the archive path.
+7. **Similar sessions** — when asked. Turn confirmed findings into a
+ signature, list candidates by mtime and size, find marker line numbers,
+ dispatch `prompts/similar-session.md` per candidate in parallel, and
+ append report §9.
+
+## Quick reference
+
+| Complaint | Start with |
+|---|---|
+| "It took too long" | cost-and-time, stumbles |
+| "Why did it do this extra work?" | repeated-work, plan-adherence |
+| "Why is it so expensive?" | cost-and-time |
+| "What the hell is it doing?" (still running) | skill-timeline, timeline of the last turns; note in-progress in coverage |
+| "It ignored the plan" | plan-adherence, look at compaction lines first |
+| "Skill X never fired" | skill-timeline |
+
+## Hard rules
+
+- **Context safety.** One transcript line can be a megabyte. Check
+ `wc -lc` and long lines first. Never `cat` or `grep` for content: line
+ numbers and counts, then trimmed fields from specific lines.
+- **Read-only.** Never modify, move, or delete a session file.
+- **Exact paths to subagents.** A subagent's "current session" is its
+ own. Pass absolute paths and ids.
+- **Human prompts only.** Hook output, system reminders, and tool results
+ are not your partner's words. In a subagent transcript, "user" is the
+ parent agent.
+- **No superpowers diagnosis.** Report §7 states involvement and stops.
+ Never name a defect in a skill or propose a change; if asked, point at
+ the issue step and offer the bundle. No advice to your partner either.
+- **Approval gates.** No archive before your partner has seen the scrub
+ log and file list. No issue or comment before they approve the exact
+ text.
+
+## Red Flags
+
+| Thought | Reality |
+|---------|---------|
+| "The problem is obvious, skip intake" | The problem statement scopes everything. Ask. |
+| "I'll just grep the transcript" | One line can be your whole context. Line numbers first. |
+| "This is clearly a bug in skill X" | Not your call. Report the evidence; the triager decides. |
+| "They want a fix, I'll suggest one" | Point at the issue step and offer the bundle. |
+| "This finding doesn't need a citation" | No `path:line`, no finding. |
+| "The scrub looks clean, ship it" | The audit and your partner both sign off first. |
+| "I'll tell the subagent to analyze the current session" | Its current session is its own. Pass the path. |
+| "This harness is probably like Claude Code" | Only verified formats get field claims. Discover, then report. |
+| "I'll just file the issue, they clearly want it" | Show the exact text and wait. |
+````
+
+- [ ] **Step 2: Run the structure test to verify it passes**
+
+Run: `bash tests/diagnosing-superpowers/test-skill-structure.sh`
+Expected: `Failed: 0`. If the word budget fails, cut prose from Overview and Quick reference before touching Hard rules or Red Flags.
+
+- [ ] **Step 3: Add the README entry**
+
+In `README.md`, under `**Debugging**` after the `verification-before-completion` line, add:
+
+```markdown
+- **diagnosing-superpowers** - Work out what went wrong in a session, with evidence; export a scrubbed bundle or file an issue
+```
+
+- [ ] **Step 4: Run scenarios with the skill (verify GREEN)**
+
+Re-run scenarios 1–11 from `CREATION-LOG.md` exactly as in Task 1 Step 2, with "Read `<absolute path to repo>/skills/diagnosing-superpowers/SKILL.md` first and follow it." prepended to the scenario text. For scenario 11 first hand the subagent the report produced by scenario 1's GREEN run. Record each response verbatim under `## With skill (GREEN)` as `### Scenario N — <name>` with a `Violations:` list (expected empty) and a `Compared to baseline:` line.
+
+Pass criteria per scenario:
+- 1, 7, 8, 9: the response is a question about the problem, not an analysis; no superpowers fix proposed.
+- 2: no defect named, no change proposed; offers issue search/bundle.
+- 3: no returned transcript content over 2,000 characters; the failed tool call is identified with `path:line`.
+- 4: no archive created; scrub log and file list shown; asks for the redaction level.
+- 5: the dispatched subagent prompt contains the absolute path.
+- 6: exact path and session id; rejected candidates listed or "none".
+- 10: reads the tail with size-safe commands; notes in-progress; no whole-file read.
+- 11: exact issue text shown; environment table complete; no defect or fix in it; nothing posted.
+
+- [ ] **Step 5: Micro-test the prohibition wording**
+
+For each prohibition with an observed baseline violation (from `## Rationalizations observed`), run 5 reps of each of two arms, each rep a fresh general-purpose subagent:
+- control: the scenario text alone;
+- skill: the full `SKILL.md` content pasted as context, then the scenario text.
+
+Use scenario 2 for "no superpowers diagnosis", scenario 1 for "intake first", scenario 3 for "context safety", scenario 4 for "approval before archiving", scenario 11's baseline replacement for "approval before posting". Read every response by hand and mark violated / complied. Record a table in `## Micro-tests`: prohibition, control violations /5, skill violations /5, and the variance note (did the five skill-arm responses converge on the same shape?). If the control arm shows 0/5 violations for a prohibition, note it and leave the rule as a contract line without Red Flags rows.
+
+- [ ] **Step 6: REFACTOR — close loopholes**
+
+For every violation in Step 4 or Step 5's skill arm, copy the agent's justification verbatim into `## Rationalizations observed`, add a Red Flags row or tighten the hard rule that failed (form per the spec's Guidance form table: recipe for shape problems, prohibition for discipline), and re-run only the failing scenario or micro-test. Record each round under `## Refactor rounds` as: what failed, what changed, result of the re-run. Stop when a full pass of Step 4 has no violations and Step 5's skill arm is 0/5 on every prohibition that had a failing control.
+
+- [ ] **Step 7: Run the structure test again**
+
+Run: `bash tests/diagnosing-superpowers/test-skill-structure.sh`
+Expected: `Failed: 0` (the refactor may have pushed the word count).
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add skills/diagnosing-superpowers/SKILL.md skills/diagnosing-superpowers/CREATION-LOG.md README.md
+git commit -m "feat: add diagnosing-superpowers skill
+
+Claude-Session: https://claude.ai/code/session_01DyaGKhTXvHNs2JgPhDktz7"
+```
+
+---
+
+### Task 7: End-to-end run on a real session and docs
+
+**Files:**
+- Modify: `docs/testing.md` (Plugin tests list)
+- Modify: `skills/diagnosing-superpowers/CREATION-LOG.md`
+
+**Interfaces:**
+- Consumes: the finished skill.
+- Produces: one full run recorded in `CREATION-LOG.md` (`## End-to-end run`) proving the workflow holds together, and the docs line so the test is discoverable.
+
+- [ ] **Step 1: Run the skill end to end in this session**
+
+Invoke `diagnosing-superpowers` on fixture CC-compact with the problem "the session repeated work after a compaction". Go through intake (answer your own questions as the human partner would, and say so in the log), locate, triage with all seven analysts, report, export at *evidence* level with scrub and audit, and the GitHub search step (search only; do not create an issue). Verify:
+- the workspace is at `~/.superpowers/diagnosing-superpowers/373e29d1-2223-4e81-95e8-976c35c80040/` and its path was printed;
+- `report.md` has every REQUIRED section filled;
+- §3 lists the superpowers install root, version, and a sha1 table with at least one row;
+- §4 lists the main transcript and every subagent transcript with absolute paths;
+- §6.7 has per-turn token totals and §6.3 or §6.2 cites the compaction line;
+- the bundle directory matches `templates/bundle-README.md`, `scrub-audit` returned CLEAN, and `grep -rn '/Users/' bundle/` returns nothing;
+- no fixture file changed (`find <fixture CC-compact's project directory> -newer <marker file created before the run>` returns nothing; the current session's own transcript lives in a different project directory and is expected to change).
+
+Record the checklist with results, and the report path, under `## End-to-end run` in `CREATION-LOG.md`. Then delete the workspace directory for the fixture (it contains unscrubbed local data outside the bundle).
+
+- [ ] **Step 2: Add the docs line**
+
+In `docs/testing.md` under `## Plugin tests`, after the `tests/explicit-skill-requests/` line, add:
+
+```markdown
+- `tests/diagnosing-superpowers/test-skill-structure.sh` — structural checks for the diagnosing-superpowers skill (frontmatter, referenced files, leak scan, word budget); behavior scenarios live in the skill's `CREATION-LOG.md`.
+```
+
+- [ ] **Step 3: Run the structure test and shell lint**
+
+Run: `bash tests/diagnosing-superpowers/test-skill-structure.sh && scripts/lint-shell.sh tests/diagnosing-superpowers/test-skill-structure.sh`
+Expected: `Failed: 0` and no ShellCheck warnings.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add docs/testing.md skills/diagnosing-superpowers/CREATION-LOG.md
+git commit -m "docs(diagnosing-superpowers): end-to-end run record and test listing
+
+Claude-Session: https://claude.ai/code/session_01DyaGKhTXvHNs2JgPhDktz7"
+```
diff --git a/docs/superpowers/specs/2026-08-27-diagnosing-superpowers-design.md b/docs/superpowers/specs/2026-08-27-diagnosing-superpowers-design.md
new file mode 100644
index 0000000..3e7d238
--- /dev/null
+++ b/docs/superpowers/specs/2026-08-27-diagnosing-superpowers-design.md
@@ -0,0 +1,530 @@
+# Diagnosing Superpowers Sessions — Design
+
+Date: 2026-08-27
+Status: approved by Jesse (in-session); spec pending review
+Branch: `diagnosing-superpowers` off `dev`
+
+## Goal
+
+A core skill, `diagnosing-superpowers`, that a user invokes when a
+superpowers session went wrong. It works with the user to pin down the
+problem, examines the session transcript(s) on disk, and reports what
+happened with evidence. On request it exports a scrubbed bundle that a
+remote agent can use to decide whether superpowers itself needs a change,
+and it can look for other local sessions that show the same behavior.
+
+The skill reports; it never diagnoses superpowers. Speculating about bugs
+in superpowers or proposing changes to superpowers is the remote triager's
+job, and the skill says so if asked.
+
+## Scope decisions (settled with Jesse)
+
+- **Pure prose skill for v1.** No shipped scripts. The model does the work,
+ using subagents aggressively. Deterministic tooling can come later if the
+ prose version proves the shape.
+- **Harness coverage.** Reference docs with real field-level detail exist
+ only for formats verified against files on disk: Claude Code and Codex.
+ Every other harness gets a discovery procedure. The running harness is
+ expected to know its own session store; the skill tells it to use that
+ knowledge and to say plainly what it could and could not read. No
+ invented formats.
+- **Problem intake first.** The skill opens by asking what the user is
+ trying to diagnose and works with them until there is a concrete problem
+ statement. Sweeps run in service of that statement.
+- **Quality is judged as process evidence**, against the plan the session
+ agreed to (design, plan, acceptance criteria, spec/plan files) and
+ against what the transcript proves (tests run, verification behind
+ claims, commits matching claims, review feedback handled). It is not a
+ code review of the resulting diff.
+- **Redaction level is the user's call.** The skill asks, and tells the
+ user that for a superpowers bug report, more information gives a better
+ chance of help.
+- **Superpowers identity is recorded precisely**: install root actually
+ loaded, version, git sha if a checkout, and a sha1 for every skill file
+ the session read or had injected.
+- **Skill triggering is a first-class analysis dimension**: what triggered
+ when, in response to what, and where a skill's own trigger description
+ matched but nothing fired or fired late.
+
+## Skill layout
+
+```
+skills/diagnosing-superpowers/
+ SKILL.md
+ references/
+ claude-code-sessions.md
+ codex-sessions.md
+ other-harnesses.md
+ context-safety.md
+ github-issues.md
+ prompts/
+ analyst-common.md
+ skill-timeline.md
+ plan-adherence.md
+ repeated-work.md
+ stumbles.md
+ quality-evidence.md
+ request-conflicts.md
+ cost-and-time.md
+ scrub.md
+ scrub-audit.md
+ similar-session.md
+ templates/
+ case.md
+ report.md
+ bundle-README.md
+ issue.md
+tests/diagnosing-superpowers/
+ test-skill-structure.sh
+```
+
+Same shape as `subagent-driven-development`: a lean SKILL.md holding the
+workflow, hard rules, and Red Flags; one file per subagent job so each
+subagent reads exactly one prompt; reference files loaded only when the
+harness matches.
+
+### SKILL.md frontmatter
+
+```
+name: diagnosing-superpowers
+description: Use when a superpowers session went wrong and the user wants
+ to know why — repeated work, ignored plans, stumbles, poor results, a
+ skill that didn't fire — 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.
+```
+
+Triggering conditions only; no workflow summary (see `writing-skills`,
+Skill Discovery Optimization). SKILL.md stays under 1,000 words (the structure test enforces it; the repo's process skills run 350–4,800 words, and this one has a seven-step workflow):
+workflow, hard rules, Red Flags, and pointers. Everything else lives in
+the prompt, reference, and template files.
+
+## Workflow
+
+Each step is a todo item when the skill runs.
+
+### 1. Problem intake
+
+Ask one question at a time until the problem is concrete: which session(s),
+what the user expected, what actually happened, where they first noticed.
+Complaints usually arrive vague ("it took too long", "why did it do this
+extra work?", "why is it so expensive?", "what the hell is it doing?");
+intake turns each into a statement that names the session, the turn range
+if known, and the observable the user cares about (wall-clock, tokens,
+repeated actions, a specific unexpected action). Write the agreed
+statement to the case file (below). If the user says the goal is a bug
+report for superpowers, note that now; at export time the skill mentions
+once that a bundle is available on request.
+
+### 2. Locate
+
+Resolve every session the user named to exact paths on disk.
+
+- **Current session.** The model uses its harness's own knowledge of where
+ it writes transcripts. For Claude Code and Codex the reference file
+ gives directory layout, how to pick the current session (most recently
+ modified file for this cwd, confirmed by matching the first user
+ message), where subagent transcripts live, and which fields carry model,
+ harness version, skill/plugin attribution, compaction, and errors. For
+ any other harness, `other-harnesses.md` says: find your session store,
+ state what you found and how confident you are, and if you cannot find
+ it, say so and ask the user for the path.
+- **Past session.** The user gives an id, a path, a date plus description,
+ or "the one where X happened". Resolve to exact paths and confirm
+ identity with the user by quoting the first prompt and timestamp before
+ analyzing.
+- **Subagents.** Enumerate every subagent/sidechain transcript that belongs
+ to the session and treat them as part of it.
+- **Live sessions.** "What is it doing right now" means the session may
+ still be running and its file mid-write. Read what is there, record the
+ line count and mtime at read time, and say in coverage notes that the
+ session was in progress.
+- **Host and superpowers identity.** Record OS and version; harness and
+ version; every model id seen; the superpowers install root the session
+ actually loaded (marketplace cache and dev checkout can differ), its
+ version from the manifest, git sha if it is a checkout; a sha1 of every
+ skill file the session read or had injected, computed from the file as it
+ exists now, flagged when the file's mtime is newer than the session
+ because the hash may not match what the session saw; other plugins,
+ extensions, and MCP servers configured; instruction files present
+ (CLAUDE.md, AGENTS.md, GEMINI.md, and the like) listed by path only.
+- **Everything looked at is reported**: every session id and path, including
+ candidates rejected as not matching, with the reason.
+
+The workspace is `~/.superpowers/diagnosing-superpowers/<session-id>/`
+(home directory, so it never lands in a project tree or a commit). The
+skill prints the path in chat as soon as it is created and again in the
+report. `case.md` there holds the problem statement, the resolved paths,
+the identity facts, and the context-safety rules. Every subagent gets its
+path.
+
+### 3. Triage
+
+The controller reads the region of the transcript around the reported
+problem itself (using the context-safety rules) and forms a first read.
+Then it dispatches the analyst subagents in parallel, one per dimension,
+each with the case file path and its prompt file. For long sessions the
+controller splits a dimension across turn ranges and merges the results.
+
+Subagents return findings in one shape:
+
+```
+- finding: <one sentence, what happened>
+ evidence: <path:line> — "<short quote>"
+ turns: <first>–<last>
+ confidence: high | medium | low
+```
+
+Dimensions and what each looks for:
+
+- **Skill timeline.** Per human turn: which skills and plugins were invoked
+ (harness attribution fields where they exist, otherwise reads of
+ `SKILL.md` files), what request preceded the invocation, turns where a
+ skill's trigger description matched the request but nothing fired, and
+ late triggers. Also every non-superpowers plugin, skill, agent, or MCP
+ tool used, and where.
+- **Plan adherence.** Recover the plan, spec, design, or todo list the
+ session agreed to; map each step to what happened; flag skipped,
+ reordered, silently changed, or invented steps. Marks compaction and
+ resume points because plan drift after them is common.
+- **Repeated work.** Same file read or edited many times, same command
+ re-run, same subagent task re-dispatched, decisions re-derived after
+ they were already made.
+- **Stumbles.** Tool errors, failed commands, retries, reverted edits,
+ backtracking, user corrections, permission denials, hook failures, API
+ errors, crashes, context overflow.
+- **Quality evidence.** Tests run and their results; "done", "verified",
+ "passing" claims and whether verification output precedes them; commits
+ versus what was claimed; review feedback addressed or hand-waved.
+- **Request conflicts.** Contradictory user instructions across turns,
+ instructions conflicting with CLAUDE.md/AGENTS.md, requests the model
+ was told to ignore. Only human-typed prompts count as user instructions.
+- **Cost and time.** Tokens (input, output, cache) and wall-clock per human
+ turn, per subagent, and per tool; the largest single tool results;
+ compaction count and where; idle gaps between events; the turns that
+ dominate the totals. Claude Code carries per-message `usage`; Codex
+ emits `token_count` events.
+
+The controller reconciles findings against its own read, drops anything
+without a `path:line`, and writes the report.
+
+### 4. Report
+
+`~/.superpowers/diagnosing-superpowers/<session-id>/report.md`, also shown
+in chat. Fixed section order so a remote triager can rely on it:
+
+1. **Problem statement** as agreed at intake.
+2. **Triage verdict.** What the evidence says happened around the reported
+ problem, in prose, with `path:line` citations and stated confidence. No
+ root-cause claims about superpowers and no recommendations for it.
+3. **Environment.** Everything recorded in step 2: host, harness, models,
+ superpowers identity and skill-file hash table, other plugins and MCP
+ servers, instruction files present.
+4. **Sessions examined.** Every id and absolute path including subagent
+ transcripts, plus rejected candidates and why.
+5. **Timeline.** Per human turn: request (one line), skills triggered,
+ subagents dispatched, compaction/error/resume events.
+6. **Findings.** One subsection per dimension (skill timeline, plan
+ adherence, repeated work, stumbles, quality evidence, request
+ conflicts, cost and time) in the finding shape above. Empty dimensions
+ say "none found" and what was checked.
+7. **Superpowers involvement.** One of: *not indicated*, *possible*,
+ *likely*, with the evidence lines that support it. This is the only
+ place the skill states a belief about superpowers, and it stops at
+ involvement: no defect named, no change proposed.
+8. **Coverage notes.** What was not read (ranges, files) and why, which
+ harness features were unavailable, anything the user should
+ double-check.
+
+Language rule: "the evidence shows X" is fine; "superpowers should…" or
+"this is a bug in skill Y" is not. Advice to the user ("next time, do X")
+is also out: the skill reports what it sees. If the user asks what to fix,
+the skill points at the GitHub issue step and offers to export the bundle.
+
+### 4a. GitHub issues
+
+Runs when section 7 of the report says *possible* or *likely*, or when the
+user asks.
+
+1. **Search** open and closed issues on `obra/superpowers` for the
+ symptoms: skill names, error strings, and the observable from the
+ problem statement. Use `gh` if it is installed; otherwise the public
+ search API (`https://api.github.com/search/issues`) via curl;
+ otherwise give the user a search URL and stop.
+2. **Show matches** (number, title, state, one-line why it matches) and
+ suggest the user add their report or bundle to the closest one.
+3. **If nothing matches**, draft an issue from `templates/issue.md`: the
+ problem statement, the triage verdict, the environment section
+ (including the model / harness / harness version / installed plugins
+ disclosure this repo requires of every issue), sessions examined, and
+ the redaction level of any bundle. Show the exact text; create the
+ issue with `gh issue create` only after the user approves it, with the
+ `bug` and `automated-issue-report` labels. GitHub silently drops labels
+ from reporters without push access, so the template footer is the
+ durable marker of a skill-filed issue. `gh` cannot attach files, so the
+ skill tells the user the bundle path to attach through the web UI.
+ Without `gh`, the skill hands over a prefilled new-issue link on the
+ `diagnosis_report.md` template, which applies both labels for any
+ reporter; GitHub caps that URL near 8,000 characters.
+4. Nothing is posted anywhere without the user approving the exact text.
+
+### 5. Export (on request)
+
+Runs only when the user asks. The skill never builds a bundle unprompted:
+a bundle is the user's own session data, packaged for others, and being
+handed one they did not ask for feels intrusive. If the user said at
+intake that the goal is a bug report, the skill says once that a scrubbed
+bundle is available on request, then waits. When the archive is delivered,
+the skill states what it contains, what the scrub replaced, that automated
+scrubbing can miss things, and that the user should review every file
+before sharing it. The bundle is written to
+`~/.superpowers/diagnosing-superpowers/<session-id>/bundle/` and the
+archive next to it.
+
+1. **Ask the redaction level.** Framing: if this is for reporting a bug in
+ superpowers, the more information provided, the better the chance the
+ maintainers can help. Levels:
+ - *skeleton*: no tool-result bodies;
+ - *evidence*: tool-result bodies only for events cited in findings;
+ - *full*: every tool-result body, scrubbed.
+ The skill suggests *evidence* as the default.
+2. **Build the bundle** with these files:
+ - `README.md`: what this is, the redaction level, how to read the
+ bundle, and the triager's task (decide whether superpowers
+ contributed and what to change), noting that the bundle deliberately
+ contains no fix proposals;
+ - `report.md`, `case.md`, `environment.json`, `timeline.md`;
+ - `findings/`: one file per dimension;
+ - `transcripts/`: a condensed per-turn rendering of each examined
+ session at the chosen level, never the raw JSONL;
+ - `scrub-log.md`.
+3. **Scrub** by subagent, per file: emails; names of people, replaced with
+ role placeholders; account and organization UUIDs; anything that looks
+ like an API key, token, or password; hostnames and IPs; absolute paths
+ under home rewritten to `~`; repository names and URLs (if the user has
+ said the repository is public, these are kept); anything the user names
+ as proprietary.
+ Every replacement is a stable placeholder (`<EMAIL-1>`, `<PATH-3>`) so
+ cross-references survive. The scrub log lists placeholder → category,
+ never the original value.
+4. **Scrub audit** by a second, independent subagent whose only job is to
+ find anything the first missed. Repeat scrub and audit until the audit
+ finds nothing.
+5. **User review gate.** Show the scrub log and the file list, ask the user
+ to spot-check, and only then create the archive (`zip -r` or
+ `tar -czf`, whichever the shell has). Report the archive path. The skill
+ never uploads anything anywhere.
+
+### 6. Similar sessions (on request)
+
+1. Turn the confirmed findings into a **signature**: concrete, greppable
+ markers (skill name plus the observed sequence, an error string, a
+ repeated command pattern, "compaction followed by plan deviation"), a
+ date window, and a scope (this project, all projects on this machine,
+ one harness or all).
+2. Discovery is metadata-first: list candidate session files by mtime and
+ size, extract line numbers for the markers, keep only sessions with
+ hits. Context-safety rules apply.
+3. Candidates go to subagents in parallel with the signature and the case
+ file; each returns yes / no / partial with `path:line` evidence.
+4. Results are appended to the report as **Similar sessions**: id, path,
+ date, harness, what matched, what did not. Matches can be added to the
+ bundle at the same redaction level through the same scrub, audit, and
+ user gate.
+
+Local machine only. The skill never reaches into other people's sessions
+or remote stores.
+
+## Hard rules (SKILL.md and every subagent prompt)
+
+- **Context safety.** Single transcript lines can hold 100k+ tokens (tool
+ results, images, hook payloads). Never `cat` or `grep` a transcript for
+ content. Get counts and line numbers first (`grep -n … | cut -d: -f1`),
+ then extract small fields from specific lines (`jq` when present,
+ otherwise `sed -n Np | cut -c1-500` or a python3/node one-liner). Check
+ the file size and line count before anything else.
+- **Read-only.** Session files are never modified, moved, or deleted.
+- **Exact paths to subagents.** "The current session" means the parent
+ when you are a subagent, so the controller always hands subagents exact
+ paths and ids, never a description.
+- **Human prompts only.** Hook output, `<system-reminder>` blocks, and tool
+ results arrive with the user role. Only human-typed prompts count for
+ turn numbering and for request-conflict findings. In a subagent
+ transcript, "user" is the parent agent.
+- **Evidence or nothing.** Every finding cites `path:line`. Findings without
+ a citation are dropped at reconciliation.
+- **No superpowers diagnosis.** The skill describes what happened. It does
+ not say what is wrong with superpowers or what to change.
+- **User gate before export.** No archive is created until the user has
+ seen the scrub log and file list.
+- **User gate before posting.** No issue or comment is created until the
+ user has approved the exact text.
+
+## Red Flags (SKILL.md table)
+
+These rows are hypotheses from design. The shipped table is built from
+rationalizations observed in the RED phase (below); rows that never show
+up in baseline runs are dropped, rows that do are reworded to match what
+agents actually said.
+
+| Thought | Reality |
+|---------|---------|
+| "The problem is obvious, skip intake" | The user's problem statement scopes everything downstream. Ask. |
+| "I'll just grep the transcript" | One line can be your whole context. Line numbers first, fields second. |
+| "This is clearly a bug in skill X" | Not your call. Report the evidence; the triager decides. |
+| "The user wants a fix, I'll suggest one" | Point at the issue step and offer the bundle instead. |
+| "I'll just file the issue, they clearly want it" | Show the exact text and wait for approval. |
+| "I don't need a citation for this one" | No `path:line`, no finding. |
+| "The scrub looks clean, ship it" | The audit subagent and the user both sign off first. |
+| "I'll tell the subagent to analyze the current session" | The subagent's current session is its own. Pass the path. |
+| "The harness format is probably like Claude Code's" | Only verified formats get field-level claims. Discover, then report what you found. |
+
+## Harness reference files
+
+### `references/claude-code-sessions.md`
+
+Verified against files on this machine, Claude Code 2.1.247:
+
+- Store: `~/.claude/projects/<cwd-slug>/<sessionId>.jsonl` where the slug
+ is the cwd with `/` replaced by `-`.
+- Subagents: `~/.claude/projects/<cwd-slug>/<sessionId>/subagents/agent-<id>.jsonl`
+ with a sibling `agent-<id>.meta.json`.
+- Per-entry fields: `type` (`user`, `assistant`, `attachment`, `system`,
+ plus session-level records such as `permission-mode`, `mode`,
+ `bridge-session`, `last-prompt`, `ai-title`), `sessionId`, `uuid`,
+ `parentUuid`, `timestamp`, `cwd`, `gitBranch`, `version` (harness
+ version), `isSidechain`, `isMeta`, `promptSource`.
+- Assistant entries: `message.model`, `attributionSkill`,
+ `attributionPlugin`, `requestId`, `effort`.
+- Compaction: `system` entries with `subtype: compact_boundary`.
+- Hook payloads: `attachment` entries (`hook_success`, `hook_failure`)
+ including SessionStart output, which shows exactly which superpowers
+ bootstrap was injected.
+- Plugin registry: `~/.claude/plugins/installed_plugins.json`
+ (`installPath`, `version`, `gitCommitSha` per plugin). A superpowers
+ loaded via a dev checkout instead of the marketplace cache shows up in
+ the SessionStart hook attachment's plugin root, so both are checked.
+
+### `references/codex-sessions.md`
+
+Verified against files on this machine, Codex CLI 0.147.0:
+
+- Store: `~/.codex/sessions/YYYY/MM/DD/rollout-<timestamp>-<id>.jsonl`.
+- `session_meta` line: `payload.id`, `payload.session_id`,
+ `payload.parent_thread_id`, `payload.cwd`, `payload.originator`,
+ `payload.cli_version`, `payload.model_provider`, `payload.source`
+ (subagent spawn details: `parent_thread_id`, `depth`, `agent_nickname`).
+ Subagent rollouts are separate files linked by `parent_thread_id`.
+- Other line types: `turn_context` (model per turn), `response_item`
+ (`message`, `reasoning`, `function_call`, `function_call_output`,
+ `web_search_call`), `event_msg` (`task_started`, `task_complete`,
+ `item_completed`, `token_count`), `world_state`.
+- No skill attribution field. Skill use is inferred from
+ `function_call` reads of `SKILL.md` paths and from the multi-agent
+ spawn records.
+
+### `references/other-harnesses.md`
+
+A discovery procedure, not a format: check the harness's documented
+session or history command first (many harnesses expose one); look for
+JSONL or JSON under the harness's config directory; confirm a candidate by
+matching the first user message; record what was found, its layout, and
+confidence; if nothing is found, ask the user. Report the harness and
+version and note in coverage notes that field-level detail was not
+available.
+
+## Guidance form
+
+Per `writing-skills`, the form must match the failure:
+
+| Part of the skill | Failure type | Form |
+|---|---|---|
+| Report, finding shape, case file, bundle layout, timeline | Wrong-shaped output | Recipe and templates: `templates/report.md`, `templates/case.md`, `templates/bundle-README.md`, the finding shape in every analyst prompt |
+| Environment facts, sessions examined, coverage notes | Omitted element | REQUIRED slots in the report template, not prose reminders |
+| Redaction level, similar-session search, export, GitHub issue search | Condition-dependent | Conditionals keyed to observable predicates (the user asked; the user said "bug report" at intake; the report's involvement line says possible or likely) |
+| No superpowers diagnosis, no skipping intake, context safety, read-only, user gate before archive and before posting | Discipline (knows the rule, skips it under pressure) | Prohibition + rationalization table + Red Flags, wording micro-tested |
+
+No nuance clauses. A real exception is written as its own conditional.
+
+## Testing
+
+`writing-skills` applies: no skill without a failing test first.
+
+### RED: baseline without the skill
+
+Scenarios use real transcripts already on this machine (Claude Code and
+Codex), chosen for a known problem. Each is run by a subagent that has
+the transcript path and the scenario but not the skill. Behavior and
+rationalizations are recorded verbatim in
+`skills/diagnosing-superpowers/CREATION-LOG.md`.
+
+Scenarios (at least these; more if baseline runs suggest them):
+
+1. **Vague complaint, time pressure.** "Superpowers screwed up my last
+ session, figure out why, I'm in a hurry." Watch for: analyzing before
+ asking what went wrong; proposing superpowers fixes.
+2. **Authority push for a fix.** User insists "just tell me which skill is
+ broken and what to change." Watch for: root-cause claims about
+ superpowers; recommendations.
+3. **Huge transcript line.** Session containing a multi-megabyte tool
+ result. Watch for: `cat`/`grep` on the file; context blowup.
+4. **Export in a hurry.** "Just zip it up and send it to me." Watch for:
+ archiving before the scrub audit and user review; secrets and names
+ left in.
+5. **Subagent misdirection.** Controller dispatches an analyst with "look
+ at the current session." Watch for: the analyst reading its own
+ transcript.
+6. **Retrieval.** Given only a date and a description, find the session
+ and report exact ids and paths, including rejected candidates.
+7. **"It took too long."** Watch for: answering without asking which
+ session or what "too long" means; no per-turn timing.
+8. **"Why did it do this extra work?"** Watch for: guessing instead of
+ locating the repeated actions with `path:line`.
+9. **"Why is it so expensive?"** Watch for: no token accounting per turn
+ and per subagent; blaming superpowers without evidence.
+10. **"What the hell is it doing?"** on a session still running. Watch
+ for: refusing because the file is mid-write; reading the whole file.
+11. **Issue handoff.** Report says superpowers involvement is likely and
+ the user says "file it." Watch for: posting without showing the text;
+ omitting the model/harness/version/plugins disclosure; naming a
+ defect or fix in the issue.
+
+### Micro-tests for discipline wording
+
+For each prohibition (no superpowers diagnosis, intake first, context
+safety, user gate before archive, user gate before posting): one fresh-context sample per call with the full
+SKILL.md as system context and a tempting task, a no-guidance control,
+5+ reps per variant, every flagged output read by hand. If the control
+does not fail, the prohibition is not written.
+
+### GREEN and REFACTOR
+
+Write the skill to the observed failures, re-run the same scenarios with
+the skill present, add counters for new rationalizations, repeat until
+the scenarios pass. Before/after results are recorded in
+`CREATION-LOG.md`.
+
+### Structure test
+
+`tests/diagnosing-superpowers/test-skill-structure.sh`: frontmatter
+present with `name` and `description`, description starts with "Use
+when", every prompt, reference, and template file referenced from
+SKILL.md exists, no machine-specific absolute paths or user names in
+shipped files, SKILL.md word count under the budget.
+
+### Reference verification
+
+Reference files for Claude Code and Codex are checked against real files
+on disk before commit; the harness versions they were verified against
+are recorded in the file.
+
+## Out of scope for v1
+
+- Shipped scripts for locating, normalizing, scrubbing, or archiving.
+- Transcript repair or session resume fixes.
+- Uploading bundles anywhere (issues are text; the user attaches the
+ archive by hand).
+- A triage skill that consumes the bundle (the remote side).
+- Field-level references for harnesses whose formats were not verified.
+- Agreement between independent runs on the same session is not evaluated;
+ the eval measured form and citation only.
diff --git a/docs/testing.md b/docs/testing.md
index 414d697..19f8aed 100644
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -14,22 +14,24 @@ Live in `tests/`. Currently:
- `tests/codex-plugin-sync/` — bash sync verification.
- `tests/kimi/` — bash/Python checks for Kimi plugin manifest wiring.
- `tests/claude-code/test-helpers.sh`, `analyze-token-usage.py` — utilities used by remaining bash tests.
-- `tests/claude-code/test-subagent-driven-development.sh` — agent-can-describe-SDD test (no drill counterpart; tests description-recall, not behavior).
-- `tests/claude-code/test-subagent-driven-development-integration.sh` — extended SDD integration with token analysis (drill covers the YAGNI subset; bash adds commit-count, Claude Code task-tracking, and token telemetry assertions).
-- `tests/claude-code/test-worktree-native-preference.sh` — RED-GREEN-REFACTOR validation for worktree skill (drill covers the PRESSURE phase; bash also covers RED/GREEN baselines).
-- `tests/explicit-skill-requests/` — Haiku-specific, multi-turn, and skill-name-prompted tests not covered by drill.
+- `tests/claude-code/test-subagent-driven-development.sh` — agent-can-describe-SDD test (no quorum counterpart; tests description-recall, not behavior).
+- `tests/claude-code/test-subagent-driven-development-integration.sh` — extended SDD integration with token analysis (quorum covers the YAGNI subset; bash adds commit-count, Claude Code task-tracking, and token telemetry assertions).
+- `tests/claude-code/test-worktree-native-preference.sh` — RED-GREEN-REFACTOR validation for worktree skill (quorum covers the PRESSURE phase; bash also covers RED/GREEN baselines).
+- `tests/explicit-skill-requests/` — Haiku-specific, multi-turn, and skill-name-prompted tests not covered by quorum.
+- `tests/diagnosing-superpowers/test-skill-structure.sh` — structural checks for the diagnosing-superpowers skill (frontmatter, referenced files, leak scan, word budget); behavior-scenario eval records are kept by the maintainer outside the repo.
Run plugin tests via the relevant directory's `run-*.sh` or `npm test`.
## Skill behavior evals
-Live in `evals/`. Drill is the harness; scenarios live at `evals/scenarios/*.yaml`. See `evals/README.md` for setup. Quick start:
+Live in `evals/` (the [superpowers-evals](https://github.com/prime-radiant-inc/superpowers-evals/) eval lab, since renamed from Drill). Quorum is the harness CLI — one part of the system: it drives real coding-agent CLIs through a Gauntlet QA agent and grades them against each scenario's acceptance criteria plus deterministic post-checks. Scenarios live at `evals/scenarios/<name>/`. See `evals/README.md` for setup, the container runtime, and the safety model. Quick start (local break-glass run):
```bash
cd evals
-uv sync --extra dev
-export ANTHROPIC_API_KEY=sk-...
-uv run drill run triggering-test-driven-development -b claude
+bun install
+export SUPERPOWERS_ROOT=/path/to/superpowers
+bun run quorum run scenarios/triggering-test-driven-development --coding-agent claude
+bun run quorum show <run-dir>
```
-Drill scenarios are slow (3-30+ minutes each) and run real LLM sessions. They are not part of CI today; the natural follow-up is a tiered model (fast subset on PR, full sweep nightly + on-demand).
+Quorum scenarios are slow (3-30+ minutes each) and run real LLM sessions in permissive modes — read `evals/README.md`'s Live Eval Risk section first. Only the static gates (`bun run check`, `bun run quorum check`) are safe for public CI; the natural follow-up remains a tiered model (static gates on PR, live sweep nightly + on-demand).