codex-workflow-v2 2.0.0-beta.12.4 → 2.0.0-beta.12.6

package/docs/validation-report.md

@@ -1,98 +1,111 @@
-# V2 beta.12.4 Validation Report
+# V2 beta.12.6 Validation Report
 
-Release candidate `2.0.0-beta.12.4` was validated on 2026-08-28 (Europe/Moscow) with
+Release candidate `2.0.0-beta.12.6` was validated on 2026-08-29 (Europe/Moscow) with
 Node.js 24.17.0.
 
 ## Automated release evidence
 
-- `npm ci` completed from the lockfile with 0 reported vulnerabilities.
-- The final `npm run validate` passed typecheck and `328/328` sequential tests with no failures,
-  skips, cancellations, or todos in 1,348,269.052041 ms.
-- The suite includes the beta.12.4 real-order replay (`stop override -> context refresh -> base
-  transport -> dependency provenance recovery -> task run`) and two fail-closed controls: an
-  unexplained Task revision and damaged post-audit dependency provenance. Existing beta.12.3
-  chained rebind, Signal T04, five-cycle remediation, transaction, credential, observer-purity,
-  dependency DAG, transition-catalog, and lifecycle transcript tests also remained green.
-- `npm run pack:check` built the exact beta.12.4 package and reported a 270-file tarball. The first
-  sandboxed attempt could not write the existing npm cache (`EPERM`); the authorized retry using
-  the same source passed.
-- `npm run smoke:downstream` packed and installed the tarball in a clean temporary project and
-  passed its packaged handshake. The sandboxed attempt could not resolve the npm registry for AJV;
-  the authorized network retry using the same source passed.
-- `npm run plugin:check`, the official Codex plugin validator, the gateway skill validator,
-  `npm run docs:pdf:check`, exact `RELEASE_TAG=v2.0.0-beta.12.4 npm run release:check`, and
-  `git diff --check` passed. The bundled gateway cachebuster is
-  `0.1.0+codex.20260828064343`.
+- The first full `npm run validate` passed typecheck and `335/335` sequential tests with no
+  failures, skips, cancellations, or todos in 1,461,147.464875 ms.
+- `npm ci` then completed from the lockfile with 0 reported vulnerabilities. The clean-install
+  `npm run validate` independently passed the same `335/335` tests with no failures, skips,
+  cancellations, or todos in 1,461,906.892 ms.
+- The exact Signal T04/downstream recovery gate passed `8/8`. The targeted dependency-provenance,
+  downstream-proof, CLI-help, and lifecycle-model suite passed `23/23`.
+- The positive beta.12.6 fixture proves the complete compatibility sequence: exact active-base and
+  Task dependency commits, history validation at `HEAD^`, candidate validation at `HEAD`, dirty
+  content binding, dependency registration, fresh navigation to `task downstream-proof-recover`,
+  unchanged product bytes, and valid recorded Task history. Negative cases cover unrelated dirty
+  files, unregistered history, and an active writer lease. Existing Signal T04 tests remain intact.
+- `npm run pack:check` built the exact beta.12.6 package: 274 files, 1.0 MB packed and 4.0 MB
+  unpacked. The first attempt could not write the user npm cache (`EPERM`); the exact retry used an
+  isolated temporary cache and passed without changing global cache ownership.
+- `npm run smoke:downstream` packed and installed the tarball in a disposable consumer project and
+  returned `ok=true`. The sandboxed attempt could not resolve the npm registry (`ENOTFOUND`); the
+  exact network-authorized retry passed.
+- `npm run plugin:check`, `npm run docs:pdf:check`, and exact
+  `RELEASE_TAG=v2.0.0-beta.12.6 npm run release:check` passed. The plugin gate caught one missing
+  `HEAD^` boundary in the human-facing gateway instructions; that boundary was added and the gate
+  then passed. The bundled gateway cachebuster is `0.1.0+codex.20260829120000`.
 
-## Root cause and bounded correction
+## Root cause corrected by beta.12.6
 
-- beta.12.3 validated the chained Knowledge-only Plan rebind and the exact Git
-  dependency-provenance chain, but retained the older Task-revision predicate
-  `reboundAudit.taskRevision + 1 === task.revision` for a failed Step.
-- Signal's actual install flow created the last mechanical Plan Risk Audit at Task revision 22,
-  wrote the atomic context-refresh result at revision 23, then registered one advertised
-  dependency-provenance recovery at revision 24. The old predicate therefore rejected valid,
-  already-verified administrative evidence at the next navigation step.
-- beta.12.4 derives the exact authorization boundary as
-  `reboundAudit.taskRevision + 1 + verifiedPostAuditRecoveries.length`. Only recovery records from
-  the already validated stop-override-to-authorization Git chain count. Each record must remain
-  ordered, single-parent, present in `systemCommits`, and an exact `package.json` plus
-  `package-lock.json` Workflow dependency commit.
-- This is not a permissive `revision >=` rule. An unrelated state write, duplicate or malformed
-  recovery, wrong parent, product-file change, semantic Plan drift, or broken chronology still
-  routes to diagnostics.
+- beta.12.5 correctly classified the current Signal downstream-proof conflict as recoverable, but
+  that did not make the release installable. Signal still runs beta.12.4, whose ordinary update
+  preflight rejects the running Step and dirty product work. Installing beta.12.5 would also advance
+  dependency manifests/HEAD before that new runtime could register the commit. The advertised
+  beta.12.5 recovery was therefore unreachable from the actual starting version.
+- This is an update authority deadlock, not a need for more review attempts: the old runtime cannot
+  authorize the dirty update, while the new runtime cannot be reached without an exact update.
+- beta.12.6 adds one bounded bridge rather than general dirty-update permission. The active
+  Milestone base and Task branch must each receive a separate dependency-only commit changing
+  exactly `package.json` and `package-lock.json`. A fresh beta.12.6 runtime then advertises
+  `update downstream-proof-dependency-recover` only for the active downstream-proof shape.
+- Preflight verifies recorded Task history at `HEAD^`, the exact candidate at `HEAD`, aligned
+  runtime/declared/locked/installed/current-branch/base versions, one active Step, completed
+  transitive-predecessor ownership, branch and Plan bindings, no lease, no pending/corrupt
+  transaction or Core operation, and every dirty path plus SHA-256 content.
+- Recovery registers only the dependency candidate in `systemCommits` and records the bound proof
+  in `dependencyProvenanceRecoveries.activeDownstreamProof`. It does not edit, stash, reset, commit,
+  or discard product work and does not change Step state. Fresh `next` then prioritizes
+  `task downstream-proof-recover` over manifest-induced Knowledge refresh.
+- The ordinary downstream recovery remains responsible for invalidating stale predecessor
+  completion authority and returning the same Task to a new Plan, Risk Audit, authorization,
+  execution, and strict-review cycle. beta.12.6 does not bypass that lifecycle.
 
-## Exact Signal read-only proof
+## Exact Signal read-only evidence
 
-- The final built beta.12.4 validator inspected Signal repository
-  `/Users/home-pc/htdocs/projects/signal_v4`, Task
-  `TASK-01M0WXJAD4GZGVNRJ284ND95C6`, and failed Step
-  `STEP-001-PROCESSING-MIGRATIONS` without mutating the repository or Workflow state.
-- The persisted state has Task revision 24, current Plan hash
-  `6a0c9b7a2a2ec11c9d6a9a24137dc17be1ecd18be42cf0188200942313776a50`, four Knowledge rebinds,
-  three dependency-provenance recoveries, applied override
-  `SOO-01M127VPRC5M5F3E3K7PS4MFJY`, and final rebound audit revision 22. Exactly one verified
-  recovery was recorded after that audit, so `22 + 1 + 1 = 24`.
-- A direct final-build `next --repo /Users/home-pc/htdocs/projects/signal_v4 --json` returned
-  `action=task run`, revision 24, the expected Step, and
-  `stopOverrideContextRebind.state=validated`. It also preserved the exact claimed C1 actor and
-  writer-credential recovery contract.
-- This proves compatibility with the currently persisted Signal M3 boundary. It does not prove
-  that future product implementation or strict reviews will pass.
+- The Signal repository `/Users/home-pc/htdocs/projects/signal_v4` was re-observed read-only after
+  implementation. It remains on branch
+  `codex/task-01m0wxjad4-processing-persistence-schema` at
+  `88f8bf70d1591852ad90c976625430d4f20585ac`.
+- Its dirty set remains exactly six paths: five modified processing-migration files and one
+  untracked `tools/postgres/run-processing-integration.ts`. No Signal repository or Workflow state
+  was mutated during beta.12.6 implementation.
+- Prior read-only state inspection identified Task
+  `TASK-01M0WXJAD4GZGVNRJ284ND95C6`, revision 103, active Step
+  `STEP-002-REAL-POSTGRES-PROOF`, five files owned by completed transitive predecessor
+  `STEP-001-PROCESSING-MIGRATIONS`, and one file owned by the active proof Step. The predecessor
+  evidence commit equals the preserved HEAD.
+- The installed beta.12.4 ordinary update preflight returned `safe=false` for the running Step and
+  dirty checkout. The external beta.12.5 classifier returned `applicable=true`, `eligible=true`, and
+  no recovery blockers, proving that the product boundary itself is supported but not that the old
+  update path can reach it.
+- The beta.12.6 regression fixture mirrors all six Signal paths and the same predecessor/active-Step
+  ownership split. It proves the new update bridge and subsequent downstream recovery route under
+  controlled Git/state mutations.
+- This is strong structural and synthetic evidence, not a claim that the published package has
+  already updated live Signal. The final operational proof still requires the released exact
+  package, two exact dependency-only transport commits, the advertised preflight/recover, and a
+  fresh Signal `status -> next` readback.
 
-## Packaged, plugin, and transcript evidence
+## PDF release documentation evidence
 
-- Downstream smoke validated exact package resolution and the packaged beta.12.4 handshake in a
-  disposable installation.
-- The bundled gateway handshake reports package beta.12.4, protocol 2, state schema 2, and the new
-  `stop-override-post-audit-dependency-revision-v1` capability.
-- A temporary trusted-harness transcript recorded the final built `gateway handshake` invocation
-  and terminal result. `node scripts/validate-lifecycle-transcript.mjs` accepted both
-  post-provenance events. The log SHA-256 is
-  `4ec7d8cb105d901e82d1049c273c4f2ec8d22ea12e0116ed70cfa8ab703ea2eb`; the temporary log remains
-  outside the repository.
-
-The transcript proves release-time invocation/result discipline for the final CLI. It does not
-claim a product Milestone replay or lifecycle mutation. Compatibility is covered by the exact
-Signal read-only proof and deterministic integration tests above.
-
-## beta.12.4 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 26 pages were rendered and visually inspected: architecture is 7 pages, the delegated
-  chat-only guide is 8 pages, and the technical reference is 11 pages. Full-size inspection of the
-  three changed compatibility pages found no clipped, overlapping, or unreadable content.
-- Visible titles, headers, package commands, capabilities, and release gates identify beta.12.4.
-  The documents state the exact evidence-bound revision formula and its fail-closed boundary.
+- Three tracked Russian PDFs were regenerated from Markdown sources; `npm run docs:pdf:check`
+  reported an empty stale set.
+- All 27 pages were rendered and visually inspected: architecture is 7 pages (101,761 bytes), the
+  delegated chat-only guide is 9 pages (107,066 bytes), and the technical reference is 11 pages
+  (112,132 bytes).
+- Visual inspection found table headers rendered dark-on-dark. The shared generator now uses an
+  explicit white bold header Paragraph style; all documents were regenerated and re-inspected.
+  Titles, version headers, Cyrillic glyphs, tables, code blocks, recovery instructions, page edges,
+  and footers have no visible clipping, overlap, or unreadable content.
 
 ## Existing boundaries and non-claims
 
-- The generic stale `continue-fix` recovery predicate is unchanged. The compatibility route does
-  not reverse a semantic stop or authorize arbitrary Git/state history.
-- Structural replacement remains intentionally disabled. beta.12.4 does not implement P04-B,
+- Structural replacement remains intentionally disabled. beta.12.6 does not implement P04-B,
   topology rewiring, completed-Step adoption, or a wider delegation surface.
+- The compatibility bridge is limited to the proven active-downstream-proof shape. Unrelated dirty
+  paths, non-predecessor ownership, unknown history, a wider dependency commit, stale base/version
+  divergence, branch/Plan/Step mismatch, lease, transaction, or damaged sidecar fails closed.
+- Read-only preflight is an observation, not an authorization token. Recover recomputes the current
+  binding. The stored hash proves which bytes the bridge preserved; subsequent downstream recovery
+  revalidates paths, ownership, and history, while the replacement Plan and review cover current
+  content.
+- Git transport commits remain agent-executed operations on exact advertised boundaries. The
+  runtime does not create, amend, merge, reset, or push Git history.
 - Validation performed no Signal mutation, npm publication, Git commit, tag, remote push, or local
-  plugin reinstall. Those are separate release actions after these gates.
-- A consumer must install the published exact beta.12.4 package, update/reinstall the bundled
-  gateway, and use fresh project-local `handshake -> doctor -> status -> next` navigation.
+  plugin reinstall. Those are separate release/deployment actions.
+- Confidence is high for the implemented source and tested Signal-shaped transition. Confidence in
+  the final live Signal update remains pending until the published package is installed and the
+  project-local runtime returns the expected recovery sequence.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-workflow-v2",
-  "version": "2.0.0-beta.12.4",
+  "version": "2.0.0-beta.12.6",
   "description": "Requirements-first Codex development workflow with local state and explicit Git ownership.",
   "repository": {
     "type": "git",

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

@@ -1,6 +1,6 @@
 {
   "name": "codex-workflow-gateway",
-  "version": "0.1.0+codex.20260828064343",
+  "version": "0.1.0+codex.20260829120000",
   "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,6 @@
 # Gateway Protocol V2
 
-## beta.12.4 compatibility transitions and continuable remediation
+## beta.12.6 compatibility transitions and continuable remediation
 
 - 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
@@ -8,6 +8,23 @@
   It records a replan posture without changing Plan or product files; corrective yield and the
   existing state-bound corrective-replan Human gate remain mandatory.
 
+- When fresh `next` advertises `task downstream-proof-recover`, Core has proved that every dirty
+  file outside the active Step belongs to a completed transitive predecessor and that recorded Git
+  history is intact. Invoke the exact lease-bound transition once. It preserves product files and
+  HEAD, invalidates stale predecessor completion authority with an append-only event, yields C1,
+  and routes the same Task to ordinary `task plan-set`. The replacement Plan, risk audit, and
+  execution authorization are fresh authority; no Task or Milestone recreation is involved.
+
+- When an older installed package cannot reach that recovery because its normal update preflight
+  requires a clean checkout, beta.12.6 permits one bounded dependency transport. The active
+  Milestone base and Task branch must first receive separate exact commits changing only
+  `package.json` and `package-lock.json`; product work remains dirty and uncommitted. Fresh beta.12.6
+  `next` must then advertise `update downstream-proof-dependency-recover`. Its preflight proves the
+  Task history at `HEAD^`, the dependency candidate at `HEAD`, aligned version surfaces, no lease or
+  transaction, exact predecessor ownership, and a content hash of the dirty set. Recovery registers
+  only the dependency commit. It does not mutate product files or Step state; fresh `next` must
+  proceed to `task downstream-proof-recover`, which outranks manifest-induced Knowledge staleness.
+
 - `update dependency-provenance-preflight --id <TASK-ID>` is read-only. The matching
   `update dependency-provenance-recover --id <TASK-ID> --expected-revision <N> --actor <ACTOR>
   --reason <TEXT>` is valid only when preflight and fresh `next` both advertise it. Historical
@@ -100,6 +117,8 @@ Current capability set:
 - `remediation-mode-recovery-v1`
 - `plan-proof-obligations-v1`
 - `bounded-plan-integrity-recovery-v1`
+- `downstream-proof-predecessor-recovery-v1`
+- `active-downstream-proof-dependency-recovery-v1`
 - `corrective-yield-journal-v1`
 - `corrective-replan-journal-v1`
 - `corrective-replan-human-gate-v1`
@@ -175,6 +194,13 @@ actor through `--actor`; reviewer identity remains internal to the route.
 An unrecorded commit is Git history drift. Stop instead of adding another commit or editing
 workflow state manually; recovery remains coordinator-controlled.
 
+If a Docker proof fails with `EPERM`, `operation not permitted`, or `permission denied` at the
+Docker socket/CLI boundary, classify it as sandbox access, not daemon failure. Re-run the exact
+read-only health probe or Plan command once with sandbox escalation; do not charge an infrastructure
+retry. Restarting Docker Desktop or pulling another image is forbidden on this evidence alone. A
+Docker infrastructure failure exists only when an escalated call reaches Docker and independently
+proves the daemon unavailable.
+
 ## Plan Risk Audit and remediation breaker
 
 Before `task authorize`, every new alpha.7 Task requires:

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

@@ -67,6 +67,20 @@ active writer token when the C1 contract requires it. The recovery records only
 `task run` merely to manufacture the second failure, and never invoke this recovery for a generic
 test failure, a writable manifest, or unconfined changes.
 
+When fresh `next` advertises `task downstream-proof-recover`, the active proof Step has produced
+uncommitted files inside its own `allowedWrites` and has also exposed required changes owned by one
+or more completed transitive predecessor Steps. Do not invoke `task step-complete`: its scope is
+known to be stale. Use only the exact returned Task revision, claimant/lease actor, writer-token
+contract, and a substantive reason. The atomic recovery preserves the worktree and HEAD, moves the
+predecessor completion commits into historical `invalidatedStepCommits`, clears only the invalidated
+completion evidence, blocks the active proof Step, supersedes execution authorization, appends
+`downstream-proof-invalidations.jsonl`, releases C1/lease authority, and returns the same Task to
+ordinary `task plan-set`. Build the replacement Plan from the full unfinished remainder, attach a
+fresh Plan Risk Audit, then obtain fresh execution authorization. Never use this route for an
+unrelated dirty file, a non-predecessor file, unregistered Git history, strict-review evidence, or
+without explicit fresh `next` eligibility. Do not reset, stash, commit, or recreate the Task or
+Milestone around this transition.
+
 If any step fails, report the concrete diagnostic. Do not load workflow
 semantics from this skill.
 
@@ -109,7 +123,7 @@ command shape or consuming a replacement Discovery. Never rebind, refresh, repla
 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 beta.12.4 `next` advertises `task stop-override-prepare`, the route is limited to the exact
+When beta.12.6 `next` advertises `task stop-override-prepare`, the route is limited to the exact
 beta.11 attempt-four policy stop: two ordinary failures, one corrective failure, a matching
 attempt-3 `continue-fix`, and a matching attempt-4 `stop-escalate` under the unchanged Plan. Invoke
 prepare with the exact Task/Step/revision, explicit human actor, and user-supplied reason. It is
@@ -135,6 +149,23 @@ Core may account for exactly one Task revision per ordered verified recovery. Ne
 compatibility from revision arithmetic alone: continue only when fresh `next` returns the validated
 `task run` route. An unrelated extra revision remains a hard stop.
 
+For the exact beta.12.6 active-downstream-proof update deadlock, do not apply the ordinary
+clean-boundary update recipe and do not stash/reset/commit product work. This exception is available
+only when a completed transitive predecessor and the active proof Step already own the complete dirty
+set, no writer lease/transaction/Core operation exists, and the active Milestone base can be updated
+in a separate worktree. Commit only exact `package.json`/`package-lock.json` dependency changes on
+that base, then commit only the same dependency files on the current Task branch while leaving all
+product bytes untouched. Install the exact beta.12.6 package and use only a fresh advertised
+`update downstream-proof-dependency-recover`. Run its read-only preflight first and require
+`eligible=true`, empty blockers, exact Task revision and non-null `activeDownstreamProof` binding.
+Require recorded Task history to validate at `HEAD^` and the exact dependency-only candidate to be
+`HEAD`; neither boundary may contain an unrelated or unregistered commit. The mutation registers
+only the dependency HEAD. Immediately run sequential `status` then `next`;
+continue only to the returned `task downstream-proof-recover` (including advertised writer-credential
+recovery when required). Any unrelated dirty path, unknown history, wider candidate commit, stale
+base, version mismatch, lease, transaction, or different route is a hard stop and never authorizes
+manual external-state edits.
+
 When `next` returns `milestone initial-assembly`, execution is unavailable. Follow only the
 advertised `linked-task-assembly.commands` (`discovery start` and `discovery materialize`) until all
 intended linked Tasks exist. The closing `milestone plan-set` option appears only after at least one
@@ -155,6 +186,17 @@ For `task start`, the policy applies only when choosing `--workspace-owner local
 `task step-complete`, `task merge`, and `task sync-base`, the advertised transition itself
 writes Git metadata.
 
+Treat Docker access diagnostics before classifying an infrastructure failure. `EPERM`,
+`operation not permitted`, or `permission denied` while opening the Docker socket or invoking the
+Docker CLI from a sandbox means the proof is unavailable at the current execution boundary; it is
+not evidence that the daemon or image is broken. Re-run the exact read-only health probe or exact
+Plan check once with the required sandbox escalation. This escalation rerun does not consume a
+Workflow remediation attempt or a local infrastructure retry. Only an escalated probe that reaches
+Docker and reports an unavailable daemon may be classified as a Docker infrastructure failure.
+Never start, stop, or restart Docker Desktop, pull a substitute image, or mutate Docker state merely
+because the sandboxed call returned a permission error; those actions require their own explicit
+authorization and evidence.
+
 When `next` includes `writerTokenContract`, treat it as an exact first-call precondition. Retain
 the active writer lease from the first-field `writerLeaseReceipt` returned by `task run` and pass it using the advertised `option` for that
 transition. The token is sensitive: never print, summarize, persist, or substitute a redacted

package/schemas/downstream-proof-invalidation-event.schema.json

@@ -0,0 +1,70 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://codex-workflow.local/schemas/downstream-proof-invalidation-event.schema.json",
+  "title": "Codex Workflow V2 Downstream Proof Invalidation Event",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "eventId",
+    "taskId",
+    "previousTaskRevision",
+    "resultTaskRevision",
+    "planHash",
+    "activeStepId",
+    "invalidatedSteps",
+    "dirtyFiles",
+    "preservedHeadCommit",
+    "actor",
+    "reason",
+    "packageVersion",
+    "previousEventHash",
+    "recordedAt",
+    "eventHash"
+  ],
+  "properties": {
+    "eventId": { "type": "string", "pattern": "^DPI-[0-9A-HJKMNP-TV-Z]{26}$" },
+    "taskId": { "$ref": "#/$defs/taskId" },
+    "previousTaskRevision": { "type": "integer", "minimum": 1 },
+    "resultTaskRevision": { "type": "integer", "minimum": 2 },
+    "planHash": { "$ref": "#/$defs/hash64" },
+    "activeStepId": { "$ref": "#/$defs/stepId" },
+    "invalidatedSteps": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["stepId", "evidenceCommit", "triggerFiles"],
+        "properties": {
+          "stepId": { "$ref": "#/$defs/stepId" },
+          "evidenceCommit": { "$ref": "#/$defs/gitHash" },
+          "triggerFiles": {
+            "type": "array",
+            "uniqueItems": true,
+            "items": { "type": "string", "minLength": 1 }
+          }
+        }
+      }
+    },
+    "dirtyFiles": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": { "type": "string", "minLength": 1 }
+    },
+    "preservedHeadCommit": { "$ref": "#/$defs/gitHash" },
+    "actor": { "type": "string", "minLength": 1 },
+    "reason": { "type": "string", "minLength": 1 },
+    "packageVersion": { "type": "string", "minLength": 1 },
+    "previousEventHash": { "$ref": "#/$defs/nullableHash64" },
+    "recordedAt": { "type": "string", "format": "date-time" },
+    "eventHash": { "$ref": "#/$defs/hash64" }
+  },
+  "$defs": {
+    "taskId": { "type": "string", "pattern": "^TASK-[0-9A-HJKMNP-TV-Z]{26}$" },
+    "stepId": { "type": "string", "pattern": "^STEP-[0-9]{3}(?:-[A-Z0-9-]+)?$" },
+    "gitHash": { "type": "string", "pattern": "^[a-f0-9]{40}$" },
+    "hash64": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "nullableHash64": { "type": ["string", "null"], "pattern": "^[a-f0-9]{64}$" }
+  }
+}

package/schemas/task.schema.json

@@ -55,6 +55,11 @@
     },
     "replacementForTaskId": { "type": ["string", "null"], "pattern": "^TASK-[0-9A-HJKMNP-TV-Z]{26}$" },
     "replacedByTaskId": { "type": ["string", "null"], "pattern": "^TASK-[0-9A-HJKMNP-TV-Z]{26}$" },
+    "invalidatedStepCommits": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": { "type": "string", "pattern": "^[a-f0-9]{40}$" }
+    },
     "dependencyProvenanceRecoveries": {
       "type": "array",
       "items": {
@@ -73,6 +78,28 @@
             "type": "array",
             "uniqueItems": true,
             "items": { "type": "string", "pattern": "^[a-f0-9]{40}$" }
+          },
+          "activeDownstreamProof": {
+            "type": "object",
+            "required": ["activeStepId", "planHash", "dirtyFiles", "dirtyWorktreeHash", "invalidatedStepIds"],
+            "properties": {
+              "activeStepId": { "type": "string", "pattern": "^STEP-[A-Z0-9][A-Z0-9-]{2,63}$" },
+              "planHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+              "dirtyFiles": {
+                "type": "array",
+                "minItems": 1,
+                "uniqueItems": true,
+                "items": { "type": "string", "minLength": 1 }
+              },
+              "dirtyWorktreeHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+              "invalidatedStepIds": {
+                "type": "array",
+                "minItems": 1,
+                "uniqueItems": true,
+                "items": { "type": "string", "pattern": "^STEP-[A-Z0-9][A-Z0-9-]{2,63}$" }
+              }
+            },
+            "additionalProperties": false
           }
         },
         "additionalProperties": false

package/scripts/generate-pdf-docs.py

@@ -200,6 +200,14 @@ def styles() -> dict[str, ParagraphStyle]:
             leading=10.3,
             textColor=TEXT,
         ),
+        "table_header": ParagraphStyle(
+            "TableHeader",
+            parent=base["BodyText"],
+            fontName="WorkflowBold",
+            fontSize=7.7,
+            leading=10.3,
+            textColor=colors.white,
+        ),
         "code": ParagraphStyle(
             "Code",
             parent=base["BodyText"],
@@ -316,8 +324,11 @@ def markdown_story(lines: list[str], style: dict[str, ParagraphStyle]) -> list:
             column_count = max(len(row) for row in rows)
             normalized = [row + [""] * (column_count - len(row)) for row in rows]
             rendered = [
-                [Paragraph(inline_markup(cell), style["small"]) for cell in row]
-                for row in normalized
+                [
+                    Paragraph(inline_markup(cell), style["table_header"] if row_index == 0 else style["small"])
+                    for cell in row
+                ]
+                for row_index, row in enumerate(normalized)
             ]
             table = LongTable(rendered, colWidths=table_widths(column_count), repeatRows=1)
             table.setStyle(TableStyle([