@sigloch/contracts 1.0.0 → 2.0.0

package/dist/se/index.d.ts

@@ -5,7 +5,7 @@
 /** Ontology schema version (element types + trace types). */
 export declare const ONTOLOGY_VERSION = "4.0.0";
 /** Rules engine version (validation rules incl. RC conformance). */
-export declare const RULES_VERSION = "2.20.0";
+export declare const RULES_VERSION = "2.21.0";
 /** Meta-model version (trace pattern constraints + format-e parser). */
 export declare const META_MODEL_VERSION = "1.4.0";
 export * from './ontology.js';

package/dist/se/index.js

@@ -5,7 +5,7 @@
 /** Ontology schema version (element types + trace types). */
 export const ONTOLOGY_VERSION = '4.0.0'; // BREAKING: `SemanticId` (`Name.TypeAbbr.Counter`) deleted, `ElementUid` (`<TYPE>-<slug>`) is the family canon — the old canon was used by no production graph of the family while 626 of 1145 elements already carried TYPE-slug (CR-SM-217); realRef unifies codeRef+schemaRef (+physical-MOD CAD ref), symbol optional; testRef stays separate (CR-228 C); +RepoRelativePathSchema on testRef/realRef .file — no absolute/`..` paths (CR-GC-255)
 /** Rules engine version (validation rules incl. RC conformance). */
-export const RULES_VERSION = '2.20.0'; // +RD-04 decomposition breadth (>11 children per level → warning) and MT-03 recalibrated to FLOW-transitive connection pairs — counting raw io traces reported internal=0 on every real SE graph (15/15 false positives), because the meta-model routes FUNC↔FUNC through FLOW; 'RD-' added to the se profile prefixes, where RD-01..04 were silently missing (CR-SM-221); -SC-01/-SC-03 deleted (BOK-CR-026): `realRef` is the single SCHEMA binding truth (R-26 presence, RC-03/RC-04 resolution); the legacy `zodDefinition`/`sourceFile`/`sourceExport` attributes are gone from every producer, SC_RULES = [SC-02]; R-20/R-26/RC-01/RC-03/RC-04 read realRef (unified codeRef+schemaRef); +R-27 physical-MOD realRef presence (CR-228 C); -R-24/R-25 REQ→MOD allocation rules deleted (CR-228 A: REQ→MOD allocate no longer a valid pattern, R-18 flags residual edges); NFR-01 budget target split physical→MOD / behavioral→FCHAIN; RULE_TO_DIMENSION completeness (R-18..R-23/R-26/MS-03/CR-R04 mapped, no advisory fall-through) (CR-228 B/D); +BQ-01/02/04/06/07 base-quality rules promoted from aimpro (K2-b, completes rule consolidation); +ND-01/02 near-duplicate + AO-D01/D03/CR-01/RT-01/PH-01/CA-01/IO-01 architecture rules promoted from aimpro (K2-b); +CR-R01..04/MS-03 change-request rules promoted from aimpro (K2-b); +FM-01..03/NFR-01 FMEA + VR-01/CL-01 view rules promoted from aimpro (K2-b); +MT-01..03 architecture metrics promoted from aimpro (K2-b); +SC-01..03/UC-01..06/FC-01..03 quality rules promoted from aimpro (K2-a); +RC-05 cross-module import drift (CR-212); +R-26/RC-03/RC-04 schemaRef (CR-211); +R-22..R-25/R-10/R-20 (CR-201/202/208/209/210)
+export const RULES_VERSION = '2.21.0'; // -MT-03 retired as a rule and reborn as the `allocationCohesion` measurement (CR-SM-223): the 80 % threshold fired on 6/7 graphcode, 4/4 gve and 10/11 family modules — in a flow-routed architecture cross-boundary interaction is the design, not a defect; the metric now reports internal/external per MOD, worst-first, and stays out of the violation stream so it cannot depress the readiness score; +RD-04 decomposition breadth (>11 children per level → warning) and MT-03 recalibrated to FLOW-transitive connection pairs — counting raw io traces reported internal=0 on every real SE graph (15/15 false positives), because the meta-model routes FUNC↔FUNC through FLOW; 'RD-' added to the se profile prefixes, where RD-01..04 were silently missing (CR-SM-221); -SC-01/-SC-03 deleted (BOK-CR-026): `realRef` is the single SCHEMA binding truth (R-26 presence, RC-03/RC-04 resolution); the legacy `zodDefinition`/`sourceFile`/`sourceExport` attributes are gone from every producer, SC_RULES = [SC-02]; R-20/R-26/RC-01/RC-03/RC-04 read realRef (unified codeRef+schemaRef); +R-27 physical-MOD realRef presence (CR-228 C); -R-24/R-25 REQ→MOD allocation rules deleted (CR-228 A: REQ→MOD allocate no longer a valid pattern, R-18 flags residual edges); NFR-01 budget target split physical→MOD / behavioral→FCHAIN; RULE_TO_DIMENSION completeness (R-18..R-23/R-26/MS-03/CR-R04 mapped, no advisory fall-through) (CR-228 B/D); +BQ-01/02/04/06/07 base-quality rules promoted from aimpro (K2-b, completes rule consolidation); +ND-01/02 near-duplicate + AO-D01/D03/CR-01/RT-01/PH-01/CA-01/IO-01 architecture rules promoted from aimpro (K2-b); +CR-R01..04/MS-03 change-request rules promoted from aimpro (K2-b); +FM-01..03/NFR-01 FMEA + VR-01/CL-01 view rules promoted from aimpro (K2-b); +MT-01..03 architecture metrics promoted from aimpro (K2-b); +SC-01..03/UC-01..06/FC-01..03 quality rules promoted from aimpro (K2-a); +RC-05 cross-module import drift (CR-212); +R-26/RC-03/RC-04 schemaRef (CR-211); +R-22..R-25/R-10/R-20 (CR-201/202/208/209/210)
 /** Meta-model version (trace pattern constraints + format-e parser). */
 export const META_MODEL_VERSION = '1.4.0'; // -REQ→MOD allocate pattern removed (CR-228 A); +FUNC→FUNC compose (blackbox function decomposition)
 export * from './ontology.js';

package/dist/se/metric-rules.d.ts

@@ -18,14 +18,41 @@ export declare function mt01Instability(graph: OntologyGraph): RuleViolation[];
  * Components > 1 → info.
  */
 export declare function mt02Lcom4(graph: OntologyGraph): RuleViolation[];
+/** One module's allocation-cohesion measurement (CR-SM-223). */
+export interface AllocationCohesion {
+    moduleId: string;
+    moduleName: string;
+    /** Connection pairs with both endpoints allocated to this module. */
+    internal: number;
+    /** Connection pairs with exactly one endpoint allocated to this module. */
+    external: number;
+    /** internal / (internal + external), in [0, 1]. */
+    cohesion: number;
+}
 /**
- * MT-03: Allocation Cohesion (CR-191 reformulated, CR-SM-221 recalibrated).
- * cohesion = internal / (internal + external), over FLOW-transitive connection pairs.
- * internal = both endpoints allocated to this module.
- * external = exactly one endpoint allocated to this module.
- * If external === 0 → cohesion = 100% → OK.
+ * Allocation cohesion — a **measurement, not a rule** (CR-SM-223, decision 2026-07-29).
+ *
+ * It used to be MT-03 with an 80 % threshold, and it fired on nearly every module of
+ * every real graph: 6 of 7 on graphcode, 4 of 4 on graph-view-edit, 10 of 11 on the
+ * family graph. `CR-SM-221` first suspected the edge definition and made it
+ * FLOW-transitive — the hit rate did not move. The threshold was the miscalibration:
+ * in a flow-routed layered architecture, module interaction crosses boundaries by
+ * design, so "80 % of interaction is internal" describes a monolith, not a healthy
+ * module.
+ *
+ * Rather than fit a cut-off to 11 data points, this reports the number and lets the
+ * architect judge. Returned worst-first, so the head of the list is where to look.
+ * Modules with fewer than two allocated FUNCs, or with no external connection at all,
+ * carry no signal and are omitted.
+ *
+ * Deliberately NOT a `RuleDefinition`: `computeReadiness` counts every violation into
+ * its dimension score regardless of severity, so a per-module advisory would depress
+ * the `alloc` score permanently. A measurement must not masquerade as a defect.
+ *
+ * Validation of this metric — and of MT-01/MT-02, which are thresholded the same way —
+ * is deferred (CR-SM-223).
  */
-export declare function mt03AllocationCohesion(graph: OntologyGraph): RuleViolation[];
+export declare function allocationCohesion(graph: OntologyGraph): AllocationCohesion[];
 export declare const MT_RULES: readonly [{
     readonly id: "MT-01";
     readonly name: "Module instability";
@@ -36,10 +63,5 @@ export declare const MT_RULES: readonly [{
     readonly name: "Module cohesion (LCOM4)";
     readonly severity: "info";
     readonly evaluate: typeof mt02Lcom4;
-}, {
-    readonly id: "MT-03";
-    readonly name: "Allocation cohesion";
-    readonly severity: "info";
-    readonly evaluate: typeof mt03AllocationCohesion;
 }];
 export declare function evaluateMTRules(graph: OntologyGraph): RuleViolation[];

package/dist/se/metric-rules.js

@@ -204,20 +204,34 @@ function connectionPairs(graph) {
     return pairs;
 }
 /**
- * MT-03: Allocation Cohesion (CR-191 reformulated, CR-SM-221 recalibrated).
- * cohesion = internal / (internal + external), over FLOW-transitive connection pairs.
- * internal = both endpoints allocated to this module.
- * external = exactly one endpoint allocated to this module.
- * If external === 0 → cohesion = 100% → OK.
+ * Allocation cohesion — a **measurement, not a rule** (CR-SM-223, decision 2026-07-29).
+ *
+ * It used to be MT-03 with an 80 % threshold, and it fired on nearly every module of
+ * every real graph: 6 of 7 on graphcode, 4 of 4 on graph-view-edit, 10 of 11 on the
+ * family graph. `CR-SM-221` first suspected the edge definition and made it
+ * FLOW-transitive — the hit rate did not move. The threshold was the miscalibration:
+ * in a flow-routed layered architecture, module interaction crosses boundaries by
+ * design, so "80 % of interaction is internal" describes a monolith, not a healthy
+ * module.
+ *
+ * Rather than fit a cut-off to 11 data points, this reports the number and lets the
+ * architect judge. Returned worst-first, so the head of the list is where to look.
+ * Modules with fewer than two allocated FUNCs, or with no external connection at all,
+ * carry no signal and are omitted.
+ *
+ * Deliberately NOT a `RuleDefinition`: `computeReadiness` counts every violation into
+ * its dimension score regardless of severity, so a per-module advisory would depress
+ * the `alloc` score permanently. A measurement must not masquerade as a defect.
+ *
+ * Validation of this metric — and of MT-01/MT-02, which are thresholded the same way —
+ * is deferred (CR-SM-223).
  */
-export function mt03AllocationCohesion(graph) {
-    const violations = [];
+export function allocationCohesion(graph) {
+    const measurements = [];
     const mods = graph.elements.filter(e => e.type === 'MOD');
-    const COHESION_THRESHOLD = 0.8;
     const pairs = [...connectionPairs(graph)].map(p => p.split('|'));
     for (const mod of mods) {
-        const allocTraces = graph.traces.filter(t => t.type === 'allocate' && t.target === mod.id);
-        const funcIds = new Set(allocTraces.map(t => t.source));
+        const funcIds = new Set(graph.traces.filter(t => t.type === 'allocate' && t.target === mod.id).map(t => t.source));
         if (funcIds.size < 2)
             continue;
         let internal = 0;
@@ -230,25 +244,24 @@ export function mt03AllocationCohesion(graph) {
             else if (aIn || bIn)
                 external++;
         }
-        // No external connections → cohesion = 100% → OK
+        // No external connections → nothing to compare against, no signal.
         if (external === 0)
             continue;
-        const cohesion = internal / (internal + external);
-        if (cohesion < COHESION_THRESHOLD) {
-            violations.push({
-                rule_id: 'MT-03',
-                severity: 'info',
-                element_id: mod.id,
-                message: `${mod.name} allocation cohesion ${Math.round(cohesion * 100)}% (<${COHESION_THRESHOLD * 100}%). internal=${internal}, external=${external}`,
-            });
-        }
+        measurements.push({
+            moduleId: mod.id,
+            moduleName: mod.name,
+            internal,
+            external,
+            cohesion: internal / (internal + external),
+        });
     }
-    return violations;
+    // Worst first; stable by id so the ranking is deterministic.
+    return measurements.sort((a, b) => a.cohesion - b.cohesion || (a.moduleId < b.moduleId ? -1 : a.moduleId > b.moduleId ? 1 : 0));
 }
 export const MT_RULES = [
     { id: 'MT-01', name: 'Module instability', severity: 'warning', evaluate: mt01Instability },
     { id: 'MT-02', name: 'Module cohesion (LCOM4)', severity: 'info', evaluate: mt02Lcom4 },
-    { id: 'MT-03', name: 'Allocation cohesion', severity: 'info', evaluate: mt03AllocationCohesion },
+    // MT-03 retired as a rule (CR-SM-223) — see `allocationCohesion` above.
 ];
 export function evaluateMTRules(graph) {
     return MT_RULES.flatMap(r => r.evaluate(graph));

package/dist/se/readiness.js

@@ -60,7 +60,9 @@ export const RULE_TO_DIMENSION = {
     // near-duplicate detection
     'ND-01': 'arch', 'ND-02': 'schema',
     // architecture metrics
-    'MT-01': 'alloc', 'MT-02': 'alloc', 'MT-03': 'alloc',
+    // MT-03 is no longer here: it became a measurement (`allocationCohesion`), not a
+    // rule (CR-SM-223) — a per-module advisory would depress this score permanently.
+    'MT-01': 'alloc', 'MT-02': 'alloc',
     // CR traceability
     'CR-R01': 'cr', 'CR-R02': 'cr', 'CR-R03': 'cr', 'CR-R04': 'cr',
     // architecture optimization

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/contracts",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",