cabloy 5.1.201 → 5.1.202

package/.cabloy-version

@@ -1 +1 @@
-5.1.201
+5.1.202

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 5.1.202
+
+### Features
+
+- Add a traceability gate for planning baseline reviews.
+
 ## 5.1.201
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cabloy",
-  "version": "5.1.201",
+  "version": "5.1.202",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "A Node.js fullstack framework",
   "keywords": [

package/repo-agent-governance/managed-assets.json

@@ -179,21 +179,21 @@
     {
       "adapter": "codex",
       "category": "skill",
-      "sha256": "788f9c94a93753f2ad16d0a1f772fe61785514ab69e2564a2a2454f4efb46086",
+      "sha256": "e3441608051b6383385a9c4bd7fd77c8fc9e48a89293c4da81f05e067f9a8e8a",
       "source": "skills/cabloy-spec-execution/references/execution-protocol.md",
       "target": ".agents/skills/cabloy-spec-execution/references/execution-protocol.md"
     },
     {
       "adapter": "codex",
       "category": "skill",
-      "sha256": "ec93b6999fcf87f35f8f1f18eed54bb08ee2753862b34f6c474480f2c88ee7e0",
+      "sha256": "d9bc04fff4781daed907508efb36efe7e60fcf8d2de98e0089b175273f29e14e",
       "source": "skills/cabloy-spec-execution/references/status-and-evidence.md",
       "target": ".agents/skills/cabloy-spec-execution/references/status-and-evidence.md"
     },
     {
       "adapter": "codex",
       "category": "skill",
-      "sha256": "52a1a0ae16f72345a761d657130fd65b681535c20937a86d1d6f279772c9bb31",
+      "sha256": "60e20ef75f390a25464208470b6862f7a559d9eddf4d6f8012d2b99cc992c887",
       "source": "skills/cabloy-spec-execution/SKILL.md",
       "target": ".agents/skills/cabloy-spec-execution/SKILL.md"
     },
@@ -221,7 +221,7 @@
     {
       "adapter": "codex",
       "category": "skill",
-      "sha256": "df49ea0a8485de0ea6cf345199481836924eed0b68608abf4e6ed829f620b72e",
+      "sha256": "f4051409e04e5557a3d45415b8111e6a70b7bfa013b52ee75553ace29d28531c",
       "source": "skills/cabloy-spec-generation/references/canonical-spec-input.md",
       "target": ".agents/skills/cabloy-spec-generation/references/canonical-spec-input.md"
     },
@@ -235,21 +235,21 @@
     {
       "adapter": "codex",
       "category": "skill",
-      "sha256": "95fb6ad6f1f85373a6565442e4f0f50582acafd2bef5c8f1f0056123b0996bc8",
+      "sha256": "17aaee04e0db0bce9b09d72eb55181d062b0024974ed72014681be1c8490a6a1",
       "source": "skills/cabloy-spec-generation/references/repo-specs-document-set.md",
       "target": ".agents/skills/cabloy-spec-generation/references/repo-specs-document-set.md"
     },
     {
       "adapter": "codex",
       "category": "skill",
-      "sha256": "45b83917c079306fb56e0c2cf406a894f7c18c9fd8732f97f9902ed02cf32594",
+      "sha256": "4174bef895433d6bdfd6238c6a90391e825e1dce90194cfd47bd6aa2d7a02494",
       "source": "skills/cabloy-spec-generation/references/traceability-and-status-rules.md",
       "target": ".agents/skills/cabloy-spec-generation/references/traceability-and-status-rules.md"
     },
     {
       "adapter": "codex",
       "category": "skill",
-      "sha256": "1fae802d5b5f2fac97c4b223870d933e9fd551fdc37b5ac3a0acaa4f40efd45b",
+      "sha256": "4d7c6a45eb8854ac50a04e8cbf878c7b47dc5253dad05b9cea7ed0ec2b28b1d0",
       "source": "skills/cabloy-spec-generation/SKILL.md",
       "target": ".agents/skills/cabloy-spec-generation/SKILL.md"
     },
@@ -515,21 +515,21 @@
     {
       "adapter": "claude",
       "category": "skill",
-      "sha256": "788f9c94a93753f2ad16d0a1f772fe61785514ab69e2564a2a2454f4efb46086",
+      "sha256": "e3441608051b6383385a9c4bd7fd77c8fc9e48a89293c4da81f05e067f9a8e8a",
       "source": "skills/cabloy-spec-execution/references/execution-protocol.md",
       "target": ".claude/skills/cabloy-spec-execution/references/execution-protocol.md"
     },
     {
       "adapter": "claude",
       "category": "skill",
-      "sha256": "ec93b6999fcf87f35f8f1f18eed54bb08ee2753862b34f6c474480f2c88ee7e0",
+      "sha256": "d9bc04fff4781daed907508efb36efe7e60fcf8d2de98e0089b175273f29e14e",
       "source": "skills/cabloy-spec-execution/references/status-and-evidence.md",
       "target": ".claude/skills/cabloy-spec-execution/references/status-and-evidence.md"
     },
     {
       "adapter": "claude",
       "category": "skill",
-      "sha256": "52a1a0ae16f72345a761d657130fd65b681535c20937a86d1d6f279772c9bb31",
+      "sha256": "60e20ef75f390a25464208470b6862f7a559d9eddf4d6f8012d2b99cc992c887",
       "source": "skills/cabloy-spec-execution/SKILL.md",
       "target": ".claude/skills/cabloy-spec-execution/SKILL.md"
     },
@@ -557,7 +557,7 @@
     {
       "adapter": "claude",
       "category": "skill",
-      "sha256": "df49ea0a8485de0ea6cf345199481836924eed0b68608abf4e6ed829f620b72e",
+      "sha256": "f4051409e04e5557a3d45415b8111e6a70b7bfa013b52ee75553ace29d28531c",
       "source": "skills/cabloy-spec-generation/references/canonical-spec-input.md",
       "target": ".claude/skills/cabloy-spec-generation/references/canonical-spec-input.md"
     },
@@ -571,21 +571,21 @@
     {
       "adapter": "claude",
       "category": "skill",
-      "sha256": "95fb6ad6f1f85373a6565442e4f0f50582acafd2bef5c8f1f0056123b0996bc8",
+      "sha256": "17aaee04e0db0bce9b09d72eb55181d062b0024974ed72014681be1c8490a6a1",
       "source": "skills/cabloy-spec-generation/references/repo-specs-document-set.md",
       "target": ".claude/skills/cabloy-spec-generation/references/repo-specs-document-set.md"
     },
     {
       "adapter": "claude",
       "category": "skill",
-      "sha256": "45b83917c079306fb56e0c2cf406a894f7c18c9fd8732f97f9902ed02cf32594",
+      "sha256": "4174bef895433d6bdfd6238c6a90391e825e1dce90194cfd47bd6aa2d7a02494",
       "source": "skills/cabloy-spec-generation/references/traceability-and-status-rules.md",
       "target": ".claude/skills/cabloy-spec-generation/references/traceability-and-status-rules.md"
     },
     {
       "adapter": "claude",
       "category": "skill",
-      "sha256": "1fae802d5b5f2fac97c4b223870d933e9fd551fdc37b5ac3a0acaa4f40efd45b",
+      "sha256": "4d7c6a45eb8854ac50a04e8cbf878c7b47dc5253dad05b9cea7ed0ec2b28b1d0",
       "source": "skills/cabloy-spec-generation/SKILL.md",
       "target": ".claude/skills/cabloy-spec-generation/SKILL.md"
     },
@@ -865,21 +865,21 @@
     {
       "adapter": "cursor",
       "category": "skill",
-      "sha256": "788f9c94a93753f2ad16d0a1f772fe61785514ab69e2564a2a2454f4efb46086",
+      "sha256": "e3441608051b6383385a9c4bd7fd77c8fc9e48a89293c4da81f05e067f9a8e8a",
       "source": "skills/cabloy-spec-execution/references/execution-protocol.md",
       "target": ".cursor/skills/cabloy-spec-execution/references/execution-protocol.md"
     },
     {
       "adapter": "cursor",
       "category": "skill",
-      "sha256": "ec93b6999fcf87f35f8f1f18eed54bb08ee2753862b34f6c474480f2c88ee7e0",
+      "sha256": "d9bc04fff4781daed907508efb36efe7e60fcf8d2de98e0089b175273f29e14e",
       "source": "skills/cabloy-spec-execution/references/status-and-evidence.md",
       "target": ".cursor/skills/cabloy-spec-execution/references/status-and-evidence.md"
     },
     {
       "adapter": "cursor",
       "category": "skill",
-      "sha256": "52a1a0ae16f72345a761d657130fd65b681535c20937a86d1d6f279772c9bb31",
+      "sha256": "60e20ef75f390a25464208470b6862f7a559d9eddf4d6f8012d2b99cc992c887",
       "source": "skills/cabloy-spec-execution/SKILL.md",
       "target": ".cursor/skills/cabloy-spec-execution/SKILL.md"
     },
@@ -907,7 +907,7 @@
     {
       "adapter": "cursor",
       "category": "skill",
-      "sha256": "df49ea0a8485de0ea6cf345199481836924eed0b68608abf4e6ed829f620b72e",
+      "sha256": "f4051409e04e5557a3d45415b8111e6a70b7bfa013b52ee75553ace29d28531c",
       "source": "skills/cabloy-spec-generation/references/canonical-spec-input.md",
       "target": ".cursor/skills/cabloy-spec-generation/references/canonical-spec-input.md"
     },
@@ -921,21 +921,21 @@
     {
       "adapter": "cursor",
       "category": "skill",
-      "sha256": "95fb6ad6f1f85373a6565442e4f0f50582acafd2bef5c8f1f0056123b0996bc8",
+      "sha256": "17aaee04e0db0bce9b09d72eb55181d062b0024974ed72014681be1c8490a6a1",
       "source": "skills/cabloy-spec-generation/references/repo-specs-document-set.md",
       "target": ".cursor/skills/cabloy-spec-generation/references/repo-specs-document-set.md"
     },
     {
       "adapter": "cursor",
       "category": "skill",
-      "sha256": "45b83917c079306fb56e0c2cf406a894f7c18c9fd8732f97f9902ed02cf32594",
+      "sha256": "4174bef895433d6bdfd6238c6a90391e825e1dce90194cfd47bd6aa2d7a02494",
       "source": "skills/cabloy-spec-generation/references/traceability-and-status-rules.md",
       "target": ".cursor/skills/cabloy-spec-generation/references/traceability-and-status-rules.md"
     },
     {
       "adapter": "cursor",
       "category": "skill",
-      "sha256": "1fae802d5b5f2fac97c4b223870d933e9fd551fdc37b5ac3a0acaa4f40efd45b",
+      "sha256": "4d7c6a45eb8854ac50a04e8cbf878c7b47dc5253dad05b9cea7ed0ec2b28b1d0",
       "source": "skills/cabloy-spec-generation/SKILL.md",
       "target": ".cursor/skills/cabloy-spec-generation/SKILL.md"
     },

package/repo-agent-governance/skills/cabloy-spec-execution/SKILL.md

@@ -97,8 +97,8 @@ Stop and route back to the relevant planning authority if any of the following a
 - the suite identity, ownership, or target boundary is unresolved;
 - PRD/SRS/ADR/WBS/test-plan records contradict one another;
 - a controlling `TODO(confirm)` or unaccepted ADR remains;
-- a predecessor is not complete according to the WBS, or its required evidence is absent;
-- the selected task is already `verified`, explicitly `deferred`, or currently `blocked`;
+- a predecessor is neither `verified` nor formally opted-in `planning-complete` with a named-reviewer, revision-scoped documentary closure disposition, or its required evidence is absent; a planning-complete edge does not authorize execution;
+- the selected task is already `verified` or `planning-complete`, explicitly `deferred`, or currently `blocked`;
 - a persisted field/schema change lacks an explicit decision about incrementing `vonaModule.fileVersion`;
 - the working tree contains overlapping unclassified changes that make attribution or rollback unclear;
 - authorization, tenant isolation, privacy, lifecycle, transaction, concurrency, idempotency, or ownership behavior is unspecified for a material risk;
@@ -139,6 +139,7 @@ Record proof under `references/status-and-evidence.md`, preserving the establish
 Set status accurately:
 
 - `in-progress` while work or verification remains open;
+- `planning-complete` only for an opted-in documentary/design task after explicit named-reviewer, revision-scoped planning-closure disposition and linked planning evidence; never infer source/ATP closure or next-task approval;
 - `implementation-complete` when source work is complete but ATP/release proof remains;
 - `verified` only after all applicable WBS checks and ATPs have durable linked redacted evidence;
 - `blocked`, `waived`, or `deferred` only with the required details.

package/repo-agent-governance/skills/cabloy-spec-execution/references/execution-protocol.md

@@ -61,7 +61,7 @@ Before implementation, verify:
 
 - the WBS target exists and is bounded;
 - every material linked requirement has a technical contract and ATP;
-- predecessor status satisfies the WBS dependency rule and required evidence exists;
+- each predecessor is `verified`, or is `planning-complete` with its own formal `Completion mode: planning-only.` declaration, named-reviewer revision-scoped disposition and documentary proof; neither `implementation-complete` nor a traceability exception satisfies this edge;
 - no controlling `TODO(confirm)`, unaccepted ADR, waiver, or failed gate remains unresolved;
 - the selected task is not already `verified`, `deferred`, or `blocked`;
 - source ownership and the target API/state/page boundary are unambiguous;

package/repo-agent-governance/skills/cabloy-spec-execution/references/status-and-evidence.md

@@ -56,15 +56,16 @@ Do not create an empty `evidence/` directory, placeholder `EVD-*` record, or fab
 
 Use the suite’s canonical status meanings:
 
-| Status                    | Meaning                                                                                                                                                           |
-| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `not-started`             | Defined, but implementation or acceptance evidence has not started.                                                                                               |
-| `in-progress`             | Work or verification has started, but closure checks remain.                                                                                                      |
-| `implementation-complete` | Source work is reported complete, but required ATP or release evidence is incomplete.                                                                             |
-| `verified`                | Applicable WBS checks and ATPs passed, with durable traceable evidence containing revision, environment, exact procedure, result, and redacted artifact location. |
-| `blocked`                 | A dependency, unresolved decision, failed gate, attribution problem, or missing required proof prevents closure.                                                  |
-| `waived`                  | A temporary exception has an owner, reason, affected scope, and expiry; expiry becomes a release blocker.                                                         |
-| `deferred`                | Explicitly postponed scope; it is not complete or verified.                                                                                                       |
+| Status                    | Meaning                                                                                                                                                                 |
+| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `not-started`             | Defined, but implementation or acceptance evidence has not started.                                                                                                     |
+| `in-progress`             | Work or verification has started, but closure checks remain.                                                                                                            |
+| `planning-complete`       | An opted-in documentary/design-only WBS task has a named-reviewer, revision-scoped planning-closure disposition and retained planning proof; not source or ATP closure. |
+| `implementation-complete` | Source work is reported complete, but required ATP or release evidence is incomplete.                                                                                   |
+| `verified`                | Applicable WBS checks and ATPs passed, with durable traceable evidence containing revision, environment, exact procedure, result, and redacted artifact location.       |
+| `blocked`                 | A dependency, unresolved decision, failed gate, attribution problem, or missing required proof prevents closure.                                                        |
+| `waived`                  | A temporary exception has an owner, reason, affected scope, and expiry; expiry becomes a release blocker.                                                               |
+| `deferred`                | Explicitly postponed scope; it is not complete or verified.                                                                                                             |
 
 The normal path is:
 
@@ -72,7 +73,7 @@ The normal path is:
 not-started -> in-progress -> implementation-complete -> verified
 ```
 
-`blocked`, `waived`, and `deferred` are explicit states, not shortcuts to completion. Mark a task `in-progress` only after approved implementation or verification actually begins. A generated file, successful scaffold, passing typecheck, code review, manual walkthrough, screenshot, or unrelated broad test pass cannot by itself produce `verified`.
+A genuinely documentary/design-only task can instead follow `not-started -> in-progress -> planning-complete`, but only when its formal WBS declaration contains `Completion mode: planning-only.`, its own checks have revision-scoped documentary evidence, and a named reviewer explicitly records the planning-closure disposition. `authority-only` traceability is not this opt-in. `planning-complete` satisfies a predecessor dependency edge but never grants successor execution approval, accepts another ADR, completes source, or passes a linked prospective runtime ATP. The Gantt shows its status separately; verified totals and the burndown's active-minus-verified remainder still count only `verified`. `implementation-complete`, `waived` and `deferred` are not completed prerequisites. `blocked`, `waived`, and `deferred` are explicit states, not shortcuts to completion. Mark an implementation task `in-progress` only after approved implementation or verification actually begins. A generated file, successful scaffold, passing typecheck, code review, manual walkthrough, screenshot, or unrelated broad test pass cannot by itself produce `verified`.
 
 A task may be `implementation-complete` when source work is complete but an ATP, browser check, paired build, release gate, redaction decision, or durable artifact remains. A phase can be verified without implying that a separately defined integration or release phase is verified.
 

package/repo-agent-governance/skills/cabloy-spec-generation/SKILL.md

@@ -128,7 +128,7 @@ npm run spec:check -- <suite> --lightweight
 
 For incremental legacy gaps, report the missing definition/owner/link and affected chain without silently changing business meaning. If correction needs a new decision, request it and report the update as incomplete at that gate. Lightweight results must state skipped owners/chain coverage; never advertise a full-suite pass.
 
-Planning creation alone initializes delivery as `not-started`, `deferred`, or specifically `blocked`. Preserve carried-forward observed evidence with its revision/authority limits. Do not run init, database reset, scaffolding, deployment/provider operations, or acceptance tests as an automatic consequence of planning.
+Planning creation alone initializes delivery as `not-started`, `deferred`, or specifically `blocked`. `planning-complete` is only available to a formally opted-in documentary/design task after its own checks receive revision-scoped proof and a named-reviewer closure disposition; it is not ATP verification or permission to execute a successor. Preserve carried-forward observed evidence with its revision/authority limits. Do not run init, database reset, scaffolding, deployment/provider operations, or acceptance tests as an automatic consequence of planning.
 
 ## 10. Finish with a bounded execution handoff
 

package/repo-agent-governance/skills/cabloy-spec-generation/references/canonical-spec-input.md

@@ -19,6 +19,8 @@ Use exact instantiated IDs in declaration-body Traceability. A wildcard or abbre
 
 For a genuinely cross-cutting engineering contract without a product requirement, an atomic SRS bullet may carry `Traceability exception: technical-only — <record-specific rationale>` on its definition line. This exempts only the incoming PRD association; its outgoing WBS mapping remains required. For a documentary planning or release gate with no independent executable scenario, a WBS task may carry `Traceability exception: authority-only — <record-specific rationale>` in its declaration body. This exempts only the outgoing ATP association; its incoming SRS mapping remains required. Use exactly one well-formed field on the correct definition and explain the alternative authority or retained documentary checks. The auditor rejects malformed, empty, duplicated, or wrong-kind exceptions. Neither classification waives the underlying contract, delivery checks, applicable ATPs, revision-scoped evidence, or release approval; never use one merely to silence a missing real link.
 
+For a Phase 10 task that reviews the entire planning baseline rather than implementing one SRS or executing one ATP, use the separate `Traceability mode: planning-baseline-review` classification and accepted local ADR review authority described in `traceability-and-status-rules.md`. It exempts only that WBS task's incoming SRS and outgoing ATP checks. Do not combine it with a `Traceability exception` or apply it to product-delivery, contract-loop, migration, or release work. Classification alone does not establish approval, proof, `planning-complete` eligibility, or `verified` status; a separate task-local `Completion mode: planning-only.` declaration is required for planning closure.
+
 ## Minimal connected example
 
 These are neutral **syntax examples**, not business requirements to copy into a real suite. All four IDs are exact and unique. Production bodies must describe the approved domain.
@@ -69,7 +71,7 @@ Acceptance checks:
 - The selected ATP passes and retains its required proof.
 ```
 
-Each phase has explicit Dependencies, using `none` when no predecessor exists. Task-level Dependencies override the phase Dependencies for that task; they are not accumulated automatically. Do not rely on an empty dependency label to mean none. Keep phases dependency-ordered and task scope bounded. WBS bodies own linked IDs, tasks, and checks; progress does not add them.
+Each phase has explicit Dependencies, using `none` when no predecessor exists. Task-level Dependencies override the phase Dependencies for that task; they are not accumulated automatically. Do not rely on an empty dependency label to mean none. Keep phases dependency-ordered and task scope bounded. WBS bodies own linked IDs, tasks, and checks; progress does not add them. For a genuinely documentary/design-only task, the formal task declaration may add exactly one `Completion mode: planning-only.` field. This opt-in is not a phase default or a traceability exception: its own checks still need a named reviewer, a revision-scoped planning-closure disposition and linked documentary proof before progress can say `planning-complete`. Keep linked prospective runtime ATPs intact and unpassed.
 
 ### test-plan.md
 
@@ -109,7 +111,7 @@ Setup, Procedure, Expected result, Minimum proof, and Traceability must each be
 | `WBS-DEMO-10-01` | `not-started` | None; execution has not begun. | Confirm the bounded execution dossier. |
 ```
 
-Resolve columns by header names (`WBS ID` and `Status`), never fixed cell positions. Additional/reordered columns are allowed. Require one row for every formal WBS task when constructing the complete chart model. Preserve the established status vocabulary and explain blockers/waivers precisely.
+Resolve columns by header names (`WBS ID` and `Status`), never fixed cell positions. Additional/reordered columns are allowed. Require one row for every formal WBS task when constructing the complete chart model. Preserve the established status vocabulary and explain blockers/waivers precisely. `planning-complete` is valid only for a task declaring `Completion mode: planning-only.` in its WBS body; it satisfies a predecessor dependency edge but does not grant successor execution approval, count as verified, or reduce the verified-based burndown remainder.
 
 ## Three gates, not one success signal
 

package/repo-agent-governance/skills/cabloy-spec-generation/references/repo-specs-document-set.md

@@ -137,10 +137,12 @@ Every WBS entry should state:
 - primary source areas or ownership boundaries;
 - bounded tasks;
 - acceptance/completion checks;
-- linked PRD, SRS, and ATP identifiers where a real adjacent-authority association exists; a genuine documentary planning/release gate without an independent ATP uses the explicit `authority-only` classification and retains its SRS association and review evidence as specified in `canonical-spec-input.md`;
+- linked PRD, SRS, and ATP identifiers where a real adjacent-authority association exists; a genuine documentary planning/release gate without an independent ATP uses the explicit `authority-only` classification and retains its SRS association and review evidence as specified in `canonical-spec-input.md`. A whole-baseline planning review with neither a specific SRS nor a formal ATP instead uses `planning-baseline-review` and an accepted local ADR review authority as specified in `traceability-and-status-rules.md`;
 - whether it is planned, implemented, or awaiting evidence.
 
-Begin with a documentation/decision implementation gate before feature work. For differing Web/Admin strategies, split shared-site integration and independent-site delivery into separate frontend tasks when their source facts, dependencies, or proof differ. An unresolved strategy or exact runtime identifier may block only the affected implementation task; preserve runnable discovery work and unaffected backend or audience work as accurately actionable. Prefer vertical, verifiable increments. Include migration and release hardening as explicit work. Keep `implementation-complete` distinct from `verified`.
+For a documentary/design-only task, declare `Completion mode: planning-only.` in that task's formal WBS body. The declaration makes `planning-complete` eligible only after the task's own checks receive a named-reviewer, revision-scoped closure disposition and retained documentary proof; it does not close linked future runtime ATPs or approve subsequent implementation. This is independent of `planning-baseline-review` and the `authority-only` traceability exception. Other tasks keep ordinary implementation and ATP closure rules.
+
+Begin with a documentation/decision implementation gate before feature work. A planning-baseline review gate does not execute an ATP or acquire `verified` status from its audit classification. For differing Web/Admin strategies, split shared-site integration and independent-site delivery into separate frontend tasks when their source facts, dependencies, or proof differ. An unresolved strategy or exact runtime identifier may block only the affected implementation task; preserve runnable discovery work and unaffected backend or audience work as accurately actionable. Prefer vertical, verifiable increments. Include migration and release hardening as explicit work. Keep `implementation-complete` distinct from `verified`.
 
 ## Test-plan template contract
 
@@ -188,17 +190,18 @@ Use:
 
 Initialize a new suite with statuses such as `not-started`, `deferred`, or explicitly `blocked`; do not mark planning work as verified. Use this vocabulary:
 
-| Status                    | Meaning                                                                                                                       |
-| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
-| `not-started`             | Defined, but implementation or acceptance evidence has not started.                                                           |
-| `in-progress`             | Work started, but closure checks are incomplete.                                                                              |
-| `implementation-complete` | Source work is reported complete, but required ATP evidence or release gates are incomplete.                                  |
-| `verified`                | Required ATP evidence is observed and retained with revision, environment, procedure, result, and redacted artifact location. |
-| `blocked`                 | A dependency, unresolved decision, or failed gate prevents closure.                                                           |
-| `waived`                  | A temporary exception with owner, reason, and expiry; expiry makes it a release blocker.                                      |
-| `deferred`                | Explicitly postponed scope, not completed scope.                                                                              |
-
-Progress must remain a derived register. It may point to evidence but must not become a second requirements document. Include a decision-register entry for each material site strategy and show strategy/identifier deferral as a blocker only on affected frontend/site WBS branches; source reading, planning, or a selected strategy alone is not implementation evidence.
+| Status                    | Meaning                                                                                                                                                              |
+| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `not-started`             | Defined, but implementation or acceptance evidence has not started.                                                                                                  |
+| `in-progress`             | Work started, but closure checks are incomplete.                                                                                                                     |
+| `planning-complete`       | An explicitly opted-in planning task's own documentary checks have a named-reviewer, revision-scoped closure disposition and linked proof; not runtime verification. |
+| `implementation-complete` | Source work is reported complete, but required ATP evidence or release gates are incomplete.                                                                         |
+| `verified`                | Required ATP evidence is observed and retained with revision, environment, procedure, result, and redacted artifact location.                                        |
+| `blocked`                 | A dependency, unresolved decision, or failed gate prevents closure.                                                                                                  |
+| `waived`                  | A temporary exception with owner, reason, and expiry; expiry makes it a release blocker.                                                                             |
+| `deferred`                | Explicitly postponed scope, not completed scope.                                                                                                                     |
+
+A `planning-complete` predecessor satisfies its dependency edge, not the next task's design/approval gates; keep a blocked successor blocked. Verified/remaining burndown counts still count only `verified` as complete. Progress must remain a derived register. It may point to evidence but must not become a second requirements document. Include a decision-register entry for each material site strategy and show strategy/identifier deferral as a blocker only on affected frontend/site WBS branches; source reading, planning, or a selected strategy alone is not implementation evidence.
 
 ## ADR 0001 template contract
 

package/repo-agent-governance/skills/cabloy-spec-generation/references/traceability-and-status-rules.md

@@ -49,6 +49,12 @@ Minimum cardinality for a material in-scope requirement:
 
 A single ATP may prove several related requirements, but the matrices must make the relationship explicit. A WBS item may cover several contracts, but it still needs bounded completion checks. The full-chain minimum applies to material in-scope product requirements; a separately sourced engineering obligation or a documentary coordination gate need not invent a product parent or an executable ATP. Use the narrowly scoped declaration-local `Traceability exception` classifications in `canonical-spec-input.md` only for those genuine cases. The unaffected direction still needs an exact-ID link, and review/closure still needs applicable retained proof. An exception is not a deferred status, evidence waiver, acceptance result, or release approval.
 
+### Planning-baseline review gate
+
+A WBS task that solely reviews and approves the whole PRD/SRS/WBS/ATP baseline before feature work may declare `Traceability mode: planning-baseline-review` in its own Phase 10 task body. It must name a local accepted boundary ADR under `decisions/` as `Review authority: [ADR](./decisions/<file>.md)`, and retain substantive Tasks and Acceptance checks for the baseline review. It must not claim to implement a specific SRS contract or execute a formal ATP, including in its title, Tasks, or Acceptance checks. The ADR may use the existing `## Status` followed by `Accepted` or `Accepted.` convention; the auditor does not require new owner or acceptance fields in the ADR, and acceptance of the ADR alone does not prove the review occurred. This explicit process gate alone is exempt from the WBS-specific SRS incoming and ATP outgoing exact-ID checks in the complete audit; all product-chain definitions, ordinary WBS tasks, references, dependencies, and progress remain checked. It cannot classify implementation, migration, contract-loop, release, or mixed-scope work. Do not infer this type from a title, task number, review status, or a summary table, and do not combine it with `Traceability exception: authority-only`.
+
+This differs from `authority-only`, which still requires an exact SRS incoming link and exempts only the ATP outgoing link. Both traceability classifications are independent of `Completion mode: planning-only.`; neither makes a task eligible for `planning-complete`. An audit exception is not approval or proof: the ADR decision owner must separately accept the baseline, and the progress record must retain that review's attributable approval before `verified` is appropriate. It does not create an ATP execution record, change any business traceability, or relax the evidence rule for other WBS work.
+
 ## Authority-first updates
 
 When a requirement or durable boundary changes:
@@ -67,17 +73,18 @@ Downstream records do not silently override authority. Charts cannot authorize s
 
 ## Status semantics
 
-| Status                    | Meaning                                                                                                                                              |
-| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `not-started`             | Defined, but implementation or acceptance evidence has not started.                                                                                  |
-| `in-progress`             | Work or verification has started, but closure checks are incomplete.                                                                                 |
-| `implementation-complete` | Source work is reported complete, but required ATP or release evidence is incomplete.                                                                |
-| `verified`                | Applicable WBS checks and ATPs passed, and durable evidence contains revision, environment, exact procedure, result, and redacted artifact location. |
-| `blocked`                 | A failed gate, dependency, or unresolved decision prevents closure.                                                                                  |
-| `waived`                  | A temporary exception explicitly approved with owner, reason, and expiry.                                                                            |
-| `deferred`                | Explicitly postponed scope; it is not complete or verified.                                                                                          |
-
-For a newly created plan, initialize delivery rows as `not-started`, `deferred`, or `blocked` as appropriate. Creating Markdown files never makes implementation `implementation-complete` or `verified`.
+| Status                    | Meaning                                                                                                                                                             |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `not-started`             | Defined, but implementation or acceptance evidence has not started.                                                                                                 |
+| `in-progress`             | Work or verification has started, but closure checks are incomplete.                                                                                                |
+| `planning-complete`       | Opted-in documentary/design-only WBS checks have a named-reviewer, revision-scoped closure disposition and retained planning proof; source and ATP remain unproven. |
+| `implementation-complete` | Source work is reported complete, but required ATP or release evidence is incomplete.                                                                               |
+| `verified`                | Applicable WBS checks and ATPs passed, and durable evidence contains revision, environment, exact procedure, result, and redacted artifact location.                |
+| `blocked`                 | A failed gate, dependency, or unresolved decision prevents closure.                                                                                                 |
+| `waived`                  | A temporary exception explicitly approved with owner, reason, and expiry.                                                                                           |
+| `deferred`                | Explicitly postponed scope; it is not complete or verified.                                                                                                         |
+
+For a newly created plan, initialize delivery rows as `not-started`, `deferred`, or `blocked` as appropriate. Creating Markdown files never makes a task `planning-complete`, implementation `implementation-complete`, or ATP `verified`. Only a formally declared `Completion mode: planning-only.` task with documentary acceptance checks, revision-scoped evidence and an explicit named-reviewer closure disposition may reach `planning-complete`; `authority-only` traceability does not establish this eligibility. A planning-complete predecessor satisfies its WBS dependency edge, but blocked/deferred/waived successors stay gated and require their own decisions and approvals. `implementation-complete`, `waived` and `deferred` do not satisfy predecessor completion. Only `verified` contributes to verified totals and the verified-based burndown remainder.
 
 ### README and ADR decision-status consistency
 

package/repo-agent-governance/tests/spec-audit.test.mjs

@@ -57,6 +57,267 @@ test('complete baseline checks exact traceability without treating a Proposed AD
   assert.match(result.limitations, /approval.*evidence authenticity/);
 });
 
+const PLANNING_GATE = {
+  ...BASELINE,
+  'srs.md': BASELINE['srs.md'].replace(', `WBS-DEMO-10-01`', ''),
+  'test-plan.md': BASELINE['test-plan.md'].replace('Traceability: `WBS-DEMO-10-01`', ''),
+  'pdp-wbs.md':
+    '# Delivery\n\n### Phase 10: Baseline\n\nDependencies: none.\n\n#### WBS-DEMO-10-01: Review planning baseline\n\nTraceability mode: planning-baseline-review\n\nReview authority: [ADR](./decisions/0001-boundary.md).\n\nTasks:\n\n- Reconcile the whole requirements, contracts, work and acceptance catalogue.\n\nAcceptance checks:\n\n- Confirm the boundary ADR was accepted by its decision owner.\n',
+  'decisions/0001-boundary.md':
+    '# Boundary\n\n## Status\n\nAccepted.\n\n## Decision\n\nAccept the planning boundary.\n',
+};
+
+test('explicit planning-baseline gate omits only its WBS adjacency checks', async t => {
+  const result = await auditPlanning(await fixture(t, PLANNING_GATE));
+  assert.deepEqual(
+    result.diagnostics.map(diagnostic => [diagnostic.id, diagnostic.code]),
+    [
+      ['SRS-DEMO-01', 'traceability-outgoing'],
+      ['ATP-DEMO-01', 'traceability-incoming'],
+    ],
+  );
+  assert.equal(result.ok, false);
+});
+
+test('a planning gate coexists with a fully connected product chain', async t => {
+  const records = {
+    ...BASELINE,
+    'pdp-wbs.md': `${PLANNING_GATE['pdp-wbs.md']}\n#### WBS-DEMO-10-02: Implement contract\n\nTraceability: \`SRS-DEMO-01\`, \`ATP-DEMO-01\`.\n`,
+    'srs.md': BASELINE['srs.md'].replace('WBS-DEMO-10-01', 'WBS-DEMO-10-02'),
+    'test-plan.md': BASELINE['test-plan.md'].replace('WBS-DEMO-10-01', 'WBS-DEMO-10-02'),
+    'progress.md': `${BASELINE['progress.md']}| WBS-DEMO-10-02 | Implement contract | not-started |\n`,
+    'decisions/0001-boundary.md': PLANNING_GATE['decisions/0001-boundary.md'],
+  };
+  const result = await auditPlanning(await fixture(t, records));
+  assert.deepEqual(result.diagnostics, []);
+  assert.equal(result.ok, true);
+});
+
+test('planning closure and baseline traceability classification remain independent', async t => {
+  const records = {
+    ...BASELINE,
+    'pdp-wbs.md': `${PLANNING_GATE['pdp-wbs.md']}\n#### WBS-DEMO-10-02: Implement contract\n\nTraceability: \`SRS-DEMO-01\`, \`ATP-DEMO-01\`.\n`,
+    'srs.md': BASELINE['srs.md'].replace('WBS-DEMO-10-01', 'WBS-DEMO-10-02'),
+    'test-plan.md': BASELINE['test-plan.md'].replace('WBS-DEMO-10-01', 'WBS-DEMO-10-02'),
+    'progress.md': `${BASELINE['progress.md'].replace('not-started |', 'planning-complete |')}| WBS-DEMO-10-02 | Implement contract | not-started |\n`,
+    'decisions/0001-boundary.md': PLANNING_GATE['decisions/0001-boundary.md'],
+  };
+  const missingMode = await auditPlanning(await fixture(t, records));
+  assert.deepEqual(codes(missingMode), ['completion-mode']);
+  const withMode = {
+    ...records,
+    'pdp-wbs.md': records['pdp-wbs.md'].replace(
+      'Traceability mode: planning-baseline-review',
+      'Traceability mode: planning-baseline-review\n\nCompletion mode: planning-only.',
+    ),
+  };
+  const eligible = await auditPlanning(await fixture(t, withMode));
+  assert.equal(eligible.ok, true, JSON.stringify(eligible.diagnostics));
+  const invalidGate = await auditPlanning(
+    await fixture(t, {
+      ...withMode,
+      'pdp-wbs.md': withMode['pdp-wbs.md'].replace(
+        'Traceability mode: planning-baseline-review',
+        'Traceability mode: unknown',
+      ),
+    }),
+  );
+  assert.ok(codes(invalidGate).includes('traceability-mode'));
+  assert.ok(!codes(invalidGate).includes('completion-mode'));
+});
+
+test('planning review accepts existing and legacy accepted ADR status formats', async t => {
+  for (const status of [
+    '## Status\n\nAccepted.\n',
+    '## Status\n\nAccepted\n',
+    '- **Status:** Accepted\n',
+  ]) {
+    await t.test(status.trim().replace(/\n/g, ' '), async subtest => {
+      const records = {
+        ...PLANNING_GATE,
+        'decisions/0001-boundary.md': `# Boundary\n\n${status}`,
+      };
+      const result = await auditPlanning(await fixture(subtest, records));
+      assert.ok(!codes(result).includes('traceability-mode'), JSON.stringify(result.diagnostics));
+    });
+  }
+});
+
+test('baseline review prose may refer to the work catalogue without doing delivery work', async t => {
+  const records = {
+    ...PLANNING_GATE,
+    'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace(
+      '- Reconcile the whole requirements, contracts, work and acceptance catalogue.',
+      '- Review the implementation plan, build risks and migration strategy as planning inputs.',
+    ),
+  };
+  const result = await auditPlanning(await fixture(t, records));
+  assert.ok(!codes(result).includes('traceability-mode'), JSON.stringify(result.diagnostics));
+});
+
+test('baseline classification must be declared inside a bounded Phase 10 WBS task', async t => {
+  const cases = [
+    [
+      'unknown',
+      { 'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace('planning-baseline-review', 'skip') },
+    ],
+    [
+      'duplicate',
+      {
+        'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace(
+          'Tasks:',
+          'Traceability mode: planning-baseline-review\n\nTasks:',
+        ),
+      },
+    ],
+    ['wrong phase', { 'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace('Phase 10', 'Phase 20') }],
+    ['no tasks', { 'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace('Tasks:', 'Work:') }],
+    [
+      'no checks',
+      { 'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace('Acceptance checks:', 'Proof:') },
+    ],
+    [
+      'mixed scope',
+      {
+        'pdp-wbs.md': `${PLANNING_GATE['pdp-wbs.md']}\n- Implement SRS-DEMO-01 through ATP-DEMO-01.\n`,
+      },
+    ],
+    [
+      'no authority',
+      { 'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace('Review authority:', 'Reviewer:') },
+    ],
+    [
+      'unaccepted authority',
+      {
+        'decisions/0001-boundary.md': PLANNING_GATE['decisions/0001-boundary.md'].replace(
+          'Accepted.',
+          'Proposed.',
+        ),
+      },
+    ],
+    [
+      'implementation in title',
+      {
+        'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace(
+          'Review planning baseline',
+          'Review baseline and implement SRS-DEMO-01',
+        ),
+      },
+    ],
+    [
+      'release task',
+      {
+        'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace(
+          '- Reconcile the whole requirements, contracts, work and acceptance catalogue.',
+          '- Review the baseline and release the feature.',
+        ),
+      },
+    ],
+    [
+      'implementation task',
+      {
+        'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace(
+          '- Reconcile the whole requirements, contracts, work and acceptance catalogue.',
+          '- Review the baseline and implement the feature.',
+        ),
+      },
+    ],
+    [
+      'implementation acceptance check',
+      {
+        'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace(
+          '- Confirm the boundary ADR was accepted by its decision owner.',
+          '- Confirm the boundary ADR was accepted and deploy the feature.',
+        ),
+      },
+    ],
+    ...['Build the checkout backend.', 'Create a service.', 'Run a migration.'].map(instruction => [
+      instruction,
+      {
+        'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace(
+          '- Reconcile the whole requirements, contracts, work and acceptance catalogue.',
+          `- ${instruction}`,
+        ),
+      },
+    ]),
+    [
+      'unmapped contract in title',
+      {
+        'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace(
+          'Review planning baseline',
+          'Review planning baseline for SRS-DEMO-01',
+        ),
+      },
+    ],
+    [
+      'contradictory ADR statuses',
+      {
+        'decisions/0001-boundary.md': '## Status\n\nAccepted.\n\n- **Status:** Proposed\n',
+      },
+    ],
+    [
+      'ADR status inside unrelated section',
+      {
+        'decisions/0001-boundary.md': '# Boundary\n\n## Background\n\n- **Status:** Accepted\n',
+      },
+    ],
+    ['mapped from SRS', { 'srs.md': BASELINE['srs.md'] }],
+    ['mapped to ATP', { 'test-plan.md': BASELINE['test-plan.md'] }],
+    [
+      'misplaced',
+      {
+        'README.md': `${PLANNING_GATE['README.md']}\nTraceability mode: planning-baseline-review\n`,
+      },
+    ],
+    [
+      'competing exception',
+      {
+        'pdp-wbs.md': PLANNING_GATE['pdp-wbs.md'].replace(
+          'Tasks:',
+          'Traceability exception: authority-only — Review the whole baseline.\n\nTasks:',
+        ),
+      },
+    ],
+  ];
+  for (const [name, changed] of cases) {
+    await t.test(name, async subtest => {
+      const result = await auditPlanning(await fixture(subtest, { ...PLANNING_GATE, ...changed }));
+      assert.ok(codes(result).includes('traceability-mode'), JSON.stringify(result.diagnostics));
+      if (name !== 'misplaced' && name !== 'mapped from SRS') {
+        assert.ok(
+          result.diagnostics.some(
+            diagnostic =>
+              diagnostic.id === 'WBS-DEMO-10-01' && diagnostic.code === 'traceability-incoming',
+          ),
+        );
+      }
+      if (name !== 'misplaced' && name !== 'mapped to ATP' && name !== 'competing exception') {
+        assert.ok(
+          result.diagnostics.some(
+            diagnostic =>
+              diagnostic.id === 'WBS-DEMO-10-01' && diagnostic.code === 'traceability-outgoing',
+          ),
+        );
+      }
+    });
+  }
+});
+
+test('ordinary unmapped WBS retains its adjacency diagnostics beside a planning gate', async t => {
+  const records = {
+    ...PLANNING_GATE,
+    'pdp-wbs.md': `${PLANNING_GATE['pdp-wbs.md']}\n#### WBS-DEMO-10-02: Implement item\n\nTasks:\n\n- Implement the item.\n`,
+    'progress.md': `${PLANNING_GATE['progress.md']}| WBS-DEMO-10-02 | Implement item | not-started |\n`,
+  };
+  const result = await auditPlanning(await fixture(t, records));
+  assert.deepEqual(
+    result.diagnostics
+      .filter(diagnostic => diagnostic.id === 'WBS-DEMO-10-02')
+      .map(diagnostic => diagnostic.code),
+    ['traceability-incoming', 'traceability-outgoing'],
+  );
+});
+
 test('canonical atomic bullets carry their own inline traceability', async t => {
   const records = {
     ...BASELINE,
@@ -361,6 +622,68 @@ test('completed tasks cannot hide unfinished recorded prerequisites', async t =>
   );
 });
 
+test('planning-complete requires a task-local mode in full and lightweight audits', async t => {
+  const progress = BASELINE['progress.md'].replace('not-started |', 'planning-complete |');
+  for (const lightweight of [false, true]) {
+    const rejected = await auditPlanning(
+      await fixture(t, { ...BASELINE, 'progress.md': progress }),
+      { lightweight },
+    );
+    assert.ok(codes(rejected).includes('completion-mode'));
+    const approved = await auditPlanning(
+      await fixture(t, {
+        ...BASELINE,
+        'pdp-wbs.md': BASELINE['pdp-wbs.md'].replace(
+          'Completion checks:',
+          'Completion mode: planning-only.\n\nCompletion checks:',
+        ),
+        'progress.md': progress,
+      }),
+      { lightweight },
+    );
+    assert.equal(approved.ok, true, JSON.stringify(approved.diagnostics));
+  }
+});
+
+test('planning-complete prerequisites allow recorded closure but never unblock successors', async t => {
+  const wbs = `${BASELINE['pdp-wbs.md'].replace('Completion checks:', 'Completion mode: planning-only.\n\nCompletion checks:')}\n#### WBS-DEMO-10-02: Dependent review\n\nDependencies: WBS-DEMO-10-01.\n\nTraceability exception: authority-only — Retain the review decision.\n\nTraceability: \`SRS-DEMO-01\`.\n`;
+  const progress = `${BASELINE['progress.md'].replace('not-started |', 'planning-complete |')}| WBS-DEMO-10-02 | Dependent | planning-complete |\n`;
+  const records = { ...BASELINE, 'pdp-wbs.md': wbs, 'progress.md': progress };
+  const completed = await auditPlanning(await fixture(t, records));
+  assert.ok(codes(completed).includes('completion-mode'));
+  assert.ok(!codes(completed).includes('dependency-state'));
+  const blocked = await auditPlanning(
+    await fixture(t, {
+      ...records,
+      'progress.md': progress.replace('Dependent | planning-complete', 'Dependent | blocked'),
+    }),
+  );
+  assert.ok(!codes(blocked).includes('dependency-state'));
+  assert.ok(!codes(blocked).includes('completion-mode'));
+  const unfinished = await auditPlanning(
+    await fixture(t, {
+      ...records,
+      'progress.md': progress.replace('planning-complete |', 'implementation-complete |'),
+    }),
+  );
+  assert.ok(codes(unfinished).includes('dependency-state'));
+  const waived = await auditPlanning(
+    await fixture(t, {
+      ...records,
+      'progress.md': progress.replace('planning-complete |', 'waived |'),
+    }),
+  );
+  assert.ok(codes(waived).includes('dependency-state'));
+  const noMode = await auditPlanning(
+    await fixture(t, {
+      ...records,
+      'pdp-wbs.md': wbs.replace('Completion mode: planning-only.\n\n', ''),
+    }),
+  );
+  assert.ok(codes(noMode).includes('completion-mode'));
+  assert.ok(codes(noMode).includes('dependency-state'));
+});
+
 test('local Markdown destinations, fragments and reference links are checked', async t => {
   const records = {
     ...BASELINE,

package/repo-agent-governance/tools/spec-audit/audit.mjs

@@ -4,6 +4,8 @@ import { fileURLToPath } from 'node:url';
 
 import {
   findIdentifiers,
+  isPlanningCompleteEligible,
+  isPrerequisiteSatisfied,
   markdownLines,
   parseDefinitions,
   parseProgress,
@@ -160,6 +162,116 @@ function collectMappings(records, definitions) {
   return edges;
 }
 
+function acceptedDecision(markdown) {
+  if (!markdown) return false;
+  const lines = markdownLines(markdown);
+  const statuses = [];
+  let section = null;
+  for (const [index, { text, heading }] of lines.entries()) {
+    if (heading?.level === 2) section = heading.text;
+    const field = text.match(/^\s*-\s*\*\*Status:\*\*/i);
+    if (field && (section === null || /^Status$/i.test(section)))
+      statuses.push(text.slice(field[0].length).trim());
+    if (!heading || !/^Status$/i.test(heading.text)) continue;
+    const value = lines.slice(index + 1).find(record => {
+      if (record.heading && record.heading.level <= heading.level) return true;
+      return record.text.trim();
+    });
+    if (value && !(value.heading && value.heading.level <= heading.level))
+      statuses.push(value.text.trim());
+  }
+  return statuses.length > 0 && statuses.every(status => /^Accepted\.?$/i.test(status));
+}
+
+function planningBaselineGates(records, wbs, edges, exceptions, report) {
+  const gates = new Set();
+  const field = /^\s*(?:-\s*)?(?:\*\*)?Traceability mode(?:\*\*)?\s*:/i;
+  const declarations = new Map();
+  for (const [file, markdown] of records) {
+    for (const { text, line } of markdownLines(markdown)) {
+      if (!field.test(text)) continue;
+      const task =
+        file === 'pdp-wbs.md'
+          ? wbs?.tasks.find(candidate => candidate.line < line && candidate.endLine >= line)
+          : null;
+      if (!task) {
+        report(
+          'traceability-mode',
+          file,
+          line,
+          'Traceability mode must be declared inside a WBS task.',
+        );
+        continue;
+      }
+      if (!declarations.has(task.id)) declarations.set(task.id, []);
+      declarations.get(task.id).push({ text, line });
+    }
+  }
+  for (const task of wbs?.tasks ?? []) {
+    const declared = declarations.get(task.id);
+    if (!declared) continue;
+    const [{ text, line }] = declared;
+    const mode = text.replace(field, '').trim().replace(/`/g, '');
+    const body = markdownLines(task.body).map(record => record.text);
+    const deliveryAction =
+      /(?:^|[,;]\s*|\b(?:and|then|to)\s+)(?:implement|deploy|migrate|release|regenerate|develop|ship|code|build\b(?!\s+risks?\b)|create|run\s+(?:an?\s+)?(?:migrations?|tests?|ATP-|scenarios?)|execute\s+(?:an?\s+)?(?:ATP-|tests?|scenarios?))\b/i;
+    const mixedScope =
+      deliveryAction.test(task.title) ||
+      body.some(value => {
+        const bullet = value.match(/^\s*[-*]\s+(.*)/);
+        return bullet && deliveryAction.test(bullet[1].replace(/^\*\*[^*]+\*\*\s*/, ''));
+      });
+    const hasItems = label =>
+      body.some((value, index) => {
+        if (value.trim().toLowerCase() !== `${label}:`) return false;
+        const next = body.slice(index + 1).find(line => line.trim());
+        return Boolean(next?.trim().match(/^[-*] \S/));
+      });
+    const authorities = body.flatMap(value => {
+      const match = value.match(/^\s*(?:-\s*)?(?:\*\*)?Review authority(?:\*\*)?\s*:/i);
+      return match ? [value.replace(match[0], '').trim()] : [];
+    });
+    const authority = authorities[0]?.match(
+      /^\[([^\]]+)\]\((\.\/decisions\/[^/()]+\.md)\)(?:\s*\([^\n]*\))?\s*\.?$/,
+    );
+    const adr = authority?.[2].slice(2);
+    const decision = adr && records.get(adr);
+    const mappedIncoming = [...edges].some(
+      ([id, targets]) => id.startsWith('SRS-') && targets.has(task.id),
+    );
+    const valid =
+      declared.length === 1 &&
+      mode === 'planning-baseline-review' &&
+      task.phase.number === '10' &&
+      /\b(?:review|freeze)\b/i.test(task.title) &&
+      /\bbaseline\b/i.test(task.title) &&
+      hasItems('tasks') &&
+      hasItems('acceptance checks') &&
+      !mixedScope &&
+      !findIdentifiers(task.title, 'SRS-').length &&
+      !findIdentifiers(task.title, 'ATP-').length &&
+      !findIdentifiers(task.body, 'SRS-').length &&
+      !findIdentifiers(task.body, 'ATP-').length &&
+      !mappedIncoming &&
+      !edges.get(task.id)?.size &&
+      !exceptions.has(task.id) &&
+      authorities.length === 1 &&
+      acceptedDecision(decision);
+    if (!valid) {
+      report(
+        'traceability-mode',
+        'pdp-wbs.md',
+        line,
+        'Planning-baseline review requires one valid mode, Phase 10 baseline review, substantive review-only Tasks and Acceptance checks, no individual SRS/ATP mapping or other traceability exception, and one accepted local ADR review authority.',
+        task.id,
+      );
+      continue;
+    }
+    gates.add(task.id);
+  }
+  return gates;
+}
+
 function headingIds(markdown) {
   const slugs = new Set();
   const counts = new Map();
@@ -362,10 +474,23 @@ export async function auditPlanning(
               task.id,
             );
           }
-          if (['implementation-complete', 'verified'].includes(rows.get(task.id))) {
+          if (rows.get(task.id) === 'planning-complete' && !isPlanningCompleteEligible(task)) {
+            report(
+              'completion-mode',
+              'progress.md',
+              locations?.get(task.id)?.line ?? 1,
+              'Planning-complete requires a declaration-local Completion mode: planning-only field.',
+              task.id,
+            );
+          }
+          if (
+            ['planning-complete', 'implementation-complete', 'verified'].includes(rows.get(task.id))
+          ) {
             for (const dependency of task.dependencyIds) {
+              const predecessor = wbs.tasks.find(item => item.id === dependency);
               if (
-                ['not-started', 'in-progress', 'blocked', 'deferred'].includes(rows.get(dependency))
+                rows.has(dependency) &&
+                !isPrerequisiteSatisfied(predecessor, rows.get(dependency))
               ) {
                 report(
                   'dependency-state',
@@ -398,9 +523,10 @@ export async function auditPlanning(
   }
   if (!lightweight) {
     const edges = collectMappings(records, definitions);
+    const gates = planningBaselineGates(records, wbs, edges, exceptions, report);
     const incoming = new Set([...edges.values()].flatMap(values => [...values]));
     for (const [id, definition] of definitions) {
-      if (definition.status === 'deferred' || definition.deferred) continue;
+      if (definition.status === 'deferred' || definition.deferred || gates.has(id)) continue;
       if (!id.startsWith('PRD-') && !incoming.has(id) && exceptions.get(id) !== 'technical-only') {
         report(
           'traceability-incoming',

package/repo-agent-governance/tools/spec-charts/generate-implementation-charts.mjs

@@ -2,12 +2,20 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { basename, resolve } from 'node:path';
 
-import { markdownLines, parseAtpIds, parseProgress, parseWbs } from './spec-parser.mjs';
+import {
+  isPlanningCompleteEligible,
+  isPrerequisiteSatisfied,
+  markdownLines,
+  parseAtpIds,
+  parseProgress,
+  parseWbs,
+} from './spec-parser.mjs';
 export { parseAtpIds, parseProgress, parseWbs } from './spec-parser.mjs';
 
 const STATUS_COLORS = {
   'not-started': 'var(--blue)',
   'in-progress': 'var(--orange)',
+  'planning-complete': 'var(--teal)',
   'implementation-complete': 'var(--violet)',
   'verified': 'var(--aqua)',
   'blocked': 'var(--red)',
@@ -47,6 +55,7 @@ const COPY = {
     statuses: {
       'not-started': 'Not started',
       'in-progress': 'In progress',
+      'planning-complete': 'Planning complete',
       'implementation-complete': 'Implementation complete',
       'verified': 'Verified',
       'blocked': 'Blocked',
@@ -104,6 +113,7 @@ const COPY = {
     statuses: {
       'not-started': '未开始',
       'in-progress': '进行中',
+      'planning-complete': '规划完成',
       'implementation-complete': '实施完成',
       'verified': '已核验',
       'blocked': '受阻',
@@ -248,6 +258,11 @@ export function createChartModel({ readme, wbs, progress, testPlan }) {
     }
     task.recordedStatus = task.status;
     task.status = progressStatus;
+    if (task.status === 'planning-complete' && !isPlanningCompleteEligible(task)) {
+      throw new Error(
+        `${task.id} has planning-complete status without Completion mode: planning-only.`,
+      );
+    }
     if (task.deferred && task.status !== 'deferred') {
       throw new Error(
         `${task.id} is marked deferred in pdp-wbs.md but has progress status ${task.status}.`,
@@ -274,10 +289,10 @@ export function createChartModel({ readme, wbs, progress, testPlan }) {
   };
 }
 
-function style() {
+function style(planningComplete) {
   return `<style>
-    :root { --surface:#fcfcfb;--page:#f9f9f7;--ink:#0b0b0b;--secondary:#52514e;--muted:#898781;--grid:#e1e0d9;--axis:#c3c2b7;--blue:#2a78d6;--orange:#eb6834;--aqua:#1baf7a;--violet:#4a3aa7;--red:#e34948;--yellow:#eda100;--blue-wash:#eaf3fd;--aqua-wash:#e7f7f0; }
-    @media (prefers-color-scheme:dark) { :root { --surface:#1a1a19;--page:#0d0d0d;--ink:#fff;--secondary:#c3c2b7;--muted:#a09f99;--grid:#2c2c2a;--axis:#383835;--blue:#3987e5;--orange:#d95926;--aqua:#199e70;--violet:#9085e9;--red:#e66767;--yellow:#c98500;--blue-wash:#172435;--aqua-wash:#122b23; } }
+    :root { --surface:#fcfcfb;--page:#f9f9f7;--ink:#0b0b0b;--secondary:#52514e;--muted:#898781;--grid:#e1e0d9;--axis:#c3c2b7;--blue:#2a78d6;--orange:#eb6834;${planningComplete ? '--teal:#087f83;' : ''}--aqua:#1baf7a;--violet:#4a3aa7;--red:#e34948;--yellow:#eda100;--blue-wash:#eaf3fd;--aqua-wash:#e7f7f0; }
+    @media (prefers-color-scheme:dark) { :root { --surface:#1a1a19;--page:#0d0d0d;--ink:#fff;--secondary:#c3c2b7;--muted:#a09f99;--grid:#2c2c2a;--axis:#383835;--blue:#3987e5;--orange:#d95926;${planningComplete ? '--teal:#29aeb0;' : ''}--aqua:#199e70;--violet:#9085e9;--red:#e66767;--yellow:#c98500;--blue-wash:#172435;--aqua-wash:#122b23; } }
     .canvas{fill:var(--page)}.card{fill:var(--surface);stroke:var(--grid);stroke-width:1}.title{fill:var(--ink);font-family:Arial,Helvetica,sans-serif;font-size:27px;font-weight:700}.subtitle{fill:var(--secondary);font-family:Arial,Helvetica,sans-serif;font-size:14px}.heading{fill:var(--ink);font-family:Arial,Helvetica,sans-serif;font-size:13px;font-weight:700}.phase{fill:var(--ink);font-family:Arial,Helvetica,sans-serif;font-size:10px;font-weight:700}.task{fill:var(--ink);font-family:Arial,Helvetica,sans-serif;font-size:10px}.small{fill:var(--muted);font-family:Arial,Helvetica,sans-serif;font-size:9px}.caption{fill:var(--secondary);font-family:Arial,Helvetica,sans-serif;font-size:11px}.num{fill:var(--ink);font-family:Arial,Helvetica,sans-serif;font-size:11px;font-weight:700;font-variant-numeric:tabular-nums}.grid{stroke:var(--grid);stroke-width:1;shape-rendering:crispEdges}.axis{stroke:var(--axis);stroke-width:1;shape-rendering:crispEdges}.row:focus{outline:2px solid var(--ink);outline-offset:2px}
   </style>`;
 }
@@ -302,13 +317,13 @@ function renderChartTextLines(className, x, y, lines, lineHeight) {
   return `<text class="${className}" x="${x}" y="${y}">${lines.map((line, lineIndex) => `<tspan x="${x}" dy="${lineIndex ? lineHeight : 0}">${escapeXml(line)}</tspan>`).join('')}</text>`;
 }
 
-function svgDocument(title, desc, body, height, metadata) {
+function svgDocument(title, desc, body, height, metadata, planningComplete = false) {
   return `<?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" width="1600" height="${height}" viewBox="0 0 1600 ${height}" role="img" aria-labelledby="chart-title chart-desc">
   <title id="chart-title">${escapeXml(title)}</title>
   <desc id="chart-desc">${escapeXml(desc)}</desc>
   <metadata>${escapeXml(metadata)}</metadata>
-  ${style()}
+  ${style(planningComplete)}
   ${body}
 </svg>
 `;
@@ -392,9 +407,12 @@ export function renderGantt(model, suiteName) {
       },
     )
     .join('\n');
-  const completed = new Set(tasks.filter(task => task.status === 'verified').map(task => task.id));
+  const completed = new Set(
+    tasks.filter(task => isPrerequisiteSatisfied(task, task.status)).map(task => task.id),
+  );
   const nextTask = tasks.find(
     task =>
+      task.status !== 'planning-complete' &&
       task.status !== 'verified' &&
       task.status !== 'deferred' &&
       task.status !== 'waived' &&
@@ -418,6 +436,7 @@ export function renderGantt(model, suiteName) {
     body,
     height,
     t.metadata,
+    tasks.some(task => task.status === 'planning-complete'),
   );
 }
 

package/repo-agent-governance/tools/spec-charts/generate-implementation-charts.test.mjs

@@ -152,6 +152,88 @@ test('creates a mixed-status model with deferred scope separated', () => {
   assert.equal(model.activeTasks.length, 2);
   assert.equal(model.deferredTasks.length, 1);
   assert.equal(model.verified, 0);
+  assert.doesNotMatch(renderGantt(model, 'Demo'), /--teal:/);
+});
+
+test('planning completion requires an explicit task mode and preserves verified-only metrics', () => {
+  const wbs = files['pdp-wbs.md'].replace(
+    '#### WBS-10-01: Freeze the baseline',
+    '#### WBS-10-01: Freeze the baseline\n\nCompletion mode: planning-only.',
+  );
+  const progress = files['progress.md'].replace('`not-started`', '`planning-complete`');
+  assert.throws(
+    () =>
+      createChartModel({
+        readme: files['README.md'],
+        wbs: files['pdp-wbs.md'],
+        progress,
+        testPlan: files['test-plan.md'],
+      }),
+    /planning-complete status without Completion mode/,
+  );
+  const model = createChartModel({
+    readme: files['README.md'],
+    wbs,
+    progress,
+    testPlan: files['test-plan.md'],
+  });
+  assert.equal(model.tasks[0].completionMode, 'planning-only');
+  assert.equal(model.verified, 0);
+  const gantt = renderGantt(model, 'Demo');
+  assert.match(gantt, /Planning complete/);
+  assert.match(gantt, /--teal:#087f83/);
+  assert.doesNotMatch(renderBurndown(model, 'Demo'), /--teal:/);
+  assert.match(gantt, /class="caption" x="96" y="195">WBS-20-01: Deliver/);
+  assert.doesNotMatch(gantt, /class="caption" x="96" y="195">WBS-10-01/);
+  assert.match(renderBurndown(model, 'Demo'), />2 remaining · 0 verified</);
+  const blocked = createChartModel({
+    readme: files['README.md'],
+    wbs,
+    progress: progress.replace('`in-progress`', '`blocked`'),
+    testPlan: files['test-plan.md'],
+  });
+  assert.match(renderGantt(blocked, 'Demo'), /No dependency-ready WBS candidate is recorded/);
+  assert.equal(blocked.verified, 0);
+  const chinese = createChartModel({
+    readme: '# 中文规划\n\n完整中文记录。',
+    wbs,
+    progress,
+    testPlan: files['test-plan.md'],
+  });
+  assert.match(renderGantt(chinese, '示例'), /规划完成/);
+  assert.match(renderBurndown(chinese, '示例'), /2 剩余 · 0 已核验/);
+});
+
+test('completion mode must be unique, supported and task-local', () => {
+  const wbs = files['pdp-wbs.md'];
+  for (const value of ['unknown.', '', 'planning-only.\nCompletion mode: planning-only.']) {
+    assert.throws(
+      () => parseWbs(wbs.replace('Tasks:', `Completion mode: ${value}\n\nTasks:`)),
+      /Completion mode/,
+    );
+  }
+  assert.throws(
+    () =>
+      parseWbs(
+        wbs.replace('Dependencies: none.', 'Dependencies: none.\nCompletion mode: planning-only.'),
+      ),
+    /Completion mode must belong to a formal WBS task/,
+  );
+  assert.throws(
+    () => parseWbs(`Completion mode: planning-only.\n${wbs}`),
+    /Completion mode must belong to a formal WBS task/,
+  );
+  const progress = files['progress.md'].replace('`not-started`', '`planning-complete`');
+  assert.throws(
+    () =>
+      createChartModel({
+        readme: files['README.md'],
+        wbs: wbs.replace('Tasks:', 'Status: in-progress.\nCompletion mode: planning-only.\nTasks:'),
+        progress,
+        testPlan: files['test-plan.md'],
+      }),
+    /explicit.*Status in-progress.*planning-complete/,
+  );
 });
 
 test('selects the earliest dependency-ready WBS item', async t => {

package/repo-agent-governance/tools/spec-charts/spec-parser.mjs

@@ -2,6 +2,7 @@
 export const STATUS_ORDER = [
   'not-started',
   'in-progress',
+  'planning-complete',
   'implementation-complete',
   'verified',
   'blocked',
@@ -306,6 +307,16 @@ function normalizeStatus(value) {
   return normalized;
 }
 
+export function isPlanningCompleteEligible(task) {
+  return task.completionMode === 'planning-only';
+}
+
+export function isPrerequisiteSatisfied(task, status) {
+  return (
+    status === 'verified' || (status === 'planning-complete' && isPlanningCompleteEligible(task))
+  );
+}
+
 function reviewDateFromLine(line) {
   return (
     line.match(/(?:last reviewed|最后审查日期)\s*(?:[:：]\s*)?(\d{4}-\d{2}-\d{2})/i)?.[1] ?? null
@@ -360,7 +371,7 @@ export function parseProgress(markdown, { file } = {}) {
 }
 
 function labeledValue(record, labels) {
-  const match = record.text.trim().match(/^([A-Z]+)\s*:(.*)$/i);
+  const match = record.text.trim().match(/^([A-Z]+(?:\s+[A-Z]+)*)\s*:(.*)$/i);
   return match && labels.includes(match[1].toLowerCase()) ? match[2].trim() : null;
 }
 
@@ -502,6 +513,11 @@ export function parseWbs(markdown, { file } = {}) {
       task = null;
       inPhase = false;
     }
+    if (!task && labeledValue(record, ['completion mode']) !== null) {
+      throw new Error(
+        `Completion mode must belong to a formal WBS task at ${atLocation(record, file)}.`,
+      );
+    }
     if (!inPhase) continue;
     if (task) task.body.push(record);
     else if (!phase.tasks.length) phase.preamble.push(record);
@@ -519,6 +535,29 @@ export function parseWbs(markdown, { file } = {}) {
         ? { line: dependency.line, ...(file ? { file } : {}) }
         : undefined;
       task.phase = { number: phase.number, title: phase.title };
+      const modeRecords = task.body.filter(
+        record => labeledValue(record, ['completion mode']) !== null,
+      );
+      if (modeRecords.length > 1) {
+        throw new Error(
+          `Multiple ${task.id} Completion mode fields at ${atLocation(modeRecords[1], file)}.`,
+        );
+      }
+      const mode = modeRecords.length
+        ? labeledValue(modeRecords[0], ['completion mode'])
+            .replace(/`/g, '')
+            .replace(/\.$/, '')
+            .toLowerCase()
+        : undefined;
+      if (mode && mode !== 'planning-only') {
+        throw new Error(
+          `Unsupported ${task.id} Completion mode at ${atLocation(modeRecords[0], file)}.`,
+        );
+      }
+      if (modeRecords.length && !mode) {
+        throw new Error(`Empty ${task.id} Completion mode at ${atLocation(modeRecords[0], file)}.`);
+      }
+      task.completionMode = mode;
       const statusRecords = task.body.filter(record => labeledValue(record, ['status']) !== null);
       if (statusRecords.length > 1) {
         throw new Error(

package/repo-docs/ai/ai-spec-driven-development.md

@@ -53,6 +53,7 @@ For the detailed authority table, identifiers, and chart boundary, see [Generate
 
 **Evidence-gated delivery** means delivery status stays precise about what is known and what has been proven.
 
+- `planning-complete` means an explicitly `planning-only` WBS task's documentary checks have a named-reviewer, revision-scoped closure disposition and retained planning proof. It satisfies that task's prerequisite edge, not implementation, ATP, successor approval, or release.
 - `implementation-complete` means the source work is complete, while required ATP or release proof remains.
 - `verified` means all applicable WBS checks and ATPs have durable, linked, redacted observed evidence.
 

package/repo-docs/ai/playbook-spec-execution.md

@@ -109,11 +109,12 @@ Use the narrowest approved check first, then follow the linked ATP procedures an
 
 Use status precisely:
 
-- `in-progress` — approved implementation or verification has actually begun
+- `in-progress` — approved work or verification has actually begun
+- `planning-complete` — only an opted-in documentary/design WBS task with a named-reviewer, revision-scoped closure disposition and linked planning proof; no source or ATP closure
 - `implementation-complete` — source work is complete, but required ATP or release proof remains
 - `verified` — all applicable WBS checks and ATPs have durable, linked, redacted observed evidence
 
-A successful build, generation command, hook, manual walkthrough, screenshot, or unrelated test run is not by itself `verified` unless the authoritative test plan defines it as sufficient retained proof. Evidence is revision- and authority-scoped; mark old proof superseded or requiring rerun when relevant source or authority changes.
+`planning-complete` satisfies a predecessor dependency edge but does not unblock a task still recorded `blocked` or grant an execution dossier. Charts count only `verified` toward verified/remaining metrics. A successful build, generation command, hook, manual walkthrough, screenshot, or unrelated test run is not by itself `verified` unless the authoritative test plan defines it as sufficient retained proof. Evidence is revision- and authority-scoped; mark old proof superseded or requiring rerun when relevant source or authority changes.
 
 ## Refresh derived charts last
 

package/repo-docs/ai/playbook-spec-generation.md

@@ -115,7 +115,7 @@ PRD → SRS → WBS → ATP → Evidence
 
 A product or technical change belongs in its PRD, SRS, or accepted ADR before its WBS, acceptance, progress, evidence, and chart implications are updated. A progress entry or chart cannot introduce a requirement, resolve a contract conflict, or accept an ADR.
 
-Planning records and derived charts do not establish `implementation-complete` or `verified`. `verified` requires the applicable acceptance procedure and retained, redacted observed evidence. A generated plan, planned command, scaffold, screenshot, or unrelated check is not automatically sufficient proof.
+A WBS task may declare `Completion mode: planning-only.` only for documentary/design-only checks. It can reach `planning-complete` after an explicit named-reviewer, revision-scoped closure disposition and linked planning proof; this satisfies its dependency edge without executing source, passing future ATPs, unblocking a recorded `blocked` successor, or counting as `verified` in charts. Planning records and derived charts do not establish `implementation-complete` or `verified`. `verified` requires the applicable acceptance procedure and retained, redacted observed evidence. A generated plan, planned command, scaffold, screenshot, or unrelated check is not automatically sufficient proof.
 
 ## Check planning without claiming implementation