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

package/README.md

@@ -19,11 +19,17 @@ automation do not import anything from the parent V1 project.
 - 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;
 - read-only Milestone progress projection with stable membership ordinals and replacement links;
@@ -32,6 +38,12 @@ automation do not import anything from the parent V1 project.
 - 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.
 
@@ -43,7 +55,7 @@ cross-machine synchronization are not part of its contract.
 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.12
+npm install --save-dev --save-exact codex-workflow-v2@2.0.0-beta.12.10
 npx codex-workflow gateway handshake --repo .
 npx codex-workflow doctor --repo .
 ```
@@ -98,6 +110,10 @@ codex-workflow task step-complete --repo . --id TASK-... --step STEP-001 \
 `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
@@ -187,7 +203,7 @@ sidecars:
   `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`, `handoffs.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.
@@ -214,6 +230,40 @@ definition, Git HEAD, manifest hash, and complete dirty-file set. The recovery r
 journaled corrective-replan path. It does not edit the Plan, run a second failing attempt, widen
 `allowedWrites`, or modify the worktree.
 
+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.
+
+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.
+
 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.
@@ -243,7 +293,12 @@ success signal, acceptance, checks, discovery, and base branch remain cryptograp
 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 semantic scope changes stay human-only. Revocation is immediate for future
+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
@@ -302,9 +357,14 @@ alpha regressions that must not recur are tracked in the
 - [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)
 
-These beta.12 documents cover delegated Discovery, Milestone Autonomy Contract issuance,
+These beta.12.10 documents cover delegated Discovery, Milestone Autonomy Contract issuance,
 dependency-aware Task routing, C1 credential handling, external-sealed reviews, bounded
-Plan-integrity recovery, and the P04-A structural-replacement stop boundary. Their reviewable
+Plan-integrity recovery, 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, and the P04-A
+structural-replacement stop boundary. 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

package/dist/src/alpha6/downstream-proof.d.ts

@@ -0,0 +1,68 @@
+import type { DownstreamProofInvalidationEvent, DownstreamProofReplanCompatibility, DownstreamProofReplanRecoveryEvent, TaskState } from '../contracts.js';
+import type { FileStateStore } from '../state/store.js';
+export interface DownstreamProofInvalidatedStep {
+    stepId: string;
+    evidenceCommit: string;
+    triggerFiles: string[];
+}
+export interface DownstreamProofRecoveryAssessment {
+    applicable: boolean;
+    eligible: boolean;
+    activeStepId: string | null;
+    dirtyFiles: string[];
+    outsideActiveStepFiles: string[];
+    invalidatedSteps: DownstreamProofInvalidatedStep[];
+    preservedHeadCommit: string | null;
+    dirtyWorktreeHash: string | null;
+    blockers: string[];
+}
+export interface PreparedDownstreamProofInvalidation {
+    event: DownstreamProofInvalidationEvent;
+    postimage: string;
+}
+export interface DownstreamProofReplanRecoveryAssessment {
+    applicable: boolean;
+    eligible: boolean;
+    invalidation: DownstreamProofInvalidationEvent | null;
+    rebind: TaskState['knowledgeRebinds'][number] | null;
+    compatibility: DownstreamProofReplanCompatibility | null;
+    dependencyRecoveryCommit: string | null;
+    blockers: string[];
+}
+export interface PreparedDownstreamProofReplanRecovery {
+    event: DownstreamProofReplanRecoveryEvent;
+    postimage: string;
+}
+export interface DownstreamProofCarryoverAssessment {
+    applicable: boolean;
+    eligible: boolean;
+    dirtyFiles: string[];
+    dirtyWorktreeHash: string | null;
+    invalidationEventId: string | null;
+    blockers: string[];
+}
+export declare function assessDownstreamProofRecovery(store: FileStateStore, repositoryRoot: string, task: TaskState, options?: {
+    historyBoundary?: string;
+    preservedHeadCommit?: string;
+}): DownstreamProofRecoveryAssessment;
+export declare function prepareDownstreamProofInvalidation(store: FileStateStore, resultTask: TaskState, assessment: DownstreamProofRecoveryAssessment, input: {
+    previousTaskRevision: number;
+    actor: string;
+    reason: string;
+}, now: Date): PreparedDownstreamProofInvalidation;
+export declare function readDownstreamProofInvalidations(store: FileStateStore, task: TaskState): DownstreamProofInvalidationEvent[];
+export declare function downstreamProofInvalidationSidecar(): string;
+export declare function assessDownstreamProofReplanRecovery(store: FileStateStore, repositoryRoot: string, task: TaskState, options?: {
+    historyBoundary?: string;
+    preservedHeadCommit?: string;
+    currentPlanRiskAuditExists?: boolean;
+}): DownstreamProofReplanRecoveryAssessment;
+export declare function prepareDownstreamProofReplanRecovery(store: FileStateStore, resultTask: TaskState, assessment: DownstreamProofReplanRecoveryAssessment, input: {
+    previousTaskRevision: number;
+    actor: string;
+    reason: string;
+}, now: Date): PreparedDownstreamProofReplanRecovery;
+export declare function readDownstreamProofReplanRecoveries(store: FileStateStore, task: TaskState): DownstreamProofReplanRecoveryEvent[];
+export declare function downstreamProofReplanRecoverySidecar(): string;
+export declare function assessDownstreamProofCarryover(store: FileStateStore, repositoryRoot: string, task: TaskState, stepId: string): DownstreamProofCarryoverAssessment;
+export declare function hashDirtyWorktree(repositoryRoot: string, dirtyFiles: readonly string[]): string;