Fable Orchestrator

Run Claude Fable 5 all day — without watching the usage meter.

Fable 5 is the best chair a Claude Code session can have, and the most expensive seat in the house. Let it type every token itself and the session ends rate-limited, waiting out the reset window.

This plugin makes the split mechanical. Fable 5 keeps the chair and spends tokens on planning, arbitration and final decisions. Everything else goes to named workers: the volume — implementation, research, briefs, review, bulk reading — to Sonnet 5, and the predictably hard slices — architecture, irreversible migrations, security review — straight to Opus 5.5, which doubles as the escalation lane. The chair sizes each worker's reasoning effort to the job, low for mechanical sweeps, xhigh for architecture and security — Opus 5.5 never runs at max.

No ledger, no interview, no mandatory verification phase. Earlier versions gated the act of delegating with a requirements file and a clarification loop. Both are gone. What is left is one rule with teeth: delegation is the default, and a hook notices when the chair quietly does the work itself.

The division of labor

                        ┌─────────────────────────────────┐
                        │         FABLE 5 — chair         │
                        │    plan · arbitrate · decide    │
                        │  sizes tier + effort per task   │
                        └────────────────┬────────────────┘
                                         │
                    specs down           │           briefs up
                                         │
           ┌────────────────────────┬────┴───────────────────┬────────────────────────┐
           ▼                        ▼                        ▼                        ▼
┌─────────────────────┐  ┌─────────────────────┐  ┌─────────────────────┐  ┌─────────────────────┐
│ SONNET 5 · low–med  │  │ SONNET 5 · med–high │  │ SONNET 5 · med–high │  │OPUS 5.5 · high–xhigh│
│   mechanical bulk   │  │   implementation    │  │   routine judgment  │  │  hard work · direct │
│   grep·fetch·scan   │  │   code · tests      │  │   briefs · review   │  │  architecture       │
│   format · read     │  │   debug · refactor  │  │   filtering         │  │  migrations·security│
└─────────────────────┘  └─────────────────────┘  └──────────┬──────────┘  └──────────┬──────────┘
                                                             │ uncertain /            │ beyond
                                                             │ high stakes            │ opus
                                                          ┌──▼────────────────────────▼──┐
                                                          │   escalation · one way only  │
                                                          │  OPUS 5.5 → FABLE 5 → stop   │
                                                          └──────────────────────────────┘

Your Fable limit pays for the thinking and almost nothing else:

┌─────────────────────────────────────────┬───────────────────┬─────────────────────┐
│ Work                                    │ Runs on           │ Fable limit pays    │
├─────────────────────────────────────────┼───────────────────┼─────────────────────┤
│ Planning, arbitration, decisions        │ Fable 5 (chair)   │ yes                 │
│ Implementation, tests, refactors        │ Sonnet 5          │ nothing             │
│ Source briefs, filtering, code review   │ Sonnet 5          │ nothing             │
│ Bulk gathering (fetch, grep, scan)      │ Sonnet 5 (low)    │ nothing             │
│ Hard slices: architecture, migrations   │ Opus 5.5 (direct) │ nothing             │
│ Security / adversarial review           │ Opus 5.5 (xhigh)  │ nothing             │
│ Escalations (sonnet "uncertain")        │ Opus → Fable      │ mostly nothing      │
└─────────────────────────────────────────┴───────────────────┴─────────────────────┘

Why this trio

• Fable tokens are the heaviest draw on your limit. Every token of bulk work kept off the chair extends how long Fable stays in it.
• Sonnet 5 carries the volume. Near-Opus quality on coding and agentic work, with the full effort ladder (low → max) — and the chair dials that ladder per task.
• Opus 5.5 takes the hard slices directly. Architecture tradeoffs, irreversible migrations, complex multi-system implementation and all security review are assigned straight to Opus, with no failed Sonnet pass required.
• Escalation is one-way. Sonnet returns "uncertain" and it goes to Opus, never back to the chair. If a tier declines a task it is re-run unchanged on another tier, never reworded to slip past a classifier. If that tier declines too, the chair stops and tells you.

What the plugin does

1 · The Fable profile — a slim core plus a playbook

Every chair session starts with a ~3.3k-char core profile: the default (delegate), the disk hand-off, spawn discipline, routing and effort. The detail lives in the orchestrator:playbook skill, which the core requires before the first delegation — the research pipeline, the worker report contract, spawn economics, the fork cap, teammate lifecycle. Sessions that never delegate never pay for it.

Three rules keep worker output from undoing the saving:

• Reports are capped at 40 lines. Verbatim over ten lines goes to ./.workflow/scratch/ and the report carries the path. A violating report is re-run, not accepted.
• Research is one worker per source: fetch verbatim to disk first, then brief from that copy. One synthesizer reads across the briefs.
• Similar mechanical work is batched. Five greps are one agent with a checklist, not five agents.

Teammates never get the profile. Named workers are full sessions and fire SessionStart too, but the profile is written for the chair alone: delivered to a worker it says "you are the orchestrator" and invites it to spawn workers of its own, invert