aiblueprint-cli 1.4.95 → 1.4.97

package/README.md

@@ -102,24 +102,8 @@ npx aiblueprint-cli@latest agents config unify sessions
 
 ### Workflow Skills
 
-**Development:**
-- `commit` - Fast conventional commits
-- `create-pr` - Auto-generated PRs
-- `fix-pr-comments` - Resolve PR comments
-- `merge` - Context-aware branch merging
-
-**Project setup:**
-- `nextjs-setup-project` - Scaffold the preferred Next.js stack
-- `nextjs-add-prisma-db` - Add Prisma and PostgreSQL
-- `nextjs-setup-better-auth` - Wire Better Auth with email OTP
-- `create-vitejs-app` - Create a Vite app with Tailwind and shadcn/ui
-
-**SaaS planning:**
-- `saas-create-prd` - Build a lean Product Requirements Document
-- `saas-create-architecture` - Design technical architecture
-- `saas-create-tasks` - Generate implementation tasks
-- `saas-define-pricing` - Create pricing strategy
-- `saas-find-domain-name` - Generate and validate domains
+The free configuration ships the skills listed in the catalog below. The CLI
+installs every directory under `agents-config/skills/`.
 
 ### Agents (3 Specialized)
 
@@ -154,24 +138,26 @@ npx skills add Melvynx/aiblueprint --skill skill-manager
 
 | Skill | Description |
 |-------|-------------|
+| `agents-manager` | Create and orchestrate Claude Code agents |
+| `apex` | Structured implementation workflow |
+| `app-icon` | Generate and prepare app icons |
+| `appstore-connect` | Manage App Store Connect workflows |
 | `commit` | Quick commit and push with clean messages |
 | `create-pr` | Auto-generated pull requests |
 | `fix-pr-comments` | Resolve PR review comments |
+| `grill-me` | Stress-test a plan with focused questions |
 | `merge` | Context-aware branch merging |
+| `environments-manager` | Set up per-worktree agent environments |
+| `oneshot` | Implement one focused change quickly |
+| `prompt` | Create minimalist SVG logo variations |
 | `prompt-creator` | Expert prompt engineering |
+| `rules-manager` | Create and maintain agent rule files |
 | `skill-manager` | Manage skills and rules across Claude Code, Codex, and Cursor |
-| `saas-create-prd` | Build a lean SaaS PRD |
-| `saas-create-architecture` | Design SaaS technical architecture |
-| `saas-create-tasks` | Generate implementation task files |
-| `nextjs-setup-project` | Set up a production-ready Next.js project |
-| `create-vitejs-app` | Create a Vite app with Tailwind and shadcn/ui |
+| `tools` | AIBlueprint tools and libraries reference |
 | `use-style` | Apply named UI style guides before implementation |
 | `use-artifacts` | Create polished local HTML plans, prototypes, and visualizations |
-| `rules-manager` | Create and maintain AGENTS.md and agent rule files |
-| `agents-managers` | Manage Claude Code agents and Task-tool orchestration |
-| `environments-manager` | Set up per-worktree agent environments |
-| `grill-me` | Stress-test a plan with focused design questions |
-| `oneshot` | Ultra-fast feature implementation |
+| `use-delegate` | Delegate heavy work to cheap executors |
+| `use-goal` | Create evidence-based agent goals |
 | `ultrathink` | Deep thinking mode for elegant solutions |
 
 ## 💎 Premium

package/agents-config/skills/app-icon/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: app-icon
-description: Generate a premium, vibrant, dimensional iOS + Android app icon for an Expo / React Native app with AI image generation, then post-process it to App Store / Play specs. Use for "create my app icon", "generate the iOS icon", "redo the app logo", "make the launcher icon". Works with ANY image-generation tool (Codex `image_gen`, `gemini-cli` Nano Banana, gpt-image, …).
+description: Generate a vibrant dimensional iOS and Android app icon for an Expo or React Native app with AI image generation, then post-process it for store specs. Use for creating, regenerating, or polishing an app logo or launcher icon.
 argument-hint: "[app concept or brand]"
 ---
 

package/agents-config/skills/use-artifacts/SKILL.md

@@ -9,7 +9,7 @@ description: Create Claude-style local HTML artifacts under global ~/.agents/art
 
 Use this skill to simulate Claude Artifacts in agents that do not have a native artifact panel. The artifact is a small global workspace, usually a single self-contained HTML file, created at `~/.agents/artifacts/<id>/` so the user can open, inspect, and iterate on it from any repo.
 
-Always create artifacts in the global user directory: `/Users/melvynx/.agents/artifacts/<id>/`. Never create artifacts inside a repo-local `.agents/artifacts` directory, even when the current working directory is a product repo.
+Always create artifacts in the global user directory: `~/.agents/artifacts/<id>/`. Never create artifacts inside a repo-local `.agents/artifacts` directory, even when the current working directory is a product repo.
 
 The HTML is the deliverable. It should turn the agent's public reasoning, plan, findings, examples, and tradeoffs into a polished page the user can scan, not just dump markdown into a file.
 
@@ -112,7 +112,7 @@ application style, a requested style, or the minimalist fallback.
 4. Scaffold the workspace:
 
 ```bash
-python3 /Users/melvynx/.agents/skills/use-artifacts/scripts/create_artifact.py "<short title>" --style "<requested, project:app-name, or fallback style>" --kind thinking
+python3 "$HOME/.agents/skills/use-artifacts/scripts/create_artifact.py" "<short title>" --style "<requested, project:app-name, or fallback style>" --kind thinking
 ```
 
 5. Implement the artifact in `index.html`.
@@ -132,7 +132,7 @@ Each artifact directory should contain:
 
 Target location:
 
-- Always use `/Users/melvynx/.agents/artifacts/<id>/`.
+- Always use `~/.agents/artifacts/<id>/`.
 - Do not use `<current-project>/.agents/artifacts/<id>/`.
 - Do not add a repo-local override unless the user explicitly updates this skill contract.
 

package/agents-config/skills/use-delegate/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: use-delegate
+description: "Delegation mode: the host agent (Claude or Codex) plans and reviews while heavy work runs on cheap executors: OpenCode Kimi K3, Codex GPT-5.6 terra/sol. Use when the user invokes /use-delegate, says 'use delegate', 'delegate mode', 'orchestrator mode', or wants to save tokens/rate limits."
+---
+
+# Use Delegate
+
+The host agent (Claude Code or Codex, whichever is running this skill) is the thinker, never the typist. Its tokens are scarce; the executors below are cheap and steerable. The host decides **what** to do and judges **whether it was done well**: everything token-hungry runs elsewhere and reports back.
+
+## Core rule
+
+The host does not execute. It may: read a few targeted files, search, inspect git state, think, plan, decompose, write specs and delegation prompts, review diffs and reports, judge outputs, and talk to the user.
+
+The host must NOT directly do:
+
+- Implementation, refactors, migrations, test writing (any multi-file or >~15-line change)
+- Codebase-wide exploration or analysis (reading many files to "understand")
+- Computer use, browser automation, UI/UX verification
+- Log triage, data analysis, bulk mechanical edits
+- Running long build/test loops and reading their full output
+
+The only direct edits allowed: trivial single-file tweaks (a config value, a typo, a one-liner) where writing a delegation prompt would cost more than the edit itself.
+
+## Executors
+
+| Executor | Command | Use for |
+|---|---|---|
+| OpenCode · Kimi K3 | `opencode run "<prompt>" -m kimi-for-coding/k3` | Default general executor: implementation, refactors, tests, bulk edits |
+| Codex · GPT-5.6 terra (high) | `codex exec -m gpt-5.6-terra "<prompt>"` | Low-stakes tasks: mechanical edits, scripts, quick investigations, log triage |
+| Codex · GPT-5.6 sol (high) | `codex exec "<prompt>"` (config default = sol + high) | Compute-heavy tasks: hard bugs, migrations, architecture-sensitive changes, computer use / UI verification |
+| Host-native subagents | Claude `Agent` tool / Codex collab threads | Exploration summaries the host plans from; taste-sensitive work (UI, copy, API design) |
+
+Read-only investigation: `codex exec -s read-only`, `opencode run --agent plan` (built-in read-only agent).
+
+Model rankings move fast: current DeepSWE scores, API pricing, and the refresh protocol live in `references/models.md`. Check its `Last verified` date before planning a big batch; if older than 14 days, delegate a refresh first (DeepSWE leaderboard + pricing pages), never guess rankings from memory.
+
+## Invocation mechanics
+
+Both CLIs: always end the command with `< /dev/null` and run in background (codex hangs forever on open stdin: full codex mechanics in `~/.claude/rules/launch-codex.md`).
+
+**Codex** (background):
+
+```bash
+codex exec -C <repo-root> -m gpt-5.6-terra \
+  --output-last-message <scratchpad>/codex-<task>.md \
+  "<self-contained prompt>" < /dev/null
+```
+
+Effort override: `-c model_reasoning_effort=high`. Non-git dir: `--skip-git-repo-check`.
+
+**OpenCode** (background):
+
+```bash
+opencode run "<self-contained prompt>" \
+  -m kimi-for-coding/k3 --title "<task>" \
+  > <scratchpad>/oc-<task>.log 2>&1 < /dev/null
+```
+
+- Final answer = tail of the log; `--format json` for machine-readable events.
+- Steer or continue a session: `opencode run -s <sessionID> "<follow-up>"`.
+- Standalone specialized agent: `--agent <name>`: the `~/.config/opencode/agent/` roster (worker, explore-fast, verifier, snipper, code-reviewer…) runs standalone with any `-m` model.
+- Permissions are pre-allowed in the user config (build agent allows all); no interactive prompt will block a non-interactive run.
+
+## Batch / multi-process
+
+- **Parallel processes** (verified): launch N independent `opencode run` / `codex exec` in background; each opencode run spins up its own server + session, results stay isolated.
+- **Shared server** for large batches: `opencode serve --port <p>` once, then N × `opencode run --attach http://localhost:<p> --dir <workdir> ...`: one server, many sessions, less startup overhead. Kill the serve process when done.
+- **In-executor subagents**: Kimi in opencode spawns its own task-tool subagents; codex spawns collab threads (config caps 6). Prefer one executor process per independent task over one giant prompt.
+
+## The loop
+
+1. **Think.** Understand the request. Missing context → delegate the exploration, think on the summaries.
+2. **Spec.** Write a self-contained delegation prompt: exact files, goal, constraints, and what "done" looks like (tests pass, lint clean, behavior X). The executor can't see this conversation: spell everything out.
+3. **Delegate.** Fire independent tasks in parallel in background. Stay available to steer.
+4. **Verify.** Delegate verification too: read-only pass, test run, or `verifier` agent. The host reads the report and the diff, not the whole tree.
+5. **Judge.** Output misses the bar → refine the spec and re-delegate (better prompts beat manual fixes). Escalate terra → Kimi K3 → sol → host-native only when the cheaper tier keeps failing.
+
+## Delegation prompt checklist
+
+- Names exact files/paths and the repo root
+- States the goal in one sentence, then constraints (style, deletion safety: `trash` not `rm -rf`, no scope creep)
+- Defines done: commands to run, expected results
+- Asks for a report: changed files, what was done, tests run, risks
+
+## Anti-patterns
+
+- "It's faster if I just do it": beyond a trivial tweak it isn't, and it burns the budget the whole session depends on.
+- Reading 10 files to plan: delegate exploration, plan from the summary.
+- Fixing an executor's output by hand: refine the prompt and rerun.
+- Serializing independent delegations: parallelize.
+- Escalating everything to sol or the host: terra and Kimi K3 handle most well-spec'd work.
+
+If no delegation path works (CLIs unavailable, Bash denied), say so explicitly and ask the user before falling back to direct execution: never silently drop out of the mode.

package/agents-config/skills/use-delegate/references/models.md

@@ -0,0 +1,32 @@
+# Delegation models: current rankings and pricing
+
+Last verified: 2026-07-20
+
+**Refresh protocol**: if the date above is older than 14 days, refresh BEFORE planning a big delegation batch. Delegate the research (exa-search skill or a read-only executor): pull the DeepSWE leaderboard (https://deepswe.datacurve.ai/) and the provider pricing pages, then update both tables and the date. DeepSWE is the reference signal: 113 original long-horizon engineering tasks, contamination-free, cost-per-task published per model.
+
+## DeepSWE leaderboard (best config per model, snapshot 2026-07-17)
+
+| Model | Pass@1 | Avg cost/task | Read |
+|---|---|---|---|
+| gpt-5.6-sol [max] | 73% | $8.39 | Top score, best cost among frontier |
+| claude-fable-5 [max] | 70% | $21.63 | Host tier: 2.6x sol cost, never a delegation target |
+| gpt-5.6-terra [max] | 70% | $4.95 | Sol-level score at 59% of the cost |
+| kimi-k3 [max] | 69% | $4.65 | Within noise of terra/sol, cheapest of the top pack |
+| gpt-5.6-luna [max] | 67% | $3.03 | Acceptable floor for trivial bulk work |
+| gpt-5.5 [xhigh] | 67% | $7.23 | Superseded by the 5.6 family |
+| claude-opus-4.8 [max] | 59% | $13.22 | Dominated: lower score, higher cost |
+
+## API list pricing (per 1M tokens)
+
+| Model | Input | Cached input | Output | Context |
+|---|---|---|---|---|
+| Kimi K3 (Moonshot) | $3.00 | $0.30 | $15.00 | 1M |
+| GPT-5.6 Sol | $5.00 | $0.50 | $30.00 | 1.05M |
+| GPT-5.6 Terra | $2.50 | $0.25 | $15.00 | 1.05M |
+| GPT-5.6 Luna | $1.00 | ~$0.10 | $6.00 | 1.05M |
+
+## Access notes (this machine)
+
+- Kimi K3: flat-rate through the kimi-for-coding subscription in opencode (`-m kimi-for-coding/k3`), so marginal cost per delegation is ~zero. The opencode-go gateway is unfunded (insufficient balance): do not route through it. Open weights due 2026-07-27; 1M context; native vision; Terminal-Bench 88.3.
+- GPT-5.6 sol/terra/luna: covered by the Codex subscription (`codex exec -m gpt-5.6-<tier>`); config default is sol + effort high.
+- Current call (2026-07-20): Kimi K3 is the default executor (top-pack score, subscription-covered). Terra for low-stakes tasks. Sol for compute-heavy work. Luna only for trivial bulk edits.

package/agents-config/skills/use-goal/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: use-goal
+description: Use when the user asks to create, draft, set, start, or refine a Codex or Claude Code /goal objective for persistent multi-turn work.
+---
+
+# Use Goal
+
+Create or draft a Codex or Claude Code Goal that follows the official `/goal` contract: one persistent objective with evidence-based completion criteria.
+
+## When To Use
+
+Use this skill when the user explicitly asks to:
+
+- create, set, start, or use a Goal
+- turn a task into a strong `/goal`
+- make Codex or Claude Code continue until an outcome is actually done
+- define success criteria for longer debugging, optimization, migration, refactor, benchmark, flaky-test, or research work
+
+Do not introduce a Goal for a one-off edit, short explanation, simple code review, or single answer unless the user explicitly asks for Goal mode.
+Do not use a Goal for a loose backlog or unrelated task list. A good Goal is bigger than one prompt but smaller than an open-ended project.
+
+## Pick The Platform
+
+Before drafting or creating a Goal, identify the active platform from the runtime and available tools:
+
+- **Codex**: use `references/codex-goal.md`.
+- **Claude Code**: use `references/claude-code-goal.md`.
+- **Unknown platform**: draft a plain `/goal ...` command and state that the user should run it in the target agent.
+
+If Goal tools are available in Codex, use them rather than only printing a slash command. If the runtime only exposes slash commands, return the exact `/goal ...` command unless the harness can dispatch it directly.
+
+## Goal Shape
+
+Before writing or creating the Goal, think through the verification strategy. Inspect repository docs, package scripts, tests, CI config, benchmark scripts, failing logs, linked issue text, plans, or referenced files when the evidence surface is not obvious.
+
+Identify which command, artifact, report, screenshot, benchmark, source document, or manual check can prove completion. Prefer existing project commands and documented workflows over invented validation. If no reliable verification surface exists, ask one concise question or make the Goal explicitly require creating one.
+
+Write one compact objective with the outcome, verification surface, constraints, boundaries, iteration policy, and blocked stop condition. For long-running implementation work, include the files to inspect first, exact proof commands, checkpoint behavior, and a short progress log requirement.
+
+Prefer this pattern:
+
+```text
+<desired end state>, verified by <specific evidence>, while preserving <constraints>. Use <allowed inputs, tools, or boundaries>. Between iterations, <how to choose and record the next best action>. If blocked or no valid paths remain, stop with <attempted paths, evidence gathered, blocker, and next input needed>.
+```
+
+## Create Or Draft
+
+When goal tools are available, check the current Goal first. Create a new one only when the user explicitly asks for it and no active Goal blocks it. Do not overwrite, clear, pause, or resume an existing Goal unless explicitly requested.
+
+If the user asks only to draft, rewrite, explain, or refine a Goal, return the final `/goal ...` text instead of activating it.
+
+## Evidence Rules
+
+Completion must be evidence-based. Do not mark a Goal complete because the work seems likely done, because a budget is exhausted, or because no more work is planned. Only mark it complete after verifying the stated stopping condition. If blocked, report the attempted paths, evidence gathered, blocker, and exact input or external change needed.
+
+## References
+
+- `references/codex-goal.md`: Codex Goal mode, tools, lifecycle, and completion rules.
+- `references/claude-code-goal.md`: Claude Code `/goal` command, evaluator, and manual activation.
+- `references/verification-harnesses.md`: measurable validation for refactors, deletions, migrations, and moves.

package/agents-config/skills/use-goal/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "Use Goal"
+  short_description: "Create evidence-based Codex or Claude Code goals"
+  icon_small: "./assets/codex-icon.svg"
+  icon_large: "./assets/codex-icon.svg"
+  brand_color: "#C70A64"
+  default_prompt: "Use $use-goal to help with this task."

package/agents-config/skills/use-goal/assets/codex-icon.svg

@@ -0,0 +1,4 @@
+<svg role="img" aria-label="use-goal skill icon" width="64" height="64" viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg">
+  <rect width="64" height="64" rx="16" fill="#C70A64"/>
+  <path d="M20 20h24v6H26v8h14v6H26v4h18v6H20V20Z" fill="#fff"/>
+</svg>

package/agents-config/skills/use-goal/references/claude-code-goal.md

@@ -0,0 +1,17 @@
+# Claude Code Goal Reference
+
+Use this reference when the active agent is Claude Code.
+
+Official reference: https://code.claude.com/docs/en/goal
+
+Claude Code uses `/goal` to set a completion condition for the current session. `/goal <condition>` starts Goal mode, `/goal` shows its state, and `/goal clear` removes it. Only one Goal can be active per session.
+
+The condition must describe one measurable end state and the proof Claude must surface in the transcript. Include constraints, the files or logs to inspect first, checkpoint reporting, and a bounded blocked stop clause when useful. Goal conditions can be up to 4,000 characters.
+
+If the harness cannot dispatch slash commands, output the exact `/goal ...` command and ask the user to paste it manually. Do not replace it with a task list or call `/goal` Claude-only.
+
+Prefer:
+
+```text
+/goal <desired end state>, verified by <proof surfaced in the transcript>, while preserving <constraints>. First inspect <files/docs/logs>. After each turn, report the checkpoint, command result, remaining gap, and next smallest step. Stop when the proof is present, or after <bound> with attempted paths, evidence, blocker, and needed input.
+```

package/agents-config/skills/use-goal/references/codex-goal.md

@@ -0,0 +1,15 @@
+# Codex Goal Reference
+
+Use this reference when the active agent is OpenAI Codex.
+
+Official references:
+
+- https://developers.openai.com/codex/use-cases/follow-goals
+- https://developers.openai.com/codex/app/commands
+- https://developers.openai.com/codex/cli/slash-commands
+
+`/goal <objective>` starts Goal mode. `/goal` views the current Goal. `/goal pause`, `/goal resume`, and `/goal clear` manage lifecycle. Objectives must be non-empty and at most 4,000 characters.
+
+When Goal tools are available, call `get_goal` before lifecycle actions and create a new Goal only when the user explicitly asks and no active Goal exists. Do not overwrite an existing Goal without explicit permission. If Goals are unavailable, tell the user to enable `[features] goals = true` or run `codex features enable goals`.
+
+A strong Goal defines one objective and stopping condition, initial files/docs, exact proof commands or artifacts, non-regression constraints, checkpoint behavior, and the evidence to report if blocked.

package/agents-config/skills/use-goal/references/verification-harnesses.md

@@ -0,0 +1,7 @@
+# Verification Harnesses For Refactors
+
+Use this reference when a Goal involves refactoring, deletion, migration, moving files, eliminating a pattern, or reducing a code smell.
+
+Convert the desired end state into a deterministic count, list, or command result. First establish the baseline before editing. Prefer existing repository tooling; otherwise create a narrow, deterministic checker that prints grouped findings and exits non-zero while work remains. Exclude generated, vendored, build, lockfile, snapshot, and binary content unless the task includes it.
+
+For deletion or migration Goals, verify both the old surface is gone and the new surface works: no imports, string references, routes, config entries, or tests should point at removed paths, and typecheck/build/test should pass. Rerun the harness after each change and report the delta.

package/dist/cli.js

@@ -33746,7 +33746,11 @@ async function hasContent(folderPath) {
 async function copyManagedFolder(source, destination) {
   await import_fs_extra7.default.copy(source, destination, {
     overwrite: true,
-    dereference: os10.platform() === "win32"
+    dereference: os10.platform() === "win32",
+    filter: async (sourcePath) => {
+      const stat = await import_fs_extra7.default.lstat(sourcePath);
+      return !(stat.isSocket() || stat.isFIFO() || stat.isCharacterDevice() || stat.isBlockDevice());
+    }
   });
 }
 async function writeMetadata(snapshotPath, metadata) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiblueprint-cli",
-  "version": "1.4.95",
+  "version": "1.4.97",
   "description": "AIBlueprint CLI for setting up AI coding configurations",
   "author": "AIBlueprint",
   "license": "MIT",

package/agents-config/skills/use-fable/SKILL.md

@@ -1,64 +0,0 @@
----
-name: use-fable
-description: "Orchestrator mode for Fable: Fable thinks, plans, and reviews while Codex CLI and subagents execute all heavy work. Use when the user invokes /use-fable, says 'use fable', 'fable mode', 'orchestrator mode', or wants to save Fable tokens/rate limits."
----
-
-# Use Fable
-
-Fable is the thinker, never the typist. Its tokens are scarce and expensive; Codex (GPT-5.5) is effectively free and highly steerable. In this mode, Fable's job is deciding **what** to do and judging **whether it was done well** — everything token-hungry runs elsewhere and reports back.
-
-Model rankings, Codex mechanics, and effort settings live in `~/.claude/rules/models.md` (already in context). This skill is the enforcement layer.
-
-## Core rule
-
-Fable does not execute. Fable may: read a few targeted files, search, inspect git state, think, plan, decompose, write specs and delegation prompts, review diffs and reports, judge outputs, and talk to the user.
-
-Fable must NOT directly do:
-
-- Implementation, refactors, migrations, test writing (any multi-file or >~15-line change)
-- Codebase-wide exploration or analysis (reading many files to "understand")
-- Computer use, browser automation, UI/UX verification
-- Log triage, data analysis, bulk mechanical edits
-- Running long build/test loops and reading their full output
-
-The only direct edits allowed: trivial single-file tweaks (a config value, a typo, a one-liner) where writing a delegation prompt would cost more than the edit itself.
-
-## Who executes what
-
-| Task | Executor |
-|------|----------|
-| Well-spec'd implementation, refactors, migrations, bulk edits | Codex: `codex exec "<prompt>"` |
-| Investigation, codebase analysis, log/data triage (no writes) | Codex: `codex exec -s read-only "<prompt>"` |
-| Computer use, UI/UX verification, browser checks | Codex (way better at it) or `verifier`/`dev-browser` subagent |
-| Codebase exploration to inform a plan | `Explore` or `explore-fast` subagent — Fable reads the summary, not the files |
-| User-facing taste work (UI, copy, API design) | Claude subagent with `model: "opus"` |
-| Plan/implementation review | Fable itself (its core job), optionally + Codex as second perspective |
-| Inside a Workflow | thin `sonnet`/`effort: low` wrapper agent that runs `codex exec` via Bash and returns output verbatim |
-
-Claude subagents always get `model: "opus"` unless the wrapper-for-Codex pattern applies. Never Haiku.
-
-## The loop
-
-1. **Think.** Understand the request. If context is missing, delegate the exploration (don't read the codebase yourself) and think on the summaries.
-2. **Spec.** Write a self-contained delegation prompt: exact files, goal, constraints, and what "done" looks like (tests pass, lint clean, behavior X). Codex can't see this conversation — spell everything out. See `/codex:gpt-5-4-prompting` for hard cases.
-3. **Delegate.** Fire independent tasks in parallel (multiple `codex exec` in background, or multiple subagents in one message). Stay available to steer.
-4. **Verify.** Delegate verification too — Codex read-only pass, test run, or `verifier` agent. Fable reads the report and the diff, not the whole tree.
-5. **Judge.** If the output misses the bar: refine the spec and re-delegate (Codex is steerable — better prompts beat manual fixes), or escalate to an opus subagent for taste-sensitive work. Do not "just fix it quickly" yourself — that's how the mode dies.
-
-## Delegation prompt checklist (for Codex)
-
-- Names exact files/paths and the repo root
-- States the goal in one sentence, then constraints (style, deletion safety: `trash` not `rm -rf`, no scope creep)
-- Defines done: commands to run, expected results
-- Asks for a report: changed files, what was done, tests run, risks
-- Non-git/untrusted dir → add `--skip-git-repo-check`
-
-## Anti-patterns
-
-- "It's faster if I just do it" — for anything beyond a trivial tweak, it isn't: it burns the budget the whole session depends on.
-- Reading 10 files to plan — delegate exploration, plan from the summary.
-- Fixing Codex's output by hand — refine the prompt and rerun instead.
-- Serializing independent delegations — parallelize.
-- Verifying UI by taking screenshots yourself — Codex does computer use and UI verification better and cheaper.
-
-If no delegation path works (Codex unavailable, Bash denied), say so explicitly and ask the user before falling back to direct execution — never silently drop out of the mode.