@sigloch/contracts 10.10.0 → 10.12.0

package/dist/se/rule-help.js

@@ -300,7 +300,15 @@ export const RULE_HELP = {
     },
     'RC-07': {
         plain: "A change request is marked done in the model but still open in the folder (or the other way round), or an open change request has no entry in the model → the folder decides; fix the model.",
-        se: "`CR` node whose `status` (closed = done/dropped/rejected) contradicts `docs/cr/open|done/`, or an OPEN CR file with no `CR` node (anchored at the first `SYS`). Nodes without a file are not reported — history. Absent `crFiles` is SILENCE (CR-SM-329).",
+        se: "`CR` node whose `status` (closed = done; CR-SM-362) contradicts `docs/cr/open|done/`, or an OPEN CR file with no `CR` node (anchored at the first `SYS`). Nodes without a file are not reported — history. Absent `crFiles` is SILENCE (CR-SM-329).",
+    },
+    'RC-08': {
+        plain: "A data contract in the model points at a type, which vanishes at runtime → write it as a Zod schema, so whoever produces the data can prove it and whoever reads it can check it.",
+        se: "`SCHEMA` whose `realRef` symbol is declared but is not a Zod schema (extractor field `zodSymbols`). Every producer needs a checkable schema — \"nobody parses it\" only means the reader is not known yet. Absent `zodSymbols` is SILENCE. Owns the type-binding cause: RC-04 stays quiet on such a SCHEMA (CR-SM-358).",
+    },
+    'RC-09': {
+        plain: "Code somewhere reads a data contract on its own, but the model does not know that place → go through the one translator the model names, or add the new translator to the model.",
+        se: "Zod-bound `SCHEMA` parsed (import + `.parse`/`.safeParse`) in a file that is neither its definition nor the `realRef` of a `FUNC` io-connected to a `FLOW` of this SCHEMA. The first code → model check: a second translator of one contract is a parallel path (spike CR-GC-637 — such paths share a contract, they are not similar). One finding per SCHEMA; test files exempt; runs only with `fileScope: 'all'` (CR-SM-358).",
     },
     'RD-01': {
         plain: "A smallest-piece feature has nothing built to fulfil it → add what implements it.",
@@ -311,10 +319,6 @@ export const RULE_HELP = {
         plain: "You split a feature into smaller features but you're also building the big one directly → build only the small pieces, not both.",
         se: "Parent `REQ` (has `compose`→`REQ` children) carrying a direct `FUNC` `satisfy`; the satisfy belongs on the children.",
     },
-    'RD-03': {
-        plain: "You split a feature into pieces, but all the pieces are handled by the same one thing — the split may be pointless → consider merging them.",
-        se: "Parent `REQ` whose children all share one satisfier.",
-    },
     'RD-04': {
         plain: "One thing has more than 9 parts directly under it → group them, so each level stays readable.",
         se: "Decomposition breadth above `metricPolicy.decompositionBreadth.warning` children on one level — `FUNC` `compose` `FUNC`, `SYS` `compose` `MOD`, a `MOD`'s sub-`MOD`s plus its own leaf `FUNC` (`allocate`), and the root `FUNC` forest anchored at `SYS` (CR-SM-282). Default 9, the upper end of 7±2 (CR-SM-296). CR-SM-311: a module level counts its own functions again — breadth, not size; module coupling is R-04. The lower bound is RD-05.",
@@ -347,14 +351,6 @@ export const RULE_HELP = {
         se: "`UC` description shorter than 10 characters or containing TBD/TODO/FIXME/placeholder/XXX. Description IS the goal (CR-150).",
         prompt: "se:author-uc",
     },
-    'UC-05': {
-        plain: "A scenario does not say what must be true once it has finished → add that as a requirement.",
-        se: "`UC` with no `compose`d `REQ` carrying `kinds:[\"postcondition\"]`.",
-    },
-    'UC-06': {
-        plain: "A scenario does not say what must be true before it can start → add that as a requirement.",
-        se: "`UC` with no `compose`d `REQ` carrying `kinds:[\"precondition\"]`.",
-    },
     'VR-01': {
         plain: "A test exists but no result was ever recorded, so nobody knows if it passed → record the outcome.",
         se: "`TEST` with no `testResult` attribute — assumed pending, never assumed green.",

package/dist/se/rules.js

@@ -4,7 +4,7 @@
  * @sigloch/contracts/se — single source of truth for SE validation rules.
  */
 import { z } from 'zod/v4';
-import { ElementType, TraceType, TestRefsSchema, RealRefSchema } from './ontology.js';
+import { ElementType, TraceType, readTestRefs, readRealRef } from './ontology.js';
 import { traceRejection, admittingAlternatives, isValidTrace, BOUNDED_PATTERNS, REQUIRED_PATTERNS, maxOccurs } from './meta-model.js';
 import { indexOf } from './graph-index.js';
 import { moduleCrossings, subtreeFuncs } from './module-crossings.js';
@@ -663,35 +663,6 @@ function decompositionConsistency(graph) {
         context: { element_type: req.type, element_name: req.name },
     }));
 }
-// ---------------------------------------------------------------------------
-// RD-03: No premature decomposition (all children same satisfy target)
-// ---------------------------------------------------------------------------
-function noPrematureDecomposition(graph) {
-    const idx = indexOf(graph);
-    const reqs = idx.elementsOfType('REQ');
-    const parentReqs = reqs.filter(req => idx.out(req.id, 'compose').some(t => idx.typeOf(t.target) === 'REQ'));
-    return parentReqs
-        .filter(parent => {
-        const childIds = graph.traces
-            .filter(t => t.source === parent.id && t.type === 'compose' &&
-            idx.typeOf(t.target) === 'REQ')
-            .map(t => t.target);
-        if (childIds.length < 2)
-            return false;
-        const satisfyTargets = childIds.map(cid => idx.in(cid, 'satisfy').filter(t => t.source !== cid).map(t => t.source));
-        // All children satisfied by the same single source
-        const allSame = satisfyTargets.every(targets => targets.length === 1 && targets[0] === satisfyTargets[0]?.[0]);
-        return allSame && satisfyTargets[0]?.length === 1;
-    })
-        .map(req => ({
-        rule_id: 'RD-03',
-        severity: 'info',
-        element_id: req.id,
-        message: `${req.id} children all have the same satisfy target — decomposition may be unnecessary`,
-        fix_hint: 'Consider merging sub-REQs back into parent if they share the same verifiable level',
-        context: { element_type: req.type, element_name: req.name },
-    }));
-}
 function breadthCounts(graph) {
     const idx = indexOf(graph);
     // CR-SM-264: `typeOf` und `byId` baute diese Regel je Aufruf selbst — der Index hat beide.
@@ -1162,7 +1133,7 @@ function testMustHaveRunnableBinding(graph) {
         .filter(e => e.attributes?.concept !== true) // concept-only TESTs are exempt
         // CR-SM-231: `testRefs` (Array, min 1) statt `testRef` (Objekt). Semantik unveraendert —
         // Praesenz und Form, keine Datei-Existenz; die pruefst RC-02.
-        .filter(e => !TestRefsSchema.safeParse(e.attributes?.testRefs).success)
+        .filter(e => readTestRefs(e.attributes).state !== 'bound')
         .map(test => ({
         rule_id: 'R-19',
         severity: 'warning',
@@ -1194,12 +1165,12 @@ function testFileExclusivity(graph) {
     for (const el of graph.elements) {
         if (el.type !== 'TEST')
             continue;
-        const parsed = TestRefsSchema.safeParse(el.attributes?.testRefs);
-        if (!parsed.success)
+        const parsed = readTestRefs(el.attributes);
+        if (parsed.state !== 'bound')
             continue; // keine/ungueltige Bindung → R-19-Gebiet
         // Innerhalb EINES Knotens ist dieselbe Datei zweimal kein Konflikt, sondern eine
         // Redundanz — sie wuerde sonst als Selbstkollision gemeldet.
-        for (const file of new Set(parsed.data.map(r => r.file))) {
+        for (const file of new Set(parsed.value.map(r => r.file))) {
             const owners = claimedBy.get(file) ?? [];
             owners.push(el.id);
             claimedBy.set(file, owners);
@@ -1244,7 +1215,7 @@ function funcMustHaveCodeBinding(graph) {
     const composeFuncChildren = (id) => graph.traces
         .filter(t => t.source === id && t.type === 'compose' && funcById.has(t.target))
         .map(t => t.target);
-    const hasCodeRef = (el) => RealRefSchema.safeParse(el.attributes?.realRef).success;
+    const hasCodeRef = (el) => readRealRef(el.attributes).state === 'bound';
     const isExempt = (el) => el.attributes?.concept === true || el.attributes?.external === true;
     // A FUNC is bound iff it is exempt, has a codeRef, or is a parent whose
     // compose→FUNC children are all bound (recursive, cycle-safe).
@@ -1501,7 +1472,7 @@ function schemaMustHaveSchemaRef(graph) {
     const idx = indexOf(graph);
     return idx.elementsOfType('SCHEMA')
         .filter(e => e.attributes?.concept !== true && e.attributes?.external !== true)
-        .filter(e => !RealRefSchema.safeParse(e.attributes?.realRef).success)
+        .filter(e => readRealRef(e.attributes).state !== 'bound')
         .map(sc => ({
         rule_id: 'R-26',
         severity: 'warning',
@@ -1526,7 +1497,7 @@ function schemaMustHaveContractTest(graph) {
     const tests = idx.elementsOfType('TEST');
     return idx.elementsOfType('SCHEMA')
         .filter(sc => sc.attributes?.concept !== true)
-        .filter(sc => { const r = RealRefSchema.safeParse(sc.attributes?.realRef); return r.success && r.data.symbol !== undefined; })
+        .filter(sc => { const r = readRealRef(sc.attributes); return r.state === 'bound' && r.value.symbol !== undefined; })
         .filter(sc => !graph.traces.some(t => t.type === 'verify' && t.target === sc.id && typeOf.get(t.source) === 'TEST'))
         .map(sc => ({
         rule_id: 'R-32',
@@ -1686,7 +1657,6 @@ export const V3_RULES = [
     { id: 'R-32', name: 'SCHEMA must have contract TEST', severity: 'warning', evaluate: schemaMustHaveContractTest, domain: ['SCHEMA'] },
     { id: 'RD-01', name: 'Unresolved requirement', severity: 'warning', evaluate: unresolvedRequirement, domain: ['REQ'] },
     { id: 'RD-02', name: 'Decomposition consistency', severity: 'warning', evaluate: decompositionConsistency, domain: ['REQ'] },
-    { id: 'RD-03', name: 'No premature decomposition', severity: 'info', evaluate: noPrematureDecomposition, domain: ['REQ'] },
     { id: 'RD-04', name: 'Decomposition breadth', severity: 'warning', evaluate: decompositionBreadth, domain: ['FUNC', 'MOD', 'SYS'] },
     { id: 'RD-05', name: 'Decomposition too narrow', severity: 'warning', evaluate: decompositionNarrow, domain: ['FUNC', 'MOD', 'SYS'] },
     { id: 'MS-01', name: 'Milestone empty scope', severity: 'warning', evaluate: msEmptyScope, domain: ['MS'] },

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

@@ -8,7 +8,5 @@ export declare function uc01HasRequirements(graph: OntologyGraph): RuleViolation
 export declare function uc02HasActor(graph: OntologyGraph): RuleViolation[];
 export declare function uc03HasScenario(graph: OntologyGraph): RuleViolation[];
 export declare function uc04GoalDefined(graph: OntologyGraph): RuleViolation[];
-export declare function uc05HasPostcondition(graph: OntologyGraph): RuleViolation[];
-export declare function uc06HasPrecondition(graph: OntologyGraph): RuleViolation[];
 export declare const UC_RULES: RuleDefinition[];
 export declare function evaluateUCRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

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

@@ -112,53 +112,15 @@ export function uc04GoalDefined(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
-// UC-05: UC should have postcondition REQ (CR-165: compose only, satisfy UC→REQ invalid)
-// ---------------------------------------------------------------------------
-export function uc05HasPostcondition(graph) {
-    const idx = indexOf(graph);
-    return idx.elementsOfType('UC')
-        .filter(uc => !idx.out(uc.id, 'compose').some(t => {
-        const target = idx.byId.get(t.target);
-        return target?.type === 'REQ' && target.kinds?.includes('postcondition');
-    }))
-        .map(uc => ({
-        rule_id: 'UC-05',
-        severity: 'info',
-        element_id: uc.id,
-        message: `${uc.id} has no postcondition requirement`,
-        fix_hint: 'Add a REQ with kinds=["postcondition"] via compose trace',
-        context: { element_type: uc.type, element_name: uc.name },
-    }));
-}
-// ---------------------------------------------------------------------------
-// UC-06: UC should have precondition REQ (CR-165: compose only, satisfy UC→REQ invalid)
-// ---------------------------------------------------------------------------
-export function uc06HasPrecondition(graph) {
-    const idx = indexOf(graph);
-    return idx.elementsOfType('UC')
-        .filter(uc => !idx.out(uc.id, 'compose').some(t => {
-        const target = idx.byId.get(t.target);
-        return target?.type === 'REQ' && target.kinds?.includes('precondition');
-    }))
-        .map(uc => ({
-        rule_id: 'UC-06',
-        severity: 'info',
-        element_id: uc.id,
-        message: `${uc.id} has no precondition requirement`,
-        fix_hint: 'Add a REQ with kinds=["precondition"] via compose trace',
-        context: { element_type: uc.type, element_name: uc.name },
-    }));
-}
-// ---------------------------------------------------------------------------
 // Aggregated
 // ---------------------------------------------------------------------------
+// CR-SM-357: UC-05/UC-06 (Pre-/Postcondition-REQ) sind gestrichen — Schreibregel in se:author-uc,
+// wie BQ in author-req (CR-GC-602): sie feuerten an fast jedem UC, und niemand handelte darauf.
 export const UC_RULES = [
     { id: 'UC-01', name: 'UC has requirements', severity: 'warning', evaluate: uc01HasRequirements, domain: ['UC'] },
     { id: 'UC-02', name: 'UC has actor', severity: 'warning', evaluate: uc02HasActor, domain: ['UC'] },
     { id: 'UC-03', name: 'UC has scenario', severity: 'warning', evaluate: uc03HasScenario, domain: ['UC'] },
     { id: 'UC-04', name: 'UC has goal', severity: 'warning', evaluate: uc04GoalDefined, domain: ['UC'] },
-    { id: 'UC-05', name: 'UC has postcondition', severity: 'info', evaluate: uc05HasPostcondition, domain: ['UC'] },
-    { id: 'UC-06', name: 'UC has precondition', severity: 'info', evaluate: uc06HasPrecondition, domain: ['UC'] },
 ];
 // CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —
 // ein Sonderweg je Familie waere genau der zweite Pfad, den der Regelsatz verbietet.

package/dist/se/view-rules.js

@@ -3,7 +3,7 @@
  * VR-01: TEST with a testRefs entry that has no result (info).
  * CL-01: ACTOR without UCs in at least 2 distinct operatingModes (warning).
  */
-import { TestRefsSchema } from './ontology.js';
+import { readTestRefs } from './ontology.js';
 // ---------------------------------------------------------------------------
 // VR-01: ein testRefs-Eintrag ohne Ergebnis
 //
@@ -20,17 +20,17 @@ export function vr01TestNoResult(graph) {
     for (const el of graph.elements) {
         if (el.type !== 'TEST')
             continue;
-        const parsed = TestRefsSchema.safeParse(el.attributes?.testRefs);
-        if (!parsed.success)
+        const parsed = readTestRefs(el.attributes);
+        if (parsed.state !== 'bound')
             continue; // keine/ungueltige Bindung → R-19-Gebiet
-        const pending = parsed.data.filter(ref => ref.result === undefined);
+        const pending = parsed.value.filter(ref => ref.result === undefined);
         if (pending.length === 0)
             continue;
         violations.push({
             rule_id: 'VR-01',
             severity: 'info',
             element_id: el.id,
-            message: `${el.id} has ${pending.length} of ${parsed.data.length} testRefs entries without a result — assumed pending: ${pending.map(r => r.file).join(', ')}`,
+            message: `${el.id} has ${pending.length} of ${parsed.value.length} testRefs entries without a result — assumed pending: ${pending.map(r => r.file).join(', ')}`,
             fix_hint: 'Record the run outcome on the entry (result, ranAt, evidence) — a binding without a result is not evidence',
         });
     }

package/package.json

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