Configure

---
name: configure
description: Choose which Opus Pocus spells load in a session by writing per-skill `skillOverrides` entries to your settings, so a small repo carries three spells instead of all of them and pays only for what it uses. Detects the repo's shape, recommends a profile (greenfield / minimal / standard / full / maintenance), shows the exact settings diff, and writes only after you approve. Use for "which spells do I need", "opus pocus is too expensive", "turn off the spells I don't use", "configure opus pocus", "cut my always-on token cost", or before the first ritual on a repo where the full set is more than you want loaded. Writes one key in one file and audits nothing. NOT for disabling another plugin's skills. NOT for choosing which passes run this session — that is the ritual's own triage, which this reuses.
---

# 🦋 Configure

> *"The whole book is a spellbook. What you carry is a wand."*

Every installed skill costs its description in **every session, whether or not you use it** —
that is what "always-on" means. The bodies load on invoke and cost nothing until then, but the
descriptions are the router's menu and the router reads the whole menu every time.

For the repo this book was distilled from, all of it earns its place. For a Node service with a
forty-line memory file, most of it is a menu of dishes the kitchen cannot cook: **five spells
have no subject there at all**, and they still charge rent.

This spell picks the subset and writes it down.

## The mechanism

Claude Code reads a **`skillOverrides`** object from settings — skill name to `"off"`:

```json
{
  "skillOverrides": {
    "avada-verbosa": "off",
    "the-pensieve": "off"
  }
}
```

A skill set `"off"` is absent from the session's skill listing entirely, so its description is
never injected. That is the lever, and it is the only one that reduces always-on cost per skill.

**Keys are bare skill names**, not `plugin:skill` — that is the form observed working. If a
change does not take effect, try the prefixed form before concluding the mechanism is wrong, and
say which one worked.

### Three levers, only one of which is this spell

| Lever | Effect | When |
|---|---|---|
| `skillOverrides: "off"` | removes one skill from the listing; no always-on cost | **this spell** — per-skill, per-scope |
| `claude plugin disable opus-pocus` | removes all of it, hook included | you want it gone for now, not tuned |
| `disable-model-invocation: true` in a skill's frontmatter | still slash-invocable, but the model will not route to it on its own | you want a spell available on demand without it competing for routing. Mentioned for completeness; this spell does not edit skill files |

### One measurement trap, and it will mislead you

`claude plugin details opus-pocus` reports the plugin's **packaged** cost, not your configured
one. Measured: with four skills set `"off"`, it reported the identical always-on figure.

It is not lying — it answers "what does this plugin contain", and that is a different question
from "what am I loading". Do not quote it as proof a config took effect. This is
`nihil-revelio`'s own class in the wild: a number that looks like the answer to the question you
asked, and is the answer to a neighbouring one.

To verify a change actually took, start a new session and ask whether a disabled spell appears
in the available skills. That is falsifiable; the cost figure is not.

## Detection — the same computation as the ritual's triage

**This spell and Phase 0.5 of the grand ritual answer the same question at different tempos.**
Triage decides which passes have a subject *this run*; configure decides which spells load
*every session*. They share one detector so they cannot drift into disagreeing about the same
repo — if a pass is `N/A` in the triage table, keeping it loaded is paying for a menu item the
kitchen cannot cook.

Run the ritual's own Scope and Phase 0.5 detection — memory-file discovery (`CLAUDE.md`,
`AGENTS.md`, nested, `.claude/rules/`), hook count, agent count, skill count, memory-file size —
and read the profile off the result. Do not restate those rules here; read them from
[`../opus-pocus/SKILL.md`](../opus-pocus/SKILL.md) so there is one copy.

## Profiles

| Profile | Loads | For |
|---|---|---|
| `greenfield` | `opus-pocus`, `the-room-of-requirement` | No memory file yet. Nothing to grade — author one first |
| `minimal` | `opus-pocus`, `clarificus-maxima`, `quietus-capslockius`, `finite-recursum` | A memory file under ~200 lines, 0 hooks, 0 agents |
| `standard` | `minimal` + `contradicto-revelio`, `descriptio-reducio`, `sorting-hat`, `muffliato-hookus`, `obliviate-fossilium`, `legilimens-anthropica`, `priori-incantato`, `protego` | Several instruction sources, some hooks or agents |
| `full` | everything | A heavily-automated repo — many hooks, a real agent roster, a large memory file |
| `maintenance` | `opus-pocus`, `the-remembrall`, `the-pensieve`, `avada-verbosa`, `tempus-mutatur` | You are measuring or ablating, not auditing |
| `reset` | clears every Opus Pocus entry | Undo — leaves other plugins' entries alone |

`opus-pocus` itself is in every profile: it holds the triage, the bounds and the report format,
and without it the individual spells have no shared frame.

**The placement rule, so a nineteenth spell has an obvious home:** a spell belongs in the
smallest profile where it **changes an outcome** — not merely where it has a subject.

Worked through, for the four that are not obvious:

- **`legilimens-anthropica`** — `standard`. It recalibrates thresholds, and the first threshold
  that matters is `descriptio-reducio`'s truncation cliff, which arrives in `standard`. Below
  that, `quietus-capslockius` uses raw counts rather than rates, so there is nothing to
  recalibrate.
- **`priori-incantato`** — `standard`. A handful of hooks is enough to have one wired to an event
  it never emits, and that is the failure a small setup makes once and never notices.
- **`nihil-revelio`** and **`alohomora`** — `full`. Both need machinery *you own and can change*.
  A repo whose checks are `eslint` and `pytest` and whose only guard is `husky` cannot act on
  most of what they prescribe.
- **`accio-rulebook`** — `full`. Splitting a memory file into path-scoped rules pays when the
  root file is large; "several memory files" is not the same as "one file worth splitting".

**`protego` is in `standard` and above, and you can switch it off afterwards.** The hook is wired
by the plugin manifest, not by `skillOverrides` — so once it is installed and running, turning
the *skill* off keeps the shield and drops the description. Say so when you recommend it; it is
the one spell whose job survives its own removal from the menu.

## Procedure

1. **Detect and recommend.** Show the evidence, not just the verdict:

   ```
   Repo shape:  2 memory files (6 KB) · 0 hooks · 0 agents · 2 skills
   Recommended: minimal  — 4 spells loaded, the rest off
   Why:         no hooks and no agents, so sorting-hat, muffliato-hookus,
                priori-incantato, nihil-revelio and alohomora have no subject here
   ```

2. **Estimate the cost both ways.** Derive it rather than quoting a number: each skill's
   always-on cost is roughly its `description:` length in characters divided by four. Sum the
   loaded set, sum all of them, show both. State that it is an estimate, and that
   `claude plugin details` will keep reporting the packaged figure regardless.

3. **Show the diff and ask.** The exact JSON that will be added or removed, and the exact file
   it lands in. Then wait. Never write settings unasked — this file governs every future session
   in the repo, and a surprise edit to it is the kind of thing that gets a plugin uninstalled.

4. **Write, merged, to project scope by default.** `<repo>/.claude/settings.json`, so the profile
   follows the repo it was chosen for. `--user` writes `~/.claude/settings.json` instead.

   **Merge into any existing `skillOverrides`; never replace the object.** A user may already
   have unrelated skills off, and clobbering those entries is real data loss in a file nobody
   re-reads. Back the file up first, write, then re-parse the result — a settings file left
   invalid disables every setting in it, which is a worse outcome than any token saving.

5. **Report what changed and when it takes effect.** The skill listing is assembled when a
   session starts, so a change most likely applies to the **next** session rather than this one.
   That has not been verified here — say so, and give the check: start a new session and ask
   whether a disabled spell still appears.

6. **Re-running replaces only Opus Pocus entries.** `reset` removes only Opus Pocus entries.
   Neither touches another plugin's.

## Bounds

- Writes **exactly one file**, and within it **only the `skillOverrides` key**, and within that
  **only this plugin's own entries**. Another plugin's entry is never added, removed or altered.
- Asks before writing, every time. There is no unattended mode.
- Audits nothing, grades nothing, produces no findings — it reads the repo's shape to pick a
  profile and stops.
- Done when the profile is written and reported. Not when the configuration is "optimal" —
  there is no such state to converge on, and hunting one is the spiral this book bounds.
- Never edits a skill's own frontmatter to achieve an effect settings can achieve.
- See [`../opus-pocus/references/casting-safety.md`](../opus-pocus/references/casting-safety.md)
  for the full rules.

## Report format

The detected shape with its evidence, the recommended profile and why, the loaded-versus-all cost
estimate with its caveat, the exact diff written, the file it went to, and the
takes-effect-next-session note with its check.

`SCANNED NOTHING` if there is no repo to shape-detect — configure refuses to guess a profile from
nothing, because the wrong profile silently hides the spell you needed.