@open-agent-toolkit/cli 0.1.55 → 0.1.59

package/assets/skills/oat-project-plan-writing/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: oat-project-plan-writing
-version: 1.2.9
+version: 1.2.12
 description: Use when authoring or mutating plan.md in any OAT workflow. Defines canonical format invariants — stable task IDs, required sections, review table rules, and resume guardrails.
 disable-model-invocation: true
 user-invocable: false
@@ -23,6 +23,21 @@ This is a sub-phase indicator; the calling skill owns the top-level banner.
 
 - When invoked by a calling skill, print the sub-banner immediately before plan authoring begins.
 
+## Shared Subagent Dispatch Contract
+
+Before every artifact self-review dispatch, read and follow
+`.agents/skills/oat-project-dispatch-subagents/SKILL.md`, which then requires
+`.agents/skills/oat-dispatch-subagents/SKILL.md`. This explicit two-skill load
+is mandatory; do not rely on ambient skill discovery. Planning self-review
+inherits the planning parent by default. The shared contracts own any
+catalog-aware exception, launch acceptance boundary, and dispatch record; this
+skill continues to own plan readiness and review disposition.
+
+After resolving the review provider, read exactly one active-provider
+reference from `.agents/skills/oat-dispatch-subagents/references/`
+(`provider-cursor.md`, `provider-codex.md`, or `provider-claude.md`). Do not
+merge provider mechanics.
+
 ## Managed Dispatch Readiness and Review Contract
 
 All plan-producing workflows and their artifact reviews use this contract:
@@ -83,40 +98,58 @@ scope.
 
 ### Reviewer Ceiling Contract
 
-A managed active-provider result is runnable only when the resolver returns
-concrete native dispatch controls or an explicit deferred cross-harness target.
-Otherwise treat the active-provider reviewer contract as unresolved.
-Reviewer resolution uses the final candidate of the configured review ceiling:
-call `--role reviewer` without an ephemeral implementer candidate request.
-Do not select a lower candidate for artifact, phase, project, or final review
-unless a separate reviewed contract explicitly authorizes reviewer lowering and
-defines its bounds. A `## Dispatch Profile` row alone is not such a contract.
-
-Bind every concrete managed reviewer target to the actual provider
-invocation before probing generic reviewer availability or selecting an
-execution tier. That target takes precedence over every availability, tier,
-timeout, and inline fallback.
-A concrete managed Codex target takes precedence over tier availability.
-
-- Codex: use the exact registered reviewer variant returned by
-  `providers.codex.dispatchArgs.variant` when the host can select that role.
-  If the exact role is unavailable or the current host cannot select it,
-  launch a fresh Codex child with the resolver target's explicit model,
-  reasoning effort, and canonical role instructions from
-  `.agents/agents/oat-reviewer.md`. If the fresh child cannot preserve the
-  target, use only a verified-equivalent inline route or block the review.
+A managed active-provider result is runnable only when the resolver identifies
+the final candidate of the configured review ceiling. Call `--role reviewer`
+without an ephemeral implementer candidate request. Use that result as the
+planning-parent capability threshold, not as an unconditional child pin.
+
+The default planning auto-review route is deliberate parent inheritance:
+
+1. Read launcher-owned evidence for the planning parent's configured model and
+   effort.
+2. Compare it with the resolved ceiling target on the provider's independent
+   axes.
+3. When the parent is known at or above the ceiling, omit the child model,
+   record `selection_reason: inherit`, and preserve the parent evidence.
+4. When the parent is unknown or below the ceiling, select the concrete ceiling
+   target before launch as the fail-closed exception below.
+
+Do not assume parent strength from self-report. Do not select a lower candidate
+for an exception. A `## Dispatch Profile` row alone cannot authorize reviewer
+lowering; only a separate reviewed contract may define a bounded lower
+candidate exception.
+
+For the exception route, bind every concrete managed reviewer target to the
+actual provider invocation before probing generic reviewer availability or
+selecting execution mechanics. A concrete managed Codex target takes precedence
+over generic tier availability.
+
+- Codex: when the resolver returns a materialized
+  `providers.codex.dispatchArgs.variant`, first launch that exact registered
+  reviewer variant as native `agent_type`. Only a recorded actual pre-start
+  native role-selection rejection permits a fresh Codex child with the resolver
+  target's explicit model, reasoning effort, and canonical role instructions
+  from `.agents/agents/oat-reviewer.md`. A separately pre-selected CLI route is
+  allowed only when native dispatch cannot express the complete target and no
+  child has started. If another route cannot preserve the target, use only a
+  verified-equivalent inline route or block the review.
 - Claude: require a non-empty `providers.claude.dispatchArgs.model` and put
   that exact value in the actual provider invocation as its `model` argument.
 - Cursor: treat `providers.cursor.dispatchArgs.model` as opaque and put that
   exact, unnormalized string in the actual provider invocation as its `model`
   argument.
 
-Build the actual host invocation payload before declaring the target enforced.
-On timeout, retry, or artifact rewrite/re-dispatch, reuse the same exact role or
-complete provider payload, including the exact model argument. If the host
-cannot apply the required role or model argument, fail closed or block unless
-the guarded inline-equivalence rule below applies. Never continue through a
-generic tier fallback.
+If the host cannot apply, pass, or bind the required exception role/model
+controls, fail closed or block unless verified equivalent inline controls are
+already established.
+
+Build the actual host invocation payload before declaring the exception target
+enforced. If the accepted reviewer does not conclude, continue, poll, or nudge
+the same child handle. A terminal timeout blocks or escalates without another
+launch. Only explicit pre-start rejection permits a new recorded selection.
+After an artifact rewrite following a completed review, the next review is a
+new attempt and reuses the same deliberate inheritance or exact exception
+policy. Never continue through a generic tier fallback.
 
 Workflow correctness must not require provider restart or hot reload.
 Runtime materialization may be best effort, but it is not the correctness
@@ -125,10 +158,10 @@ unavailable in the current session. Base Codex roles are allowed only for
 explicit inherit/default behavior and the documented managed-uncapped reviewer
 fallback.
 
-Inline review of a concrete managed target is permitted only after verifying
-equivalent current-host model and effort controls. Otherwise inline or base
-execution is limited to explicit inherit/default behavior or the documented
-managed-uncapped reviewer fallback.
+Inline review of a concrete managed exception target is permitted only with
+verified equivalent current-host model and effort controls. The default
+inheritance route may review inline because the planning parent is the selected
+reviewer context.
 
 The Auto Artifact-Review Loop below consumes this reviewer dispatch contract.
 Tier selection happens only after the target-preserving route is known and
@@ -269,11 +302,11 @@ Use this loop after an artifact has been written and before the calling skill ha
    - The bound controls rewrite/re-dispatch cycles after the initial review. A bound of `0` still permits the initial structured review, then surfaces residual findings without retrying.
 
 3. **Dispatch `oat-reviewer` in structured mode**
-   - When the resolver returned a concrete managed Codex target, use its exact registered reviewer or a fresh child pinned to the same model, effort, and canonical instructions. If neither is possible, run inline only with verified equivalent current-host controls; otherwise block.
-   - When the resolver returned a concrete managed Claude or Cursor target, require `providers.claude.dispatchArgs.model` or `providers.cursor.dispatchArgs.model` respectively and pass that exact value in the actual provider invocation's `model` argument. Cursor values are opaque and must not be normalized. If the host cannot apply the model argument, fail closed unless inline execution has verified equivalent controls.
-   - For explicit inherit/default behavior or the documented managed-uncapped reviewer fallback, Tier 1 uses the configured `oat-reviewer` subagent when available and authorized; Tier 2 may run the same reviewer prompt inline.
+   - Default: after the parent-at-or-above-ceiling check succeeds, omit the child model deliberately and record `selection_reason: inherit`. Tier 1 uses the configured `oat-reviewer` subagent; Tier 2 runs the same structured prompt in the planning parent.
+   - Exception: when the planning parent is unknown or below the ceiling, use the resolver's concrete ceiling target. Codex uses its exact registered reviewer or a fresh child pinned to the same model, effort, and canonical instructions after pre-start role rejection. Claude or Cursor requires the exact `providers.<provider>.dispatchArgs.model` value on the actual invocation; Cursor values remain opaque. If the host cannot preserve that target, block unless inline execution has verified equivalent controls.
+   - If an accepted child does not conclude, continue only through its existing handle. A terminal timeout blocks or escalates and cannot launch a replacement child.
    - Always set `oat_output_mode: structured`; the loop consumes `StructuredFindings` in-memory and the reviewer writes no artifact.
-   - Do not downgrade the resolved target or checklist when changing execution mechanics.
+   - Do not downgrade the selected inheritance/exception policy or checklist when changing execution mechanics.
 
 4. **Apply or offer fixes by severity**
    - If the structured review is clean, proceed to outcome recording.
@@ -282,7 +315,7 @@ Use this loop after an artifact has been written and before the calling skill ha
    - If a finding cannot be fixed within the artifact boundary, preserve it as residual and surface it before handoff.
 
 5. **Rewrite and re-dispatch within the bound**
-   - After applying fixes, rewrite the artifact and re-dispatch `oat-reviewer` with the same complete target payload, including the exact Claude or Cursor `dispatchArgs.model` argument.
+   - After applying fixes, rewrite the artifact and start a new review attempt with the same deliberate inheritance policy or complete exception payload, including any exact Claude or Cursor `dispatchArgs.model` argument.
    - Each rewrite/re-dispatch cycle consumes one retry.
    - Stop when the reviewer returns no findings or when the retry bound is exhausted.
 
@@ -330,8 +363,9 @@ Additional frontmatter keys (`oat_phase`, `oat_phase_status`, `oat_blockers`, `o
 `## Dispatch Profile` is optional and should be omitted by default. A profile
 may narrow a phase to a named ceiling at or below the project ceiling. The
 named ceiling is a maximum candidate tier, not an exact model-family or effort
-preference; the later coordinator chooses exact task targets from the complete
-configured ladder.
+preference; the implementation root chooses one exact phase-implementer target
+from the complete configured ladder. Optional nested work resolves separately
+only when the phase implementer justifies and launches it.
 
 Only include the section when the user has explicit constraints or preferences. Routine hand-tuning can be worse than runtime selection because the orchestrator has fresher phase context and host capability information at dispatch time.
 

package/assets/skills/oat-project-quick-start/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: oat-project-quick-start
-version: 2.1.14
+version: 2.1.15
 description: Use when a task is small enough for quick mode or rapid iteration is preferred. Scaffolds a lightweight OAT project from discovery directly to a runnable plan, with optional brainstorming and lightweight design.
 argument-hint: '<project-name> ["project description"]'
 oat_gateable: true
@@ -608,13 +608,21 @@ Apply the shared loop exactly:
 
 - Resolve `workflow.autoArtifactReview.plan`; only an explicit `false` skips the loop.
 - Resolve `oat_orchestration_retry_limit` from project state, defaulting to `2`.
-- For a concrete managed target, dispatch the exact registered reviewer role. If the host cannot select it, launch a fresh Codex child pinned to the resolved model and reasoning effort with the canonical reviewer instructions.
-- For Claude or Cursor, pass the exact resolver-returned
-  `providers.<provider>.dispatchArgs.model` as the actual invocation's model
-  argument. Preserve the same complete payload on timeout and retry; Cursor
-  strings remain opaque.
-- Run inline only with verified equivalent current-host model and effort controls, or for explicit inherit/default behavior or the managed-uncapped reviewer exception. If none applies, fail closed before artifact review.
-- If the reviewer times out or does not conclude, poll and nudge once, then retry the same exact role or pinned child within the retry bound. If that target-preserving retry still fails, fail closed; never downgrade the review to inline.
+- Review in the current planning parent by deliberate inheritance by default.
+  Do not launch a managed child unless launcher-owned evidence identifies that
+  parent as unknown or below the resolved reviewer ceiling.
+- For that exception only, apply the shared concrete target contract. A Codex
+  materialized variant must first be launched as the exact native `agent_type`;
+  only a recorded actual pre-start role-selection rejection permits a fresh
+  child pinned to the resolved model and effort. Claude and Cursor use the
+  exact resolver-returned `providers.<provider>.dispatchArgs.model` value;
+  Cursor strings remain opaque.
+- After acceptance, poll, nudge, or continue only through the existing reviewer
+  handle. A terminal timeout blocks or escalates without another launch.
+  Replacement eligibility is limited to explicit pre-start rejection.
+- Run an exception inline only with verified equivalent current-host model and
+  effort controls. Default inherited review runs in the planning parent. If
+  neither route applies, fail closed before artifact review.
 - Apply Critical and Important artifact-local fixes when unambiguous; offer Medium and Minor fixes instead of silently applying them.
 - Re-dispatch after rewrites until clean or the retry bound is exhausted.
 - Update the `plan` artifact row in the `## Reviews` table to `passed` when clean. If residual findings remain, preserve the row and surface the residual findings before downstream handoff.

package/assets/skills/oat-project-review-provide/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: oat-project-review-provide
-version: 1.3.14
+version: 1.3.15
 description: Use when the user explicitly asks to review an OAT project — e.g. "review project", "review the project", "run project review", or confirms a previously offered review. Do NOT auto-invoke on completed work alone. Resolves a project review scope and offers before running.
 disable-model-invocation: false
 user-invocable: true
@@ -588,10 +588,13 @@ terminal blocking review outcome: it blocks the review and does not invoke or
 trigger the fresh-child fallback. Absent findings from that terminal must not
 be parsed, interpreted, or treated as a passing review.
 
-On timeout or retry, reuse the same exact role or complete invocation payload,
-including the Claude or Cursor model argument. If the host cannot apply a
-required role or model argument, fail closed or block unless inline execution
-has verified equivalent current-host controls.
+Before acceptance, an explicit transport or role-selection rejection may retry
+with the same exact role and complete invocation payload, including the Claude
+or Cursor model argument. After acceptance, poll, nudge, or continue only
+through the existing reviewer handle. Terminal timeout, interruption, or
+`BLOCKED` blocks or escalates without another launch. If the host cannot apply
+a required role or model argument before launch, fail closed or block unless
+inline execution has verified equivalent current-host controls.
 Workflow correctness must not require provider restart or hot reload.
 Never use a managed base role because a target is missing or unavailable; a
 managed base role is forbidden except for

package/assets/skills/oat-worktree-bootstrap/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: oat-worktree-bootstrap
-version: 1.2.0
+version: 1.2.1
 description: Use when creating or resuming a git worktree for OAT implementation. Creates or validates a worktree and runs OAT bootstrap checks.
 argument-hint: '<branch-name> [--base <ref>] [--path <root>] [--existing]'
 disable-model-invocation: true
@@ -15,7 +15,8 @@ Create or resume a git worktree and prepare it for OAT development.
 ## Prerequisites
 
 - Git repository is clean enough to create/switch worktrees.
-- Node.js and pnpm are available in the target environment.
+- The toolchain required by the repository is available in the target
+  environment.
 - OAT project files exist (`.oat/`, `.agents/`).
 
 ## Mode Assertion
@@ -166,21 +167,30 @@ oat local sync "{target-path}" 2>/dev/null || true
 - Non-blocking: if sync fails or no `localPaths` are configured, bootstrap continues.
 - Does not overwrite existing paths in the target (use `--force` to override).
 
-### Step 3: Run OAT Bootstrap
+### Step 3: Resolve and Run the Repository Bootstrap
 
-Run bootstrap and readiness checks in the target worktree:
+Resolve setup from repository context; do not assume Node.js, pnpm, or any
+other ecosystem:
 
-```bash
-pnpm run worktree:init
-oat status --scope project
-pnpm test
-git status --porcelain
-```
+1. Read the applicable agent instructions and contributing/setup guidance.
+2. Inspect repository task definitions, manifests, and lockfiles.
+3. Prefer an explicit worktree bootstrap command when the repository declares
+   one. For example, this repository documents a `worktree:init` script and its
+   package-manager invocation in `AGENTS.md` and `package.json`.
+4. If no command exists, derive the minimum safe setup needed for a fresh
+   worktree from repository context: dependency setup, generated files, build,
+   and any required local configuration.
+5. State the exact selected commands and evidence before executing them.
+
+Run the selected bootstrap command, then the repository's documented readiness
+check and a proportionate baseline verification. Run `oat status --scope
+project` when the initialized repository contains an OAT project. Finish with
+`git status --porcelain`.
 
 Required behavior:
 
-- Stop immediately if `worktree:init` or `status` fails.
-- If `pnpm test` fails:
+- Stop immediately if the selected bootstrap or required status check fails.
+- If the selected baseline verification fails:
   - show a concise failure summary
   - ask the user whether to `abort` or `proceed anyway`
   - if user proceeds:

package/assets/skills/oat-worktree-bootstrap/references/worktree-conventions.md

@@ -24,14 +24,14 @@ For relative paths, resolve from repository root.
 
 ## Baseline Readiness
 
-Run baseline commands before reporting ready:
-
-```bash
-pnpm run worktree:init
-oat status --scope project
-pnpm test
-git status --porcelain
-```
+Before reporting ready, resolve the repository's bootstrap contract from its
+agent instructions, setup/contributing guidance, task definitions, manifests,
+and lockfiles. Prefer an explicit worktree bootstrap command. If none exists,
+derive the minimum safe setup for a fresh worktree from that context.
+
+Do not assume a package manager, dependency strategy, build command, or test
+command. Record the selected bootstrap and verification commands, run a
+proportionate baseline check, and finish with `git status --porcelain`.
 
 If checks fail, stop and report exact remediation.