@open-agent-toolkit/cli 0.1.73 → 0.1.74

package/assets/config/dispatch-matrix-recommendation.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026-07-10.2",
+  "version": "2026-07-11.1",
   "providers": {
     "codex": {
       "economy": {
@@ -101,29 +101,25 @@
     "cursor": {
       "economy": {
         "candidates": [
-          "gpt-5.6-luna-low",
-          "gpt-5.6-luna-medium",
-          "gpt-5.6-luna-high"
+          "composer-2.5",
+          "claude-sonnet-5-high",
+          "gpt-5.6-luna-high",
+          "gpt-5.6-luna-xhigh"
         ]
       },
       "balanced": {
-        "candidates": [
-          "gpt-5.6-luna-xhigh",
-          "gpt-5.6-terra-low",
-          "gpt-5.6-terra-medium",
-          "gpt-5.6-terra-high",
-          "gpt-5.6-terra-xhigh"
-        ]
+        "candidates": ["cursor-grok-4.5-high", "gpt-5.6-terra-high"]
       },
       "high": {
-        "candidates": [
-          "gpt-5.6-sol-low",
-          "gpt-5.6-sol-medium",
-          "gpt-5.6-sol-high"
-        ]
+        "candidates": ["gpt-5.6-sol-medium", "gpt-5.6-sol-high"]
       },
       "frontier": {
-        "candidates": ["gpt-5.6-sol-xhigh", "gpt-5.6-sol-max"]
+        "candidates": [
+          "claude-fable-5-thinking-high",
+          "claude-fable-5-thinking-xhigh",
+          "gpt-5.6-sol-xhigh",
+          "gpt-5.6-sol-max"
+        ]
       }
     }
   }

package/assets/docs/cli-utilities/configuration.md

@@ -232,14 +232,15 @@ values. Planning shows the complete bundled recommendation before asking for
 this scope, then rechecks the effective ladder. If explicit cells still leave
 the ladder incomplete, readiness blocks; OAT does not overwrite them.
 
-Scope determines ownership and Codex materialization:
+Scope determines ownership and Codex/Cursor materialization:
 
 - `--shared` and `--local` are project configuration sources. Their configured
-  Codex candidates materialize into the tracked project `.codex` view.
+  Codex and Cursor candidates materialize into the tracked project `.codex`
+  and `.cursor` views.
 - `--user` writes reusable personal defaults to `~/.oat/config.json`; those
-  Codex candidates materialize under `~/.codex`.
-- Active-project sparse candidates also materialize into the tracked project
-  view.
+  candidates materialize under `~/.codex` and `~/.cursor`.
+- Active-project sparse candidates also materialize into the applicable tracked
+  project view.
 
 Project-generated provider views remain visible to version control. OAT does
 not auto-ignore them. A project-specific active policy or ceiling must not be
@@ -274,7 +275,7 @@ even when the reusable ladder is user-owned.
         },
         "cursor": {
           "balanced": {
-            "candidates": ["opaque:model/lower [v1]", "opaque:model/high [v2]"]
+            "candidates": ["cursor-grok-4.5-high", "gpt-5.6-terra-high"]
           }
         }
       }
@@ -285,9 +286,11 @@ even when the reusable ladder is user-owned.
 
 The bundled recommendation covers 13 Codex model/effort combinations: Luna and
 Terra at `low`, `medium`, `high`, and `xhigh`, plus Sol at those efforts and
-`max`. Claude covers `haiku`, `sonnet`, `opus`, and `fable`. Cursor covers 13
-opaque configured strings. Cursor spelling never supplies capability metadata;
-the configured candidate position owns the tier meaning.
+`max`. Claude covers `haiku`, `sonnet`, `opus`, and `fable`. Cursor covers 12
+verified multi-family flat IDs across Composer, Claude, GPT, and Grok. An
+explicit mapping connects each flat ladder ID to a separate bracket-form
+frontmatter model; configuration and skills never derive or normalize either
+form.
 
 The corresponding pinned Codex variant catalogue includes
 `gpt-5.6-luna-high`, `gpt-5.6-terra-xhigh`, `gpt-5.6-sol-high`, and
@@ -360,7 +363,7 @@ oat project dispatch-ceiling resolve \
   --provider cursor \
   --role implementer \
   --ceiling-tier high \
-  --candidate-model 'opaque:model/lower [v1]' \
+  --candidate-model gpt-5.6-sol-high \
   --json
 ```
 
@@ -381,11 +384,12 @@ remains compatibility behavior for legacy scalar ceilings and managed
 | -------- | ---------------------------------------------------------------------------------------------------- |
 | Codex    | `providers.codex.dispatchArgs.variant` as `agent_type`, or a fresh child pinned to model plus effort |
 | Claude   | `providers.claude.dispatchArgs.model` as the actual Agent `model`                                    |
-| Cursor   | `providers.cursor.dispatchArgs.model` byte-for-byte as the actual opaque invocation model            |
+| Cursor   | `providers.cursor.dispatchArgs.variant` as the exact native agent type first                         |
 
-Project sync materializes the supported Codex catalogue and every configured
-project-owned candidate for both `oat-phase-implementer` and `oat-reviewer`.
-User sync materializes user-owned candidates under `~/.codex`:
+Project sync materializes the supported Codex and Cursor catalogues and every
+configured project-owned candidate for both `oat-phase-implementer` and
+`oat-reviewer`. User sync materializes user-owned candidates under `~/.codex`
+and `~/.cursor/agents`:
 
 ```bash
 oat sync --scope project
@@ -394,60 +398,31 @@ oat sync --scope all
 ```
 
 Generated roles carry `supported-catalogue`, `project-config`, or `user-config`
-ownership. Cleanup reconciles only the current owner. Materialization is best
-effort at sync boundaries; the exact fresh-child route means workflow
-correctness does not require provider restart or hot reload.
+ownership. Cleanup reconciles only the current owner. Cursor's mapping registry
+rejects unknown flat IDs instead of writing unverified frontmatter.
 
 Reviewer resolution uses the final candidate at the configured review ceiling.
-Codex selects the exact reviewer variant; Claude and Cursor pass the resolver's
-exact model argument. Timeout retries preserve the same complete payload. A
-lower reviewer candidate requires a separate reviewed contract.
+Codex and Cursor select exact native reviewer variants; Claude passes the
+resolver's exact model argument. Timeout retries preserve the same complete
+payload. A lower reviewer candidate requires a separate reviewed contract.
 
 Tier 2 remains target-preserving. Inline review is permitted only when the host
 has verified equivalent current-host controls for explicit inherit,
 managed-uncapped, or base-role behavior. Capped managed reviews still require
 the exact registered role, pinned child, or resolver-returned model argument.
 
-### Cursor validation pass and live evidence
-
-Config adoption and doctor validate Cursor candidates with one command-scoped
-pass context. Duplicate references to the same byte-for-byte candidate share
-one Task/subagent probe. If a decisive probe is unavailable, the pass resolves
-the broad catalog once, with at most one `--list-models` fallback. The cache
-ends with that adopt or doctor command; it is not process-global and has no
-TTL.
-
-A correlated Task start/completion pair that preserves the exact model argument
-and returns the sentinel establishes that the argument is eligible for that
-account and client. A structured rejection or exact allow-list exclusion can
-establish `unknown-value`. Neither result identifies the backend runtime model:
-`runtimeIdentity` remains `not-reported` unless trusted Cursor telemetry or
-Cursor support confirms it. Parent prose and broad catalog presence are
-diagnostic-only, so OAT preserves `unvalidated` when launcher evidence is
-absent instead of inferring capability from candidate spelling.
-
-The [dated GPT-5.6 Cursor verification evidence](https://github.com/voxmedia/open-agent-toolkit/blob/main/.oat/repo/reference/project-summaries/20260711-cursor-gpt-5-6-subagent-verification.md)
-preserves the original text-mode pass and a versioned stream-JSON second pass.
-The second pass ran a dynamic positive control and deliberate invalid control
-before candidates. Both parent runs completed without a Task event, making the
-controls inconclusive; the stop rule therefore executed zero of the 13
-recommended candidates and did not execute exploratory
-`gpt-5.6-sol-high-fast`. The recommendation remains unchanged and candidate
-eligibility remains unresolved.
-
-The tracked artifact's structured second-pass block contains only allowlisted
-event structure, derived outcomes, sanitized auth-presence context, and
-non-reversible identifier hashes. Exact request/session/tool-call IDs and
-credential-redacted unprojected streams from that pass stay under gitignored
-`.oat/projects/local/` storage for possible Cursor support diagnosis.
-
-The same public artifact intentionally retains the sanitized historical v1
-text-mode record for provenance. That older section includes command arguments
-and prompts, stdout and stderr, exit and duration data, and capture-environment
-details such as user-specific binary paths; it is not limited to the structured
-second-pass allowlist. Re-run after a Cursor client rollout exposes Task in
-headless mode or Cursor support confirms the private requests; review the open
-verification item by 2026-08-08.
+### Cursor availability and evidence
+
+`oat doctor` compares configured Cursor flat IDs with the current Cursor
+catalogue and reports availability drift. This check is diagnostic: catalogue
+presence does not prove that a bracket-form definition pin was honored.
+
+Each shipped mapping has mapping-specific native-launch evidence, but Cursor
+can silently fallback when account, plan, or administration constraints prevent
+the requested pin. OAT therefore records the selected variant and mapped model
+with launcher-owned `configured` provenance. Runtime identity remains
+`not-reported` unless independently observed; self-report and catalogue
+availability do not upgrade that evidence.
 
 ### Legacy compatibility
 

package/assets/docs/cli-utilities/workflow-gates.md

@@ -94,6 +94,37 @@ model that ran, and the reviewer must not replace them with self-identification.
 The CLI compares the copied values with its gate-owned record before it applies
 the severity threshold.
 
+### Review producer identity
+
+Dynamic planning workflows can declare their current parent model to a review
+gate without writing a provider or model into shared/user config:
+
+```bash
+OAT_GATE_PRODUCER_IDENTITY='<model>:declared' oat gate review ...
+```
+
+This is a review-command-only bridge. `oat gate review` accepts it only when
+the value is non-empty and its provenance suffix is exactly `declared`. The
+gate removes the variable from the child reviewer's environment, and non-review
+commands such as `oat gate cross-provider-exec` ignore it.
+
+Producer evidence precedence is explicit `--producer-identity`, then a
+qualifying implementation dispatch stamp, then the review-only environment
+declaration, and finally unknown producer behavior. The environment bridge does
+not replace stronger explicit or stamped evidence and does not establish
+observed runtime identity.
+
+For final and contiguous-range reviews, each in-scope implementer/fix stamp
+contributes its claimable producer family. If that producer is not claimable or
+has an unknown family, the gate may infer only a family exclusion from the
+stamp's launcher-owned configured target. The target does not become producer
+runtime identity, and generic or unclassifiable targets contribute no family.
+
+Keep reusable gate commands producer-neutral in shared and user config.
+Planning skills attach the ephemeral declaration only while executing a
+resolved configured command that invokes `oat gate review`; they leave it
+absent for every other gate command.
+
 ### Headless completion safety
 
 Every `oat gate review` child receives the same headless contract through two
@@ -492,7 +523,9 @@ By default the dispatcher:
 4. Resolves producer identity from `--producer-identity` or dispatch stamps when
    available. Exact phase/task scopes use the matching stamp. `final` and
    contiguous ranges such as `p02-p03` aggregate every in-range implementer/fix
-   stamp.
+   stamp. A stamp whose producer is not claimable or has an unknown family may
+   contribute its classifiable configured target family to aggregate avoidance
+   at lower confidence.
 5. Applies `--avoid same-family`.
 6. Checks candidate availability in descending priority order, with target id as
    the tie-breaker.
@@ -537,7 +570,10 @@ single stamp or when no stamp has a claimable family. Their producer record uses
 an unknown representative instead of presenting the latest stamp as aggregate
 truth:
 
-- `avoidFamilies` is the stable deduplicated union of claimable known families.
+- `avoidFamilies` is the stable deduplicated union of claimable known producer
+  families plus classifiable configured target families from stamps whose
+  producer is not claimable or has an unknown family. A known, claimable
+  producer remains authoritative over a conflicting target.
 - `contributingScopes` is the stable document-order list of distinct scopes from
   every relevant stamp.
 - `contributingStampCount` counts every relevant stamp, including unknown or

package/assets/docs/provider-sync/providers.md

@@ -18,14 +18,11 @@ description: 'Provider-specific path mappings for Claude, Cursor, Copilot, Gemin
 
     - Project: `.agents/skills` -> `.cursor/skills`, `.agents/agents` -> `.cursor/agents`, `.agents/rules` -> `.cursor/rules`
     - User: `~/.agents/skills` -> `~/.cursor/skills`, `~/.agents/agents` -> `~/.cursor/agents`
-    - Subagent invocation in Cursor is prompt-driven (`/name` or natural mention), not `subagent_type`
-    - OAT-controlled Cursor dispatch uses the generic `.cursor/agents/<name>.md` file plus the exact `providers.cursor.dispatchArgs.model` value selected from the candidate ladder. OAT passes it byte-for-byte as the actual Task-level `model`; a `model` frontmatter value is only a default/fallback mechanism.
-    - Cursor model strings are opaque. OAT does not infer family, effort, cost, or capability from their spelling; the configured candidate position owns the named tier meaning.
-    - Cursor model validation checks whether the selected model is eligible for subagent Task dispatch. Each adopt/doctor command probes each distinct exact candidate once and shares one lazy broad-catalog lookup across that pass; the cache ends with the command.
-    - A correlated accepted Task carrying the exact model argument plus the child sentinel proves argument eligibility for that account/client. It does not prove backend runtime identity; that remains `not-reported` without trusted Cursor telemetry or support confirmation. Structured rejection can establish `unknown-value`, while parent prose and broad `cursor-agent models` catalog presence remain diagnostic-only.
-    - The [dated GPT-5.6 verification artifact](https://github.com/voxmedia/open-agent-toolkit/blob/main/.oat/repo/reference/project-summaries/20260711-cursor-gpt-5-6-subagent-verification.md) preserves the original probe and a stream-JSON control pass. The controls observed no Task events, so the stop rule ran zero recommendation or exploratory candidates and retained the recommendation unchanged.
-    - The artifact's structured second-pass block contains only allowlisted event fields, derived outcomes, sanitized auth presence, and identifier hashes. Exact request/session/tool-call IDs and credential-redacted unprojected streams from that pass remain in gitignored local project storage for support escalation.
-    - The same public artifact retains the sanitized historical v1 text-mode record for provenance. That older section includes command arguments and prompts, stdout and stderr, exit and duration data, and capture-environment details such as user-specific binary paths; it is not limited to the structured second-pass allowlist.
+    - Sync materializes pinned Markdown definitions for both `oat-phase-implementer` and `oat-reviewer`. Each generated name keeps the configured flat ladder ID, while an explicit verified mapping writes the separate bracket-form frontmatter model. OAT never derives one form from the other.
+    - Generated definitions carry `supported-catalogue`, `project-config`, or `user-config` ownership. Project and supported output lives in the tracked `.cursor/agents` view; user-owned output lives under `~/.cursor/agents`. Cleanup reconciles only the applicable owner.
+    - Managed dispatch requires `providers.cursor.dispatchArgs.variant` and launches that exact resolver-selected native agent type first. Skills do not pass a Task-level model argument or normalize Cursor model strings.
+    - Cursor may silently fallback when a definition pin cannot be honored. Variant acceptance therefore establishes launcher-owned `configured` provenance only; runtime identity remains `not-reported` unless independently observed.
+    - `oat doctor` checks whether each flat ID is still present in the current Cursor catalogue and reports availability drift. Catalogue availability is diagnostic and does not prove that a definition-level bracket pin ran as configured.
     - Rule files render as `.cursor/rules/*.mdc`
 
 === "Copilot"
@@ -81,9 +78,9 @@ oat config adopt dispatch-matrix --user
 ```
 
 Project-config candidates materialize into the tracked, version-controlled
-project `.codex` view. User-config candidates materialize under `~/.codex`.
-OAT does not auto-ignore project output or create its Git commit; the team owns
-that repository change.
+project `.codex` and `.cursor` views. User-config candidates materialize under
+`~/.codex` and `~/.cursor`. OAT does not auto-ignore project output or create
+its Git commit; the team owns that repository change.
 
 At implementation time, the root passes the recorded named maximum through
 invocation-only `--ceiling-tier`, resolves one exact candidate per phase, and
@@ -91,19 +88,20 @@ dispatches one phase implementer. Codex first attempts the resolver-returned
 materialized role as the native `agent_type`. The launcher records the target,
 model axis, and effort axis from that resolved payload; child self-report is not
 provenance and cannot replace those values.
-Only an explicit pre-start native role-selection rejection permits a fresh
-pinned-child fallback. An accepted child, including one that later returns
+Only an explicit pre-start native role-selection rejection permits another
+target-preserving route. An accepted child, including one that later returns
 `BLOCKED` or lacks telemetry, is a task outcome rather than a fallback signal.
-Claude and Cursor bind the exact model arguments described above. A missing or
-unselectable managed target blocks rather than falling back to the root target
-or a base role.
+Claude binds the exact model argument described above. Cursor launches the
+exact native variant. A missing or unselectable managed target blocks rather
+than falling back to the root target or a base role.
 
 ## Scope rules
 
 - Project scope: skills + agents + rules
-- User scope: skills, plus the two bundled managed Codex role definitions used only for user-owned target expansion (provider mappings vary by adapter)
+- User scope: skills, plus the two bundled managed Codex and Cursor role definitions used only for user-owned target expansion (provider mappings vary by adapter)
 - Rules are project-scoped only in this release
 - Codex user-scope sync materializes user-config custom roles under `~/.codex`; project-config and supported-catalogue output remains project-scoped and version controlled
+- Cursor user-scope sync materializes user-config variants under `~/.cursor/agents`; project-config and supported-catalogue output remains project-scoped and version controlled
 
 ## Adoption model
 

package/assets/docs/workflows/projects/artifacts.md

@@ -127,7 +127,7 @@ Each inner array is a group of phases that execute concurrently in their own wor
 - Each group must contain **2 or more** phases — singleton groups are rejected.
 - Every phase ID must exist in the plan body.
 - No phase may appear in more than one group.
-- Parallelism is only honored at Tier 1 (native subagents). Tier 2 degrades parallel groups to sequential target-preserving execution, not unconditional inline review. Concrete managed Claude and Cursor reviewers retain the exact resolver-returned `dispatchArgs.model` in the actual invocation and every retry; Codex retains its exact role or pinned child. Inline review requires verified equivalent host controls or an explicit inherit/default or managed-uncapped base-role exception, and otherwise blocks.
+- Parallelism is only honored at Tier 1 (native subagents). Tier 2 degrades parallel groups to sequential target-preserving execution, not unconditional inline review. Concrete managed Claude reviewers retain the exact resolver-returned `dispatchArgs.model`; Cursor reviewers retain the exact `providers.cursor.dispatchArgs.variant` native agent type; Codex retains its exact role or pinned child. Every retry preserves the complete target. Inline review requires verified equivalent host controls or an explicit inherit/default or managed-uncapped base-role exception, and otherwise blocks.
 
 **Authoring responsibility:**
 

package/assets/docs/workflows/projects/dispatch-ceiling.md

@@ -194,8 +194,10 @@ candidate in each tier:
   `max`.
 - **Claude:** `haiku`, `sonnet`, `opus`, and `fable` across the ordered named
   tiers.
-- **Cursor:** opaque strings corresponding to the same 13 configured positions.
-  OAT does not parse those strings to infer family, effort, cost, or capability.
+- **Cursor:** 12 verified multi-family flat IDs across Composer, Claude, GPT,
+  and Grok. The explicit materialization catalogue maps each flat ladder ID to
+  a separate bracket-form frontmatter model; OAT does not derive or normalize
+  either value.
 
 The final candidate in a named tier defines that tier's reviewer ceiling. Lower
 reviewer selection requires a separate reviewed contract; a normal reviewer
@@ -240,7 +242,7 @@ oat project dispatch-ceiling resolve \
   --provider cursor \
   --role implementer \
   --ceiling-tier high \
-  --candidate-model 'opaque:model/balanced [v2]' \
+  --candidate-model gpt-5.6-sol-high \
   --json
 ```
 
@@ -280,45 +282,39 @@ branch replaces, rather than supplements, preferred selection.
 | -------- | ---------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- |
 | Codex    | Use `providers.codex.dispatchArgs.variant` as `agent_type`; otherwise launch a fresh child pinned to the returned model and effort | Block if neither exact route is usable    |
 | Claude   | Pass `providers.claude.dispatchArgs.model` as the actual Task `model`                                                              | Block if the model cannot be applied      |
-| Cursor   | Pass `providers.cursor.dispatchArgs.model` byte-for-byte as the actual invocation model; treat it as opaque                        | Block rather than normalize or substitute |
+| Cursor   | Launch `providers.cursor.dispatchArgs.variant` as the exact native agent type first                                                | Block rather than normalize or substitute |
 | Other    | Use a registered provider adapter when it can compile exact controls                                                               | Unsupported providers remain advisory     |
 
-Materialized Codex roles exist before phase dispatch after project/user sync.
-The supported catalogue is committed project output; custom Codex candidates
-materialize according to config ownership. Workflow correctness still keeps a
-fresh pinned-child fallback and does not require provider restart or hot reload.
+Materialized Codex and Cursor roles exist before phase dispatch after
+project/user sync. Cursor definitions carry `supported-catalogue`,
+`project-config`, or `user-config` ownership. Project and supported variants
+are tracked under `.cursor/agents`; user variants live under
+`~/.cursor/agents`. Cleanup stays within the current owner boundary.
 
 Reviewers use the final candidate at the configured review ceiling. Managed
 `Uncapped` and explicit inherit/default behavior retain their documented base
 reviewer behavior. A timeout retry preserves the same exact role or complete
-Claude/Cursor model payload.
+Claude model payload or Cursor native variant.
 
 ### Cursor evidence authority
 
-Cursor resolution and runtime evidence answer different questions. Resolution
-proves which opaque candidate OAT requested. A stream-JSON Task start and
-correlated completion prove launcher behavior only when the model argument is
-preserved byte-for-byte. An accepted Task plus the child sentinel establishes
-argument eligibility for that account and client; a structured rejection can
-establish `unknown-value`. Runtime producer identity remains `not-reported`
-unless trusted Cursor telemetry or Cursor support independently confirms it.
-
-The [2026-07-11 GPT-5.6 evidence record](https://github.com/voxmedia/open-agent-toolkit/blob/main/.oat/repo/reference/project-summaries/20260711-cursor-gpt-5-6-subagent-verification.md)
-ran positive and negative controls before candidate probes. Neither control
-emitted a Task event, so the harness stopped without probing the 13 recommended
-arguments or exploratory `gpt-5.6-sol-high-fast`. This is a harness/account
-boundary, not model rejection, and it supports no recommendation change.
-
-The tracked artifact's structured second-pass block exposes only an allowlisted
-event projection and non-reversible identifier hashes. Exact
-request/session/tool-call IDs and credential-redacted unprojected streams from
-that pass stay in gitignored local project storage for support diagnosis.
-
-The same public artifact intentionally preserves the sanitized historical v1
-text-mode record for provenance. That older section includes command arguments
-and prompts, stdout and stderr, exit and duration data, and capture-environment
-details such as user-specific binary paths; it is not limited to the structured
-second-pass projection.
+Cursor selection, pin mapping, catalogue availability, and runtime identity are
+separate evidence layers:
+
+- The candidate ladder and resolver use an opaque flat ID.
+- The materialized definition uses the mapping's explicit bracket-form
+  frontmatter model.
+- Mapping-specific native-launch evidence authorizes the shipped mapping data.
+- `oat doctor` checks current flat-ID catalogue availability, which can detect
+  drift but cannot prove a definition pin.
+- The launcher records the selected variant and mapped model with `configured`
+  provenance. Runtime identity remains `not-reported` without an independent
+  observation.
+
+Cursor can silently fallback when account, plan, or administration constraints
+prevent a requested definition pin. Native variant acceptance is therefore not
+runtime-model verification, and skills must not promote self-report or
+catalogue presence into observed identity.
 
 ## Phase and Optional-Worker Layers
 

package/assets/docs/workflows/projects/implementation-execution.md

@@ -126,10 +126,13 @@ needed, OAT does not probe or require third-tier capacity.
 
 Provider controls remain exact: Codex uses
 `providers.codex.dispatchArgs.variant`, Claude uses
-`providers.claude.dispatchArgs.model`, and Cursor treats
-`providers.cursor.dispatchArgs.model` as an opaque, byte-for-byte enforced model
-argument.
-For Cursor, opaque selection is enforced as a byte-for-byte model arg.
+`providers.claude.dispatchArgs.model`, and Cursor uses
+`providers.cursor.dispatchArgs.variant`. Cursor launches that exact
+resolver-selected native agent type first; the flat ID and bracket-form pin
+remain inside the explicit mapping and are never normalized by workflow prose.
+The launcher records this selection as `configured`, while runtime identity
+remains `not-reported` without independent observation. Only a pre-start native
+role-selection rejection permits another target-preserving route.
 
 See [Dispatch Policy](dispatch-ceiling.md) for configuration and
 [Orchestration Model](orchestration-model.md) for the complete role map.

package/assets/docs/workflows/projects/lifecycle.md

@@ -115,9 +115,10 @@ through the import-plan lane.
 
 A concrete managed reviewer remains bound across both tiers. Codex uses the
 exact registered role or a child pinned to the resolved model and effort;
-Claude and Cursor pass the exact resolver-returned `dispatchArgs.model` in the
-actual provider invocation, including retries. Tier 2 does not authorize a
-target downgrade. Inline review is allowed only with verified equivalent host
+Claude passes the exact resolver-returned `dispatchArgs.model`; Cursor launches
+the exact `providers.cursor.dispatchArgs.variant` native reviewer variant.
+Retries preserve that complete target. Tier 2 does not authorize a target
+downgrade. Inline review is allowed only with verified equivalent host
 controls, or for explicit inherit/default behavior or the documented
 managed-uncapped reviewer base-role exception; otherwise the review blocks.
 

package/assets/public-package-versions.json

@@ -1,6 +1,6 @@
 {
-  "cli": "0.1.73",
-  "docs-config": "0.1.73",
-  "docs-theme": "0.1.73",
-  "docs-transforms": "0.1.73"
+  "cli": "0.1.74",
+  "docs-config": "0.1.74",
+  "docs-theme": "0.1.74",
+  "docs-transforms": "0.1.74"
 }

package/assets/skills/oat-dispatch-subagents/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: oat-dispatch-subagents
-version: 1.1.3
+version: 1.1.4
 description: Use when an OAT skill or workflow needs provider-neutral selection, launch, recovery, or evidence for bounded subagent work without project lifecycle policy.
 disable-model-invocation: true
 user-invocable: false

package/assets/skills/oat-dispatch-subagents/references/provider-cursor.md

@@ -6,24 +6,35 @@ volatile snapshot, never a durable inventory.
 
 ## Control Surfaces
 
-| Source                       | Establishes                                               | Does not establish                                             |
-| ---------------------------- | --------------------------------------------------------- | -------------------------------------------------------------- |
-| Native Task/Subagent schema  | Roles and opaque selectors for that dispatcher invocation | CLI account eligibility or another dispatcher's native catalog |
-| `cursor-agent --list-models` | Opaque selectors accepted by the account CLI              | Native Task eligibility                                        |
-| Cursor UI role configuration | User-selected defaults and role settings                  | Live root or nested schema without a new observation           |
+| Source                       | Establishes                                                    | Does not establish                                             |
+| ---------------------------- | -------------------------------------------------------------- | -------------------------------------------------------------- |
+| Native Task/Subagent schema  | Agent types available for that dispatcher invocation           | CLI account eligibility or another dispatcher's native catalog |
+| `cursor-agent --list-models` | Opaque flat model IDs accepted by the account CLI and resolver | Native Task eligibility or definition-pin acceptance           |
+| Cursor UI role configuration | User-selected defaults and role settings                       | Live root or nested schema without a new observation           |
 
 Root and nested catalogs are independent, volatile observations. Equality in
 one run does not establish equality in another run or nesting boundary.
 
 ## Native Selection
 
-1. Read the native model enum from the dispatcher that will launch the child.
-2. Intersect configured candidates with that exact snapshot.
-3. Pass the selected opaque string byte-for-byte.
-4. Treat an omitted model as deliberate parent inheritance, not generic
-   defaulting or evidence that a target was unavailable.
-5. Record requested selector, acceptance, outcome, and runtime identity
-   separately.
+Managed Cursor dispatch resolves an opaque flat model ID through OAT's explicit
+mapping and returns `providers.cursor.dispatchArgs.variant`. The mapping owns
+the bracket-form model pin inside the materialized definition; skills must
+never parse, normalize, or reconstruct either model string.
+
+1. Require a non-empty `providers.cursor.dispatchArgs.variant`.
+2. Launch that exact resolver-selected native agent type first.
+3. Treat native launch acceptance plus the complete launcher payload as
+   configured-invocation evidence, not observed runtime model identity.
+4. Permit a replacement route only after a recorded pre-start native
+   role-selection rejection of that exact variant, before any child starts.
+5. After acceptance, continue only through the existing handle. Timeout,
+   interruption, `BLOCKED`, missing telemetry, or self-report never authorizes
+   fallback or replacement.
+6. Treat an omitted variant as deliberate parent inheritance only when the
+   resolver selected no managed target.
+7. Record selected variant, mapped target, acceptance, outcome, and runtime
+   identity separately.
 
 Do not infer Cursor IDE behavior from a headless CLI surface. Keep bounded
 recon on economical explicit targets and reserve stronger targets for
@@ -52,12 +63,13 @@ verdict.
 
 ## Pre-Start CLI Routes
 
-When the current native intersection is absent or unsatisfactory, a caller may
-use a deliberate pre-start CLI route only when:
+When exact native role selection rejects the resolver-selected variant before
+launch, a caller may use a deliberate pre-start CLI route only when:
 
 - the caller's fallback policy allows it;
 - the exact CLI selector exists in the account catalog;
-- native mismatch, route, reason, and candidates are recorded before launch;
+- the native mismatch, rejected variant, route, reason, and candidates are
+  recorded before launch;
 - the prompt is self-contained and authority-bounded.
 
 Verify current CLI help before use. A typical shape is:

package/assets/skills/oat-project-autonomous/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: oat-project-autonomous
-version: 1.0.3
+version: 1.0.4
 description: Use when a user explicitly asks to run an OAT project autonomously end-to-end. Activates session-only autonomy, resumes the correct lifecycle phase, and drives the existing OAT skills through final PR or a reported boundary.
 argument-hint: '<goal | project-slug | ticket-ref>'
 disable-model-invocation: true