@transitrix/diagrams 1.8.21 → 1.10.0

package/src/compliance/gap-report.ts

@@ -1,6 +1,7 @@
-// Gap dashboard report (vkgeorgia/strategy#84 Phase 4 / CV-5).
+// Gap dashboard report (Phase 4 / CV-5; REQ-VERIF-COVERAGE-001/002 per
+// 15-requirement.md §4).
 //
-// Four operational gap lists computed from the shared reverse-index (Phase 3):
+// Operational gap lists computed from the shared reverse-index (Phase 3):
 //   1. Requirements with no Assertion targeting them (severity-sorted).
 //   2. Assertions without evidence — the ASSERT-007 case: status ∈
 //      {compliant, partial} AND no evidence. `under_review` / `non_compliant` /
@@ -9,9 +10,18 @@
 //   3. Stale Assertions — the ASSERT-008 case: `next_review_at` is in the past.
 //   4. Past-deadline requirements (CV-5) — REQUIREMENT.deadline < today AND
 //      the requirement has no fully-compliant assertion. Deadline-missed gaps.
+//   5. Requirements with no Verification targeting them — REQ-VERIF-COVERAGE-001
+//      (27-verification.md §5 / 15-requirement.md §4). Independent of #1 — the
+//      ASSERTION and VERIFICATION catalogues never disagree with each other by
+//      construction; a requirement may have one, both, or neither.
+//   6. Requirements whose verifications exist but never closed — every one is
+//      still `not_yet_run` / `inconclusive` — REQ-VERIF-COVERAGE-002. Mutually
+//      exclusive with #5 by construction.
 
-import type { ComplianceIndex, IndexAssertion, IndexRequirement } from './types.js';
+import type { ComplianceIndex, IndexAssertion, IndexRequirement, IndexNeed } from './types.js';
 import { computeDeadlineStatus } from './impact.js';
+import { CLOSED_VERIFICATION_OUTCOMES } from '../verification/types.js';
+import { CLOSED_VALIDATION_OUTCOMES } from '../validation/types.js';
 
 export interface GapReport {
   /** Requirements with no assertion about them, severity-sorted then id. */
@@ -26,6 +36,36 @@ export interface GapReport {
    * (oldest first). Empty when `today` is not supplied.
    */
   pastDeadlineRequirements: IndexRequirement[];
+  /**
+   * REQ-VERIF-COVERAGE-001: requirements with no VERIFICATION targeting them,
+   * severity-sorted then id — the engineering V&V analogue of
+   * `requirementsWithoutAssertions`.
+   */
+  requirementsWithoutVerification: IndexRequirement[];
+  /**
+   * REQ-VERIF-COVERAGE-002: requirements with one or more VERIFICATIONs
+   * targeting them, but none closed (`pass`/`fail`) — every one is still
+   * `not_yet_run`/`inconclusive`. Severity-sorted then id.
+   */
+  requirementsWithUnresolvedVerification: IndexRequirement[];
+  /**
+   * NEED-COVERAGE-001: needs with no REQUIREMENT whose `serves` names them —
+   * the NEED-side analogue of `requirementsWithoutAssertions`, id-sorted.
+   */
+  needsWithoutRequirements: IndexNeed[];
+  /**
+   * NEED-VALIDATION-COVERAGE-001: needs with no VALIDATION targeting them,
+   * id-sorted — the validation-side analogue of
+   * `requirementsWithoutVerification`.
+   */
+  needsWithoutValidation: IndexNeed[];
+  /**
+   * NEED-VALIDATION-COVERAGE-002: needs with one or more VALIDATIONs
+   * targeting them, but none closed (`pass`/`fail`) — every one is still
+   * `not_yet_run`/`inconclusive`. Mutually exclusive with
+   * `needsWithoutValidation` by construction. Id-sorted.
+   */
+  needsWithUnresolvedValidation: IndexNeed[];
 }
 
 export interface GapReportOptions {
@@ -90,5 +130,52 @@ export function buildGapReport(index: ComplianceIndex, options: GapReportOptions
         })
     : [];
 
-  return { requirementsWithoutAssertions, assertionsWithoutEvidence, staleAssertions, pastDeadlineRequirements };
+  // REQ-VERIF-COVERAGE-001 — no VERIFICATION targets the requirement at all.
+  const requirementsWithoutVerification = [...index.requirementById.values()]
+    .filter(r => (index.verificationsByRequirement.get(r.id) ?? []).length === 0)
+    .sort((a, b) => {
+      const d = severityRank(a.severity) - severityRank(b.severity);
+      return d !== 0 ? d : a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+    });
+
+  // REQ-VERIF-COVERAGE-002 — has verifications, but none closed (pass/fail).
+  // Mutually exclusive with -001 by construction (only requirements with at
+  // least one verification are considered here).
+  const requirementsWithUnresolvedVerification = [...index.requirementById.values()]
+    .filter(r => {
+      const verifications = index.verificationsByRequirement.get(r.id) ?? [];
+      return verifications.length > 0
+        && !verifications.some(v => (CLOSED_VERIFICATION_OUTCOMES as readonly string[]).includes(v.outcome));
+    })
+    .sort((a, b) => {
+      const d = severityRank(a.severity) - severityRank(b.severity);
+      return d !== 0 ? d : a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+    });
+
+  // NEED-COVERAGE-001 — no REQUIREMENT.serves names this need.
+  const needsWithoutRequirements = [...index.needById.values()]
+    .filter(n => (index.requirementsByNeed.get(n.id) ?? []).length === 0)
+    .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+
+  // NEED-VALIDATION-COVERAGE-001 — no VALIDATION targets the need at all.
+  const needsWithoutValidation = [...index.needById.values()]
+    .filter(n => (index.validationsByNeed.get(n.id) ?? []).length === 0)
+    .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+
+  // NEED-VALIDATION-COVERAGE-002 — has validations, but none closed (pass/fail).
+  // Mutually exclusive with -001 by construction (only needs with at least
+  // one validation are considered here).
+  const needsWithUnresolvedValidation = [...index.needById.values()]
+    .filter(n => {
+      const validations = index.validationsByNeed.get(n.id) ?? [];
+      return validations.length > 0
+        && !validations.some(v => (CLOSED_VALIDATION_OUTCOMES as readonly string[]).includes(v.outcome));
+    })
+    .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+
+  return {
+    requirementsWithoutAssertions, assertionsWithoutEvidence, staleAssertions, pastDeadlineRequirements,
+    requirementsWithoutVerification, requirementsWithUnresolvedVerification,
+    needsWithoutRequirements, needsWithoutValidation, needsWithUnresolvedValidation,
+  };
 }

package/src/compliance/html.ts

@@ -1,4 +1,4 @@
-// HTML renderers for the compliance views (vkgeorgia/strategy#84 Phase 5,
+// HTML renderers for the compliance views (Phase 5,
 // PDF follow-on). Pure string builders — fed to WeasyPrint by the
 // `transitrix export-compliance --format pdf` path in src/export-compliance.ts.
 //
@@ -183,11 +183,13 @@ export function renderComplianceHtml(canon: ComplianceCanon, scope: ReportScope,
     }
 
     case 'gap': {
-      const index = buildComplianceIndex({ requirements: canon.requirements, assertions: canon.assertions });
+      const index = buildComplianceIndex({
+        requirements: canon.requirements,
+        assertions: canon.assertions,
+        verifications: canon.verifications,
+      });
       const report = buildGapReport(index, { today: options.today });
       const title = options.title ?? 'Compliance Gap Dashboard';
-      const total = report.requirementsWithoutAssertions.length + report.assertionsWithoutEvidence.length + report.staleAssertions.length;
-      const summary = `<p class="cmp-summary">${total} gap(s)</p>`;
       const section = (heading: string, count: number, items: string[]): string => {
         const body = items.length === 0
           ? '<p class="cmp-ok">✓ none</p>'
@@ -206,13 +208,23 @@ export function renderComplianceHtml(canon: ComplianceCanon, scope: ReportScope,
       const pastDl = report.pastDeadlineRequirements.map(r => (
         `<li><code>${escHtml(r.id)}</code> ${escHtml(r.name)} <span class="cmp-meta">deadline ${r.deadline ? escHtml(r.deadline) : '—'}${r.severity ? `, severity ${escHtml(r.severity)}` : ''}</span></li>`
       ));
-      const total4 = report.requirementsWithoutAssertions.length + report.assertionsWithoutEvidence.length + report.staleAssertions.length + report.pastDeadlineRequirements.length;
+      const noVerif = report.requirementsWithoutVerification.map(r => (
+        `<li><code>${escHtml(r.id)}</code> ${escHtml(r.name)}${r.severity ? ` <span class="cmp-meta">severity ${escHtml(r.severity)}</span>` : ''}</li>`
+      ));
+      const unresolvedVerif = report.requirementsWithUnresolvedVerification.map(r => (
+        `<li><code>${escHtml(r.id)}</code> ${escHtml(r.name)}${r.severity ? ` <span class="cmp-meta">severity ${escHtml(r.severity)}</span>` : ''}</li>`
+      ));
+      const total6 = report.requirementsWithoutAssertions.length + report.assertionsWithoutEvidence.length
+        + report.staleAssertions.length + report.pastDeadlineRequirements.length
+        + report.requirementsWithoutVerification.length + report.requirementsWithUnresolvedVerification.length;
       const body = [
-        `<p class="cmp-summary">${total4} gap(s) across 4 checks</p>`,
+        `<p class="cmp-summary">${total6} gap(s) across 6 checks</p>`,
         section('Requirements without assertions', report.requirementsWithoutAssertions.length, reqs),
         section('Assertions without evidence — ASSERT-007', report.assertionsWithoutEvidence.length, noEvidence),
         section('Stale assertions — ASSERT-008', report.staleAssertions.length, stale),
         section('Past-deadline requirements (CV-5)', report.pastDeadlineRequirements.length, pastDl),
+        section('Requirements without verification — REQ-VERIF-COVERAGE-001', report.requirementsWithoutVerification.length, noVerif),
+        section('Requirements with unresolved verification — REQ-VERIF-COVERAGE-002', report.requirementsWithUnresolvedVerification.length, unresolvedVerif),
       ].join('');
       return htmlDoc(title, options.today, body);
     }

package/src/compliance/impact.ts

@@ -1,5 +1,5 @@
 // Compliance-impact matrix derivation + markdown renderer
-// (vkgeorgia/strategy#166 — interim renderer; CV-1 view-config wiring
+// (interim renderer; CV-1 view-config wiring
 // per strategy#84 decomposition refresh).
 //
 // Implements the render contract from

package/src/compliance/index.ts

@@ -5,6 +5,8 @@ export { buildGapReport } from './gap-report.js';
 export type { GapReport, GapReportOptions } from './gap-report.js';
 export { emptyCanon, ingestComplianceDoc } from './classify.js';
 export type { ComplianceCanon, ComplianceProduct, ComplianceCodexDoc } from './classify.js';
+export { CLOSED_VERIFICATION_OUTCOMES } from '../verification/types.js';
+export { CLOSED_VALIDATION_OUTCOMES } from '../validation/types.js';
 export {
   admitDocumentToCatalog,
   buildComplianceScan,
@@ -58,6 +60,9 @@ export type {
   DeadlineStatus,
   IndexRequirement,
   IndexAssertion,
+  IndexVerification,
+  IndexNeed,
+  IndexValidation,
   LawTree,
   LawTreeRequirement,
   ProductView,
@@ -66,6 +71,7 @@ export type {
   ObjectDetailInput,
   RequirementTrace,
   TraceAssertionRow,
+  TraceVerificationRow,
   TraceElementCatalog,
   TraceElementRef,
   TraceSourceRef,

package/src/compliance/markdown.ts

@@ -1,4 +1,4 @@
-// Markdown renderers for the compliance views (vkgeorgia/strategy#84 Phase 5).
+// Markdown renderers for the compliance views (Phase 5).
 // Pure string builders consumed by the `transitrix export-compliance` CLI.
 // PDF rendering lives in `html.ts` (HTML doc fed to WeasyPrint by the CLI).
 
@@ -111,10 +111,16 @@ function productMarkdown(canon: ComplianceCanon, productId: string): string {
 }
 
 function gapMarkdown(canon: ComplianceCanon, today?: string): string {
-  const index = buildComplianceIndex({ requirements: canon.requirements, assertions: canon.assertions });
+  const index = buildComplianceIndex({
+    requirements: canon.requirements,
+    assertions: canon.assertions,
+    verifications: canon.verifications,
+  });
   const report = buildGapReport(index, { today });
-  const total = report.requirementsWithoutAssertions.length + report.assertionsWithoutEvidence.length + report.staleAssertions.length + report.pastDeadlineRequirements.length;
-  const out: string[] = ['# Compliance Gap Dashboard', '', `_${total} gap(s) across 4 checks_`, ''];
+  const total = report.requirementsWithoutAssertions.length + report.assertionsWithoutEvidence.length
+    + report.staleAssertions.length + report.pastDeadlineRequirements.length
+    + report.requirementsWithoutVerification.length + report.requirementsWithUnresolvedVerification.length;
+  const out: string[] = ['# Compliance Gap Dashboard', '', `_${total} gap(s) across 6 checks_`, ''];
 
   out.push(`## Requirements without assertions (${report.requirementsWithoutAssertions.length})`, '');
   if (report.requirementsWithoutAssertions.length === 0) out.push('_✓ none_', '');
@@ -132,5 +138,13 @@ function gapMarkdown(canon: ComplianceCanon, today?: string): string {
   if (report.pastDeadlineRequirements.length === 0) out.push('_✓ none_', '');
   else { for (const r of report.pastDeadlineRequirements) out.push(`- [ ] \`${r.id}\` ${r.name} — deadline: ${r.deadline ?? '—'}${r.severity ? `, severity: ${r.severity}` : ''}`); out.push(''); }
 
+  out.push(`## Requirements without verification — REQ-VERIF-COVERAGE-001 (${report.requirementsWithoutVerification.length})`, '');
+  if (report.requirementsWithoutVerification.length === 0) out.push('_✓ none_', '');
+  else { for (const r of report.requirementsWithoutVerification) out.push(`- [ ] \`${r.id}\` ${r.name}${r.severity ? ` — severity: ${r.severity}` : ''}`); out.push(''); }
+
+  out.push(`## Requirements with unresolved verification — REQ-VERIF-COVERAGE-002 (${report.requirementsWithUnresolvedVerification.length})`, '');
+  if (report.requirementsWithUnresolvedVerification.length === 0) out.push('_✓ none_', '');
+  else { for (const r of report.requirementsWithUnresolvedVerification) out.push(`- [ ] \`${r.id}\` ${r.name}${r.severity ? ` — severity: ${r.severity}` : ''}`); out.push(''); }
+
   return out.join('\n');
 }

package/src/compliance/reverse-index.ts

@@ -1,6 +1,14 @@
-// Reverse-index builder (vkgeorgia/strategy#84 Phase 3).
+// Reverse-index builder (Phase 3).
 
-import type { ComplianceIndex, ComplianceIndexInput, IndexAssertion, IndexRequirement } from './types.js';
+import type {
+  ComplianceIndex,
+  ComplianceIndexInput,
+  IndexAssertion,
+  IndexRequirement,
+  IndexVerification,
+  IndexNeed,
+  IndexValidation,
+} from './types.js';
 
 function push<K, V>(map: Map<K, V[]>, key: K, value: V): void {
   const list = map.get(key);
@@ -12,7 +20,12 @@ function push<K, V>(map: Map<K, V[]>, key: K, value: V): void {
  * Builds the reverse indexes used by every compliance view. Pure; the input
  * arrays are read, not mutated. Requirements with no `derived_from` simply do
  * not appear under any law; assertions are indexed by both their requirement
- * (`about`) and their subject.
+ * (`about`) and their subject; verifications are indexed by their requirement
+ * (`verifies`) — an independent catalogue from assertions (27-verification.md §4).
+ * Needs are indexed by id; requirements are additionally indexed by the NEED
+ * they `serves` (15-requirement.md §2.7), and validations by the NEED they
+ * `validate` (28-validation.md §2) — both feed the NEED-side coverage rules
+ * (ELEMENT_PRIMITIVES.md §9).
  */
 export function buildComplianceIndex(input: ComplianceIndexInput): ComplianceIndex {
   const requirementById = new Map<string, IndexRequirement>();
@@ -20,16 +33,34 @@ export function buildComplianceIndex(input: ComplianceIndexInput): ComplianceInd
   const assertionsByRequirement = new Map<string, IndexAssertion[]>();
   const assertionsBySubject = new Map<string, IndexAssertion[]>();
   const requirementsByParent = new Map<string, IndexRequirement[]>();
+  const verificationsByRequirement = new Map<string, IndexVerification[]>();
+  const needById = new Map<string, IndexNeed>();
+  const requirementsByNeed = new Map<string, IndexRequirement[]>();
+  const validationsByNeed = new Map<string, IndexValidation[]>();
 
   for (const r of input.requirements) {
     requirementById.set(r.id, r);
     for (const law of r.derived_from ?? []) push(requirementsByLaw, law, r);
     if (r.parent) push(requirementsByParent, r.parent, r);
+    if (r.serves) push(requirementsByNeed, r.serves, r);
   }
   for (const a of input.assertions) {
     push(assertionsByRequirement, a.about, a);
     push(assertionsBySubject, a.subject, a);
   }
+  for (const v of input.verifications ?? []) {
+    push(verificationsByRequirement, v.verifies, v);
+  }
+  for (const n of input.needs ?? []) {
+    needById.set(n.id, n);
+  }
+  for (const v of input.validations ?? []) {
+    push(validationsByNeed, v.validates, v);
+  }
 
-  return { requirementById, requirementsByLaw, assertionsByRequirement, assertionsBySubject, requirementsByParent };
+  return {
+    requirementById, requirementsByLaw, assertionsByRequirement, assertionsBySubject,
+    requirementsByParent, verificationsByRequirement,
+    needById, requirementsByNeed, validationsByNeed,
+  };
 }

package/src/compliance/trace.ts

@@ -22,6 +22,7 @@ import type {
   IndexRequirement,
   RequirementTrace,
   TraceAssertionRow,
+  TraceVerificationRow,
   TraceElementCatalog,
   TraceElementRef,
   TraceSourceRef,
@@ -95,10 +96,15 @@ export function buildRequirementTrace(
       realisedVia: (assertion.realised_via ?? []).map(rid => resolveElement(rid, catalog)),
     }));
 
+  const rawVerifications = index.verificationsByRequirement.get(requirementId) ?? [];
+  const verifications: TraceVerificationRow[] = [...rawVerifications]
+    .sort(byId)
+    .map(verification => ({ verification }));
+
   const ancestors = collectAncestors(requirement, index);
   const children = [...(index.requirementsByParent.get(requirementId) ?? [])].sort(byId);
 
-  return { requirement, sources, assertions, ancestors, children };
+  return { requirement, sources, assertions, verifications, ancestors, children };
 }
 
 /**

package/src/compliance/types.ts

@@ -1,9 +1,10 @@
-// Shared compliance reverse-index + derived views (vkgeorgia/strategy#84
-// Phase 3). The reverse-index pass (Law → Requirements, Requirement →
+// Shared compliance reverse-index + derived views (Phase 3). The reverse-index pass (Law → Requirements, Requirement →
 // Assertions, Subject → Assertions) backs the single-law tree and the
 // single-product view here, and the gap dashboard in Phase 4.
 
 import type { AssertionStatus } from '../assertion/types.js';
+import type { VerificationMethod, VerificationOutcome } from '../verification/types.js';
+import type { ValidationMethod, ValidationOutcome } from '../validation/types.js';
 import type { ComplianceCodexDoc } from './classify.js';
 
 /** Projection of a REQUIREMENT (or CONSTRAINT) the compliance views need. */
@@ -53,6 +54,35 @@ export interface IndexRequirement {
    * Present when the author has scheduled a review; drives `REQ-STALE-001`.
    */
   next_review_at?: string;
+  /**
+   * Typed ID of the upstream `NEED` this requirement traces to
+   * (15-requirement.md §2.7; `REQ-SERVES-001`). Optional, singular. Feeds
+   * `NEED-COVERAGE-001` (ELEMENT_PRIMITIVES.md §9) on the NEED side.
+   */
+  serves?: string;
+}
+
+/** Projection of a `NEED` element (ELEMENT_PRIMITIVES.md §7.28) the compliance
+ *  views need — just enough to list an unaddressed / unvalidated need. */
+export interface IndexNeed {
+  id: string;
+  name: string;
+}
+
+/** Projection of a `VALIDATION` claim (28-validation.md §2) the compliance
+ *  views need — the validation-domain peer of `IndexVerification`, anchored
+ *  on NEED instead of REQUIREMENT. */
+export interface IndexValidation {
+  id: string;
+  /** Typed ID of the NEED this validation targets. */
+  validates: string;
+  method: ValidationMethod;
+  outcome: ValidationOutcome;
+  performed_at?: string;
+  /** Number of evidence entries — feeds the VALID-006 gap. */
+  evidenceCount?: number;
+  /** Admission date (CONTRACT §6) — feeds DQ-1 freshness decay. */
+  admitted_at?: string;
 }
 
 // ── Temporal status (CV-3) ──────────────────────────────────────────────────
@@ -91,6 +121,20 @@ export interface IndexAssertion {
   owner_to_confirm?: string;
 }
 
+/** Projection of a VERIFICATION the compliance views need (27-verification.md §2). */
+export interface IndexVerification {
+  id: string;
+  /** Typed ID of the REQUIREMENT this verification targets. */
+  verifies: string;
+  method: VerificationMethod;
+  outcome: VerificationOutcome;
+  performed_at?: string;
+  /** Number of evidence entries — feeds the VERIF-006 gap. */
+  evidenceCount?: number;
+  /** Admission date (CONTRACT §6) — feeds DQ-1 freshness decay. */
+  admitted_at?: string;
+}
+
 // ── Stage grouping (CV-3a) ──────────────────────────────────────────────────
 
 /** One stage (or task) element of a business object, used as a matrix sub-column. */
@@ -128,6 +172,12 @@ export interface ObjectDetailInput {
 export interface ComplianceIndexInput {
   requirements: IndexRequirement[];
   assertions: IndexAssertion[];
+  /** Optional — absent inputs (existing callers) simply index no verifications. */
+  verifications?: IndexVerification[];
+  /** Optional — absent inputs (existing callers) simply index no needs. */
+  needs?: IndexNeed[];
+  /** Optional — absent inputs (existing callers) simply index no validations. */
+  validations?: IndexValidation[];
 }
 
 /** The reverse-index — all maps are keyed by canonical id. */
@@ -144,6 +194,18 @@ export interface ComplianceIndex {
    * (15-requirement.md §2.4). Enables the requirement-hierarchy view.
    */
   requirementsByParent: Map<string, IndexRequirement[]>;
+  /** Requirement id → verifications whose `verifies` names it
+   *  (27-verification.md §2). The engineering V&V analogue of
+   *  `assertionsByRequirement` — the two catalogues are independent. */
+  verificationsByRequirement: Map<string, IndexVerification[]>;
+  /** NEED id → needs, keyed by their own id (single-entry lookup convenience). */
+  needById: Map<string, IndexNeed>;
+  /** NEED id → requirements whose `serves` names it (15-requirement.md §2.7).
+   *  Feeds `NEED-COVERAGE-001`. */
+  requirementsByNeed: Map<string, IndexRequirement[]>;
+  /** NEED id → validations whose `validates` names it (28-validation.md §2).
+   *  Feeds `NEED-VALIDATION-COVERAGE-001..002`. */
+  validationsByNeed: Map<string, IndexValidation[]>;
 }
 
 // ── Single-law tree ─────────────────────────────────────────────────────────
@@ -198,6 +260,13 @@ export interface TraceAssertionRow {
   realisedVia: TraceElementRef[];
 }
 
+/** One VERIFICATION targeting the traced requirement (27-verification.md §2).
+ *  No subject/realised_via — a verification claims a protocol was run against
+ *  the requirement's acceptance criteria directly (16-assertion.md §4). */
+export interface TraceVerificationRow {
+  verification: IndexVerification;
+}
+
 /**
  * Requirement traceability + hierarchy view.
  *
@@ -219,6 +288,10 @@ export interface RequirementTrace {
   sources: TraceSourceRef[];
   /** Forward-trace via ASSERTION. Empty for CONSTRAINT elements (16-assertion.md §1) or for a REQUIREMENT with no filed assertion. */
   assertions: TraceAssertionRow[];
+  /** Forward-trace via VERIFICATION (27-verification.md §2). Empty for CONSTRAINT
+   *  elements (the engineering V&V leg applies to REQUIREMENT only, same posture
+   *  as ASSERTION) or for a REQUIREMENT with no filed verification. */
+  verifications: TraceVerificationRow[];
   /** Parent chain: immediate parent first, root last. Empty when the element has no `parent`. */
   ancestors: IndexRequirement[];
   /** Direct children: elements naming this one as their `parent`, id-sorted. */

package/src/compliance/views.ts

@@ -1,4 +1,4 @@
-// Single-law tree + single-product view builders (vkgeorgia/strategy#84 Phase 3).
+// Single-law tree + single-product view builders (Phase 3).
 
 import type {
   ComplianceIndex,

package/src/compliance-matrix/types.ts

@@ -1,4 +1,4 @@
-// Compliance matrix model (vkgeorgia/strategy#84 Phase 2).
+// Compliance matrix model (Phase 2).
 //
 // The matrix is Products × Requirements. Each cell is the status of the
 // (Product, Requirement) ASSERTION when one exists, or a gap when none does.
@@ -97,6 +97,6 @@ export interface MatrixFilter {
   statuses?: AssertionStatus[];
   /** Keep only requirement columns whose resolved jurisdictions intersect this
    *  set. Requirements with no resolved jurisdiction are filtered out when this
-   *  is non-empty (F16, epic #84). */
+   *  is non-empty (F16). */
   jurisdictions?: string[];
 }

package/src/confidence/score.ts

@@ -2,7 +2,7 @@
 // callers (Studio previews, DSM React) pass already-resolved element inputs
 // and a `today` reference; this module returns the per-element scores and
 // the view composite. Lives in @transitrix/diagrams so Studio and DSM share
-// one implementation (see vkgeorgia/strategy#159 — DQ-1).
+// one implementation (DQ-1).
 
 import type {
   ConfidenceBand,

package/src/constraint/validate.ts

@@ -3,6 +3,7 @@
 
 import type { ValidationError, ValidationWarning, ValidationResult } from '../validation-types.js';
 import { typeOfId, isCanonicalIdOfType, type CanonCatalog } from '../typed-id.js';
+import { checkAgreement } from '../agreement.js';
 import { CONSTRAINT_STATUSES, CONSTRAINT_SEVERITIES } from './types.js';
 
 export interface ConstraintValidateOptions {
@@ -127,5 +128,8 @@ export function validateConstraint(
     }
   }
 
+  // AGREE-001..003 — agreement axis (CONTRACT.md §6.3.1), optional; absent ⇒ agreed.
+  errors.push(...checkAgreement(c));
+
   return { valid: errors.length === 0, errors, warnings };
 }

package/src/edge-path.ts

@@ -5,7 +5,7 @@
 // arrow reads as perpendicular to the node's vertical edge.
 //
 // Pulling the path math here (rather than duplicating it inline in each
-// preview) makes the configurable-curvature behaviour (vkgeorgia/strategy#76)
+// preview) makes the configurable-curvature behaviour
 // unit-testable — the extension has no test harness.
 
 /**

package/src/factor/validate.ts

@@ -36,8 +36,8 @@ export function validateFactor(input: unknown, options: FactorValidateOptions =
   const f = input as Record<string, unknown>;
 
   // FACTOR-001 — id grammar + notation tag + envelope.
-  if (!isCanonicalIdOfType(f.id, 'FACTOR')) {
-    errors.push({ code: 'FACTOR-001', message: `id "${String(f.id)}" must match FACTOR-[<middle>-]<INTEGER>.`, path: 'id' });
+  if (!isCanonicalIdOfType(f.id, 'DRIVER')) {
+    errors.push({ code: 'FACTOR-001', message: `id "${String(f.id)}" must match DRIVER-[<middle>-]<INTEGER>.`, path: 'id' });
   }
   if (f.notation !== 'driver') {
     errors.push({ code: 'FACTOR-001', message: 'notation must be the fixed value "driver".', path: 'notation' });

package/src/fgca/chain-table.ts

@@ -1,4 +1,4 @@
-// Chain-table model for the FGCA / FGA previews (vkgeorgia/strategy#137).
+// Chain-table model for the FGCA / FGA previews.
 //
 // The tree/chain preview (`layoutFGCAPreview`) shows Driver → Goal → Change →
 // Activity as columns of nodes joined by edges. This module produces the

package/src/fgca/parse-canonical.ts

@@ -17,7 +17,7 @@
  * historically but the layout code only uses IDs as opaque keys, so
  * string IDs work fine.
  *
- * Strategy hub #63: this lives at the input boundary so the library's
+ * This lives at the input boundary so the library's
  * internal types (currently using DSM-API form — numeric IDs and
  * singular cross-refs) can stay where they are. A follow-up task can
  * unify the internal types with the canonical form across all sister
@@ -354,7 +354,7 @@ export interface CanonicalFGAResult extends ValidationResult {
  * FGA-001..011). The resulting internal `FGCADoc` carries `activity.goal_id`,
  * which is exactly what the renderer needs to draw goal → activity edges —
  * the field whose absence produced the "FGA nodes render, no edges" bug
- * (transitrix/methodology#65 / vkgeorgia/strategy#65).
+ * (transitrix/methodology#65).
  *
  * Lives beside `parseCanonicalFGCA` (rather than inline in the extension) so
  * the canonical FGA path is unit-testable and the library owns the single

package/src/fgca/preview-layout.ts

@@ -49,7 +49,7 @@ export interface FGCAPreviewLayoutOptions {
   colGap?: number;
   /** Vertical gap (px) between stacked nodes within a column. Default matches the historical hardcoded value. */
   rowGap?: number;
-  /** Trim to a level cap or a single root goal (vkgeorgia/strategy#77). Defaults to 'all'. */
+  /** Trim to a level cap or a single root goal. Defaults to 'all'. */
   scope?: Scope;
   /** Entity node width (px). Default {@link FGCA_NODE_W}. */
   nodeWidth?: number;

package/src/goals/layout.ts

@@ -8,7 +8,7 @@ const DEFAULT_RANK_SEP = 80;
 const DEFAULT_NODE_SEP = 40;
 
 /**
- * Trims a flat goal list to a scope (vkgeorgia/strategy#77).
+ * Trims a flat goal list to a scope.
  *   - 'level' → goals with `level <= maxLevel`.
  *   - 'root'  → the root goal (matched by string id) plus all its descendants
  *               via `parent_id`; an empty list when the root is absent.

package/src/goals/parse-canonical.ts

@@ -15,7 +15,7 @@
  * mapped to internal sequential numbers, `parent: GOAL-X` becomes
  * `parent_id: <numeric>`, `parent_id: 0` denotes a root.
  *
- * Strategy hub #63: this lives at the input boundary so the library's
+ * This lives at the input boundary so the library's
  * internal types (numeric IDs) stay where they are. Convergence on
  * canonical typed-string IDs across all sister modules is a follow-up
  * task.

package/src/goals/types.ts

@@ -60,7 +60,7 @@ export interface LayoutOptions {
   nodeSep?: number;
   hideCollapsed?: number[];
   viewDepth?: number | null;
-  /** Trim the tree to a level cap or a subtree root (vkgeorgia/strategy#77). Defaults to 'all'. */
+  /** Trim the tree to a level cap or a subtree root. Defaults to 'all'. */
   scope?: Scope;
 }
 

package/src/goals/validate.ts

@@ -21,7 +21,7 @@ export function validateGoalTree(input: unknown): ValidationResult {
   const tree = raw as unknown as GoalTree;
 
   // GOALS-013 — goal_types[].level values must be contiguous starting from 0.
-  // Per the N+1 rule (decision in vkgeorgia/strategy#66), the level set must
+  // Per the N+1 rule, the level set must
   // be exactly {0, 1, …, N}; a gap breaks the parent→child level invariant
   // and means GOALS-012 cannot be enforced consistently.
   const levels = tree.goal_types
@@ -96,7 +96,7 @@ export function validateGoalTree(input: unknown): ValidationResult {
       continue;
     }
     // GOALS-012 — parent must be exactly one level above the child (N+1
-    // hierarchy, decision in vkgeorgia/strategy#66). Only enforced when the
+    // hierarchy). Only enforced when the
     // parent is resolvable; a missing parent is covered by BROKEN_PARENT_REF.
     if (g.parent_id !== 0) {
       const parentLevel = levelById.get(g.parent_id);