@sigloch/contracts 10.12.0 → 10.14.0

package/dist/se/ontology.d.ts

@@ -40,24 +40,27 @@ export declare const TraceType: z.ZodEnum<{
 }>;
 export type TraceType = z.infer<typeof TraceType>;
 /**
- * REQ kind — 6 values aligned with SysML 2.0 + FMEA (CR-180).
+ * REQ kind — GENAU EIN Wert je REQ, aus zwei (CR-SM-366).
  *
- * CR-SM-266 B: `negative` ENTFAELLT. Ein Verbots-REQ ("das System tut X nie") ist auch eine
- * Anforderung — die Implementierung muss Regeln abfragen oder Sicherungen einbauen, und das
- * ist `functional`. Der Wert hatte NULL Leser (kein Regel-, Gate- oder View-Konsument; anders
- * als risk/mitigation → FM-01..03, pre/postcondition → UC-05/06, non-functional → NFR-01) und
- * haette durch die where-Praedikate am satisfy-Pattern per AUSLASSUNG erstmals Wirkung
- * bekommen: er stand in keiner der vier Listen und waere damit nur noch per FCHAIN erfuellbar
- * gewesen. Die sechs verbleibenden Werte partitionieren die where-Listen VOLLSTAENDIG — kein
- * Wert ohne Zuordnung, keine Kante, die durch ein Loch in der Aufzaehlung faellt.
+ * `functional` -> erfuellt von FUNC. `non-functional` -> erfuellt von MOD (lokales Budget), SYS
+ * (Systemebene) oder FCHAIN (Ende-zu-Ende entlang der Kette). Ohne kinds kein Erfueller (BQ-07,
+ * `satisfiesPredicate`). Ein REQ, das beides ist, ist falsch zerlegt -> teilen; die
+ * Teilmengen-Semantik der where-Praedikate laesst es von niemandem erfuellen.
+ *
+ * Entfallen (Major, CR-SM-366):
+ * - `precondition` / `postcondition`: die Vorbedingung steckt im Eingangs-FLOW der Kette, die
+ *   Nachbedingung ist das UC-Ziel — beides prueft R-21 (Integrationstest je Kette). Ihre Leser
+ *   UC-05/06 sind seit CR-SM-357 gestrichen.
+ * - `risk` / `mitigation`: die FMEA-ROLLE einer Anforderung, keine Art — `REQ.attributes.role`
+ *   (CR-SM-365), satisfy-neutral.
+ * Ein Altwert wird nicht still verworfen: `normalizeReqKinds` laesst ihn stehen, das Schema
+ * lehnt ihn ab, und R-18 meldet jede satisfy-Kante darauf als `kinds-mismatch` mit `declared`.
+ *
+ * Vorher CR-SM-266 B: `negative` entfiel (ein Verbots-REQ ist `functional`).
  */
 export declare const ReqKind: z.ZodEnum<{
     functional: "functional";
     "non-functional": "non-functional";
-    risk: "risk";
-    mitigation: "mitigation";
-    precondition: "precondition";
-    postcondition: "postcondition";
 }>;
 export type ReqKind = z.infer<typeof ReqKind>;
 /**
@@ -222,6 +225,32 @@ type Attributes = Record<string, unknown> | undefined;
 export declare function readTestRefs(attributes: Attributes): BindingRead<TestRefs>;
 /** Der EINE Leser von `attributes.realRef` (CR-SM-360). */
 export declare function readRealRef(attributes: Attributes): BindingRead<RealRef>;
+/**
+ * CR-SM-364: die Kopplung eines Uebergangs — `FLOW.attributes.sync`. Fehlend heisst UNBEKANNT,
+ * nie stillschweigend `sync`: eine Kettenkennzahl (synchrone Tiefe, Engstellen-Grad) weist eine
+ * unmarkierte Kette als „nicht bewertbar" aus, statt sie ueber eine Annahme zu beurteilen.
+ */
+export declare const FlowSync: z.ZodEnum<{
+    sync: "sync";
+    async: "async";
+}>;
+export type FlowSync = z.infer<typeof FlowSync>;
+/** Der EINE Leser von `FLOW.attributes.sync` (CR-SM-364) — ungueltig ist nicht fehlend. */
+export declare function readFlowSync(attributes: Attributes): BindingRead<FlowSync>;
+/**
+ * CR-SM-365: die ROLLE einer Anforderung im FMEA-Sinn — `REQ.attributes.role`. `risk` und
+ * `mitigation` waren bis hierher `kinds`-Werte und damit satisfy-relevant (MOD/SYS erfuellten
+ * sie). Sie sind aber keine ART der Anforderung, sondern ihre Motivation: eine Gegenmassnahme ist
+ * funktional oder nicht-funktional wie jede andere REQ. Die Rolle ist satisfy-neutral — die
+ * Grammatik (`isValidTrace`) liest sie nicht; FM-01..03 lesen NUR sie.
+ */
+export declare const ReqRole: z.ZodEnum<{
+    risk: "risk";
+    mitigation: "mitigation";
+}>;
+export type ReqRole = z.infer<typeof ReqRole>;
+/** Der EINE Leser von `REQ.attributes.role` (CR-SM-365) — ungueltig ist nicht fehlend. */
+export declare function readReqRole(attributes: Attributes): BindingRead<ReqRole>;
 /**
  * The five judgment-work artifact ids (CR-GC-221's creation keys) that graphcode's
  * skills produce and that a phase gate checks for presence+freshness (CR-SM-227).
@@ -314,10 +343,6 @@ export declare const OntologyElement: z.ZodObject<{
     kinds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         functional: "functional";
         "non-functional": "non-functional";
-        risk: "risk";
-        mitigation: "mitigation";
-        precondition: "precondition";
-        postcondition: "postcondition";
     }>>>;
     attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     status: z.ZodDefault<z.ZodEnum<{
@@ -380,10 +405,6 @@ export declare const OntologyGraph: z.ZodObject<{
         kinds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
             functional: "functional";
             "non-functional": "non-functional";
-            risk: "risk";
-            mitigation: "mitigation";
-            precondition: "precondition";
-            postcondition: "postcondition";
         }>>>;
         attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         status: z.ZodDefault<z.ZodEnum<{

package/dist/se/ontology.js

@@ -25,21 +25,25 @@ export const TraceType = z.enum([
     'compose', 'io', 'satisfy', 'verify', 'allocate', 'relation',
 ]);
 /**
- * REQ kind — 6 values aligned with SysML 2.0 + FMEA (CR-180).
+ * REQ kind — GENAU EIN Wert je REQ, aus zwei (CR-SM-366).
  *
- * CR-SM-266 B: `negative` ENTFAELLT. Ein Verbots-REQ ("das System tut X nie") ist auch eine
- * Anforderung — die Implementierung muss Regeln abfragen oder Sicherungen einbauen, und das
- * ist `functional`. Der Wert hatte NULL Leser (kein Regel-, Gate- oder View-Konsument; anders
- * als risk/mitigation → FM-01..03, pre/postcondition → UC-05/06, non-functional → NFR-01) und
- * haette durch die where-Praedikate am satisfy-Pattern per AUSLASSUNG erstmals Wirkung
- * bekommen: er stand in keiner der vier Listen und waere damit nur noch per FCHAIN erfuellbar
- * gewesen. Die sechs verbleibenden Werte partitionieren die where-Listen VOLLSTAENDIG — kein
- * Wert ohne Zuordnung, keine Kante, die durch ein Loch in der Aufzaehlung faellt.
+ * `functional` -> erfuellt von FUNC. `non-functional` -> erfuellt von MOD (lokales Budget), SYS
+ * (Systemebene) oder FCHAIN (Ende-zu-Ende entlang der Kette). Ohne kinds kein Erfueller (BQ-07,
+ * `satisfiesPredicate`). Ein REQ, das beides ist, ist falsch zerlegt -> teilen; die
+ * Teilmengen-Semantik der where-Praedikate laesst es von niemandem erfuellen.
+ *
+ * Entfallen (Major, CR-SM-366):
+ * - `precondition` / `postcondition`: die Vorbedingung steckt im Eingangs-FLOW der Kette, die
+ *   Nachbedingung ist das UC-Ziel — beides prueft R-21 (Integrationstest je Kette). Ihre Leser
+ *   UC-05/06 sind seit CR-SM-357 gestrichen.
+ * - `risk` / `mitigation`: die FMEA-ROLLE einer Anforderung, keine Art — `REQ.attributes.role`
+ *   (CR-SM-365), satisfy-neutral.
+ * Ein Altwert wird nicht still verworfen: `normalizeReqKinds` laesst ihn stehen, das Schema
+ * lehnt ihn ab, und R-18 meldet jede satisfy-Kante darauf als `kinds-mismatch` mit `declared`.
+ *
+ * Vorher CR-SM-266 B: `negative` entfiel (ein Verbots-REQ ist `functional`).
  */
-export const ReqKind = z.enum([
-    'functional', 'non-functional', 'risk',
-    'mitigation', 'precondition', 'postcondition',
-]);
+export const ReqKind = z.enum(['functional', 'non-functional']);
 /**
  * `kinds` in der Form, die WIRKLICH auf Platte liegt — als Liste.
  *
@@ -183,6 +187,36 @@ export function readRealRef(attributes) {
     const r = RealRefSchema.safeParse(raw);
     return r.success ? { state: 'bound', value: r.data } : { state: 'invalid', error: r.error.message };
 }
+/**
+ * CR-SM-364: die Kopplung eines Uebergangs — `FLOW.attributes.sync`. Fehlend heisst UNBEKANNT,
+ * nie stillschweigend `sync`: eine Kettenkennzahl (synchrone Tiefe, Engstellen-Grad) weist eine
+ * unmarkierte Kette als „nicht bewertbar" aus, statt sie ueber eine Annahme zu beurteilen.
+ */
+export const FlowSync = z.enum(['sync', 'async']);
+/** Der EINE Leser von `FLOW.attributes.sync` (CR-SM-364) — ungueltig ist nicht fehlend. */
+export function readFlowSync(attributes) {
+    const raw = attributes?.sync;
+    if (raw === undefined || raw === null)
+        return { state: 'absent' };
+    const r = FlowSync.safeParse(raw);
+    return r.success ? { state: 'bound', value: r.data } : { state: 'invalid', error: r.error.message };
+}
+/**
+ * CR-SM-365: die ROLLE einer Anforderung im FMEA-Sinn — `REQ.attributes.role`. `risk` und
+ * `mitigation` waren bis hierher `kinds`-Werte und damit satisfy-relevant (MOD/SYS erfuellten
+ * sie). Sie sind aber keine ART der Anforderung, sondern ihre Motivation: eine Gegenmassnahme ist
+ * funktional oder nicht-funktional wie jede andere REQ. Die Rolle ist satisfy-neutral — die
+ * Grammatik (`isValidTrace`) liest sie nicht; FM-01..03 lesen NUR sie.
+ */
+export const ReqRole = z.enum(['risk', 'mitigation']);
+/** Der EINE Leser von `REQ.attributes.role` (CR-SM-365) — ungueltig ist nicht fehlend. */
+export function readReqRole(attributes) {
+    const raw = attributes?.role;
+    if (raw === undefined || raw === null)
+        return { state: 'absent' };
+    const r = ReqRole.safeParse(raw);
+    return r.success ? { state: 'bound', value: r.data } : { state: 'invalid', error: r.error.message };
+}
 /**
  * The five judgment-work artifact ids (CR-GC-221's creation keys) that graphcode's
  * skills produce and that a phase gate checks for presence+freshness (CR-SM-227).
@@ -263,7 +297,7 @@ export const OntologyElement = z.object({
     description: z.string(),
     /** INCOSE TIAD verification method — only for TEST elements (CR-057). */
     method: VerificationMethod.optional(),
-    /** REQ kinds: multi-valued classification (CR-180). Only for REQ elements. */
+    /** REQ kinds: exactly ONE of functional|non-functional (CR-SM-366); a list for the on-disk form. Only for REQ elements. */
     kinds: z.array(ReqKind).optional(),
     attributes: z.record(z.string(), z.unknown()).optional(),
     status: z.enum(['draft', 'reviewed', 'open', 'done']).default('draft'),
@@ -335,6 +369,7 @@ export const ELEMENT_ATTRIBUTES = {
         { key: 'concept', type: 'boolean', description: 'Concept-only TEST: no run artifact yet; exempt from the R-19 testRefs-binding requirement (CR-GC-205)' },
     ],
     REQ: [
+        { key: 'role', type: 'enum', enumValues: ReqRole.options, description: "FMEA role: 'risk' | 'mitigation' — satisfy-neutral, read by FM-01..03 via readReqRole. A mitigation is functional or non-functional like any REQ; the role is its motivation, not its kind (CR-SM-365)" },
         { key: 'severity', type: 'number', description: 'FMEA severity (1-10)' },
         { key: 'occurrence', type: 'number', description: 'FMEA occurrence (1-10)' },
         { key: 'detection', type: 'number', description: 'FMEA detection (1-10)' },
@@ -355,10 +390,12 @@ export const ELEMENT_ATTRIBUTES = {
         { key: 'status', type: 'enum', enumValues: ['open', 'done'], description: 'CR completion status' },
         { key: 'rationale', type: 'string', description: 'Reason for the change' },
         { key: 'spike', type: 'boolean', description: 'CR is a spike/exploration' },
+        { key: 'architectureOnly', type: 'boolean', description: 'Done CR without code change (model/architecture only): exempt from the CR-R02 commitRef requirement (CR-SM-386)' },
     ],
+    // CR-SM-364: genau ein Realisierungsattribut. `protocol`/`qos` entfielen — freie Strings, in
+    // 0 von 186 Familien-FLOWs gesetzt, ohne Leser. Abweichende Kopplung je Verbraucher ⇒ FLOW teilen.
     FLOW: [
-        { key: 'protocol', type: 'string', description: 'ICD protocol (e.g. REST, gRPC)' },
-        { key: 'qos', type: 'string', description: 'Quality of Service level' },
+        { key: 'sync', type: 'enum', enumValues: FlowSync.options, description: "Coupling of the transition: 'sync' | 'async'. Missing = unknown, never an implicit 'sync' — read with readFlowSync (CR-SM-364)" },
     ],
     MOD: [
         { key: 'path', type: 'string', description: 'Source file or glob the module owns, e.g. src/harness.ts — anchors the MOD<->file mapping for graph<->code conformance (CR-GC-205)' },

package/dist/se/placeholder.d.ts

@@ -0,0 +1 @@
+export declare function hasPlaceholder(text: string): boolean;

package/dist/se/placeholder.js

@@ -0,0 +1,13 @@
+/**
+ * placeholder.ts — the one definition of "this text still carries a placeholder" (CR-SM-383).
+ *
+ * UC-04 and BQ-07 each had their own pattern, both case-insensitive: `todo` matched the domain
+ * word "Todo" ("Benutzer fuegt einen neuen Todo-Eintrag hinzu"), and the finding could not be
+ * resolved by any rewording that kept the subject. Markers are written in capitals by
+ * convention; only the spelled-out phrases are matched regardless of case.
+ */
+const MARKER_RE = /\b(TBD|TBR|TODO|FIXME|XXX)\b/;
+const PHRASE_RE = /\b(placeholder|to be determined)\b|needs\s.*review/i;
+export function hasPlaceholder(text) {
+    return MARKER_RE.test(text) || PHRASE_RE.test(text);
+}

package/dist/se/quality-rules.js

@@ -1,4 +1,5 @@
 import { normalizeReqKinds } from './ontology.js';
+import { hasPlaceholder } from './placeholder.js';
 // ---------------------------------------------------------------------------
 // Weasel words list (BQ-01)
 // ---------------------------------------------------------------------------
@@ -205,7 +206,6 @@ export function bq06Conforming(graph) {
 // ---------------------------------------------------------------------------
 // BQ-07 Complete — REQ must have meaningful description and no placeholders
 // ---------------------------------------------------------------------------
-const placeholderPattern = /\b(TBD|TBR|TODO|placeholder|to be determined)\b|needs\s.*review/i;
 const BQ07_MIN_DESC_LENGTH = 20;
 export function bq07Complete(graph) {
     // CR-SM-266 REQ-X06: `kinds` ist Pflicht am REQ — hier als DRITTER Grund derselben Regel,
@@ -220,7 +220,7 @@ export function bq07Complete(graph) {
     // Angabe ist ein Vollstaendigkeitssignal und deshalb hier/warning — dieselbe Trennung, die
     // CR-SM-262 fuer RC-06 begruendet hat.
     const isIncomplete = (req) => descriptionOf(req).trim().length < BQ07_MIN_DESC_LENGTH ||
-        placeholderPattern.test(descriptionOf(req)) ||
+        hasPlaceholder(descriptionOf(req)) ||
         normalizeReqKinds(req.kinds).length === 0;
     return reqElements(graph)
         .filter(isIncomplete)
@@ -230,7 +230,7 @@ export function bq07Complete(graph) {
         if (desc.trim().length < BQ07_MIN_DESC_LENGTH) {
             reasons.push(`description too short (${desc.trim().length}/${BQ07_MIN_DESC_LENGTH} chars)`);
         }
-        if (placeholderPattern.test(desc)) {
+        if (hasPlaceholder(desc)) {
             reasons.push('contains placeholder');
         }
         if (normalizeReqKinds(req.kinds).length === 0) {

package/dist/se/readiness.d.ts

@@ -170,6 +170,20 @@ export type PhaseGateType = z.infer<typeof PhaseGate>;
  * single-owner convention as RULE_TO_DIMENSION.
  */
 export declare const RULE_TO_PHASE: Record<string, PhaseGateType>;
+/**
+ * CR-SM-343 — die VORBEDINGUNG einer Regel: der Elementtyp, von dem der Graph mindestens ein
+ * Element tragen muss, damit die Regel ueberhaupt ausgewertet ist.
+ *
+ * Der Nenner einer Dimension ist `Σ Grundgesamtheit` ueber ihre Regeln (`domain`). Eine Regel,
+ * die mangels Gegenstand schweigt, truege dort ihre ganze Grundgesamtheit bei und liefert null
+ * Verstoesse — der Score STIEGE, weil nicht geprueft wurde. CR-R05 fragt nach einem Bauauftrag;
+ * ein Graph ohne einen einzigen CR (`cr: docs`) hat keinen Plan im Graphen, also ist die Frage
+ * dort NICHT GESTELLT, nicht bestanden. Wer einen Anteil bildet, fragt `ruleApplies` und laesst
+ * eine nicht anwendbare Regel aus Zaehler UND Nenner.
+ */
+export declare const RULE_PRECONDITION: Readonly<Record<string, string>>;
+/** Ist die Regel an einem Graphen mit diesen Typ-Zaehlungen ausgewertet? (CR-SM-343) */
+export declare function ruleApplies(ruleId: string, countByType: Readonly<Record<string, number>>): boolean;
 /**
  * Die Eigentuemer-Spalte (CR-SM-350, Entscheidung 2026-09-22): welcher TASK eine Regel bearbeitet.
  *

package/dist/se/readiness.js

@@ -152,6 +152,9 @@ export const RULE_TO_DIMENSION = {
     'BQ-01': 'req', 'BQ-02': 'req', 'BQ-04': 'req',
     'BQ-06': 'req', 'BQ-07': 'req',
     'RD-01': 'req', 'RD-02': 'req',
+    // CR-SM-343: CR-R05 (Blatt-REQ ohne Bauauftrag) — ein Mangel der Anforderungsdeckung, nicht
+    // der CR-Hygiene; zaehlt nur, wenn der Graph ueberhaupt CR-Knoten traegt (RULE_PRECONDITION).
+    'CR-R05': 'req',
     // RD-04 is decomposition *breadth* — an architecture concern, not a requirement one
     'RD-04': 'arch',
     // CR-SM-311: die Untergrenze derselben Breite — ebenfalls Architektur
@@ -171,6 +174,7 @@ export const RULE_TO_DIMENSION = {
     'R-15': 'uc', 'R-16': 'uc', 'R-17': 'uc',
     // FC-04 (CR-SM-226): FCHAIN actor-bounded (trigger+consumer) — same dimension as FC-01..03.
     'FC-02': 'uc', 'FC-03': 'uc', 'FC-04': 'uc',
+    'FC-05': 'uc', // CR-SM-363: Zusammenhang der Kette — dieselbe Dimension wie FC-04
     // arch
     'R-02': 'arch', 'R-10': 'arch', 'R-12': 'arch',
     // alloc
@@ -262,7 +266,7 @@ export const RULE_TO_PHASE = {
     'R-02': '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-03': 'PDR', 'FC-04': 'PDR',
+    'FC-03': 'PDR', 'FC-04': 'PDR', 'FC-05': 'PDR',
     // CR-GC-366: Anschluss des Funktionsbaus — gehoert an dasselbe Gate wie R-15/IO-01,
     // die auf derselben Kette aufsetzen.
     'R-30': 'PDR', 'R-31': 'PDR',
@@ -282,7 +286,27 @@ export const RULE_TO_PHASE = {
     'VR-01': 'TRR',
     'FM-03': 'TRR',
     'CR-R02': 'TRR',
+    'CR-R05': 'TRR', // CR-SM-343: dieselbe Phase wie AF-05 (Implementierungsplan)
 };
+/**
+ * CR-SM-343 — die VORBEDINGUNG einer Regel: der Elementtyp, von dem der Graph mindestens ein
+ * Element tragen muss, damit die Regel ueberhaupt ausgewertet ist.
+ *
+ * Der Nenner einer Dimension ist `Σ Grundgesamtheit` ueber ihre Regeln (`domain`). Eine Regel,
+ * die mangels Gegenstand schweigt, truege dort ihre ganze Grundgesamtheit bei und liefert null
+ * Verstoesse — der Score STIEGE, weil nicht geprueft wurde. CR-R05 fragt nach einem Bauauftrag;
+ * ein Graph ohne einen einzigen CR (`cr: docs`) hat keinen Plan im Graphen, also ist die Frage
+ * dort NICHT GESTELLT, nicht bestanden. Wer einen Anteil bildet, fragt `ruleApplies` und laesst
+ * eine nicht anwendbare Regel aus Zaehler UND Nenner.
+ */
+export const RULE_PRECONDITION = {
+    'CR-R05': 'CR',
+};
+/** Ist die Regel an einem Graphen mit diesen Typ-Zaehlungen ausgewertet? (CR-SM-343) */
+export function ruleApplies(ruleId, countByType) {
+    const required = RULE_PRECONDITION[ruleId];
+    return required === undefined || (countByType[required] ?? 0) > 0;
+}
 /**
  * Die Eigentuemer-Spalte (CR-SM-350, Entscheidung 2026-09-22): welcher TASK eine Regel bearbeitet.
  *
@@ -302,10 +326,13 @@ export const TASK_OWNED_RULES = {
     trade: ['TR-01'], // CR-SM-355: Trade-Entscheidung als CR
     irr: ['IR-01'], // CR-SM-355: Annahmen-Review promoviert zu CR
     fmea: ['FM-01', 'FM-02', 'FM-03'],
-    plan: ['MS-01', 'MS-02', 'MS-03', 'CR-R01', 'CR-R02', 'CR-R03'],
+    // CR-SM-377: CR-R05 (Blatt-REQ ohne Bauauftrag, CR-SM-343) fragt nach einem CR — die Antwort
+    // schreibt der Plan-Task (se-plan), nicht die Generierungsschleife. FC-05 bleibt Kern: die
+    // Kette zu schliessen ist Spezifikationsarbeit wie FC-04.
+    plan: ['MS-01', 'MS-02', 'MS-03', 'CR-R01', 'CR-R02', 'CR-R03', 'CR-R05'],
     // Annahme (CR-SM-350): BQ bekommt einen eigenen Task, vorerst ohne automatischen Eintrittspunkt.
     anforderungsqualitaet: ['BQ-01', 'BQ-02', 'BQ-04', 'BQ-06', 'BQ-07'],
-    realisierung: ['R-19', 'R-20', 'R-26', 'R-29', 'R-32', 'VR-01', 'RC-01', 'RC-02', 'RC-03', 'RC-04', 'RC-05', 'RC-06', 'RC-07', 'RC-08', 'RC-09'],
+    realisierung: ['R-19', 'R-20', 'R-26', 'R-29', 'R-32', 'VR-01', 'RC-01', 'RC-02', 'RC-03', 'RC-04', 'RC-05', 'RC-06', 'RC-07', 'RC-08', 'RC-09', 'RC-10'],
 };
 /**
  * Der Eintrittspunkt eines Tasks im Kern: die Regel, die "dieses Artefakt fehlt" sagt. `null` = der

package/dist/se/rule-help.d.ts

@@ -31,12 +31,18 @@
  * umformulierter Satz darf keinen Major ausloesen, deshalb steht im Golden-File nur die
  * Schluesselmenge, nicht die Prosa.
  *
- * Sprache: Englisch, wie die Regelbeschreibungen selbst. 18,6 KB reine Strings — der
- * `./browser`-Eintrag bleibt transitiv `node:`-frei (CR-SM-230), Strings ziehen nichts nach.
+ * Sprache: Englisch, wie die Regelbeschreibungen selbst — ausser `vorschlag`, der Satz, den ein Nutzer
+ * seinem Agenten schickt (CR-SM-384): Deutsch, weil er in der Sprache des Nutzers steht, nicht in der
+ * des Katalogs. Bis CR-SM-384 lag er als `VORSCHLAG_REGEL` in graphcode, ein paralleler Pfad zu
+ * `plain` und `fix_hint` mit derselben Driftgefahr wie oben. Reine Strings — der `./browser`-Eintrag
+ * bleibt transitiv `node:`-frei (CR-SM-230), Strings ziehen nichts nach.
  *
  * @author andreas@siglochconsulting
  */
-/** Ein verfasster Hilfeeintrag: die zwei Klartext-Schichten, dazu ein Kopier-Prompt, wo einer passt. */
+/**
+ * Ein verfasster Hilfeeintrag: die zwei Klartext-Schichten, dazu ein Kopier-Prompt, wo einer passt,
+ * und — fuer die Regeln des Kern-Fokus — der Vorschlag an den Nutzer.
+ */
 export interface RuleHelpEntry {
     /** Schicht 0 — ohne SE-Jargon; endet mit der EINEN einfachen Handlung. */
     readonly plain: string;
@@ -44,6 +50,14 @@ export interface RuleHelpEntry {
     readonly se: string;
     /** Schicht 2 — ein kopierbarer Prompt (`se:*`-Skill oder MCP-Aufruf), wo einer passt. */
     readonly prompt?: string;
+    /**
+     * Schicht 3 (CR-SM-384) — der naechste Schritt als Bitte des NUTZERS an seinen Agenten: ein deutscher
+     * Satz, Imperativ, `{n}` = die Namen der Fund-Elemente. Keine Werkzeugnamen, keine Regel-IDs, keine
+     * Fix-Vorlage — der Nutzer entscheidet, der Agent fuehrt aus (graphcode CR-GC-729/730). Genau an den
+     * Regeln, die den Kern-Fokus stellen koennen: Task `kern`, Schwere nicht `info`, kein Eintrittspunkt
+     * einer Analyse (die haben ihren eigenen Satz beim Konsumenten). Beidseitig erzwungen im Test.
+     */
+    readonly vorschlag?: string;
 }
 /**
  * Je Regel-ID der Hilfeeintrag — Katalogregeln (`ALL_RULE_DEFS`) UND Conformance-Regeln