codex-workflow-v2 2.0.0-beta.13.9 → 2.0.0-beta.14.1

package/README.md

@@ -1,408 +1,47 @@
 # Codex Workflow V2
 
-Self-contained, requirements-first workflow for Codex. This directory can be moved into a
-separate repository: runtime code, tests, templates, schemas, plugin source, and release
-automation do not import anything from the parent V1 project.
+A requirements-first workflow for one user, one machine and one consumer project that always updates to the latest release. Core binds plans, permissions, checks, reviews and Git history; the gateway coordinates agents through the current local CLI.
 
-## What V2 guarantees
+The project is a controlled beta. Integrity guards do not by themselves prove that every valid task can finish. Accepted A1 route fixes establish only their tested continuation paths; broad autonomy and the documented runtime limitations remain bounded claims, not universal completion guarantees.
 
-- exact npm dependency with no `postinstall` mutation;
-- no downstream `.codex`, `.tasks`, `.increments`, manifest, or overlay;
-- repository files are the only durable project knowledge;
-- derived workflow state lives under `$CODEX_HOME/workflow-state/v2`;
-- Discovery precedes Task or Milestone identifiers and branches;
-- Project Knowledge Map approval binds Plans to current canonical files;
-- safe Task Plan knowledge rebind preserves Step evidence and requires fresh authorization;
-- delegated content-only context refresh composes map refresh, rebind, and reauthorization
-  without hiding classification changes;
-- optional `codebase-memory-mcp` product and workflow graph bindings with explicit fallback;
-- one writer lease and one atomic Git commit per completed Step;
-- execution authorization with a bounded, versioned mechanical Plan-feasibility payload, independent
-  review, and a state-bound human final-acceptance gate;
-- automatic release of the active Task writer lease when `result-set` enters human final acceptance,
-  followed by fresh credential acquisition for merge;
-- high-risk Plan guidance plus evidence-bound `fix`/`replan` review routing without an attempt-count stop;
-- executable proof obligations with hostile counterexamples for every guarded failure mode;
-- read-only update preflight for clean checkout, running-Step, and writer-lease blockers;
-- beta.10 bounded recovery for one exact dependency-only HEAD, including retained product commits
-  proven by intact passed strict-review and reviewer-attestation chains;
-- beta.12.6 active-downstream-proof update bridge: one exact dependency-only Task HEAD can be
-  registered while the already-classified proof work remains dirty and its Step remains active;
-- beta.12.7 stranded-replan recovery: an accidental post-recovery Knowledge rebind cannot resurrect
-  the rejected Plan, and exact dirty bytes can be adopted by one newly authorized owning Step;
-- bounded first-failure Plan-integrity recovery for legacy/in-flight contradictions that could not
-  be rejected by the current pre-authorization feasibility gate;
-- beta.12.17 Plan-integrity update transport accepts any coherent exact beta.12 source from .11 up
-  to the current runner, provided declared, locked, installed, Task-branch, and Milestone-base
-  versions agree; this removes the release-specific source-version literal without weakening the
-  dirty-worktree, lease, transaction, or dependency-only commit boundary;
-- beta.12.18 preserves historical check-support decisions against the Plan that produced them and
-  recognizes one exact post-rebind Plan that explicitly adopts every previously derived support
-  path; the same dependency-only transport can therefore resume the stranded Task without a Human
-  approval, retroactive evidence mutation, or implicit scope carry-over;
-- beta.13 replaces secret-bearing CLI credentials with host-safe local references, atomically
-  records failed-Step continuation while preserving dirty bytes, and routes continuation by stable
-  mechanical/reviewer causes instead of attempt count. It also validates transitive component
-  owners and derives explicit production-edge obligations from multi-Step `runtime-composition`
-  PRA classifications before authorization, publishes a Signal-observed route-class
-  catalog with explicit action-level witness status, defaults `status` to a bounded projection, prepares isolated reviewer runtime evidence,
-  and requires an explicit ordinary/security review mode;
-- beta.12.19 closes the previous execution-boundary gap: after dependency registration, Knowledge
-  rebind, PRA and authorization, `next` and `task run` share one fail-closed authority for adopting
-  the exact registered dirty set. HEAD, Plan/rebind chain, file list, content hash, historical event
-  and current Step scope must all match; any byte or scope drift routes to `doctor`;
-- beta.12.16 check-support authority: migration checksum/catalog modules imported directly by an
-  approved check must be owned by the producing Step; an already-running Step receives only the
-  exact machine-proved support path without a Human replan or a synthetic second failure;
-- beta.13.7 retains a completed Step's carryover as verified history so later Steps can
-  replan normally, and binds corrective continuation to the original Worker.
-- beta.13.6 binds dirty work retained by a mechanical root-cause replan to its source failure,
-  exact replacement Plan and audit, current authorization, unchanged HEAD and content hash;
-  navigation and execution share that assessment instead of demanding a clean checkout after replan;
-- read-only Milestone progress projection with stable membership ordinals and replacement links;
-- one project-monotonic `#NNN` chat registry with compact titles, exact readback, and deterministic fallback;
-- narrow, read-only alpha.6 strict-review rescue preflight for the lifecycle deadlock fixed in alpha.7;
-- optional time-bound delegated approval with project/Milestone/Task scope and an explicit audit trail;
-- one bounded Milestone Autonomy Contract for approvals, guarded content-only context refresh,
-  and membership-only Task-graph evolution;
-- audited remediation topology for an unstarted Task whose current Plan Risk Audit records
-  `stop-escalate`: Core may append exactly one upstream Task, inherit the blocked Task's exact
-  merged dependency frontier, and derive replacement Milestone/Task authority without a new
-  human approval while preserving outcome, success signal, acceptance, and checks;
-- bounded recovery of one previously passed and accepted Step commit omitted by a corrective Plan,
-  without rewriting Git history or adopting the old Step into the replacement Plan;
-- Milestones aggregate already merged Tasks on the base branch, without an integration branch;
-- V1 transition is snapshot-only and never performs semantic import.
+## Use
 
-V2 is intentionally designed for one user on one machine. Remote coordination and
-cross-machine synchronization are not part of its contract.
+The supported runtime is exactly Node **24.17.0** for development, CI and the installed Workflow reviewer. Other patch versions and majors are unsupported. The package engines, `.node-version` and `.nvmrc` share this exact pin; validation rejects runtime or configuration drift before acquiring its lock or writing build outputs.
 
-## Install and verify
+Install the chosen **exact published version** as a development dependency with `--save-exact`. The declared version, lockfile and installed package must agree. Invoke its local CLI, not a global or external rescue runner:
 
-Node.js 22 or newer is required. Consumers pin the exact package version:
-
-```bash
-npm install --save-dev --save-exact codex-workflow-v2@2.0.0-beta.13.9
-npx codex-workflow gateway handshake --repo .
-npx codex-workflow doctor --repo .
-```
-
-Maintainers run:
-
-```bash
-npm install
-npm run validate
-npm run pack:check
-npm run smoke:downstream
-npm run plugin:check
-npm run release:check
-```
-
-## Protocol 2 Task flow
-
-The CLI emits JSON. Every update after creation requires the current state revision.
-
-For a fresh alpha.7 project, registration writes the adoption posture automatically. For an
-existing schema 2 project, apply adoption before execution:
-
-```bash
-codex-workflow update preflight --repo .
-codex-workflow state adoption-prepare --repo .
-codex-workflow state adoption-apply --repo . --actor user:owner --confirmation-code ADA-...
-```
-
-Do not use `state migrate` for schema-2 adoption.
-
-```bash
-codex-workflow project-memory scan --repo .
-codex-workflow project-memory approve --repo . --expected-revision 1 --file selections.json
-codex-workflow discovery start --repo . --goal "..." --outcome "..." \
-  --scope "..." --acceptance "..."
-codex-workflow discovery materialize --repo . --id DISC-... \
-  --expected-revision 1 --kind task --title "..."
-codex-workflow task plan-set --repo . --id TASK-... \
-  --expected-revision 1 --file plan.json --risk-audit-file plan-risk-audit.json
-codex-workflow task authorize --repo . --id TASK-... \
-  --expected-revision 2 --actor user
-codex-workflow task start --repo . --id TASK-... \
-  --expected-revision 3 --workspace-owner local
-codex-workflow task run --repo . --id TASK-... --step STEP-001 \
-  --expected-revision 4 --owner worker
-# Worker changes only allowed files and leaves them uncommitted.
-codex-workflow task step-complete --repo . --id TASK-... --step STEP-001 \
-  --expected-revision 5 --writer-token <TOKEN-FROM-TASK-RUN>
-```
-
-`task run` returns the writer token and Worker context. The Worker must not stage or commit.
-`task step-complete` runs configured checks, creates the workflow-owned atomic commit, and
-either records completion immediately or leaves the Step non-terminal for `task step-review`
-when the current Plan Risk Audit marks it for strict review.
-After a passing final Task review, fresh `next` makes `task result-set` lease-bound. Pass the active
-writer token (and the exact claimant as `--actor` for C1). Success releases that lease before the
-unbounded human final-acceptance pause. After acceptance, do not reuse the consumed token; follow
-fresh `next` through `task writer-credential-replace` before merge or merge confirmation.
-When `next` includes `gitMutationPolicy`, obtain bounded permission to write Git metadata
-before the first call of that exact transition. For `task start`, the policy applies only when
-you invoke `--workspace-owner local`; for `task step-complete`, `task merge`, and
-`task sync-base`, the advertised transition itself is Git-writing.
-For `task step-review`, keep `--actor` equal to the exact C1 claimant or required actor from
-`next`; the independent reviewer runs inside Core and is not passed as `--actor`.
-
-The Plan Risk Audit is mandatory for every new alpha.7 Task before execution authorization,
-including a positive `approved` decision for a Plan with no guarded Steps. The audit sidecar
-must identify a Plan author and an independent auditor, classify every current Step exactly
-once, describe guarded failure modes, and bind required evidence to exact executable Step
-checks. Every guarded failure mode additionally needs one `proofObligations` entry containing
-the hostile `counterexample`, expected safe result, and an exact executable evidence command.
-`split-required` and `stop-escalate` block authorization. Historical alpha.6 audit sidecars
-remain readable for strict-review recovery, but newly recorded audits must use proof obligations.
-
-Before every new Task execution authorization, Core also runs a read-only P01-A mechanical
-feasibility check. Version 1 recognizes only an exact root `npm run <literal-script>` check and
-an exact `path:<repository-relative POSIX path>` output, including exact transitive Step-provider
-proof. A proved missing script/path outside responsible write bounds blocks authorization and
-routes back to `task plan-set`. Unsupported shell, prose, flags, arguments, and semantic coverage
-remain `unverified`; they are neither accepted as proof nor rejected. A clear payload, its
-canonical hash, and evaluated Git HEAD are stored atomically in the execution authorization event.
-`claim`, `start`, and execution entry points reject stale base HEAD, Plan/input binding, base
-commit, or Task ancestry before acquiring new execution authority.
-
-`task review-launch` starts the strict read-only reviewer after submission and atomically records
-the returned review. If C1 handoff is active, keep `--actor` equal to the current claimant or
-required actor from `next`; the reviewer identity remains internal to the compound route. If a completed Step changes approved project
-knowledge, reconcile and approve the map, then run `task knowledge-rebind --repo . --id
-TASK-... --expected-revision ...`. The rebind changes no Step definition, preserves runtime
-status and evidence, supersedes execution authorization, and requires `task authorize`
-before another Step or submission. Use `next` after transitions.
-
-### Protocol-v2 corrective replan
-
-When strict review records an exact `replan-required` decision, legacy `task plan-set` is no
-longer an executor for that posture. Follow the command returned by `next`:
-
-```bash
-# Required first when the Task still has a C1 claimant/writer lease.
-codex-workflow task corrective-yield --repo . --id TASK-... \
-  --expected-revision ... --actor agent:claimant --writer-token <TOKEN> --reason "..."
-
-codex-workflow task corrective-replan-prepare --repo . --id TASK-... \
-  --file corrective-candidate.json
-# Show the returned candidate-bound code to the Human principal. Then persist only the returned
-# gate object and submit the same candidate again.
-codex-workflow task corrective-replan-confirm --repo . --id TASK-... \
-  --file corrective-candidate.json --gate-file human-gate.json --confirmation-code <CODE>
-codex-workflow task corrective-replan-execute --repo . --id TASK-... \
-  --file corrective-candidate.json --credential-file corrective-credential.json
+```sh
+node node_modules/codex-workflow-v2/dist/src/cli.js gateway handshake --repo .
+node node_modules/codex-workflow-v2/dist/src/cli.js status --repo .
+node node_modules/codex-workflow-v2/dist/src/cli.js next --repo .
 ```
 
-Prepare and failed confirmation are non-mutating. Execution uses a Task-exclusive journal,
-apply-or-confirm roll-forward and two readbacks. A nonterminal journal makes `status`/`next`
-return the exact `task corrective-replan-recover` or `task corrective-yield-recover` command;
-read-only routes never recover implicitly. Protocol and lifecycle epoch are `2`, transition
-definition/catalog format is `4`, and state schema remains `2`. Intact protocol-v1 adoption
-evidence remains readable without rewriting it; new adoption events are always protocol v2.
+Follow the returned current action and its `--help`; refresh state after each successful mutation. Do not copy revisions, confirmation codes or credentials from examples. New project setup begins through the current Discovery flow. The gateway resolves the installed package and never copies Workflow assets into the project.
 
-An active writer lease without a C1 claim does not make corrective replan executable: `next`
-returns a blocked diagnostic instead of advertising prepare. Let the lease expire, run the
-explicit lock repair reported by `doctor`, then request `next` again. Corrective yield is reserved
-for the exact claimed-C1 posture and is not a general lease-release command.
+Repository files remain durable product knowledge. Workflow state lives outside the repository under the local Codex state root. The codebase-memory graph is derived code orientation, with an explicit fallback when unavailable. Workers leave changes uncommitted; Core completes Steps and records their commits. Independent review, bound authority and scoped credentials remain separate checks. In delegate mode the human participates in Discovery creation/edits and grant issuance/expansion; the Coordinator performs eligible operational decisions and supervises the assigned work through terminal closure. Acceptance must never be weakened to manufacture completion. Human mode retains its explicit approval gates. See [the current delegate contract](docs/autonomy-guardrails.md).
 
-When repository `next` returns top-level `action: task context-refresh` with an exact delegated
-option, the coordinator must use that atomic action instead of standalone reconcile:
+Only current package execution is supported. Historical evidence needed to verify a current Task remains readable; old version-specific update and rescue procedures are retired.
 
-```bash
-codex-workflow task context-refresh --repo . --id TASK-... \
-  --expected-task-revision ... --expected-map-revision ... \
-  --actor agent:deputy --delegation-grant DGR-...
-```
-
-The only permitted source-set expansion is an exact Plan-declared supporting source under the
-active Milestone Autonomy Grant. Removed, undeclared, canonical, category/authority-changing,
-gap-changing, or conflicting sources are never auto-approved.
-
-## Alpha.7 sidecars
-
-Alpha.7 keeps canonical entity JSON unchanged and stores guardrail evidence in append-only
-sidecars:
-
-- project: `adoption-posture.jsonl`
-- task: `plan-risk-audits.jsonl`, `plan-validations.jsonl`,
-  `corrective-replan-executions.jsonl`, `step-review-events.jsonl`,
-  `reviewer-attestations.jsonl`, `remediation-events.jsonl`,
-  `corrective-decisions.jsonl`, `corrective-decision-recoveries.jsonl`,
-  `remediation-mode-recoveries.jsonl`, `downstream-proof-invalidations.jsonl`, `handoffs.jsonl`
-- milestone: `scope-change-events.jsonl`, `autonomy-contract-events.jsonl`
-
-Milestone scope-change recovery also uses Milestone-local `.transactions/` journal files.
-Broken JSONL, duplicate event ids, broken hash chains, stale revision/hash/commit bindings,
-or mismatched authority fail closed with structured diagnostics.
-
-Alpha.7.2.1 can recover the one exact alpha.7.2 defect where a validated third
-corrective attempt was persisted as `mode=ordinary`. `next` exposes
-`task remediation-mode-recover` only for that fully verified legacy shape. Run the
-returned command with its exact Task revision, actor, and writer token. Recovery
-appends a bound event to `remediation-mode-recoveries.jsonl`; it never edits the
-historical remediation event. An identical retry is idempotent. After recovery,
-the historical attempt is interpreted as `corrective`, but no attempt-count hard stop is
-created: after any required Knowledge refresh, `next` may continue the same failed Step.
-
-For a legacy authorization without current mechanical evidence, or a contradiction that genuinely
-becomes observable only after execution starts, the first guarded `checks-failed` event may cause
-`next` to advertise `task plan-integrity-recover` instead of an identical retry. Missing scripts and
-missing required selectors retain the existing evidence-bound `replan-required` route. beta.12.16
-adds one narrower outcome for a direct imported checksum/catalog authority: when an absent declared
-migration output is writable by the Step, the check runner directly imports a tracked immutable
-support module, that module contains approved SHA/catalog anchors for the same output family, every
-dirty file remains inside the original Step scope, and the support module is outside both the
-original `allowedWrites` and `forbiddenScope`, Core records an append-only `continue-fix` authority
-for that exact support path. The Task keeps the same Plan hash and implementation bytes; subsequent
-run, commit and sealed-review packets use the effective scope and disclose the derived authority.
-Any semantic Plan change, indirect/dynamic check, unrelated dirty path, forbidden path, missing
-hash anchor or ambiguous import remains fail-closed and uses the ordinary corrective path.
-
-When an active downstream proof exposes a required change in files owned by a completed transitive
-predecessor Step, fresh `next` advertises `task downstream-proof-recover` instead of the impossible
-`task step-complete`. The lease-bound transaction preserves worktree and HEAD, invalidates only the
-affected predecessor completion evidence, retains its commits as historical `invalidatedStepCommits`, yields
-C1, and returns the same Task to ordinary planning. A fresh replacement Plan, Plan Risk Audit, and
-execution authorization are required. Unrelated dirty files, non-predecessor ownership, unregistered
-history, or damaged invalidation evidence fail closed.
-
-If that exact condition is already present on an older package and therefore blocks the ordinary
-clean-checkout update, beta.12.6 provides a bounded compatibility bridge. Update the active
-Milestone base and Task branch with separate commits that each change only `package.json` and
-`package-lock.json`, install the exact package, and continue only when fresh `next` advertises
-`update downstream-proof-dependency-recover`. Its read-only preflight validates the candidate at
-`HEAD`, the previously recorded Task history at `HEAD^`, aligned runtime/declared/locked/installed/
-base versions, absence of leases and transactions, the exact active Step, predecessor ownership,
-and a SHA-256 binding of every dirty product file. Recovery registers only that dependency commit,
-does not touch product bytes or end the Step, and makes the existing `task downstream-proof-recover`
-route reachable. Unknown history, an unrelated dirty path, a non-dependency candidate, stale base,
-or changed authority remains a hard stop.
-
-If beta.12.6 already invalidated the predecessor but a later Project Knowledge approval rebound the
-rejected Plan, beta.12.7 exposes a separate exact compatibility route. Run the new package's read-only
-`update downstream-proof-replan-update-preflight` before changing dependencies. After the two
-dependency-only commits, follow fresh `next` through replan dependency registration and
-`task downstream-proof-replan-recover`. Knowledge refresh may follow, but it cannot replace the
-required `task plan-set`. Preserved dirty bytes are executable only when one replacement Step owns the
-entire path set and `next` reports `downstreamProofCarryover.state=validated`; normal checks, Core commit,
-and strict review remain mandatory.
+## Current guides
 
-Docker socket `EPERM`/permission errors observed inside a sandbox are access-boundary evidence, not
-daemon-failure evidence. The gateway repeats the exact read-only probe or Plan check once with
-sandbox escalation without consuming a remediation/infra retry. Docker Desktop restart or image
-mutation requires separate authority and an escalated probe that actually proves daemon failure.
+- [Development and supervision](docs/development-flow.md)
+- [Autonomy, review and recovery](docs/autonomy-guardrails.md)
+- [Project Knowledge and graph orientation](docs/project-memory.md)
+- [Current product decisions](docs/decisions.md)
+- [Updating the consumer](docs/updating-existing-project.md)
+- [Release criteria and evidence](docs/release.md)
 
-For a terminal split, follow the [canonical replacement stop procedure](docs/split-required-recovery.md).
-P04-A intentionally disables structural replacement; P04-B/P05 must define the topology-preserving
-transaction before the route can be used.
+## Maintain
 
-## Delegated approval
+On the pinned runtime, run:
 
-Delegation never makes an agent a human actor. A user first approves an exact grant policy;
-later authorization events record the agent as `delegate`, the user as `principal`, the grant
-ID, policy hash, transition, scope, and expiry. Existing schema 2 projects need no migration.
-
-```bash
-codex-workflow delegation prepare --repo . --file delegation-policy.json
-# After the user confirms the returned DGA code in a later message:
-codex-workflow delegation grant --repo . --file delegation-policy.json \
-  --confirmation-code DGA-...
-codex-workflow task authorize --repo . --id TASK-... --expected-revision 2 \
-  --actor agent:deputy --delegation-grant DGR-...
+```sh
+npm ci
+npm run release:check
 ```
 
-Policies may allow only `project_memory.approve`, `task.execution_authorize`, `task.final_accept`,
-`milestone.execution_authorize`, and/or `milestone.final_accept`. Scope is one project,
-Milestone, or Task; ordinary Project Knowledge Map approval requires project scope. Alpha.7 does
-not extend this allow-list. A separate Milestone Autonomy Contract may authorize membership-only
-evolution and the `project_memory.approve` half of an atomic, content-only Task context refresh
-for the same Milestone. It cannot approve Project Memory as a standalone operation. Outcome,
-success signal, acceptance, checks, discovery, and base branch remain cryptographically fixed.
-Pass `--delegation-grant` only when the same `next` response exposes an exact eligible
-`delegatedApprovalOptions` entry for that transition. Ordinary C1 handoff, claim, run,
-step-complete, step-review, merge, and sync-base do not inherit a Milestone approval grant.
-Adoption apply and arbitrary semantic scope changes stay human-only. The bounded
-`milestone remediation-materialize` route is not a generic delegated scope change: it is admitted
-only by a current `stop-escalate` audit, keeps Milestone semantics byte-for-byte unchanged, appends
-one required remediation Task, and adds only the blocked Task dependency edge. Its
-`corrective-derived` authority covers execution authorization and final acceptance of current
-required Tasks; final Milestone acceptance remains unchanged. Revocation is immediate for future
-uses. The original human path remains available and unchanged.
-
-## Milestone autonomy and alpha.6 rescue
-
-Materialize all linked Task discoveries while the new Milestone remains in its initial planning
-posture, then call `milestone plan-set` once with the complete classified membership. Execution
-is unavailable until that full Plan exists. Every membership must explicitly declare its
-canonical `dependsOnTaskIds` array, including `[]`; missing arrays are legacy unknown state, not
-an empty graph. Required Tasks become runnable only after every required predecessor is merged.
-The initial state and `plan.json` are committed by the same recoverable Milestone transaction.
-To approve a bounded autonomous run for up to 72
-hours, use `milestone autonomy-prepare` and, after confirming its `MAC-*` binding,
-`milestone autonomy-grant`. The resulting milestone-scoped grant covers Task/Milestone execution
-and final-acceptance approvals plus Project Memory approval only inside an atomic content-only
-Task context refresh for the same Milestone. `milestone autonomy-evolve` may change only
-memberships and always supersedes the current execution authorization; semantic changes require
-the ordinary human scope-change path.
-
-`update rescue-preflight` is a read-only compatibility route for one exact deadlock shape:
-the project is pinned to `2.0.0-alpha.6`, exactly one strict review is pending, the checkout and
-completion HEAD are exact, and no active lease exists. It returns only stale-lock repair and
-strict-review actions. It neither installs alpha.7 nor rewrites state.
-
-## C1 handoff and legacy adoption
-
-`C1` coordination uses `task handoff-prepare` (with `task handoff` retained as an alias),
-`task claim --claim-token ...`, and `task handback-create` (with `task handback` retained as
-an alias). `task handoff-show` returns the persisted safe bindings but never the plaintext
-claim token. If `--target-actor` is omitted, alpha.7 deterministically derives a distinct
-`agent:worker:<task-id>` actor. Preparation returns a one-time claim token and a prompt bound to `handoffId`, Task
-revision, Brief/Plan/Knowledge hashes, Milestone display positions, dependency membership revision,
-Milestone revision and Plan hash, delegate/grant, expiry,
-and exact expected next action. Only the token hash is persisted. Milestone-linked Tasks must
-be claimed before start; terminal handback records result, evidence, review, knowledge,
-limitations, and recommended-next bindings. This does not prove a physically separate Codex
-thread.
-
-For legacy schema 2 projects:
-
-- accepted/cancelled Milestones stay terminal;
-- merged/cancelled Tasks stay terminal;
-- completed and skipped Steps in active Tasks keep their recorded status and evidence;
-- remaining non-completed, non-skipped legacy Steps need a bootstrap Plan Risk Audit at a
-  safe boundary;
-- newly created Milestones, Tasks, and Steps use the full alpha.7 contract.
-
-See [development flow](docs/development-flow.md), [autonomy guardrails](docs/autonomy-guardrails.md), [delegated approval](docs/delegated-approval.md), [updating an existing project](docs/updating-existing-project.md), [project memory](docs/project-memory.md),
-[accepted decisions](docs/decisions.md), [validation report](docs/validation-report.md), and
-[release policy](docs/release.md). Open stable-release defects, downstream E2E fixtures, and
-alpha regressions that must not recur are tracked in the
-[stable release defect register](docs/stable-release-defect-register.md).
-
-## Russian PDF documentation
+That command performs a fresh build, the full test suite, current PDF freshness, one retained package, installed downstream smoke, plugin and release assertions. It writes an automated-only release passport; original App lifecycle evidence and independent review are separately required before publication. Publication also needs explicit user authorization; no owner signature is required. `npm run validate` stops after the suite; focused test commands are for targeted development. Do not run them all in sequence for a release.
 
-- [Architecture and concepts](docs/pdf/codex-workflow-v2-architecture-ru.pdf)
-- [Chat-only development guide](docs/pdf/codex-workflow-v2-chat-only-guide-ru.pdf)
-- [Deep technical reference](docs/pdf/codex-workflow-v2-technical-reference-ru.pdf)
+Test files run in two isolated processes by default, with startup/execution deadlines and process-tree cleanup. Timing and failed attempts are evidence, not a reason to inflate waits or silently retry. Native host startup problems can precede JavaScript and require separate diagnosis. See [validation boundaries](scripts/validation-pipeline.md) in the source repository.
 
-These beta.13 documents cover delegated Discovery, Milestone Autonomy Contract issuance,
-dependency-aware Task routing, C1 credential handling, external-sealed reviews, bounded
-Plan-integrity recovery (including repeated selector-contract failures), pre-authorization
-selector feasibility, Task-local dependency provenance recovery, the human-confirmed legacy
-attempt-four stop override (including append-only multi-rebind, dependency-only HEAD continuation,
-evidence-accounted post-audit recovery revisions), both downstream-proof update bridges, exact
-dirty-worktree carryover into a replacement Step, audited additive remediation topology with
-corrective-derived Task authority, its atomic dependency-only Knowledge refresh without a Human
-approval gap, the atomic beta.12.11-to-beta.12.12 dirty-worktree update bridge, separate source/target
-Knowledge bindings for corrective replan, exact consecutive dependency-update carryover, historical
-corrective-yield journal continuity, atomic recovery of multiple consecutive unregistered
-dependency-only updates after a failed package transition, and the P04-A
-structural-replacement stop boundary. They also cover beta.13 host-safe credentials, atomic
-failed-Step continuation, cause-bound rolling refinement, structural production-edge admission,
-bounded status and prepared ordinary/security review. Their reviewable
-sources live in [`docs/pdf/sources`](docs/pdf/sources), and `npm run docs:pdf:check` proves the
-tracked binaries were generated from the current source and package version. The PDFs remain
-human-facing artifacts; the Markdown documents above, bundled gateway, schemas, and runtime code
-are the technical authority.
+The automated release command does not publish. The publication entry point re-verifies the complete passport and publishes its exact tarball. Historical briefs and optional PDF exports are outside the package's current instruction surface.