codex-workflow-v2 2.0.0-beta.10 → 2.0.0-beta.12

package/docs/validation-report.md

@@ -1,85 +1,98 @@
-# V2 beta.10 Validation Report
+# V2 beta.12 Validation Report
 
-Release candidate `2.0.0-beta.10` was validated on 2026-08-22 with Node.js 24.17.0.
+Release candidate `2.0.0-beta.12` was validated on 2026-08-27 with Node.js 24.17.0.
 
 ## Automated release evidence
 
-- `npm run validate` passed `297/297` sequential tests with no failures, skips,
-  cancellations, or todos. The exact Signal recovery tests also passed independently through
-  `npm run test:signal-t04-recovery` (`5/5`).
-- `npm run pack:check` passed with an isolated temporary npm cache. The tarball contains 247 files;
-  package size is 1.0 MB and unpacked size is 3.6 MB.
-- `npm run smoke:downstream` packed and installed the actual beta.10 tarball in an empty project,
-  then passed the packaged CLI handshake. The first sandboxed attempt was network-blocked while
-  fetching `ajv`; the authorized network retry passed.
-- `npm run plugin:check`, the plugin-creator structural validator, the skill validator,
-  `npm run release:check`, and `git diff --check` passed. The bundled plugin source cachebuster is
-  `0.1.0+codex.20260822140058`; the packaged installer produced and read back personal installation
-  `0.1.0+codex.20260822140239` with the beta.10 recovery instructions present in source and cache.
+- `npm ci` completed from the committed lockfile with 0 reported vulnerabilities.
+- The final `npm run validate` passed `321/321` sequential tests with no failures, skips,
+  cancellations, or todos. The focused Signal T04 recovery suite passed independently (`5/5`).
+- `npm run pack:check` passed outside the filesystem-restricted sandbox. The beta.12 tarball
+  contains 269 files; package size is 955.6 kB and unpacked size is 3.7 MB.
+- `npm run smoke:downstream` packed and installed the actual beta.12 tarball in an empty temporary
+  project, then passed the packaged CLI handshake. The first sandboxed attempt was network-blocked
+  while fetching pinned `ajv`; the authorized network retry passed.
+- `npm run plugin:check`, the official Codex plugin validator, `npm run docs:pdf:check`, exact
+  `RELEASE_TAG=v2.0.0-beta.12 npm run release:check`, and `git diff --check` passed. The bundled
+  gateway cachebuster is `0.1.0+codex.20260827003726`.
 
-## beta.10 retained-review recovery evidence
+The first full post-version-bump validation exposed three failures before the Signal T04 runtime
+scenario began: a historical read-only snapshot truthfully targeted beta.11, while its replay
+assertion incorrectly required the current package version. The fix keeps the snapshot immutable at
+`2.0.0-beta.11`, binds the synthetic replay dependency to current `PACKAGE_VERSION`, and makes the
+release check verify both identities separately. The focused suite then passed `5/5`, and the final
+complete suite passed `321/321`.
 
-- Recovery still requires one clean local Task branch whose final unregistered HEAD changes exactly
-  `package.json` and `package-lock.json`, with runtime, manifest, lock, installed package, current
-  branch, and Task base branch all aligned to beta.10. Running Steps, leases, transactions, Core
-  operations, product changes in the candidate, and base payload drift fail closed.
-- A product commit removed from the current Step by corrective replan is now admissible only when
-  Core derives it from the globally validated strict-review sidecars: an intact
-  `pending → review-recorded → attestation-verified` chain, `passed` decision, exact completion
-  commit, and verified reviewer isolation. Pending review and a corrupted event-hash chain fail
-  closed in dedicated regressions.
-- The dependency candidate is recorded in `systemCommits`. Historical reviewed product commits are
-  recorded separately in `dependencyProvenanceRecoveries[].retainedHistoricalCommits`; they are not
-  relabelled as Workflow system commits. Normal Git-history validation consumes both provenance
-  classes after recovery.
-- The release check pins the exact sanitized Signal fixture: project
-  `b06d0f18f790f4521a23c770`, Milestone `MS-01M0HVCBC9DM3XQAR82T4550DA`, Task
-  `TASK-01M0HVK4YDJ3W9X0N72TYNV8WK` revision 26, status
-  `awaiting_execution_authorization`, planned Step with null current evidence, recorded system
-  commits `d6cce722…` and `198de88…`, and retained passed-review commit `acdfc803…`.
+## Continuable remediation and review-routing evidence
 
-## Isolated exact Signal replay
+- A guarded Task remains in the same Task/Step and reaches a passing strict review after five
+  consecutive failed review cycles. Attempts 1–2 are ordinary; attempts 3+ are corrective
+  diagnostics but remain executable and review-gated.
+- Attempt count no longer selects a terminal lifecycle transition. It is retained as diagnostic
+  history only; explicit `split-required` and `stop-escalate` remain the stop authorities.
+- A failed review defaults to `route=fix` (or an omitted route) and continues the same Task/Step.
+  `route=replan` is valid only with exact `planClause`, `whyFixCannotFit`, and `minimalPlanChange`
+  evidence.
+- Replan returns to ordinary `task plan-set`; objective, requirements, and acceptance remain
+  immutable, while only implementation Steps may change. The replacement Plan still passes the
+  normal Plan Risk Audit and execution-authorization gates.
+- Failed-review routing evidence is hash-chained in the public Step Review event schema. Drift,
+  malformed evidence, unrelated Knowledge changes, forged actors, and corrupt chains remain
+  fail-closed.
 
-- The real Signal Git branch and Workflow state were copied to temporary isolated state plus two
-  temporary Git worktrees. The replay modelled the actual installed transition
-  `2.0.0-beta.7 → 2.0.0-beta.10`; it did not assume beta.9.
-- With an exact dependency-only candidate over `acdfc803…`, read-only preflight returned
-  `eligible=true`, no blockers, Task revision 26, and exactly one retained historical commit:
-  `acdfc80345d2d4cd9d42af17da246701c42f0969`.
-- Fresh `next` advertised only `update dependency-provenance-recover`. Recovery advanced the copied
-  Task `26 → 27`, preserved current corrective Plan/Step posture, appended the dependency candidate
-  to `systemCommits`, and persisted `acdfc803…` under `retainedHistoricalCommits`.
-- Sequential post-recovery `status → next` returned the normal actionable route
-  `task context-refresh`, because manifest/lock changed the derived Knowledge inputs. It did not
-  return `doctor` or another dependency recovery.
-- Temporary worktrees, branches, tarball, and copied Workflow state were deleted. Direct readback
-  then confirmed the real Signal repository remained clean at `acdfc803…` and the real Task remained
-  revision 26 with no dependency-provenance recovery record.
+## Retained dependency, feasibility, and recovery evidence
 
-## Progress, replacement, and chat evidence
+- P04-A retains the canonical Milestone dependency DAG, atomic initial Plan transaction/recovery,
+  dependency-bound handoff/claim/start, legacy fail-closed policy, and unconditional structural
+  replacement shutdown.
+- P01-A retains three versioned read-only analyzers, canonical in-event evidence/hash binding,
+  exact pre-start and corrective source selection, and phase-aware freshness before claim/start/run.
+- The exact Signal T04 revision-26 fixture still proves that only a verified historical Step Review
+  can retain its completion commit across corrective replan. Pending review is never trusted, and a
+  corrupt strict-review hash chain is rejected.
+- Bounded beta.11 `task plan-integrity-recover` compatibility remains green for its exact first
+  ordinary checks-failed case. It does not edit the Plan, package manifest, or worktree and still
+  fails closed for writable-manifest scope, unrelated dirty files, binding drift, or tampering.
+- Read-only Milestone progress still preserves `T03 cancelled → T08 replacement`; project-monotonic
+  chat allocation and deterministic long-title fallback/readback remain green.
 
-- The full suite retains the read-only Milestone progress projection and exact regression
-  `T03 cancelled → T08 replacement`, including stable membership/Step ordinals.
-- Automated chat-registry coverage still proves project-monotonic `#NNN`, all compact title
-  families, long Cyrillic readback/fallback, multiple review attempts, and atomic allocation.
-- The beta.9 live App E2E evidence remains valid for the unchanged title/registry implementation:
-  Tasks `01a02928-0436-7af2-a1b9-a969226d50d9`,
-  `01a02928-3d39-7673-8e08-6d4ed0f8d554`, and
-  `01a02928-58a0-7e03-b487-f8877b7f76d8` exercised Task, Step Review A1, and Step Review A2 with
-  exact deterministic fallback and readback before archival.
+## Packaged real-agent lifecycle replay
 
-## External App-runtime limitation retained
+- A fresh disposable Git project installed the locally packed beta.12 tarball, declared the exact
+  `2.0.0-beta.12` dependency, and passed packaged `gateway handshake` plus `doctor` with protocol 2,
+  state schema 2, current dependency identity, and a clean checkout.
+- The trusted harness invoked the real packaged CLI sequentially for handshake, doctor, direct first
+  Discovery bootstrap, `status`, and fresh `next`. The resulting navigation advertised
+  `project-memory scan`.
+- `node scripts/validate-lifecycle-transcript.mjs` accepted all `10/10` post-provenance events with
+  no failed invocation, unadvertised mutation, or missing checkpoint. The semantic log SHA-256 is
+  `ab4ef10ad00e2fd9f54810ec5d0bbfb4106e1b211b3a185869d8a46787a5062d`; the raw packaged-result
+  log SHA-256 is `e693a839604c7ba2055f99e43c49c5ab63ac0cf6e790adc901db5dd8eb0ffae9`.
+- Credential-marker inspection found no writer, claim, delegation, bearer, or secret material, and
+  the disposable product checkout remained clean. Logs and external workflow state stayed outside
+  this repository.
 
-Plugin CLI installation and cache readback passed. A currently open Codex task can still retain the
-skill path injected when that task started; loading the new personal plugin version requires a new
-Codex task. This is an App runtime/catalog lifetime boundary, not a package or Workflow-state
-failure.
+This replay validates package resolution, clean bootstrap, one real mutation, and mandatory
+post-mutation navigation discipline. It does not claim a second full product Milestone replay;
+deeper remediation, P01-A, and P04-A behavior is covered by deterministic and integration tests.
+
+## beta.12 PDF release documentation evidence
+
+- Three tracked Russian PDFs were deterministically regenerated from reviewable Markdown sources
+  under `docs/pdf/sources/`; `npm run docs:pdf:check` reported an empty stale set.
+- All 24 pages were rendered and visually inspected: architecture is 6 pages, the delegated
+  chat-only guide is 8 pages, and the technical reference is 10 pages. No blank, clipped, or orphaned
+  page was found.
+- Visible titles, headers, package commands, and release gates identify beta.12. The content covers
+  continuable remediation, evidence-bound fix/replan routing, Milestone dependency authority,
+  P01-A mechanical feasibility, C1 credentials, external-sealed review, Plan-integrity compatibility,
+  structural-replacement shutdown, and the limited derived-graph role of `codebase-memory-mcp`.
 
 ## Not claimed
 
-- No npm publication, Git tag, push, or release commit was performed by validation.
-- No real Signal Workflow mutation, package update, branch change, or manual external-state edit was
-  performed.
-- The isolated replay proves the exact recovery path before publication; a real Signal update must
-  still install the published beta.10 package and follow fresh project-local `handshake → doctor →
-  status → next → preflight → advertised recovery`.
+- Validation itself performs no npm publication, Git tag, push, Signal Workflow mutation, or local
+  plugin reinstall. Tagging and remote push are separate actions after the exact candidate gates.
+- Structural replacement remains intentionally disabled; beta.12 does not claim P04-B replacement
+  materialization or completed-Step adoption.
+- A real project must install the published exact beta.12 package, update/reinstall the bundled
+  gateway, and follow fresh project-local `handshake → doctor → status → next` navigation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-workflow-v2",
-  "version": "2.0.0-beta.10",
+  "version": "2.0.0-beta.12",
   "description": "Requirements-first Codex development workflow with local state and explicit Git ownership.",
   "repository": {
     "type": "git",
@@ -34,6 +34,8 @@
     "references",
     "plugins",
     "docs",
+    "scripts/generate-pdf-docs.py",
+    "scripts/run-pdf-docs.mjs",
     "README.md"
   ],
   "scripts": {
@@ -46,6 +48,8 @@
     "pack:check": "npm run build && npm pack --dry-run",
     "smoke:downstream": "npm run build && node scripts/downstream-smoke.mjs",
     "plugin:check": "node scripts/validate-plugin.mjs",
+    "docs:pdf": "node scripts/run-pdf-docs.mjs",
+    "docs:pdf:check": "node scripts/run-pdf-docs.mjs --check",
     "release:check": "node scripts/release-check.mjs",
     "publish:release": "node scripts/publish.mjs"
   },

package/plugins/codex-workflow-gateway/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-workflow-gateway",
-  "version": "0.1.0+codex.20260822140058",
+  "version": "0.1.0+codex.20260827003726",
   "description": "Thin personal Codex gateway for exact project-local Codex Workflow V2 packages and codebase-memory-mcp.",
   "author": {
     "name": "Codex Workflow Maintainers"

package/plugins/codex-workflow-gateway/references/protocol.md

@@ -1,6 +1,12 @@
 # Gateway Protocol V2
 
-## beta.10 coordinator projections, retained review provenance, and chat registry
+## beta.12 continuable remediation, coordinator projections, and retained recovery compatibility
+
+- When fresh `next` advertises `task plan-integrity-recover`, consume its exact Task revision,
+  Step, actor, and writer-token contract. This route is valid only for the Core-derived
+  first-failure missing-root-npm-script evidence and must be followed by fresh `status -> next`.
+  It records a replan posture without changing Plan or product files; corrective yield and the
+  existing state-bound corrective-replan Human gate remain mandatory.
 
 - `update dependency-provenance-preflight --id <TASK-ID>` is read-only. The matching
   `update dependency-provenance-recover --id <TASK-ID> --expected-revision <N> --actor <ACTOR>
@@ -38,7 +44,7 @@ Current capability set:
 - `delegated-approval-v1`
 - `task-knowledge-rebind-v1`
 - `task-context-refresh-v1`
-- `terminal-task-replacement-transaction-v1`
+- `structural-task-replacement-disabled-v1`
 - `project-composite-transaction-journal-v1`
 - `corrective-plan-audit-v1`
 - `safe-update-preflight-v1`
@@ -52,9 +58,12 @@ Current capability set:
 - `step-remediation-circuit-breaker-sidecar-v1`
 - `milestone-scope-change-sidecar-v1`
 - `milestone-membership-integrity-v1`
+- `milestone-task-dependency-dag-v1`
+- `milestone-initial-plan-transaction-v1`
 - `task-c1-handoff-sidecar-v1`
+- `task-mechanical-feasibility-v1`
 - `semantic-plan-risk-audit-v2`
-- `guarded-remediation-hard-stop-v1`
+- `guarded-remediation-continuation-v1`
 - `milestone-reverse-membership-integrity-v1`
 - `task-c1-handoff-bundle-v2`
 - `alpha6-adoption-posture-v1`
@@ -62,10 +71,18 @@ Current capability set:
 - `milestone-initial-assembly-v1`
 - `milestone-initial-assembly-navigation-v2`
 - `milestone-autonomy-contract-v1`
+- `milestone-autonomy-content-refresh-v1`
 - `milestone-autonomous-membership-evolution-v1`
 - `task-c1-derived-worker-actor-v1`
 - `guarded-corrective-auditor-routing-v1`
+- `corrective-decision-context-recovery-v1`
+- `remediation-mode-recovery-v1`
 - `plan-proof-obligations-v1`
+- `bounded-plan-integrity-recovery-v1`
+- `corrective-yield-journal-v1`
+- `corrective-replan-journal-v1`
+- `corrective-replan-human-gate-v1`
+- `corrective-replan-protocol-v2`
 
 Protocol `1` and schema `2` remain valid only because alpha.7 is additive. The gateway must
 not claim compatibility if canonical entity shapes or non-additive command semantics change.
@@ -152,18 +169,23 @@ one hostile counterexample, expected safe result, and exact executable evidence
 unguarded Plan. Missing, stale, `split-required`, or `stop-escalate` evidence blocks
 authorization.
 
-For guarded remediation, `next.correctivePlanGate` or the runtime gate blocks a third
-ordinary retry on the same guarded Step until a current corrective decision exists. Record it
-with:
+For guarded remediation, the first two failed cycles are recorded as `ordinary` and later cycles as
+`corrective`. This mode is diagnostic: a third or later retry remains executable and still requires
+a fresh strict review. A finding defaults to `route=fix`; `route=replan` is accepted only with exact
+Plan-conflict evidence and routes to ordinary `task plan-set` for implementation-Step changes.
+
+An explicit corrective disposition can still be recorded when the actor deliberately chooses a
+stop, split, or compatible historical recovery route:
 
 ```text
 codex-workflow task corrective-decision --repo <git-root> \
   --id <TASK-ID> --step <STEP-ID> --expected-revision <REVISION> --file <decision.json>
 ```
 
-Only `continue-fix` permits bounded continuation. `replan-required`, `split-required`, and
-`stop-escalate` are stop or redirection decisions. If the third corrective review fails, a
-fourth run is prohibited; only split or stop may be recorded.
+`continue-fix` permits continuation; `replan-required`, `split-required`, and `stop-escalate` are
+explicit stop or redirection decisions. They are never inferred from attempt count. Without such an
+explicit decision, another failed strict review continues the same Task through its evidence-bound
+`fix`/`replan` route.
 
 ## Context refresh
 

package/plugins/codex-workflow-gateway/skills/codex-workflow-gateway/SKILL.md

@@ -50,6 +50,17 @@ pending/corrupt transaction. After success run sequential `status` then `next` a
 returned lifecycle action; Knowledge reconciliation or atomic Task context refresh may legitimately
 be next because the dependency files changed.
 
+The beta.11 bounded Plan-integrity route prevents a known impossible check from consuming a second
+ordinary remediation attempt. Use `task plan-integrity-recover` only when fresh `next` advertises
+it for the exact failed Task/Step/revision. Require `state=eligible`, no blockers, one first
+`checks-failed` remediation, an exact missing root npm script, `package.json` outside the Step's
+`allowedWrites`, and a dirty-file set confined to that Step. Pass the exact returned actor and the
+active writer token when the C1 contract requires it. The recovery records only a bound early
+`replan-required` decision: it does not edit the Plan or worktree. Then follow fresh `next` through
+`task corrective-yield` and the existing Human-confirmed corrective-replan flow. Never repeat
+`task run` merely to manufacture the second failure, and never invoke this recovery for a generic
+test failure, a writable manifest, or unconfined changes.
+
 If any step fails, report the concrete diagnostic. Do not load workflow
 semantics from this skill.
 
@@ -85,9 +96,12 @@ Autonomy Grant. Never infer eligibility from the Plan yourself; if Core returns
 `contextRefreshBlocked.unsafeDifferences`, use the ordinary visible Knowledge Map flow.
 
 When `next` reports terminal `split-required`, follow `docs/split-required-recovery.md` from the
-installed package. The only valid continuation is the exact `task replacement-materialize`
-transition (or creation of its one ready Discovery when requested). Never rebind, refresh, replan,
-authorize, or resume the historical Task, and never emulate the membership changes manually.
+installed package. P04-A returns `doctor` with blocked action `task replacement-materialize`,
+diagnostic `STRUCTURAL_REPLACEMENT_REQUIRED`, and
+`replacementGate.structuralReplacementAvailable=false`. Stop without invoking the retained
+command shape or consuming a replacement Discovery. Never rebind, refresh, replan, authorize,
+resume, cancel, or manually replace the historical Task. Continue only after a later P04-B/P05
+package explicitly advertises a topology-preserving replacement capability.
 
 When `next` returns `milestone initial-assembly`, execution is unavailable. Follow only the
 advertised `linked-task-assembly.commands` (`discovery start` and `discovery materialize`) until all
@@ -362,9 +376,12 @@ only for membership changes; any change to outcome, success signal, acceptance,
 discovery, or base branch requires the ordinary human scope-change gate. Never self-renew or
 replace the contract.
 
-After two failed Task reviews, follow `next.correctivePlanGate`: obtain a distinct read-only
-corrective Auditor result and pass it through `--corrective-audit-file`. Do not continue for
-replan, split, or stop decisions.
+Repeated failed Task reviews remain on the same Task and do not require a separate corrective
+Plan audit based only on count. Follow fresh `next`: ordinary findings default to `route=fix`;
+`route=replan` is valid only with the exact Plan clause, obstruction, and minimal Plan change
+retained by Core. A remediation Plan may change implementation Steps but must preserve the Task
+objective, requirements, and acceptance. Explicit split or stop decisions still stop ordinary
+continuation.
 
 When `next.strictStepReview.recommendedMode` is `external-sealed`, do not launch the nested local
 reviewer from inside a Codex App sandbox. Run the advertised read-only `task step-review-packet`,

package/references/state-machine.md

@@ -37,16 +37,17 @@ bindings, supersedes execution authorization, and returns the Task to
 `awaiting_execution_authorization`. It cannot run while a Step is `in_progress` or while the
 Task is `blocked`; unrelated blocks must be resolved through their owning transition.
 
-For guarded remediation, two ordinary remediation attempts are allowed. Corrective posture is
+For guarded remediation, the first two attempts use mode `ordinary`; later attempts use mode
+`corrective`. Corrective posture is
 derived from the guarded Step, current Plan Risk Audit, remediation history, and
 corrective-decision history rather than from `Task.status` alone, so the same gate survives
-content-only Knowledge refresh, Task Knowledge rebind, and later reauthorization. A third
-ordinary retry is blocked until a current corrective decision exists for the same Step and
-Plan binding. `continue-fix` allows exactly the third corrective attempt; `replan-required`
-requires an actual new Plan posture before execution; `split-required` and `stop-escalate`
-stop ordinary execution. A failed third corrective attempt is a hard stop: `next` must
-report the stop without throwing, no fourth run is allowed, and no new `continue-fix` or
-`replan-required` decision is accepted.
+content-only Knowledge refresh, Task Knowledge rebind, and later reauthorization. Attempt count
+does not block execution: every new completion still requires exact strict-review evidence, while
+the same Task may continue until review passes. A failed finding defaults to `route=fix`.
+`route=replan` requires exact Plan-conflict evidence and routes to `task plan-set`; it may change
+implementation Steps but not the Task objective, requirements, or acceptance. Explicit
+`replan-required`, `split-required`, and `stop-escalate` decisions retain their redirect/stop
+semantics and outrank ordinary continuation.
 
 Milestone authorization is bound to its Plan and membership revision. Plan amendments
 supersede authorization. Milestone validation and acceptance are bound to the current base
@@ -78,20 +79,24 @@ the grant's Milestone. Every added source must match the Plan, and removals, can
 wildcard or directory targets, existing source category/scope/authority changes, gaps, and
 conflicts fail closed before any state write. `next` exposes the composite option only when the
 full predicate passes and otherwise reports concrete unsafe differences. Both update paths journal
-`state.json`, `plan.json`, and `scope-change-events.jsonl` together. Membership integrity is validated
-before scheduling, Task start, Milestone validation, scope change, and repository `next`.
+`state.json`, `plan.json`, and `scope-change-events.jsonl` together. Initial Plan publication uses
+the same recovery journal for `state.json` and `plan.json`. Membership and dependency integrity is
+validated before scheduling, handoff, claim (before lease acquisition), Task start, Milestone
+validation, scope change, and repository `next`.
 The same guard scans in reverse and blocks every live Task whose `milestoneId` is absent from
 the Milestone's required/waived/cancelled classification.
 
 `C1` coordination is machine-bound but local: `task handoff-prepare` returns a one-time claim
 token and prompt bound to a stable handoff ID, revision, context hashes, Milestone positions,
-delegate/grant, expected next action, and expiry. `task claim` validates those bindings and
+Milestone revision, membership revision, Milestone Plan hash, delegate/grant, expected next action,
+and expiry. `task claim` validates those bindings and
 activates claimant-only mutation; terminal `task handback-create` returns result, evidence,
 review, knowledge, limitation, and recommended-next bindings. Milestone Tasks must be claimed
 before start. If no target is supplied, Core derives `agent:worker:<task-id>`. No part of this
 contract requires or proves a physically separate Codex thread.
 
-Repository-level scheduling respects current Milestone membership. An unstarted linked Task
-is eligible only for an `active` Milestone with `required` disposition. Historical unstarted
+Repository-level scheduling respects current Milestone membership and its canonical dependency
+DAG. A linked Task is eligible only for an `active` Milestone with `required` disposition after
+all required predecessors are `merged`. Historical unstarted
 Tasks from `waived`, `cancelled`, accepted, or cancelled Milestone paths cannot shadow the
 Milestone/repository transition returned by `next`.

package/references/validation-and-review.md

@@ -13,10 +13,17 @@ upgrade, concurrent state includes deterministic races, restart/replay claims in
 windows, and provider integrations include failure injection plus hidden-default checks.
 Happy-path green tests do not replace this evidence.
 
-After two failed independent reviews, another corrective Plan requires a distinct Auditor.
-The Auditor covers every latest finding and records `continue-fix`, `replan-required`,
-`split-required`, or `stop-escalate`. Only `continue-fix` may be passed to `task plan-set`
-through `--corrective-audit-file`; the other decisions stop implementation.
+Failed review does not impose a Task-lifecycle attempt limit. The first two guarded remediation
+events are recorded as `ordinary`; later events are `corrective`, remain executable, and each
+requires another fresh strict review. A failed-review finding defaults to `route=fix`. It may use
+`route=replan` only with exact `planClause`, `whyFixCannotFit`, and `minimalPlanChange` evidence;
+Core then routes to ordinary `task plan-set`, where only implementation Steps may change. Task
+objective, requirements, and acceptance remain immutable during remediation.
+
+The explicit corrective-decision journal remains available for intentional `continue-fix`,
+`replan-required`, `split-required`, and `stop-escalate` dispositions and for compatible historical
+recovery. It is not an attempt-count gate. Explicit split and stop decisions still stop or redirect
+execution; repeated review failure alone does not create either decision.
 
 The strict path is `task review-launch`. It starts an ephemeral Codex process with user
 configuration and rules ignored, a read-only sandbox, structured output, and an attempted

package/schemas/authorization-event.schema.json

@@ -20,7 +20,8 @@
     "headCommit": { "$ref": "#/$defs/nullableHash" },
     "reason": { "type": "string" },
     "authorizationMode": { "enum": ["human", "delegated"] },
-    "delegation": { "$ref": "#/$defs/delegation" }
+    "delegation": { "$ref": "#/$defs/delegation" },
+    "mechanicalFeasibility": { "$ref": "#/$defs/mechanicalFeasibility" }
   },
   "allOf": [
     {
@@ -50,6 +51,68 @@
           ]
         }
       }
+    },
+    "mechanicalFeasibility": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "schemaVersion", "taskId", "evaluatedTaskRevision", "briefHash", "planHash",
+        "sourceKind", "sourceBranch", "evaluatedHead", "baseCommit", "analyzerSetHash",
+        "analyzerInputHash", "analyzers", "findings", "decision"
+      ],
+      "properties": {
+        "schemaVersion": { "const": 1 },
+        "taskId": { "type": "string", "pattern": "^TASK-[0-9A-HJKMNP-TV-Z]{26}$" },
+        "evaluatedTaskRevision": { "type": "integer", "minimum": 1 },
+        "briefHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "planHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "sourceKind": { "enum": ["pre-start-base", "corrective-task-workspace"] },
+        "sourceBranch": { "type": "string", "minLength": 1 },
+        "evaluatedHead": { "type": "string", "pattern": "^[a-f0-9]{40,64}$" },
+        "baseCommit": { "$ref": "#/$defs/nullableHash" },
+        "analyzerSetHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "analyzerInputHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "analyzers": {
+          "type": "array",
+          "minItems": 3,
+          "maxItems": 3,
+          "items": { "$ref": "#/$defs/mechanicalAnalyzer" }
+        },
+        "findings": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/mechanicalFinding" }
+        },
+        "decision": { "enum": ["clear", "blocked"] }
+      }
+    },
+    "mechanicalAnalyzer": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["analyzerId", "analyzerVersion"],
+      "properties": {
+        "analyzerId": {
+          "enum": ["wf2.root-npm-script", "wf2.exact-output-path", "wf2.exact-predecessor-path"]
+        },
+        "analyzerVersion": { "const": 1 }
+      }
+    },
+    "mechanicalFinding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "analyzerId", "analyzerVersion", "result", "stepId", "subject", "evidence", "reasonCode"
+      ],
+      "properties": {
+        "analyzerId": {
+          "enum": ["wf2.root-npm-script", "wf2.exact-output-path", "wf2.exact-predecessor-path"]
+        },
+        "analyzerVersion": { "const": 1 },
+        "result": { "enum": ["pass", "blocked", "unverified"] },
+        "stepId": { "type": "string", "pattern": "^STEP-[0-9]{3}(?:-[A-Z0-9-]+)?$" },
+        "subject": { "type": "string" },
+        "evidence": { "type": "string", "minLength": 1 },
+        "reasonCode": { "type": "string", "pattern": "^[A-Z0-9_]+$" }
+      }
     }
   }
 }

package/schemas/corrective-decision-event.schema.json

@@ -22,7 +22,7 @@
     "eventId": { "type": "string", "minLength": 1 },
     "taskId": { "$ref": "#/$defs/taskId" },
     "stepId": { "$ref": "#/$defs/stepId" },
-    "triggeringAttemptCount": { "type": "integer", "minimum": 3 },
+    "triggeringAttemptCount": { "type": "integer", "minimum": 2 },
     "decision": {
       "enum": ["continue-fix", "replan-required", "split-required", "stop-escalate"]
     },
@@ -38,18 +38,63 @@
       "items": { "type": "string", "minLength": 1 }
     },
     "planHash": { "$ref": "#/$defs/hash64" },
+    "recoveryBasis": { "const": "plan-integrity" },
+    "planIntegrityEvidence": { "$ref": "#/$defs/planIntegrityEvidence" },
     "previousEventHash": { "$ref": "#/$defs/nullableHash64" },
     "recordedAt": { "type": "string", "format": "date-time" },
     "eventHash": { "$ref": "#/$defs/hash64" }
   },
-  "anyOf": [
+  "allOf": [
+    {
+      "if": { "properties": { "triggeringAttemptCount": { "const": 2 } }, "required": ["triggeringAttemptCount"] },
+      "then": {
+        "required": ["recoveryBasis", "planIntegrityEvidence"],
+        "properties": { "decision": { "const": "replan-required" } }
+      },
+      "else": {
+        "not": { "anyOf": [{ "required": ["recoveryBasis"] }, { "required": ["planIntegrityEvidence"] }] }
+      }
+    },
+    {
+      "anyOf": [
     { "properties": { "coveredFindingIds": { "minItems": 1 } } },
     { "properties": { "coveredEventIds": { "minItems": 1 } } }
+      ]
+    }
   ],
   "$defs": {
     "taskId": { "type": "string", "pattern": "^TASK-[0-9A-HJKMNP-TV-Z]{26}$" },
     "stepId": { "type": "string", "pattern": "^STEP-[0-9]{3}(?:-[A-Z0-9-]+)?$" },
     "hash64": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
-    "nullableHash64": { "type": ["string", "null"], "pattern": "^[a-f0-9]{64}$" }
+    "nullableHash64": { "type": ["string", "null"], "pattern": "^[a-f0-9]{64}$" },
+    "gitOid": { "type": "string", "pattern": "^[a-f0-9]{40,64}$" },
+    "stringList": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": { "type": "string", "minLength": 1 }
+    },
+    "planIntegrityEvidence": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "kind", "taskRevision", "remediationEventId", "remediationEventHash",
+        "manifestPath", "manifestHash", "gitHead", "stepDefinitionHash",
+        "missingScripts", "checkCommands", "changedFiles", "conflictHash"
+      ],
+      "properties": {
+        "kind": { "const": "missing-npm-script-outside-allowed-writes" },
+        "taskRevision": { "type": "integer", "minimum": 1 },
+        "remediationEventId": { "type": "string", "minLength": 1 },
+        "remediationEventHash": { "$ref": "#/$defs/hash64" },
+        "manifestPath": { "const": "package.json" },
+        "manifestHash": { "$ref": "#/$defs/nullableHash64" },
+        "gitHead": { "$ref": "#/$defs/gitOid" },
+        "stepDefinitionHash": { "$ref": "#/$defs/hash64" },
+        "missingScripts": { "$ref": "#/$defs/stringList", "minItems": 1 },
+        "checkCommands": { "$ref": "#/$defs/stringList", "minItems": 1 },
+        "changedFiles": { "$ref": "#/$defs/stringList" },
+        "conflictHash": { "$ref": "#/$defs/hash64" }
+      }
+    }
   }
 }

package/schemas/milestone-scope-change-event.schema.json

@@ -50,7 +50,12 @@
       "properties": {
         "taskId": { "$ref": "#/$defs/taskId" },
         "disposition": { "enum": ["required", "waived", "cancelled"] },
-        "reason": { "type": "string" }
+        "reason": { "type": "string" },
+        "dependsOnTaskIds": {
+          "type": "array",
+          "uniqueItems": true,
+          "items": { "$ref": "#/$defs/taskId" }
+        }
       }
     },
     "scopeSnapshot": {

package/schemas/milestone.schema.json

@@ -51,7 +51,12 @@
       "properties": {
         "taskId": { "$ref": "#/$defs/taskId" },
         "disposition": { "enum": ["required", "waived", "cancelled"] },
-        "reason": { "type": "string" }
+        "reason": { "type": "string" },
+        "dependsOnTaskIds": {
+          "type": "array",
+          "uniqueItems": true,
+          "items": { "$ref": "#/$defs/taskId" }
+        }
       }
     }
   }