cabloy 5.1.200 → 5.1.202

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,
@@ -99,6 +360,176 @@ test('ordinary co-occurrence and wildcard matrices cannot manufacture traceabili
   );
 });
 
+test('technical-only SRS exempts its PRD parent, not its WBS successor', async t => {
+  const records = {
+    ...BASELINE,
+    'srs.md':
+      '# Contracts\n\n- **SRS-DEMO-01**: Test hygiene. Traceability exception: technical-only — Repository fixture policy owns cleanup.\n\nTraceability: `WBS-DEMO-10-01`\n\n- **SRS-DEMO-02**: Product contract. Traceability: `PRD-DEMO-01`, `WBS-DEMO-10-01`.\n',
+    'prd.md': BASELINE['prd.md'].replace('`SRS-DEMO-01`', '`SRS-DEMO-02`'),
+  };
+  const result = await auditPlanning(await fixture(t, records));
+  assert.deepEqual(result.diagnostics, []);
+  const withoutException = {
+    ...records,
+    'srs.md': records['srs.md'].replace(
+      ' Traceability exception: technical-only — Repository fixture policy owns cleanup.',
+      '',
+    ),
+  };
+  const missingParent = await auditPlanning(await fixture(t, withoutException));
+  assert.ok(
+    missingParent.diagnostics.some(
+      diagnostic => diagnostic.id === 'SRS-DEMO-01' && diagnostic.code === 'traceability-incoming',
+    ),
+  );
+  const missingSuccessor = await auditPlanning(
+    await fixture(t, {
+      ...records,
+      'srs.md': records['srs.md'].replace('Traceability: `WBS-DEMO-10-01`\n', ''),
+      'pdp-wbs.md': records['pdp-wbs.md'].replace('`SRS-DEMO-01`, ', ''),
+    }),
+  );
+  assert.ok(
+    missingSuccessor.diagnostics.some(
+      diagnostic => diagnostic.id === 'SRS-DEMO-01' && diagnostic.code === 'traceability-outgoing',
+    ),
+  );
+});
+
+test('authority-only WBS exempts its ATP successor, not its SRS parent', async t => {
+  const records = {
+    ...BASELINE,
+    'pdp-wbs.md': `${BASELINE['pdp-wbs.md']}\n#### WBS-DEMO-10-02: Review baseline\n\nTraceability exception: authority-only — Retain the baseline review disposition.\n\nTraceability: \`SRS-DEMO-01\`.\n`,
+    'progress.md': `${BASELINE['progress.md']}| WBS-DEMO-10-02 | Review | not-started |\n`,
+  };
+  const result = await auditPlanning(await fixture(t, records));
+  assert.deepEqual(result.diagnostics, []);
+  const withoutException = {
+    ...records,
+    'pdp-wbs.md': records['pdp-wbs.md'].replace(
+      'Traceability exception: authority-only — Retain the baseline review disposition.\n\n',
+      '',
+    ),
+  };
+  const missingSuccessor = await auditPlanning(await fixture(t, withoutException));
+  assert.ok(
+    missingSuccessor.diagnostics.some(
+      diagnostic =>
+        diagnostic.id === 'WBS-DEMO-10-02' && diagnostic.code === 'traceability-outgoing',
+    ),
+  );
+  const missingParent = await auditPlanning(
+    await fixture(t, {
+      ...records,
+      'pdp-wbs.md': records['pdp-wbs.md'].replace('Traceability: `SRS-DEMO-01`.\n', ''),
+    }),
+  );
+  assert.ok(
+    missingParent.diagnostics.some(
+      diagnostic =>
+        diagnostic.id === 'WBS-DEMO-10-02' && diagnostic.code === 'traceability-incoming',
+    ),
+  );
+});
+
+test('malformed, repeated and wrong-kind exceptions fail closed', async t => {
+  const invalid = [
+    'Traceability exception: technical-only —',
+    'Traceability exception: technical-only — !',
+    'Traceability exception: unknown — Rationale.',
+    'Traceability exception: authority-only — Rationale.',
+    'Traceability exception: technical-only — Rationale. Traceability exception: technical-only — Again.',
+  ];
+  for (const field of invalid) {
+    const records = {
+      ...BASELINE,
+      'srs.md': BASELINE['srs.md'].replace(
+        '### SRS-DEMO-01: Contract\n',
+        `- **SRS-DEMO-01**: Contract. ${field}\n`,
+      ),
+    };
+    const result = await auditPlanning(await fixture(t, records));
+    assert.ok(
+      result.diagnostics.some(diagnostic => diagnostic.code === 'traceability-exception'),
+      field,
+    );
+  }
+  const wrongWbs = {
+    ...BASELINE,
+    'pdp-wbs.md': BASELINE['pdp-wbs.md'].replace(
+      'Completion checks:',
+      'Traceability exception: technical-only — Not an SRS.\n\nCompletion checks:',
+    ),
+  };
+  assert.ok(
+    codes(await auditPlanning(await fixture(t, wrongWbs))).includes('traceability-exception'),
+  );
+});
+
+test('an exception outside its own declaration cannot exempt a missing link', async t => {
+  const records = {
+    ...BASELINE,
+    'srs.md':
+      '# Contracts\n\nTraceability exception: technical-only — Preamble.\n\n- **SRS-DEMO-02**: Unmapped contract.\n- **SRS-DEMO-01**: Contract. Traceability exception: technical-only — Different record.\n\nTraceability: `PRD-DEMO-01`, `WBS-DEMO-10-01`\n',
+    'pdp-wbs.md': `${BASELINE['pdp-wbs.md'].replace(
+      'Dependencies: none.',
+      'Dependencies: none.\n\nTraceability exception: authority-only — Phase preamble.',
+    )}\n#### WBS-DEMO-10-02: Unmapped task\n`,
+    'progress.md': `${BASELINE['progress.md']}| WBS-DEMO-10-02 | Unmapped | not-started |\n`,
+  };
+  const result = await auditPlanning(await fixture(t, records));
+  for (const [id, code] of [
+    ['SRS-DEMO-02', 'traceability-incoming'],
+    ['WBS-DEMO-10-02', 'traceability-outgoing'],
+  ]) {
+    assert.ok(
+      result.diagnostics.some(diagnostic => diagnostic.id === id && diagnostic.code === code),
+    );
+  }
+  assert.ok(result.diagnostics.some(diagnostic => diagnostic.code === 'traceability-exception'));
+});
+
+test('classified gates retain reference and completed-prerequisite checks', async t => {
+  const records = {
+    ...BASELINE,
+    'pdp-wbs.md': `${BASELINE['pdp-wbs.md']}\n#### WBS-DEMO-10-02: Review gate\n\nDependencies: WBS-DEMO-10-01.\n\nTraceability exception: authority-only — Retain the review disposition.\n\nTraceability: \`SRS-DEMO-01\`.\n\nReview \`SRS-MISSING-01\`.\n`,
+    'progress.md': `${BASELINE['progress.md']}| WBS-DEMO-10-02 | Review | verified |\n`,
+  };
+  const result = await auditPlanning(await fixture(t, records));
+  assert.ok(
+    result.diagnostics.some(
+      diagnostic => diagnostic.code === 'undefined-reference' && diagnostic.id === 'SRS-MISSING-01',
+    ),
+  );
+  assert.ok(
+    result.diagnostics.some(
+      diagnostic => diagnostic.code === 'dependency-state' && diagnostic.id === 'WBS-DEMO-10-02',
+    ),
+  );
+  assert.ok(
+    !result.diagnostics.some(
+      diagnostic =>
+        diagnostic.code === 'traceability-outgoing' && diagnostic.id === 'WBS-DEMO-10-02',
+    ),
+  );
+});
+
+test('fences and comments cannot annotate a definition', async t => {
+  const records = {
+    ...BASELINE,
+    'pdp-wbs.md': `${BASELINE['pdp-wbs.md']}\n#### WBS-DEMO-10-02: Review gate\n\nTraceability: \`SRS-DEMO-01\`.\n\n\`\`\`md\nTraceability exception: authority-only — Example only.\n\`\`\`\n\n<!-- Traceability exception: authority-only — Not authority. -->\n`,
+    'progress.md': `${BASELINE['progress.md']}| WBS-DEMO-10-02 | Review | not-started |\n`,
+  };
+  const result = await auditPlanning(await fixture(t, records));
+  assert.ok(
+    result.diagnostics.some(
+      diagnostic =>
+        diagnostic.code === 'traceability-outgoing' && diagnostic.id === 'WBS-DEMO-10-02',
+    ),
+  );
+  assert.ok(!codes(result).includes('traceability-exception'));
+});
+
 test('lightweight records do not require absent baseline files or charts', async t => {
   const directory = await fixture(t, {
     'README.md': '# Lightweight\n',
@@ -191,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,