bullswarm 0.25.3 → 0.25.5

package/CHANGELOG.md

@@ -1,5 +1,134 @@
 # bullswarm changelog
 
+## 0.25.5 — forecast-aware routing
+
+- Bullswarm now knows what it is already running. Every dispatch registers the
+  work it starts in a small ledger on disk (`~/.bullswarm/assignments/`, one
+  atomically written file per assignment), and every process reads it: a
+  `bullswarm run` in one terminal, a V1 runtime and four concurrent V2 kernel
+  actions all see each other's agents instead of each assuming the pool is
+  idle. Records whose process is gone, or that are older than 12 hours, are
+  pruned on read, so a crash cannot leave phantom load behind. `bullswarm
+  assignments` lists what is in flight right now — pool, run, action, how long
+  it has been going and how much longer it is expected to take — and
+  `bullswarm pools` carries the same count as `inflight=<n>`.
+
+- A spend model turns those records into percentage points. It measures how
+  fast a pool actually burns its 5-hour and weekly windows by pairing meter
+  readings with the worker-minutes dispatched between them, and how long an
+  assignment on a given lane and effort tier usually runs by taking the median
+  of real attempts from the decision log. Every number carries its basis —
+  `history` (measured), `bootstrap` (one window's usage so far), or the
+  documented `default` table — and the sample count behind it. A pool nobody
+  has measured reports `null`, never a plausible-looking guess.
+
+- Routing now decides on the forecast instead of on the last reading. Each
+  pool's projection (reading + what its in-flight agents will still spend) gets
+  the expected consumption of the assignment being routed added on top, and the
+  existing thresholds apply to that number: a pool projected at or above 75% of
+  its 5-hour window drops to the near-limit tier while its reading is still
+  below the line, and one projected at or above 90% is dropped from selection
+  as forecast-gated. Nothing is gated on an unknown forecast, and if every
+  capable pool is gated, the least loaded of them is still picked — with the
+  reason saying exactly that — rather than the action being stranded.
+
+- Parallel work now spreads instead of stacking. Within a tier, a pool's pace
+  surplus is reduced by the weekly quota its in-flight agents and this
+  assignment are expected to spend, and by at least a flat 3 surplus points
+  per in-flight agent (`DEFAULT_INFLIGHT_PENALTY_PCT`, `config.inflightPenaltyPct`
+  in state.json, `0` disables it). The floor matters: at measured weekly rates
+  a six-minute agent projects to under one point, which would leave a burst on
+  one pool. The charge is labeled `penalty` when the floor set it and by its
+  measured basis otherwise. Load also beats incumbency: an incumbent carrying
+  more in-flight agents than a challenger keeps neither its margin nor its cost
+  guard. Four actions launched within the same second land on
+  four different providers rather than all on the single most-behind one, and
+  the V2 kernel re-reads the ledger before every pick rather than only on its
+  throttled meter refresh, so actions launched seconds apart still see each
+  other.
+
+- Everything that observes routing shows the new numbers. `bullswarm
+  assignments [--json]` is a new command listing the live ledger; `bullswarm
+  pools` gained an `inflight=<n>` column and prints its 5-hour cell as
+  `5h=<reading>%-><projected>%` when in-flight work is expected to move it,
+  with `spend`, `projectedFiveHourPct` and `projectedWeeklyPct` in `--json`;
+  `bullswarm run --dry-run` prints the forecast the pick was made on and, being
+  a preview, still registers nothing and writes no decision log; and the
+  strategy control center shows each provider's in-flight count next to its
+  usage. Live meter readings are now retained as a capped per-pool series at
+  `~/.bullswarm/meters/history/<pool>.jsonl`, because the snapshot cache keeps
+  only the newest reading and a rate needs two.
+
+- A rate is only reported once the dispatch behind it is real: at least five
+  worker-minutes must be attributable to a window before its utilization
+  counts as percentage-points-per-minute. Without that floor a pool at 26% of
+  its 5-hour window with one six-second-old agent measures as 260% per minute
+  and forecasts every provider past the burst line, which is the failure this
+  model exists to prevent rather than cause.
+
+- All of it is visible after the fact. The routing reason names the in-flight
+  counts and projections that moved the pick (`5h used 30% -> 41% projected, 2
+  in flight`, `skipped near 5h limit (projected): wati 76%`, `forecast-gated
+  at/above 90%: …`, `preferred over busier: …`), every candidate row carries
+  `pace`, `effectiveSurplus`, `inflight`, `projectedFiveHourPct`,
+  `forecastFiveHourPct`, `projectedWeeklyPct`, `ratePerMinute`,
+  `estimateSource` and `forecastGated`, and the decision log records the
+  forecast the pick was made on. Pools that carry no ledger or spend fields
+  route exactly as they did before.
+
+## 0.25.4 — reasoning levels
+
+- A connector now declares how its own CLI expresses a thinking level, and
+  every dispatch resolves exactly one level per attempt. The block is
+  `reasoning: { flag | args, levels, defaults, skipModels? }` — `flag` for a
+  CLI that takes `--effort <level>`, `args` for one whose control is a config
+  override (`-c model_reasoning_effort={level}`). The packaged `claude-code`,
+  `codex`, `grok`, and `command-code` templates carry the block read from
+  their installed CLIs or an official source (Claude Code and Command Code from
+  `--help`, Codex from its config reference, Grok from the binary's own
+  validation message); Command Code's model-dependent set stays marked
+  UNVERIFIED rather than invented. One shared resolver applies the precedence
+  chain — the action's own `reasoning` field, the run-wide override, the
+  configured `strategy.reasoning` level for that pool and tier, the same for
+  the tier globally, then the connector's default for the effort tier — so
+  the first layer that sets a level wins, not the strongest. The level is
+  appended to the spawned command exactly as `--model` is appended today;
+  nothing is appended for a connector with no block, for the literal level
+  `default`, or for a model the connector marks under `skipModels`. A level
+  the connector does not accept is clamped to the nearest one it does, never
+  dropped and never invented. `{ requested, applied, source, clamped }` is
+  recorded on every attempt, in the decision log, in `bullswarm run --json`,
+  in the V2 result envelope, and in the new `bullswarm run --dry-run` command
+  preview — which builds its argv through the same builder that spawns, so
+  preview and dispatch cannot drift.
+
+- `bullswarm setup` asks one reasoning level per effort tier (suggesting
+  high=xhigh, medium=high, low=medium, with `default` always offered to leave
+  a worker CLI's own setting untouched) and stores the answers under
+  `state.strategy.reasoning`. Agents configure the same thing without a
+  terminal: `bullswarm strategy set-reasoning --tier <high|medium|low> --level
+  <low|medium|high|xhigh|max|default> [--pool <name>] --yes`, `bullswarm
+  strategy reset-reasoning [--tier ..] [--pool ..] --yes`, and a `reasoning`
+  section in `strategy configure --file <json> --yes` whose invalidity rejects
+  the whole document. `bullswarm strategy inventory --json` reports the
+  configured levels and, through the resolver dispatch itself uses, the
+  effective level and its source for every pool and tier. Installed home
+  connectors receive the packaged `reasoning` block additively on upgrade, and
+  a block the user has customized is never overwritten.
+
+- A V2 program action accepts an optional `reasoning` field
+  (`low|medium|high|xhigh|max|default`) that the calling agent or the
+  Workflow Planner can set and that outranks every configured level for that
+  one action; `workflow plan contract` documents the field and echoes the
+  run-wide levels a launch would apply. `workflow goal` takes
+  `--worker-reasoning <level>` for every non-planner dispatch and
+  `--planner-reasoning <level>` for a dispatched Workflow Planner, and
+  `bullswarm run` takes `--reasoning <level>`; a level off the scale is a
+  usage error that launches nothing. The applied level appears next to the
+  model in `workflow runs show` (text and `--json`), `workflow runs result
+  --json`, the TUI attempt rows and agent pane, so a run that thought more
+  cheaply than asked is visible rather than inferred.
+
 ## 0.25.3 — usage-limit recovery and headroom-aware routing
 
 - A provider that reports a usage limit is now its own mechanical failure kind,

package/README.md

@@ -149,6 +149,9 @@ bullswarm strategy set-model opencode2 kaihk/gpt-5.6-luna \
   --tiers high,medium,low --yes
 bullswarm strategy configure --file strategy.json --yes  # atomic agent-authored policy
 bullswarm strategy reset-tier low --yes     # restore one tier to automatic
+bullswarm strategy set-reasoning --tier high --level xhigh --yes
+bullswarm strategy set-reasoning --tier high --level high --pool codex --yes
+bullswarm strategy reset-reasoning --tier high --yes  # back to connector defaults
 bullswarm strategy refresh
 bullswarm strategy show --json
 bullswarm strategy apply --yes --refresh-hours 24
@@ -224,6 +227,49 @@ name the utilization that decided the pick, and meters and quarantines are
 re-read before each dispatch — and again, live, right after a usage limit —
 so a long run never routes off the snapshot it launched with.
 
+Those thresholds are applied to the FORECAST, not to the last reading. A meter
+reading is already old when it arrives: agents dispatched seconds ago have
+spent quota the provider has not reported yet, and the assignment being routed
+will spend more. So each pool's projection — its reading plus the quota its
+in-flight agents are still expected to burn — gets this candidate's own
+expected consumption added, and the tiers apply to that number: a pool
+projected at or above 75% drops to the near-limit tier even while its reading
+is lower, and one projected at or above `BURST_BLOCK_PCT` (90) is left out of
+selection entirely as forecast-gated. If every capable pool is forecast-gated,
+routing still names the least loaded of them rather than stranding the action,
+and says so in the reason. A pool with no measured rate forecasts nothing and
+is never gated or deprioritized for a number nobody produced.
+
+Within a tier, pools already carrying work yield to quieter pools of similar
+pace: each pool's surplus is reduced by the weekly quota its in-flight agents
+and this assignment are expected to spend, and by at least a flat 3 surplus
+points per in-flight agent. That floor is what spreads work at real rates,
+where a six-minute agent projects to well under one point; the charge is
+labeled `penalty` when the floor set it and carries its measured basis
+(`history`, `bootstrap`) when the projection was larger. Load also beats
+incumbency: an incumbent carrying more in-flight agents than a challenger keeps
+neither its 10-point margin nor its cost protection, so the quieter pool wins
+as soon as its effective surplus is higher. A burst of parallel actions
+therefore spreads across providers instead of stacking on the single
+most-behind one.
+`bullswarm pools` shows each pool's `inflight=<n>` count and its 5-hour column
+as `5h=<reading>%-><projected>%` whenever in-flight work is expected to move
+it, `bullswarm assignments` lists what those agents are, `bullswarm run
+--dry-run` prints the forecast the pick was made on without registering
+anything, and every candidate row carries `pace`, `effectiveSurplus`,
+`inflight`, `projectedFiveHourPct`, `forecastFiveHourPct`, `ratePerMinute`,
+`estimateSource` and `forecastGated`, so a surprising pick can be read back
+number by number.
+
+The rates come from real records: every live meter reading is retained as a
+capped per-pool series (`~/.bullswarm/meters/history/<pool>.jsonl`) and paired
+with the worker-minutes dispatched between readings. Until at least five
+worker-minutes of dispatch are attributable to a window there is no rate at
+all — `null`, not a ratio of percentage points to seconds — so a fresh machine
+routes on pace and the flat penalty until it has measured something. The
+penalty itself is `config.inflightPenaltyPct` in `~/.bullswarm/state.json`
+(default 3; `0` turns the tie-breaker off).
+
 Model exclusions are hard routing policy. An excluded model is removed from
 recommendations and assignments, and Bullswarm pins a same-tier allowed model
 through the connector-owned model flag whenever the provider default could be
@@ -302,6 +348,16 @@ 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`.
 
+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
+outranks every configured level for it. `default` passes nothing and lets the
+worker CLI's own setting decide. Omitting the field keeps the configured level.
+It never changes the pool, model, or effort tier, so a `low`-effort mechanical
+step can still be given `xhigh` thinking and a `high`-effort action can be told
+to think cheaply. A connector that does not accept the requested level gets the
+nearest level it supports.
+
 The planner does not author phases or declare success/failure. The kernel
 derives stable presentation stages for the TUI and computes the final V2
 result. Saved V2 runs retain their original execution and workspace policy on
@@ -352,6 +408,30 @@ The worker lock covers scout, work actions, and evidence actions. A pool that ca
 the requested model is ineligible rather than silently substituting another
 model.
 
+Reasoning depth can be pinned for a whole run the same way, without touching
+global strategy:
+
+```bash
+bullswarm workflow goal "Implement and verify the change" --cwd . \
+  --program plan.json --worker-reasoning high --json
+bullswarm run --lane build --reasoning xhigh --prompt '<task>' --json
+```
+
+`--worker-reasoning` covers scout, work actions, and evidence actions;
+`--planner-reasoning` covers a dispatched Workflow Planner and applies only
+with `--orchestrator`. Exactly one level is resolved per attempt, and the
+first layer that sets one wins — not the strongest: the action's own
+`reasoning` field, then the run-wide flag (`--worker-reasoning`,
+`--planner-reasoning`, `bullswarm run --reasoning`), then the configured
+`strategy.reasoning` level for that pool and tier, then the same for the tier
+globally, then the connector's own default for the effort tier, and otherwise
+nothing is appended. So an action asking for `low` beats a run-wide `max`.
+`default` at any layer stops there and passes nothing, letting the worker
+CLI's own setting decide; a connector with no `reasoning` block, or a model it
+marks as skipped, never receives a flag. The applied level is recorded on
+every attempt with the layer that set it and displayed next to the model, so a
+run that thought more cheaply than requested is visible rather than inferred.
+
 The `opencode2` connector itself does not require a KaiHK provider: its base
 spawn command carries no hardcoded model, so a plain OpenCode installation
 dispatches with OpenCode's own configured default. When
@@ -656,8 +736,9 @@ while working. Process exit, a fatal auth/quota signature, explicit operator
 cancellation, or an opt-in timeout remain the terminal signals.
 
 Each attempt records the phase/action, selected pool and model, effort tier,
-routing reason, all eligible candidates with quota surplus, timestamps,
-artifact paths, outcome, and reported-or-estimated token/cost/quota usage.
+the applied reasoning level with the layer that set it, routing reason, all
+eligible candidates with quota surplus, timestamps, artifact paths, outcome,
+and reported-or-estimated token/cost/quota usage.
 `workflow tui <id>` renders this breakdown for completed runs as well as live
 ones; `workflow tui --json <id>` exposes the durable audit document.
 When a provider event stream reports the actual model, Bullswarm records that

package/connectors/_schema.json

@@ -74,6 +74,19 @@
     "free": false
   }],
   "modelSelection": {"flag": "--model", "mode": "replace-or-append"},
+  "reasoning": {
+    "$comment": "Optional. How THIS CLI expresses a thinking level. Omit the block entirely when the CLI has no such control: core then appends nothing and reports source 'unsupported'. Declare exactly one of flag/args.",
+    "flag": "--effort",
+    "args": ["-c", "model_reasoning_effort={level}"],
+    "$comment-form": "flag: appended as `<flag> <level>` with replace-or-append semantics, so a level already pinned in spawn.cmd is replaced rather than duplicated. args: appended verbatim with {level} substituted, for CLIs whose control is a config override rather than a flag.",
+    "levels": ["low", "medium", "high", "xhigh", "max"],
+    "$comment-levels": "the subset of the common scale (low, medium, high, xhigh, max — weakest to strongest, src/lib/reasoning.js) that this CLI accepts, weakest first. A requested level outside the subset is clamped to the strongest supported level not above it, or to the weakest supported level when the request is below all of them, and the clamp is recorded.",
+    "defaults": {"high": "xhigh", "medium": "high", "low": "medium"},
+    "$comment-defaults": "the level to use for each effort tier when nothing else asked. Last layer of the precedence chain: action override > run override > strategy per-pool > strategy per-tier > THESE > nothing appended. The literal 'default' at any layer means 'append nothing, let the CLI's own configuration decide'.",
+    "skipModels": ["^model-id-regex-that-rejects-the-flag"],
+    "$comment-skipModels": "Optional connector-owned regexes. A selected model matching one gets no level appended (source 'skipped-model'), for CLIs whose flag is only valid on some models."
+  },
+  "$comment-reasoning": "Optional prose companion. Say which command's output the block was read from, and mark anything the CLI does not actually print as UNVERIFIED — never invent an accepted value.",
   "subscription": {"plan": null, "monthlyPriceUsd": null, "includedValueUsd": null, "quotaWindow": "weekly"},
   "flags": {
     "stealth": false,

package/connectors/claude-code.json

@@ -60,6 +60,13 @@
   "capabilities": ["strong-analysis", "code-reading", "file-editing", "workflow-planning"],
   "knownModels": ["claude-fable-5", "claude-opus-5", "claude-sonnet-5", "claude-haiku-4-5"],
   "modelSelection": { "flag": "--model", "mode": "replace-or-append" },
+  "$comment-reasoning": "verified from `claude --help` (Claude Code 2.1.263): `--effort <level>  Effort level for the current session (low, medium, high, xhigh, max)`. skipModels: `--help` does not state per-model support, so Haiku is excluded conservatively — re-verify before removing the exclusion. With no `reasoning` override anywhere, workers inherit whatever effortLevel the home settings.json sets.",
+  "reasoning": {
+    "flag": "--effort",
+    "levels": ["low", "medium", "high", "xhigh", "max"],
+    "defaults": { "high": "xhigh", "medium": "high", "low": "medium" },
+    "skipModels": ["^claude-haiku-"]
+  },
   "conversation": {
     "newArgs": ["--session-id", "{sessionId}"],
     "resumeArgs": ["--resume", "{sessionId}"]

package/connectors/codex.json

@@ -31,14 +31,61 @@
   },
   "eventStream": {
     "format": "jsonl",
-    "args": ["--json"],
+    "args": [
+      "--json"
+    ],
     "silenceThresholdSec": 600,
     "rules": [
-      { "rootMatch": { "path": "type", "equals": "item.started" }, "idPaths": ["item.id"], "kindPaths": ["item.type"], "kindMap": { "agent_message": "response" }, "summaryPaths": ["item.command", "item.text"], "status": "running" },
-      { "rootMatch": { "path": "type", "equals": "item.completed" }, "idPaths": ["item.id"], "kindPaths": ["item.type"], "kindMap": { "agent_message": "response" }, "summaryPaths": ["item.command", "item.text"], "status": "completed" }
+      {
+        "rootMatch": {
+          "path": "type",
+          "equals": "item.started"
+        },
+        "idPaths": [
+          "item.id"
+        ],
+        "kindPaths": [
+          "item.type"
+        ],
+        "kindMap": {
+          "agent_message": "response"
+        },
+        "summaryPaths": [
+          "item.command",
+          "item.text"
+        ],
+        "status": "running"
+      },
+      {
+        "rootMatch": {
+          "path": "type",
+          "equals": "item.completed"
+        },
+        "idPaths": [
+          "item.id"
+        ],
+        "kindPaths": [
+          "item.type"
+        ],
+        "kindMap": {
+          "agent_message": "response"
+        },
+        "summaryPaths": [
+          "item.command",
+          "item.text"
+        ],
+        "status": "completed"
+      }
     ],
     "output": [
-      { "match": { "path": "type", "equals": "item.completed" }, "path": "item.text", "mode": "last" }
+      {
+        "match": {
+          "path": "type",
+          "equals": "item.completed"
+        },
+        "path": "item.text",
+        "mode": "last"
+      }
     ]
   },
   "meter": {
@@ -51,18 +98,109 @@
     "build",
     "chore"
   ],
-  "capabilities": ["strong-analysis", "code-reading", "file-editing", "workflow-planning"],
-  "knownModels": ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex"],
-  "modelSelection": { "flag": "--model", "mode": "replace-or-append" },
+  "capabilities": [
+    "strong-analysis",
+    "code-reading",
+    "file-editing",
+    "workflow-planning"
+  ],
+  "knownModels": [
+    "gpt-5.6-sol",
+    "gpt-5.6-terra",
+    "gpt-5.6-luna",
+    "gpt-5.5",
+    "gpt-5.4",
+    "gpt-5.4-mini",
+    "gpt-5.3-codex"
+  ],
+  "modelSelection": {
+    "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).",
+  "reasoning": {
+    "args": [
+      "-c",
+      "model_reasoning_effort={level}"
+    ],
+    "levels": [
+      "low",
+      "medium",
+      "high",
+      "xhigh"
+    ],
+    "defaults": {
+      "high": "high",
+      "medium": "medium",
+      "low": "low"
+    }
+  },
   "modelProfiles": [
-    { "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\\.(5|4)$", "tier": "high", "qualityRank": 5 },
-    { "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\\.3-codex$", "tier": "medium", "qualityRank": 4, "pricing": { "inputUsdPerMillion": 1.75, "cacheReadUsdPerMillion": 0.175, "outputUsdPerMillion": 14 }, "pricingSource": "https://help.openai.com/en/articles/20001415-chatgpt-rate-card-enterprise-token-based-pricing", "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": "mini", "tier": "low", "qualityRank": 2 }
+    {
+      "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\\.(5|4)$",
+      "tier": "high",
+      "qualityRank": 5
+    },
+    {
+      "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\\.3-codex$",
+      "tier": "medium",
+      "qualityRank": 4,
+      "pricing": {
+        "inputUsdPerMillion": 1.75,
+        "cacheReadUsdPerMillion": 0.175,
+        "outputUsdPerMillion": 14
+      },
+      "pricingSource": "https://help.openai.com/en/articles/20001415-chatgpt-rate-card-enterprise-token-based-pricing",
+      "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": "mini",
+      "tier": "low",
+      "qualityRank": 2
+    }
   ],
-  "subscription": { "plan": null, "monthlyPriceUsd": null, "includedValueUsd": null, "quotaWindow": "weekly" },
+  "subscription": {
+    "plan": null,
+    "monthlyPriceUsd": null,
+    "includedValueUsd": null,
+    "quotaWindow": "weekly"
+  },
   "flags": {
     "stealth": false
   },

package/connectors/command-code.json

@@ -55,6 +55,12 @@
   "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.",
+  "reasoning": {
+    "flag": "--effort",
+    "levels": ["low", "medium", "high"],
+    "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" },