bullswarm 0.25.5 → 0.26.0

package/AGENTS.md

@@ -59,13 +59,13 @@ bullswarm workflow runs delete <shortId> --yes
 ## Using bullswarm from another agent
 
 If you are an agent that wants to offload bounded work via bullswarm,
-read `skill/SKILL.md` — that's the agent-facing user guide. Use
-`bullswarm delegate` (or the installed `/bullswarm` skill) by default: it
-previews whether one bounded agent or an autonomous workflow is appropriate,
-shows the conceptual plan, and executes the chosen engine. Reach for `run`,
-`workflow goal`, or a fixed workflow graph directly only when the caller has
-already chosen that execution shape. The skill is published alongside the
-package and is the canonical reference for the CLI surface.
+read `skill/SKILL.md` — that's the agent-facing user guide. There are
+exactly two ways to start work, and the caller chooses the shape itself: one
+bounded outcome goes to `bullswarm run`; parallel territories, integration,
+or independent acceptance go to `bullswarm workflow goal` with a program you
+author (`bullswarm workflow plan contract` returns the schema). There is no
+classifier or preview step. The skill is published alongside the package and
+is the canonical reference for the CLI surface.
 
 - Zero runtime dependencies. Node >= 18. Tests must never require network:
   prime `~/.bullswarm/meters/*.json` caches with fresh timestamps if needed.

package/CHANGELOG.md

@@ -1,5 +1,108 @@
 # bullswarm changelog
 
+## 0.26.0 — two entry points, kinds and rungs
+
+- There are now exactly two ways to start work, and `bullswarm delegate` is
+  gone. `delegate` existed to decide, on the caller's behalf, whether a request
+  needed one agent or a workflow — with `--mode auto` it spent a real
+  analyze-lane dispatch on a deterministic-then-LLM classifier before doing any
+  of the actual work. The calling agent already knows the shape of its own
+  request, so that round trip bought latency and quota, not accuracy. `bullswarm
+  run` is the single-agent entry point and `bullswarm workflow goal` is the
+  workflow entry point; `bullswarm --help` names those two, in that order, and
+  `bullswarm delegate` now exits 2 with the standard unknown-verb message and
+  dispatches nothing. The packaged skill and the awareness block registered into
+  Codex, Claude, and Grok say the same thing in six lines: decide the shape
+  yourself, there is no preview step.
+
+- `bullswarm run --lane analyze` now defaults to `medium` effort instead of
+  `high`. The V2 validator has always defaulted an analyze action to medium, so
+  the same lane meant a different tier depending on which entry point you used.
+  `run` and the validator now read one exported `DEFAULT_EFFORT_BY_LANE` table,
+  and `run --help` states the corrected default.
+
+- Program actions can now say what they *are* instead of restating how to route
+  them. The optional `kind` field takes one of seven values — `mechanical`,
+  `io-read`, `check`, `implement`, `integration`, `architecture`,
+  `adversarial-acceptance` — and derives `lane` and `effort` from a table
+  exported alongside the existing per-lane default. Resolution is per field: an
+  explicit action field wins, then the kind table, then a new optional
+  program-level `defaults` object (`effort` and `reasoning` only), then the lane
+  default. A kind outside the closed list is a validation error with the allowed
+  values named, because it is a typo in the program rather than a runtime
+  condition. Programs that use neither `kind` nor `defaults` and state
+  `lane` and `effort` on every action normalise byte-identically to before;
+  `effort` itself is now optional and falls back to the per-lane default
+  where it used to be rejected as missing.
+
+- Two non-blocking advisories, never rejections. `all-writers-high` fires when
+  three or more build/chore actions run and none is below high effort;
+  `docs-at-high` fires when a build/chore action owns only `*.md` files at high
+  effort. `workflow plan validate --json` carries them as `advisories` and the
+  human output prints `advisory:` lines; `workflow goal --program` prints the
+  same lines at launch. Neither changes acceptance or an exit code. The kernel
+  records them on the run, and `workflow runs show` lists them.
+
+- `workflow runs result`, `runs show`, and `action show` print `kind` next to
+  lane and effort when an action has one. `workflow action show` now understands
+  autonomous V2 runs at all — it previously read only the V1 action ledger and
+  failed on every V2 run.
+
+- **Rungs: one pool's model plus its reasoning level, for one effort tier, read
+  and written as one thing.** `bullswarm strategy rungs [--json] [--pool <name>]`
+  prints one row per enabled pool and configured tier with the effective model
+  and its source, the effective reasoning level and the layer that chose it, the
+  dated Epoch benchmark evidence for that model *at that level* (`blended`, cost
+  per task, tokens per task), and the local record from the decision log for that
+  pool and tier (dispatches, median wall minutes, ok share). Absent evidence
+  prints `no evidence` and an unmeasured tier prints `no dispatches`; neither is
+  ever estimated. `strategy inventory --json` gained the same rows under `rungs`.
+
+- `bullswarm strategy set-rung <pool> <tier> --model <model> [--reasoning <level>]
+  [--force]` writes both halves of a rung in one atomic state save, so the model
+  and the thinking depth can never land separately. A rung is singular per pool
+  and tier: the tier moves off whichever model held it, and that model keeps its
+  other tiers. A level the connector cannot express is clamped to the strongest
+  it accepts and the clamp is printed. An unknown pool or tier exits 2; a model
+  absent from the pool's cached discovery exits 2 and lists the known models
+  unless `--force` is given. Neither `rungs` nor `set-rung` ever spawns model
+  discovery. No state migration: rungs are a projection of `strategy.modelTiers`
+  and `strategy.reasoning`, and `~/.bullswarm/state.json` gained no keys.
+
+- The setup wizard's tier step now shows each suggested rung with its benchmark
+  evidence line and asks one reasoning question per configured tier. **Behavior
+  change:** Enter keeps that connector's own per-tier default and writes nothing,
+  where the previous question stored a suggested level (`xhigh`/`high`/`medium`)
+  on a blank answer. Connector defaults remain the final fallback, so a pool with
+  no configured rung behaves exactly as before. Non-TTY and `--yes` paths are
+  unchanged.
+
+- A dated evidence datapack per model *and reasoning level*, from Epoch AI.
+  `data/epoch-benchmarks.json` (schema `bullswarm.epoch.benchmarks.v1`) is built
+  by the new `scripts/refresh-epoch-benchmarks.mjs` from Epoch's cursorbench,
+  deepswe, arc-agi-2, and critpt exports, and `src/lib/epoch-benchmarks.js`
+  reads it with the same cache → bundled → URL fallback as the OpenRouter pack.
+  `rungEvidence()` returns the mean of whichever of those four scores exist for a
+  (model, level) pair as `blended`, with cost and tokens per task from
+  cursorbench; `normalizeModelId()` is how connector model ids match the export.
+  The data is used under CC BY 4.0 — Epoch AI, 'AI Benchmarking Hub'. Published
+  online at epoch.ai. Retrieved from https://epoch.ai/benchmarks.
+
+- The daily refresh job is renamed `.github/workflows/refresh-benchmarks.yml` and
+  now refreshes both assets on the rolling `benchmark-data-latest` release: it
+  downloads and unzips Epoch's public export, runs the script, runs the new
+  tests, and uploads `epoch-benchmarks.json` next to `openrouter-benchmarks.json`.
+  The ambiguous `npm run refresh:benchmarks` script is split into
+  `refresh:openrouter` and `refresh:epoch`, since only one of the two now
+  refreshes "the benchmarks".
+
+- The OpenRouter builder is unchanged, and that is a finding rather than an
+  omission: the Artificial Analysis records in the 2026-09-08 capture carry only
+  `agentic_index`, `coding_index`, and `intelligence_index` per model, with no
+  reasoning-effort marker on any of the `reasoning_effort`, `effort`, `variant`,
+  `reasoning`, or `reasoning_level` fields checked, so there is no per-effort row
+  to keep. `data/README.md` records the field names inspected.
+
 ## 0.25.5 — forecast-aware routing
 
 - Bullswarm now knows what it is already running. Every dispatch registers the

package/README.md

@@ -6,10 +6,24 @@ evidence agents by quota, and computes completion from a durable requirement
 ledger without an initiating agent authoring a graph.
 Every delegate output is judged by content before it counts.
 
-For agents, `/bullswarm` (or `$bullswarm` where skills use that syntax) is the
-common entry point. Its durable CLI equivalent is `bullswarm delegate`: it
-first explains whether the request needs one bounded agent or an autonomous
-workflow, shows the conceptual plan, and then executes the selected engine.
+## Entry points
+
+There are exactly two ways to start work:
+
+```bash
+bullswarm run --lane analyze --add-dir ~/some-repo --prompt "Explain the parser" --json
+bullswarm workflow goal "Fix the failing tests and verify the change" --cwd ~/some-repo --program plan.json
+```
+
+`bullswarm run` is the single-agent entry point: route, dispatch, watch,
+verify, one JSON verdict. `bullswarm workflow goal` is the workflow entry
+point: you author the bounded action program and the kernel executes it to the
+end. For agents, `/bullswarm` (or `$bullswarm` where skills use that syntax)
+reads the packaged skill and goes straight to one of those two. The calling
+agent decides the shape itself from the request — one bounded outcome takes
+`run`, parallel territories, integration, or independent acceptance take
+`workflow goal`. There is no preview, classifier, or dispatcher command
+between them.
 
 Every command and nested subcommand supports contextual `-h` / `--help`
 without initializing state or executing the command:
@@ -79,9 +93,6 @@ bullswarm setup    # interactive provider/model configuration
 bullswarm setup --wizard  # broader worktree + integration questionnaire
 bullswarm pools    # meter state, pace position, quarantine status
 bullswarm strategy  # explicit alias for the same routing control center
-bullswarm delegate --cwd ~/some-repo --prompt "Explain the parser"            # one agent
-bullswarm delegate --cwd ~/some-repo --prompt "Audit all commands, fix help, and independently verify"  # workflow
-bullswarm delegate --dry-run --json --cwd ~/some-repo --prompt "Your task"     # bounded classification + decision/plan; no work dispatch
 bullswarm run --lane analyze --add-dir ~/some-repo --task-file /tmp/t.md --json
 bullswarm run --lane analyze --add-dir ~/some-repo --prompt "Inspect the parser" --json
 bullswarm workflow plan contract "Fix the failing tests and verify the change" --cwd ~/some-repo --json  # you are the planner
@@ -96,7 +107,6 @@ bullswarm health   # re-judge saved outputs; catch gate failures
 |---|---|
 | `setup` | Discover installed agent CLIs, show quota state, toggle pools, suggest a routing table, write config. Approval-gated, idempotent. |
 | `integrate` | Register or remove the canonical Bullswarm skill and global awareness rules for Codex, Claude, and Grok. |
-| `delegate` | Explain and execute the smallest reliable shape: one content-verified agent, or the planning contract for an autonomous workflow you author (`--orchestrator` dispatches a planner agent instead). |
 | `run` | route → dispatch → watch → verify → one JSON verdict |
 | `health` | Re-judge saved outputs against their verdicts; surface verify-gate failures and quarantine clusters |
 | `pools` | Show each pool's meter state, pace position, 5-hour utilization (`5h=<n>%`, flagged `NEAR-5H-LIMIT` at or above 75%), quarantine status |
@@ -107,22 +117,6 @@ bullswarm health   # re-judge saved outputs; catch gate failures
 | `version` / `--version` | Print the installed Bullswarm version. |
 | `release` | Run the guarded local version-bump, commit, and tag workflow used before CI publishes to npm. |
 
-### Delegate classification
-
-With the default `--mode auto`, `delegate` first uses deterministic task
-signals, then uses an LLM to refine the choice between a single delegate and a
-workflow during execution. If that optional refinement is unavailable or
-unusable, automatic mode uses the deterministic decision.
-
-Use `--classify deterministic` to bypass the LLM refinement — this is the
-instant, no-dispatch preview. Use `--classify llm` when an LLM decision is
-required: the command fails if it cannot obtain a usable one. In automatic
-mode, `--dry-run` still performs that same bounded low-effort classification
-request (one analyze-lane, low-effort dispatch) and prints the resulting
-decision — it never dispatches the work itself. An explicit `--mode single` or
-`--mode workflow` is the caller's decision and bypasses automatic LLM
-classification.
-
 Discover and validate workflow definitions without executing them:
 
 ```bash
@@ -163,6 +157,44 @@ bullswarm strategy exclude-model claude-fable-5
 bullswarm run --effort high --lane analyze --task-file /tmp/task.md --json
 ```
 
+### Rungs
+
+A **rung** is one pool's model *plus its reasoning level* for one effort tier —
+the two halves you actually choose together. `bullswarm strategy rungs` reads
+them as one table and `bullswarm strategy set-rung` writes both halves in one
+atomic save:
+
+```bash
+bullswarm strategy rungs                      # every enabled pool x configured tier
+bullswarm strategy rungs --json --pool codex  # machine-readable, one pool
+bullswarm strategy set-rung codex high --model gpt-5.6-sol --reasoning xhigh
+```
+
+Each row carries the effective model and where it came from, the effective
+reasoning level and which layer chose it, the dated benchmark evidence for that
+model *at that reasoning level* (`blended`, `$/task`, `tok/task`), and what this
+machine recorded for that pool and tier (dispatch count, median wall minutes, ok
+share). Evidence and record are never estimated: a model the datapack does not
+cover prints `no evidence`, and a tier with no matching attempt prints `no
+dispatches`. `strategy inventory --json` carries the identical rows under
+`rungs`.
+
+Reading is free of side effects — no state write, no model discovery, no
+download. `set-rung` never spawns discovery either: a model absent from the
+pool's cached discovery exits 2 and lists the models it does know, unless you
+pass `--force`. A reasoning level the connector cannot express is clamped down
+to the strongest level it accepts and the clamp is printed. A rung is singular
+per pool and tier, so the tier moves off whichever model held it while that
+model keeps its other tiers. Nothing about `state.json` changed shape: rungs are
+a view over `strategy.modelTiers` and `strategy.reasoning`.
+
+The benchmark evidence comes from Epoch AI's benchmarking hub, used under
+CC BY 4.0: Epoch AI, 'AI Benchmarking Hub'. Published online at epoch.ai.
+Retrieved from <https://epoch.ai/benchmarks>. `blended` is the mean of the
+cursorbench, deepswe, arc-agi-2, and critpt scores recorded for that exact
+model and reasoning level; cost and tokens per task come from cursorbench. See
+[data/README.md](data/README.md) for the schema and the refresh job.
+
 Setup first asks whether to analyze live usage and recommend routes or open the
 current configuration for manual editing. Analysis shows a spinner plus
 per-provider usage progress, then presents the proposed defaults before making
@@ -170,10 +202,13 @@ any routing change. Press `Y` to apply them or `N` to retain the current policy.
 The analysis selects at most one default model for each provider and effort
 tier. It uses OpenRouter's agentic, coding, and intelligence indices as quality
 signals and API-equivalent pricing as the budget signal. A repository-owned
-GitHub Actions job calls the authenticated OpenRouter APIs once per day and
-replaces a public, validated `openrouter-benchmarks.json` asset on the rolling
-`benchmark-data-latest` GitHub Release. Installed CLIs download only that public
-file and never need or receive an OpenRouter key.
+GitHub Actions job (`.github/workflows/refresh-benchmarks.yml`) refreshes two
+public assets on the rolling `benchmark-data-latest` GitHub Release:
+`openrouter-benchmarks.json` from the authenticated OpenRouter APIs, and
+`epoch-benchmarks.json` from Epoch AI's CC BY 4.0 benchmark export, which is
+what `strategy rungs` reads for per-model-per-reasoning-level evidence.
+Installed CLIs download only those public files and never need or receive an
+OpenRouter key.
 The sources are OpenRouter's [benchmarks API](https://openrouter.ai/docs/api/api-reference/benchmarks/list-benchmarks)
 and [models API](https://openrouter.ai/docs/api/api-reference/models/list-all-models-and-their-properties).
 The CLI caches the datapack under `~/.bullswarm/cache/`; network failure falls
@@ -348,6 +383,42 @@ adversarial acceptance judgment. Merely being an analysis/evidence action or
 part of a difficult goal never promotes an action to high. The selected effort
 then resolves through the High/Medium/Low routes configured by `bullswarm setup`.
 
+### Kinds
+
+Stating lane and effort separately on every action means re-deciding two
+fields for work whose nature already implies both. The optional `kind` field
+names that nature once and derives them:
+
+| `kind` | lane | effort |
+| --- | --- | --- |
+| `mechanical` | chore | low |
+| `io-read` | analyze | low |
+| `check` | analyze | medium |
+| `implement` | build | medium |
+| `integration` | build | high |
+| `architecture` | analyze | high |
+| `adversarial-acceptance` | analyze | high |
+
+Resolution is per field: an explicit `lane` or `effort` on the action wins,
+then the kind table, then an optional program-level `defaults` object — which
+may set only `effort` and `reasoning`, because lane follows the individual
+action — then the per-lane default table. A `kind` outside that closed list is
+a validation error, not a runtime failure: it is a typo in your program, so
+`workflow plan validate` exits 2 and nothing launches. A program that uses
+neither `kind` nor `defaults` and states `lane` and `effort` on every action
+validates and runs exactly as before; the one widening is that `effort` is now
+optional and falls back to the per-lane default instead of being rejected.
+
+Two advisories report effort smells without ever rejecting anything.
+`all-writers-high` fires when three or more `build`/`chore` actions run and
+none is below high effort; `docs-at-high` fires when a `build`/`chore` action
+owns only `*.md` files at high effort. `workflow plan validate` includes them
+as `advisories` in `--json` and prints `advisory:` lines otherwise, `workflow
+goal` prints the same lines at launch, and both keep their exit codes. The
+kernel stores them on the run, so `workflow runs show` lists them afterwards,
+and `runs result`, `runs show`, and `workflow action show` print `kind` next to
+lane and effort.
+
 Reasoning depth is a third, independent decision. An action may carry an
 optional `reasoning` field — `low`, `medium`, `high`, `xhigh`, `max`, or
 `default` — that sets how hard the picked model thinks on that one action and

package/connectors/codex.json

@@ -117,7 +117,7 @@
     "flag": "--model",
     "mode": "replace-or-append"
   },
-  "$comment-reasoning": "Codex has no reasoning flag; the control is the config key `model_reasoning_effort`, overridden per invocation with the escape hatch verified from `codex exec --help` (codex-cli 0.153.4): `-c, --config <key=value>  Override a configuration value that would otherwise be loaded from ~/.codex/config.toml`. Accepted values verified from the official Codex config reference (https://learn.chatgpt.com/docs/config-file/config-reference, read 2026-09-09): `minimal | low | medium | high | xhigh` — \"Adjust reasoning effort for supported models (Responses API only; xhigh is model-dependent)\". `minimal` sits below bullswarm's common scale, so a request below `low` clamps up to `low`. Tier defaults stay at high/medium/low because `xhigh` is model-dependent; an explicit `xhigh` request passes through. Without this block Codex workers think at whatever config.toml sets (this machine: low).",
+  "$comment-reasoning": "verified 2026-09-09 against codex-cli 0.153.4: `codex exec -c model_reasoning_effort=max --model gpt-5.6-luna` ran (exit 0), printed `reasoning effort: max`, and the session rollout recorded reasoning_effort \"max\"; the public config reference still lists only minimal|low|medium|high|xhigh. `minimal` is accepted by the CLI but sits below bullswarm's ladder and is not declared.",
   "reasoning": {
     "args": [
       "-c",
@@ -127,7 +127,8 @@
       "low",
       "medium",
       "high",
-      "xhigh"
+      "xhigh",
+      "max"
     ],
     "defaults": {
       "high": "high",

package/connectors/command-code.json

@@ -28,18 +28,97 @@
   },
   "eventStream": {
     "format": "jsonl",
-    "args": ["--output-format", "json"],
-    "modelPaths": ["event.model", "model"],
+    "args": [
+      "--output-format",
+      "json"
+    ],
+    "modelPaths": [
+      "event.model",
+      "model"
+    ],
     "silenceThresholdSec": 600,
     "rules": [
-      { "rootMatch": { "path": "event.type", "equals": "tool_queued" }, "idPaths": ["event.toolCallId"], "kindPaths": ["event.toolName"], "summaryPaths": ["event.input.command", "event.input.file_path", "event.input.path"], "status": "queued" },
-      { "rootMatch": { "path": "event.type", "equals": "tool_running" }, "idPaths": ["event.toolCallId"], "kindPaths": ["event.toolName"], "summaryPaths": ["event.description"], "status": "running" },
-      { "rootMatch": { "path": "event.type", "equals": "tool_completed" }, "idPaths": ["event.toolCallId"], "kindPaths": ["event.toolName"], "status": "completed" },
-      { "rootMatch": { "path": "event.type", "equals": "message_end" }, "forEach": "event.content", "match": { "path": "type", "equals": "text" }, "kind": "response", "summaryPaths": ["text"], "status": "completed" }
+      {
+        "rootMatch": {
+          "path": "event.type",
+          "equals": "tool_queued"
+        },
+        "idPaths": [
+          "event.toolCallId"
+        ],
+        "kindPaths": [
+          "event.toolName"
+        ],
+        "summaryPaths": [
+          "event.input.command",
+          "event.input.file_path",
+          "event.input.path"
+        ],
+        "status": "queued"
+      },
+      {
+        "rootMatch": {
+          "path": "event.type",
+          "equals": "tool_running"
+        },
+        "idPaths": [
+          "event.toolCallId"
+        ],
+        "kindPaths": [
+          "event.toolName"
+        ],
+        "summaryPaths": [
+          "event.description"
+        ],
+        "status": "running"
+      },
+      {
+        "rootMatch": {
+          "path": "event.type",
+          "equals": "tool_completed"
+        },
+        "idPaths": [
+          "event.toolCallId"
+        ],
+        "kindPaths": [
+          "event.toolName"
+        ],
+        "status": "completed"
+      },
+      {
+        "rootMatch": {
+          "path": "event.type",
+          "equals": "message_end"
+        },
+        "forEach": "event.content",
+        "match": {
+          "path": "type",
+          "equals": "text"
+        },
+        "kind": "response",
+        "summaryPaths": [
+          "text"
+        ],
+        "status": "completed"
+      }
     ],
     "output": [
-      { "match": { "path": "type", "equals": "result" }, "path": "finalText", "mode": "last" },
-      { "match": { "path": "event.type", "equals": "run_end" }, "path": "event.result.finalText", "mode": "last" }
+      {
+        "match": {
+          "path": "type",
+          "equals": "result"
+        },
+        "path": "finalText",
+        "mode": "last"
+      },
+      {
+        "match": {
+          "path": "event.type",
+          "equals": "run_end"
+        },
+        "path": "event.result.finalText",
+        "mode": "last"
+      }
     ]
   },
   "meter": {
@@ -52,30 +131,153 @@
     "build",
     "chore"
   ],
-  "capabilities": ["code-reading", "file-editing", "strong-analysis", "workflow-planning"],
-  "modelDiscovery": { "cmd": ["command-code", "--list-models"], "parse": "columns", "ignorePattern": "^(Available|Open Source$|Anthropic$|OpenAI$|Google$|Sakana$|Meta$|xAI$|Pass|cmd|Docs)", "timeoutMs": 20000, "maxModels": 150 },
-  "modelSelection": { "flag": "--model", "mode": "replace-or-append" },
-  "$comment-reasoning": "verified from `command-code --help` (1.44.0): `--effort <level>  Set reasoning effort for the session (e.g. low, medium, high) — depends on the model`. UNVERIFIED: the CLI says \"e.g.\" and \"depends on the model\", so the accepted set is neither closed nor uniform across this pool's many providers; low/medium/high is declared conservatively and a stronger request clamps down to high.",
+  "capabilities": [
+    "code-reading",
+    "file-editing",
+    "strong-analysis",
+    "workflow-planning"
+  ],
+  "modelDiscovery": {
+    "cmd": [
+      "command-code",
+      "--list-models"
+    ],
+    "parse": "columns",
+    "ignorePattern": "^(Available|Open Source$|Anthropic$|OpenAI$|Google$|Sakana$|Meta$|xAI$|Pass|cmd|Docs)",
+    "timeoutMs": 20000,
+    "maxModels": 150
+  },
+  "modelSelection": {
+    "flag": "--model",
+    "mode": "replace-or-append"
+  },
+  "$comment-reasoning": "verified 2026-09-09 against command-code 1.44.0: `--effort bogus` fails with `Unknown effort \"bogus\". Supported: low, medium, high, xhigh, max.`; `--effort max --model gpt-5.6-luna` printed `Reasoning effort set to max for GPT-5.6 Luna.` and the JSON model_request_end event carried effort \"max\". The help text still says `(e.g. low, medium, high) \u2014 depends on the model`.",
   "reasoning": {
     "flag": "--effort",
-    "levels": ["low", "medium", "high"],
-    "defaults": { "high": "high", "medium": "medium", "low": "low" }
+    "levels": [
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ],
+    "defaults": {
+      "high": "high",
+      "medium": "medium",
+      "low": "low"
+    }
   },
   "modelProfiles": [
-    { "match": "^meta/muse-spark-1\\.3-contributor$", "tier": "high", "qualityRank": 5, "pricing": { "inputUsdPerMillion": 0.1, "cacheReadUsdPerMillion": 0.002, "outputUsdPerMillion": 0.2 }, "pricingSource": "https://commandcode.ai/docs/resources/pricing-limits", "pricingUpdatedAt": "2026-09-03" },
-    { "match": "^meta/muse-spark-", "tier": "high", "qualityRank": 5, "pricing": { "inputUsdPerMillion": 1.25, "cacheReadUsdPerMillion": 0.15, "outputUsdPerMillion": 4.25 }, "pricingSource": "https://commandcode.ai/docs/resources/pricing-limits", "pricingUpdatedAt": "2026-09-03" },
-    { "match": "^gpt-5\\.6-sol$", "tier": "high", "qualityRank": 6, "pricing": { "inputUsdPerMillion": 4, "cacheReadUsdPerMillion": 0.4, "outputUsdPerMillion": 20 }, "pricingSource": "https://help.openai.com/en/articles/20001415-chatgpt-rate-card-enterprise-token-based-pricing", "pricingUpdatedAt": "2026-08-27" },
-    { "match": "^gpt-5\\.6-terra$", "tier": "medium", "qualityRank": 4, "pricing": { "inputUsdPerMillion": 2, "cacheReadUsdPerMillion": 0.2, "outputUsdPerMillion": 12 }, "pricingSource": "https://developers.openai.com/api/docs/models/gpt-5.6-terra", "pricingUpdatedAt": "2026-08-27" },
-    { "match": "^gpt-5\\.6-luna$", "tier": "low", "qualityRank": 3, "pricing": { "inputUsdPerMillion": 0.2, "cacheReadUsdPerMillion": 0.02, "outputUsdPerMillion": 1.2 }, "pricingSource": "https://developers.openai.com/api/docs/models", "pricingUpdatedAt": "2026-08-27" },
-    { "match": "(?:^|/)claude-fable-", "tier": "high", "qualityRank": 6, "autoRecommend": false, "pricing": { "inputUsdPerMillion": 10, "cacheReadUsdPerMillion": 1, "outputUsdPerMillion": 50 }, "pricingSource": "https://platform.claude.com/docs/en/about-claude/pricing", "pricingUpdatedAt": "2026-08-27" },
-    { "match": "^claude-opus-", "tier": "high", "qualityRank": 5 },
-    { "match": "^claude-sonnet-", "tier": "medium", "qualityRank": 4 },
-    { "match": "^claude-haiku-", "tier": "low", "qualityRank": 3 },
-    { "match": "(?:flash|(?:^|[/.-])mini(?:$|[/.-])|luna|free)", "tier": "low", "qualityRank": 2 },
-    { "match": "(?:terra|sonnet|grok-4\\.5|gpt-5\\.4$)", "tier": "medium", "qualityRank": 4 },
-    { "match": "(?:fable|opus|sol|grok-4\\.6|minimax-m3)", "tier": "high", "qualityRank": 5 }
+    {
+      "match": "^meta/muse-spark-1\\.3-contributor$",
+      "tier": "high",
+      "qualityRank": 5,
+      "pricing": {
+        "inputUsdPerMillion": 0.1,
+        "cacheReadUsdPerMillion": 0.002,
+        "outputUsdPerMillion": 0.2
+      },
+      "pricingSource": "https://commandcode.ai/docs/resources/pricing-limits",
+      "pricingUpdatedAt": "2026-09-03"
+    },
+    {
+      "match": "^meta/muse-spark-",
+      "tier": "high",
+      "qualityRank": 5,
+      "pricing": {
+        "inputUsdPerMillion": 1.25,
+        "cacheReadUsdPerMillion": 0.15,
+        "outputUsdPerMillion": 4.25
+      },
+      "pricingSource": "https://commandcode.ai/docs/resources/pricing-limits",
+      "pricingUpdatedAt": "2026-09-03"
+    },
+    {
+      "match": "^gpt-5\\.6-sol$",
+      "tier": "high",
+      "qualityRank": 6,
+      "pricing": {
+        "inputUsdPerMillion": 4,
+        "cacheReadUsdPerMillion": 0.4,
+        "outputUsdPerMillion": 20
+      },
+      "pricingSource": "https://help.openai.com/en/articles/20001415-chatgpt-rate-card-enterprise-token-based-pricing",
+      "pricingUpdatedAt": "2026-08-27"
+    },
+    {
+      "match": "^gpt-5\\.6-terra$",
+      "tier": "medium",
+      "qualityRank": 4,
+      "pricing": {
+        "inputUsdPerMillion": 2,
+        "cacheReadUsdPerMillion": 0.2,
+        "outputUsdPerMillion": 12
+      },
+      "pricingSource": "https://developers.openai.com/api/docs/models/gpt-5.6-terra",
+      "pricingUpdatedAt": "2026-08-27"
+    },
+    {
+      "match": "^gpt-5\\.6-luna$",
+      "tier": "low",
+      "qualityRank": 3,
+      "pricing": {
+        "inputUsdPerMillion": 0.2,
+        "cacheReadUsdPerMillion": 0.02,
+        "outputUsdPerMillion": 1.2
+      },
+      "pricingSource": "https://developers.openai.com/api/docs/models",
+      "pricingUpdatedAt": "2026-08-27"
+    },
+    {
+      "match": "(?:^|/)claude-fable-",
+      "tier": "high",
+      "qualityRank": 6,
+      "autoRecommend": false,
+      "pricing": {
+        "inputUsdPerMillion": 10,
+        "cacheReadUsdPerMillion": 1,
+        "outputUsdPerMillion": 50
+      },
+      "pricingSource": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "pricingUpdatedAt": "2026-08-27"
+    },
+    {
+      "match": "^claude-opus-",
+      "tier": "high",
+      "qualityRank": 5
+    },
+    {
+      "match": "^claude-sonnet-",
+      "tier": "medium",
+      "qualityRank": 4
+    },
+    {
+      "match": "^claude-haiku-",
+      "tier": "low",
+      "qualityRank": 3
+    },
+    {
+      "match": "(?:flash|(?:^|[/.-])mini(?:$|[/.-])|luna|free)",
+      "tier": "low",
+      "qualityRank": 2
+    },
+    {
+      "match": "(?:terra|sonnet|grok-4\\.5|gpt-5\\.4$)",
+      "tier": "medium",
+      "qualityRank": 4
+    },
+    {
+      "match": "(?:fable|opus|sol|grok-4\\.6|minimax-m3)",
+      "tier": "high",
+      "qualityRank": 5
+    }
   ],
-  "subscription": { "plan": null, "monthlyPriceUsd": null, "includedValueUsd": null, "quotaWindow": "monthly" },
+  "subscription": {
+    "plan": null,
+    "monthlyPriceUsd": null,
+    "includedValueUsd": null,
+    "quotaWindow": "monthly"
+  },
   "flags": {
     "stealth": false
   },