@maestrofrontier/frontier 1.4.3 → 1.4.5

package/integrations/README.md

@@ -1,18 +1,21 @@
 # Maestro integrations — slash commands for other CLIs
 
 The Claude Code plugin ships Maestro's slash commands (`/maestro:*`) plus
-enforcement hooks and auto-run. Other agent CLIs support **custom slash commands**
-too, but only as *prompt templates* — they inject instruction text, they do not run
-wrapper logic, gate tools, or auto-run on every prompt. So these ports are typing
-shortcuts that tell the agent to shell out to the portable Frontier engine via
-`maestro frontier ...`; they are **not** a plugin equivalent.
-
-Only `/frontier` and `/update` are ported. `/frontier` drives the portable engine
-(`maestro frontier ...`); `/update` refreshes the install (git pull or re-download +
-re-copy `frontier/`, `bin/maestro.cjs`, and the command files). `terse`,
-`context-bar`, and `settings` depend on Claude Code hooks/status line and would only
-inject text elsewhere; `compress` operates on memory files and is partly portable.
-The orchestration doctrine itself needs no command — it lives in `AGENTS.md` and
+enforcement hooks and auto-run. Codex CLI/Desktop can install Maestro as a
+native plugin from the repo marketplace; after the Maestro Codex plugin is
+installed, enabled, and trusted, Frontier can auto-route normal Codex prompts
+when you arm a project/workspace scope. Other agent CLIs mostly support
+**custom slash commands** as prompt templates: they inject
+instruction text, but do not run wrapper logic, gate tools, or auto-run every
+prompt. Those ports are shortcuts around the portable `maestro frontier ...`
+CLI, not plugin equivalents.
+
+Portable integrations include `/frontier` and `/update`; Codex also installs
+`maestro-frontier`, `maestro-settings`, `maestro-terse`, and `maestro-update`
+skills. `/frontier` drives the portable engine (`maestro frontier ...`);
+`/update` refreshes the install. `context-bar` is Claude Code-specific, while
+settings and terse are available through Codex skills or the portable CLI. The
+orchestration doctrine itself needs no command — it lives in `AGENTS.md` and
 loads on demand.
 
 ## Placement
@@ -20,16 +23,25 @@ loads on demand.
 | Runtime | Source in this repo | Install to | Invoke |
 |---|---|---|---|
 | Cursor | `integrations/cursor/commands/frontier.md` | `.cursor/commands/frontier.md` (per-repo) or `~/.cursor/commands/` (global) | `/frontier` |
-| Codex (CLI + IDE/Desktop) | `integrations/codex/skills/frontier/SKILL.md` (and `terse`, `settings`, `update`) | `.agents/skills/<name>/SKILL.md` (per-repo) or `~/.agents/skills/<name>/SKILL.md` (global) | `/frontier` |
+| Codex (CLI + Desktop) | `skills/maestro-frontier/SKILL.md` in the plugin; `integrations/codex/skills/` mirrors the same files for portable installs | bundled by the `maestro@maestro` Codex plugin; portable fallback copies to `.agents/skills/<name>/SKILL.md` | ask for the Maestro skill |
 
-After adding a file, restart the tool or open a new chat so it loads. Both runtimes
-expand `$ARGUMENTS` to the full argument string — `/frontier fusion opus-gpt` passes
-`fusion opus-gpt`.
+After adding a file, restart the tool or open a new chat so it loads.
 
-Each runtime passes an explicit `--scope` flag so armed state is per-CLI and never
-leaks across runtimes on the same machine: Codex uses `--scope codex`, Cursor uses
-`--scope cursor`. Claude Code autodetects its scope and needs no flag. If you add a
-Gemini or Antigravity integration, pass `--scope gemini`.
+Use an explicit `--scope` flag when the runtime cannot autodetect one. Codex
+plugin contexts resolve a project/workspace scope automatically (`codex-<8hex>`),
+which is the recommended default for repo installs. For manual Codex commands,
+use `--scope codex-project` from the repo root to target that same active scope:
+
+```bash
+maestro frontier status --scope codex-project
+maestro frontier mode fusion --preset chatgpt-duo --scope codex-project
+maestro frontier mode fusion --preset frontier-trio --judge chatgpt --synth chatgpt --scope codex-project
+maestro frontier mode off --scope codex-project
+```
+
+Global/user scope is optional and should be intentional. Cursor uses
+`--scope cursor`, Cline uses `--scope cline`, Gemini uses `--scope gemini`, and
+Windsurf/Devin use `--scope windsurf`.
 
 ## Updating portable installs
 
@@ -60,7 +72,7 @@ updates are a single invocation:
 | Runtime | Source in this repo | Install to | Invoke |
 |---|---|---|---|
 | Cursor | `integrations/cursor/commands/update.md` | `.cursor/commands/update.md` (per-repo) or `~/.cursor/commands/` (global) | `/update` |
-| Codex (CLI + IDE/Desktop) | `integrations/codex/skills/update/SKILL.md` | `.agents/skills/update/SKILL.md` (per-repo) or `~/.agents/skills/update/SKILL.md` (global) | `/update` |
+| Codex (CLI + Desktop) | `integrations/codex/skills/maestro-update/SKILL.md` | `.agents/skills/maestro-update/SKILL.md` (project/workspace) or `~/.agents/skills/maestro-update/SKILL.md` (global/user) | ask for `maestro-update` |
 
 **Version model:** Maestro pins no version for portable files. Fetching from
 latest `main` always resolves the newest committed code — no manual version bump
@@ -68,26 +80,31 @@ needed per release.
 
 ## Caveats
 
-- **No auto-run.** Neither runtime has a `UserPromptSubmit` hook, so arming a mode
-  (`mode fusion`) only persists state — nothing fuses later prompts automatically.
-  Use `/frontier run "<prompt>"` to actually run the panel.
-- **Codex uses skills, not prompts.** `maestro install --target codex` installs the
-  `frontier`, `terse`, `settings`, and `update` skills as Codex skills
-  (no-clobber) to `.agents/skills/<name>/SKILL.md` (per-repo) or
-  `~/.agents/skills/<name>/SKILL.md` (global). The deprecated
-  `~/.codex/prompts/frontier.md` prompt file remains as a compatibility bridge but
-  the canonical path is the skill.
+- **Auto-run parity varies.** Claude Code and Codex can auto-route after a mode is
+  armed. Cursor, Gemini, Cline, and Windsurf/Devin command ports are manual
+  shortcuts unless those runtimes add an equivalent trusted hook surface. Use
+  `maestro frontier run "<prompt>" ...` there for one-off panels.
+- **Codex uses plugin-bundled skills, not prompts.** Install the marketplace
+  once with `codex plugin marketplace add mbanderas/maestro`, then install
+  `maestro@maestro` with `codex plugin add maestro@maestro`. The portable
+  fallback `maestro install --target codex` still copies the
+  `maestro-frontier`, `maestro-terse`, `maestro-settings`, and
+  `maestro-update` skills to `.agents/skills/<name>/SKILL.md`
+  (project/workspace) or `~/.agents/skills/<name>/SKILL.md` (global/user).
+  Deprecated `~/.codex/prompts/*.md` prompt files remain compatibility bridges
+  only.
 - **Codex per-repo skill path:** `.agents/skills/<name>/SKILL.md` is the
   repo-scoped option for Codex skills. The global path is
   `~/.agents/skills/<name>/SKILL.md`.
 - **Maestro Frontier ON indicator (Codex only).** When
-  `maestro frontier status --scope codex` reports mode != off, the `frontier` skill
+  `maestro frontier status --scope codex-project` reports mode != off, the `maestro-frontier` skill
   instructs Codex to lead its reply with `Maestro Frontier ON (<label>)` —
   `single · <model>` or `fusion · <preset>`. When mode is off, no indicator line
   appears. This is Codex-scoped only and has no effect on Claude Code.
-- **Requires `frontier/` and `bin/maestro.cjs` in the project.** The command runs
-  `maestro frontier ...` (or `node bin/maestro.cjs frontier ...`) from the repo root,
-  so the engine must have been copied in during install.
+- **Engine location.** Plugin installs run the bundled engine from the
+  installed plugin; portable/manual installs run `maestro frontier ...` (or
+  `node bin/maestro.cjs frontier ...`) from the repo root, so the engine must
+  have been copied in during install.
 - **Windows + Gemini judge/synth.** `gemini` is fine as a panel member, but a poor
   `--judge`/`--synth` on Windows (its arg-passing rejects the newline-bearing
   judge/synth prompts, so the stage degrades). Use `opus` or `gpt-5.5` for

package/integrations/codex/prompts/frontier.md

@@ -1,32 +1,32 @@
 ---
-description: Maestro Frontier local multi-CLI fusion engine — switch mode, or run a prompt through the panel
+description: Maestro Frontier local multi-CLI fusion engine — arm, disarm, inspect, or debug-run the panel
 argument-hint: "<off | single <model> | fusion <preset> | status | run <prompt>>"
 ---
 
 Drive the **Maestro Frontier** engine — a zero-dependency local multi-CLI fusion
 engine (a parallel panel of local CLIs → a judge model's analysis → a grounded
-synthesis). It is the same engine the Claude Code plugin ships; here it runs through
-the `maestro` CLI, installed into this repo during setup.
+synthesis). It is the same engine the Claude Code plugin ships; here it runs
+through the `maestro` CLI, installed into this repo during setup.
 
-**This is a typing shortcut, not the Claude Code plugin.** Codex has no
-prompt hook, so arming a mode does **not** auto-run the engine on later prompts —
-it only persists the mode. To actually fuse a prompt, invoke `run` explicitly
-(step 3).
+When the Maestro Codex plugin hook is installed, enabled, and trusted, arming a
+non-`off` mode makes ordinary later Codex prompts auto-run through Frontier
+until disabled. Manual `run` remains available for advanced/debug one-offs.
 
 Requested action: `$ARGUMENTS`
 
 Map it to one engine CLI call and run it from the repo root. Do not edit
 the engine's state file by hand.
 
-1. Switch mode (persists to `~/.config/maestro/frontier-state.codex.json`; default `off`).
-   `--scope codex` keeps Codex's armed mode independent from Claude Code and Cursor on the same machine:
+1. Switch mode. Project/workspace scope is the default recommendation. Run from
+   the repo root with `--scope codex-project`; the CLI expands it to the same
+   `codex-<8hex>` scope the trusted Codex hook uses:
 
    ```bash
-   maestro frontier mode off --scope codex
-   maestro frontier mode single --model <model> --scope codex
-   maestro frontier mode fusion --preset <preset> --scope codex
-   maestro frontier mode fusion --preset custom --models <a,b,c> --scope codex
-   maestro frontier mode fusion --preset <preset> --judge <model> --synth <model> --scope codex
+   maestro frontier mode off --scope codex-project
+   maestro frontier mode single --model <model> --scope codex-project
+   maestro frontier mode fusion --preset chatgpt-duo --scope codex-project
+   maestro frontier mode fusion --preset frontier-trio --judge chatgpt --synth chatgpt --scope codex-project
+   maestro frontier mode fusion --preset custom --models <a,b,c> --scope codex-project
    ```
 
    Models: `opus` (Claude Opus 4.8, needs `claude`), `gpt-5.5` (needs `codex`),
@@ -34,18 +34,22 @@ the engine's state file by hand.
    `frontier-trio`, `custom`. Judge + synth default to Opus; `--judge`/`--synth`
    override for any preset (e.g. `--judge opus --synth gpt-5.5`). `gpt-duo` runs
    judge + synth on GPT-5.5 — a Codex-only fusion that needs no `claude`.
+   Friendly aliases are accepted: `chatgpt` -> `gpt-5.5`, and `chatgpt-duo` ->
+   `gpt-duo`.
 
 2. Show the current mode/preset:
 
    ```bash
-   maestro frontier status --scope codex
+   maestro frontier status --scope codex-project
    ```
 
-3. Run a prompt through the current mode — **this is the action that actually
-   fuses**, since nothing auto-runs here. Set a mode first (step 1), then:
+3. Normal use after arming: type ordinary Codex prompts. The trusted hook
+   auto-runs Frontier and injects the synthesized answer as context.
+
+4. Advanced/debug one-off run:
 
    ```bash
-   maestro frontier run "<prompt>" --scope codex
+   maestro frontier run "<prompt>" --scope codex-project
    ```
 
    - `off`: prints a notice, spawns nothing.

package/integrations/codex/prompts/update.md

@@ -30,6 +30,9 @@ curl -O https://raw.githubusercontent.com/mbanderas/maestro/main/bin/maestro.cjs
 ```
 
 After updating, run `node bin/maestro.cjs frontier status` to confirm the engine is present.
+For Codex skills, managed Maestro copies refresh automatically, user-edited
+copies are preserved with next-step output, and older exact unprefixed Maestro
+skills may be migrated to compatibility shims.
 
 Report what was refreshed and note any errors.
 

package/integrations/codex/skills/maestro-frontier/SKILL.md

@@ -0,0 +1,122 @@
+---
+name: maestro-frontier
+description: Maestro Frontier local multi-CLI fusion engine - arm, disarm, inspect, or debug-run the panel
+---
+
+Drive the **Maestro Frontier** engine: a zero-dependency local multi-CLI fusion
+engine where a parallel panel of local CLIs feeds a judge model's analysis and a
+grounded synthesis.
+
+When the Maestro Codex plugin hook is installed, enabled, and trusted, arming a
+non-`off` mode makes normal later Codex prompts auto-run through Frontier until
+you turn it off. Users should not need to type `maestro frontier run "<prompt>"`
+for normal use.
+
+Map the user's request to one engine CLI call and run it from the repo root.
+Do not edit the engine's state file by hand.
+
+## Command launcher
+
+Use `maestro` when it is on `PATH`. If it is not, and this skill is loaded
+from the Maestro Codex plugin, locate the plugin root by walking up from this
+`SKILL.md` until `.codex-plugin/plugin.json` is present, then run:
+
+```bash
+node "<maestro-plugin-root>/bin/maestro.cjs" frontier ...
+```
+
+In the examples below, `maestro frontier ...` means either the bare command or
+that plugin-root `node .../bin/maestro.cjs frontier ...` form.
+
+## 1. Switch mode
+
+Project/workspace scope is the default recommendation. Use `--scope
+codex-project` from the repository root; the CLI expands it to the same
+`codex-<8hex>` workspace scope the Codex plugin hook resolves from
+`PLUGIN_ROOT` / `PLUGIN_DATA`. Default mode is `off`.
+
+```bash
+maestro frontier mode off --scope codex-project
+maestro frontier mode single --model <model> --scope codex-project
+maestro frontier mode fusion --preset chatgpt-duo --scope codex-project
+maestro frontier mode fusion --preset frontier-trio --judge chatgpt --synth chatgpt --scope codex-project
+maestro frontier mode fusion --preset custom --models <a,b,c> --scope codex-project
+```
+
+Models: `opus` (Claude Opus 4.8, needs `claude`), `gpt-5.5` (needs `codex`),
+`gemini` (needs `gemini`). Presets: `opus-duo`, `opus-gpt`, `gpt-duo`,
+`frontier-trio`, `custom`. Friendly aliases are accepted: `chatgpt` maps to
+`gpt-5.5`, and `chatgpt-duo` maps to `gpt-duo`.
+
+Judge + synth default to Opus except for presets with explicit stage defaults.
+Override them for mixed panels with `--judge <model>` and `--synth <model>`;
+for example, `--judge chatgpt --synth chatgpt`.
+
+## 2. Show current mode/preset
+
+```bash
+maestro frontier status --scope codex-project
+```
+
+If you intentionally want one shared Codex state across unrelated repos, choose
+an explicit global name such as `--scope codex-global`. Do not use global scope
+unless that cross-repo behavior is what you want.
+
+## 3. Normal use after arming
+
+After mode is non-`off`, type ordinary Codex prompts. The trusted Codex hook
+auto-runs Frontier and injects the synthesized answer as context for the live
+reply. Turn it off with:
+
+```bash
+maestro frontier mode off --scope codex-project
+```
+
+## 4. Advanced/debug one-off run
+
+Manual one-off execution remains available for debugging:
+
+```bash
+maestro frontier run "<prompt>" --scope codex-project
+```
+
+- `off`: prints a notice, spawns nothing.
+- `single`: dispatches the one selected CLI, prints its answer.
+- `fusion`: runs the panel in parallel, then judge, then synthesizer; prints
+  the final answer (a one-line run meta goes to stderr). Report stdout verbatim.
+
+On error the engine prints `ERROR [<reason>]: <detail>` to stderr and exits
+non-zero; relay the reason.
+
+## Indicator instruction
+
+<!-- INDICATOR INSTRUCTION - apply every turn while this skill is active -->
+
+Before composing your first reply each turn, run:
+
+```bash
+maestro frontier status --scope codex-project
+```
+
+Parse the returned JSON `mode` field:
+
+- If `mode` is not `off`, make the **first line** of your reply exactly:
+  `Maestro Frontier ON (<label>)`
+  where `<label>` is formed as follows:
+  - single mode -> `single - <model>` (e.g. `single - opus`)
+  - fusion mode -> `fusion - <preset>` (e.g. `fusion - frontier-trio`);
+    for a custom preset use `fusion - custom (<model1>, <model2>, ...)`
+- If `mode` is `off`, output no indicator line.
+
+<!-- END INDICATOR INSTRUCTION -->
+
+## Notes
+
+- Real `single`/`fusion` runs spawn local CLIs and cost tokens; `off` is free.
+- The autorun hook no-ops when `FUSION_DEPTH >= 1`, so child `codex`, `claude`,
+  and `gemini` panel processes do not recursively run Frontier.
+- Each model's CLI must be on `PATH`, or point at a specific build with
+  `MAESTRO_CLAUDE_BIN` / `MAESTRO_CODEX_BIN` / `MAESTRO_GEMINI_BIN`.
+- Requires `node` on `PATH`. The bare `maestro` command is optional when the
+  skill is loaded from the Maestro Codex plugin; use the plugin-root launcher
+  above.

package/integrations/codex/skills/{settings → maestro-settings}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: settings
+name: maestro-settings
 description: View and change Maestro toggles (terse, frontier, context-bar) via the settings CLI
 ---
 
@@ -9,14 +9,24 @@ the three primary toggles: `terse`, `frontier`, and `context-bar`.
 When the user invokes this skill, run the settings CLI from the repo root.
 Do not edit settings files by hand.
 
+## Command launcher
+
+Use `node settings/cli.cjs` when Maestro is installed in the project root. If
+that file is not present and this skill is loaded from the Maestro Codex
+plugin, locate the plugin root by walking up from this `SKILL.md` until
+`.codex-plugin/plugin.json` is present, then run:
+
+```bash
+node "<maestro-plugin-root>/settings/cli.cjs" ...
+```
+
 ## Discover available commands
 
 ```bash
 node settings/cli.cjs --help
 ```
 
-If `settings/cli.cjs` is not present, run `maestro --help` to locate the
-correct entry point.
+If `settings/cli.cjs` is not present, use the plugin-root launcher above.
 
 ## Common operations
 
@@ -41,6 +51,5 @@ printed by `--help` — do not guess flags.
 
 - Changes persist in Maestro's settings store and apply to subsequent agent
   turns in this project.
-- Requires `node` on `PATH` and Maestro installed in the project root. If
-  `settings/cli.cjs` is missing, re-run the installer:
-  `npx github:mbanderas/maestro install --target codex`
+- Requires `node` on `PATH`. A project-local Maestro install is optional when
+  the skill is loaded from the Maestro Codex plugin.

package/integrations/codex/skills/{terse → maestro-terse}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: terse
+name: maestro-terse
 description: Toggle Maestro terse output level (lite, full, ultra, off) via the settings CLI
 ---
 
@@ -10,6 +10,17 @@ condenses agent replies; levels range from `off` (default verbosity) through
 When the user invokes this skill, run the settings CLI to read or change the
 terse level. Do not edit settings files by hand.
 
+## Command launcher
+
+Use `node settings/cli.cjs` when Maestro is installed in the project root. If
+that file is not present and this skill is loaded from the Maestro Codex
+plugin, locate the plugin root by walking up from this `SKILL.md` until
+`.codex-plugin/plugin.json` is present, then run:
+
+```bash
+node "<maestro-plugin-root>/settings/cli.cjs" ...
+```
+
 ## Check current terse level
 
 ```bash
@@ -17,8 +28,7 @@ node settings/cli.cjs --help
 ```
 
 Consult the help output for the exact read subcommand, then run it. If
-`settings/cli.cjs` is not present, run `maestro --help` to discover the
-correct path.
+`settings/cli.cjs` is not present, use the plugin-root launcher above.
 
 ## Set terse level
 
@@ -44,6 +54,5 @@ If the CLI rejects an argument or the subcommand name differs, run
 
 - The change persists in Maestro's settings store; it applies to subsequent
   agent turns in this project.
-- Requires `node` on `PATH` and Maestro installed in the project root. If
-  `settings/cli.cjs` is missing, re-run the Maestro installer:
-  `npx github:mbanderas/maestro install --target codex`
+- Requires `node` on `PATH`. A project-local Maestro install is optional when
+  the skill is loaded from the Maestro Codex plugin.

package/integrations/codex/skills/maestro-update/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: maestro-update
+description: Update Maestro to the latest marketplace version for Codex
+---
+
+Update **Maestro** to the latest Codex marketplace code. This refreshes the
+configured Git marketplace and reinstalls the Maestro plugin from it.
+
+When the user invokes this skill, run:
+
+```bash
+codex plugin marketplace upgrade maestro
+codex plugin add maestro@maestro
+```
+
+The update is idempotent. It will:
+
+- Pull the latest Maestro source from the repository.
+- Refresh the installed Maestro plugin cache.
+- Refresh bundled Codex skills and hooks exposed by the plugin.
+- Leave project-local configuration (state files, secrets) untouched.
+
+## Notes
+
+- Requires the Codex CLI on `PATH`.
+- After reinstalling, restart the Codex session or open a new thread so updated
+  skills and hooks take effect.
+- If the marketplace is not configured yet, run
+  `codex plugin marketplace add mbanderas/maestro` first.
+- Portable/manual installs can still be refreshed with
+  `npx github:mbanderas/maestro install --target codex` from the project root.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maestrofrontier/frontier",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "description": "Achieve Frontier AI performance in your CLI by fusing the model CLIs you already run. Maestro Frontier is an opt-in, zero-dependency local multi-CLI fusion engine for AI coding agents: fan a prompt across a panel of any 1 to 8 local model CLIs you pick, have a judge model and a synthesizer you choose read the answers into a structured analysis and write one grounded synthesis (default Opus 4.8, override either with --judge/--synth). On a 100-task benchmark every fusion panel outscored its individual member models. Three adapters ship today: Opus 4.8, GPT-5.5, Gemini 3.1 Pro, with Kimi, DeepSeek, GLM, and Qwen to follow. Off, single, and fusion modes switch via /maestro:frontier. Built on Maestro orchestration discipline: decision-gated routing, verified done-claims, surgical scope, and structural enforcement hooks.",
   "keywords": ["multi-cli-fusion", "fusion-engine", "frontier", "multi-agent", "orchestration", "claude-code", "gemini", "codex", "agents", "hooks", "doctrine"],
   "license": "MIT",
@@ -25,6 +25,9 @@
     "frontier/semaphore.cjs",
     "frontier/synthesize.cjs",
     "scripts/install.cjs",
+    ".codex-plugin/",
+    ".agents/plugins/marketplace.json",
+    "skills/",
     "AGENTS.md",
     "CLAUDE.md",
     "GEMINI.md",