codex-workflow-v2 2.0.0-alpha.7.2.1 → 2.0.0-beta.1

package/docs/autonomy-guardrails.md

@@ -88,8 +88,9 @@ not a human approval, while auditor independence remains mandatory.
 
 ## Atomic context refresh
 
-When `next.contextRefresh` offers an exact option, a project-scoped delegate may run one
-composite transition:
+When `next` returns top-level `action: task context-refresh` with an exact option, a
+project-scoped delegate may run one composite transition and must not run standalone reconcile
+first:
 
 ```text
 task context-refresh

package/docs/beta1-stabilization-brief.md

@@ -0,0 +1,165 @@
+# Codex Workflow V2 2.0.0-beta.1 Stabilization Brief
+
+Status: implementation complete; release candidate awaiting user authorization for commit/tag/push/publish
+
+Baseline: `v2.0.0-alpha.7.2.1` (`1214b4c`)
+
+Primary evidence register: [stable-release-defect-register.md](stable-release-defect-register.md)
+
+## Objective
+
+Produce one feature-frozen beta release that closes every confirmed workflow defect found during
+the `signal_v4` Milestone 3 alpha.7 replay, resolves or evidence-closes the remaining validation
+concurrency investigation, preserves every alpha.7 regression guard, and proves that a real agent can
+recover a terminal `split-required` Task by creating a replacement Task without reviving or rewriting
+the historical Task.
+
+No intermediate npm version is published. `signal_v4` and its external workflow state are read-only
+evidence. Workflow V2 is not used to organize this repository's implementation.
+
+## Release scope
+
+### B1 — Secret-safe lock recovery (`WF-STABLE-001`)
+
+- `locks repair` must never expose a plaintext writer token in ordinary CLI JSON, logs, errors, or
+  snapshots.
+- A repaired lease may expose only non-authorizing metadata and a token fingerprint.
+- If ownership recovery needs a new credential, it must use an explicit one-time handoff boundary
+  rather than a reusable token in general diagnostics.
+
+### B2 — Terminal corrective routing and replacement (`WF-STABLE-002/003`)
+
+- `split-required` and `stop-escalate` outrank Project Knowledge reconcile, approval, rebind, context
+  refresh, authorization, and Task run.
+- `task knowledge-rebind` and `task context-refresh` reject these postures before their first write.
+- A Project Knowledge change cannot detach a terminal corrective decision from its historical Plan.
+- `next` must expose an explicit replacement route for `split-required`; `stop-escalate` remains a
+  hard stop.
+- Replacement must be one journal-recoverable transition that:
+  - consumes one ready Task Discovery;
+  - materializes a new Task with a new ID and the same active Milestone;
+  - changes the old membership from `required` to `cancelled` with a reason;
+  - adds the replacement as `required` with an explicit relationship reason;
+  - marks the old Task `cancelled` without changing its Plan, Steps, review, remediation, corrective,
+    result, or evidence history;
+  - revokes the cancelled Task's writer lease in the same recoverable transaction;
+  - absorbs exact safe Plan-bound Knowledge drift through the active Milestone Autonomy Grant in
+    that transaction, so the replacement Task can be planned without a stranded standalone gate;
+  - supersedes Milestone execution authorization and increments membership revision;
+  - leaves no orphan Task or partial membership state after process interruption;
+  - is idempotently recoverable from its journal.
+- Normal standalone Project Knowledge actions must identify a triggering Task only as diagnostic
+  provenance, never as implied Task authorization.
+- When an exact delegated atomic context refresh is eligible, `next` must return it as the top-level
+  action and standalone reconcile must fail before writing; an agent cannot create an avoidable
+  human-approval gap by selecting the nested Project Knowledge sub-transition.
+
+### B3 — Update/base diagnostics and canonical recovery guidance (`WF-STABLE-004/005`)
+
+- Update diagnostics must distinguish the current checkout from an active Milestone base branch and
+  report exact declared, locked, installed, current-branch, and base-branch workflow versions.
+- Divergence must fail closed before lifecycle work continues and must recommend dependency-only
+  transport rather than merging product commits.
+- Documentation must include one canonical `split-required` recovery prompt and exact ordering for
+  replacement, membership evolution, Milestone reauthorization, new Task planning, and execution.
+
+### B4 — Composite context-refresh durability (`WF-STABLE-006`)
+
+- Project Knowledge reconcile/approval, Task Plan rebind, rebound risk-audit evidence, and execution
+  authorization must use a recoverable multi-file transaction.
+- All semantic and authority checks happen before the first target write.
+- Crash recovery is deterministic and idempotent at every write boundary.
+- `doctor`, `status`, and `next` detect an incomplete transaction and return the exact recovery action;
+  no partial refresh is treated as authorized.
+
+### B5 — Deterministic maintainer validation (`WF-STABLE-007`)
+
+- Reproduce or disprove shared-output contention between full validation commands.
+- If confirmed, serialize destructive build/test output preparation or isolate per-run artifacts.
+- Concurrent invocation must either complete independently or fail immediately with a clear,
+  non-secret diagnostic; it must not hang silently.
+- Child processes and temporary resources are cleaned up after interruption.
+
+## Required deterministic evidence
+
+1. Exact `signal_v4` replay:
+   `split-required -> Knowledge Map 169 active -> next replacement -> replacement transaction -> old
+   Task immutable/terminal -> new required Task planning`.
+2. Negative rebind/context-refresh tests for `split-required` and `stop-escalate` proving zero writes.
+3. Replacement rejection tests for wrong Task, wrong Milestone, wrong decision, non-ready Discovery,
+   semantic Milestone changes, stale revisions, expired/wrong actor autonomy, corrupt sidecars, and
+   duplicate retries.
+4. Crash injection before and after every replacement and context-refresh transaction write.
+5. CLI/output scans proving writer tokens are absent.
+6. Base-version divergence tests for clean and dirty repositories and unrelated product commits.
+7. Concurrent validation reproduction with bounded completion.
+8. All existing unit, integration, milestone, alpha.6, alpha.7, packaging, plugin, downstream smoke,
+   release, and root regression checks.
+
+## Real-agent acceptance
+
+Create a fresh disposable downstream project with isolated `CODEX_HOME`, workflow state, plugin root,
+and a locally packed beta candidate. A real Delegate must complete:
+
+1. Discovery and initial Milestone assembly.
+2. A guarded Task with three failed strict reviews, `continue-fix`, and a terminal
+   `split-required` decision.
+3. A Project Knowledge change and human-style approval boundary.
+4. The exact replacement transition without rebind of the failed Task.
+5. Replacement Task implementation, review, merge, remaining required Task completion, Milestone
+   validation, and final acceptance.
+
+The E2E is invalid if the harness injects lifecycle failures, edits external state, reuses a stale
+plugin cache, bypasses `next`, or requires a fourth remediation attempt.
+
+## Final evidence
+
+- Deterministic package suite: all beta.1 transaction, terminal-routing, Knowledge refresh,
+  diagnostics, concurrency, alpha.6, alpha.7, integration, Milestone, and workflow regressions pass.
+- Crash replay covers rollback and dead-process roll-forward at every tested write boundary,
+  including deletion of the cancelled Task writer lease.
+- Real-agent disposable run:
+  `test-runs/2.0.0-beta.1/replacement-e2e-final`.
+- Historical Task `TASK-01M02N276D6AE83VBVRH17RDQY` ended `cancelled` at revision 18 and links to
+  replacement Task `TASK-01M02NMZZBVCA4TZKK6WG724RY`.
+- Replacement Task passed its guarded Step review and independent final review, then merged as
+  `c8d45be7f3165731cf891a47e88a112f76d0119f`.
+- Milestone `MS-01M02N1M9M1CT8RHYGSZH8ETHC` reached `accepted` revision 7; final `next` returned
+  repository `idle`.
+- The run exposed one additional bounded UX defect: local replacement start initially required a
+  manual return from the cancelled Task branch to `main`. The final candidate makes local Task start
+  create its branch from the exact declared base ref even when another clean Task branch is checked
+  out, with a deterministic regression.
+
+## Non-goals
+
+- Fixing the downstream `signal_v4` NUL validator in this repository.
+- Deleting historical Milestones, Tasks, branches, chats, worktrees, or append-only evidence.
+- Broadening delegated authority or removing human final acceptance.
+- Publishing, tagging, pushing, or modifying `signal_v4` without separate user authorization.
+- Declaring `2.0.0` stable before the new real `signal_v4` Milestone completes successfully.
+
+## Release gate
+
+`2.0.0-beta.1` is recommended only when all confirmed findings are closed, every investigation is
+resolved with evidence, deterministic and crash replay pass, the real-agent disposable Milestone
+reaches final acceptance, an independent final audit has no unresolved material finding, and the
+release diff contains no downstream product implementation.
+
+## Final audit and residual risks
+
+No material requirement gap remains in the beta.1 scope. The final source audit confirmed that
+authority checks precede replacement/context-refresh target writes, cancelled Task authority is
+deleted inside the same recoverable transaction, terminal decisions outrank Knowledge navigation,
+and ordinary CLI output contains no reusable writer credential.
+
+Residual beta risks are bounded:
+
+- the project journal is a local-process/local-filesystem recovery protocol, not a distributed
+  cross-host transaction service; cross-machine synchronization remains outside the package
+  contract;
+- the final real-agent run encountered and safely recovered the clean-branch start precondition;
+  the final candidate fixes that behavior and covers it deterministically, but the entire long E2E
+  was not repeated solely for that Git convenience change;
+- `2.0.0` stable remains gated on a successful new real `signal_v4` Milestone, as stated in the
+  non-goals.

package/docs/delegated-approval.md

@@ -160,9 +160,10 @@ exact `task step-complete` из `next`, а core выполняет checks, со
 записывает evidence. Worker не использует grant. При изменении Knowledge Map
 выполни reconcile; approve разрешён только при exact project_memory.approve
 option этого project-scoped grant. Затем knowledge-rebind и новая authorization.
-Если next содержит exact `contextRefresh` для того же grant, можешь вместо четырёх
-команд выполнить `task context-refresh`; при любом изменении source set,
-category/authority, gaps или conflicts используй обычный видимый процесс.
+Если next возвращает top-level `action: task context-refresh` и exact `contextRefresh` для того же
+grant, выполни только `task context-refresh`; не запускай перед ним standalone reconcile. Exact
+Plan-declared supporting additions допустимы только когда их признал Core. При любом другом
+изменении source set, category/authority, gaps или conflicts используй обычный видимый процесс.
 
 После submit запусти отдельный Independent Reviewer; Reviewer не использует
 grant и не исправляет код. После второго failed review не запускай очередной

package/docs/development-flow.md

@@ -50,10 +50,12 @@ active Worker Step, a no-op binding, an invalid knowledge target, or a modified
 artifact. After the user authorizes the rebound Plan, execution resumes in the existing
 workspace; if all Steps are complete, the next action is submission.
 
-When `next.contextRefresh` exposes an eligible project-scoped grant and content-only mode,
-`task context-refresh` may compose reconcile, delegated map approval, rebind, and delegated
-execution reauthorization. Core validates both approval transitions before writing and
-rejects any source-set, category, scope, authority, gap, or conflict change.
+When `next` returns top-level `action: task context-refresh` with an eligible grant,
+`task context-refresh` composes reconcile, delegated map approval, rebind, and delegated
+execution reauthorization. Do not run standalone reconcile first. Core validates both approval
+transitions before writing. It permits content-only drift and exact Plan-declared supporting-source
+additions under Milestone autonomy; every unsafe source-set, category, scope, authority, gap, or
+conflict change is rejected.
 
 Submission requires a clean, auditable Task history and records evidence for the exact
 Task head. `task review-launch` starts a separate read-only reviewer. A passing fresh review

package/docs/project-memory.md

@@ -30,12 +30,14 @@ definition, status, and evidence record, records the old/new binding, supersedes
 authorization, and cannot run while a Step is in progress. If local state is lost, the map
 is rebuilt from repository files.
 
-For delegated autonomy, repository `next` may expose `contextRefresh` when the stored map was
-active and inspection proves content-hash-only drift. `task context-refresh` then performs
+For delegated autonomy, repository `next` returns top-level `action: task context-refresh` and an
+exact `contextRefresh` option when the stored map was active and inspection proves eligible drift.
+Do not run standalone reconcile first. `task context-refresh` then performs
 reconcile, delegated map approval, Task rebind, and delegated execution authorization while
-preserving the ordinary audit events. The command rejects new/removed sources, category,
-scope or authority changes, changed gaps, and conflicts. Those changes always remain visible
-for normal classification and approval.
+preserving the ordinary audit events. In addition to content-only drift, a Milestone Autonomy Grant
+may admit one or more exact Plan-declared supporting sources. The command rejects removed,
+undeclared, canonical, category/scope/authority-changing, gap-changing, and conflicting sources.
+Those changes remain visible for normal classification and approval.
 
 ## Codebase graph
 

package/docs/release.md

@@ -20,14 +20,21 @@ The downstream smoke packs the actual tarball, installs it into an empty tempora
 runs the packaged CLI handshake, and proves installation created none of `.codex`, `.tasks`,
 `.increments`, or `.memory-bank` in that project.
 
-For alpha.7, the release gate also relies on `npm run release:check` to fail if:
+For beta.1, the release gate also relies on `npm run release:check` to fail if:
 
 - canonical entity schema 2 shapes drift;
 - protocol 1 compatibility is no longer additive;
 - the delegated transition allow-list expands;
 - schema-2 adoption is presented as `state migrate` instead of posture sidecars;
 - alpha.7 rescue, Milestone autonomy (including guarded content refresh), derived actor, or
-  proof-obligation capabilities and schemas are absent from the packaged surface.
+  proof-obligation capabilities and schemas are absent from the packaged surface;
+- terminal Task replacement, project-level transaction recovery, secret-safe lock diagnostics,
+  version/base diagnostics, or serialized maintainer validation are missing.
+
+Full `npm test` and `npm run validate` invocations share destructive build outputs and are therefore
+single-owner operations. A concurrent invocation fails immediately with
+`VALIDATION_ALREADY_RUNNING`; retry it after the owner exits. Stale process locks are recovered
+automatically.
 
 Tag releases as `v<package-version>`. The tag workflow verifies the tag/package match and
 uses npm trusted publishing with public access. For a public GitHub repository and public

package/docs/split-required-recovery.md

@@ -0,0 +1,53 @@
+# Canonical `split-required` recovery
+
+Use this procedure only when the exact package-local `next` response identifies a terminal
+`split-required` decision. Never rebind, refresh, replan, authorize, or resume the historical Task.
+
+## Delegate prompt
+
+```text
+Continue the active Milestone through the package-local codex-workflow-v2 Core only.
+
+1. Run `codex-workflow status --repo .` and `codex-workflow next --repo .`. Treat every returned
+   revision and action as authoritative. Stop on corruption, stop-escalate, version divergence, or
+   an unexpected action. Do not edit workflow state or sidecars.
+2. Confirm that `next` reports the historical Task as `split-required`. Do not run
+   `task knowledge-rebind`, `task context-refresh`, `task plan-set`, `task authorize`, or `task run`
+   for that Task.
+3. If `next` says `discovery start`, create one thin replacement Discovery containing only the
+   failed Step's remaining outcome, exact acceptance, constraints, and explicit out-of-scope. Make
+   it `ready_to_materialize`, then run `status` and `next` again.
+4. When `next` returns `task replacement-materialize`, run that exact command with its old Task,
+   Discovery, and Milestone revisions, a precise replacement title, and the current authorized
+   actor. This single transaction must consume the Discovery, cancel/link the historical Task,
+   create/link the replacement Task, change both memberships, supersede Milestone execution
+   authorization, and leave the Milestone awaiting reauthorization. Do not perform a separate
+   scope change for these effects.
+5. Run `status` and `next`. Verify: old Task `cancelled`; old membership `cancelled`; new Task
+   `planning` and `replacementForTaskId` points to the old Task; new membership `required`;
+   Milestone `awaiting_execution_authorization`. If any relation is missing, stop and run `doctor`.
+6. Follow the exact `next` transition to reauthorize the changed Milestone. Run `status` and `next`
+   again. Do not reuse the historical Task's Plan or authorization.
+7. Plan the replacement Task from its own Brief, record the required Plan Risk Audit, authorize it,
+   prepare and claim its C1 handoff, and execute only the exact Step returned by `next`. Run
+   `status` and `next` after every state boundary.
+8. Complete review, final acceptance, merge, remaining required Tasks, Milestone validation, and
+   Milestone final acceptance through exact Core transitions. Never create a fourth remediation
+   attempt for the historical Task.
+```
+
+## Exact replacement command shape
+
+```sh
+codex-workflow task replacement-materialize --repo . \
+  --id TASK-OLD \
+  --expected-revision OLD_TASK_REVISION \
+  --discovery DISC-REPLACEMENT \
+  --expected-discovery-revision DISCOVERY_REVISION \
+  --expected-milestone-revision MILESTONE_REVISION \
+  --title "Thin replacement title" \
+  --actor agent:milestone-coordinator
+```
+
+Copy revisions from the same `next` response. If multiple ready Discoveries exist, Core refuses to
+guess; choose the intended Discovery explicitly after reviewing its raw content.

package/docs/stable-release-defect-register.md

@@ -0,0 +1,268 @@
+# Stable Release Defect Register
+
+This register captures defects and operational gaps found while running the
+alpha.7 line against the `signal_v4` Milestone 3 lifecycle. It is intentionally
+separate from implementation briefs: an item stays here until it is either
+verified fixed by a regression test or explicitly classified as downstream-only.
+
+Last reviewed: 2026-08-15.
+
+## Severity and status
+
+- **Confirmed** means the behavior was reproduced from package or downstream evidence.
+- **Investigation** means the risk is concrete, but the package defect boundary is not yet proven.
+- **Closed-regression** means a patch exists; the stable release must retain its regression coverage.
+- **Downstream** means the finding belongs to `signal_v4`, not to the workflow package.
+
+## Workflow findings closed for beta.1
+
+### WF-STABLE-001 — `locks repair` exposes a full writer token
+
+- Status: Closed-regression in beta.1
+- Severity: High
+- Area: lock recovery, CLI output, secret handling
+- Evidence: the `locks repair` result includes the complete credential-bearing writer token rather
+  than a redacted value or one-time bounded handoff.
+- Risk: a transcript, log, screenshot, or delegated agent output can disclose authority that permits
+  state mutation.
+- Stable-release requirement:
+  - never print the full token in ordinary JSON or human-readable output;
+  - return only a redacted fingerprint unless an explicit secure handoff channel is used;
+  - add CLI, JSON-envelope, logging, snapshot, and error-path tests proving no token leakage;
+  - preserve deterministic recovery and avoid making the token unrecoverable before ownership is
+    safely transferred.
+
+### WF-STABLE-002 — standalone Project Knowledge `next` is misleadingly attributed to a failed Task
+
+- Status: Closed-regression in beta.1
+- Severity: Medium
+- Area: `next`, Project Knowledge Map, remediation terminality
+- Signal replay evidence:
+  - Task `TASK-01M00W190K3V3HM68Q3QVSH1AY` is `needs_fix` with
+    `STEP-002-FORMALIZATION-CONTRACTS` failed and a `split-required` decision;
+  - after a top-level reconcile, `next` correctly returns scope `project-memory`, action
+    `project-memory approve`, revision `168`, but also returns that failed Task as `taskId`.
+- Risk: an agent or operator can interpret a standalone project approval as permission to refresh or
+  resume the terminal remediation path.
+- Stable-release requirement:
+  - standalone Project Knowledge actions must not look like Task execution actions;
+  - either omit `taskId` or expose it under an explicit non-authorizing field such as
+    `triggerTaskId`/`stalenessOriginTaskId`;
+  - state clearly that approval cannot authorize, refresh, or resume the referenced Task;
+  - add a replay for `split-required -> main branch reconcile -> standalone approval next`.
+
+### WF-STABLE-003 — terminal `split-required` is routed into unsafe Knowledge rebind
+
+- Status: Closed-regression in beta.1
+- Severity: Critical
+- Area: corrective terminal decisions, Milestone membership evolution, `next`
+- Signal replay evidence:
+  - after human approval of Project Knowledge Map revision `169`, exact `next` returns
+    `task knowledge-rebind` for `TASK-01M00W190K3V3HM68Q3QVSH1AY` at revision `28`;
+  - the Task is `needs_fix`, its guarded Step is failed, and its current corrective decision is
+    `split-required`;
+  - `taskCanRebindKnowledge` accepts every `needs_fix` Task without checking a hard-blocking
+    corrective decision;
+  - repository `next` lets Knowledge Map rebind override the Task-level `doctor` result for the
+    `split-required` posture;
+  - `rebindTaskKnowledge` changes the Plan hash, sets status to
+    `awaiting_execution_authorization`, clears review/block state, and supersedes execution
+    authorization without preserving the terminal decision on the rebound Plan;
+  - no Task cancellation transition exists, and a started Task remains repository-actionable while
+    its Milestone is active even if membership disposition is changed.
+- Risk: following exact `next` can detach the new Plan hash from the recorded `split-required`
+  decision and make the failed Task appear authorizable again. Ignoring `next` to create or
+  reclassify a replacement Task cannot remove the started failed Task from repository routing.
+- Stable-release requirement:
+  - reject `knowledge-rebind` and `context-refresh` before the first write when the current
+    corrective posture is `split-required` or `stop-escalate`;
+  - keep terminal corrective decisions effective across Project Knowledge changes without
+    rebinding or rewriting the historical Task Plan;
+  - provide one unambiguous replacement route with explicit old/new Task relationship;
+  - require atomic or journal-recoverable membership evolution;
+  - prevent both orphan replacement Tasks and a still-required terminal Task;
+  - make repository `next` return that replacement route rather than `knowledge-rebind`;
+  - add deterministic and real-agent E2E coverage for
+    `split-required -> Project Knowledge approval -> replacement -> Milestone continuation`.
+
+### WF-STABLE-004 — workflow package upgrades can remain stranded on a Task branch
+
+- Status: Closed-regression in beta.1
+- Severity: Medium
+- Area: update instructions, branch ownership, Milestone base verification
+- Evidence: dependency commit `3f45abc88f7b85091c484d0b84f4c96d1dfeb045` pinned
+  `codex-workflow-v2@2.0.0-alpha.7.2.1` only on the failed Task branch while local `main`, the
+  Milestone base, remained on alpha.7.1. Recovery required a manually scoped cherry-pick producing
+  `fabd1c868a9baa74c7ef273bf0272753c7927812` on local `main`.
+- Risk: diagnostics run with one package version while Milestone creation or replacement work starts
+  from another, invalidating assumptions and repeating already-fixed lifecycle failures.
+- Stable-release requirement:
+  - update preflight and documentation must distinguish current worktree version from Milestone base
+    branch version;
+  - provide an explicit dependency-only landing check before lifecycle work continues;
+  - fail closed when declared, locked, installed, current-branch, and base-branch versions diverge;
+  - never suggest merging unrelated product commits to transport a workflow dependency update.
+
+### WF-STABLE-005 — agent guidance did not make replacement membership evolution explicit
+
+- Status: Closed-regression in beta.1
+- Severity: Medium
+- Area: recovery prompts, operator guidance
+- Evidence: the generated post-approval prompt said to create a thin required replacement Task but
+  did not explicitly require reclassification of the old failed membership and Milestone
+  reauthorization through exact Core transitions.
+- Risk: correct package primitives can still be used in the wrong order, recreating an apparently
+  active but non-completable Milestone.
+- Stable-release requirement:
+  - ship a canonical `split-required` operator/delegate recovery prompt;
+  - require `status`/`next` after every state boundary;
+  - distinguish Task creation, replacement linkage, membership evolution, and execution
+  reauthorization;
+- prohibit manual state editing and resumption of the failed Step.
+
+### WF-STABLE-006 — composite context refresh has no multi-file crash-recovery journal
+
+- Status: Closed-regression in beta.1
+- Severity: High
+- Area: Project Knowledge refresh, Task rebind, delegated reauthorization, durability
+- Evidence: alpha.7.1 validates the complete transition before its first canonical write and uses
+  atomic replacement for each individual file, but the composite transition performs multiple file
+  writes without a transaction journal. A process or machine failure between those writes can leave
+  a partially applied cross-file transition.
+- Risk: the repository can be clean while Project Knowledge, Task binding, authorization, and audit
+  sidecars disagree after a crash. Prevalidation prevents logical rejection after the first write but
+  cannot recover an interrupted physical write sequence.
+- Stable-release requirement:
+  - introduce a project-local transaction journal or an equivalent recoverable commit protocol;
+  - define deterministic roll-forward/rollback semantics for every write boundary;
+  - make recovery idempotent and preserve append-only audit history;
+  - add crash-injection tests before and after each canonical and sidecar write;
+  - prove `doctor`, `status`, and `next` detect and route every interrupted legacy/candidate shape;
+  - never silently treat a partial refresh as authorized.
+
+### WF-STABLE-007 — full validation commands may race through shared build/clean outputs
+
+- Status: Closed-regression in beta.1
+- Severity: Medium if confirmed
+- Area: maintainer validation, reproducibility
+- Evidence: concurrent `npm test` and `npm run validate` runs stopped producing reliable completion
+  evidence after both reached shared test/build phases. A later sequential run continued normally.
+  The observed behavior is consistent with shared `build`/`clean` output contention, but the exact
+  cause has not been isolated.
+- Risk: maintainers can mistake a hung or corrupted concurrent run for passing release evidence, or
+  waste hours waiting on a validation process that cannot complete deterministically.
+- Verification required:
+  - reproduce with process-level tracing and isolated logs;
+  - identify shared directories, cleanup commands, ports, caches, and child processes;
+  - distinguish a package-script race from a test-runner or environment defect.
+- Stable-release requirement if confirmed:
+  - isolate run outputs/resources or enforce an explicit single-run lock with a clear diagnostic;
+  - ensure interruption cleans up child processes and resources;
+  - document whether concurrent full validation is supported;
+  - add a deterministic concurrency regression where practical.
+
+### WF-STABLE-008 — replacement Task local start required a manual base-branch switch
+
+- Status: Closed-regression in beta.1
+- Severity: Low
+- Area: local Task start, replacement autonomy, Git preconditions
+- Evidence: the final disposable E2E correctly materialized and reauthorized the replacement, but
+  its first `task start` was safely rejected because the clean checkout still pointed at the
+  cancelled Task branch instead of `main`; the Delegate recovered by switching branches and retrying.
+- Stable guard: local Task start resolves the exact declared base ref and creates the new Task branch
+  from that ref even when another clean Task branch is checked out. Dirty worktrees and external
+  ownership rules remain fail-closed.
+
+## Beta.1 closure evidence
+
+- `WF-STABLE-001`: CLI integration proves both inspection and stale repair return only a token
+  fingerprint and never the writer token.
+- `WF-STABLE-002`: repository navigation returns diagnostic provenance as
+  `stalenessOriginTaskId` with `authorizesTask: false`; eligible atomic refresh is a Task-scoped
+  top-level action.
+- `WF-STABLE-003`: deterministic terminal replay and the disposable real-agent Milestone prove
+  `split-required -> replacement -> reauthorization -> merge -> final acceptance`, with the old
+  Task cancelled, linked, immutable in history, and without a retained writer lease.
+- `WF-STABLE-004`: update-preflight regressions cover declared, locked, installed, current-branch,
+  and active Milestone base versions plus dependency-only transport guidance.
+- `WF-STABLE-005`: `docs/split-required-recovery.md` and the packaged gateway protocol define one
+  exact replacement ordering and prohibit manual membership/state mutation.
+- `WF-STABLE-006`: beta transaction regressions inject ordinary failure and dead-process exit at
+  every target-write boundary, then prove rollback or idempotent roll-forward, including file
+  deletion. Context refresh and replacement both use the project journal.
+- `WF-STABLE-007`: a deterministic second full-validation owner fails immediately with
+  `VALIDATION_ALREADY_RUNNING`; the sequential release suite completed normally.
+- `WF-STABLE-008`: the local branch-start regression begins on a clean historical Task branch and
+  proves the new Task branch is created from the exact `main` commit.
+
+## Downstream findings to retain as E2E fixtures
+
+### SIGNAL-M3-001 — stable identifier validation misses real U+0000 after line terminators
+
+- Status: Downstream confirmed defect
+- Owner: `signal_v4`
+- Workflow relevance: use as the thin replacement-Task fixture for validating `split-required`
+  recovery; do not implement the product fix in this repository.
+- Required downstream acceptance: reject real U+0000 in every position, including immediately after
+  line terminators, without weakening other stable-identifier rules.
+
+### SIGNAL-M3-002 — Project Knowledge has an unresolved `ownership` gap
+
+- Status: Downstream gap, currently non-blocking
+- Owner: `signal_v4`
+- Evidence: candidate Knowledge Map revision `168`, hash
+  `8d775d82fb1aec85322a923ecf62053453160376033f45bd3c7e2a8c2588d51d`, reports no conflicts
+  and one missing `ownership` category source.
+- Rule: do not expand the NUL replacement Task to fix this gap. Track it as separate project
+  documentation work.
+
+### SIGNAL-M3-003 — local `main` has no configured `origin`
+
+- Status: Downstream operational risk
+- Owner: `signal_v4`
+- Evidence: local `main` is at `fabd1c868a9baa74c7ef273bf0272753c7927812`, but `git ls-remote
+  --heads origin main` fails because `origin` is not configured.
+- Risk: a local dependency correction may be mistaken for a shared or durable project update.
+- Rule: resolve repository remote/backup policy separately; do not let workflow lifecycle commands
+  infer permission to publish.
+
+## Closed alpha.7 regressions that must not recur
+
+### WF-REG-001 — context-only Knowledge Map rebinding invalidated `continue-fix`
+
+- Status: Closed-regression in alpha.7.2
+- Stable guard: semantic Plan equality must preserve an authorized `continue-fix`; semantic changes
+  must invalidate it; recovery remains append-only and non-mutating on failure.
+
+### WF-REG-002 — recovered corrective decision still produced `TOKEN_RECOVERY_NO_GO`
+
+- Status: Closed-regression in alpha.7.2.1
+- Stable guard: an append-only remediation-mode recovery must restore the exact allowed transition
+  without a fourth remediation run, duplicate decision, manual state edit, or writer-lease bypass.
+
+### WF-REG-003 — delegated creation of exact Plan-declared supporting Knowledge sources was blocked
+
+- Status: Closed-regression in alpha.7.1
+- Stable guard: only exact normalized Plan-declared supporting sources with
+  `knowledgeImpact=create` may be added; wildcard, directory, canonical, unauthorized, removal,
+  category/authority changes, gaps, and conflicts remain blocked before the first write.
+
+### WF-REG-004 — E2E history contained a spurious review failure from the harness
+
+- Status: Closed-regression in alpha.7.1 E2E evidence
+- Stable guard: fresh real-agent E2E evidence must separate harness/setup failures from lifecycle
+  review attempts and must not pollute the Task remediation history.
+
+### WF-REG-005 — `next` offered work that the exact transition would reject
+
+- Status: Closed-regression in alpha.7.2
+- Stable guard: `next` must use the same binding, recovery, terminal-decision, and corruption
+  predicates as the exact mutating transition. If the transition is guaranteed to reject, `next`
+  must return the recovery/blocking action instead of a Task run.
+
+## Stable-release exit rule
+
+The stable release is not ready while any Confirmed workflow finding above is open. Investigation
+items must be either reproduced and fixed or closed with recorded evidence that Core already provides
+the required safe semantics. Downstream findings do not block the package by themselves, but the NUL
+fixture must complete the real-agent replacement path through final Milestone acceptance.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-workflow-v2",
-  "version": "2.0.0-alpha.7.2.1",
+  "version": "2.0.0-beta.1",
   "description": "Requirements-first Codex development workflow with local state and explicit Git ownership.",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "clean": "node --eval \"import('node:fs').then(({rmSync}) => { rmSync('dist', {recursive:true, force:true}); rmSync('.test-dist', {recursive:true, force:true}); })\"",
     "build": "npm run clean && tsc -p tsconfig.build.json && node scripts/mark-cli-executable.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "npm run build && tsc -p tsconfig.test.json && node --test .test-dist/tests/*.test.js",
+    "test": "node scripts/with-validation-lock.mjs test",
     "validate": "npm run typecheck && npm test",
     "pack:check": "npm run build && npm pack --dry-run",
     "smoke:downstream": "npm run build && node scripts/downstream-smoke.mjs",

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

@@ -25,6 +25,8 @@ Current capability set:
 - `delegated-approval-v1`
 - `task-knowledge-rebind-v1`
 - `task-context-refresh-v1`
+- `terminal-task-replacement-transaction-v1`
+- `project-composite-transaction-journal-v1`
 - `corrective-plan-audit-v1`
 - `safe-update-preflight-v1`
 - `strict-reviewer-v1`
@@ -127,8 +129,10 @@ classifications. A planned new scanner-visible Knowledge file must be declared w
 directories, and inferred authority are not declarations; only Core may decide whether the final
 diff is eligible for delegated refresh.
 
-Use `task context-refresh` only when the same `next` response exposes `contextRefresh` for the
-exact grant. Pass Task revision, map revision, delegate actor, and grant ID. The composite
+Use `task context-refresh` only when the same `next` response returns it as the top-level action and
+exposes `contextRefresh` for the exact grant. Pass Task revision, map revision, delegate actor, and
+grant ID. Never run standalone `project-memory reconcile` first; Core blocks that non-atomic route
+when the exact delegated composite is available. The composite
 operation accepts content-hash-only drift and, under a Milestone Autonomy Grant, an exact
 supporting-source addition predeclared by the current execution-authorized Task Plan. Core checks
 the full fail-closed predicate; do not reconstruct it in the gateway. When `next` instead returns

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

@@ -51,12 +51,19 @@ scanner category. Do not replace the path with a wildcard or directory, do not i
 authority, and do not claim delegated-refresh eligibility; Core decides eligibility from the
 resulting repository diff and current authorization state.
 
-When `next` exposes an exact delegated `contextRefresh`, use `task context-refresh` only for
-the returned Task/map revisions, actor, and grant. A source-set change is eligible only when
+When `next` returns top-level `action: task context-refresh`, use only that atomic action for
+the returned Task/map revisions, actor, and grant. Do not run standalone `project-memory reconcile`
+first: Core rejects it because it would create a human-approval gap and strand the Task. A
+source-set change is eligible only when
 Core identifies it as a Plan-bounded supporting-source addition under the same Milestone
 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.
+
 ## Product Or Workflow Graph Refresh
 
 1. Run `graph refresh-request --kind product|workflow --mode moderate`.