Add efficient-orchestrator; make efficient-frontier and efficient-fable explicit-only aliases

.agents/skills/adding-a-skill/SKILL.md

@@ -94,7 +94,7 @@ If the skill should affect `AGENTS.md` / `CLAUDE.md` through
   pnpm --filter @agent-native/skills test -- src/index.spec.ts --runInBand
   ```
 
-Use this for durable behavior rules like `quick-recap`, `efficient-fable`,
+Use this for durable behavior rules like `quick-recap`, `efficient-orchestrator`,
 `stay-within-limits`, and likely docs-first behavior such as
 `read-the-damn-docs`.
 

README.md

@@ -39,8 +39,7 @@ See the [full CLI docs below](#install).
 - [`/agent-watchdog`](#agent-watchdog) - Audit another agent's work.
 - [`/plan-arbiter`](#plan-arbiter) - Compare competing plans and choose a direction.
 - [`/plow-ahead`](#plow-ahead) - Keep working through ordinary ambiguity.
-- [`/efficient-fable`](#efficient-fable) - Orchestrate Fable with cheaper helper agents.
-- [`/efficient-frontier`](#efficient-frontier) - Preserve high-cost models for judgment.
+- [`/efficient-orchestrator`](#efficient-orchestrator) - Keep an expensive model on judgment while cheap agents do the heavy lifting (aliases: `/efficient-frontier`, `/efficient-fable`).
 - [`/stay-within-limits`](#stay-within-limits) - Track usage limits before long-running work.
 - [`/quick-recap`](#quick-recap) - End work with a clear status signal.
 - [`/read-the-damn-docs`](#read-the-damn-docs) - Check authoritative docs before guessing.
@@ -308,31 +307,23 @@ Solves for explicit autonomy requests: the agent converts routine questions into
 assumptions, proceeds with conservative choices, validates the work, and recaps
 the decisions it made without stopping.
 
-### [`/efficient-fable`](skills/efficient-fable/README.md)
+### [`/efficient-orchestrator`](skills/efficient-orchestrator/README.md)
 
-Use Claude Fable as the orchestrator, architect, synthesizer, and final judge
-while lighter agents handle token-heavy research, coding, testing, and log
-reduction.
+Run an expensive model (Claude Fable or Opus, OpenAI Astra or Sol) as the
+orchestrator, architect and final judge while cheaper agents (Haiku or Sonnet,
+Terra or Luna) handle token-heavy research, coding, QA and log reduction. It runs
+only when invoked by name; `/efficient-frontier` and `/efficient-fable` are
+aliases.
 
-Solves for expensive-model waste: Fable should spend tokens on judgment, not on
-reading every file, reducing every log, or manually running every browser check.
+Solves for expensive-model waste without unrequested fan-out: the premium model
+spends tokens on judgment, and helpers stay capped and short-lived.
 
 <picture>
-  <source media="(prefers-color-scheme: dark)" srcset="skills/efficient-fable/assets/fable-orchestrator-dark.png">
-  <source media="(prefers-color-scheme: light)" srcset="skills/efficient-fable/assets/fable-orchestrator.png">
-  <img alt="Fable orchestrator diagram" src="skills/efficient-fable/assets/fable-orchestrator.png">
+  <source media="(prefers-color-scheme: dark)" srcset="skills/efficient-orchestrator/assets/fable-orchestrator-dark.png">
+  <source media="(prefers-color-scheme: light)" srcset="skills/efficient-orchestrator/assets/fable-orchestrator.png">
+  <img alt="Orchestrator diagram" src="skills/efficient-orchestrator/assets/fable-orchestrator.png">
 </picture>
 
-### [`/efficient-frontier`](skills/efficient-frontier/README.md)
-
-Apply the same orchestration as `/efficient-fable` to any high-cost frontier
-model: preserve the expensive model for planning, tradeoffs, integration,
-validation strategy, and final review; use cheaper agents for bounded heavy
-lifting.
-
-Solves for broad work that can be parallelized without asking the most expensive
-model to do every scan and every edit itself.
-
 ### [`/stay-within-limits`](skills/stay-within-limits/README.md)
 
 Check current 5-hour and weekly usage before substantial work and between

scripts/check-skill-frontmatter.mjs

@@ -10,6 +10,7 @@ const skillsRoot = path.join(repoRoot, "skills");
 const allowedProperties = new Set([
   "allowed-tools",
   "description",
+  "disable-model-invocation",
   "installer-group",
   "license",
   "metadata",

skills/efficient-fable/README.md

@@ -1,75 +1,3 @@
 # /efficient-fable
 
-Use Claude Fable where it is worth paying for judgment.
-
-`/efficient-fable` helps a Fable-class model orchestrate codebase-heavy work
-without spending premium tokens on every scan, log, browser run, and bounded
-edit. Fable keeps the hard calls: decomposition, architecture, product tradeoffs,
-synthesis, risk, and final review. Lighter agents do the repeatable heavy
-passes.
-
-<picture>
-  <source media="(prefers-color-scheme: dark)" srcset="assets/fable-orchestrator-dark.png">
-  <source media="(prefers-color-scheme: light)" srcset="assets/fable-orchestrator.png">
-  <img alt="Fable orchestrator diagram" src="assets/fable-orchestrator.png">
-</picture>
-
-## What It Does
-
-- Splits large work into research, coding, and testing lanes.
-- Tells Fable to choose the strategy, validation direction, and review bar.
-- Encourages cheaper agents to scan repos, summarize docs, reduce logs, run
-  browser checks, and attempt bounded patches.
-- Keeps evidence flowing back to Fable as files, commands, diffs, failures, and
-  uncertainties.
-- Uses self-contained handoff packets so delegated agents can work without
-  hidden context from the orchestrator chat.
-- Reminds Fable to verify important delegated claims before relying on them.
-
-## When To Use It
-
-Use this when the task is too broad for one expensive model pass: unfamiliar
-repos, long test output, multi-file changes, product/architecture ambiguity, or
-validation work that can run in parallel.
-
-Skip it for tiny fixes, highly coupled edits, or judgment-sensitive debugging
-where delegating would create more coordination cost than it saves.
-
-## Testing Guidance
-
-Fable should suggest the validation direction and name the scripts or browser
-flows that matter. Lighter agents can run those checks, collect screenshots,
-reduce logs, and report whether failures look real, flaky, or environmental.
-
-The point is not to outsource responsibility. Fable still decides what signal is
-trustworthy.
-
-## Delegation Quality
-
-Good handoffs include the repo path, exact objective, in-scope and out-of-scope
-areas, expected evidence, verification commands, and stop conditions. A lighter
-agent should know when to stop and report instead of widening the task on its
-own.
-
-Fable should treat delegated reports as leads. For important decisions, it
-reopens the cited files or logs and checks that the evidence really supports the
-claim.
-
-## Diagram
-
-Editable Excalidraw source:
-[`assets/fable-orchestrator.excalidraw`](assets/fable-orchestrator.excalidraw)
-
-Rendered PNGs:
-[`assets/fable-orchestrator.png`](assets/fable-orchestrator.png)
-and
-[`assets/fable-orchestrator-dark.png`](assets/fable-orchestrator-dark.png)
-
-## Install
-
-```sh
-npx @agent-native/skills@latest add --skill efficient-fable --update-instructions
-```
-
-Use `--update-instructions` when you want the Fable delegation convention added
-to `AGENTS.md` or `CLAUDE.md` automatically.
+Alias for [`/efficient-orchestrator`](../efficient-orchestrator/README.md). It runs only when you invoke it by name.

skills/efficient-fable/SKILL.md

@@ -1,95 +1,9 @@
 ---
 name: efficient-fable
-description: Use when running Claude Fable on codebase-heavy or token-heavy work and the user wants Fable to orchestrate research, coding, and testing while cheaper subagents do bounded heavy lifting.
+description: Alias for /efficient-orchestrator. Run only when the user explicitly invokes /efficient-fable; never self-activate.
+disable-model-invocation: true
 ---
 
-# Efficient Fable
+# /efficient-fable
 
-Use Claude Fable as the orchestrator, architect, synthesizer, and final judge.
-Use cheaper subagents for token-heavy research, coding, testing, and
-summarization that do not require Fable's full judgment.
-
-## Where Fable Shines
-
-Reserve Fable for:
-
-- Decomposing ambiguous work into clean parallel slices.
-- Architecture, product, and safety tradeoffs.
-- Reading conflicting subagent reports and deciding what matters.
-- Integrating partial implementations into one coherent plan.
-- Final review, risk assessment, and user-facing synthesis.
-
-## Delegation Pattern
-
-1. Name the expensive-token risk: large repo search, long logs, broad docs, or
-   repetitive edits.
-2. Split independent work into subagents before reading everything yourself.
-3. Use cheaper models for research scans, inventory, search summaries, narrow
-   bug hunts, browser/testing passes, test output reduction, and bounded code
-   edits.
-4. Ask subagents for concise evidence: files, line references, commands run,
-   diffs, uncertainties, and stop conditions they hit.
-5. Spend Fable tokens on the decision layer: compare results, resolve conflicts,
-   choose the implementation path, and review the final patch.
-
-Prefer parallel subagents when the slices do not depend on each other. Keep
-blocking or highly coupled work local.
-
-## Handoff Packets
-
-Write delegated prompts as if the subagent has no useful chat context. Include
-only the context it needs:
-
-- The repo path and exact objective.
-- The files, packages, or surfaces in scope and anything explicitly out of
-  scope.
-- The evidence format to return: files, line refs, commands, diffs, failures,
-  screenshots, and uncertainty.
-- The verification commands or browser flows to run, plus what success should
-  look like when that is knowable.
-- Stop conditions: if the code does not match the prompt, a command fails after
-  a reasonable retry, or the task needs out-of-scope files, stop and report
-  instead of improvising.
-
-## Vetting Delegated Work
-
-Treat subagent reports as leads, not facts. Before using a high-impact finding,
-opening a PR, or telling the user the work is done, Fable should reopen the
-important cited files, confirm the relevant line refs or failures, and review
-the final diff against the task. Let lighter agents gather signal; keep
-truth-judgment with Fable.
-
-## Common Scenarios
-
-Treat these as soft defaults, not rigid rules:
-
-- Research: ask lighter agents to scan docs, prior art, APIs, and repo surfaces;
-  Fable decides what evidence changes the plan.
-- Coding: give cheaper agents bounded edits or candidate patches; Fable owns
-  shared-file coordination, integration, and final review.
-- Testing: have Fable suggest the validation direction and the scripts or
-  browser checks that matter. Let lighter agents run targeted tests, browser
-  flows, screenshots, and log reduction, then report exact commands, failures,
-  likely causes, and whether failures look flaky, environmental, or real.
-- Debugging: use cheaper agents to cluster logs, reproduce issues, and try
-  small fixes; Fable decides which diagnosis is most trustworthy.
-
-If a task is tiny or the validation itself needs delicate judgment, keep it
-with Fable.
-
-## Diagram
-
-Use `assets/fable-orchestrator.excalidraw` when a visual explanation helps.
-
-## Claims
-
-For codebase-heavy work, it is reasonable to describe this as up to 3-5x more
-cost-efficient and 2-4x faster when independent research, coding, or testing
-slices can run in parallel. Treat those as workload-dependent estimates, not
-guarantees.
-
-Good launch copy:
-
-> Make Claude Fable more efficient by using cheaper subagents for token-heavy
-> research, coding, and testing, saving Fable for judgment, architecture,
-> synthesis, and final review.
+The user asked for /efficient-fable, an alias of /efficient-orchestrator. Follow the efficient-orchestrator skill exactly; install it alongside this alias.

skills/efficient-frontier/README.md

@@ -1,53 +1,3 @@
 # /efficient-frontier
 
-Apply the same orchestration as `/efficient-fable` to any high-cost frontier
-model.
-
-`/efficient-frontier` is the model-agnostic version of `/efficient-fable`. It
-works for any high-cost model where the expensive part should be reserved for
-judgment, synthesis, integration, and final quality.
-
-## What It Does
-
-- Separates frontier-only decisions from delegable work.
-- Pushes research scans, docs extraction, log reduction, browser checks,
-  mechanical edits, and narrow coding tasks to cheaper agents.
-- Asks delegated agents for compact evidence instead of broad essays.
-- Uses self-contained handoff packets with scope, verification, and stop
-  conditions.
-- Treats delegated findings as leads that the frontier model verifies before
-  relying on them.
-- Keeps final integration and risk assessment with the frontier model.
-
-## When To Use It
-
-Use it for large or ambiguous work where independent slices can run in parallel:
-repo exploration, refactors, multi-file implementation, test-failure clustering,
-or PR-quality validation.
-
-Skip it when the work is tiny, when edits are all in the same fragile files, or
-when the next step depends on one immediate blocker you need to inspect yourself.
-
-## Testing Guidance
-
-The frontier model should choose the validation plan. Cheaper agents can run
-unit checks, browser flows, screenshots, and log reduction, then return exact
-commands, failures, likely causes, and the signal quality.
-
-## Delegation Quality
-
-Give each delegated agent enough context to succeed without the full chat:
-objective, repo path, in-scope files, out-of-scope areas, expected evidence,
-verification commands, and stop conditions.
-
-The frontier model should reopen important cited files, review high-risk diffs,
-and spot-check verification before presenting the final answer.
-
-## Install
-
-```sh
-npx @agent-native/skills@latest add --skill efficient-frontier --update-instructions
-```
-
-Use `--update-instructions` when you want the orchestration convention added to
-project instructions.
+Alias for [`/efficient-orchestrator`](../efficient-orchestrator/README.md). It runs only when you invoke it by name.

skills/efficient-frontier/SKILL.md

@@ -1,76 +1,9 @@
 ---
 name: efficient-frontier
-description: >-
-  Apply the same orchestration as `/efficient-fable` to any high-cost frontier
-  model: delegate research, coding, and testing to cheaper subagents while
-  keeping planning, synthesis, and final review with the expensive model.
+description: Alias for /efficient-orchestrator. Run only when the user explicitly invokes /efficient-frontier; never self-activate.
+disable-model-invocation: true
 ---
 
-# Efficient Frontier
+# /efficient-frontier
 
-Use the expensive frontier model where its marginal judgment matters. Push
-repeatable, bounded, or token-heavy work to cheaper/faster subagents.
-
-## Workflow
-
-1. Identify the frontier-only decisions: architecture, prioritization,
-   ambiguity resolution, risk, synthesis, and final review.
-2. Identify delegable work: research scans, repository inventory, search, docs
-   extraction, browser/testing passes, log reduction, test failure clustering,
-   narrow coding, and mechanical edits.
-3. Spawn parallel subagents for independent slices with clear ownership,
-   bounded scope, verification gates, and expected evidence.
-4. Require compact returns: findings, changed files, commands run, residual
-   risk, stop conditions hit, and anything the frontier model must decide.
-5. Integrate and review centrally before presenting the result.
-
-## Handoff Packets
-
-Write delegated prompts as self-contained packets. Assume the receiving agent
-has not seen the conversation. Include the repo path, objective, scope,
-out-of-scope areas, relevant files or search targets, expected return format,
-verification commands, and stop conditions.
-
-Useful stop conditions:
-
-- The live code does not match the assumption in the handoff.
-- A verification command fails twice after a reasonable fix or retry.
-- The work appears to require files outside the assigned scope.
-- The agent cannot produce concrete evidence for its claim.
-
-## Review Loop
-
-Treat delegated output as evidence to inspect, not a verdict to forward. Reopen
-important cited files, skim high-risk diffs, and rerun or spot-check the
-verification that matters before claiming completion. If delegated agents
-disagree, resolve the disagreement at the frontier-model layer.
-
-## Common Scenarios
-
-Use these as soft suggestions:
-
-- Research: delegate broad repo scans, docs extraction, and source comparison;
-  the frontier model keeps the judgment about what matters.
-- Coding: delegate bounded patches, refactors, or mechanical edits when file
-  ownership is clear; integrate and review centrally.
-- Testing: let the frontier model choose the validation strategy and scripts,
-  then use cheaper agents to run unit checks, browser flows, screenshots, and
-  log reduction. Ask them to return exact commands, failures, likely causes, and
-  whether the signal looks flaky, environmental, or product-relevant.
-- Debugging: send independent agents after separate theories, logs, or repro
-  paths; keep the final diagnosis with the frontier model.
-
-## Guardrails
-
-- Do not delegate the immediate blocker if your next step depends on it.
-- Do not ask multiple agents to edit the same files at the same time.
-- Do not trust subagent conclusions blindly when the risk is high; inspect the
-  important evidence yourself.
-- Do not claim universal savings. The pattern works best when exploration and
-  implementation, testing, or research can be parallelized.
-
-## Default Framing
-
-"I will use the frontier model as the orchestrator and reviewer, and use
-cheaper subagents for token-heavy research, coding, or testing so the expensive
-tokens go to judgment, synthesis, and final quality."
+The user asked for /efficient-frontier, an alias of /efficient-orchestrator. Follow the efficient-orchestrator skill exactly; install it alongside this alias.