@sigloch/contracts 11.0.0 → 12.0.0

package/dist/se/analysis-freshness-rules.d.ts

@@ -66,33 +66,6 @@ export declare const AF_RULES: readonly [{
     readonly evaluate: typeof buildPlanDue;
     readonly domain: readonly ["graph"];
 }];
-/** TR-01: a stamped trade study names >=1 existing CR, each carrying a relation(label: decides) edge. */
-export declare function tradeDecisionRecorded(graph: OntologyGraph): RuleViolation[];
-/**
- * IR-01 (CR-SM-397): every REQ named by a stamped assumption review exists; an empty list is a
- * legitimate outcome. That the REQ carries a verifying TEST is R-01's finding, not repeated here.
- */
-export declare function assumptionReviewRequirementsExist(graph: OntologyGraph): RuleViolation[];
-/** CR-SM-355: the outcome rules of trade / irr — silent until the analysis is stamped. */
-export declare const TASK_OUTCOME_RULES: readonly [{
-    readonly id: "TR-01";
-    readonly name: "Trade decision recorded as CR";
-    readonly severity: "warning";
-    readonly stage: 7;
-    readonly role: "analysis";
-    readonly evaluate: typeof tradeDecisionRecorded;
-    readonly domain: readonly ["graph"];
-}, {
-    readonly id: "IR-01";
-    readonly name: "Assumption review requirements exist";
-    readonly severity: "warning";
-    readonly stage: 7;
-    readonly role: "analysis";
-    readonly evaluate: typeof assumptionReviewRequirementsExist;
-    readonly domain: readonly ["graph"];
-}];
-/** Evaluate the task-outcome rules (CR-SM-355). */
-export declare function evaluateTaskOutcomeRules(graph: OntologyGraph): RuleViolation[];
 /** Evaluate all analysis-freshness-presence rules. */
 export declare function evaluateAFRules(graph: OntologyGraph): RuleViolation[];
 export {};

package/dist/se/analysis-freshness-rules.js

@@ -30,7 +30,7 @@ const ANALYSIS_WORK = {
     },
     trade: {
         skill: 'se-trade',
-        firstStep: 'name the open decision with its options and criteria, then record the chosen option as a CR with relation(label: decides) edges to what it decides',
+        firstStep: 'name the open decision with its options and criteria, then apply the chosen option to the model and record the decision as a done CR with relation edges to what was decided',
     },
     'assumption-review': {
         skill: 'se-irr',
@@ -108,82 +108,6 @@ export const AF_RULES = [
     { id: 'AF-04', name: 'FMEA freshness stamp present', severity: 'warning', stage: 8, role: 'analysis', evaluate: fmeaFreshnessPresent, domain: ['graph'] },
     { id: 'AF-05', name: 'Unbuilt elements have an open CR', severity: 'warning', stage: 10, role: 'existence', evaluate: buildPlanDue, domain: ['graph'] },
 ];
-/**
- * Task-Ausgangsregeln fuer trade und irr (CR-SM-355, CR-SM-397): was der Task hinterlassen hat, ist
- * im Frischestempel genannt und existiert. Ein Variantenvergleich hinterlaesst Entscheidungs-CRs
- * (`crRefs`, TR-01), ein Annahmen-Review Anforderungen (`reqRefs`, IR-01) — eine Analyse legt keinen
- * Bauauftrag an. Ohne Stempel feuern die Regeln nicht (dann feuert der Eintritt AF-02/AF-03).
- * `label` wird als `Trace.label` gelesen wie bei MS-02 — `decides` ist kein TraceType, sondern das
- * SP-1-Label einer relation-Kante.
- */
-function stampedOutcome(graph, artifactId) {
-    const sys = graph.elements.find(e => e.type === 'SYS');
-    if (!sys)
-        return null;
-    const stamp = readAnalysisStamp(graph, artifactId);
-    if (stamp.state !== 'bound')
-        return null;
-    return { sys, stamp: stamp.value };
-}
-/** TR-01: a stamped trade study names >=1 existing CR, each carrying a relation(label: decides) edge. */
-export function tradeDecisionRecorded(graph) {
-    const stamped = stampedOutcome(graph, 'trade');
-    if (!stamped)
-        return [];
-    const { sys } = stamped;
-    const crRefs = stamped.stamp.crRefs ?? [];
-    const base = { rule_id: 'TR-01', severity: 'warning', context: { element_type: sys.type, element_name: sys.name } };
-    if (crRefs.length === 0) {
-        return [{
-                ...base,
-                element_id: sys.id,
-                message: 'Trade Study is stamped but names no decision CR (analysisFreshness.trade.crRefs is empty) — a trade without a recorded decision is a list, not a trade',
-                fix_hint: 'Record the decision as a CR with relation(label: decides) edges and list its id in analysisFreshness.trade.crRefs (se-trade)',
-            }];
-    }
-    const byId = new Map(graph.elements.map(e => [e.id, e]));
-    const decidesFrom = new Set(graph.traces.filter(t => t.type === 'relation' && t.label === 'decides').map(t => t.source));
-    return crRefs.flatMap(id => {
-        const cr = byId.get(id);
-        if (!cr || cr.type !== 'CR') {
-            return [{ ...base, element_id: sys.id, message: `Trade Study names ${id} as its decision, but no CR with that id exists`, fix_hint: 'Point analysisFreshness.trade.crRefs at an existing CR, or add the CR through graph_mutate (se-trade)' }];
-        }
-        if (!decidesFrom.has(id)) {
-            return [{ ...base, element_id: id, message: `${id} is named as a trade decision but carries no relation(label: decides) edge`, fix_hint: 'Add a relation edge from the CR to the element it decides, with label "decides" (se-trade)' }];
-        }
-        return [];
-    });
-}
-/**
- * IR-01 (CR-SM-397): every REQ named by a stamped assumption review exists; an empty list is a
- * legitimate outcome. That the REQ carries a verifying TEST is R-01's finding, not repeated here.
- */
-export function assumptionReviewRequirementsExist(graph) {
-    const stamped = stampedOutcome(graph, 'assumption-review');
-    if (!stamped)
-        return [];
-    const { sys } = stamped;
-    const byId = new Map(graph.elements.map(e => [e.id, e]));
-    return (stamped.stamp.reqRefs ?? [])
-        .filter(id => byId.get(id)?.type !== 'REQ')
-        .map(id => ({
-        rule_id: 'IR-01',
-        severity: 'warning',
-        element_id: sys.id,
-        message: `Assumption Review names ${id} as the requirement of a load-bearing assumption, but no REQ with that id exists`,
-        fix_hint: 'Point analysisFreshness.assumption-review.reqRefs at an existing REQ, or add the REQ with its verifying TEST through graph_mutate (se-irr)',
-        context: { element_type: sys.type, element_name: sys.name },
-    }));
-}
-/** CR-SM-355: the outcome rules of trade / irr — silent until the analysis is stamped. */
-export const TASK_OUTCOME_RULES = [
-    { id: 'TR-01', name: 'Trade decision recorded as CR', severity: 'warning', stage: 7, role: 'analysis', evaluate: tradeDecisionRecorded, domain: ['graph'] },
-    { id: 'IR-01', name: 'Assumption review requirements exist', severity: 'warning', stage: 7, role: 'analysis', evaluate: assumptionReviewRequirementsExist, domain: ['graph'] },
-];
-/** Evaluate the task-outcome rules (CR-SM-355). */
-export function evaluateTaskOutcomeRules(graph) {
-    return TASK_OUTCOME_RULES.flatMap(r => r.evaluate(graph));
-}
 /** Evaluate all analysis-freshness-presence rules. */
 export function evaluateAFRules(graph) {
     return AF_RULES.flatMap(r => r.evaluate(graph));

package/dist/se/chain-metrics.d.ts

@@ -0,0 +1,116 @@
+/**
+ * CR-SM-404 — Kennzahlen der Wirkkette: je FCHAIN eine Zahl, oder der Grund, warum es keine gibt.
+ *
+ * Die Leitlinie verlangt, die Realisierungsarchitektur AUF DER WIRKKETTE zu bewerten (graphcode
+ * `docs/graphcode_architektur_konzept.md`, „Kennzahlen der Wirkkette"). Bis hierher rechnete das
+ * nur ein Spike in graphcode (`scripts/spike-kettenkennzahlen.mjs`); von dort ist die Rechnung
+ * portiert, nicht neu erfunden. Gemessen 2026-10-09 ueber 10 Familie-Graphen: 76 Ketten, 31
+ * bewertbar.
+ *
+ * ## Diese Datei URTEILT NICHT
+ *
+ * Keine Regel, keine Schwelle, kein Katalogeintrag — dieselbe Trennung wie `moduleMetrics` und
+ * `functionCriticality`. Ob eine Laenge von 6 gut ist, sagt erst ein Profil.
+ *
+ * ## Nicht bewertbar heisst: KEINE Zahl
+ *
+ * Eine FCHAIN ist grammatisch eine Menge; die Reihenfolge entsteht erst aus Erzeuger ->
+ * Verbraucher (`FUNC -io-> FLOW -io-> FUNC`, beide Enden Glied). Zerfaellt die Kette, beschriebe
+ * jede Kennzahl etwas, das es nicht gibt. Eine solche Kette traegt deshalb ihre Gruende und kein
+ * einziges Zahlenfeld — das Schema laesst es nicht zu. Sie zaehlt im NENNER der Quote
+ * (`measurability`), die neben jedem Wert stehen muss wie die Bindungsquote neben RC-*.
+ *
+ * ## Wer urteilt, ob eine Kette eine Kette ist
+ *
+ * - `FC-05`: die Regel FC-05, aufgerufen, nicht nachgebaut. Ursache (fehlendes Glied, Sack) und
+ *   die Nebenkomponenten stehen in ihrem Befund (`context.side_components`), nicht hier.
+ * - `loose-member`: ein Glied ohne io-Eingang oder -Ausgang. Das ist die Bedingung, unter der
+ *   FC-05 sich ENTHAELT (R-31 meldet das Glied) — ohne diesen Grund haette eine solche Kette weder
+ *   einen FC-05-Befund noch einen Grund und bekaeme Zahlen.
+ * - `no-entry` / `no-exit`: kein FLOW von bzw. zu einem Knoten AUSSERHALB der Kette. Weiter als
+ *   FC-04, das nur einen ACTOR gelten laesst: eine Kette, die eine andere fortsetzt, ist messbar.
+ * - `empty`: keine FUNC (R-15).
+ *
+ * ## Ein Kettenbegriff, ein Modulbegriff
+ *
+ * Glied = direkte `FCHAIN -compose-> FUNC`-Kante, ueber `chainsByFunc` (R-30s Definition).
+ * Modul einer FUNC = direkte `allocate`-Kante, wie `module-crossings.ts` und `moduleMetrics`.
+ * Der Spike erbte das Modul ueber compose-Vorfahren; gemessen sind 326 von 326 Kettengliedern
+ * des Korpus direkt alloziert — die Vererbung kauft nichts und waere eine zweite Vorstellung von
+ * Zugehoerigkeit im selben Paket.
+ *
+ * ## CR-SM-406 — die ORTE je Kette, nur erkannt
+ *
+ * Neben jeder Zahl steht, WO sie herkommt: die Mitglieder je Rueckkopplung, die geteilten
+ * Funktionen, die Grenzen je gerichtetem Modulpaar mit ihren Vertraegen, dazu Zulauf, Importe und
+ * Uebergaben. Reine Zusatzfelder — die Zahlen aus CR-SM-404 bleiben und sind die Laenge ihrer
+ * Liste. Weiter kein Urteil.
+ *
+ * - Import und Uebergabe zaehlen nur an Gliedern, die ALLEIN dieser Kette gehoeren. Was an einer
+ *   geteilten Funktion haengt, steht an der geteilten Funktion — sie ist ein eigener Ort. Ohne
+ *   diese Grenze meldete jede Kette durch Gate und Store deren Zufluesse als ihre eigenen
+ *   (gemessen am graphcode-Modell 2026-10-10: 333 statt 16).
+ * - Ein ACTOR als Erzeuger oder Verbraucher ist der Ein- und Ausgang der Kette, kein Ort.
+ * - Vertrag = `contractsOfFlow` aus `module-crossings.ts` (SCHEMA, sonst `UNBOUND:<flow>`), hier je
+ *   Kettenkante gelesen. `moduleCrossings().pairs` selbst traegt die Vertraege des GANZEN Graphen
+ *   je ungerichtetem Paar und kann „elf Kanten auf einem Vertrag" in EINER Kette nicht zeigen.
+ *
+ * @author andreas@siglochconsulting
+ */
+import { z } from 'zod/v4';
+import type { OntologyGraph } from './ontology.js';
+export declare const ChainMetrics: z.ZodObject<{
+    chains: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        measurable: z.ZodLiteral<true>;
+        length: z.ZodNumber;
+        branching: z.ZodNumber;
+        moduleBoundaries: z.ZodNullable<z.ZodNumber>;
+        feedbackLoops: z.ZodNumber;
+        sharedFuncs: z.ZodNumber;
+        bottlenecks: z.ZodNumber;
+        syncDepth: z.ZodNull;
+        errorPathDepth: z.ZodNull;
+        memberCount: z.ZodNumber;
+        fanIn: z.ZodNumber;
+        loops: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            members: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        shared: z.ZodArray<z.ZodString>;
+        boundaries: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            edges: z.ZodNumber;
+            contracts: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+        imports: z.ZodArray<z.ZodObject<{
+            flow: z.ZodString;
+            func: z.ZodString;
+        }, z.core.$strict>>;
+        handovers: z.ZodArray<z.ZodObject<{
+            flow: z.ZodString;
+            func: z.ZodString;
+        }, z.core.$strict>>;
+        chainId: z.ZodString;
+        chainName: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        measurable: z.ZodLiteral<false>;
+        reasons: z.ZodArray<z.ZodEnum<{
+            "FC-05": "FC-05";
+            "loose-member": "loose-member";
+            "no-entry": "no-entry";
+            "no-exit": "no-exit";
+            empty: "empty";
+        }>>;
+        chainId: z.ZodString;
+        chainName: z.ZodString;
+    }, z.core.$strict>], "measurable">>;
+    measurability: z.ZodObject<{
+        chains: z.ZodNumber;
+        measurable: z.ZodNumber;
+        ratio: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ChainMetrics = z.infer<typeof ChainMetrics>;
+/** Die Kennzahlen aller FCHAINs dieses Graphen und die Quote der bewertbaren. */
+export declare function chainMetrics(graph: OntologyGraph): ChainMetrics;

package/dist/se/chain-metrics.js

@@ -0,0 +1,311 @@
+/**
+ * CR-SM-404 — Kennzahlen der Wirkkette: je FCHAIN eine Zahl, oder der Grund, warum es keine gibt.
+ *
+ * Die Leitlinie verlangt, die Realisierungsarchitektur AUF DER WIRKKETTE zu bewerten (graphcode
+ * `docs/graphcode_architektur_konzept.md`, „Kennzahlen der Wirkkette"). Bis hierher rechnete das
+ * nur ein Spike in graphcode (`scripts/spike-kettenkennzahlen.mjs`); von dort ist die Rechnung
+ * portiert, nicht neu erfunden. Gemessen 2026-10-09 ueber 10 Familie-Graphen: 76 Ketten, 31
+ * bewertbar.
+ *
+ * ## Diese Datei URTEILT NICHT
+ *
+ * Keine Regel, keine Schwelle, kein Katalogeintrag — dieselbe Trennung wie `moduleMetrics` und
+ * `functionCriticality`. Ob eine Laenge von 6 gut ist, sagt erst ein Profil.
+ *
+ * ## Nicht bewertbar heisst: KEINE Zahl
+ *
+ * Eine FCHAIN ist grammatisch eine Menge; die Reihenfolge entsteht erst aus Erzeuger ->
+ * Verbraucher (`FUNC -io-> FLOW -io-> FUNC`, beide Enden Glied). Zerfaellt die Kette, beschriebe
+ * jede Kennzahl etwas, das es nicht gibt. Eine solche Kette traegt deshalb ihre Gruende und kein
+ * einziges Zahlenfeld — das Schema laesst es nicht zu. Sie zaehlt im NENNER der Quote
+ * (`measurability`), die neben jedem Wert stehen muss wie die Bindungsquote neben RC-*.
+ *
+ * ## Wer urteilt, ob eine Kette eine Kette ist
+ *
+ * - `FC-05`: die Regel FC-05, aufgerufen, nicht nachgebaut. Ursache (fehlendes Glied, Sack) und
+ *   die Nebenkomponenten stehen in ihrem Befund (`context.side_components`), nicht hier.
+ * - `loose-member`: ein Glied ohne io-Eingang oder -Ausgang. Das ist die Bedingung, unter der
+ *   FC-05 sich ENTHAELT (R-31 meldet das Glied) — ohne diesen Grund haette eine solche Kette weder
+ *   einen FC-05-Befund noch einen Grund und bekaeme Zahlen.
+ * - `no-entry` / `no-exit`: kein FLOW von bzw. zu einem Knoten AUSSERHALB der Kette. Weiter als
+ *   FC-04, das nur einen ACTOR gelten laesst: eine Kette, die eine andere fortsetzt, ist messbar.
+ * - `empty`: keine FUNC (R-15).
+ *
+ * ## Ein Kettenbegriff, ein Modulbegriff
+ *
+ * Glied = direkte `FCHAIN -compose-> FUNC`-Kante, ueber `chainsByFunc` (R-30s Definition).
+ * Modul einer FUNC = direkte `allocate`-Kante, wie `module-crossings.ts` und `moduleMetrics`.
+ * Der Spike erbte das Modul ueber compose-Vorfahren; gemessen sind 326 von 326 Kettengliedern
+ * des Korpus direkt alloziert — die Vererbung kauft nichts und waere eine zweite Vorstellung von
+ * Zugehoerigkeit im selben Paket.
+ *
+ * ## CR-SM-406 — die ORTE je Kette, nur erkannt
+ *
+ * Neben jeder Zahl steht, WO sie herkommt: die Mitglieder je Rueckkopplung, die geteilten
+ * Funktionen, die Grenzen je gerichtetem Modulpaar mit ihren Vertraegen, dazu Zulauf, Importe und
+ * Uebergaben. Reine Zusatzfelder — die Zahlen aus CR-SM-404 bleiben und sind die Laenge ihrer
+ * Liste. Weiter kein Urteil.
+ *
+ * - Import und Uebergabe zaehlen nur an Gliedern, die ALLEIN dieser Kette gehoeren. Was an einer
+ *   geteilten Funktion haengt, steht an der geteilten Funktion — sie ist ein eigener Ort. Ohne
+ *   diese Grenze meldete jede Kette durch Gate und Store deren Zufluesse als ihre eigenen
+ *   (gemessen am graphcode-Modell 2026-10-10: 333 statt 16).
+ * - Ein ACTOR als Erzeuger oder Verbraucher ist der Ein- und Ausgang der Kette, kein Ort.
+ * - Vertrag = `contractsOfFlow` aus `module-crossings.ts` (SCHEMA, sonst `UNBOUND:<flow>`), hier je
+ *   Kettenkante gelesen. `moduleCrossings().pairs` selbst traegt die Vertraege des GANZEN Graphen
+ *   je ungerichtetem Paar und kann „elf Kanten auf einem Vertrag" in EINER Kette nicht zeigen.
+ *
+ * @author andreas@siglochconsulting
+ */
+import { z } from 'zod/v4';
+import { indexOf } from './graph-index.js';
+import { chainsByFunc } from './function-criticality.js';
+import { fc05ChainConnected } from './fchain-quality-rules.js';
+import { contractsOfFlow } from './module-crossings.js';
+const count = z.number().int().nonnegative();
+const identity = { chainId: z.string(), chainName: z.string() };
+/** CR-SM-406: ein Fluss an der Kettengrenze und das Glied der Kette, an dem er haengt. */
+const FlowAtFunc = z.strictObject({ flow: z.string(), func: z.string() });
+/**
+ * Eine bewertbare Kette: die fuenf heute rechenbaren Kennzahlen plus die Engstellen-Schranke,
+ * dazu die Orte (CR-SM-406). Jede Liste ist uid-sortiert.
+ */
+const MeasuredChain = z.strictObject({
+    ...identity,
+    measurable: z.literal(true),
+    /** Gesamtlaenge: FUNC-Schritte auf dem laengsten Pfad; eine Schleife zaehlt als EIN Schritt. */
+    length: count,
+    /** Verzweigungsgrad: groesster Ausgangsgrad eines Glieds INNERHALB der Kette. */
+    branching: count,
+    /**
+     * Modulgrenzen: Kettenkanten, deren Enden in verschiedenen MOD liegen.
+     * `null`, sobald ein Glied kein Modul hat (R-22 meldet es) — keine geratene Zahl.
+     */
+    moduleBoundaries: count.nullable(),
+    /** Rueckkopplungen: nicht-triviale starke Komponenten ueber die Kettenkanten. */
+    feedbackLoops: count,
+    /** Geteilte Knoten: Glieder, die in mehr als einer Kette liegen. */
+    sharedFuncs: count,
+    /**
+     * Engstellen — OBERE SCHRANKE: geteilte Glieder mit Ein- UND Ausgang in der Kette. Der
+     * Konzeptbegriff verlangt „synchron durchlaufen"; ohne `FLOW.sync` zaehlt jeder Durchgang.
+     */
+    bottlenecks: count,
+    /** Synchrone Tiefe — in dieser Stufe nie berechnet: braucht den Leser von `FLOW.sync` (CR-SM-364). */
+    syncDepth: z.null(),
+    /** Fehlerpfad-Tiefe — nicht berechenbar: Fehlerfluesse traegt kein Attribut (CR-SM-364, `kind` verworfen). */
+    errorPathDepth: z.null(),
+    /** Zahl der Glieder. */
+    memberCount: count,
+    /** Zulauf: groesster Eingangsgrad eines Glieds INNERHALB der Kette — das Gegenstueck zu `branching`. */
+    fanIn: count,
+    /**
+     * Die Rueckkopplungen, die `feedbackLoops` zaehlt. `id` entsteht allein aus den Mitgliedern
+     * (uids mit `+` verbunden) — dieselbe Schleife traegt in jeder Kette dieselbe Kennung.
+     */
+    loops: z.array(z.strictObject({ id: z.string(), members: z.array(z.string()).min(2) })),
+    /** Die geteilten Glieder, die `sharedFuncs` zaehlt. */
+    shared: z.array(z.string()),
+    /**
+     * Die Modulgrenzen je GERICHTETEM Modulpaar: `edges` Kettenkanten von `from` nach `to` (ihre
+     * Summe ist `moduleBoundaries`) auf den verschiedenen Vertraegen `contracts`. `null` wie dort.
+     */
+    boundaries: z.array(z.strictObject({
+        from: z.string(), to: z.string(), edges: count.min(1), contracts: z.array(z.string()).min(1),
+    })).nullable(),
+    /**
+     * Importe: ein Glied, das NUR in dieser Kette liegt, verbraucht einen Fluss, den mindestens
+     * eine FUNC erzeugt und kein Glied der Kette.
+     */
+    imports: z.array(FlowAtFunc),
+    /**
+     * Uebergaben, gespiegelt: ein Glied, das nur in dieser Kette liegt, erzeugt einen Fluss, den
+     * mindestens eine FUNC verbraucht und kein Glied der Kette.
+     */
+    handovers: z.array(FlowAtFunc),
+});
+/** Eine nicht bewertbare Kette: der Grund statt der Zahl. Reihenfolge der Gruende ist fest. */
+const UnmeasurableChain = z.strictObject({
+    ...identity,
+    measurable: z.literal(false),
+    reasons: z.array(z.enum(['FC-05', 'loose-member', 'no-entry', 'no-exit', 'empty'])).min(1),
+});
+// CR-SM-361: ein Zod-Vertrag, kein Typ — der Erzeuger prueft sein Ergebnis.
+export const ChainMetrics = z.object({
+    /** Eine Zeile je FCHAIN, in GRAPH-Reihenfolge — keine Rangfolge, die Zahl ist kein Urteil. */
+    chains: z.array(z.discriminatedUnion('measurable', [MeasuredChain, UnmeasurableChain])),
+    /** Die Reichweite der Aussage. `ratio` ist `null` ohne Ketten — kein Ersatzwert. */
+    measurability: z.object({ chains: count, measurable: count, ratio: z.number().min(0).max(1).nullable() }),
+});
+/** Die Kennzahlen aller FCHAINs dieses Graphen und die Quote der bewertbaren. */
+export function chainMetrics(graph) {
+    const idx = indexOf(graph);
+    const chainsOf = chainsByFunc(graph);
+    // FC-05 ist der EINE Leser fuer „gerichtet zusammenhaengend" — hier zaehlt nur, ob er meldet.
+    const fc05 = new Set(fc05ChainConnected(graph).map((v) => v.element_id));
+    const flowsInto = (id) => idx.in(id, 'io').map((t) => t.source).filter((s) => idx.typeOf(s) === 'FLOW');
+    const flowsOutOf = (id) => idx.out(id, 'io').map((t) => t.target).filter((s) => idx.typeOf(s) === 'FLOW');
+    const moduleOf = (func) => idx.out(func, 'allocate').map((t) => t.target).find((m) => idx.typeOf(m) === 'MOD');
+    const chains = idx.elementsOfType('FCHAIN').map((fc) => {
+        const who = { chainId: fc.id, chainName: fc.name };
+        const members = [...new Set(idx.out(fc.id, 'compose').map((t) => t.target).filter((id) => idx.typeOf(id) === 'FUNC'))].sort();
+        if (members.length === 0)
+            return { ...who, measurable: false, reasons: ['empty'] };
+        const inChain = new Set(members);
+        // Kettenkanten Erzeuger -> Verbraucher; dazu, wo die Kette von aussen gespeist wird und wo sie hinausliefert.
+        const next = new Map(members.map((m) => [m, new Set()]));
+        const carriers = new Map(); // Kettenkante `a b` -> die FLOWs, die sie tragen
+        let entry = false;
+        let exit = false;
+        let loose = false;
+        for (const m of members) {
+            const ins = flowsInto(m);
+            const outs = flowsOutOf(m);
+            if (ins.length === 0 || outs.length === 0)
+                loose = true;
+            for (const flow of ins)
+                if (idx.in(flow, 'io').some((t) => !inChain.has(t.source)))
+                    entry = true;
+            for (const flow of outs) {
+                for (const t of idx.out(flow, 'io')) {
+                    if (t.target === m)
+                        continue;
+                    if (!inChain.has(t.target)) {
+                        exit = true;
+                        continue;
+                    }
+                    next.get(m).add(t.target);
+                    const edge = `${m} ${t.target}`;
+                    (carriers.get(edge) ?? carriers.set(edge, new Set()).get(edge)).add(flow);
+                }
+            }
+        }
+        const reasons = [];
+        if (fc05.has(fc.id))
+            reasons.push('FC-05');
+        if (loose)
+            reasons.push('loose-member');
+        if (!entry)
+            reasons.push('no-entry');
+        if (!exit)
+            reasons.push('no-exit');
+        if (reasons.length > 0)
+            return { ...who, measurable: false, reasons };
+        // Rueckkopplungen: Tarjan — jede starke Komponente mit mehr als einem Glied ist eine Schleife.
+        const order = new Map();
+        const low = new Map();
+        const onStack = new Set();
+        const stack = [];
+        const sccOf = new Map();
+        const loops = [];
+        const visit = (v) => {
+            order.set(v, order.size);
+            low.set(v, order.get(v));
+            stack.push(v);
+            onStack.add(v);
+            for (const w of next.get(v)) {
+                if (!order.has(w)) {
+                    visit(w);
+                    low.set(v, Math.min(low.get(v), low.get(w)));
+                }
+                else if (onStack.has(w))
+                    low.set(v, Math.min(low.get(v), order.get(w)));
+            }
+            if (low.get(v) !== order.get(v))
+                return;
+            const comp = [];
+            let w;
+            do {
+                w = stack.pop();
+                onStack.delete(w);
+                comp.push(w);
+            } while (w !== v);
+            if (comp.length > 1)
+                loops.push({ id: comp.sort().join('+'), members: comp });
+            for (const c of comp)
+                sccOf.set(c, v);
+        };
+        for (const m of members)
+            if (!order.has(m))
+                visit(m);
+        loops.sort((a, b) => (a.id < b.id ? -1 : 1));
+        // Gesamtlaenge: laengster Pfad auf dem Kondensat — eine Schleife ist dort ein Knoten.
+        const condensed = new Map();
+        for (const [a, targets] of next) {
+            for (const b of targets) {
+                const ca = sccOf.get(a);
+                const cb = sccOf.get(b);
+                if (ca !== cb)
+                    (condensed.get(ca) ?? condensed.set(ca, new Set()).get(ca)).add(cb);
+            }
+        }
+        const longestFrom = new Map();
+        const longest = (c) => {
+            const known = longestFrom.get(c);
+            if (known !== undefined)
+                return known;
+            let best = 1;
+            for (const n of condensed.get(c) ?? [])
+                best = Math.max(best, 1 + longest(n));
+            longestFrom.set(c, best);
+            return best;
+        };
+        const length = Math.max(...members.map((m) => longest(sccOf.get(m))));
+        const allocated = members.every((m) => moduleOf(m) !== undefined);
+        let branching = 0;
+        const inDegree = new Map();
+        const pairs = new Map();
+        for (const [a, targets] of next) {
+            branching = Math.max(branching, targets.size);
+            for (const b of targets) {
+                inDegree.set(b, (inDegree.get(b) ?? 0) + 1);
+                const from = moduleOf(a);
+                const to = moduleOf(b);
+                if (from === undefined || to === undefined || from === to)
+                    continue;
+                const key = `${from} ${to}`;
+                const pair = pairs.get(key) ?? pairs.set(key, { from, to, edges: 0, contracts: new Set() }).get(key);
+                pair.edges++;
+                for (const flow of carriers.get(`${a} ${b}`))
+                    for (const c of contractsOfFlow(idx, flow))
+                        pair.contracts.add(c);
+            }
+        }
+        const boundaries = [...pairs.entries()].sort(([a], [b]) => (a < b ? -1 : 1))
+            .map(([, p]) => ({ ...p, contracts: [...p.contracts].sort() }));
+        const shared = members.filter((m) => (chainsOf.get(m)?.size ?? 0) > 1);
+        // Importe und Uebergaben: nur an Gliedern, die allein dieser Kette gehoeren; die andere Seite
+        // des Flusses ist mindestens eine FUNC und kein Glied (ein ACTOR ist Ein-/Ausgang, kein Ort).
+        const own = members.filter((m) => !shared.includes(m));
+        const foreign = (ends) => {
+            const funcs = ends.filter((id) => idx.typeOf(id) === 'FUNC');
+            return funcs.length > 0 && !funcs.some((f) => inChain.has(f));
+        };
+        const at = (flows, farEnds) => own.flatMap((func) => [...new Set(flows(func))].sort()
+            .filter((flow) => foreign(farEnds(flow))).map((flow) => ({ flow, func })));
+        return {
+            ...who,
+            measurable: true,
+            length,
+            branching,
+            moduleBoundaries: allocated ? boundaries.reduce((n, p) => n + p.edges, 0) : null,
+            feedbackLoops: loops.length,
+            sharedFuncs: shared.length,
+            bottlenecks: shared.filter((m) => inDegree.has(m) && next.get(m).size > 0).length,
+            syncDepth: null,
+            errorPathDepth: null,
+            memberCount: members.length,
+            fanIn: Math.max(0, ...inDegree.values()),
+            loops,
+            shared,
+            boundaries: allocated ? boundaries : null,
+            imports: at(flowsInto, (flow) => idx.in(flow, 'io').map((t) => t.source)),
+            handovers: at(flowsOutOf, (flow) => idx.out(flow, 'io').map((t) => t.target)),
+        };
+    });
+    const measurable = chains.filter((c) => c.measurable).length;
+    return ChainMetrics.parse({
+        chains,
+        measurability: { chains: chains.length, measurable, ratio: chains.length > 0 ? measurable / chains.length : null },
+    });
+}

package/dist/se/evaluate-all.d.ts

@@ -10,9 +10,8 @@ import { type MarkType, type RuleRole, type RuleStage } from './readiness.js';
  * All prescribed rule definitions (single source of truth for the catalog).
  *
  * CR-SM-235: `domain` reicht mit durch — die Grundgesamtheit, ueber die eine Regel feuert.
- * Konsumenten, die einen Anteil bilden (`se-steering`s `computeApplicable`), lesen den Nenner
- * hier statt eine eigene Tabelle zu fuehren. Eine zweite Tabelle kann nicht hinterherhinken,
- * wenn es keine zweite gibt.
+ * Die Faelligkeit (`isDue`) liest sie hier statt eine eigene Tabelle zu fuehren. Eine zweite
+ * Tabelle kann nicht hinterherhinken, wenn es keine zweite gibt.
  */
 /** Profile groupings — see CATALOGS. */
 export type ProfileId = 'default' | 'se' | 'coding' | 'conformance';

package/dist/se/evaluate-all.js

@@ -10,7 +10,7 @@ import { CR_RULES } from './cr-quality-rules.js';
 import { ND_RULES } from './near-duplicate-rules.js';
 import { AO_RULES } from './ao-rules.js';
 import { BQ_RULES } from './quality-rules.js';
-import { AF_RULES, TASK_OUTCOME_RULES } from './analysis-freshness-rules.js';
+import { AF_RULES } from './analysis-freshness-rules.js';
 import { CODE_CONFORMANCE_RULES } from './conformance-rules.js';
 import { markOfStage } from './readiness.js';
 /**
@@ -37,7 +37,6 @@ const CATALOGS = [
     { profile: 'se', rules: FM_RULES },
     { profile: 'se', rules: VIEW_RULES },
     { profile: 'se', rules: AF_RULES },
-    { profile: 'se', rules: TASK_OUTCOME_RULES }, // CR-SM-355: Task-Ausgaenge trade / irr
     // Sprach-/Textqualitaet statt SE-Struktur — das ist die Trennlinie, die die Praefixliste meinte.
     { profile: 'coding', rules: BQ_RULES },
     { profile: 'coding', rules: ND_RULES },
@@ -76,7 +75,6 @@ export function getRuleDefsForProfile(profile) {
 const EVALUATED_CATALOGS = [
     V3_RULES, BQ_RULES, UC_RULES, FC_RULES, SC_RULES, ND_RULES, MT_RULES, CR_RULES, AO_RULES,
     FM_RULES, VIEW_RULES, AF_RULES,
-    TASK_OUTCOME_RULES, // CR-SM-355
 ];
 /**
  * Evaluate all rules against a graph. Single call replaces the individual evaluator calls.