@sigloch/contracts 1.0.0 → 3.0.0

package/dist/harness/index.d.ts

@@ -79,6 +79,15 @@ export declare const MutateCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     targetUid: z.ZodString;
 }, z.core.$strip>], "op">;
 export type MutateCommand = z.infer<typeof MutateCommandSchema>;
+export interface OpRisk {
+    destructive: boolean;
+    structural: boolean;
+}
+export declare const OP_RISK: Record<MutateCommand['op'], OpRisk>;
+/** True iff `op` removes data that is not recoverable by re-running the same op. */
+export declare function isDestructiveOp(op: MutateCommand['op']): boolean;
+/** True iff `op` changes graph topology (nodes/edges), not just attributes. */
+export declare function isStructuralOp(op: MutateCommand['op']): boolean;
 /** Monotone graph revision; incremented by +1 per successful mutate(). */
 export declare const GraphVersionSchema: z.ZodNumber;
 export type GraphVersion = z.infer<typeof GraphVersionSchema>;

package/dist/harness/index.js

@@ -93,6 +93,23 @@ export const MutateCommandSchema = z.discriminatedUnion('op', [
         targetUid: z.string(),
     }),
 ]);
+export const OP_RISK = {
+    'add-node': { destructive: false, structural: true },
+    'update-node': { destructive: false, structural: false },
+    'delete-node': { destructive: true, structural: true },
+    'add-edge': { destructive: false, structural: true },
+    'delete-edge': { destructive: true, structural: true },
+    'update-edge': { destructive: false, structural: true },
+    'merge-nodes': { destructive: true, structural: true },
+};
+/** True iff `op` removes data that is not recoverable by re-running the same op. */
+export function isDestructiveOp(op) {
+    return OP_RISK[op].destructive;
+}
+/** True iff `op` changes graph topology (nodes/edges), not just attributes. */
+export function isStructuralOp(op) {
+    return OP_RISK[op].structural;
+}
 // ---------------------------------------------------------------------------
 // CR-199: OCC — graph revision + optional baseVersion on mutate().
 // Schema-only here; revision counter/stale-check/delta live in the harness

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

@@ -52,7 +52,7 @@ export declare const AO_RULES: readonly [{
     readonly evaluate: typeof ca01CapabilityAllocation;
 }, {
     readonly id: "IO-01";
-    readonly name: "CrossModuleIOCompleteness";
+    readonly name: "FuncPairIOCompleteness";
     readonly severity: "warning";
     readonly evaluate: typeof io01CrossModuleCompleteness;
 }];

package/dist/se/ao-rules.js

@@ -256,8 +256,12 @@ export function ca01CapabilityAllocation(graph) {
     return violations;
 }
 // ---------------------------------------------------------------------------
-// IO-01: Cross-module IO completeness (CR-192)
-// For each FCHAIN, FUNCs in different MODs must have a FLOW path between them.
+// IO-01: FUNC-pair IO completeness (CR-192, extended CR-SM-226)
+// For each FCHAIN with ≥2 FUNCs, every pair of FUNCs in the chain must have a
+// FLOW path between them — not just pairs allocated to different MODs.
+// CR-SM-226 removed the cross-module-only restriction: same-module FUNC
+// pairs need an explicit FLOW just as much (module allocation is an
+// orthogonal concern to whether the interaction itself is wired up).
 // ---------------------------------------------------------------------------
 export function io01CrossModuleCompleteness(graph) {
     const violations = [];
@@ -270,23 +274,21 @@ export function io01CrossModuleCompleteness(graph) {
             .filter(id => graph.elements.some(e => e.id === id && e.type === 'FUNC'));
         if (funcIds.length < 2)
             continue;
-        // Map FUNC→MOD via allocate
+        // Map FUNC→MOD via allocate (kept for the message context; no longer a filter).
         const funcToMod = new Map();
         for (const fid of funcIds) {
             const allocTrace = graph.traces.find(t => t.source === fid && t.type === 'allocate');
             if (allocTrace)
                 funcToMod.set(fid, allocTrace.target);
         }
-        // For each pair of FUNCs in different MODs, check for FLOW path
+        // For each pair of FUNCs in the chain, check for a FLOW path.
         const checked = new Set();
         for (const fA of funcIds) {
             for (const fB of funcIds) {
                 if (fA >= fB)
                     continue;
-                const modA = funcToMod.get(fA);
-                const modB = funcToMod.get(fB);
-                if (!modA || !modB || modA === modB)
-                    continue;
+                const modA = funcToMod.get(fA) ?? 'unallocated';
+                const modB = funcToMod.get(fB) ?? 'unallocated';
                 const pairKey = `${fA}:${fB}`;
                 if (checked.has(pairKey))
                     continue;
@@ -314,7 +316,7 @@ export function io01CrossModuleCompleteness(graph) {
                         severity: 'warning',
                         element_id: fA,
                         message: `${fA} (${modA}) and ${fB} (${modB}) in FCHAIN ${fc.id} have no IO path — missing FLOW?`,
-                        fix_hint: 'Add a FLOW element with io traces between these cross-module functions',
+                        fix_hint: 'Add a FLOW element with io traces between these functions',
                         context: {
                             element_type: 'FUNC',
                             element_name: elA?.name ?? fA,
@@ -334,7 +336,7 @@ export const AO_RULES = [
     { id: 'RT-01', name: 'PhysicalBoundaryIntegrity', severity: 'error', evaluate: rt01PhysicalBoundaryIntegrity },
     { id: 'PH-01', name: 'PhysicalModCompleteness', severity: 'info', evaluate: ph01PhysicalModCompleteness },
     { id: 'CA-01', name: 'CapabilityAllocation', severity: 'error', evaluate: ca01CapabilityAllocation },
-    { id: 'IO-01', name: 'CrossModuleIOCompleteness', severity: 'warning', evaluate: io01CrossModuleCompleteness },
+    { id: 'IO-01', name: 'FuncPairIOCompleteness', severity: 'warning', evaluate: io01CrossModuleCompleteness },
 ];
 export function evaluateAORules(graph) {
     return AO_RULES.flatMap(r => r.evaluate(graph));

package/dist/se/fchain-quality-rules.d.ts

@@ -6,5 +6,6 @@ import type { RuleDefinition, RuleViolation } from './rules.js';
 export declare function fc01ActorBoundary(graph: OntologyGraph): RuleViolation[];
 export declare function fc02LeafUcHasFchain(graph: OntologyGraph): RuleViolation[];
 export declare function fc03FchainFlat(graph: OntologyGraph): RuleViolation[];
+export declare function fc04ActorBounded(graph: OntologyGraph): RuleViolation[];
 export declare const FC_RULES: RuleDefinition[];
 export declare function evaluateFCRules(graph: OntologyGraph): RuleViolation[];

package/dist/se/fchain-quality-rules.js

@@ -93,12 +93,55 @@ export function fc03FchainFlat(graph) {
     return violations;
 }
 // ---------------------------------------------------------------------------
+// FC-04: FCHAIN is actor-bounded — trigger AND consumer (CR-SM-226).
+// Distinct from FC-01: FC-01 is satisfied by ANY single actor connection (one
+// direction only), and even allows a UC-level bypass (the parent UC's own
+// ACTOR io counts, with no FUNC-level connection at all). FC-04 is stricter —
+// it requires BOTH an entry (ACTOR→FLOW→FUNC∈chain, something triggers the
+// chain) AND an exit (FUNC∈chain→FLOW→ACTOR, the chain produces something
+// back to an actor), evaluated purely at the FUNC/FLOW level. This catches
+// the "hollow chain" FC-01 cannot see: a chain with an entry but no exit (or
+// vice versa), or one that only looks bounded because its parent UC happens
+// to have unrelated ACTOR io.
+// ---------------------------------------------------------------------------
+export function fc04ActorBounded(graph) {
+    return graph.elements
+        .filter(e => e.type === 'FCHAIN')
+        .filter(fc => {
+        const funcIds = new Set(graph.traces
+            .filter(t => t.source === fc.id && t.type === 'compose')
+            .map(t => t.target)
+            .filter(id => graph.elements.some(e => e.id === id && e.type === 'FUNC')));
+        if (funcIds.size === 0)
+            return false; // R-15 already flags the empty-chain case
+        const io = graph.traces.filter(t => t.type === 'io');
+        const isActor = (id) => graph.elements.some(e => e.id === id && e.type === 'ACTOR');
+        const isFlow = (id) => graph.elements.some(e => e.id === id && e.type === 'FLOW');
+        // Entry: ACTOR→FLOW→FUNC∈chain (something triggers the chain).
+        const entry = io.some(e => funcIds.has(e.target) && isFlow(e.source) &&
+            io.some(a => a.target === e.source && isActor(a.source)));
+        // Exit: FUNC∈chain→FLOW→ACTOR (the chain produces something back to an actor).
+        const exit = io.some(e => funcIds.has(e.source) && isFlow(e.target) &&
+            io.some(a => a.source === e.target && isActor(a.target)));
+        return !(entry && exit);
+    })
+        .map(fc => ({
+        rule_id: 'FC-04',
+        severity: 'warning',
+        element_id: fc.id,
+        message: `${fc.id} is not actor-bounded (needs an ACTOR trigger into AND an ACTOR consumer out of the chain)`,
+        fix_hint: 'Link an ACTOR→FLOW→FUNC entry and a FUNC→FLOW→ACTOR exit for at least one FUNC in the chain',
+        context: { element_type: fc.type, element_name: fc.name },
+    }));
+}
+// ---------------------------------------------------------------------------
 // Aggregated
 // ---------------------------------------------------------------------------
 export const FC_RULES = [
     { id: 'FC-01', name: 'FCHAIN has actor boundary', severity: 'warning', evaluate: fc01ActorBoundary },
     { id: 'FC-02', name: 'Leaf UC has FCHAIN', severity: 'warning', evaluate: fc02LeafUcHasFchain },
     { id: 'FC-03', name: 'FCHAIN is flat', severity: 'warning', evaluate: fc03FchainFlat },
+    { id: 'FC-04', name: 'FCHAIN actor-bounded (trigger+consumer)', severity: 'warning', evaluate: fc04ActorBounded },
 ];
 export function evaluateFCRules(graph) {
     return FC_RULES.flatMap(rule => rule.evaluate(graph));

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.22.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.22.0'; // CR-SM-226: +RULE_TO_PHASE (readiness.ts) — rule → SRR/PDR/CDR/TRR gate mapping analogous to RULE_TO_DIMENSION, exported PhaseGate enum, completeness-tested (no advisory fall-through); +DIMENSION_READINESS_NAME/PHASE_READINESS_NAME/DIMENSION_READINESS_DELTA_NAME Sprachregelung constants; -emergentPhase/-phaseScore (CR-120/146) DELETED from ReadinessReport — a third, undocumented phase construct next to RULE_TO_DIMENSION and the phase-gate grouping, no computation ever lived in contracts; +R-28 Ebenen-Präsenz (funcCount>1 requires ≥1 FLOW AND ≥1 SCHEMA, ONE combined rule — closes the vacuous-complete hole where 0 FLOWs/SCHEMAs read as "complete" because no per-element rule had anything to iterate) → PDR; +FC-04 FCHAIN-actor-bounded (ACTOR→FLOW→FUNC∈chain entry AND FUNC∈chain→FLOW→ACTOR exit, both required — stricter than FC-01's any-direction/UC-bypass check) → PDR; +SC-04 FLOW→SCHEMA sharp rule (every FLOW must relation→SCHEMA, the per-FLOW inverse of SC-02's per-SCHEMA check) → CDR; IO-01 extended to ALL FUNC pairs within an FCHAIN (removed the same-module skip — same-module pairs need an explicit FLOW just as much as cross-module ones) and added to RULE_TO_PHASE → PDR (was RULE_TO_DIMENSION-only); harness: +OP_RISK/isDestructiveOp/isStructuralOp destructive/structural classification per MutateCommand op (GVE-Audit F7) — informational only, does not drive the Apply-Gate verdict.
 /** 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.d.ts

@@ -1,6 +1,11 @@
 /**
  * CR-120: Readiness dimension schemas for dynamic phase readiness.
  * Dimensions emerge from graph state — no state machine.
+ * CR-SM-226: `emergentPhase`/`phaseScore` (CR-120/146) removed — a third,
+ * undocumented phase construct next to RULE_TO_DIMENSION and the (then still
+ * ad-hoc) phase-gate grouping. `RULE_TO_PHASE` below is the one replacement:
+ * a rule → SRR/PDR/CDR/TRR mapping, same shape and same completeness
+ * guarantee as `RULE_TO_DIMENSION`, exported so no consumer reinvents it.
  */
 import { z } from 'zod/v4';
 export declare const ReadinessDimension: z.ZodEnum<{
@@ -48,8 +53,6 @@ export declare const ReadinessReport: z.ZodObject<{
         applicable: z.ZodNumber;
         ready: z.ZodBoolean;
     }, z.core.$strip>>;
-    emergentPhase: z.ZodString;
-    phaseScore: z.ZodNumber;
     overallScore: z.ZodNumber;
     timestamp: z.ZodISODateTime;
 }, z.core.$strip>;
@@ -60,3 +63,24 @@ export type ReadinessReportType = z.infer<typeof ReadinessReport>;
  * since its core concern is test verification coverage.
  */
 export declare const RULE_TO_DIMENSION: Record<string, ReadinessDimensionType>;
+/** INCOSE technical-review gates, in lifecycle order. */
+export declare const PhaseGate: z.ZodEnum<{
+    SRR: "SRR";
+    PDR: "PDR";
+    CDR: "CDR";
+    TRR: "TRR";
+}>;
+export type PhaseGateType = z.infer<typeof PhaseGate>;
+/**
+ * Rule → phase-gate mapping (CR-SM-226). SRR = requirements/scope clarity,
+ * PDR = architecture/functional completeness, CDR = critical design/schema
+ * completeness, TRR = test readiness. Primary-gate assignment, same
+ * single-owner convention as RULE_TO_DIMENSION.
+ */
+export declare const RULE_TO_PHASE: Record<string, PhaseGateType>;
+/** The 8 RULE_TO_DIMENSION topic scores (req/uc/arch/alloc/ver/schema/cr/ms). */
+export declare const DIMENSION_READINESS_NAME = "dimension_readiness";
+/** The 4 RULE_TO_PHASE gate scores (SRR/PDR/CDR/TRR). */
+export declare const PHASE_READINESS_NAME = "phase_readiness";
+/** Best-of-N ranking KPI: candidate dimension_readiness minus baseline. */
+export declare const DIMENSION_READINESS_DELTA_NAME = "dimension_readiness_delta";

package/dist/se/readiness.js

@@ -1,15 +1,20 @@
 /**
  * CR-120: Readiness dimension schemas for dynamic phase readiness.
  * Dimensions emerge from graph state — no state machine.
+ * CR-SM-226: `emergentPhase`/`phaseScore` (CR-120/146) removed — a third,
+ * undocumented phase construct next to RULE_TO_DIMENSION and the (then still
+ * ad-hoc) phase-gate grouping. `RULE_TO_PHASE` below is the one replacement:
+ * a rule → SRR/PDR/CDR/TRR mapping, same shape and same completeness
+ * guarantee as `RULE_TO_DIMENSION`, exported so no consumer reinvents it.
  */
 import { z } from 'zod/v4';
 export const ReadinessDimension = z.enum([
     'req', // Requirements quality (BQ-01..07, RD-01..03)
-    'uc', // UC completeness (UC-01..06, R-14, FC-01..03)
+    'uc', // UC completeness (UC-01..06, R-14, FC-01..04)
     'arch', // Functional architecture (R-02, R-03, R-10, R-12)
     'alloc', // Module allocation (R-04)
     'ver', // Test coverage (R-01, R-05)
-    'schema', // Interface completeness (R-26 binding, SC-02 usage)
+    'schema', // Interface completeness (R-26 binding, SC-02/SC-04 usage)
     'cr', // CR traceability (CR-R01..R03)
     'ms', // Milestone planning (MS-01..02)
 ]);
@@ -22,8 +27,6 @@ export const ReadinessScore = z.object({
 });
 export const ReadinessReport = z.object({
     scores: z.array(ReadinessScore),
-    emergentPhase: z.string(),
-    phaseScore: z.number().min(0).max(1), // CR-146: % progress of current phase
     overallScore: z.number().min(0).max(1),
     timestamp: z.iso.datetime(),
 });
@@ -42,11 +45,14 @@ export const RULE_TO_DIMENSION = {
     // trace/realization/allocation completeness rules (CR-228 D: previously unmapped → advisory fall-through)
     'R-18': 'arch', 'R-19': 'ver', 'R-20': 'arch', 'R-21': 'ver',
     'R-22': 'alloc', 'R-23': 'alloc', 'R-26': 'schema', 'R-27': 'arch',
+    // CR-SM-226: R-28 Ebenen-Präsenz (>1 FUNC needs FLOW+SCHEMA) is an architecture rule.
+    'R-28': 'arch',
     // uc
     'UC-01': 'uc', 'UC-02': 'uc', 'UC-03': 'uc', 'UC-04': 'uc',
     'UC-05': 'uc', 'UC-06': 'uc',
     'R-14': 'uc', 'R-15': 'uc', 'R-16': 'uc', 'R-17': 'uc',
-    'FC-01': 'uc', 'FC-02': 'uc', 'FC-03': 'uc',
+    // FC-04 (CR-SM-226): FCHAIN actor-bounded (trigger+consumer) — same dimension as FC-01..03.
+    'FC-01': 'uc', 'FC-02': 'uc', 'FC-03': 'uc', 'FC-04': 'uc',
     // arch
     'R-02': 'arch', 'R-03': 'arch', 'R-10': 'arch', 'R-12': 'arch',
     // alloc
@@ -55,12 +61,16 @@ export const RULE_TO_DIMENSION = {
     'R-01': 'ver', 'R-05': 'ver',
     // schema
     'SC-02': 'schema', // SC-01/SC-03 deleted (BOK-CR-026) — R-26 is the binding rule
+    // CR-SM-226: SC-04 sharp per-FLOW SCHEMA-binding check — same dimension as SC-02.
+    'SC-04': 'schema',
     // structural rules without primary dimension → assigned by closest concern
     'R-08': 'arch',
     // 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
@@ -79,3 +89,65 @@ export const RULE_TO_DIMENSION = {
     'VR-01': 'ver',
     'CL-01': 'uc',
 };
+// ---------------------------------------------------------------------------
+// Phase-gate readiness (CR-SM-226) — the INCOSE technical-review axis.
+// Orthogonal to RULE_TO_DIMENSION (8 topic scores): RULE_TO_PHASE groups the
+// SAME rule violations into the 4 lifecycle gates SRR/PDR/CDR/TRR. Both are
+// projections of one rule stream — "three views over the same rule
+// violations" (docs/articles/07-the-scoring-landscape.md), not three
+// independent scoring systems. No advisory fall-through: every rule in
+// ALL_RULE_DEFS must appear here (enforced by a completeness test analogous
+// to the RULE_TO_DIMENSION one).
+// ---------------------------------------------------------------------------
+/** INCOSE technical-review gates, in lifecycle order. */
+export const PhaseGate = z.enum(['SRR', 'PDR', 'CDR', 'TRR']);
+/**
+ * Rule → phase-gate mapping (CR-SM-226). SRR = requirements/scope clarity,
+ * PDR = architecture/functional completeness, CDR = critical design/schema
+ * completeness, TRR = test readiness. Primary-gate assignment, same
+ * single-owner convention as RULE_TO_DIMENSION.
+ */
+export const RULE_TO_PHASE = {
+    // SRR — requirements/scope clarity, system+UC boundary definition.
+    'BQ-01': 'SRR', 'BQ-02': 'SRR', 'BQ-04': 'SRR', 'BQ-06': 'SRR', 'BQ-07': 'SRR',
+    'RD-01': 'SRR', 'RD-02': 'SRR', 'RD-03': 'SRR',
+    'UC-01': 'SRR', 'UC-02': 'SRR', 'UC-03': 'SRR', 'UC-04': 'SRR', 'UC-05': 'SRR', 'UC-06': 'SRR',
+    'R-14': 'SRR', 'R-16': 'SRR', 'R-17': 'SRR',
+    'FC-02': 'SRR',
+    'CL-01': 'SRR',
+    'FM-01': 'SRR', 'FM-02': 'SRR',
+    'CR-R01': 'SRR', 'CR-R03': 'SRR',
+    'MS-01': 'SRR', 'MS-02': 'SRR', 'MS-03': 'SRR',
+    // PDR — architecture/functional completeness.
+    'RD-04': 'PDR',
+    'R-02': 'PDR', 'R-03': 'PDR', 'R-08': 'PDR', 'R-10': 'PDR', 'R-12': 'PDR', 'R-18': 'PDR',
+    'R-04': 'PDR', 'R-22': 'PDR', 'R-23': 'PDR',
+    'R-15': 'PDR',
+    'FC-01': 'PDR', 'FC-03': 'PDR', 'FC-04': 'PDR',
+    'R-28': 'PDR', // Ebenen-Präsenz (CR-SM-226)
+    'MT-01': 'PDR', 'MT-02': 'PDR',
+    'ND-01': 'PDR',
+    'AO-D01': 'PDR', 'AO-D03': 'PDR', 'CR-01': 'PDR', 'RT-01': 'PDR', 'PH-01': 'PDR', 'CA-01': 'PDR',
+    'IO-01': 'PDR', // CR-SM-226: extended to all FCHAIN FUNC-pairs, added to the phase axis.
+    'CR-R04': 'PDR',
+    // CDR — critical design/schema completeness.
+    'R-26': 'CDR', 'R-27': 'CDR',
+    'SC-02': 'CDR', 'SC-04': 'CDR', // SC-04: FLOW→SCHEMA sharp rule (CR-SM-226)
+    'ND-02': 'CDR',
+    'NFR-01': 'CDR',
+    // TRR — test readiness.
+    'R-01': 'TRR', 'R-05': 'TRR', 'R-19': 'TRR', 'R-20': 'TRR', 'R-21': 'TRR',
+    'VR-01': 'TRR',
+    'FM-03': 'TRR',
+    'CR-R02': 'TRR',
+};
+// ---------------------------------------------------------------------------
+// Sprachregelung (CR-SM-226) — naming SSOT so graphcode/graph-view-edit/
+// article render the same terms instead of re-inventing string literals.
+// ---------------------------------------------------------------------------
+/** The 8 RULE_TO_DIMENSION topic scores (req/uc/arch/alloc/ver/schema/cr/ms). */
+export const DIMENSION_READINESS_NAME = 'dimension_readiness';
+/** The 4 RULE_TO_PHASE gate scores (SRR/PDR/CDR/TRR). */
+export const PHASE_READINESS_NAME = 'phase_readiness';
+/** Best-of-N ranking KPI: candidate dimension_readiness minus baseline. */
+export const DIMENSION_READINESS_DELTA_NAME = 'dimension_readiness_delta';

package/dist/se/rules.js

@@ -898,6 +898,41 @@ function physicalModMustHaveRealRef(graph) {
         context: { element_type: mod.type, element_name: mod.name },
     }));
 }
+// ---------------------------------------------------------------------------
+// R-28: Ebenen-Präsenz — architecture-level presence (CR-SM-226).
+// Closes the vacuous-complete hole: with 0 or 1 FUNC, per-element rules like
+// R-15/FC-04/SC-04 fire 0 times and every completeness leg reads "complete" —
+// not because the architecture is done, but because there is nothing to check
+// yet. Once >1 FUNC exists, the graph must ALSO carry at least one FLOW (data
+// moves between functions) AND at least one SCHEMA (that data has a
+// contract) — ONE combined rule, not staged PDR/CDR checks (the CR draft's
+// two-stage proposal was simplified in Familie-Review 2026-08-04).
+// ---------------------------------------------------------------------------
+function ebenenPraesenz(graph) {
+    const funcs = graph.elements.filter(e => e.type === 'FUNC');
+    if (funcs.length <= 1)
+        return [];
+    const flows = graph.elements.filter(e => e.type === 'FLOW');
+    const schemas = graph.elements.filter(e => e.type === 'SCHEMA');
+    const missingLevels = [];
+    if (flows.length === 0)
+        missingLevels.push('FLOW');
+    if (schemas.length === 0)
+        missingLevels.push('SCHEMA');
+    if (missingLevels.length === 0)
+        return [];
+    // Anchor the graph-wide violation on SYS (the root) if present, else the
+    // first FUNC — there is no single "population" element this rule checks.
+    const anchor = graph.elements.find(e => e.type === 'SYS') ?? funcs[0];
+    return [{
+            rule_id: 'R-28',
+            severity: 'warning',
+            element_id: anchor.id,
+            message: `Graph has ${funcs.length} FUNCs but no ${missingLevels.join(' and no ')} element — architecture level(s) absent`,
+            fix_hint: `Add at least one ${missingLevels.join(' and one ')} element to bind the functional and data-level architecture`,
+            context: { element_type: anchor.type, element_name: anchor.name },
+        }];
+}
 export const V3_RULES = [
     { id: 'R-01', name: 'REQ must have verification', severity: 'error', evaluate: reqMustHaveVerification },
     { id: 'R-02', name: 'FUNC must satisfy REQ', severity: 'warning', evaluate: funcMustSatisfyReq },
@@ -925,6 +960,7 @@ export const V3_RULES = [
     { id: 'RD-04', name: 'Decomposition breadth', severity: 'warning', evaluate: decompositionBreadth },
     { id: 'MS-01', name: 'Milestone empty scope', severity: 'warning', evaluate: msEmptyScope },
     { id: 'MS-02', name: 'Milestone dangling dependency', severity: 'error', evaluate: msDanglingDependency },
+    { id: 'R-28', name: 'Ebenen-Präsenz (FLOW+SCHEMA when funcCount>1)', severity: 'warning', evaluate: ebenenPraesenz },
 ];
 /** Run all rules against a graph */
 export function evaluateRules(graph) {

package/dist/se/schema-quality-rules.d.ts

@@ -15,5 +15,6 @@
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
 export declare function sc02IsReferenced(graph: OntologyGraph): RuleViolation[];
+export declare function sc04FlowHasSchema(graph: OntologyGraph): RuleViolation[];
 export declare const SC_RULES: RuleDefinition[];
 export declare function evaluateSCRules(graph: OntologyGraph): RuleViolation[];

package/dist/se/schema-quality-rules.js

@@ -20,10 +20,37 @@ export function sc02IsReferenced(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
+// SC-04: FLOW must reference a SCHEMA (CR-SM-226) — the sharp per-FLOW
+// inverse of SC-02. SC-02 catches an orphan SCHEMA (nobody uses it); SC-04
+// catches a FLOW with no data contract at all — until now only caught
+// loosely, around the SC-02-adjacent CDR completeness leg, never as its own
+// rule.
+// ---------------------------------------------------------------------------
+export function sc04FlowHasSchema(graph) {
+    const schemas = graph.elements.filter(e => e.type === 'SCHEMA');
+    return graph.elements
+        .filter(e => e.type === 'FLOW')
+        .filter(f => !graph.traces.some(t => t.source === f.id && t.type === 'relation' &&
+        graph.elements.some(e => e.id === t.target && e.type === 'SCHEMA')))
+        .map(f => ({
+        rule_id: 'SC-04',
+        severity: 'warning',
+        element_id: f.id,
+        message: `${f.id} has no SCHEMA binding`,
+        fix_hint: 'Link a SCHEMA via relation trace to define this FLOW\'s data contract',
+        context: {
+            element_type: f.type,
+            element_name: f.name,
+            candidate_targets: schemas.map(s => ({ id: s.id, type: s.type, name: s.name })),
+        },
+    }));
+}
+// ---------------------------------------------------------------------------
 // Aggregated array & convenience runner
 // ---------------------------------------------------------------------------
 export const SC_RULES = [
     { id: 'SC-02', name: 'Schema referenced by FLOW', severity: 'warning', evaluate: sc02IsReferenced },
+    { id: 'SC-04', name: 'FLOW has SCHEMA binding', severity: 'warning', evaluate: sc04FlowHasSchema },
 ];
 export function evaluateSCRules(graph) {
     return SC_RULES.flatMap(rule => rule.evaluate(graph));

package/package.json

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