Opus Pocus

---
name: opus-pocus
description: The grand ritual — run the Opus Pocus audit passes over this repo's Claude instruction layer (memory files, hooks, skills, agents) and its automation layer, then emit The O.W.L. report with a grade per spell and a fix table you approve from. Triages first, so passes with no subject in your repo are marked N/A rather than run. Use for "audit this repo for Opus 5", "run opus pocus", "de-hex this repo", "why does Opus behave badly here", or any request to modernize Claude instructions for the 5-family. Read-only until you approve fixes; passes are bounded, and a repo with no memory file is routed to the one pass that authors a starter instead of being graded on a vacuum. NOT for auditing application code — the instruction and automation layers only.
---

# 🪄 Opus Pocus — the Grand Ritual

> *Wave wand over repo. Curses removed. Opus behaves.*

Runs the curriculum: read-only audit passes over the repo's Claude instruction and automation
layers, one consolidated report, then fixes only after the user approves them.

**Before anything else, read [`references/casting-safety.md`](references/casting-safety.md).** It
holds the ten bounds every pass runs under. They exist because this toolkit is run *by* the model
it is written about: unbounded, the audit becomes the disease it treats.

**If the full set is more than you want loaded every session, run
[`configure`](../configure/SKILL.md) first.** It reads the same repo shape this ritual triages on
and writes a profile — so the spells with no subject here stop costing their descriptions in
every session, not just this one. Triage decides what runs *now*; configure decides what loads
*at all*. One detector, two tempos.

## Scope

The instruction layer, **discovered rather than assumed**. Resolve the memory files first:

```sh
ls CLAUDE.md AGENTS.md CLAUDE.local.md 2>/dev/null
find . -name 'CLAUDE.md' -o -name 'AGENTS.md' | grep -v node_modules | head -50
ls .claude/rules/ .cursor/rules/ .github/copilot-instructions.md 2>/dev/null
```

Whatever that finds is "the memory file" for every spell in this book. `AGENTS.md` is graded
exactly as `CLAUDE.md` is, a nested-only layout with no root file is a valid shape rather than an
empty one, and `~/.claude/CLAUDE.md` is included only if the user opts in.

Then the rest of the layer: `.claude/hooks/`, `.claude/skills/`, `.claude/agents/`,
`.claude/commands/`, `.claude/rules/`, hook wiring in settings files, and any output-style or
system-prompt files the repo carries. Plus the automation those files describe — the hooks, gates,
lints and verifiers themselves, judged on what they actually do rather than what they claim.

**If the resolution finds no memory file at all, do not run the curriculum — run
[`the-room-of-requirement`](../the-room-of-requirement/SKILL.md) instead:**

> *"This repo has no Claude instruction layer, so there is nothing to de-hex. What you want is a
> starter memory file — build and test commands, the two or three conventions a new contributor
> gets wrong. `the-room-of-requirement` derives one from this repo's own machinery and proposes
> it; the rest of the book grades instructions once they exist."*

Running the curriculum over an absent layer and grading it Outstanding is this book's own
`nihil-revelio` class 1.

Out of scope: application source, dependencies and vendored trees, lockfiles, build output,
`.git`, and other installed plugins — **including this one**. If Opus Pocus is installed in the
target repo, skip its own directory and say so; auditing the auditor produces findings about a
tool the user did not ask you to review.

## Procedure

**Phase 0 — inventory and consent.** List every instruction and automation artifact with size.
This is the denominator every pass reports against; a pass that examined nothing says
`SCANNED NOTHING`, never "clean".

Then, before running the curriculum, state the cost and get agreement:

```
Scope:    <N> memory files, <N> hooks, <N> skills, <N> agents  (<N> KB total)
Plan:     <N> passes with a subject here, read-only  (<N> marked N/A — see triage)
Excluded: <the fence — app source, dependencies, other plugins, this plugin>
```

On a large layer, offer a narrowed run — one class, one spell, or one directory — before starting.
A ritual that announces its price afterwards is one the user cannot refuse.

**Phase 0.5 — triage.** From the inventory, mark each pass `RUN` or `N/A` **before running any of
it**, and print the triage table first. A pass is `N/A` when its subject count is zero:

| Pass | Requires | `N/A` when |
|---|---|---|
| `finite-recursum` | memory files; hooks for classes 2 and 6 | no memory file (class 1 has no instances without a Stop-class hook — see that spell) |
| `clarificus-maxima` | any instruction text | no memory file, no skills, no agents |
| `quietus-capslockius` | any instruction text | as above |
| `contradicto-revelio` | ≥2 instruction sources | a single memory file and nothing else |
| `sorting-hat` | agent definitions | 0 agents |
| `descriptio-reducio` | skills or agents | 0 of both |
| `muffliato-hookus` | hooks that inject context | 0 hooks |
| `obliviate-fossilium` | a memory file | none found |
| `accio-rulebook` | a root memory file large enough to be worth splitting | smaller than ~200 lines, or no root file |
| `legilimens-anthropica` | network access | offline — report `?`, not `O` |
| `avada-verbosa` | a Pensieve baseline | no baseline yet — a **prerequisite**, not `N/A` |
| `the-pensieve` | counters with a live subject | drop individual counters whose subject is zero |
| `priori-incantato` | automation artifacts | 0 hooks, 0 repo-owned lints, 0 agents, 0 skills |
| `nihil-revelio` | checks **you own and can change** | only vendor tools (`eslint`, `pytest`, `tsc`) |
| `alohomora` | blocking guards **you wrote** | no repo-owned blocking guards |
| `the-remembrall` | a readable transcript store for this repo | no transcripts — report `?`, not `O` |
| `tempus-mutatur` | an establishable "written for" era | the era cannot be established — `?`, not `O` |
| `the-room-of-requirement` | **no memory file** — its row is the inverse of every other | a memory file already exists |
| `protego` | instruction artifacts to watch | nothing for it to watch |

This table is also what [`configure`](../configure/SKILL.md) reads to pick a profile: a pass that
is `N/A` here is one whose description need not be loaded in future sessions either. Keeping the
two in one place is what stops them disagreeing about the same repo.

**If fewer than five passes are `RUN`, say so up front**, before running them:

> *"This repo has a small instruction layer. N of the passes have a subject here; the rest are
> N/A. The O.W.L. below grades the N."*

That is a better first impression than a report that is two-thirds vacuum, and it is the honest
one. An audit that grades an absent layer is the thing this book was written to stop.

**Phase 0.6 — calibration.** Run `legilimens-anthropica` before the graded passes when the
network is available. It fetches current guidance, and its findings recalibrate the other passes'
thresholds — so it has to run *before* the passes that use them, not alongside them in Divination
where its class puts it. Class is taxonomy; phase is execution order.

**Phase 1 — Defence Against the Dark Prompts** *(remove cursed text)*. Run in order:

1. `finite-recursum` — self-correction death spirals
2. `clarificus-maxima` — vague rules
3. `quietus-capslockius` — emphasis detox
4. `contradicto-revelio` — contradictory rule pairs

**Phase 2 — Charms** *(add structure)*:

5. `sorting-hat` — model tiering
6. `descriptio-reducio` — description right-sizing
7. `muffliato-hookus` — hook injection noise
8. `obliviate-fossilium` — memory-file diet
9. `accio-rulebook` — path-scoped rules migration

**Phase 3 — Divination** *(measure, don't guess)*:

10. `the-remembrall` — corrections the transcripts already recorded
11. `tempus-mutatur` — what the model era changed underneath these files
12. `avada-verbosa` — ablation candidates
13. `the-pensieve` — measurement plan

`the-remembrall` runs **before** `avada-verbosa`: it mines the never-triggered rules that spell
names as a candidate class and has no way to find. (`legilimens-anthropica` is a Divination spell
too, and already ran, in Phase 0.6.)

**Phase 4 — Care of Magical Constructs** *(your automation is alive, and it bites)*:

14. `priori-incantato` — is every artifact actually reached?
15. `nihil-revelio` — can every check tell passed from never-ran?
16. `alohomora` — do any blocking guards refuse legitimate work?

Phase 4 runs after the instruction passes, deliberately. A broken mechanism explains findings the
text passes would otherwise blame on the text: a hook whose payload is silently dropped reads as
"the rule is being ignored", a check that reports clean on empty input reads as "the rule isn't
needed", and a guard that blocks legitimate work reads as "agents don't follow the workflow".
Grade the words first, then find out which of those verdicts the machinery caused.

**Phase 5 — Transfiguration** *(change what's there, or make what isn't)*:

17. `the-room-of-requirement` — author a first memory file, when the repo has none
18. `protego` — install the write-time hook, so the classes above stop accumulating
19. `configure` — write the profile this run's triage just proved, so the next session loads it

These act on what the earlier phases established rather than adding findings of their own.
`the-room-of-requirement` is the one pass whose trigger is an *absent* layer — reached from the
Scope stop above, not from a curriculum run that found something to grade. `protego`'s thresholds
come from `descriptio-reducio`'s measured cliff and `quietus-capslockius`'s baseline; installed
before those ran, it would be enforcing its own defaults on a repo that never measured them.
`configure` runs last for the same reason in reverse: by then the triage has been proved against
a real run, so the profile it writes is evidence rather than a guess.

## Running the passes

For a small layer, run passes inline. For a large one, dispatch each pass to a read-only subagent
(the `apprentice-auditor` if installed), **pasting `references/casting-safety.md` verbatim into
every dispatch prompt** — a paraphrase is a different instruction, and the bounds are the point.

Fan-out is capped: at most 4 concurrent agents, one explicit slice each, no nested dispatch. The
dispatching agent merges. Treat a subagent's finding as a lead to check, not a fact to publish —
open the cited line before it enters the report.

## The O.W.L. report

One consolidated report: **the Opus Wizarding Level**. Per spell, a grade:

| Grade | Meaning here |
|---|---|
| **N/A** — no subject | This repo has none of what the spell examines (0 agents, 0 hooks, no memory file). Not a pass, not a fail — the spell had nothing to grade, and the report says so |
| **?** — could not verify | A subject exists but could not be measured: no transcript access, no network, a harness feature this version does not support. Distinct from N/A, and distinct from O |
| **O** — Outstanding | A real subject was examined and the pattern is absent, or already mechanized |
| **E** — Exceeds Expectations | Minor findings only; nothing that changes model behaviour |
| **A** — Acceptable | Findings exist but are contained; fix when convenient |
| **P** — Poor | Findings degrade model behaviour in common workflows |
| **D** — Dreadful | Findings cause loops, token burn, or routing failures today |
| **T** — Troll | The instruction layer is fighting the model and winning |

**Every row carries its denominator.** `sorting-hat  N/A  (0 agents)` and
`sorting-hat  O  (7 agents, all tiered)` are different verdicts and must never render alike.

**A grade of O with a denominator of zero is a bug in this report, not a result.** It claims a
clean bill of health for an exam nobody sat, which is the exact defect `nihil-revelio` exists to
catch — and shipping it inside the report format of the toolkit that hunts it would end the
argument in the reader's favour.

Then the **fix table**: every proposed fix as one row — file, finding, prescription, blast
radius, and which spell prescribed it. Ranked by impact. Nothing is written until the user
approves rows from this table. Approved fixes are applied in the repo's own change workflow
(branch, worktree, PR — whatever its conventions demand); the exorcist does not get to ignore the
house rules.

## Bounds

- **One pass per session.** Audit once. Do not re-audit after applying fixes — the judgement that
  produced the findings cannot validate them. Re-measurement belongs to `the-pensieve`, next week,
  with counters.
- **The approved list is the contract.** Apply exactly the rows the user approved, in themed
  commits, then stop. No opportunistic adjacent fixes.
- **Fan-out**: 4 concurrent agents, one slice each, no nesting.
- **Report in the register you prescribe** — no all-caps sentences, no `CRITICAL`/`YOU MUST`.
  Severity rides on rank order and a stated consequence.
- Do not run `avada-verbosa`'s deletions in the same session as the audit; ablation needs a
  baseline, and `the-pensieve` defines it.
- Every finding cites `file:line`. An uncited finding is a vibe, and `clarificus-maxima` would
  flag it in your own report.

Full rules, written to be pasted into a dispatch prompt:
[`references/casting-safety.md`](references/casting-safety.md).