cabloy 5.1.201 → 5.1.203

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/skills/cabloy-workflow/SKILL.md

@@ -107,11 +107,11 @@ The reason is simple: these files are where Cabloy already encodes its real work
 
 ### Parallel worktree environment setup
 
-When a request involves a second worktree, concurrent Vona/Zova development, isolated ordinary tests, or managed clean E2E, classify it as fullstack workflow setup. Read [Parallel Worktree Environment](../../../repo-docs/fullstack/parallel-worktree-environment.md), the canonical shared recipe maintained in Cabloy Basic for both editions.
+When a request involves a second worktree, concurrent Vona/Zova development, isolated ordinary tests, or managed E2E, classify it as fullstack workflow setup. Read [Parallel Worktree Environment](../../../repo-docs/fullstack/parallel-worktree-environment.md), the canonical shared recipe maintained in Cabloy Basic for both editions.
 
 This routing skill provides read-only guidance only. Do not infer an `APP_NAME` or ports, edit local overrides, or run `npm run init` from a generic worktree request. When the user wants confirmation-gated local environment setup, ask them to explicitly invoke `/cabloy-worktree-environment`.
 
-The invoked skill detects Basic or Start to select the active root scripts and managed clean-E2E command. It uses Git worktree metadata, fixed Vona/Zova port baselines, and the worktree basename to recommend the complete standard tuple for confirmation: `APP_NAME`, `SERVER_LISTEN_PORT`, `DEV_SERVER_PORT`, `DEV_SERVER_HMR_PORT`, and an `API_BASE_URL` derived from the Vona port. After confirmation, it writes both `vona/env/.env.local` and `zova/env/.env.local`; never use flavor-, mode-, app-mode-, or runtime-specific `.env.*.local` files. It does not inspect environment-file content or allocate/reserve a live port. The shared environment is Vona + Zova development: Admin and Web are alternative commands using the same configuration, and they must not run concurrently in one worktree. Concurrent use requires separately configured linked worktrees.
+The invoked skill detects Basic or Start to select the active root scripts and managed E2E command. It uses Git worktree metadata, fixed Vona/Zova port baselines, and the worktree basename to recommend the complete standard tuple for confirmation: `APP_NAME`, `SERVER_LISTEN_PORT`, `DEV_SERVER_PORT`, `DEV_SERVER_HMR_PORT`, and an `API_BASE_URL` derived from the Vona port. After confirmation, it writes both `vona/env/.env.local` and `zova/env/.env.local`; never use flavor-, mode-, app-mode-, or runtime-specific `.env.*.local` files. It does not inspect environment-file content or allocate/reserve a live port. The shared environment is Vona + Zova development: Admin and Web are alternative commands using the same configuration, and they must not run concurrently in one worktree. Concurrent use requires separately configured linked worktrees.
 
 ## Step 4: Prefer CLI-first workflows
 

package/repo-agent-governance/skills/cabloy-workflow/evals/evals.json

@@ -39,7 +39,7 @@
     },
     {
       "id": 7,
-      "prompt": "I created a linked Cabloy Start worktree and need isolated Vona, Zova Web, and managed clean E2E. Which workflow should I use?",
+      "prompt": "I created a linked Cabloy Start worktree and need isolated Vona, Zova Web, and managed E2E. Which workflow should I use?",
       "expected_output": "Routes to the canonical shared guide and explicitly invoked /cabloy-worktree-environment skill. It recognizes that the invoked skill selects the Start command npm run test:e2e while retaining read-only generic routing, a deterministic Git-metadata recommendation, no environment-content inspection, no automatic initialization, and the universal five-setting tuple written to both permitted broad local files only after confirmation.",
       "files": []
     },

package/repo-agent-governance/skills/cabloy-worktree-environment/SKILL.md

@@ -29,10 +29,10 @@ Before proposing configuration values or writing files:
 
 Interpretation:
 
-| Marker                  | Edition      | Managed clean E2E command |
-| ----------------------- | ------------ | ------------------------- |
-| `__CABLOY_BASIC__` only | Cabloy Basic | `npm run test:e2e`        |
-| `__CABLOY_START__` only | Cabloy Start | `npm run test:e2e`        |
+| Marker                  | Edition      | Managed E2E command |
+| ----------------------- | ------------ | ------------------- |
+| `__CABLOY_BASIC__` only | Cabloy Basic | `npm run test:e2e`  |
+| `__CABLOY_START__` only | Cabloy Start | `npm run test:e2e`  |
 
 Stop without edits when both markers are present, neither marker is present, the checkout is primary/unregistered, required environment directories are missing, or the selected edition's required scripts are unavailable.
 
@@ -178,7 +178,7 @@ npm run dev:zova:web
 npm run test
 ```
 
-Run the edition-appropriate managed clean E2E command:
+Run the edition-appropriate managed E2E command:
 
 ```bash
 # Cabloy Basic or Cabloy Start

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',