@sigloch/contracts 3.1.0 → 3.2.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.23.0";
+export declare const RULES_VERSION = "2.24.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.23.0'; // CR-SM-227: +AF-01..05 Analysis-Freshness-Legs (analysis-freshness-rules.ts) — the third leg-kind a review gate checks (rule legs, layer-presence legs [R-28], now analysis-freshness legs, docs/articles/07-the-scoring-landscape.md); presence-only rules (Presence/Resolution-Split like R-19/R-20/R-26/R-27 vs. RC-01..05) checking a `graphVersion` freshness stamp exists under SYS.attributes.analysisFreshness.<AnalysisArtifactId> for each of the 5 CR-GC-221 judgment artifacts (conops/trade/assumption-review/fmea/implplan) — staleness (stamp vs live graphVersion) stays a consumer/I-O concern (`CreationCurrencyProvider`, @sigloch/graphcode-client), NOT evaluated here; Familie-Review 2026-08-05 gate assignment → RULE_TO_PHASE: ConOps/Trade/Assumption-Review → PDR, FMEA → CDR, Implementation Plan → TRR (SRR gets none); +AnalysisArtifactId enum + AnalysisFreshnessStampSchema (ontology.ts) as the SSOT graphcode-client's ARTIFACT_CATALOG analysis ids must match; grober Graph-Versions-Stempel only, no scope-hash in this first cut (conscious CR-SM-227 limitation).
+export const RULES_VERSION = '2.24.0'; // CR-GC-315: R-12 + R-21 no longer tax FLOW reuse. R-12 restricted to dependency-carrying traces (compose/allocate/relation) — on `io` the only reachable shape was FUNC ─io→ FLOW ─io→ the SAME FUNC, i.e. read-modify-write on a shared FLOW, so the check was pure false-positive there (real io-cycles span ≥2 FUNCs and a 2-cycle test cannot see them); satisfy/verify/produces 2-cycles are pattern-illegal and belong to R-18. Its dedup key is now direction-independent (`type|sorted pair`) — keying on the message never collapsed anything, so every cycle was reported twice. R-21 no longer derives FUNC↔FUNC connections from FLOW co-adjacency alone: a producer/consumer pair with NO shared FCHAIN is silent. One hub FLOW with P producers and C consumers manufactured P·C findings, each demanding its own FCHAIN+integration test including pairs that never interact — reuse was penalised quadratically. The FCHAIN is the declared integration scope; the test is owed on that declared claim only. Rule intent (CR-GC-240 gap: unit/UC tests do not cover FUNC↔FUNC wiring) unchanged. Prior: CR-SM-227: +AF-01..05 Analysis-Freshness-Legs (analysis-freshness-rules.ts) — the third leg-kind a review gate checks (rule legs, layer-presence legs [R-28], now analysis-freshness legs, docs/articles/07-the-scoring-landscape.md); presence-only rules (Presence/Resolution-Split like R-19/R-20/R-26/R-27 vs. RC-01..05) checking a `graphVersion` freshness stamp exists under SYS.attributes.analysisFreshness.<AnalysisArtifactId> for each of the 5 CR-GC-221 judgment artifacts (conops/trade/assumption-review/fmea/implplan) — staleness (stamp vs live graphVersion) stays a consumer/I-O concern (`CreationCurrencyProvider`, @sigloch/graphcode-client), NOT evaluated here; Familie-Review 2026-08-05 gate assignment → RULE_TO_PHASE: ConOps/Trade/Assumption-Review → PDR, FMEA → CDR, Implementation Plan → TRR (SRR gets none); +AnalysisArtifactId enum + AnalysisFreshnessStampSchema (ontology.ts) as the SSOT graphcode-client's ARTIFACT_CATALOG analysis ids must match; grober Graph-Versions-Stempel only, no scope-hash in this first cut (conscious CR-SM-227 limitation).
 /** 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/rules.js

@@ -312,28 +312,39 @@ function flowCompleteness(graph) {
 // R-11: REMOVED — superseded by SC-02 (identical check, better severity).
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
-// R-12: Circular dependency detection
-// ---------------------------------------------------------------------------
+// R-12: Circular dependency detection — direct 2-cycles over dependency-carrying
+// traces only (CR-GC-315). `io` is excluded: the only shape a 2-cycle test can
+// hit on `io` is FUNC ─io→ FLOW ─io→ the SAME FUNC, i.e. read-modify-write on a
+// shared FLOW — the reuse pattern, not a dependency cycle. Real io-cycles span
+// ≥2 FUNCs and are invisible to a 2-cycle test anyway, so on `io` the rule was
+// pure false-positive and taxed FLOW reuse. satisfy/verify/produces 2-cycles are
+// already pattern-illegal and belong to R-18.
+// ---------------------------------------------------------------------------
+/** Trace types on which a direct 2-cycle is a real finding (CR-GC-315). */
+const CIRCULAR_TRACE_TYPES = new Set(['compose', 'allocate', 'relation']);
 function noDirectCircular(graph) {
     const violations = [];
-    for (const t of graph.traces) {
-        if (graph.traces.some(other => other.source === t.target && other.target === t.source && other.type === t.type)) {
-            violations.push({
-                rule_id: 'R-12',
-                severity: 'warning',
-                element_id: t.source,
-                message: `Circular ${t.type} between ${t.source} and ${t.target}`,
-            });
-        }
-    }
+    // Direction-independent key: A↔B is ONE cycle, reported once. Keying on the
+    // message (CR-GC-315 predecessor) never collapsed anything — the two
+    // directions render different messages, so every cycle was reported twice.
     const seen = new Set();
-    return violations.filter(v => {
-        const key = v.message;
+    for (const t of graph.traces) {
+        if (!CIRCULAR_TRACE_TYPES.has(t.type))
+            continue;
+        if (!graph.traces.some(other => other.source === t.target && other.target === t.source && other.type === t.type))
+            continue;
+        const key = `${t.type}|${[t.source, t.target].sort().join('|')}`;
         if (seen.has(key))
-            return false;
+            continue;
         seen.add(key);
-        return true;
-    });
+        violations.push({
+            rule_id: 'R-12',
+            severity: 'warning',
+            element_id: t.source,
+            message: `Circular ${t.type} between ${t.source} and ${t.target}`,
+        });
+    }
+    return violations;
 }
 // ---------------------------------------------------------------------------
 // R-13: DELETED — superseded by RD-01 (CR-180)
@@ -724,13 +735,17 @@ function funcMustHaveCodeBinding(graph) {
 }
 /** All rules — see RULES_VERSION in ./index.ts (R-06/R-07/R-09/R-11/R-13/R-24/R-25 removed, R-14..R-23/R-26/RD-01..03/MS-01..02 added) */
 // ---------------------------------------------------------------------------
-// R-21: Every FUNC↔FUNC connection must be covered by an integration test.
-//       A connection is FUNC ─io→ FLOW ─io→ FUNC. It is covered iff both
-//       endpoints share an FCHAIN that owns a verifying integration test
-//       (TEST ─verify→ REQ ←satisfy─ FCHAIN). Unit tests (FUNC→REQ) and UC
-//       acceptance tests do NOT cover the interface between two functions —
-//       CR-GC-240 folded "integration" onto the UC level, leaving FUNC↔FUNC
-//       wiring unverified; this rule closes that gap edge-granularly.
+// R-21: Every FUNC↔FUNC connection *declared as an FCHAIN* must be covered by an
+//       integration test. A connection is FUNC ─io→ FLOW ─io→ FUNC. It is
+//       covered iff both endpoints share an FCHAIN that owns a verifying
+//       integration test (TEST ─verify→ REQ ←satisfy─ FCHAIN). Unit tests
+//       (FUNC→REQ) and UC acceptance tests do NOT cover the interface between
+//       two functions — CR-GC-240 folded "integration" onto the UC level,
+//       leaving FUNC↔FUNC wiring unverified; this rule closes that gap.
+//       CR-GC-315: a producer/consumer pair with NO shared FCHAIN is silent.
+//       Co-adjacency at a shared FLOW is not an asserted interface — treating it
+//       as one produced P·C findings per hub FLOW and made reuse the expensive
+//       choice. The FCHAIN is the modelled claim; the test is owed on the claim.
 // ---------------------------------------------------------------------------
 function fchainMustHaveIntegrationTest(graph) {
     const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
@@ -769,9 +784,15 @@ function fchainMustHaveIntegrationTest(graph) {
     const seen = new Set();
     for (const [p, c] of connections) {
         const shared = [...(chainsOfFunc.get(p) ?? [])].filter(ch => chainsOfFunc.get(c)?.has(ch));
+        // No shared FCHAIN = no asserted integration (CR-GC-315). Sharing one FLOW
+        // between P producers and C consumers does not mean P·C interfaces exist —
+        // deriving connections from FLOW adjacency alone taxed reuse quadratically.
+        // The FCHAIN is the declared integration scope; only that is held to a test.
+        if (shared.length === 0)
+            continue;
         if (shared.some(ch => testedChains.has(ch)))
             continue;
-        const anchor = shared[0] ?? p;
+        const anchor = shared[0];
         const key = `${anchor}|${p}>${c}`;
         if (seen.has(key))
             continue;
@@ -781,10 +802,8 @@ function fchainMustHaveIntegrationTest(graph) {
             rule_id: 'R-21',
             severity: 'warning',
             element_id: anchor,
-            message: shared.length > 0
-                ? `${anchor} has no integration test covering connection ${p} → ${c}`
-                : `connection ${p} → ${c} is in no FCHAIN with an integration test`,
-            fix_hint: 'Group both FUNCs in an FCHAIN and verify an FCHAIN-satisfied REQ with an integration TEST',
+            message: `${anchor} has no integration test covering connection ${p} → ${c}`,
+            fix_hint: 'Verify an FCHAIN-satisfied REQ with an integration TEST',
             context: { element_type: anchorEl?.type, element_name: anchorEl?.name },
         });
     }

package/package.json

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