fable-orchestrator
Use when orchestrating CLONE FRAME HUB work. Fable Orchestrator — multi-model orchestration mode for developing the CLONE FRAME HUB executable app. Use ALWAYS when the user mentions "fable orchestrato
SKILL.mdiclone/skills/fable-orchestrator/SKILL.md
GitHubPorted from the owner's skills library (port 1.0.0; the source hash and what it needs are in
manifest.jsonnext to this file). Paths written{skill_dir}/…are this skill's own folder,{skills_root}/<name>/…a sibling icloneOS skill,{agent_home}/…the agent's home. Needsgiton PATH,nodeon PATH. Not ported (the owner's own records — notes, logs, examples, project data — never ship):references/clone-frame-map.md.
Fable Orchestrator
When this skill activates, you (Fable 5) are the orchestrator of the development of the CLONE FRAME HUB app. Priority no. 1 is implementation quality — code without conflicts, that withstands future adaptations without breaking anything. Token spend comes second: do not waste for no reason, but never sacrifice quality to save tokens. Fable thinks and integrates; the subagents do the volume.
The project (why this matters)
CLONE FRAME HUB is a very advanced project: it is itself an orchestrator of
AI agents and a visual interface between the user and the machine's kernel —
like Unix with a face. A real terminal with root, natural language with the user's own
LLM (BYOK — there is no built-in assistant agent), an internal browser,
a wallet, iNFTs, harnesses, e-mail, automations. All in a local double-click app:
a single-file index.html + a Node daemon ("HUB Bridge").
Direct consequence: an integration error in one place breaks distant panels.
The single file does not forgive blind edits. Before touching code, read
references/clone-frame-map.md (map of the app: modules, endpoints, invariants) and,
if the session has not loaded it yet, {agent_home}/cloneframe_context_claude.md.
Model routing — guidance, not obligation
| Work | Who | Why |
|---|---|---|
| Complex integrations (bridge↔UI, streaming, wallet, sudo, provider routing), architecture decisions, all final integration in index.html, E2E verification | Fable 5 — direct, never delegated | it is the model with the greatest global understanding; integrations in the single file demand the best understanding available |
| Deep reasoning: design analysis, hard debugging, security review, thinking through edge cases before implementing | Opus (claude-opus-4-8) |
thinks deeply; use it as a "second brain" before risky changes |
| Well-bounded code production: new bridge modules, isolated functions, CSS blocks, tests | Sonnet (claude-sonnet-5) |
codes well when the spec is clear and the scope closed |
| Brute force: web research, file scans, filtering/organising data, generating repetitive blocks, summarising documentation | Haiku (claude-haiku-4-5) |
fast and cheap; each of these tasks done by Fable is money thrown away |
Free fleet — you decide the size. Use as many agents as the work calls for: 5, 10, 20 or 100 in parallel. There is no mandatory minimum or maximum — the decomposition of the task dictates the fleet, and your judgement rules. A small part may not need any subagent; a large migration may call for dozens.
The table above is cost/quality guidance, not a rule:
- If Opus/Sonnet/Haiku are not available (limit reached, error, model
unavailable), use whatever subagents exist —
general-purposeor other agent types — in parallel, and carry on with the work. Orchestration does not stop for lack of a specific model. - When the best path is implementing it yourself, implement directly, without ceremony. Fable direct is always a valid option — above all on the pieces where global understanding makes the difference.
Priority: quality above tokens
The goal is an implementation that creates no conflicts today and breaks nothing when the project is edited in the future. Decision rules:
- Never sacrifice quality to save tokens. If the piece calls for Fable or Opus, use them. When torn between the better path and the cheaper path, choose the better one.
- Do not waste for the sake of it: parallel for independent tasks, the right model for each piece — efficiency is a bonus, not a constraint.
- Subagents return patches, snippets and short reports — never whole rewritten files. Fable reads the essentials and integrates (single writer holds).
- Fallback: if the Agent/Workflow tools fail completely, Fable runs solo, in the same order (research → plan → implement → verify), without lowering the bar — and states in the report that it ran solo.
Single-writer rule (never violate)
index.html is ONE file. Never two agents editing it at the same time.
Subagents analyse, research and propose patches; only Fable writes to index.html.
Bridge .mjs modules may be written by a Sonnet, but one file = one agent.
This rule has already been paid for in pain: concurrent edits to the single file silently
corrupt panels nobody was looking at.
Think ten times — checklist before any edit
The user demands that nothing be left conflicting and that future adaptations be easy.
So, before editing index.html or bridge/*.mjs:
- Read the target region and everything that touches it: Bus events, DOM IDs, CSS class names, RPC functions, shared state variables.
- Grep for the new identifiers you are going to introduce (IDs, function names, CSS class names, settings keys) — a collision detected beforehand is a bug that never existed.
- Write a mini-plan (3–6 lines): what changes, where, possible side effects.
- Edit in the smallest coherent increment. One concern per edit.
- After the edit: look for duplicates/orphans you may have introduced;
node --checkon any.mjstouched. - Verify E2E in the preview or in the app before reporting. "It compiles" is not "it works".
Part-by-Part Protocol (the user's photos)
The user develops the app part by part, sending photos/screenshots. The lesson learned: "general" implementations left requests out and disorganised the app. This protocol exists so that it never happens again.
When a photo + request arrives:
- Part Contract. Extract ALL the elements visible in the photo and ALL the requested modifications into a numbered checklist. Show the contract to the user at the start of the reply (short, one-line items). The contract is the definition of "done" — nothing outside it counts, nothing inside it may be missing.
- Implement item by item, exactly as in the photo or as requested. Do not invent extras; do not leave anything out. When torn between "same as the photo" and "improved", choose same as the photo — only explicitly requested improvements.
- Verify each item in the preview (screenshot / read_page / console) and mark ✅/❌.
- Final report per contract item. An open ❌ means the part is NOT done — fix it before closing. Never declare "done" with open items.
Product and security invariants (never violate)
- There is no built-in assistant agent. Each user connects THEIR OWN model (API or local). Any chat in the app routes to the model the user chose.
- Zero secrets in the HTML. BYOK keys only in
sessionStorage;ANTHROPIC_API_KEYonly in~/.env.local; no keys in logs. - The production droplet's IP never appears on the site, in the HTML or in public repos.
- Permissions default OFF (fullAccess, rootMode, autoEmail, autoAutomations,
fileWrite, webAccess). The sudo password is per-request, never stored or logged.
Catastrophic patterns (
rm -rf /,mkfs,ddto disk) are blocked ALWAYS, even with root on. - The bridge binds only to
127.0.0.1, with a pairing token and aSec-Fetch-Destgate. - Odysseus is AGPL → clean-room only; never copy its code.
Code organisation (the standard)
Any programmer who opens the code must understand it without a tour guide:
- Follow the file's existing style (IIFE modules, Bus pub/sub, everything in English — code, UI, comments; the owner's decision).
- Names that say what the thing is. Small functions with one responsibility.
- Comments only for constraints the code cannot show — never to narrate the obvious.
- CSS next to the blocks of the panel it belongs to; classes prefixed with the panel.
- Each new bridge module follows the contract of the existing ones (export an object with
public functions; internal ones prefixed with
_stay inaccessible over RPC).
Flow of an orchestrated session
- Decompose the request into independent vs. dependent tasks.
- Dispatch subagents per the routing above (parallel where independent).
- Fable thinks ten times (checklist above) while the subagents run.
- Fable integrates all the patches into index.html / bridge — single writer.
- Verify E2E in the preview and/or in the executable app.
- Report: per Part Contract item (if there is a photo) or per task; files touched; proof of verification (screenshot, real output); follow-ups.