@open-agent-toolkit/cli 0.2.3 → 0.2.4

package/assets/agents/oat-reviewer.md

@@ -1,8 +1,8 @@
 ---
 name: oat-reviewer
-version: 1.1.7
+version: 1.1.8
 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
+tools: Read, Bash, Grep, Glob, Write, Task
 color: yellow
 ---
 
@@ -73,6 +73,47 @@ For Codex, deterministic review dispatch under a capped managed policy uses the
 
 For Claude Code, review dispatch is model-axis based and the effort axis is `not-applicable`.
 
+## Bounded Reviewer Reconnaissance
+
+The primary reviewer must establish the authoritative scope before considering delegation. Establish its authoritative commit range and read the mode-required discovery, spec, design, plan, and implementation artifacts that are available before decomposition or delegation. Understand the requirements, changed surfaces, and failure consequences in that authoritative scope before deciding whether lanes are independent. Delegation is optional and useful only when the resolved scope has multiple independent evidence lanes. Eligible broad reviews include final code reviews, broad phase/range reviews, docs sweeps, and provider-view audits. Narrow task or artifact reviews stay inline when coordination would cost as much as direct inspection.
+
+When delegation is eligible:
+
+1. Use one bounded, read-only, non-recursive reconnaissance round with disjoint lane scopes. This is a one-level fan-out limit: lane workers must not spawn additional workers.
+2. Before launching any lane, read `.agents/skills/oat-dispatch-subagents/SKILL.md`, resolve the active provider, and read exactly one matching active-provider reference under `.agents/skills/oat-dispatch-subagents/references/`. Reviewer-local reconnaissance must not read or load `.agents/skills/oat-project-dispatch-subagents/SKILL.md`; that adapter is reserved for project lifecycle phase/task policy.
+3. Map every lane worker to the shared `recon` role class (`role.class: recon`); role authority stays read-only and advisory. Assign the independent `task_class`, `classification_source: caller`, and non-empty `classification_reason` fields after understanding the artifacts and diff. These task-class fields are required for reviewer-local reconnaissance even though the generic dispatch contract keeps them optional for other callers.
+4. Classify each lane as `mechanical-recon`, `intelligent-recon`, `default-implementation`, `hard-reasoning`, or `consequential`. Use the stronger floor when uncertain. Classification proceeds from deterministic verification to silent-miss risk, then dispersed context, ambiguity, and consequence; file count alone never justifies escalation.
+   - `mechanical-recon`: deterministic inventories, parity checks, and test/lint/format/build execution whose misses are visible and cheaply checked.
+   - `intelligent-recon`: interpretation, semantic completeness, policy-aware auditing, or unfamiliar-code review where a miss could be silent.
+   - `default-implementation`: rare, independently bounded dossier work that must retain and reconcile dispersed context; prefer keeping it with the root.
+   - `hard-reasoning`: ambiguity, novelty, architecture analysis, or competing interpretations dominate.
+   - `consequential`: security, release safety, irreversible impact, or expensive failure dominates.
+
+   Mechanical workers may execute checks and report exact output, but interpretation and policy judgment require stronger classes or stay with the root reviewer.
+
+5. The generic dispatch contract owns capability, catalog, model, effort, route, authorization, launch evidence, class-floor selection, and floor-satisfaction evidence. It applies active user and repository instructions, the active-provider reference, the live nested catalog, and the supplied policy/ceiling. Select an explicit target meeting the declared floor; never silently inherit the primary reviewer's model and never hard-code provider model names. Prefer a cheaper/faster worker only when the host reliably exposes that control and the target still satisfies the floor.
+6. Give each lane an exact scope and a compact return contract: coverage, checks performed, exact `file:line` evidence, gaps, and explicit uncertainty. Reports are advisory candidate observations, not accepted findings.
+7. Workers must not mutate files, emit final findings, assign severity, make validation decisions, write review artifacts or `StructuredFindings`, or otherwise write either output sink.
+
+Lanes may share one homogeneous dispatch wave only when every existing dispatch axis, `task_class`, and `model_class_floor` match. Mixed task classes require separate records and waves. The one-level fan-out limit applies across all waves.
+
+When delegated reconnaissance is attempted, artifact mode must include a
+compact `## Review Orchestration` section. Record the waves, task classes,
+classification rationale, selected targets, acceptance and outcomes, floor
+satisfaction, fallback, and primary reconciliation. Condense the dispatch
+evidence instead of copying every worker record. In structured-output mode,
+summarize orchestration in the existing `summary`; do not add a field to the
+`StructuredFindings` schema.
+
+The primary reviewer owns source validation and verification, reconciliation, synthesis, severity, validation decisions, artifact writing, output ownership, and the final findings or `StructuredFindings`. Reopen authoritative sources and directly re-verify every load-bearing positive and negative claim; repeat relevant searches for absence claims before promotion to a finding. Reconcile overlap, disagreement, and cross-lane gaps across task classes before deduplicating and assigning severity.
+
+Capability-check reviewer-local delegation once. A reviewer-local request must use `fallback.mode: caller-inline` and `allow_below_task_class_floor: false`. If the requested floor cannot be explicitly satisfied, record it as unsatisfied, do not launch a below-floor worker, and cover the affected lane inline without weakening review coverage, the checklist, or the output contract. The same inline fallback applies when nested dispatch is unsupported, unauthorized, failed, empty, or malformed. The inline and delegated paths preserve the existing artifact-mode, gate-parsing, and structured-output schemas unchanged.
+
+The primary reviewer and lane workers must not write or modify
+`project-log.md` and must not invoke `oat project log append`. The root project
+workflow validates review orchestration evidence and owns any structural log
+entry.
+
 ## Mode Contract
 
 Use workflow mode to determine required evidence:
@@ -338,6 +379,17 @@ oat_invocation_source: { exec-target-config|unknown }
 
 Findings: {N} critical, {N} important, {N} medium, {N} minor
 
+## Review Orchestration
+
+{Include this section only when delegated reconnaissance was attempted.}
+
+| Wave | Task class | Classification rationale | Selected target  | Acceptance / outcome | Floor satisfaction | Fallback |
+| ---- | ---------- | ------------------------ | ---------------- | -------------------- | ------------------ | -------- |
+| {id} | {class}    | {reason}                 | {target or none} | {status / outcome}   | {status}           | {route}  |
+
+**Primary reconciliation:** {independent verification, accepted/rejected
+worker claims, and root-inline coverage}
+
 ## Findings
 
 ### Critical
@@ -414,6 +466,9 @@ For gate-originated artifacts, all six gate-only fields are required when the pr
 **Artifact mode only.** In structured-output mode (`oat_output_mode: structured`), return the `StructuredFindings` object instead — see **Structured-Output Mode** below.
 
 Return a brief confirmation. DO NOT include full review contents.
+Return exactly one reconnaissance status line using only `attempted` or
+`not-attempted`; this signal reports whether delegated reconnaissance was
+attempted, including an attempted launch that fell back or failed.
 
 Format:
 ```
@@ -423,6 +478,7 @@ Format:
 **Scope:** {scope}
 **Findings:** {N} critical, {N} important, {N} medium, {N} minor
 **Review artifact:** {path}
+**Reconnaissance:** {attempted | not-attempted}
 
 Return to your main session and run the `oat-project-review-receive` skill.
 
@@ -439,7 +495,7 @@ When the dispatch payload sets `oat_output_mode: structured`, the output sink ch
 
 ```typescript
 interface StructuredFindings {
-  summary: string; // 2-3 sentence review summary
+  summary: string; // 2-3 sentence review summary; include compact orchestration when reconnaissance was attempted
   findings: Array<{
     id: string; // C1, I1, M1, m1 — stable per dispatch (C/I/M/m prefix matches the severity model)
     severity: 'critical' | 'important' | 'medium' | 'minor';

package/assets/docs/cli-utilities/project-log.md

@@ -93,6 +93,22 @@ entries without asking agents to edit `project-log.md`:
 - `oat-project-implement` records accepted subagent dispatches, STOP or park
   events, phase outcomes, and parallel-group merge results. These entries point
   to the corresponding `implementation.md` record instead of copying it.
+- When `oat-project-implement` or `oat-project-review-provide` receives an
+  artifact-mode review, the root workflow first consumes exactly one
+  `**Reconnaissance:** attempted` or
+  `**Reconnaissance:** not-attempted` signal from the reviewer's brief
+  confirmation. A missing, duplicate, or invalid signal fails closed before
+  artifact validation or bookkeeping.
+  - `attempted` requires a complete `Review Orchestration` section recording
+    waves, task classes, classification rationale, selected targets,
+    acceptance and outcomes, floor satisfaction, fallback, and primary
+    reconciliation. The root then invokes `oat project log append` exactly once
+    for one structural entry referencing the review artifact instead of copying
+    worker records.
+  - `not-attempted` forbids a `Review Orchestration` section and does not invoke
+    `oat project log append` for review orchestration.
+    Reviewers and reconnaissance workers never write `project-log.md`
+    themselves.
 - `oat gate review` records exactly one entry for every terminal outcome,
   including successful and blocking verdicts, child failure, timeout,
   targeting-correlation failure, and artifact-validation failure. A log append

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

@@ -216,7 +216,7 @@ Final review `passed` gate requires:
 
 ## Subagent Compatibility
 
-`oat-project-review-provide` uses provider-aware subagent dispatch when available:
+`oat-project-review-provide` uses provider-aware subagent dispatch when available. This outer dispatch starts the primary `oat-reviewer`; it is separate from any optional reconnaissance workers that the reviewer may launch after resolving its authoritative review scope:
 
 - Claude Code: dispatch `oat-reviewer` with `subagent_type` (resolved from `.claude/agents/oat-reviewer.md`).
 - Cursor: dispatch `oat-reviewer` via explicit `/oat-reviewer` invocation or natural mention (resolved from `.cursor/agents/oat-reviewer.md`; `.claude/agents/oat-reviewer.md` is also supported for compatibility).
@@ -246,6 +246,93 @@ Final review `passed` gate requires:
   fallback). This generic fallback does not override managed exact-target
   rules: a managed reviewer that cannot be launched exactly blocks the review.
 
+### Reviewer-local reconnaissance
+
+After the outer dispatch, the primary reviewer may use reviewer-local workers
+when a broad review has multiple independent evidence lanes. Examples include
+final code reviews, broad phase or phase-range reviews, documentation sweeps,
+and provider-view audits. Running disjoint searches concurrently can reduce
+wall-clock review time, and matching each lane to the least expensive model
+class that can safely do the work can reduce cost. The primary reviewer first
+reads the authoritative diff and the workflow-required discovery, spec,
+design, plan, and implementation artifacts. It decides lane boundaries and
+task classes only after understanding the changed surfaces, requirements, and
+failure consequences. Narrow task and artifact reviews remain inline when
+coordination would cost as much as direct inspection.
+
+Worker authority and model capability are independent. Every reviewer-local
+worker keeps the read-only, advisory `recon` role class. The lane's separate
+task class sets its minimum model-capability floor:
+
+- **Mechanical recon** covers deterministic inventories, exact parity checks,
+  and test, lint, format, or build execution whose results are cheaply
+  verifiable.
+- **Intelligent recon** covers semantic interpretation, unfamiliar-code
+  auditing, and other evidence where a miss could be silent.
+- **Stronger bounded analysis** is reserved for independently scoped work where
+  dispersed context, ambiguity, security, release safety, irreversible impact,
+  or expensive failure warrants a higher floor.
+
+File count alone does not justify escalation. Interpretation and policy
+judgment either use an adequate stronger class or remain with the primary
+reviewer. Active user and repository instructions, the active-provider
+guidance, and the live nested catalog resolve current model examples; the
+canonical reviewer does not promise named models.
+
+Reviewer-local fan-out is limited to one bounded, read-only, non-recursive
+round. Each worker receives a disjoint scope, cannot modify files or spawn more
+workers, and returns a compact advisory report containing:
+
+- coverage and checks performed;
+- exact `file:line` evidence;
+- gaps in the assigned scope; and
+- explicit uncertainty, including uncertainty about absence claims.
+
+Before launching these lanes, the reviewer loads the generic
+`oat-dispatch-subagents` contract and exactly one active-provider reference.
+That shared contract owns nested capability checks, worker catalog resolution,
+model and effort selection, routing, authorization, launch evidence, and
+provider-specific mechanics. It records each lane's task class, model-class
+floor, classification rationale, and floor satisfaction without assuming that
+workers inherit the primary reviewer's target. Lanes may share one wave only
+when their task classes, model floors, and all other dispatch axes match;
+mixed-class reviews use separate waves and records.
+
+This generic reviewer-local use is distinct from
+`oat-project-dispatch-subagents`, which is reserved for OAT lifecycle phase and
+task dispatch policy. Reviewer-local lanes do not load or depend on that
+lifecycle adapter.
+
+Worker reports are candidate observations, not findings. The primary reviewer
+reopens authoritative sources, verifies load-bearing positive and negative
+claims, reconciles overlap and disagreement, fills cross-lane gaps, performs
+synthesis, assigns severity, decides validation, and alone writes the review
+artifact or final `StructuredFindings`.
+
+When the reviewer attempts delegated reconnaissance, the review artifact
+includes a compact `Review Orchestration` section. It records each wave's task
+class and classification rationale, selected target, acceptance and outcome,
+floor satisfaction, fallback, and the primary reviewer's reconciliation. The
+section is the detailed evidence source; it does not copy every internal worker
+record. Structured-output reviews keep the existing schema and summarize the
+same orchestration evidence in `summary`.
+
+The reviewer and its workers never write `project-log.md`. After validating the
+artifact, the root project implementation or review workflow uses
+`oat project log append` to add one concise structural entry that references
+the artifact. Logging remains capability-gated by the CLI helper, so disabled
+project logging requires no reviewer-side branch or write authority.
+
+If nested workers are unsupported, unauthorized, fail, or return empty or
+malformed reports, the primary reviewer covers those lanes inline. It also
+stays inline when the host cannot explicitly satisfy a lane's model-class
+floor. Fallback never selects below the declared floor. It preserves the same
+checklist, verification depth, severity policy, and final output contract; it
+does not promise provider behavior or silently inherit the primary reviewer's
+model. Workers remain advisory and non-recursive regardless of task class, and
+the primary reviewer keeps final verification, reconciliation, severity,
+validation decisions, and output ownership.
+
 ## Reference artifacts
 
 - `.oat/projects/<scope>/<project>/plan.md` (`## Reviews`)

package/assets/public-package-versions.json

@@ -1,6 +1,6 @@
 {
-  "cli": "0.2.3",
-  "docs-config": "0.2.3",
-  "docs-theme": "0.2.3",
-  "docs-transforms": "0.2.3"
+  "cli": "0.2.4",
+  "docs-config": "0.2.4",
+  "docs-theme": "0.2.4",
+  "docs-transforms": "0.2.4"
 }

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

@@ -1,6 +1,6 @@
 ---
 name: oat-dispatch-subagents
-version: 1.1.4
+version: 1.1.5
 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
@@ -76,6 +76,19 @@ Require the caller to provide:
 - route-selection source for any non-native route;
 - optional resolved dispatch policy or named ceiling.
 
+The caller may also provide `task_class`, `classification_source`, and
+`classification_reason`. This task-class metadata is optional for existing
+generic callers. When supplied, all three fields are required:
+
+- `task_class`: `mechanical-recon`, `intelligent-recon`,
+  `default-implementation`, `hard-reasoning`, or `consequential`;
+- `classification_source`: the literal `caller`; and
+- `classification_reason`: a non-empty artifact-informed rationale.
+
+The caller owns classification. `oat-reviewer` requires these fields for every
+reviewer-local reconnaissance lane; other callers that omit them retain
+role-based selection behavior and records without class-floor fields.
+
 Reject an over-broad request before selection. Every nontrivial request must
 state the exact objective, scope, expected output, verification evidence, and
 conditions that require escalation. Model routing never repairs poor
@@ -169,19 +182,55 @@ or a second launch.
 
 Specific role names are extensible, but map every dispatch to one class:
 
-| Class          | Default contract                                                                                                                  |
-| -------------- | --------------------------------------------------------------------------------------------------------------------------------- |
-| `recon`        | Read-only, bounded evidence collection. Select an explicit economical target; never silently inherit an expensive root model.     |
-| `dossier-lead` | Reconcile dispersed evidence within one declared scope. May coordinate bounded recon only when nesting is supported and approved. |
-| `generator`    | Produce a self-contained artifact within caller-declared authority.                                                               |
-| `worker`       | Execute bounded work with explicit authority, outputs, and verification.                                                          |
-| `reviewer`     | Perform independent or inherited review exactly as caller policy specifies.                                                       |
-| `coordinator`  | Coordinate a caller-defined topology without taking over caller synthesis or user dialogue.                                       |
+| Class          | Default contract                                                                                                                                                                                                                          |
+| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `recon`        | Read-only, bounded evidence collection. Meet any supplied `task_class` / `model_class_floor` at or above the floor; select an explicit economical target only when no task-class floor was supplied. Never silently inherit a root model. |
+| `dossier-lead` | Reconcile dispersed evidence within one declared scope. May coordinate bounded recon only when nesting is supported and approved.                                                                                                         |
+| `generator`    | Produce a self-contained artifact within caller-declared authority.                                                                                                                                                                       |
+| `worker`       | Execute bounded work with explicit authority, outputs, and verification.                                                                                                                                                                  |
+| `reviewer`     | Perform independent or inherited review exactly as caller policy specifies.                                                                                                                                                               |
+| `coordinator`  | Coordinate a caller-defined topology without taking over caller synthesis or user dialogue.                                                                                                                                               |
 
 Use stronger workers when context, ambiguity, or consequence requires them,
 not merely because many files exist. Keep coherence-critical synthesis and
 cross-scope judgment in the root caller.
 
+## Task Classes and Model Floors
+
+Role class and task class are independent. Role class controls authority and
+output ownership; task class is the minimum model-capability floor for one
+bounded objective. A `role.class: recon` worker remains read-only and advisory
+at every task class.
+
+Classify by deterministic verifiability, silent-miss risk, dispersed context,
+ambiguity, and consequence, in that order. File count alone never justifies
+escalation:
+
+| Task class               | Minimum capability contract                                                                             |
+| ------------------------ | ------------------------------------------------------------------------------------------------------- |
+| `mechanical-recon`       | Deterministic inventories, parity checks, or test/lint/format/build execution whose misses are visible. |
+| `intelligent-recon`      | Interpretation, unfamiliar-code auditing, or policy/semantic evidence where a miss could be silent.     |
+| `default-implementation` | Retain and reconcile dispersed context inside one independently bounded scope.                          |
+| `hard-reasoning`         | Ambiguity, novelty, architecture analysis, or competing interpretations dominate.                       |
+| `consequential`          | Security, release safety, irreversible impact, adversarial analysis, or expensive failure dominates.    |
+
+Mechanical workers may execute checks and return exact output. Interpretation
+and policy judgment require a stronger class or stay with the root caller. When
+uncertain between classes, use the stronger floor.
+
+For unconstrained legacy recon with no `task_class` supplied, select an
+explicit economical target rather than silently inheriting the root model.
+Class-constrained recon must select a target at or above the supplied
+`model_class_floor`; otherwise set `floor_satisfaction: unsatisfied` and return
+the lane through `caller-inline`. An economical target is not a universal
+baseline for the `recon` role.
+
+Resolve current class examples through active user and repository instructions
+first, then the active-provider reference and live catalog, all constrained by
+the supplied policy and ceiling. Provider-reference model names are dated
+examples, not canonical requirements. Select an exact eligible target at or
+above the requested floor; never silently downgrade.
+
 ## Catalog Evidence
 
 A catalog snapshot belongs to one dispatch context. A root native catalog does
@@ -206,9 +255,11 @@ cannot expose before selection. Record the visibility timing instead.
 For every dispatch:
 
 1. Validate the caller request and capability state.
-2. Resolve provider, context, role class, policy, ceiling, and candidates.
+2. Resolve provider, context, role class, optional task class and model-class
+   floor, policy, ceiling, and candidates.
 3. Observe the launching dispatcher's relevant catalogs.
-4. Compute the exact native intersection.
+4. Compute the exact native intersection at or above the supplied task-class
+   floor, when present.
 5. Prefer an eligible native route. Otherwise select one policy-resolved or
    explicitly authorized inherited, provider-CLI/programmatic, workflow, gate,
    or blocked route before launch.
@@ -239,14 +290,38 @@ flowchart TD
 
 ## Homogeneous Recon Waves
 
+A homogeneous wave may share one record only when `task_class` and
+`model_class_floor` match in addition to every existing dispatch axis.
 Multiple read-only recon lanes may share one selection record only when all of
 these axes are identical: provider, dispatch context, catalog snapshot,
 selected route, role class, role selector, model, effort, authority, deadline,
-retry limit, and fallback. Include a lane manifest with lane-specific scope,
-acceptance, and outcome.
+retry limit, fallback, `task_class`, and `model_class_floor`. Include a lane
+manifest with lane-specific scope, acceptance, and outcome. A recon-wave record
+repeats the shared `task_class` and `model_class_floor` beside
+`shared_dispatch_record`; lane entries do not redefine them.
+
+If any axis differs or either class field does not match, create separate
+records and waves. The record-level scope is the aggregate wave boundary; each
+lane may narrow that boundary.
+
+## Class-Constrained Fallback
+
+For a request with task-class metadata, record `model_class_floor` equal to
+`task_class` and set `floor_satisfaction` to `satisfied` or `unsatisfied`.
+An unsatisfied floor blocks launch and returns control to the caller; it never
+records a weaker selection as success.
+
+Reviewer-local requests use:
+
+```yaml
+fallback:
+  mode: caller-inline
+  allow_below_task_class_floor: false
+```
 
-If any axis differs, create separate records. The record-level scope is the
-aggregate wave boundary; each lane may narrow that boundary.
+Below-floor selection is prohibited. The legacy `explicit-downgrade` fallback
+remains available only to unconstrained callers without task-class metadata or
+a declared class floor.
 
 ## Acceptance and Recovery
 

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

@@ -31,6 +31,27 @@ known role from the active contract when a pre-call role list is unavailable,
 and record visibility timing. Do not launch a diagnostic child solely to
 satisfy a universal catalog rule.
 
+## Task-Class Resolution
+
+Apply active user and repository instructions first; they override the dated
+model-family examples in this provider reference. Intersect the resulting
+class guidance with the live native model enum and the supplied policy and
+ceiling. Select one exact accepted alias at or above the requested floor:
+
+- `mechanical-recon`: the fastest economical class suitable for deterministic
+  inventories, parity, and command execution;
+- `intelligent-recon`: a stronger fast class that can interpret unfamiliar
+  code, semantics, and silent-miss-prone evidence;
+- `default-implementation`: a context-retentive implementation class for
+  independently bounded dossier work;
+- `hard-reasoning`: a strong reasoning class for ambiguity or architecture;
+- `consequential`: the strongest allowed class for security, release safety,
+  irreversible impact, or expensive failure.
+
+A stale or unavailable named example requires a newer eligible model meeting
+the same class floor or a route one class up. Selection below the floor is
+prohibited. Record the exact selector and `floor_satisfaction`.
+
 ## Surface-Aware Selection
 
 - Select an exact accepted alias from the native enum for native dispatch.

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

@@ -42,6 +42,28 @@ dispersed evidence, and to a stronger reasoning route when ambiguity,
 consequence, or adversarial analysis dominates. Do not escalate merely because
 many files must be searched.
 
+## Task-Class Resolution
+
+Apply active user and repository instructions first; they override the dated
+model-family examples in this provider reference. Intersect that guidance with
+the live model/effort selectors, registered roles, supplied policy and ceiling,
+and requested class floor:
+
+- `mechanical-recon`: an economical class and effort suitable for
+  deterministic inventories, parity, and command execution;
+- `intelligent-recon`: a stronger fast class for interpretation,
+  unfamiliar-code auditing, and silent-miss-prone evidence;
+- `default-implementation`: a context-retentive implementation class for an
+  independently bounded dossier;
+- `hard-reasoning`: a strong reasoning class for ambiguity or architecture;
+- `consequential`: the strongest allowed class for security, release safety,
+  irreversible impact, or expensive failure.
+
+A stale or unavailable named example requires a newer eligible model meeting
+the same class floor or a route one class up. Selection below the floor is
+prohibited. Keep model and reasoning effort as separate recorded axes, and
+record `floor_satisfaction`.
+
 Native spawn acceptance is configured-invocation evidence. Missing runtime
 model identity does not invalidate an accepted configured payload.
 

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

@@ -15,15 +15,37 @@ volatile snapshot, never a durable inventory.
 Root and nested catalogs are independent, volatile observations. Equality in
 one run does not establish equality in another run or nesting boundary.
 
-## Native Selection
-
-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.
+## Task-Class Resolution
+
+Apply active user and repository instructions first; they override the dated
+model-family examples in this provider reference. Intersect that guidance with
+the exact model choices advertised by the dispatcher, the supplied policy and
+ceiling, and the requested class floor:
+
+- `mechanical-recon`: the fastest economical class suitable for deterministic
+  inventories, parity, and command execution;
+- `intelligent-recon`: a stronger fast class for interpretation,
+  unfamiliar-code auditing, and silent-miss-prone evidence;
+- `default-implementation`: a context-retentive implementation class for an
+  independently bounded dossier;
+- `hard-reasoning`: a strong reasoning class for ambiguity or architecture;
+- `consequential`: the strongest allowed class for security, release safety,
+  irreversible impact, or expensive failure.
+
+A stale or unavailable example requires a newer eligible model meeting the
+same class floor or a route one class up. Selection below the floor is
+prohibited.
+
+## Outer Lifecycle Native Selection
+
+Outer lifecycle implementer and reviewer dispatch uses the exact
+`providers.cursor.dispatchArgs.variant` returned by the lifecycle resolver.
+The resolver maps an opaque flat model ID and owns the bracket-form model pin
+inside the materialized definition; skills never parse, normalize, or
+reconstruct either model string.
+
+1. Require a non-empty resolver-returned variant for managed dispatch.
+2. Launch that exact 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
@@ -36,9 +58,34 @@ never parse, normalize, or reconstruct either model string.
 7. Record selected variant, mapped target, acceptance, outcome, and runtime
    identity separately.
 
+## Reviewer-Local Nested Selection
+
+Reviewer-local recon uses `generalPurpose` with an
+`exact-native-model-choice` selector.
+Reviewer-local reconnaissance is a separate nested native surface. It does not
+use the lifecycle resolver because no materialized lifecycle `recon` role
+exists.
+
+1. Read the model choices advertised by the nested Task/Subagent dispatcher.
+2. Intersect those advertised model choices with active user and repository
+   model-class instructions, this provider reference, the supplied
+   policy/ceiling, and the requested `model_class_floor`.
+3. Use the native `generalPurpose` agent type and pass the exact model choice
+   advertised by the current nested dispatcher byte-for-byte.
+4. Record the selector as `model_selector` with
+   `model_selector_granularity: exact-native-model-choice`.
+5. Treat an omitted model as deliberate parent inheritance only for an
+   unconstrained caller whose recorded policy permits inheritance. A
+   class-constrained reviewer lane never omits the model.
+
+This nested path does not call the lifecycle resolver, parse bracket-form
+model pins, or reconstruct a lifecycle variant. If no exact nested selector
+satisfies the floor, record `floor_satisfaction: unsatisfied` and return the
+lane for caller-inline coverage without launching a weaker worker.
+
 Do not infer Cursor IDE behavior from a headless CLI surface. Keep bounded
-recon on economical explicit targets and reserve stronger targets for
-context-heavy or consequential work.
+mechanical recon on economical explicit targets. Stronger lanes use a
+floor-satisfying target when advertised or stay with the primary reviewer.
 
 ## Dispatch Mode and Liveness
 
@@ -63,13 +110,17 @@ verdict.
 
 ## Pre-Start CLI Routes
 
-When exact native role selection rejects the resolver-selected variant before
-launch, a caller may use a deliberate pre-start CLI route only when:
+Any native mismatch is recorded before launch with the route, reason, and
+candidate set.
+
+When exact outer lifecycle role selection rejects the resolver-selected
+variant before launch, or a generic caller's current native intersection is
+unsatisfactory, 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;
-- the native mismatch, rejected variant, route, reason, and candidates are
-  recorded before launch;
+- the native mismatch, rejected variant when applicable, 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-dispatch-subagents/references/record-schema.md

@@ -37,6 +37,28 @@ escalate_when:
 `dispatch_policy` and `dispatch_ceiling` are optional resolved inputs. The
 general engine does not resolve their source.
 
+Task-class metadata is also generic-optional. A class-constrained caller adds
+all of these fields; `oat-reviewer` requires them for reviewer-local recon:
+
+```yaml
+task_class: intelligent-recon
+classification_source: caller
+classification_reason: >-
+  Determining whether semantic tests pin safety boundaries requires
+  interpretation, and a silent miss would survive mechanical checks.
+fallback:
+  mode: caller-inline
+  allow_below_task_class_floor: false
+```
+
+`task_class` is one of `mechanical-recon`, `intelligent-recon`,
+`default-implementation`, `hard-reasoning`, or `consequential`.
+`classification_source` is the literal `caller`, and
+`classification_reason` is non-empty. Legacy callers may omit all three and
+retain the original role-based selection and fallback behavior. The legacy
+`explicit-downgrade` example above is valid only for an unconstrained request
+without task-class metadata or a declared class floor.
+
 ## Record
 
 ```yaml
@@ -76,6 +98,41 @@ diagnostics: []
 continuation_events: []
 ```
 
+For a class-constrained dispatch, the record also includes:
+
+```yaml
+task_class: intelligent-recon
+model_class_floor: intelligent-recon
+classification_source: caller
+classification_reason: Semantic contract interpretation has silent-miss risk.
+floor_satisfaction: satisfied
+```
+
+`model_class_floor` equals the requested `task_class`.
+`floor_satisfaction` is `satisfied` or `unsatisfied`. An unsatisfied floor
+blocks launch and records no weaker selection as success. These five fields
+remain absent when a legacy request omits task-class metadata.
+
+For a Cursor reviewer-local request whose advertised nested model choices do
+not satisfy the class floor, record the blocked selection without inventing a
+selector:
+
+```yaml
+role_selector: generalPurpose
+model_selector: null
+model_selector_granularity: exact-native-model-choice
+floor_satisfaction: unsatisfied
+fallback:
+  mode: caller-inline
+  allow_below_task_class_floor: false
+launch_status: blocked-before-start
+child_outcome: caller-inline-completed
+```
+
+`exact-native-model-choice` means an exact model choice advertised by the
+current nested dispatcher. It does not imply a stable enum or authorize
+reconstruction of a materialized lifecycle variant.
+
 `role_selector` is the exact provider or harness agent-type selector, when that
 surface exists. Preserve opaque selectors byte-for-byte.
 
@@ -98,6 +155,8 @@ selection source.
 wave_id: repo-audit-wave-1
 scope: repo:packages/cli
 shared_dispatch_record: dispatch-unique-id
+task_class: intelligent-recon
+model_class_floor: intelligent-recon
 lanes:
   - lane_id: correctness
     scope: packages/cli/src
@@ -110,5 +169,7 @@ lanes:
 ```
 
 The wave scope is the aggregate boundary. Lane scope may narrow it. Use one
-shared record only when every dispatch axis listed in the main skill is
-identical.
+shared record only when every dispatch axis listed in the main skill,
+`task_class`, and `model_class_floor` are identical. Lane entries do not
+redefine the shared class fields. Mixed classes require separate records and
+waves.