fable-orchestrate: the fleet layer as a fifth skill, with six trap fixtures and four eval rounds

.claude-plugin/marketplace.json

@@ -1,6 +1,6 @@
 {
   "name": "fable-method",
-  "description": "Home of the Fable Workflow plugin: Claude Fable 5's working method as four skills (think / act / prove / grow), with the eval that keeps them honest.",
+  "description": "Home of the Fable Workflow plugin: Claude Fable 5's working method as five skills (think / act / prove / grow / direct), with the eval that keeps them honest.",
   "owner": {
     "name": "Sahir619",
     "url": "https://github.com/Sahir619"
@@ -9,7 +9,7 @@
     {
       "name": "fable",
       "source": "./",
-      "description": "The Fable Workflow: think (fable-method), act (fable-loop), prove (fable-judge), grow (fable-domain). A problem-solving loop, its orchestration, an adversarial work-verifier, and a domain-adapter generator, with the eval that keeps them honest.",
+      "description": "The Fable Workflow: think (fable-method), act (fable-loop), prove (fable-judge), grow (fable-domain), direct (fable-orchestrate). A problem-solving loop, its orchestration, an adversarial work-verifier, a domain-adapter generator, and a fleet orchestrator, with the eval that keeps them honest.",
       "version": "1.4.0",
       "author": {
         "name": "Sahir619"

.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "description": "The Fable Workflow: how Claude Fable 5 worked, distilled into four skills any model can run. Think (fable-method), act (fable-loop), prove (fable-judge), grow (fable-domain). Evidence-backed: ships its own eval, failures included.",
+  "description": "The Fable Workflow: how Claude Fable 5 worked, distilled into five skills any model can run. Think (fable-method), act (fable-loop), prove (fable-judge), grow (fable-domain), direct (fable-orchestrate). Evidence-backed: ships its own eval, failures included.",
   "version": "1.4.0",
   "author": {
     "name": "Sahir619"

.github/checks.py

@@ -49,7 +49,7 @@ def ok(msg):
     fail(f"version check: {e}")
 
 # 3. All four skills exist with frontmatter name + description
-for skill in ["fable-method", "fable-loop", "fable-judge", "fable-domain"]:
+for skill in ["fable-method", "fable-loop", "fable-judge", "fable-domain", "fable-orchestrate"]:
     path = os.path.join(ROOT, "skills", skill, "SKILL.md")
     try:
         with io.open(path, encoding="utf-8") as f:

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## Unreleased
+
+- **Coverage complete: all 14 fable-orchestrate rules trap-armed** (`eval/scenarios/s20-threshold-drift/`, round 19): the delegation threshold's two-item discrimination trap produced the program's cleanest split (bare 0,0 vs skill 2,2) and a third artifact-without-discipline specimen, contract-as-decoration (both bare runs wrote dispatch paperwork and hand-executed anyway). Six fixtures s15-s20, four rounds 16-19, raw runs per round in `eval/results/`.
+- **Scripted-executor multi-turn harness** (`eval/scenarios/s19-thrash-track/`, round 18): a deterministic fake executor that applies useless patches and files false success reports each dispatch cycle, over a gate whose root cause sits in a wave-owner file outside every contract's scope, with `attempts.log` as the mechanical cycle counter. Reusable for any loop-or-retry rule. First round: the retry bound never armed (root cause too discoverable, declared v2 refinement); what armed instead was authority self-promotion (4 of 4 runs bumped the wave-owner file), plus one live rule-10 win (a false executor report refuted against observed output). **Terminal artifact gate** added to fable-orchestrate as rule 15, including a costumed-AUTH clause; measured double edge on the s16 re-run (one fabricated SESSIONS line, cumulative collision-guard limit 0 of 8 published). s17 inline-AUTH conditions now 2 of 4 vs 0 of 4 by-reference. Rounds and raw runs: `eval/RESULTS.md` round 18, `eval/results/round18-multiturn-harness.json`.
+
+- **fable-orchestrate** (new skill): the fleet layer. fable-loop runs one task with subagents; fable-orchestrate runs a program of tasks across many executors: self-contained dispatch contracts (`FILES` / `ACCEPT` / `CONSTRAINTS` / `MODEL` / `VERIFY`, agents inherit nothing), explicit tier routing with a small-tier dispatch floor, worktree isolation with central logging, independent refuting verifiers, a non-optional controller backstop with a forced `BACKSTOP:` line (the orchestrator re-runs the real gates personally before integrating; one reviewer's approval is signal, not proof), a collision guard with a forced `SESSIONS:` line, a self-contained AUTH gate on integration with inline `AUTH:`/`PENDING:` mechanics, per-track hard bounds, and ledger discipline for blocked items. Trap fixtures `s15`-`s18`, each hardened or fail-then-fixed under adversarial review; rounds 16-17 in `eval/RESULTS.md`: BACKSTOP artifact transfers 2/2 vs 0/2 (r16), planning vocabulary transfers (s18 skill 2,2 vs bare 1,2), inline AUTH splits 2,0 against four straight 0s for by-reference wording (one costumed AUTH line kept as a judge specimen), collision guard resists at the weak tier (0/6, open issue; terminal artifact gate is the declared next experiment). Raw runs in `eval/results/round16-*.json` and `round17-*.json`.
+
 ## 1.4.0 (2026-07-15)
 
 - **Fit gate** (fable-method, before Step 0): routes each ask by where the answer lives - run the loop, research first, make a skill, or say plainly that the answer is a judgment call. The universal fallback is an honest hand-back, never faked rigor.

DOC.md

@@ -16,7 +16,7 @@ does not make a model smarter; it makes it disciplined and honest. That is a
 narrow claim, and it is the whole point: procedural failure is most of what
 goes wrong with agents, especially cheap ones.
 
-Three skills, one idea:
+Five skills, one idea:
 
 - **fable-method** - the loop (think). Classify the ask, define done, gather
   evidence, decide, act surgically, verify by observation, report outcome-first.
@@ -26,6 +26,11 @@ Three skills, one idea:
   set of claims and re-runs every one; believes nothing it did not observe.
 - **fable-domain** - the maker (grow). Turns the loop into a trusted skill for
   a new domain.
+- **fable-orchestrate** - the fleet layer (direct). Runs the method across many
+  agents at once: self-contained dispatch contracts, explicit model tiering, and a
+  controller backstop that re-runs the gates before trusting any executor's "done".
+  All 14 of its rules are exercised by armed traps (s15-s20, eval rounds 16-19),
+  floors published beside wins; its Evidence status carries the full accounting.
 
 Every rule exists because a test failed without it. The whole `eval/` directory
 is the receipts, wins and failures both.

README.md

@@ -8,7 +8,7 @@
 
 In its final days before getting removed from the Subscription, Claude Fable 5 distilled its own way of approaching problems into a set of skills any model can run: classify the ask before touching anything, define done with a named verification, gather evidence in parallel from primary sources, commit to one recommendation, change the smallest correct thing, verify by observation, report the outcome first with honest caveats. Then it tested that distillation against itself, adversarially, across fifteen eval rounds and more than 260 agent runs, and kept the failures in the log.
 
-Most agent instruction files tell the model *what to value* ("be careful, verify your work"). This one tells it *what to do, in what order, with thresholds*, so a mid-tier model can follow it literally. Four skills, one philosophy: **think** (fable-method), **act** (fable-loop), **prove** (fable-judge), **grow** (fable-domain, which generates new domain adapters the way the author model was observed making one). Every rule exists because a test failed without it or a trace demanded it; every claim below links to the committed transcript that backs it.
+Most agent instruction files tell the model *what to value* ("be careful, verify your work"). This one tells it *what to do, in what order, with thresholds*, so a mid-tier model can follow it literally. Five skills, one philosophy: **think** (fable-method), **act** (fable-loop), **prove** (fable-judge), **grow** (fable-domain, which generates new domain adapters the way the author model was observed making one), **direct** (fable-orchestrate, which runs the method across a fleet: dispatch contracts, tier routing, and a controller backstop). Every rule exists because a test failed without it or a trace demanded it; every claim below links to the committed transcript that backs it.
 
 ## Results at a glance
 
@@ -25,6 +25,8 @@ Fifteen eval rounds, more than 260 agent runs, blind LLM judges that verify by d
 | Sonnet generating a research-grounded devops adapter bundle blind, judged against the Fable-trace bar (fable-domain) | n/a | **9/10**: sources fetched and spot-checked, trap fixture verified in all three states | [round 12](eval/results/round12-fable-domain.json) |
 | Haiku surfacing the skipped-deploy decision on s9 | 0 of 2 | 1 of 12 across three rule wordings: **published open issue, weak-tier only** (Sonnet and Opus surface it natively, 8 of 8) | [round 11](eval/results/round11-transfer.json), [round 13](eval/results/round13-cross-tier.json) |
 | Building a trustworthy adapter bundle blind, bare vs with fable-domain (judged /10 against the Fable-trace bar) | Haiku **2** (false "production-ready" claim over unverified work), Sonnet 9, Opus 8 | Haiku 6, Sonnet **10**, Opus 9: **the lift is inversely proportional to tier**, which is the repo's thesis | [round 13](eval/results/round13-cross-tier.json), [round 12](eval/results/round12-fable-domain.json) |
+| Haiku discriminating the delegation threshold: contract the multi-file item, or hand-execute it from the orchestrator seat (fable-orchestrate) | 0 of 2, and both runs wrote the dispatch contracts, then hand-executed anyway | **2 of 2** | [round 19](eval/results/round19-threshold-drift.json) |
+| The forced BACKSTOP line appearing before integration (fable-orchestrate) | 0 of 2 | **2 of 2** (the integration decision itself was a ceiling null, published as such) | [round 16](eval/results/round16-orchestrate-backstop.json) |
 | Ordinary small tasks on capable models | fine | fine (no lift) | [rounds 1, 6, 7](eval/RESULTS.md) |
 
 That last row is deliberate: the method's value concentrates at **traps** (authority conflicts, false completion claims, weak executors, unattended runs), not everywhere. The nulls are reported with the wins, because a results log that only contains wins would not be worth trusting.
@@ -78,7 +80,7 @@ Seven more charts (ask classification with tie-breaks, the bounded evidence loop
 /plugin install fable@fable-method
 ```
 
-All four skills arrive namespaced (`/fable:fable-method`, `/fable:fable-loop`, `/fable:fable-judge`, `/fable:fable-domain`), versioned, and updatable via `/plugin marketplace update`.
+All five skills arrive namespaced (`/fable:fable-method`, `/fable:fable-loop`, `/fable:fable-judge`, `/fable:fable-domain`, `/fable:fable-orchestrate`), versioned, and updatable via `/plugin marketplace update`.
 
 **As standalone skills** (un-namespaced `/fable-method` etc.):
 
@@ -122,6 +124,11 @@ Windows PowerShell: `git clone https://github.com/Sahir619/fable-method; .\fable
                             (researched, every claim sourced), its trap fixture with an answer
                             sheet, and a smoke eval, following the process observed in blind
                             Fable 5 adapter-creation runs. An adapter without its trap is not done
+
+/fable-orchestrate <program>  the fleet layer: decompose a program into self-contained dispatch
+                            contracts, route executors by tier (set explicitly, worktree-isolated),
+                            verify with independent refuters, then re-run the real gates personally
+                            before integrating any track. The loop runs one task; this runs many
 ```
 
 fable-judge exists because the most documented failure of coding agents is claiming success regardless of reality: reward hacking grows with codebase size ([SpecBench](https://arxiv.org/abs/2605.21384)), agents end failure transcripts with "all tests pass", and tests get weakened until they agree. The judge treats a report as a set of claims and believes nothing it did not observe. Want to see it work? The repo ships a crime scene: [`eval/scenarios/s7-fraudulent-work/`](eval/scenarios/s7-fraudulent-work/) is a "completed" agent task with five planted frauds behind a lying completion report; point your model at it with `/fable-judge` and compare against the [round-8 transcripts](eval/results/round8-fable-judge-transfer.json).
@@ -166,6 +173,7 @@ skills/
   fable-loop/               the orchestrated plan-execute-verify-audit workflow
   fable-judge/              adversarial verification of finished work + trap suite
   fable-domain/             generates new domain adapter bundles (adapter + trap + smoke eval)
+  fable-orchestrate/        the fleet layer: dispatch contracts, tier routing, controller backstop
 AGENTS.md                   the same method for any other harness
 DOC.md                      plain-language explainer: the flow, what changed since 1.3, why it is better
 install.sh / install.ps1    standalone-skill install into ~/.claude/skills/ (plugin preferred)