feat: add Claude effort dispatch and refresh model guidance

.agents/agents/oat-reviewer.md

@@ -1,6 +1,6 @@
 ---
 name: oat-reviewer
-version: 1.2.8
+version: 1.2.9
 description: Unified reviewer for OAT projects - mode-aware verification of requirements/design alignment and code quality. Writes a review artifact to disk by default, or returns structured findings in-memory when dispatched in structured-output mode.
 tools: Read, Bash, Grep, Glob, Write, Task
 color: yellow
@@ -72,7 +72,12 @@ The orchestrator owns dispatch control. Do not read `plan.md` Dispatch Profile r
 
 For Codex, deterministic review dispatch under a capped managed policy uses the materialized Codex role name returned by `providers.codex.dispatchArgs.variant`; the orchestrator also supplies `providers.codex.selection.target` context when available and should derive `model_axis` and `effort_axis` from resolver output. Managed `Uncapped` and inherit/default policies have no reviewer target, so the base `oat-reviewer` role is used only when the resolver returns no `dispatchArgs.variant`, as a provider-default/unpinned fallback. If you are running as the base role, report any provided `provider_default_effort` as context but do not treat it as managed uncapped selection or an OAT cap. Use base `oat-reviewer` only when the resolver returns no `dispatchArgs.variant`.
 
-For Claude Code, review dispatch is model-axis based and the effort axis is `not-applicable`.
+For Claude Code, an effort-pinned managed review launches the exact generated
+variant returned by `providers.claude.dispatchArgs.variant`; the variant's
+frontmatter applies both model and effort because the Agent call has no effort
+field. Any per-call model must match the definition. Derive both selected axes
+from resolver output and the launcher payload. Legacy model-only and inherited
+routes retain their existing provider-default or inherited effort behavior.
 
 ## Bounded Reviewer Reconnaissance
 

.agents/skills/oat-dispatch-subagents/SKILL.md

@@ -5,7 +5,7 @@ disable-model-invocation: true
 user-invocable: false
 allowed-tools: Read
 metadata:
-  version: 1.2.8
+  version: 1.2.9
 ---
 
 # Dispatching OAT Subagents

.agents/skills/oat-dispatch-subagents/references/provider-claude.md

@@ -8,16 +8,18 @@ policy for this provider lives in
 
 | Surface           | Controls                                   | Qualification                                          |
 | ----------------- | ------------------------------------------ | ------------------------------------------------------ |
-| Native agent tool | Agent type plus optional model             | Effort may not be exposed on this surface.             |
-| Agent definition  | Default model in frontmatter               | Between explicit call selection and inheritance.       |
+| Native agent tool | Agent type plus optional matching model    | Effort has no per-call Agent field.                    |
+| Agent definition  | Default model and effort in frontmatter    | Managed effort targets use generated named variants.   |
 | Workflow agent    | Agent type, model, and effort when exposed | Use only controls present in the live schema.          |
 | `claude -p`       | Alias or full model ID plus CLI effort     | Verify current CLI help before constructing a route.   |
 | Continuation      | Existing child handle through message send | Preserves context; a new launch creates another child. |
 
 Native model resolution commonly follows explicit call model, agent-definition
 model, then parent/session inheritance. Treat omission as a deliberate
-inheritance selection. Never omit a worker model when inheritance is not the
-recorded policy.
+inheritance selection. For a managed model-plus-effort target, launch the exact
+resolver-returned generated variant. Any per-call model must match that
+variant's definition; there is no per-call Agent effort argument. Never omit a
+worker target when inheritance is not the recorded policy.
 
 ## Native Topology
 
@@ -56,10 +58,21 @@ prohibited. Record the exact selector and `floor_satisfaction`.
 ## Surface-Aware Selection
 
 - Select an exact accepted alias from the native enum for native dispatch.
-- Select a CLI route before launch when a full model ID or explicit effort is
-  required and native controls cannot express it.
+- Select the exact generated agent variant before launch when managed effort is
+  required. Effort-pinned targets must use a recognized versioned model ID or a
+  family alias whose matching `ANTHROPIC_DEFAULT_<FAMILY>_MODEL` pin establishes
+  capability. A custom pin requires matching `<PIN>_SUPPORTED_CAPABILITIES`;
+  `CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST` takes precedence, so bare aliases fail
+  closed when their generation cannot be proven. A CLI route remains available
+  only when the selected target cannot be expressed by native dispatch and the
+  caller's fallback contract permits it.
 - Record selector granularity such as `tier-alias` or `exact-model-id`.
-- Record native effort as `not-exposed`, not globally `not-applicable`.
+- Record generated-definition effort as `selected:<effort>`. Use `not-exposed`
+  only for an unpinned native surface whose active schema cannot report effort;
+  do not turn that observation into a global `not-applicable` claim.
+- Legacy model-only aliases remain compatible through the per-call model
+  argument. Their per-call effort axis is `not-applicable` because Agent exposes
+  no per-call effort argument; this does not claim that Claude lacks effort.
 - Record service tier separately; fast Claude routes are latency purchases.
 - Keep acceptance, outcome, runtime identity, and continuation separate.
 - Record the provider-guidance version and freshness state.

.agents/skills/oat-project-implement/SKILL.md

@@ -7,7 +7,7 @@ disable-model-invocation: true
 user-invocable: true
 allowed-tools: Read, Write, Bash(git:*), Bash(oat:*), Bash(oat project log:*), Glob, Grep, AskUserQuestion, Task
 metadata:
-  version: 2.3.11
+  version: 2.3.12
 ---
 
 # Implementation Phase

.agents/skills/oat-project-implement/references/completion-and-closeout.md

@@ -221,6 +221,8 @@ missing self-report, or a later `BLOCKED` result cannot trigger fallback. Record
 the final review `target`, `model_axis`, and `effort_axis` from resolver output
 and the constructed launcher payload, never from reviewer self-report. A
 concrete managed Claude target must put
+`providers.claude.dispatchArgs.variant` into the native agent type for an
+effort-pinned target. A legacy model-only target must put
 `providers.claude.dispatchArgs.model` into the actual provider invocation as
 the exact `model` argument. A concrete managed Cursor target must launch
 `providers.cursor.dispatchArgs.variant` as the exact resolver-selected native

.agents/skills/oat-project-implement/references/dispatch-and-dry-run.md

@@ -201,19 +201,23 @@ Resolution order:
 
 Read `providers.<active-provider>` from the `--json` response for the concrete
 dispatch controls. `dispatchArgs` carries the provider-specific argument to
-pass through (Codex: `variant` name; Claude: `model` string; Cursor:
-materialized `variant` name). `selection` carries `role`, `selectedValue`, `capped`,
-`selectionMode`, and policy fields; `selection.target` and an optional
-`providers.<provider>.target` carry route data. For implementer/fix dispatch,
-use exactly one of two mutually exclusive selection paths:
-
-1. **Preferred-selection branch:** pass `--preferred <preferred-value>` when
-   asking the resolver to choose from a preference under an uncapped or other
-   preference-driven policy. Do not include `--candidate-model` or
+pass through (Codex: `providers.codex.dispatchArgs.variant`; Claude:
+`providers.claude.dispatchArgs.variant` for an effort-pinned target or
+`providers.claude.dispatchArgs.model` for a legacy model-only target; Cursor:
+`providers.cursor.dispatchArgs.variant`). `selection` carries `role`,
+`selectedValue`, `capped`, `selectionMode`, and policy fields;
+`selection.target` and an optional `providers.<provider>.target` carry route
+data. For implementer/fix dispatch, use exactly one of two mutually exclusive
+selection paths:
+
+1. **Preferred-selection branch:** pass `--preferred <preferred-value>` for a
+   legacy scalar ceiling, another preference-driven policy, or managed
+   `Uncapped` model-only compatibility. Do not include `--candidate-model` or
    `--candidate-effort`.
 2. **Exact-candidate branch:** pass `--candidate-model` and, when applicable,
    `--candidate-effort` after selecting a concrete configured candidate for a
-   managed-capped route. This branch must not include `--preferred`.
+   managed-capped route or for managed `Uncapped` with an explicit model/effort
+   choice. This branch must not include `--preferred`.
 
 Use `selection.selectedValue` as the selected axis value when it is present.
 Never re-derive these controls from the policy label or a ceiling-only variant
@@ -266,8 +270,9 @@ At minimum, preserve these semantics in any fallback text:
   Implementation preflight must block until a policy resolves.
 
 OAT applies managed policies where the provider exposes a reliable mechanism
-(Codex: pinned variants; Claude: Task model parameter). Other providers may
-treat managed policies as advisory.
+(Codex: pinned variants; Claude: generated agent variants for effort-pinned
+targets and the Task model parameter for legacy model-only targets). Other
+providers may treat managed policies as advisory.
 
 **Managed capped policy selection** persists only `mode: managed`, the named
 maximum `policy`, and `source`. The named maximum leaves lower configured
@@ -397,7 +402,11 @@ All project-aware launch paths record the launch in the project's run record.
 Construct and redact the complete generic record plus OAT role event before the
 native host call; when the call returns `accepted` or `blocked-before-start`,
 write the request ID, the `Dispatch:` stamp, the launch status, and later the
-terminal outcome into the run record in `implementation.md`. Writing a per-dispatch file with `oat project dispatch record` is optional and off by default: no lifecycle skill or command consumes those files, so do not write them unless the host has explicitly opted in. A rejected
+terminal outcome into the run record in `implementation.md`. Writing a
+per-dispatch file with `oat project dispatch record` is optional and off by
+default: no lifecycle skill or command consumes those files, so do not persist
+one unless the host has explicitly opted in. The managed Claude validation-only
+call below is mandatory and does not persist a file. A rejected
 launch must attest `provesNoChildStarted: true`; only it permits one
 exact-target approximation with a fresh request ID. Preserve exact model,
 effort, reasoning, service tier, route, authority, and provider controls.
@@ -465,29 +474,77 @@ requested; never silently downgrade to it.
 
 Claude rules:
 
-- Claude policy selection is model-based: `haiku < sonnet < opus < fable`.
+- Claude policy selection compares configured model and effort independently.
+  Model families remain ordered `haiku < sonnet < opus < fable`; within one
+  model, configured effort follows the provider-supported order.
 - Implementer/fix dispatch chooses one selection branch:
-  - Managed `Uncapped`: use the preferred-selection branch with
-    `--preferred <preferred-model>` so the resolver selects the classified
-    model with no cap.
+  - Managed `Uncapped` with an explicit effort: use the exact-candidate branch.
+    Pass
+    `--candidate-model <preferred-model> --candidate-effort <preferred-effort>`
+    and include `--task-effort <preferred-effort>` as matching classification
+    provenance. Do not combine this branch with `--preferred`.
+  - Managed `Uncapped` with a model-only choice: use the preferred-selection
+    branch with `--preferred <preferred-model>`; this intentionally preserves
+    the legacy model-only route with no selected effort.
   - Capped managed policy: use the exact-candidate branch below. The
     `--candidate-model` call replaces the preferred-selection call and must not
     include `--preferred`.
   - Inherit/default: use neither selection branch; the resolver returns no
-    selected model, so omit `model` and inherit host/default behavior.
+    selected target, so omit managed variant/model controls and inherit
+    host/default behavior.
 - Review dispatch:
   - Capped managed policy: target the configured policy cap directly.
-  - Managed `Uncapped` or inherit/default: no reviewer target exists; omit `model` and log inherited/default model behavior.
+  - Managed `Uncapped` or inherit/default: no reviewer target exists; omit
+    managed variant/model controls and log inherited/default behavior.
 - For managed capped phase-implementer/fix dispatch, call
-  `oat project dispatch-ceiling resolve --provider claude --role implementer --ceiling-tier <project-or-phase-tier> --candidate-model <model> --task-class <task-class> --orchestrator-tier <current-orchestrator-tier> --escalation-level <route-level> --report-scope <phase-id> --report-action implementation --json`.
+  `oat project dispatch-ceiling resolve --provider claude --role implementer --ceiling-tier <project-or-phase-tier> --candidate-model <model> [--candidate-effort <effort>] --task-class <task-class> --orchestrator-tier <current-orchestrator-tier> --escalation-level <route-level> --report-scope <phase-id> --report-action implementation --json`.
   For bounded fixes, reuse the exact phase target and task classification with a
   bounded fix scope.
   For review dispatch, call the resolver with
   `--role reviewer --report-scope <phase-or-review-scope> --report-action review --json`
-  and no candidate flags. Read `providers.claude.dispatchArgs.model` and pass it
-  exactly on the actual Task invocation.
-- Pass `model: "<value>"` when `model_axis=selected:<value>` on the Task tool call.
-- Keep `effort_axis=not-applicable`; Claude Code has no separate per-dispatch effort axis.
+  and no candidate flags. For an effort-pinned result, require
+  `providers.claude.dispatchArgs.variant` and launch that exact generated native
+  agent type. For a legacy model-only result, read
+  `providers.claude.dispatchArgs.model` and pass it exactly on the actual Agent
+  invocation.
+- An effort-pinned launch gets effort from generated agent frontmatter; the
+  Agent call has no per-call effort field. If the call also includes `model`, it
+  must equal the definition's model.
+- Before any managed effort-pinned Claude launch, pass the real completed
+  resolver JSON, the selected generated `.claude/agents/<variant>.md`
+  definition, and the exact proposed payload through the shipped record
+  producer. Use its managed input form:
+
+  ```json
+  {
+    "claudeLaunch": {
+      "resolution": { "<complete-resolver-field>": "<value>" },
+      "definition": "<the exact generated definition text>",
+      "payload": { "variant": "<the exact native variant>" }
+    },
+    "recordBase": { "<generic-nonderived-field>": "<value>" },
+    "event": { "<canonical-role-resolution-field>": "<value>" }
+  }
+  ```
+
+  Construct this JSON with a JSON-aware tool such as `jq --slurpfile` and
+  `--rawfile`; the placeholder keys illustrate object shapes and are never
+  literal input. Set the pre-launch record base to `launch_status: planned` and
+  `child_outcome: null`, then run
+  `oat project dispatch record --event-file <input> --json` without
+  `--project`. Require `status: validated-only`. Launch only
+  `record.payload.variant` (and `record.payload.model` when present) from that
+  result. The producer rejects a missing or stale variant, an absent or drifted
+  generated definition, and a conflicting per-call model. After the terminal
+  child outcome, rebuild through the same managed input with the terminal
+  status; persistence remains subject to the opt-in rule above. Never copy
+  model, effort, selector, candidate, or payload fields into the record base:
+  the accepted envelope owns and derives them.
+
+- Derive `model_axis=selected:<model>` and `effort_axis=selected:<effort>` from
+  resolver output and the constructed variant payload. Legacy model-only
+  targets retain provider-default effort; inherited targets retain inherited
+  axes.
 
 Cursor rules:
 
@@ -668,7 +725,7 @@ Dispatch policy: {policy}; selected={selected value | none}; cap={value | none}
 ```text
 Dispatch policy: balanced; selected=xhigh; cap=xhigh (codex, enforced — variant oat-phase-implementer-gpt-5-6-terra-xhigh)
 Dispatch policy: inherit host defaults; selected=none; cap=none (codex, advisory — base role follows provider default)
-Dispatch policy: balanced; selected=sonnet; cap=sonnet (claude, enforced — Task model arg)
+Dispatch policy: balanced; selected=claude-sonnet-5/high; cap=claude-sonnet-5/high (claude, enforced — native variant oat-phase-implementer-claude-claude-sonnet-5-high)
 Cursor materialized-variant example: Dispatch policy: frontier; selected=gpt-5.6-sol-max; cap=gpt-5.6-sol-max (cursor, enforced — native variant oat-phase-implementer-gpt-5-6-sol-max)
 Dispatch policy: unresolved; selected=none; cap=none (codex, advisory — policy set but no value resolved)
 ```

.agents/skills/oat-project-implement/references/phase-execution.md

@@ -101,12 +101,17 @@ Before each phase:
 
 Codex first uses the resolver-returned materialized implementer variant as
 native `agent_type`; only explicit pre-start role rejection permits the exact
-pinned fresh-child route. Claude passes the exact resolver model argument.
-Cursor launches the exact `providers.cursor.dispatchArgs.variant` native agent
-type first; only explicit pre-start native role-selection rejection permits
-another target-preserving route. After acceptance, missing telemetry, timeout,
-`BLOCKED`, or any other terminal outcome cannot trigger fallback or
-replacement.
+pinned fresh-child route. For Claude, an effort-pinned target launches the exact
+generated `providers.claude.dispatchArgs.variant` as the native agent type only
+after the mandatory validation-only managed-Claude record boundary in
+`dispatch-and-dry-run.md` accepts the resolver, generated definition, and exact
+payload; a
+legacy model-only target passes `providers.claude.dispatchArgs.model` as the
+exact model argument. Cursor launches the exact
+`providers.cursor.dispatchArgs.variant` native agent type first; only explicit
+pre-start native role-selection rejection permits another target-preserving
+route. After acceptance, missing telemetry, timeout, `BLOCKED`, or any other
+terminal outcome cannot trigger fallback or replacement.
 
 The phase recovery limit is not a route retry limit. Implementation recovery
 must not use route escalation, route-level advancement, model/provider
@@ -700,12 +705,15 @@ artifact under the project's `reviews/` directory.
 
 For a managed capped review, bind the exact provider argument to the actual
 invocation: `providers.codex.dispatchArgs.variant`,
-`providers.claude.dispatchArgs.model`, or
+`providers.claude.dispatchArgs.variant` for an effort-pinned target,
+`providers.claude.dispatchArgs.model` for a legacy model-only target, or
 `providers.cursor.dispatchArgs.variant`. Cursor must launch that exact
 resolver-selected native reviewer variant first and must not normalize its
 mapped model or attach a Task-level model argument. If the root cannot apply,
 pass, or bind the required model, variant, or role control, fail closed before
-launch.
+launch. A managed effort-pinned Claude reviewer also passes the real reviewer
+resolver result, generated definition, and proposed payload through the same
+mandatory validation-only managed-Claude record boundary before launch.
 
 After acceptance, poll, nudge, or continue only through the accepted reviewer
 handle. Only explicit pre-start rejection allows another route. Timeout,