@transitrix/diagrams 1.8.21 → 1.10.0

package/dist/compliance/gap-report.d.ts

@@ -1,4 +1,4 @@
-import type { ComplianceIndex, IndexAssertion, IndexRequirement } from './types.js';
+import type { ComplianceIndex, IndexAssertion, IndexRequirement, IndexNeed } from './types.js';
 export interface GapReport {
     /** Requirements with no assertion about them, severity-sorted then id. */
     requirementsWithoutAssertions: IndexRequirement[];
@@ -12,6 +12,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 {
     /** Today as ISO `YYYY-MM-DD`; required for the stale-assertion list. */

package/dist/compliance/gap-report.js

@@ -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,7 +10,16 @@
 //   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 { computeDeadlineStatus } from './impact.js';
+import { CLOSED_VERIFICATION_OUTCOMES } from '../verification/types.js';
+import { CLOSED_VALIDATION_OUTCOMES } from '../validation/types.js';
 const SEVERITY_RANK = { high: 0, medium: 1, low: 2 };
 function severityRank(s) {
     return s !== undefined && s in SEVERITY_RANK ? SEVERITY_RANK[s] : 3;
@@ -60,5 +70,47 @@ export function buildGapReport(index, options = {}) {
             return da < db ? -1 : da > db ? 1 : a.id < b.id ? -1 : 1;
         })
         : [];
-    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.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.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/dist/compliance/html.js

@@ -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.
 //
@@ -163,11 +163,13 @@ export function renderComplianceHtml(canon, scope, options = {}) {
             return htmlDoc(title, options.today, `${summary}<table><thead>${head}</thead><tbody>${rows}</tbody></table>`);
         }
         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, count, items) => {
                 const body = items.length === 0
                     ? '<p class="cmp-ok">✓ none</p>'
@@ -178,13 +180,19 @@ export function renderComplianceHtml(canon, scope, options = {}) {
             const noEvidence = report.assertionsWithoutEvidence.map(a => (`<li><code>${escHtml(a.id)}</code> <span class="cmp-meta">about <code>${escHtml(a.about)}</code>, subject <code>${escHtml(a.subject)}</code>, status ${escHtml(a.status)}</span></li>`));
             const stale = report.staleAssertions.map(a => (`<li><code>${escHtml(a.id)}</code> <span class="cmp-meta">review due ${a.next_review_at ? escHtml(a.next_review_at) : '—'}, subject <code>${escHtml(a.subject)}</code></span></li>`));
             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/dist/compliance/impact.js

@@ -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/dist/compliance/index.d.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, catalogFromMap, } from './canon-catalog.js';
 export type { ComplianceScanResult, ScannedYamlDoc } from './canon-catalog.js';
 export { renderComplianceMarkdown } from './markdown.js';
@@ -16,4 +18,4 @@ export type { ImpactCell, ImpactColumn, ImpactEmptyCellLabels, ImpactFinding, Im
 export { assertionToScoringElement, complianceConfidenceHeader, requirementToScoringElement, scoreComplianceView, } from './confidence.js';
 export { parseCoverageMetricConfig, buildCoverageMatrix, collectCoverageViewResolutionFindings, } from './coverage-metric.js';
 export type { CoverageMetricConfig, CoverageMetricRegimes, CoverageMetricRegimesFilter, CoverageMetricSubjects, CoverageMetricThresholds, CoverageMatrix, CoverageRow, CoverageViewFinding, ParseCoverageMetricResult, RagStatus, } from './coverage-metric.js';
-export type { ComplianceIndex, ComplianceIndexInput, DeadlineStatus, IndexRequirement, IndexAssertion, LawTree, LawTreeRequirement, ProductView, ProductRequirementStatus, ObjectDetailDef, ObjectDetailInput, RequirementTrace, TraceAssertionRow, TraceElementCatalog, TraceElementRef, TraceSourceRef, } from './types.js';
+export type { ComplianceIndex, ComplianceIndexInput, DeadlineStatus, IndexRequirement, IndexAssertion, IndexVerification, IndexNeed, IndexValidation, LawTree, LawTreeRequirement, ProductView, ProductRequirementStatus, ObjectDetailDef, ObjectDetailInput, RequirementTrace, TraceAssertionRow, TraceVerificationRow, TraceElementCatalog, TraceElementRef, TraceSourceRef, } from './types.js';

package/dist/compliance/index.js

@@ -3,6 +3,8 @@ export { buildLawTree, buildProductView } from './views.js';
 export { buildRequirementTrace, buildTraceElementCatalog } from './trace.js';
 export { buildGapReport } from './gap-report.js';
 export { emptyCanon, ingestComplianceDoc } from './classify.js';
+export { CLOSED_VERIFICATION_OUTCOMES } from '../verification/types.js';
+export { CLOSED_VALIDATION_OUTCOMES } from '../validation/types.js';
 export { admitDocumentToCatalog, buildComplianceScan, catalogFromMap, } from './canon-catalog.js';
 export { renderComplianceMarkdown } from './markdown.js';
 export { renderComplianceHtml, renderImpactMatrixHtml } from './html.js';

package/dist/compliance/markdown.js

@@ -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).
 import { buildComplianceMatrix } from '../compliance-matrix/index.js';
@@ -90,10 +90,16 @@ function productMarkdown(canon, productId) {
     return out.join('\n');
 }
 function gapMarkdown(canon, today) {
-    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 = ['# 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 = ['# 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_', '');
@@ -126,5 +132,21 @@ function gapMarkdown(canon, today) {
             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/dist/compliance/reverse-index.d.ts

@@ -3,6 +3,11 @@ import type { ComplianceIndex, ComplianceIndexInput } from './types.js';
  * 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 declare function buildComplianceIndex(input: ComplianceIndexInput): ComplianceIndex;

package/dist/compliance/reverse-index.js

@@ -1,4 +1,4 @@
-// Reverse-index builder (vkgeorgia/strategy#84 Phase 3).
+// Reverse-index builder (Phase 3).
 function push(map, key, value) {
     const list = map.get(key);
     if (list)
@@ -10,7 +10,12 @@ function push(map, key, value) {
  * 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) {
     const requirementById = new Map();
@@ -18,16 +23,35 @@ export function buildComplianceIndex(input) {
     const assertionsByRequirement = new Map();
     const assertionsBySubject = new Map();
     const requirementsByParent = new Map();
+    const verificationsByRequirement = new Map();
+    const needById = new Map();
+    const requirementsByNeed = new Map();
+    const validationsByNeed = new Map();
     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);
     }
-    return { requirementById, requirementsByLaw, assertionsByRequirement, assertionsBySubject, requirementsByParent };
+    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, verificationsByRequirement,
+        needById, requirementsByNeed, validationsByNeed,
+    };
 }

package/dist/compliance/trace.js

@@ -69,9 +69,13 @@ export function buildRequirementTrace(requirementId, index, catalog, codex = [])
         subject: resolveElement(assertion.subject, catalog),
         realisedVia: (assertion.realised_via ?? []).map(rid => resolveElement(rid, catalog)),
     }));
+    const rawVerifications = index.verificationsByRequirement.get(requirementId) ?? [];
+    const verifications = [...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 };
 }
 /**
  * Convenience: build a `TraceElementCatalog` from the scanned canon's product

package/dist/compliance/types.d.ts

@@ -1,4 +1,6 @@
 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. */
 export interface IndexRequirement {
@@ -47,6 +49,33 @@ 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 of a requirement deadline relative to today.
@@ -80,6 +109,19 @@ export interface IndexAssertion {
     /** ID or name of the party who must confirm this assertion (pending-owner state). */
     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;
+}
 /** One stage (or task) element of a business object, used as a matrix sub-column. */
 export interface ObjectDetailDef {
     id: string;
@@ -116,6 +158,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. */
 export interface ComplianceIndex {
@@ -131,6 +179,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[]>;
 }
 export interface LawTreeRequirement {
     requirement: IndexRequirement;
@@ -173,6 +233,12 @@ export interface TraceAssertionRow {
     /** Elements named in the assertion's `realised_via` list (may be empty). */
     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.
  *
@@ -194,6 +260,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/dist/compliance/types.js

@@ -1,5 +1,4 @@
-// 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.
 export {};

package/dist/compliance/views.js

@@ -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).
 function byId(a, b) {
     return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
 }

package/dist/compliance-matrix/types.d.ts

@@ -81,6 +81,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/dist/compliance-matrix/types.js

@@ -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.

package/dist/confidence/score.js

@@ -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).
 /** §11.3 implicit defaults — used when the adopter omits `confidence_decay`. */
 export const IMPLICIT_DECAY_DEFAULTS = {
     fresh_days: 180,

package/dist/constraint/validate.js

@@ -1,6 +1,7 @@
 // CONSTRAINT validator — methodology ELEMENT_PRIMITIVES.md §7.13 (sibling to
 // 15-requirement.md). Implements CONST-001..005 for the compliance suite (#518 C4).
 import { typeOfId, isCanonicalIdOfType } from '../typed-id.js';
+import { checkAgreement } from '../agreement.js';
 import { CONSTRAINT_STATUSES, CONSTRAINT_SEVERITIES } from './types.js';
 const REQUIRED_FIELDS = [
     'notation',
@@ -111,5 +112,7 @@ export function validateConstraint(input, options = {}) {
             });
         }
     }
+    // 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/dist/edge-path.js

@@ -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.
 /**
  * Base handle length floor + span factors. The handle grows with both the

package/dist/factor/validate.js

@@ -24,8 +24,8 @@ export function validateFactor(input, options = {}) {
     }
     const f = input;
     // 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/dist/fgca/chain-table.js

@@ -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/dist/fgca/nodeTypes.d.ts

@@ -1,6 +1,6 @@
 export declare const FGCA_NODE_TYPES: {
-    readonly fgcaDriver: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAFactorNode").FGCADriverNodeProps) => import("react/jsx-runtime").JSX.Element>;
-    readonly fgcaGoal: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAGoalNode").FGCAGoalNodeProps) => import("react/jsx-runtime").JSX.Element>;
-    readonly fgcaChange: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAChangeNode").FGCAChangeNodeProps) => import("react/jsx-runtime").JSX.Element>;
-    readonly fgcaActivity: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAActivityNode").FGCAActivityNodeProps) => import("react/jsx-runtime").JSX.Element>;
+    readonly fgcaDriver: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAFactorNode").FGCADriverNodeProps) => import("react").JSX.Element>;
+    readonly fgcaGoal: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAGoalNode").FGCAGoalNodeProps) => import("react").JSX.Element>;
+    readonly fgcaChange: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAChangeNode").FGCAChangeNodeProps) => import("react").JSX.Element>;
+    readonly fgcaActivity: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAActivityNode").FGCAActivityNodeProps) => import("react").JSX.Element>;
 };

package/dist/fgca/nodes/FGCAActivityNode.d.ts

@@ -9,5 +9,5 @@ export interface FGCAActivityNodeProps {
     };
     isConnectable?: boolean;
 }
-declare const FGCAActivityNode: React.MemoExoticComponent<({ data, isConnectable }: FGCAActivityNodeProps) => import("react/jsx-runtime").JSX.Element>;
+declare const FGCAActivityNode: React.MemoExoticComponent<({ data, isConnectable }: FGCAActivityNodeProps) => React.JSX.Element>;
 export default FGCAActivityNode;

package/dist/fgca/nodes/FGCAChangeNode.d.ts

@@ -8,5 +8,5 @@ export interface FGCAChangeNodeProps {
     };
     isConnectable?: boolean;
 }
-declare const FGCAChangeNode: React.MemoExoticComponent<({ data, isConnectable }: FGCAChangeNodeProps) => import("react/jsx-runtime").JSX.Element>;
+declare const FGCAChangeNode: React.MemoExoticComponent<({ data, isConnectable }: FGCAChangeNodeProps) => React.JSX.Element>;
 export default FGCAChangeNode;

package/dist/fgca/nodes/FGCAFactorNode.d.ts

@@ -8,5 +8,5 @@ export interface FGCADriverNodeProps {
     };
     isConnectable?: boolean;
 }
-declare const FGCADriverNode: React.MemoExoticComponent<({ data, isConnectable }: FGCADriverNodeProps) => import("react/jsx-runtime").JSX.Element>;
+declare const FGCADriverNode: React.MemoExoticComponent<({ data, isConnectable }: FGCADriverNodeProps) => React.JSX.Element>;
 export default FGCADriverNode;

package/dist/fgca/nodes/FGCAGoalNode.d.ts

@@ -10,5 +10,5 @@ export interface FGCAGoalNodeProps {
     };
     isConnectable?: boolean;
 }
-declare const FGCAGoalNode: React.MemoExoticComponent<({ data, isConnectable }: FGCAGoalNodeProps) => import("react/jsx-runtime").JSX.Element>;
+declare const FGCAGoalNode: React.MemoExoticComponent<({ data, isConnectable }: FGCAGoalNodeProps) => React.JSX.Element>;
 export default FGCAGoalNode;

package/dist/fgca/parse-canonical.d.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
@@ -49,7 +49,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/dist/fgca/parse-canonical.js

@@ -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
@@ -301,7 +301,7 @@ const FGA_DOC_ID_RE = /^(FGA|DGA)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
  * 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