@wairon/cli 5.1.1-dev.26 → 5.1.1-dev.27

package/dist/index.js

@@ -1113,7 +1113,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.26";
+    WAIRON_VERSION = "5.1.1-dev.27";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     ARCHITECT_AGENT_ID = "agent-architect";
     ARCHITECT_TEMPLATE_ID = "architect";
@@ -2253,8 +2253,8 @@ function extractTypeIdentifiers(typeStr) {
   cleaned = cleaned.replace(/(?<=\S)\s*\([^)]*\)\s*$/, "");
   cleaned = cleaned.replace(/(?<=\S)\s+[-—:]\s+[a-z\s_-]+$/, "");
   cleaned = cleaned.replace(/(["'`])(?:\\.|[^\\])*?\1/g, " ");
-  const matches2 = cleaned.match(/[a-zA-Z0-9_-]+(?:::[a-zA-Z0-9_-]+|\.[a-zA-Z0-9_-]+)*/g) || [];
-  return matches2.filter((t) => {
+  const matches = cleaned.match(/[a-zA-Z0-9_-]+(?:::[a-zA-Z0-9_-]+|\.[a-zA-Z0-9_-]+)*/g) || [];
+  return matches.filter((t) => {
     if (!/[a-zA-Z0-9]/.test(t)) return false;
     if (/^\d+$/.test(t)) return false;
     return true;
@@ -8877,6 +8877,37 @@ function buildDependencyEdges(ctx) {
   }
   return { all, matrix };
 }
+function buildSpecIds(ctx) {
+  const out = [];
+  for (const s of ctx.subsystems) out.push({ id: s.id, kind: "Subsystem" });
+  for (const c of ctx.components) out.push({ id: c.id, kind: "Component" });
+  for (const i of ctx.interfaces) out.push({ id: i.id, kind: "Interface" });
+  for (const im of ctx.implementations) out.push({ id: im.id, kind: "Implementation" });
+  for (const t of ctx.types) out.push({ id: t.id, kind: "Type" });
+  return out;
+}
+function buildImplementationMethods(ctx) {
+  const out = [];
+  for (const impl of ctx.implementations) {
+    const contract = ctx.interfaceMap.get(impl.contract);
+    if (!contract) continue;
+    const component = ctx.componentMap.get(contract.component);
+    if (!component) continue;
+    if (ctx.isInChainedSubproject(component.subsystem)) continue;
+    const draftContext = ctx.isImplementationDraft(impl);
+    for (const method of impl.methods) {
+      const sourceFile = methodSourceFile(method, impl.sourcePath);
+      out.push({
+        implementation: impl,
+        method,
+        component,
+        ...sourceFile !== void 0 ? { sourceFile } : {},
+        draftContext
+      });
+    }
+  }
+  return out;
+}
 function offTreeEdge(ctx, from, ref, fromDraft) {
   const base = { from, ref, retired: false, draftContext: fromDraft, licensed: false };
   const external = ctx.isExternalNamespaceRef(ref);
@@ -8977,48 +9008,58 @@ var init_hierarchy_integrity = __esm({
   }
 });
 
-// src/core/rules/integrity/namespace-hygiene.ts
-var namespaceHygieneRule;
-var init_namespace_hygiene = __esm({
-  "src/core/rules/integrity/namespace-hygiene.ts"() {
+// src/core/rules/integrity/reserved-id-segments.ts
+var reservedIdSegmentsRule;
+var init_reserved_id_segments = __esm({
+  "src/core/rules/integrity/reserved-id-segments.ts"() {
     "use strict";
-    namespaceHygieneRule = {
-      name: "namespace-hygiene",
-      description: 'Ids must stay resolvable in the :: namespace grammar: no id segment may be the reserved keyword "super", and a subproject-local name must not shadow a root-level subsystem id \u2014 a bare reference to a shadowed name silently anchors to the ROOT subsystem, so the local spec becomes unaddressable.',
+    reservedIdSegmentsRule = {
+      name: "reserved-id-segments",
+      description: 'No segment of a spec id may be the reserved namespace keyword "super" \u2014 the :: grammar consumes it as a namespace hop, so a stored reference to such an id resolves to a different spec.',
+      codes: [
+        { code: "RESERVED_ID_SEGMENT", defaultSeverity: "error", summary: 'Id uses the reserved namespace keyword "super"' }
+      ],
+      check(ctx) {
+        for (const spec of ctx.specIds()) {
+          if (!ctx.isSpecInScope(spec.id)) continue;
+          if (!spec.id.split("::").includes("super")) continue;
+          ctx.addIssue(
+            "error",
+            "RESERVED_ID_SEGMENT",
+            `${spec.kind} id "${spec.id}" uses the reserved namespace keyword "super" \u2014 stored references to it would be consumed as a namespace hop and resolve to a different spec.`,
+            spec.id
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/integrity/namespace-shadowing.ts
+var namespaceShadowingRule;
+var init_namespace_shadowing = __esm({
+  "src/core/rules/integrity/namespace-shadowing.ts"() {
+    "use strict";
+    namespaceShadowingRule = {
+      name: "namespace-shadowing",
+      description: "A subproject-local name must not shadow a root-level subsystem id \u2014 inside its subproject a bare reference to the shadowed name anchors to the ROOT subsystem, so the local spec cannot be addressed reliably.",
       codes: [
-        { code: "RESERVED_ID_SEGMENT", defaultSeverity: "error", summary: 'Id uses the reserved namespace keyword "super"' },
         { code: "NAMESPACE_SHADOWING", defaultSeverity: "error", summary: "Subproject-local id shadows a root subsystem id (bare references anchor to the root)" }
       ],
       check(ctx) {
         const rootSubs = new Set(ctx.subsystems.filter((s) => !s.id.includes("::")).map((s) => s.id));
-        const checkId = (id, kindLabel) => {
-          if (!ctx.isSpecInScope(id)) return;
-          const segments = id.split("::");
-          if (segments.includes("super")) {
-            ctx.addIssue(
-              "error",
-              "RESERVED_ID_SEGMENT",
-              `${kindLabel} id "${id}" uses the reserved namespace keyword "super" \u2014 stored references to it would be consumed as a namespace hop and resolve to a different spec.`,
-              id
-            );
-          }
-          if (segments.length > 1) {
-            const local = segments[segments.length - 1];
-            if (rootSubs.has(local)) {
-              ctx.addIssue(
-                "error",
-                "NAMESPACE_SHADOWING",
-                `${kindLabel} "${id}" shadows root subsystem "${local}" \u2014 inside its subproject a bare reference to "${local}" anchors to the ROOT subsystem, so this spec cannot be addressed reliably. Rename one of them.`,
-                id
-              );
-            }
-          }
-        };
-        for (const s of ctx.subsystems) checkId(s.id, "Subsystem");
-        for (const c of ctx.components) checkId(c.id, "Component");
-        for (const i of ctx.interfaces) checkId(i.id, "Interface");
-        for (const im of ctx.implementations) checkId(im.id, "Implementation");
-        for (const t of ctx.types) checkId(t.id, "Type");
+        for (const spec of ctx.specIds()) {
+          if (!ctx.isSpecInScope(spec.id)) continue;
+          const segments = spec.id.split("::");
+          const local = segments[segments.length - 1];
+          if (segments.length <= 1 || !rootSubs.has(local)) continue;
+          ctx.addIssue(
+            "error",
+            "NAMESPACE_SHADOWING",
+            `${spec.kind} "${spec.id}" shadows root subsystem "${local}" \u2014 inside its subproject a bare reference to "${local}" anchors to the ROOT subsystem, so this spec cannot be addressed reliably. Rename one of them.`,
+            spec.id
+          );
+        }
       }
     };
   }
@@ -9163,10 +9204,48 @@ var init_signature_type_references = __esm({
   }
 });
 
-// src/core/rules/integrity/public-surface.ts
-var pubTypeMatches, EVENT_VOCAB, expectedFor, publicSurfaceRule;
-var init_public_surface = __esm({
-  "src/core/rules/integrity/public-surface.ts"() {
+// src/core/rules/integrity/public-surface-binding.ts
+var publicSurfaceBindingRule;
+var init_public_surface_binding = __esm({
+  "src/core/rules/integrity/public-surface-binding.ts"() {
+    "use strict";
+    init_models();
+    publicSurfaceBindingRule = {
+      name: "public-surface-binding",
+      description: "Every declared publicInterface names a backing component, that component exists, and the subsystem owns it \u2014 a subsystem may only publish its own components.",
+      codes: [
+        { code: "PUBLIC_INTERFACE_UNBOUND", defaultSeverity: "error", summary: "Public interface with no backing component" },
+        { code: "PUBLIC_INTERFACE_INVALID_COMPONENT", defaultSeverity: "error", summary: "Public interface references a non-existent component" },
+        { code: "PUBLIC_INTERFACE_FOREIGN_COMPONENT", defaultSeverity: "error", summary: "Subsystem publishing a component it does not own" }
+      ],
+      check(ctx) {
+        for (const sub of ctx.subsystems) {
+          const isDraftCtx = isDraftSubsystem(sub);
+          for (const pi of sub.publicInterfaces) {
+            if (!pi.component) {
+              ctx.addIssue("error", "PUBLIC_INTERFACE_UNBOUND", `Subsystem "${sub.id}" declares a ${pi.type} public interface with no backing component. Bind it to the component that realizes it (publicInterfaces[].component).`, sub.id, isDraftCtx);
+              continue;
+            }
+            const backing = ctx.componentMap.get(pi.component);
+            if (!backing) {
+              ctx.addIssue("error", "PUBLIC_INTERFACE_INVALID_COMPONENT", `Subsystem "${sub.id}" public interface references component "${pi.component}" which does not exist.`, sub.id, isDraftCtx);
+              continue;
+            }
+            const isSubsystemOwner = backing.subsystem === sub.id || backing.subsystem.startsWith(sub.id + "::");
+            if (!isSubsystemOwner) {
+              ctx.addIssue("error", "PUBLIC_INTERFACE_FOREIGN_COMPONENT", `Subsystem "${sub.id}" publishes component "${pi.component}", but it belongs to subsystem "${backing.subsystem}". A subsystem may only publish its own components.`, sub.id, isDraftCtx);
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/integrity/public-surface-declared-type.ts
+var pubTypeMatches, EVENT_VOCAB, expectedFor, publicSurfaceDeclaredTypeRule;
+var init_public_surface_declared_type = __esm({
+  "src/core/rules/integrity/public-surface-declared-type.ts"() {
     "use strict";
     init_models();
     pubTypeMatches = (piType, ct, portalType) => {
@@ -9200,45 +9279,22 @@ var init_public_surface = __esm({
           return "a compatible component";
       }
     };
-    publicSurfaceRule = {
-      name: "public-surface",
-      description: "Every declared publicInterface is bound to an existing component of this subsystem whose stereotype can realize the declared interface type; Custom entries whose prose implies eventing must be backed by an event-capable component.",
+    publicSurfaceDeclaredTypeRule = {
+      name: "public-surface-declared-type",
+      description: "A publicInterface entry's declared type must be realizable by the stereotype of its backing component; Custom entries whose prose implies eventing must be backed by an event-capable component.",
       codes: [
-        { code: "PUBLIC_INTERFACE_UNBOUND", defaultSeverity: "error", summary: "Public interface with no backing component" },
-        { code: "PUBLIC_INTERFACE_INVALID_COMPONENT", defaultSeverity: "error", summary: "Public interface references a non-existent component" },
-        { code: "PUBLIC_INTERFACE_FOREIGN_COMPONENT", defaultSeverity: "error", summary: "Subsystem publishing a component it does not own" },
         { code: "PUBLIC_INTERFACE_TYPE_MISMATCH", defaultSeverity: "error", summary: "Backing component cannot realize the declared interface type" },
-        { code: "PUBLIC_INTERFACE_INVALID_INTERFACE", defaultSeverity: "error", summary: "Bound L3 interface missing or belonging to another component" },
         { code: "PUBLIC_INTERFACE_EVENT_MISTYPED", defaultSeverity: "warning", summary: "Custom interface describing eventing backed by a non-event component" }
       ],
       check(ctx) {
         for (const sub of ctx.subsystems) {
           const isDraftCtx = isDraftSubsystem(sub);
           for (const pi of sub.publicInterfaces) {
-            if (!pi.component) {
-              ctx.addIssue("error", "PUBLIC_INTERFACE_UNBOUND", `Subsystem "${sub.id}" declares a ${pi.type} public interface with no backing component. Bind it to the component that realizes it (publicInterfaces[].component).`, sub.id, isDraftCtx);
-              continue;
-            }
-            const backing = ctx.componentMap.get(pi.component);
-            if (!backing) {
-              ctx.addIssue("error", "PUBLIC_INTERFACE_INVALID_COMPONENT", `Subsystem "${sub.id}" public interface references component "${pi.component}" which does not exist.`, sub.id, isDraftCtx);
-              continue;
-            }
-            const isSubsystemOwner = backing.subsystem === sub.id || backing.subsystem.startsWith(sub.id + "::");
-            if (!isSubsystemOwner) {
-              ctx.addIssue("error", "PUBLIC_INTERFACE_FOREIGN_COMPONENT", `Subsystem "${sub.id}" publishes component "${pi.component}", but it belongs to subsystem "${backing.subsystem}". A subsystem may only publish its own components.`, sub.id, isDraftCtx);
-            }
+            const backing = pi.component ? ctx.componentMap.get(pi.component) : void 0;
+            if (!backing) continue;
             if (!pubTypeMatches(pi.type, backing.componentType, backing.portalType)) {
               ctx.addIssue("error", "PUBLIC_INTERFACE_TYPE_MISMATCH", `Subsystem "${sub.id}" declares a ${pi.type} public interface backed by "${pi.component}" (${backing.componentType}${backing.portalType ? `/${backing.portalType}` : ""}), which cannot realize ${pi.type}. Expected ${expectedFor(pi.type)}.`, sub.id, isDraftCtx);
             }
-            if (pi.interface) {
-              const intf = ctx.interfaceMap.get(pi.interface);
-              if (!intf) {
-                ctx.addIssue("error", "PUBLIC_INTERFACE_INVALID_INTERFACE", `Subsystem "${sub.id}" public interface references interface "${pi.interface}" which does not exist.`, sub.id, isDraftCtx);
-              } else if (intf.component !== pi.component) {
-                ctx.addIssue("error", "PUBLIC_INTERFACE_INVALID_INTERFACE", `Subsystem "${sub.id}" binds interface "${pi.interface}" to component "${pi.component}", but that interface belongs to component "${intf.component}".`, sub.id, isDraftCtx);
-              }
-            }
             if (pi.type === "Custom" && EVENT_VOCAB.test(pi.details)) {
               const eventCapable = backing.componentType === "Observer" || backing.componentType === "Portal" && backing.portalType === "MessageBus";
               if (!eventCapable) {
@@ -9252,6 +9308,37 @@ var init_public_surface = __esm({
   }
 });
 
+// src/core/rules/integrity/public-surface-bound-contract.ts
+var publicSurfaceBoundContractRule;
+var init_public_surface_bound_contract = __esm({
+  "src/core/rules/integrity/public-surface-bound-contract.ts"() {
+    "use strict";
+    init_models();
+    publicSurfaceBoundContractRule = {
+      name: "public-surface-bound-contract",
+      description: "A publicInterface entry that binds an L3 interface must bind one that exists and that belongs to the component the entry publishes.",
+      codes: [
+        { code: "PUBLIC_INTERFACE_INVALID_INTERFACE", defaultSeverity: "error", summary: "Bound L3 interface missing or belonging to another component" }
+      ],
+      check(ctx) {
+        for (const sub of ctx.subsystems) {
+          const isDraftCtx = isDraftSubsystem(sub);
+          for (const pi of sub.publicInterfaces) {
+            if (!pi.interface) continue;
+            if (!pi.component || !ctx.componentMap.has(pi.component)) continue;
+            const intf = ctx.interfaceMap.get(pi.interface);
+            if (!intf) {
+              ctx.addIssue("error", "PUBLIC_INTERFACE_INVALID_INTERFACE", `Subsystem "${sub.id}" public interface references interface "${pi.interface}" which does not exist.`, sub.id, isDraftCtx);
+            } else if (intf.component !== pi.component) {
+              ctx.addIssue("error", "PUBLIC_INTERFACE_INVALID_INTERFACE", `Subsystem "${sub.id}" binds interface "${pi.interface}" to component "${pi.component}", but that interface belongs to component "${intf.component}".`, sub.id, isDraftCtx);
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/core/rules/integrity/lint-allows.ts
 var lintAllowsRule;
 var init_lint_allows = __esm({
@@ -9857,7 +9944,7 @@ var init_narrative_jump_edges = __esm({
   }
 });
 
-// src/core/rules/narrative/narrative-antipatterns.ts
+// src/core/rules/narrative/completed-step-graph.ts
 function completedStepGraph(steps) {
   const numbers = steps.flatMap((s) => [
     s.stepNumber,
@@ -9887,6 +9974,14 @@ function isUnavoidable(steps, target) {
     if (s.type === "return" || s.type === "throw") return true;
     const arms = s.type === "parallel" ? (s.branches ?? []).map((b) => b.step).filter((e) => graph.stepAt(e) !== void 0) : [];
     if (arms.length) return arms.every((e) => completes.has(e));
+    const guaranteed = s.endStep !== void 0 && (s.type === "try" || s.type === "loop" && s.loopKind === "doWhile");
+    if (guaranteed) {
+      const bodyEntry = graph.nextOf(n);
+      if (bodyEntry !== void 0 && bodyEntry <= s.endStep) {
+        if (s.type === "loop") return completes.has(bodyEntry);
+        if (bodyEntry === target) return false;
+      }
+    }
     return graph.successorsOf(n).some((t) => completes.has(t));
   };
   const order = [...graph.stepNumbers].reverse();
@@ -9950,25 +10045,27 @@ function stronglyConnected(nums, successorsOf) {
   }
   return sccs;
 }
-var byCodeUnit, narrativeAntipatternsRule;
-var init_narrative_antipatterns = __esm({
-  "src/core/rules/narrative/narrative-antipatterns.ts"() {
+var init_completed_step_graph = __esm({
+  "src/core/rules/narrative/completed-step-graph.ts"() {
     "use strict";
     init_models();
-    byCodeUnit = (a, b) => a < b ? -1 : a > b ? 1 : 0;
-    narrativeAntipatternsRule = {
-      name: "narrative-antipatterns",
-      description: "Provable narrative bugs, caught at spec level before implementation: a step-graph cycle with no exit edge and no return/throw member never terminates by construction (INESCAPABLE_CYCLE); a branch or switch whose arms all target the same step decides nothing (MEANINGLESS_BRANCH); a method-level call cycle across components in which every call edge is unavoidable on every entry-to-exit path is unbounded recursion (UNCONDITIONAL_CALL_CYCLE \u2014 dispatch steps resolved through their portal tables; a cycle with even one guarded edge is NOT flagged, since prose conditions are never judged). Structure-only claims \u2014 warnings, lint.allow-suppressible.",
+  }
+});
+
+// src/core/rules/narrative/meaningless-branches.ts
+var meaninglessBranchesRule;
+var init_meaningless_branches = __esm({
+  "src/core/rules/narrative/meaningless-branches.ts"() {
+    "use strict";
+    init_completed_step_graph();
+    meaninglessBranchesRule = {
+      name: "meaningless-branches",
+      description: "A branch or switch whose arms all target the same step decides nothing: the condition is evaluated and flow continues at one place whatever it answers. A decision's targets are its explicit ones plus, where it leaves its fall-through field unset, the steps the step graph continues it at \u2014 so the classic authoring slip of pointing both arms at the next step is caught. Structure-only \u2014 a warning, lint.allow-suppressible.",
       codes: [
-        { code: "INESCAPABLE_CYCLE", defaultSeverity: "warning", summary: "Step cycle with no exit edge and no return/throw member \u2014 never terminates by construction" },
-        { code: "MEANINGLESS_BRANCH", defaultSeverity: "warning", summary: "Branch/switch whose arms all target the same step \u2014 the decision changes nothing" },
-        { code: "UNCONDITIONAL_CALL_CYCLE", defaultSeverity: "warning", summary: "Cross-component call cycle in which every call edge is unavoidable \u2014 unbounded recursion by construction" }
+        { code: "MEANINGLESS_BRANCH", defaultSeverity: "warning", summary: "Branch/switch whose arms all target the same step \u2014 the decision changes nothing" }
       ],
       check(ctx) {
-        const callEdges = [];
         for (const impl of ctx.implementations) {
-          const contract = ctx.interfaceMap.get(impl.contract);
-          const component = contract ? ctx.componentMap.get(contract.component) : void 0;
           const isDraftCtx = ctx.isImplementationDraft(impl);
           for (const implMethod of impl.methods) {
             const steps = implMethod.narrative;
@@ -10007,6 +10104,33 @@ var init_narrative_antipatterns = __esm({
                 }
               }
             }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/narrative/inescapable-cycles.ts
+var inescapableCyclesRule;
+var init_inescapable_cycles = __esm({
+  "src/core/rules/narrative/inescapable-cycles.ts"() {
+    "use strict";
+    init_completed_step_graph();
+    inescapableCyclesRule = {
+      name: "inescapable-cycles",
+      description: "A cycle in a narrative's step graph with no exit edge and no return or throw member never terminates, by construction: every path that enters it stays inside it forever. Read over the step graph closed by a completion step, so falling off the end of the narrative counts as leaving. Structure-only \u2014 prose conditions are never judged \u2014 and reported as a warning, lint.allow-suppressible.",
+      codes: [
+        { code: "INESCAPABLE_CYCLE", defaultSeverity: "warning", summary: "Step cycle with no exit edge and no return/throw member \u2014 never terminates by construction" }
+      ],
+      check(ctx) {
+        for (const impl of ctx.implementations) {
+          const isDraftCtx = ctx.isImplementationDraft(impl);
+          for (const implMethod of impl.methods) {
+            const steps = implMethod.narrative;
+            if (!steps.length) continue;
+            const where = `Method "${implMethod.name}" in implementation "${impl.id}": `;
+            const graph = completedStepGraph(steps);
             for (const scc of stronglyConnected(graph.stepNumbers, graph.successorsOf)) {
               const inScc = new Set(scc);
               const isCycle = scc.length > 1 || graph.successorsOf(scc[0]).includes(scc[0]);
@@ -10027,7 +10151,35 @@ var init_narrative_antipatterns = __esm({
                 );
               }
             }
-            if (!component) continue;
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/narrative/unconditional-call-cycles.ts
+var byCodeUnit, unconditionalCallCyclesRule;
+var init_unconditional_call_cycles = __esm({
+  "src/core/rules/narrative/unconditional-call-cycles.ts"() {
+    "use strict";
+    init_completed_step_graph();
+    byCodeUnit = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+    unconditionalCallCyclesRule = {
+      name: "unconditional-call-cycles",
+      description: "A method-level call cycle across components in which every call edge is unavoidable on every entry-to-exit path of its narrative is unbounded recursion, by construction. Dispatch steps are resolved through their portal's table; register steps are never edges (a handoff defers the invocation to the runtime, so it cannot recurse). A cycle with even one guarded edge is NOT flagged, since prose conditions are never judged. Structure-only \u2014 a warning, lint.allow-suppressible, anchored on the member edge that sorts first so one allow covers the cycle.",
+      codes: [
+        { code: "UNCONDITIONAL_CALL_CYCLE", defaultSeverity: "warning", summary: "Cross-component call cycle in which every call edge is unavoidable \u2014 unbounded recursion by construction" }
+      ],
+      check(ctx) {
+        const callEdges = [];
+        for (const impl of ctx.implementations) {
+          const contract = ctx.interfaceMap.get(impl.contract);
+          const component = contract ? ctx.componentMap.get(contract.component) : void 0;
+          if (!component) continue;
+          for (const implMethod of impl.methods) {
+            const steps = implMethod.narrative;
+            if (!steps.length) continue;
             const fromKey = `${component.id}::${implMethod.name}`;
             for (const s of steps) {
               let toComponent;
@@ -10089,34 +10241,29 @@ var init_narrative_antipatterns = __esm({
 });
 
 // src/core/rules/narrative/narrative-detail.ts
-var DEFAULT_MAX_UNNARRATED_COMPLEXITY, narrativeDetailRule;
+var narrativeDetailRule;
 var init_narrative_detail = __esm({
   "src/core/rules/narrative/narrative-detail.ts"() {
     "use strict";
     init_models();
-    DEFAULT_MAX_UNNARRATED_COMPLEXITY = 8;
     narrativeDetailRule = {
       name: "narrative-detail",
-      description: "The narrative detail dial: each method resolves to full | calls-only | intent (method override \u2192 spec default \u2192 stereotype default). full requires a narrative; intent-level methods without a narrative must specify behavior as non-trivial prose (L4 intent or L3 description) \u2014 dialing detail down never means leaving behavior unspecified. Explicit declarations are held to their promise as errors; stereotype-defaulted gaps surface as warnings. Detail sufficiency rides along: a method whose realized function \u2014 in the method's own source file, else the implementation's \u2014 measures real branching (cyclomatic complexity above rules.complexity.maxUnnarratedComplexity, exact AST grade only) may not hide below detail: full without a narrative (UNNARRATED_COMPLEXITY), and an explicit dial below a full-floor logic stereotype without a narrative is a visible, lint.allow-justifiable choice (DETAIL_BELOW_STEREOTYPE). Both are honest lints over declarations \u2014 they never claim the narrative or prose is CORRECT.",
+      description: "The narrative detail dial: each method resolves to full | calls-only | intent (method override \u2192 spec default \u2192 stereotype default). full requires a narrative; intent-level methods without a narrative must specify behavior as non-trivial prose (L4 intent or L3 description) \u2014 dialing detail down never means leaving behavior unspecified. Explicit declarations are held to their promise as errors; stereotype-defaulted gaps surface as warnings. An honest lint over declarations \u2014 it never claims the narrative or the prose is CORRECT.",
       codes: [
         { code: "MISSING_NARRATIVE", defaultSeverity: "warning", summary: "Method resolved to detail: full but has no narrative (error when the level was declared explicitly)" },
-        { code: "INTENT_FLOOR", defaultSeverity: "warning", summary: "Intent-level method whose intent/description prose is missing or placeholder-thin (error when declared explicitly)" },
-        { code: "UNNARRATED_COMPLEXITY", defaultSeverity: "warning", summary: "Method below detail: full with no narrative whose realized function, in the method's source file, has real branching (cyclomatic complexity over the configured threshold, exact-grade analysis only)" },
-        { code: "DETAIL_BELOW_STEREOTYPE", defaultSeverity: "warning", summary: "Method explicitly dialed below the full narrative floor of its logic stereotype, with no narrative" }
+        { code: "INTENT_FLOOR", defaultSeverity: "warning", summary: "Intent-level method whose intent/description prose is missing or placeholder-thin (error when declared explicitly)" }
       ],
       check(ctx) {
-        const code = ctx.codeIndex();
         for (const impl of ctx.implementations) {
           const contract = ctx.interfaceMap.get(impl.contract);
           if (!contract) continue;
           const component = ctx.componentMap.get(contract.component);
-          const isDraftCtx = impl.status === "draft" || impl.status === "design" || contract.status === "draft" || contract.status === "design" || ctx.isComponentDraft(contract.component);
+          const isDraftCtx = ctx.isImplementationDraft(impl);
           for (const implMethod of impl.methods) {
             const contractMethod = contract.methods.find((m) => m.name === implMethod.name);
             if (!contractMethod) continue;
+            if (implMethod.narrative.length > 0) continue;
             const eff = effectiveDetail(implMethod, impl, component);
-            const hasNarrative = implMethod.narrative.length > 0;
-            if (hasNarrative) continue;
             if (eff.level === "full") {
               ctx.addIssue(
                 eff.explicit ? "error" : "warning",
@@ -10127,34 +10274,6 @@ var init_narrative_detail = __esm({
               );
               continue;
             }
-            let complexityFired = false;
-            const tier = implMethod.conformance ?? impl.conformance ?? defaultConformanceTier(component);
-            const file = methodSourceFile(implMethod, impl.sourcePath);
-            if (file && tier !== "off" && !(component && ctx.isInChainedSubproject(component.subsystem))) {
-              const facts = code.factsAt(file);
-              const symbol = implMethod.symbol ?? implMethod.name;
-              const complexity = facts?.status === "analyzed" && facts.analysisGrade === "exact" && facts.functionComplexity && Object.prototype.hasOwnProperty.call(facts.functionComplexity, symbol) ? facts.functionComplexity[symbol] : void 0;
-              const limit = ctx.complexityConfigFor(component?.subsystem)?.maxUnnarratedComplexity ?? DEFAULT_MAX_UNNARRATED_COMPLEXITY;
-              if (complexity !== void 0 && complexity > limit) {
-                complexityFired = true;
-                ctx.addIssue(
-                  "warning",
-                  "UNNARRATED_COMPLEXITY",
-                  `Method "${implMethod.name}" in implementation "${impl.id}" sits at detail: ${eff.level} with no narrative, but its realized function "${symbol}" in "${file}" measures cyclomatic complexity ${complexity} (limit ${limit}) \u2014 real branching is hiding behind ${eff.level}. Write the narrative, or keep the dial with a lint.allow stating why the branching needs no choreography.`,
-                  impl.id,
-                  isDraftCtx
-                );
-              }
-            }
-            if (!complexityFired && eff.explicit && component && isLogic(component)) {
-              ctx.addIssue(
-                "warning",
-                "DETAIL_BELOW_STEREOTYPE",
-                `Method "${implMethod.name}" in implementation "${impl.id}" is explicitly dialed to detail: ${eff.level}, below the full narrative floor of its ${component.componentType} stereotype, and has no narrative. Logic behavior belongs in a narrative \u2014 write one, or keep the dial with a lint.allow stating why.`,
-                impl.id,
-                isDraftCtx
-              );
-            }
             const prose = implMethod.intent ?? contractMethod.description;
             if (!passesIntentFloor(prose, implMethod.name)) {
               ctx.addIssue(
@@ -10172,6 +10291,71 @@ var init_narrative_detail = __esm({
   }
 });
 
+// src/core/rules/narrative/detail-sufficiency.ts
+var DEFAULT_MAX_UNNARRATED_COMPLEXITY, detailSufficiencyRule;
+var init_detail_sufficiency = __esm({
+  "src/core/rules/narrative/detail-sufficiency.ts"() {
+    "use strict";
+    init_models();
+    DEFAULT_MAX_UNNARRATED_COMPLEXITY = 8;
+    detailSufficiencyRule = {
+      name: "detail-sufficiency",
+      description: "A method dialed below detail: full with no narrative may not be hiding behavior it owes a reader. A method whose realized function \u2014 in the method's own source file, else the implementation's \u2014 measures real branching (cyclomatic complexity above rules.complexity.maxUnnarratedComplexity, exact AST grade only) is reported (UNNARRATED_COMPLEXITY), and an explicit dial below a full-floor logic stereotype without a narrative is a visible, lint.allow-justifiable choice (DETAIL_BELOW_STEREOTYPE) \u2014 reported only where the measured finding did not already fire, since evidence outranks expectation. Both are honest lints over declarations: they never claim a narrative would be correct, only that the dial hides something.",
+      codes: [
+        { code: "UNNARRATED_COMPLEXITY", defaultSeverity: "warning", summary: "Method below detail: full with no narrative whose realized function, in the method's source file, has real branching (cyclomatic complexity over the configured threshold, exact-grade analysis only)" },
+        { code: "DETAIL_BELOW_STEREOTYPE", defaultSeverity: "warning", summary: "Method explicitly dialed below the full narrative floor of its logic stereotype, with no narrative" }
+      ],
+      check(ctx) {
+        const code = ctx.codeIndex();
+        const dialedDown = [];
+        for (const impl of ctx.implementations) {
+          const contract = ctx.interfaceMap.get(impl.contract);
+          if (!contract) continue;
+          const component = ctx.componentMap.get(contract.component);
+          const draftContext = ctx.isImplementationDraft(impl);
+          for (const method of impl.methods) {
+            const detail = effectiveDetail(method, impl, component);
+            if (contract.methods.some((m) => m.name === method.name) && method.narrative.length === 0 && detail.level !== "full") {
+              dialedDown.push({ implementation: impl, method, component, detail, draftContext });
+            }
+          }
+        }
+        for (const entry of dialedDown) {
+          const { implementation: impl, method, component, detail } = entry;
+          const tier = method.conformance ?? impl.conformance ?? defaultConformanceTier(component);
+          const file = methodSourceFile(method, impl.sourcePath);
+          const symbol = method.symbol ?? method.name;
+          const limit = ctx.complexityConfigFor(component?.subsystem)?.maxUnnarratedComplexity ?? DEFAULT_MAX_UNNARRATED_COMPLEXITY;
+          let complexity;
+          if (file && tier !== "off" && !(component && ctx.isInChainedSubproject(component.subsystem))) {
+            const facts = code.factsAt(file);
+            complexity = facts?.status === "analyzed" && facts.analysisGrade === "exact" && facts.functionComplexity && Object.prototype.hasOwnProperty.call(facts.functionComplexity, symbol) ? facts.functionComplexity[symbol] : void 0;
+          }
+          if (complexity !== void 0 && complexity > limit) {
+            ctx.addIssue(
+              "warning",
+              "UNNARRATED_COMPLEXITY",
+              `Method "${method.name}" in implementation "${impl.id}" sits at detail: ${detail.level} with no narrative, but its realized function "${symbol}" in "${file}" measures cyclomatic complexity ${complexity} (limit ${limit}) \u2014 real branching is hiding behind ${detail.level}. Write the narrative, or keep the dial with a lint.allow stating why the branching needs no choreography.`,
+              impl.id,
+              entry.draftContext
+            );
+            continue;
+          }
+          if (detail.explicit && component && isLogic(component)) {
+            ctx.addIssue(
+              "warning",
+              "DETAIL_BELOW_STEREOTYPE",
+              `Method "${method.name}" in implementation "${impl.id}" is explicitly dialed to detail: ${detail.level}, below the full narrative floor of its ${component.componentType} stereotype, and has no narrative. Logic behavior belongs in a narrative \u2014 write one, or keep the dial with a lint.allow stating why.`,
+              impl.id,
+              entry.draftContext
+            );
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/core/rules/intrinsic/portal-fields.ts
 var portalFieldsRule;
 var init_portal_fields = __esm({
@@ -10356,45 +10540,61 @@ var init_portal_endpoints = __esm({
     };
     portalsRule = {
       name: "portal-endpoints",
-      description: "A Portal binds every interface method to a concrete endpoint of the matching transport, and only a Portal may carry endpoints at all.",
+      description: "A Portal binds every interface method to a concrete endpoint of the transport its portalType expects.",
       codes: [
         { code: "MISSING_ENDPOINT", defaultSeverity: "error", summary: "Portal method without a wire endpoint binding" },
-        { code: "ENDPOINT_TRANSPORT_MISMATCH", defaultSeverity: "error", summary: "Endpoint transport does not match the Portal portalType" },
-        { code: "ARCHITECTURE_VIOLATION_NON_PORTAL_ENDPOINT", defaultSeverity: "error", summary: "Non-Portal component method declaring an endpoint" }
+        { code: "ENDPOINT_TRANSPORT_MISMATCH", defaultSeverity: "error", summary: "Endpoint transport does not match the Portal portalType" }
       ],
       check(ctx) {
         for (const comp of ctx.components) {
+          if (comp.componentType !== "Portal") continue;
+          const expected = comp.portalType ? PORTAL_TRANSPORT[comp.portalType] : void 0;
+          if (!expected) continue;
           const isDraftCtx = ctx.isComponentDraft(comp.id);
-          const compInterfaces = ctx.interfaces.filter((i) => i.component === comp.id);
-          if (comp.componentType === "Portal") {
-            if (!comp.portalType) continue;
-            const expected = PORTAL_TRANSPORT[comp.portalType];
-            if (!expected) continue;
-            for (const intf of compInterfaces) {
-              const isIntfDraft = intf.status === "draft" || intf.status === "design";
-              for (const m of intf.methods) {
-                if (!m.endpoint) {
-                  ctx.addIssue(
-                    "error",
-                    "MISSING_ENDPOINT",
-                    `Method "${m.name}" on interface "${intf.id}" (Portal ${comp.portalType}) is missing an "endpoint" mapping. Bind it with sdd_set_endpoints (transport "${expected}").`,
-                    intf.id,
-                    isDraftCtx || isIntfDraft
-                  );
-                } else if (m.endpoint.transport !== expected) {
-                  ctx.addIssue(
-                    "error",
-                    "ENDPOINT_TRANSPORT_MISMATCH",
-                    `Method "${m.name}" on interface "${intf.id}" declares a "${m.endpoint.transport}" endpoint, but its Portal "${comp.id}" is portalType "${comp.portalType}" (expects transport "${expected}").`,
-                    intf.id,
-                    isDraftCtx || isIntfDraft
-                  );
-                }
+          for (const intf of ctx.interfaces.filter((i) => i.component === comp.id)) {
+            const isIntfDraft = intf.status === "draft" || intf.status === "design";
+            for (const m of intf.methods) {
+              if (!m.endpoint) {
+                ctx.addIssue(
+                  "error",
+                  "MISSING_ENDPOINT",
+                  `Method "${m.name}" on interface "${intf.id}" (Portal ${comp.portalType}) is missing an "endpoint" mapping. Bind it with sdd_set_endpoints (transport "${expected}").`,
+                  intf.id,
+                  isDraftCtx || isIntfDraft
+                );
+              } else if (m.endpoint.transport !== expected) {
+                ctx.addIssue(
+                  "error",
+                  "ENDPOINT_TRANSPORT_MISMATCH",
+                  `Method "${m.name}" on interface "${intf.id}" declares a "${m.endpoint.transport}" endpoint, but its Portal "${comp.id}" is portalType "${comp.portalType}" (expects transport "${expected}").`,
+                  intf.id,
+                  isDraftCtx || isIntfDraft
+                );
               }
             }
-            continue;
           }
-          for (const intf of compInterfaces) {
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/doctrine/non-portal-endpoints.ts
+var nonPortalEndpointsRule;
+var init_non_portal_endpoints = __esm({
+  "src/core/rules/doctrine/non-portal-endpoints.ts"() {
+    "use strict";
+    nonPortalEndpointsRule = {
+      name: "non-portal-endpoints",
+      description: "Only a Portal may carry endpoints: a method on a non-Portal component's interface that declares one is publishing a block that is not the system's boundary as if it were.",
+      codes: [
+        { code: "ARCHITECTURE_VIOLATION_NON_PORTAL_ENDPOINT", defaultSeverity: "error", summary: "Non-Portal component method declaring an endpoint" }
+      ],
+      check(ctx) {
+        for (const comp of ctx.components) {
+          if (comp.componentType === "Portal") continue;
+          const isDraftCtx = ctx.isComponentDraft(comp.id);
+          for (const intf of ctx.interfaces.filter((i) => i.component === comp.id)) {
             const isIntfDraft = intf.status === "draft" || intf.status === "design";
             for (const m of intf.methods) {
               if (m.endpoint) {
@@ -10415,20 +10615,16 @@ var init_portal_endpoints = __esm({
 });
 
 // src/core/rules/doctrine/portal-call-auth.ts
-var COMPONENT_REF_PREFIX, portalCallAuthRule;
+var portalCallAuthRule;
 var init_portal_call_auth = __esm({
   "src/core/rules/doctrine/portal-call-auth.ts"() {
     "use strict";
-    COMPONENT_REF_PREFIX = "component:";
     portalCallAuthRule = {
       name: "portal-call-auth",
-      description: "Hardens authenticated cross-service calls. An OUTBOUND narrative `call` into ANOTHER component's Portal whose auth is not `none` must (a) be made by an Adapter \u2014 the only block that does external I/O \u2014 and (b) declare the credential source it presents via the step's `auth.from`. Absence of a source warns PORTAL_AUTH_UNMET; a non-Adapter presenter warns AUTH_PRESENTER_NOT_ADAPTER. When `auth.from` is a modeled reference (`component:<id>`) it must resolve to an Adapter/Store the presenter is wired to (UNKNOWN_AUTH_SOURCE / AUTH_SOURCE_NOT_PROVIDER / AUTH_SOURCE_UNWIRED). The actual secret is never stored in the spec. Dispatch steps (a portal's OWN inbound routing) and self-calls are not cross-service calls and are excluded.",
+      description: "Hardens authenticated cross-service calls. An OUTBOUND narrative `call` into ANOTHER component's Portal whose auth is not `none` must (a) be made by an Adapter \u2014 the only block that does external I/O \u2014 and (b) declare the credential source it presents via the step's `auth.from`. Absence of a source warns PORTAL_AUTH_UNMET; a non-Adapter presenter warns AUTH_PRESENTER_NOT_ADAPTER. The actual secret is never stored in the spec. Dispatch steps (a portal's OWN inbound routing) and self-calls are not cross-service calls and are excluded.",
       codes: [
         { code: "PORTAL_AUTH_UNMET", defaultSeverity: "warning", summary: "A narrative call into another component's authed Portal does not declare where its credential loads from" },
-        { code: "AUTH_PRESENTER_NOT_ADAPTER", defaultSeverity: "warning", summary: "A non-Adapter component authenticates an outbound call to a portal (external I/O must go through an Adapter)" },
-        { code: "UNKNOWN_AUTH_SOURCE", defaultSeverity: "warning", summary: "auth.from references a component: source that does not exist" },
-        { code: "AUTH_SOURCE_NOT_PROVIDER", defaultSeverity: "warning", summary: "auth.from references a component that is not an Adapter or Store" },
-        { code: "AUTH_SOURCE_UNWIRED", defaultSeverity: "warning", summary: "The presenter declares a component: credential source it does not depend on or own" }
+        { code: "AUTH_PRESENTER_NOT_ADAPTER", defaultSeverity: "warning", summary: "A non-Adapter component authenticates an outbound call to a portal (external I/O must go through an Adapter)" }
       ],
       check(ctx) {
         for (const impl of ctx.implementations) {
@@ -10451,8 +10647,7 @@ var init_portal_call_auth = __esm({
                   draft
                 );
               }
-              const from = step.auth?.from;
-              if (!from) {
+              if (!step.auth?.from) {
                 ctx.addIssue(
                   "warning",
                   "PORTAL_AUTH_UNMET",
@@ -10460,40 +10655,73 @@ var init_portal_call_auth = __esm({
                   impl.id,
                   draft
                 );
-                continue;
               }
-              if (from.startsWith(COMPONENT_REF_PREFIX)) {
-                const srcId = from.slice(COMPONENT_REF_PREFIX.length);
-                const src = ctx.componentMap.get(srcId);
-                if (!src) {
-                  ctx.addIssue(
-                    "warning",
-                    "UNKNOWN_AUTH_SOURCE",
-                    `Narrative step ${step.stepNumber} of "${method.name}" in "${impl.id}": auth.from references component "${srcId}", which does not exist.`,
-                    impl.id,
-                    draft
-                  );
-                } else {
-                  if (src.componentType !== "Adapter" && src.componentType !== "Store") {
-                    ctx.addIssue(
-                      "warning",
-                      "AUTH_SOURCE_NOT_PROVIDER",
-                      `Narrative step ${step.stepNumber} of "${method.name}" in "${impl.id}": auth.from references "${srcId}" (${src.componentType}); a credential source must be an Adapter (loads the secret via external I/O) or a Store (holds it).`,
-                      impl.id,
-                      draft
-                    );
-                  }
-                  const wired = (presenter?.dependsOn ?? []).includes(srcId) || (presenter?.owns ?? []).includes(srcId);
-                  if (presenter && !wired) {
-                    ctx.addIssue(
-                      "warning",
-                      "AUTH_SOURCE_UNWIRED",
-                      `Narrative step ${step.stepNumber} of "${method.name}" in "${impl.id}": "${presenter.id}" loads its credential from "${srcId}" but neither depends on nor owns it \u2014 declare the dependsOn edge so the credential wiring is real.`,
-                      impl.id,
-                      draft
-                    );
-                  }
-                }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/doctrine/auth-source-wiring.ts
+var COMPONENT_REF_PREFIX, authSourceWiringRule;
+var init_auth_source_wiring = __esm({
+  "src/core/rules/doctrine/auth-source-wiring.ts"() {
+    "use strict";
+    COMPONENT_REF_PREFIX = "component:";
+    authSourceWiringRule = {
+      name: "auth-source-wiring",
+      description: "Resolves the credential source a narrative call presents to an authenticated Portal. When the step's `auth.from` is a modeled reference (`component:<id>`) it must name a component that exists (UNKNOWN_AUTH_SOURCE), that can hold or load a secret \u2014 an Adapter or a Store (AUTH_SOURCE_NOT_PROVIDER) \u2014 and that the presenting component depends on or owns (AUTH_SOURCE_UNWIRED). Opaque sources (env:/config:/vault:/free note) are design notes and are never resolved; a missing source is portal-call-auth's finding.",
+      codes: [
+        { code: "UNKNOWN_AUTH_SOURCE", defaultSeverity: "warning", summary: "auth.from references a component: source that does not exist" },
+        { code: "AUTH_SOURCE_NOT_PROVIDER", defaultSeverity: "warning", summary: "auth.from references a component that is not an Adapter or Store" },
+        { code: "AUTH_SOURCE_UNWIRED", defaultSeverity: "warning", summary: "The presenter declares a component: credential source it does not depend on or own" }
+      ],
+      check(ctx) {
+        for (const impl of ctx.implementations) {
+          const ownComponent = ctx.interfaceMap.get(impl.contract)?.component;
+          const presenter = ownComponent ? ctx.componentMap.get(ownComponent) : void 0;
+          const draft = ctx.isImplementationDraft(impl);
+          for (const method of impl.methods ?? []) {
+            for (const step of method.narrative ?? []) {
+              if (step.type !== "call") continue;
+              if (!step.targetComponent || step.targetComponent === ownComponent) continue;
+              const target = ctx.componentMap.get(step.targetComponent);
+              if (!target || target.componentType !== "Portal") continue;
+              if (!target.auth || target.auth.scheme === "none") continue;
+              const from = step.auth?.from;
+              if (!from || !from.startsWith(COMPONENT_REF_PREFIX)) continue;
+              const srcId = from.slice(COMPONENT_REF_PREFIX.length);
+              const src = ctx.componentMap.get(srcId);
+              if (!src) {
+                ctx.addIssue(
+                  "warning",
+                  "UNKNOWN_AUTH_SOURCE",
+                  `Narrative step ${step.stepNumber} of "${method.name}" in "${impl.id}": auth.from references component "${srcId}", which does not exist.`,
+                  impl.id,
+                  draft
+                );
+                continue;
+              }
+              if (src.componentType !== "Adapter" && src.componentType !== "Store") {
+                ctx.addIssue(
+                  "warning",
+                  "AUTH_SOURCE_NOT_PROVIDER",
+                  `Narrative step ${step.stepNumber} of "${method.name}" in "${impl.id}": auth.from references "${srcId}" (${src.componentType}); a credential source must be an Adapter (loads the secret via external I/O) or a Store (holds it).`,
+                  impl.id,
+                  draft
+                );
+              }
+              const wired = (presenter?.dependsOn ?? []).includes(srcId) || (presenter?.owns ?? []).includes(srcId);
+              if (presenter && !wired) {
+                ctx.addIssue(
+                  "warning",
+                  "AUTH_SOURCE_UNWIRED",
+                  `Narrative step ${step.stepNumber} of "${method.name}" in "${impl.id}": "${presenter.id}" loads its credential from "${srcId}" but neither depends on nor owns it \u2014 declare the dependsOn edge so the credential wiring is real.`,
+                  impl.id,
+                  draft
+                );
               }
             }
           }
@@ -11369,17 +11597,135 @@ var init_component_variants = __esm({
   }
 });
 
-// src/core/rules/extension/declarative-assertions.ts
+// src/core/rules/extension/declared-assertion.ts
+function assertionsOfKind(ctx, kind) {
+  return ctx.ext.assertions.filter(
+    (a) => a.kind === kind
+  );
+}
 function globToRegExp(glob) {
   const escaped = glob.replace(/[.*+?^${}()|[\]\\]/g, (ch) => ch === "*" ? ".*" : `\\${ch}`);
   return new RegExp(`^${escaped}$`);
 }
-function matches(sel, comp, ctx) {
+function matchesSelector(sel, comp, ctx) {
   if (sel.componentType?.length && !sel.componentType.includes(comp.componentType)) return false;
   if (sel.profile?.length && !sel.profile.includes(ctx.getComponentProfile(comp.id))) return false;
   if (sel.id && !globToRegExp(sel.id).test(comp.id)) return false;
   return true;
 }
+function reportAssertion(ctx, a, message, specId, isDraftCtx) {
+  const severity = isDraftCtx && a.severity === "error" ? "warning" : a.severity;
+  ctx.addIssue(severity, a.fullCode, `${message} [pack "${a.pack}"]: ${a.reason}`, specId, isDraftCtx);
+}
+var init_declared_assertion = __esm({
+  "src/core/rules/extension/declared-assertion.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/rules/extension/assertion-forbidden-edges.ts
+var assertionForbiddenEdgesRule;
+var init_assertion_forbidden_edges = __esm({
+  "src/core/rules/extension/assertion-forbidden-edges.ts"() {
+    "use strict";
+    init_declared_assertion();
+    assertionForbiddenEdgesRule = {
+      name: "assertion-forbidden-edges",
+      description: "Evaluates the `forbid-edge` assertions loaded packs declare: for every component matching the assertion's from-selector, every dependsOn/owns id whose target matches the to-selector is reported. Findings carry the pack's namespaced code (<PACK>_<CODE>) and its stated reason; severity is the pack's declaration (project sddRuleSeverity still wins, and error downgrades to warning in draft context). The codes are the packs' own, so no fixed code list applies.",
+      // Static codes are unknown here — packs bring their own. The validator
+      // gathers every loaded assertion's fullCode into knownIssueCodes.
+      codes: [],
+      check(ctx) {
+        for (const a of assertionsOfKind(ctx, "forbid-edge")) {
+          for (const comp of ctx.components) {
+            if (!matchesSelector(a.from, comp, ctx)) continue;
+            const isDraftCtx = ctx.isComponentDraft(comp.id);
+            const edges = a.relation.flatMap(
+              (relation) => comp[relation].map((targetId) => ({ relation, targetId }))
+            );
+            for (const { relation, targetId } of edges) {
+              const target = ctx.componentMap.get(targetId);
+              if (!target || !matchesSelector(a.to, target, ctx)) continue;
+              reportAssertion(
+                ctx,
+                a,
+                `Component "${comp.id}" (${comp.componentType}) ${relation === "owns" ? "owns" : "depends on"} "${target.id}" (${target.componentType}), forbidden by assertion ${a.code}`,
+                comp.id,
+                isDraftCtx
+              );
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/extension/assertion-required-fields.ts
+function fieldValue(spec, field) {
+  const segments = field.split(".");
+  if (segments[0] !== "ext") {
+    return segments.length === 1 ? spec[field] : void 0;
+  }
+  let cur = spec.ext;
+  for (const seg of segments.slice(1)) {
+    if (cur === null || typeof cur !== "object") return void 0;
+    if (!Object.prototype.hasOwnProperty.call(cur, seg)) return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+function holdersAt(ctx, level) {
+  const holders = [];
+  if (level === "component") {
+    for (const c of ctx.components) {
+      holders.push({ spec: c, specId: c.id, comp: c, draft: ctx.isComponentDraft(c.id) });
+    }
+  } else if (level === "interface") {
+    for (const i of ctx.interfaces) {
+      const comp = ctx.componentMap.get(i.component);
+      if (comp) holders.push({ spec: i, specId: i.id, comp, draft: ctx.isComponentDraft(comp.id) || i.status === "draft" || i.status === "design" });
+    }
+  } else {
+    for (const impl of ctx.implementations) {
+      const contract = ctx.interfaceMap.get(impl.contract);
+      const comp = contract ? ctx.componentMap.get(contract.component) : void 0;
+      if (comp) holders.push({ spec: impl, specId: impl.id, comp, draft: ctx.isImplementationDraft(impl) });
+    }
+  }
+  return holders;
+}
+var assertionRequiredFieldsRule;
+var init_assertion_required_fields = __esm({
+  "src/core/rules/extension/assertion-required-fields.ts"() {
+    "use strict";
+    init_declared_assertion();
+    assertionRequiredFieldsRule = {
+      name: "assertion-required-fields",
+      description: "Evaluates the `require-field` assertions loaded packs declare: at the assertion's level (component / interface / implementation), every spec whose owning component matches the on-selector must declare the named field \u2014 a top-level spec field or an `ext.*` path \u2014 and, when the assertion states a closed value set, hold one of those values. Findings carry the pack's namespaced code (<PACK>_<CODE>) and its stated reason; severity is the pack's declaration (project sddRuleSeverity still wins, and error downgrades to warning in draft context). The codes are the packs' own, so no fixed code list applies.",
+      // Static codes are unknown here — packs bring their own. The validator
+      // gathers every loaded assertion's fullCode into knownIssueCodes.
+      codes: [],
+      check(ctx) {
+        for (const a of assertionsOfKind(ctx, "require-field")) {
+          for (const h of holdersAt(ctx, a.level)) {
+            if (!matchesSelector(a.on, h.comp, ctx)) continue;
+            const v = fieldValue(h.spec, a.field);
+            if (v === void 0 || v === null) {
+              reportAssertion(ctx, a, `${a.level} spec "${h.specId}" does not declare "${a.field}", required by assertion ${a.code}`, h.specId, h.draft);
+              continue;
+            }
+            if (a.values && !a.values.includes(String(v))) {
+              reportAssertion(ctx, a, `${a.level} spec "${h.specId}" declares "${a.field}" = "${String(v)}", outside the allowed set (${a.values.join(", ")}) of assertion ${a.code}`, h.specId, h.draft);
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/extension/assertion-endpoint-shapes.ts
 function endpointAddress(ep) {
   switch (ep.transport) {
     case "HTTP":
@@ -11400,92 +11746,42 @@ function endpointAddress(ep) {
       return ep.address;
   }
 }
-function fieldValue(spec, field) {
-  const segments = field.split(".");
-  if (segments[0] !== "ext") {
-    return segments.length === 1 ? spec[field] : void 0;
-  }
-  let cur = spec.ext;
-  for (const seg of segments.slice(1)) {
-    if (cur === null || typeof cur !== "object") return void 0;
-    if (!Object.prototype.hasOwnProperty.call(cur, seg)) return void 0;
-    cur = cur[seg];
+function boundEndpoints(ctx, on) {
+  const out = [];
+  for (const intf of ctx.interfaces) {
+    const comp = ctx.componentMap.get(intf.component);
+    if (!comp || !matchesSelector(on, comp, ctx)) continue;
+    const draft = ctx.isComponentDraft(comp.id) || intf.status === "draft" || intf.status === "design";
+    for (const method of intf.methods) {
+      if (!method.endpoint) continue;
+      out.push({ intf, method, endpoint: method.endpoint, draft });
+    }
   }
-  return cur;
+  return out;
 }
-var declarativeAssertionsRule;
-var init_declarative_assertions = __esm({
-  "src/core/rules/extension/declarative-assertions.ts"() {
+var assertionEndpointShapesRule;
+var init_assertion_endpoint_shapes = __esm({
+  "src/core/rules/extension/assertion-endpoint-shapes.ts"() {
     "use strict";
-    declarativeAssertionsRule = {
-      name: "declarative-assertions",
-      description: "Evaluates the declarative rule assertions loaded packs declare (forbid-edge / require-field / endpoint-shape) \u2014 closed kinds instantiated with pack data, the hosted-safe doctrine channel. Findings carry the pack's namespaced code (<PACK>_<CODE>) and its stated reason; severity is the pack's declaration (project sddRuleSeverity still wins, and error downgrades to warning in draft context). The codes are the packs' own, so no fixed code list applies.",
+    init_declared_assertion();
+    assertionEndpointShapesRule = {
+      name: "assertion-endpoint-shapes",
+      description: "Evaluates the `endpoint-shape` assertions loaded packs declare: every endpoint bound on a contract whose component matches the on-selector must use an allowed transport and bind an address (path / topic / command / pipe / channel) matching the assertion's anchored pattern. Findings carry the pack's namespaced code (<PACK>_<CODE>) and its stated reason; severity is the pack's declaration (project sddRuleSeverity still wins, and error downgrades to warning in draft context). The codes are the packs' own, so no fixed code list applies.",
       // Static codes are unknown here — packs bring their own. The validator
       // gathers every loaded assertion's fullCode into knownIssueCodes.
       codes: [],
       check(ctx) {
-        const assertions = ctx.ext.assertions;
-        if (!assertions.length) return;
-        const emit = (a, message, specId, isDraftCtx) => {
-          const severity = isDraftCtx && a.severity === "error" ? "warning" : a.severity;
-          ctx.addIssue(severity, a.fullCode, `${message} [pack "${a.pack}"]: ${a.reason}`, specId, isDraftCtx);
-        };
-        for (const a of assertions) {
-          if (a.kind === "forbid-edge") {
-            for (const comp of ctx.components) {
-              if (!matches(a.from, comp, ctx)) continue;
-              const isDraftCtx = ctx.isComponentDraft(comp.id);
-              for (const relation of a.relation) {
-                for (const targetId of comp[relation]) {
-                  const target = ctx.componentMap.get(targetId);
-                  if (!target || !matches(a.to, target, ctx)) continue;
-                  emit(a, `Component "${comp.id}" (${comp.componentType}) ${relation === "owns" ? "owns" : "depends on"} "${target.id}" (${target.componentType}), forbidden by assertion ${a.code}`, comp.id, isDraftCtx);
-                }
-              }
-            }
-          } else if (a.kind === "require-field") {
-            const holders = [];
-            if (a.level === "component") {
-              for (const c of ctx.components) holders.push({ spec: c, specId: c.id, comp: c, draft: ctx.isComponentDraft(c.id) });
-            } else if (a.level === "interface") {
-              for (const i of ctx.interfaces) {
-                const comp = ctx.componentMap.get(i.component);
-                if (comp) holders.push({ spec: i, specId: i.id, comp, draft: ctx.isComponentDraft(comp.id) || i.status === "draft" || i.status === "design" });
-              }
-            } else {
-              for (const impl of ctx.implementations) {
-                const contract = ctx.interfaceMap.get(impl.contract);
-                const comp = contract ? ctx.componentMap.get(contract.component) : void 0;
-                if (comp) holders.push({ spec: impl, specId: impl.id, comp, draft: ctx.isImplementationDraft(impl) });
-              }
-            }
-            for (const h of holders) {
-              if (!matches(a.on, h.comp, ctx)) continue;
-              const v = fieldValue(h.spec, a.field);
-              if (v === void 0 || v === null) {
-                emit(a, `${a.level} spec "${h.specId}" does not declare "${a.field}", required by assertion ${a.code}`, h.specId, h.draft);
-              } else if (a.values && !a.values.includes(String(v))) {
-                emit(a, `${a.level} spec "${h.specId}" declares "${a.field}" = "${String(v)}", outside the allowed set (${a.values.join(", ")}) of assertion ${a.code}`, h.specId, h.draft);
-              }
+        for (const a of assertionsOfKind(ctx, "endpoint-shape")) {
+          const pattern = a.pathPattern ? new RegExp(a.pathPattern) : void 0;
+          for (const bound2 of boundEndpoints(ctx, a.on)) {
+            const { intf, method, endpoint } = bound2;
+            if (a.transport?.length && !a.transport.includes(endpoint.transport)) {
+              reportAssertion(ctx, a, `Endpoint of "${intf.id}.${method.name}" uses transport ${endpoint.transport}, outside the allowlist (${a.transport.join(", ")}) of assertion ${a.code}`, intf.id, bound2.draft);
+              continue;
             }
-          } else if (a.kind === "endpoint-shape") {
-            const pattern = a.pathPattern ? new RegExp(a.pathPattern) : void 0;
-            for (const intf of ctx.interfaces) {
-              const comp = ctx.componentMap.get(intf.component);
-              if (!comp || !matches(a.on, comp, ctx)) continue;
-              const isDraftCtx = ctx.isComponentDraft(comp.id) || intf.status === "draft" || intf.status === "design";
-              for (const method of intf.methods) {
-                if (!method.endpoint) continue;
-                const ep = method.endpoint;
-                if (a.transport?.length && !a.transport.includes(ep.transport)) {
-                  emit(a, `Endpoint of "${intf.id}.${method.name}" uses transport ${ep.transport}, outside the allowlist (${a.transport.join(", ")}) of assertion ${a.code}`, intf.id, isDraftCtx);
-                  continue;
-                }
-                const address = endpointAddress(ep);
-                if (pattern && !pattern.test(address)) {
-                  emit(a, `Endpoint of "${intf.id}.${method.name}" binds "${address}", which does not match ${a.pathPattern} required by assertion ${a.code}`, intf.id, isDraftCtx);
-                }
-              }
+            const address = endpointAddress(endpoint);
+            if (pattern && !pattern.test(address)) {
+              reportAssertion(ctx, a, `Endpoint of "${intf.id}.${method.name}" binds "${address}", which does not match ${a.pathPattern} required by assertion ${a.code}`, intf.id, bound2.draft);
             }
           }
         }
@@ -11925,16 +12221,13 @@ var reachabilityRule;
 var init_unused_detection = __esm({
   "src/core/rules/wiring/unused-detection.ts"() {
     "use strict";
-    init_models();
     init_narrative_graph_projector();
     reachabilityRule = {
       name: "unused-detection",
-      description: "Walks the narrative execution graph (call steps, register handoffs, dispatch-table routing, lifecycle flows) from every entrypoint (Portal/Observer/published component/lifecycle entrypoint/invokedBy-declared method) and flags components and methods no execution chain reaches, plus types no field or signature references. An interface method declaring invokedBy (a real caller outside the modeled graph) seeds the walk, so its narrative propagates reachability; the declaration itself is audited (thin caller prose, or a method the internal walk already reaches).",
+      description: "Walks the narrative execution graph (call steps, register handoffs, dispatch-table routing, lifecycle flows) from every entrypoint (Portal/Observer/published component/lifecycle entrypoint/invokedBy-declared method) and flags components and methods no execution chain reaches. An interface method declaring invokedBy (a real caller outside the modeled graph) seeds the walk, so its narrative propagates reachability; a declaration the INTERNAL walk (without those seeds) already reaches is stale and is reported.",
       codes: [
         { code: "UNUSED_COMPONENT", defaultSeverity: "warning", summary: "Component never reached by any narrative call chain" },
         { code: "UNUSED_METHOD", defaultSeverity: "warning", summary: "Method never called by any narrative step" },
-        { code: "UNUSED_TYPE", defaultSeverity: "warning", summary: "Type never referenced by fields or signatures" },
-        { code: "INVOKED_BY_UNDESCRIBED", defaultSeverity: "warning", summary: "invokedBy declaration whose caller prose is missing or placeholder-thin" },
         { code: "INVOKED_BY_REDUNDANT", defaultSeverity: "warning", summary: "invokedBy declaration on a method the internal narrative walk already reaches \u2014 stale, remove it" }
       ],
       check(ctx) {
@@ -11962,17 +12255,8 @@ var init_unused_detection = __esm({
             if (!m.invokedBy) continue;
             invokedBySeeds.push({ compId: intf.component, methodName: m.name });
             if (!ctx.isSpecInScope(intf.id)) continue;
-            const isDraftCtx = ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design";
-            if (!passesIntentFloor(m.invokedBy.caller, m.name)) {
-              ctx.addIssue(
-                "warning",
-                "INVOKED_BY_UNDESCRIBED",
-                `Method "${m.name}" on component "${intf.component}" declares invokedBy (${m.invokedBy.kind}) but its "caller" prose is missing or placeholder-thin \u2014 state WHO invokes it and when, so the entrypoint claim stays reviewable.`,
-                intf.id,
-                isDraftCtx
-              );
-            }
             if (baseWalk.reachesMethod(intf.component, m.name)) {
+              const isDraftCtx = ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design";
               ctx.addIssue(
                 "warning",
                 "INVOKED_BY_REDUNDANT",
@@ -11995,23 +12279,75 @@ var init_unused_detection = __esm({
               comp.id,
               isDraftCtx
             );
-          } else {
-            for (const intf of ctx.interfacesByComponent.get(comp.id) ?? []) {
-              for (const m of intf.methods) {
-                if (!reach.reachesMethod(comp.id, m.name)) {
-                  const isDraftCtx = ctx.isComponentDraft(comp.id) || intf.status === "draft" || intf.status === "design";
-                  ctx.addIssue(
-                    "warning",
-                    "UNUSED_METHOD",
-                    `Method "${m.name}" on component "${comp.id}" is defined but never called by any narrative step.`,
-                    intf.id,
-                    isDraftCtx
-                  );
-                }
+            continue;
+          }
+          for (const intf of ctx.interfacesByComponent.get(comp.id) ?? []) {
+            for (const m of intf.methods) {
+              if (!reach.reachesMethod(comp.id, m.name)) {
+                const isDraftCtx = ctx.isComponentDraft(comp.id) || intf.status === "draft" || intf.status === "design";
+                ctx.addIssue(
+                  "warning",
+                  "UNUSED_METHOD",
+                  `Method "${m.name}" on component "${comp.id}" is defined but never called by any narrative step.`,
+                  intf.id,
+                  isDraftCtx
+                );
               }
             }
           }
         }
+      }
+    };
+  }
+});
+
+// src/core/rules/wiring/invoked-by-description.ts
+var invokedByDescriptionRule;
+var init_invoked_by_description = __esm({
+  "src/core/rules/wiring/invoked-by-description.ts"() {
+    "use strict";
+    init_models();
+    invokedByDescriptionRule = {
+      name: "invoked-by-description",
+      description: 'An invokedBy declaration names a caller outside the modeled graph and silences unused-detection for its method, so the claim must stay reviewable: its "caller" prose is held to the intent floor (missing or placeholder-thin prose is reported), stating WHO invokes the method and when.',
+      codes: [
+        { code: "INVOKED_BY_UNDESCRIBED", defaultSeverity: "warning", summary: "invokedBy declaration whose caller prose is missing or placeholder-thin" }
+      ],
+      check(ctx) {
+        for (const intf of ctx.interfaces) {
+          if (!ctx.componentMap.has(intf.component)) continue;
+          if (!ctx.isSpecInScope(intf.id)) continue;
+          for (const m of intf.methods) {
+            if (!m.invokedBy) continue;
+            if (passesIntentFloor(m.invokedBy.caller, m.name)) continue;
+            const isDraftCtx = ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design";
+            ctx.addIssue(
+              "warning",
+              "INVOKED_BY_UNDESCRIBED",
+              `Method "${m.name}" on component "${intf.component}" declares invokedBy (${m.invokedBy.kind}) but its "caller" prose is missing or placeholder-thin \u2014 state WHO invokes it and when, so the entrypoint claim stays reviewable.`,
+              intf.id,
+              isDraftCtx
+            );
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/wiring/unused-types.ts
+var unusedTypesRule;
+var init_unused_types = __esm({
+  "src/core/rules/wiring/unused-types.ts"() {
+    "use strict";
+    init_models();
+    unusedTypesRule = {
+      name: "unused-types",
+      description: "Flags types no field of any type and no interface method signature references. References are matched through the type-reference grammar (generic arguments, collections, qualified ids), and the declaring type's own generic parameters are left out \u2014 a type parameter is not a reference to a type.",
+      codes: [
+        { code: "UNUSED_TYPE", defaultSeverity: "warning", summary: "Type never referenced by fields or signatures" }
+      ],
+      check(ctx) {
         const referencedTypes = /* @__PURE__ */ new Set();
         const markTypeReferenced = (ref) => {
           if (ctx.isBuiltinType(ref)) return;
@@ -12245,7 +12581,44 @@ var init_prose_claims = __esm({
   }
 });
 
-// src/core/rules/wiring/invariant-backing.ts
+// src/core/rules/wiring/unique-invariant-ids.ts
+var uniqueInvariantIdsRule;
+var init_unique_invariant_ids = __esm({
+  "src/core/rules/wiring/unique-invariant-ids.ts"() {
+    "use strict";
+    init_models();
+    uniqueInvariantIdsRule = {
+      name: "unique-invariant-ids",
+      description: `An entity's declared invariant ids must be unique within the entity: a narrative step asserts an invariant by "<type-id>.<invariant-id>", so a repeated id makes one assertion stand for two properties and satisfying either silences both.`,
+      codes: [
+        { code: "DUPLICATE_INVARIANT_ID", defaultSeverity: "error", summary: "An entity declares two invariants with the same id" }
+      ],
+      check(ctx) {
+        for (const t of ctx.types) {
+          const invariants = t.invariants ?? [];
+          if (invariants.length === 0) continue;
+          const sub = t.subsystem ? ctx.subsystems.find((s) => s.id === t.subsystem) : void 0;
+          const entityDraft = sub !== void 0 && isDraftSubsystem(sub);
+          const seen = /* @__PURE__ */ new Set();
+          for (const inv of invariants) {
+            if (seen.has(inv.id)) {
+              ctx.addIssue(
+                "error",
+                "DUPLICATE_INVARIANT_ID",
+                `Entity "${t.id}" declares invariant id "${inv.id}" more than once \u2014 invariant ids must be unique within the entity.`,
+                t.id,
+                entityDraft
+              );
+            }
+            seen.add(inv.id);
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/wiring/invariant-ref.ts
 function splitInvariantRef(ref) {
   const at = ref.lastIndexOf(".");
   if (at <= 0 || at === ref.length - 1) return null;
@@ -12269,6 +12642,14 @@ function refMatchesInvariant(ref, type, invariantId) {
   if (!(type.invariants ?? []).some((inv) => inv.id === invariantId)) return false;
   return typeMatchesRef(type, parts.typeRef);
 }
+var init_invariant_ref = __esm({
+  "src/core/rules/wiring/invariant-ref.ts"() {
+    "use strict";
+    init_models();
+  }
+});
+
+// src/core/rules/wiring/invariant-backing.ts
 function stepAsserts(impl, methodName, type, invariantId) {
   const method = impl.methods.find((m) => m.name === methodName);
   if (!method) return false;
@@ -12293,33 +12674,19 @@ var init_invariant_backing = __esm({
   "src/core/rules/wiring/invariant-backing.ts"() {
     "use strict";
     init_models();
+    init_invariant_ref();
     invariantBackingRule = {
       name: "invariant-backing",
-      description: 'The invariant registry: entities may declare domain invariants (type.invariants), anchored through their componentClass. Every write-effect contract method of the owning component must carry a narrative step asserting each invariant (step.assertsInvariants: "<type-id>.<invariant-id>") \u2014 the same declared-and-backed shape as semantic guarantees. This is an HONEST lint over declarations: a green run means every write path visibly claims the invariant, never that the narrative or code actually enforces it. An invariant with no resolvable owner or no declared write path is unanchored; dangling assertion references are errors.',
+      description: 'The invariant registry: entities may declare domain invariants (type.invariants), anchored through their componentClass. Every write-effect contract method of the owning component must carry a narrative step asserting each invariant (step.assertsInvariants: "<type-id>.<invariant-id>") \u2014 the same declared-and-backed shape as semantic guarantees. This is an HONEST lint over declarations: a green run means every write path visibly claims the invariant, never that the narrative or code actually enforces it. An invariant with no resolvable owner or no declared write path is unanchored, and nothing further is claimed about it.',
       codes: [
-        { code: "DUPLICATE_INVARIANT_ID", defaultSeverity: "error", summary: "An entity declares two invariants with the same id" },
         { code: "INVARIANT_UNANCHORED", defaultSeverity: "warning", summary: "An entity declares invariants but has no componentClass, its componentClass does not resolve, or the owning component declares no write-effect contract methods" },
-        { code: "UNASSERTED_INVARIANT", defaultSeverity: "warning", summary: "A write-effect method of the invariant's owning component has no narrative step asserting it" },
-        { code: "UNKNOWN_INVARIANT_REF", defaultSeverity: "error", summary: "A narrative step asserts an invariant that no entity declares" }
+        { code: "UNASSERTED_INVARIANT", defaultSeverity: "warning", summary: "A write-effect method of the invariant's owning component has no narrative step asserting it" }
       ],
       check(ctx) {
         for (const t of ctx.types) {
           const invariants = t.invariants ?? [];
           if (invariants.length === 0) continue;
           const entityDraft = isEntityDraft(t, ctx);
-          const seen = /* @__PURE__ */ new Set();
-          for (const inv of invariants) {
-            if (seen.has(inv.id)) {
-              ctx.addIssue(
-                "error",
-                "DUPLICATE_INVARIANT_ID",
-                `Entity "${t.id}" declares invariant id "${inv.id}" more than once \u2014 invariant ids must be unique within the entity.`,
-                t.id,
-                entityDraft
-              );
-            }
-            seen.add(inv.id);
-          }
           const comp = resolveComponentClass(t, ctx);
           if (!comp) {
             ctx.addIssue(
@@ -12361,6 +12728,24 @@ var init_invariant_backing = __esm({
             }
           }
         }
+      }
+    };
+  }
+});
+
+// src/core/rules/wiring/invariant-references.ts
+var invariantReferencesRule;
+var init_invariant_references = __esm({
+  "src/core/rules/wiring/invariant-references.ts"() {
+    "use strict";
+    init_invariant_ref();
+    invariantReferencesRule = {
+      name: "invariant-references",
+      description: "Every invariant a narrative step asserts (step.assertsInvariants) must resolve to a declared entity invariant: the reference splits at its last dot into a type reference and an invariant id, and some entity matching that type reference must declare that id. A reference nothing declares is an error \u2014 the step claims a property that exists nowhere.",
+      codes: [
+        { code: "UNKNOWN_INVARIANT_REF", defaultSeverity: "error", summary: "A narrative step asserts an invariant that no entity declares" }
+      ],
+      check(ctx) {
         for (const impl of ctx.implementations) {
           const isDraftCtx = ctx.isImplementationDraft(impl);
           for (const method of impl.methods) {
@@ -12692,54 +13077,45 @@ var init_call_conformance = __esm({
       ],
       check(ctx) {
         const code = ctx.codeIndex();
-        for (const impl of ctx.implementations) {
-          const contract = ctx.interfaceMap.get(impl.contract);
-          if (!contract) continue;
-          const component = ctx.componentMap.get(contract.component);
-          if (!component) continue;
-          if (ctx.isInChainedSubproject(component.subsystem)) continue;
-          const specTier = impl.conformance ?? defaultConformanceTier(component);
-          const isDraftCtx = ctx.isImplementationDraft(impl);
-          for (const implMethod of impl.methods) {
-            const tier = implMethod.conformance ?? specTier;
-            if (tier === "off") continue;
-            if (!implMethod.narrative.length) continue;
-            const file = methodSourceFile(implMethod, impl.sourcePath);
-            if (!file) continue;
-            const facts = code.factsAt(file);
-            if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
-            const fnSymbol = implMethod.symbol ?? implMethod.name;
-            const callees = closedCallees(facts, fnSymbol);
-            if (!callees) continue;
-            const missing = [];
-            for (const step of implMethod.narrative) {
-              if (step.type !== "call" || !step.targetComponent || !step.targetMethod) continue;
-              if (!ctx.componentMap.has(step.targetComponent)) continue;
-              const accepted = /* @__PURE__ */ new Set([step.targetMethod]);
-              for (const targetIntf of ctx.interfacesByComponent.get(step.targetComponent) ?? []) {
-                for (const targetImpl of ctx.implementationsByContract.get(targetIntf.id) ?? []) {
-                  const targetMethod = targetImpl.methods.find((m) => m.name === step.targetMethod);
-                  if (targetMethod?.symbol) accepted.add(targetMethod.symbol);
-                }
+        for (const entry of ctx.implementationMethods()) {
+          const { implementation: impl, method: implMethod, component, sourceFile: file } = entry;
+          const tier = implMethod.conformance ?? impl.conformance ?? defaultConformanceTier(component);
+          if (tier === "off") continue;
+          if (!implMethod.narrative.length) continue;
+          if (!file) continue;
+          const facts = code.factsAt(file);
+          if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
+          const fnSymbol = implMethod.symbol ?? implMethod.name;
+          const callees = closedCallees(facts, fnSymbol);
+          if (!callees) continue;
+          const missing = [];
+          for (const step of implMethod.narrative) {
+            if (step.type !== "call" || !step.targetComponent || !step.targetMethod) continue;
+            if (!ctx.componentMap.has(step.targetComponent)) continue;
+            const accepted = /* @__PURE__ */ new Set([step.targetMethod]);
+            for (const targetIntf of ctx.interfacesByComponent.get(step.targetComponent) ?? []) {
+              for (const targetImpl of ctx.implementationsByContract.get(targetIntf.id) ?? []) {
+                const targetMethod = targetImpl.methods.find((m) => m.name === step.targetMethod);
+                if (targetMethod?.symbol) accepted.add(targetMethod.symbol);
               }
-              if (accepted.has(fnSymbol)) continue;
-              if ([...accepted].some((name) => callees.has(name))) continue;
-              missing.push({
-                step: step.stepNumber,
-                target: `${step.targetComponent}.${step.targetMethod}`,
-                accepted: [...accepted]
-              });
             }
-            if (missing.length === 0) continue;
-            const detail = missing.map((m) => `step ${m.step} \u2192 ${m.target} (looked for ${m.accepted.map((a) => `"${a}"`).join(" / ")})`).join("; ");
-            ctx.addIssue(
-              "warning",
-              "CALL_STEP_UNREALIZED",
-              `Method "${implMethod.name}" in implementation "${impl.id}": ${missing.length} narrative call step(s) are not realized as calls of the function "${fnSymbol}" in "${file}" \u2014 ${detail}. Callees are matched by name, closed over same-file helpers (exact grade, set membership \u2014 order and arguments are not checked). Realize the calls, fix the narrative, or map code names via per-method symbols on the targets.`,
-              impl.id,
-              isDraftCtx
-            );
+            if (accepted.has(fnSymbol)) continue;
+            if ([...accepted].some((name) => callees.has(name))) continue;
+            missing.push({
+              step: step.stepNumber,
+              target: `${step.targetComponent}.${step.targetMethod}`,
+              accepted: [...accepted]
+            });
           }
+          if (missing.length === 0) continue;
+          const detail = missing.map((m) => `step ${m.step} \u2192 ${m.target} (looked for ${m.accepted.map((a) => `"${a}"`).join(" / ")})`).join("; ");
+          ctx.addIssue(
+            "warning",
+            "CALL_STEP_UNREALIZED",
+            `Method "${implMethod.name}" in implementation "${impl.id}": ${missing.length} narrative call step(s) are not realized as calls of the function "${fnSymbol}" in "${file}" \u2014 ${detail}. Callees are matched by name, closed over same-file helpers (exact grade, set membership \u2014 order and arguments are not checked). Realize the calls, fix the narrative, or map code names via per-method symbols on the targets.`,
+            impl.id,
+            entry.draftContext
+          );
         }
       }
     };
@@ -12906,20 +13282,95 @@ var init_dependency_conformance = __esm({
   }
 });
 
-// src/core/rules/conformance/integration-conformance.ts
-var integrationConformanceRule;
-var init_integration_conformance = __esm({
-  "src/core/rules/conformance/integration-conformance.ts"() {
+// src/core/rules/conformance/integration-sim-declaration.ts
+var integrationSimDeclarationRule;
+var init_integration_sim_declaration = __esm({
+  "src/core/rules/conformance/integration-sim-declaration.ts"() {
+    "use strict";
+    integrationSimDeclarationRule = {
+      name: "integration-sim-declaration",
+      description: "Once a subsystem has adopted integration sims (its first declared L4 simPath), every OTHER complete, non-leaf implementation of that subsystem must declare one too: its unit suite proves contract shape against mocks, not that the wired components run together. A leaf component's unit suite IS its sim, and a subsystem that has adopted nothing is never flooded.",
+      codes: [
+        { code: "MISSING_INTEGRATION_SIM", defaultSeverity: "warning", summary: "Complete non-leaf implementation in a sim-adopting subsystem declares no simPath" }
+      ],
+      check(ctx) {
+        const adopted = /* @__PURE__ */ new Set();
+        for (const impl of ctx.implementations) {
+          if (!impl.simPath) continue;
+          const contract = ctx.interfaceMap.get(impl.contract);
+          const comp = contract ? ctx.componentMap.get(contract.component) : void 0;
+          if (!comp || ctx.isInChainedSubproject(comp.subsystem)) continue;
+          adopted.add(comp.subsystem);
+        }
+        for (const impl of ctx.implementations) {
+          if (impl.simPath) continue;
+          const contract = ctx.interfaceMap.get(impl.contract);
+          const comp = contract ? ctx.componentMap.get(contract.component) : void 0;
+          if (!comp) continue;
+          if (ctx.isInChainedSubproject(comp.subsystem)) continue;
+          if (!adopted.has(comp.subsystem)) continue;
+          if (ctx.isImplementationDraft(impl)) continue;
+          const deps = [.../* @__PURE__ */ new Set([...comp.dependsOn, ...comp.owns])].filter((d) => ctx.componentMap.has(d));
+          if (deps.length === 0) continue;
+          ctx.addIssue(
+            "warning",
+            "MISSING_INTEGRATION_SIM",
+            `Implementation "${impl.id}" (component "${comp.id}") is complete with ${deps.length} declared dependenc${deps.length === 1 ? "y" : "ies"}, its subsystem "${comp.subsystem}" has adopted integration sims, but it declares no simPath \u2014 its unit suite proves contract shape against mocks, not that the wired components run together. Declare the committed harness that constructs it with its REAL dependencies (N:1 sharing allowed), or lint.allow with the reason.`,
+            impl.id
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/conformance/integration-sim-file.ts
+var integrationSimFileRule;
+var init_integration_sim_file = __esm({
+  "src/core/rules/conformance/integration-sim-file.ts"() {
     "use strict";
     init_models();
-    integrationConformanceRule = {
-      name: "integration-conformance",
-      description: "A component cannot honestly claim completeness until a committed integration harness wires it to its REAL dependencies (L4 simPath). Statically checked: the harness file exists inside the project root, and its import graph \u2014 closed transitively over the analyzed module set, exact grade only \u2014 reaches at least one of the component's own source modules (its implementation's or a method's) and at least one source module of each direct dependsOn/owns component (technology-boundary dependencies exempt: their fakes are sanctioned). Execution is CI's job \u2014 these findings prove wiring, never that the sim passes. MISSING_INTEGRATION_SIM activates per subsystem once its first simPath is declared.",
+    integrationSimFileRule = {
+      name: "integration-sim-file",
+      description: "A declared L4 simPath must resolve to a readable, committed file inside the project root \u2014 the integration harness is a re-runnable file, not a claim. Execution stays CI's job.",
       codes: [
-        { code: "MISSING_INTEGRATION_SIM", defaultSeverity: "warning", summary: "Complete non-leaf implementation in a sim-adopting subsystem declares no simPath" },
-        { code: "SIM_FILE_MISSING", defaultSeverity: "warning", summary: "Declared simPath resolves to no file inside the project root" },
-        { code: "UNWIRED_INTEGRATION_SIM", defaultSeverity: "warning", summary: "Sim file does not import the real modules it claims to wire" },
-        { code: "SIM_PATH_UNCOVERED", defaultSeverity: "warning", summary: "A narrative path has no sim:<component>.<method>[:<label>] anchor in the component's coverage-opted harness" }
+        { code: "SIM_FILE_MISSING", defaultSeverity: "warning", summary: "Declared simPath resolves to no file inside the project root" }
+      ],
+      check(ctx) {
+        const code = ctx.codeIndex();
+        for (const impl of ctx.implementations) {
+          if (!impl.simPath) continue;
+          const contract = ctx.interfaceMap.get(impl.contract);
+          const comp = contract ? ctx.componentMap.get(contract.component) : void 0;
+          if (!comp) continue;
+          if (ctx.isInChainedSubproject(comp.subsystem)) continue;
+          const facts = code.factsAt(pathKey(impl.simPath));
+          if (facts && facts.status === "analyzed") continue;
+          const why = !facts || facts.status === "missing" ? "resolves to no file" : facts.status === "escaped" ? "escapes the project root \u2014 sims are project-relative, committed files" : "is not readable as source text";
+          ctx.addIssue(
+            "warning",
+            "SIM_FILE_MISSING",
+            `Implementation "${impl.id}" declares simPath "${impl.simPath}", which ${why}. The integration harness must be a committed, re-runnable file inside the project.`,
+            impl.id,
+            ctx.isImplementationDraft(impl)
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/conformance/integration-sim-wiring.ts
+var integrationSimWiringRule;
+var init_integration_sim_wiring = __esm({
+  "src/core/rules/conformance/integration-sim-wiring.ts"() {
+    "use strict";
+    init_models();
+    integrationSimWiringRule = {
+      name: "integration-sim-wiring",
+      description: "A committed integration harness's import graph \u2014 closed transitively over the analyzed module set, exact grade only \u2014 must reach at least one of the component's own source modules (its implementation's or a method's) and at least one source module of each direct dependsOn/owns component (technology-boundary dependencies exempt: their contract-faithful fakes are sanctioned). Execution is CI's job \u2014 this proves wiring, never that the sim passes.",
+      codes: [
+        { code: "UNWIRED_INTEGRATION_SIM", defaultSeverity: "warning", summary: "Sim file does not import the real modules it claims to wire" }
       ],
       check(ctx) {
         const code = ctx.codeIndex();
@@ -12931,48 +13382,18 @@ var init_integration_conformance = __esm({
         };
         const modulesOf = (compId) => realization.filesOf(compId).filter(exists);
         const modulesIn = (subsystemId) => realization.filesIn(subsystemId).filter(exists);
-        const adopted = /* @__PURE__ */ new Set();
-        for (const impl of ctx.implementations) {
-          if (!impl.simPath) continue;
-          const contract = ctx.interfaceMap.get(impl.contract);
-          const comp = contract ? ctx.componentMap.get(contract.component) : void 0;
-          if (!comp || ctx.isInChainedSubproject(comp.subsystem)) continue;
-          adopted.add(comp.subsystem);
-        }
         const isTechBoundary = (compId) => realization.implementationsOf(compId).some((i) => (i.technologies ?? []).length > 0);
         for (const impl of ctx.implementations) {
+          if (!impl.simPath) continue;
           const contract = ctx.interfaceMap.get(impl.contract);
           const comp = contract ? ctx.componentMap.get(contract.component) : void 0;
           if (!comp) continue;
           if (ctx.isInChainedSubproject(comp.subsystem)) continue;
-          const deps = [.../* @__PURE__ */ new Set([...comp.dependsOn, ...comp.owns])].filter((d) => ctx.componentMap.has(d));
-          if (!impl.simPath) {
-            if (!adopted.has(comp.subsystem)) continue;
-            if (ctx.isImplementationDraft(impl)) continue;
-            if (deps.length === 0) continue;
-            ctx.addIssue(
-              "warning",
-              "MISSING_INTEGRATION_SIM",
-              `Implementation "${impl.id}" (component "${comp.id}") is complete with ${deps.length} declared dependenc${deps.length === 1 ? "y" : "ies"}, its subsystem "${comp.subsystem}" has adopted integration sims, but it declares no simPath \u2014 its unit suite proves contract shape against mocks, not that the wired components run together. Declare the committed harness that constructs it with its REAL dependencies (N:1 sharing allowed), or lint.allow with the reason.`,
-              impl.id
-            );
-            continue;
-          }
           const simPath = pathKey(impl.simPath);
           const facts = code.factsAt(simPath);
-          const isDraftCtx = ctx.isImplementationDraft(impl);
-          if (!facts || facts.status === "missing" || facts.status === "escaped" || facts.status === "unreadable") {
-            const why = !facts || facts.status === "missing" ? "resolves to no file" : facts.status === "escaped" ? "escapes the project root \u2014 sims are project-relative, committed files" : "is not readable as source text";
-            ctx.addIssue(
-              "warning",
-              "SIM_FILE_MISSING",
-              `Implementation "${impl.id}" declares simPath "${impl.simPath}", which ${why}. The integration harness must be a committed, re-runnable file inside the project.`,
-              impl.id,
-              isDraftCtx
-            );
-            continue;
-          }
+          if (!facts || facts.status !== "analyzed") continue;
           if (facts.analysisGrade !== "exact") continue;
+          const deps = [.../* @__PURE__ */ new Set([...comp.dependsOn, ...comp.owns])].filter((d) => ctx.componentMap.has(d));
           const reach = graph.reachFrom(simPath);
           const ownFiles = modulesOf(comp.id);
           const missing = [];
@@ -12989,15 +13410,43 @@ var init_integration_conformance = __esm({
               missing.push(label);
             }
           }
-          if (missing.length) {
-            ctx.addIssue(
-              "warning",
-              "UNWIRED_INTEGRATION_SIM",
-              `Sim "${impl.simPath}" of implementation "${impl.id}" does not reach ${missing.join(", nor ")} through its import graph (closed over the analyzed modules, exact grade) \u2014 the harness is not wiring the real implementations it claims to exercise. Import the real modules (technology-boundary adapters may stay contract-faithfully faked), or fix the simPath.`,
-              impl.id,
-              isDraftCtx
-            );
-          }
+          if (missing.length === 0) continue;
+          ctx.addIssue(
+            "warning",
+            "UNWIRED_INTEGRATION_SIM",
+            `Sim "${impl.simPath}" of implementation "${impl.id}" does not reach ${missing.join(", nor ")} through its import graph (closed over the analyzed modules, exact grade) \u2014 the harness is not wiring the real implementations it claims to exercise. Import the real modules (technology-boundary adapters may stay contract-faithfully faked), or fix the simPath.`,
+            impl.id,
+            ctx.isImplementationDraft(impl)
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/conformance/integration-sim-coverage.ts
+var integrationSimCoverageRule;
+var init_integration_sim_coverage = __esm({
+  "src/core/rules/conformance/integration-sim-coverage.ts"() {
+    "use strict";
+    init_models();
+    integrationSimCoverageRule = {
+      name: "integration-sim-coverage",
+      description: "Once a committed integration harness carries sim:<component-id>. anchors, that component claims path coverage: every narrated method's happy path and every labeled throw step needs its exact sim:<component>.<method>[:<label>] string-literal anchor. Anchors prove the path is NAMED \u2014 assertion quality and execution stay CI's job.",
+      codes: [
+        { code: "SIM_PATH_UNCOVERED", defaultSeverity: "warning", summary: "A narrative path has no sim:<component>.<method>[:<label>] anchor in the component's coverage-opted harness" }
+      ],
+      check(ctx) {
+        const code = ctx.codeIndex();
+        for (const impl of ctx.implementations) {
+          if (!impl.simPath) continue;
+          const contract = ctx.interfaceMap.get(impl.contract);
+          const comp = contract ? ctx.componentMap.get(contract.component) : void 0;
+          if (!comp) continue;
+          if (ctx.isInChainedSubproject(comp.subsystem)) continue;
+          const facts = code.factsAt(pathKey(impl.simPath));
+          if (!facts || facts.status !== "analyzed") continue;
+          if (facts.analysisGrade !== "exact") continue;
           const simAnchors = new Set(facts.anchoredNames.filter((a) => a.startsWith("sim:")));
           if (simAnchors.size === 0) continue;
           const compPrefix = `sim:${comp.id}.`;
@@ -13018,15 +13467,14 @@ var init_integration_conformance = __esm({
               }
             }
           }
-          if (uncovered.length) {
-            ctx.addIssue(
-              "warning",
-              "SIM_PATH_UNCOVERED",
-              `Sim "${impl.simPath}" declares path coverage for component "${comp.id}" (it carries sim: anchors) but does not name ${uncovered.join(", nor ")}. Drive the path and anchor it with the exact string literal, or drop the component's sim: anchors to withdraw the coverage claim. Unlabeled throw steps are not expected \u2014 a step's label is the path's identity. Anchors prove the path is NAMED; assertion quality and execution stay CI's job.`,
-              impl.id,
-              isDraftCtx
-            );
-          }
+          if (uncovered.length === 0) continue;
+          ctx.addIssue(
+            "warning",
+            "SIM_PATH_UNCOVERED",
+            `Sim "${impl.simPath}" declares path coverage for component "${comp.id}" (it carries sim: anchors) but does not name ${uncovered.join(", nor ")}. Drive the path and anchor it with the exact string literal, or drop the component's sim: anchors to withdraw the coverage claim. Unlabeled throw steps are not expected \u2014 a step's label is the path's identity. Anchors prove the path is NAMED; assertion quality and execution stay CI's job.`,
+            impl.id,
+            ctx.isImplementationDraft(impl)
+          );
         }
       }
     };
@@ -13136,10 +13584,10 @@ var init_coupling_health = __esm({
   }
 });
 
-// src/core/rules/heuristic/target-language.ts
-var LANGUAGE_MARKERS, UNSUPPORTED_FLOW, languageRule;
-var init_target_language = __esm({
-  "src/core/rules/heuristic/target-language.ts"() {
+// src/core/rules/heuristic/signature-language-builtins.ts
+var LANGUAGE_MARKERS, signatureLanguageBuiltinsRule;
+var init_signature_language_builtins = __esm({
+  "src/core/rules/heuristic/signature-language-builtins.ts"() {
     "use strict";
     init_models();
     LANGUAGE_MARKERS = {
@@ -13174,6 +13622,68 @@ var init_target_language = __esm({
       csharp: /* @__PURE__ */ new Set(["task"]),
       go: /* @__PURE__ */ new Set(["chan", "rune"])
     };
+    signatureLanguageBuiltinsRule = {
+      name: "signature-language-builtins",
+      description: "Contracts must speak the declared target language: builtin types that unambiguously belong to another language family are flagged in method signatures (e.g. `usize` in a TypeScript system, `Promise` in a Rust one). Set targetLanguage on the system (L0) or override per subsystem (L1).",
+      codes: [
+        { code: "LANGUAGE_FOREIGN_BUILTIN", defaultSeverity: "warning", summary: "Signature uses a builtin from a different language family" }
+      ],
+      check(ctx) {
+        const markersFor = (family) => {
+          const base = LANGUAGE_MARKERS[family];
+          const extra = ctx.ext.languages[family]?.foreignBuiltins;
+          if (!extra?.length) return base;
+          return /* @__PURE__ */ new Set([...base ?? [], ...extra.map((s) => s.toLowerCase())]);
+        };
+        const families = [.../* @__PURE__ */ new Set([...Object.keys(LANGUAGE_MARKERS), ...Object.keys(ctx.ext.languages)])];
+        const scans = [];
+        for (const intf of ctx.interfaces) {
+          const comp = ctx.componentMap.get(intf.component);
+          const lang = ctx.targetLanguageFor(comp?.subsystem);
+          if (!lang) continue;
+          const ownMarkers = markersFor(lang);
+          if (!ownMarkers || ownMarkers.size === 0) continue;
+          const draft = ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design";
+          for (const method of intf.methods) {
+            for (const ref of methodTypeRefs(method)) scans.push({ intf, method, ref, lang, ownMarkers, draft });
+          }
+        }
+        for (const scan of scans) {
+          const refLower = scan.ref.toLowerCase();
+          if (scan.ownMarkers.has(refLower)) continue;
+          const foreign = families.find((family) => family !== scan.lang && markersFor(family)?.has(refLower));
+          if (!foreign) continue;
+          ctx.addIssue(
+            "warning",
+            "LANGUAGE_FOREIGN_BUILTIN",
+            `Method "${scan.method.name}" on interface "${scan.intf.id}" uses "${scan.ref}", a ${foreign} builtin, but the target language here is ${scan.lang}. Use the ${scan.lang} equivalent so implementers generate idiomatic code.`,
+            scan.intf.id,
+            scan.draft
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/heuristic/narrative-language-constructs.ts
+function constructsOf(step) {
+  const constructs = [
+    step.type === "loop" ? step.loopKind ?? (step.over ? "forEach" : "while") : step.type
+  ];
+  if (step.detach) constructs.push("detach");
+  return constructs;
+}
+function constructLabel(construct) {
+  if (construct === "doWhile") return "a do-while loop";
+  if (construct === "forEach" || construct === "for" || construct === "while") return `a ${construct} loop`;
+  if (construct === "detach") return "a detached (fire-and-forget) call";
+  return `a ${construct} step`;
+}
+var UNSUPPORTED_FLOW, narrativeLanguageConstructsRule;
+var init_narrative_language_constructs = __esm({
+  "src/core/rules/heuristic/narrative-language-constructs.ts"() {
+    "use strict";
     UNSUPPORTED_FLOW = {
       rust: {
         try: "Rust models errors as values (Result + ?) \u2014 specify the guarded logic as explicit error branches, or note the Result mapping in the step description",
@@ -13193,53 +13703,18 @@ var init_target_language = __esm({
         doWhile: "Python has no do-while \u2014 prefer loopKind: while, or state the emulation (while True + break)"
       }
     };
-    languageRule = {
-      name: "target-language",
-      description: "Contracts must speak the declared target language: builtin types that unambiguously belong to another language family are flagged in method signatures, and narrative flow steps using constructs the language lacks (e.g. exceptions in Rust/Go, do-while in Python) are flagged too. Set targetLanguage on the system (L0) or override per subsystem (L1).",
+    narrativeLanguageConstructsRule = {
+      name: "narrative-language-constructs",
+      description: "Narratives must describe flows the declared target language can express: steps using constructs the language lacks (e.g. exceptions in Rust/Go, do-while in Python) are flagged with the idiomatic alternative. Set targetLanguage on the system (L0) or override per subsystem (L1).",
       codes: [
-        { code: "LANGUAGE_FOREIGN_BUILTIN", defaultSeverity: "warning", summary: "Signature uses a builtin from a different language family" },
         { code: "LANGUAGE_FOREIGN_FLOW", defaultSeverity: "warning", summary: "Narrative flow step uses a construct the target language does not have" }
       ],
       check(ctx) {
-        const markersFor = (family) => {
-          const base = LANGUAGE_MARKERS[family];
-          const extra = ctx.ext.languages[family]?.foreignBuiltins;
-          if (!extra?.length) return base;
-          return /* @__PURE__ */ new Set([...base ?? [], ...extra.map((s) => s.toLowerCase())]);
-        };
-        const families = /* @__PURE__ */ new Set([...Object.keys(LANGUAGE_MARKERS), ...Object.keys(ctx.ext.languages)]);
         const gapsFor = (lang) => ({
           ...UNSUPPORTED_FLOW[lang] ?? {},
           ...ctx.ext.languages[lang]?.unsupportedFlow ?? {}
         });
-        for (const intf of ctx.interfaces) {
-          const comp = ctx.componentMap.get(intf.component);
-          const lang = ctx.targetLanguageFor(comp?.subsystem);
-          if (!lang) continue;
-          const ownMarkers = markersFor(lang);
-          if (!ownMarkers || ownMarkers.size === 0) continue;
-          const isDraftCtx = ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design";
-          for (const m of intf.methods) {
-            const refs = methodTypeRefs(m);
-            for (const ref of refs) {
-              const refLower = ref.toLowerCase();
-              if (ownMarkers.has(refLower)) continue;
-              for (const family of families) {
-                if (family === lang) continue;
-                if (markersFor(family)?.has(refLower)) {
-                  ctx.addIssue(
-                    "warning",
-                    "LANGUAGE_FOREIGN_BUILTIN",
-                    `Method "${m.name}" on interface "${intf.id}" uses "${ref}", a ${family} builtin, but the target language here is ${lang}. Use the ${lang} equivalent so implementers generate idiomatic code.`,
-                    intf.id,
-                    isDraftCtx
-                  );
-                  break;
-                }
-              }
-            }
-          }
-        }
+        const scans = [];
         for (const impl of ctx.implementations) {
           const contract = ctx.interfaceMap.get(impl.contract);
           if (!contract) continue;
@@ -13248,28 +13723,54 @@ var init_target_language = __esm({
           if (!lang) continue;
           const gaps = gapsFor(lang);
           if (Object.keys(gaps).length === 0) continue;
-          const isDraftCtx = ctx.isImplementationDraft(impl);
-          for (const implMethod of impl.methods) {
-            for (const step of implMethod.narrative) {
-              const constructs = [
-                step.type === "loop" ? step.loopKind ?? (step.over ? "forEach" : "while") : step.type
-              ];
-              if (step.detach) constructs.push("detach");
-              for (const construct of constructs) {
-                const guidance = gaps[construct];
-                if (!guidance) continue;
-                const label = construct === "doWhile" ? "a do-while loop" : construct === "forEach" || construct === "for" || construct === "while" ? `a ${construct} loop` : construct === "detach" ? "a detached (fire-and-forget) call" : `a ${construct} step`;
-                ctx.addIssue(
-                  "warning",
-                  "LANGUAGE_FOREIGN_FLOW",
-                  `Step ${step.stepNumber} of "${implMethod.name}" in implementation "${impl.id}" uses ${label}, but the target language is ${lang}: ${guidance}.`,
-                  impl.id,
-                  isDraftCtx
-                );
-              }
-            }
+          const draft = ctx.isImplementationDraft(impl);
+          for (const method of impl.methods) {
+            for (const step of method.narrative) scans.push({ implementation: impl, method, step, lang, gaps, draft });
           }
         }
+        for (const scan of scans) {
+          for (const construct of constructsOf(scan.step)) {
+            const guidance = scan.gaps[construct];
+            if (!guidance) continue;
+            ctx.addIssue(
+              "warning",
+              "LANGUAGE_FOREIGN_FLOW",
+              `Step ${scan.step.stepNumber} of "${scan.method.name}" in implementation "${scan.implementation.id}" uses ${constructLabel(construct)}, but the target language is ${scan.lang}: ${guidance}.`,
+              scan.implementation.id,
+              scan.draft
+            );
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/heuristic/technology-binding.ts
+var DATA_LAYER, technologyBindingRule;
+var init_technology_binding = __esm({
+  "src/core/rules/heuristic/technology-binding.ts"() {
+    "use strict";
+    DATA_LAYER = /* @__PURE__ */ new Set(["Adapter", "Store", "Registry", "Index"]);
+    technologyBindingRule = {
+      name: "technology-binding",
+      description: "Only data-layer stereotypes (Adapter/Store/Registry/Index) should bind a technology directly: an L4 that declares `technologies` on logic has no swap seam. No hardcoded vendor lists \u2014 only declared tokens are policed, so the rule never fires on a tree that doesn't opt in.",
+      codes: [
+        { code: "TECH_ON_LOGIC_COMPONENT", defaultSeverity: "warning", summary: "Technology bound by a non-data-layer stereotype" }
+      ],
+      check(ctx) {
+        for (const impl of ctx.implementations) {
+          const intf = ctx.interfaceMap.get(impl.contract);
+          const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
+          if (!impl.technologies?.length || !comp || DATA_LAYER.has(comp.componentType)) continue;
+          ctx.addIssue(
+            "warning",
+            "TECH_ON_LOGIC_COMPONENT",
+            `Implementation "${impl.id}" binds technology (${impl.technologies.join(", ")}) on component "${comp.id}" (${comp.componentType}). Technology belongs behind a data-layer seam \u2014 extract an Adapter (or Store/Registry/Index) behind an intent interface and let this component depend on that.`,
+            impl.id,
+            ctx.isImplementationDraft(impl)
+          );
+        }
       }
     };
   }
@@ -13298,19 +13799,29 @@ function contractIdentifiers(m) {
   if (m.endpoint) parts.push(Object.values(m.endpoint).map(String).join(" "));
   return parts.join(" ");
 }
-var DATA_LAYER, technologyRule;
+function implementationText(impl) {
+  const parts = [impl.description, ...implementationSourceFiles(impl)];
+  for (const m of impl.methods) {
+    parts.push(m.intent);
+    for (const s of m.narrative ?? []) {
+      parts.push(s.description, s.targetComponent, s.targetMethod, s.condition, s.over, s.on, s.outcome, s.error);
+      for (const c of s.cases ?? []) parts.push(c.value);
+      for (const c of s.catches ?? []) parts.push(c.error);
+    }
+  }
+  return parts.filter(Boolean).join(" ");
+}
+var technologyRule;
 var init_technology_boundaries = __esm({
   "src/core/rules/heuristic/technology-boundaries.ts"() {
     "use strict";
     init_models();
-    DATA_LAYER = /* @__PURE__ */ new Set(["Adapter", "Store", "Registry", "Index"]);
     technologyRule = {
       name: "technology-boundaries",
-      description: "Technology stays behind its owning boundary: an L4 that declares `technologies` (e.g. [mysql]) makes its component's ownership tree the technology's home. References outside that tree are leakage, L3 contract identifiers must stay intent-language (the contract is the swap seam), and only data-layer stereotypes (Adapter/Store/Registry/Index) should bind a technology directly.",
+      description: "Technology stays behind its owning boundary: an L4 that declares `technologies` (e.g. [mysql]) makes its component's ownership tree the technology's home. References outside that tree are leakage, and L3 contract identifiers must stay intent-language \u2014 the contract is the swap seam, so the vendor name is wrong even on the owning component's own interface.",
       codes: [
         { code: "TECH_LEAKAGE", defaultSeverity: "warning", summary: "Technology referenced outside its owning boundary" },
-        { code: "VENDOR_NAME_IN_CONTRACT", defaultSeverity: "warning", summary: "Technology name in L3 contract identifiers" },
-        { code: "TECH_ON_LOGIC_COMPONENT", defaultSeverity: "warning", summary: "Technology bound by a non-data-layer stereotype" }
+        { code: "VENDOR_NAME_IN_CONTRACT", defaultSeverity: "warning", summary: "Technology name in L3 contract identifiers" }
       ],
       check(ctx) {
         const ownerOf = /* @__PURE__ */ new Map();
@@ -13338,21 +13849,18 @@ var init_technology_boundaries = __esm({
           }
           return out;
         };
-        const homes = /* @__PURE__ */ new Map();
+        const declarations = [];
         for (const impl of ctx.implementations) {
           if (!impl.technologies?.length) continue;
           const intf = ctx.interfaceMap.get(impl.contract);
           const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
           if (!comp) continue;
-          if (!DATA_LAYER.has(comp.componentType)) {
-            ctx.addIssue(
-              "warning",
-              "TECH_ON_LOGIC_COMPONENT",
-              `Implementation "${impl.id}" binds technology (${impl.technologies.join(", ")}) on component "${comp.id}" (${comp.componentType}). Technology belongs behind a data-layer seam \u2014 extract an Adapter (or Store/Registry/Index) behind an intent interface and let this component depend on that.`,
-              impl.id,
-              ctx.isImplementationDraft(impl)
-            );
-          }
+          for (const tech of impl.technologies) declarations.push({ comp, tech });
+        }
+        const scopes = /* @__PURE__ */ new Map();
+        const scopeOf = (comp) => {
+          const cached = scopes.get(comp.id);
+          if (cached) return cached;
           const compSet = ownsClosure(ownershipRoot(comp.id));
           const scope = new Set(compSet);
           for (const i of ctx.interfaces) if (compSet.has(i.component)) scope.add(i.id);
@@ -13367,15 +13875,18 @@ var init_technology_boundaries = __esm({
               if (subId === s.id || subId.startsWith(`${s.id}::`)) scope.add(s.id);
             }
           }
-          for (const tech of impl.technologies) {
-            const match = makeMatcher(tech);
-            if (!match) continue;
-            const key = tech.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean).join("");
-            const home = homes.get(key) ?? { label: tech, match, ownerComponents: /* @__PURE__ */ new Set(), scope: /* @__PURE__ */ new Set() };
-            home.ownerComponents.add(comp.id);
-            for (const id of scope) home.scope.add(id);
-            homes.set(key, home);
-          }
+          scopes.set(comp.id, scope);
+          return scope;
+        };
+        const homes = /* @__PURE__ */ new Map();
+        for (const { comp, tech } of declarations) {
+          const match = makeMatcher(tech);
+          if (!match) continue;
+          const key = tech.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean).join("");
+          const home = homes.get(key) ?? { label: tech, match, ownerComponents: /* @__PURE__ */ new Set(), scope: /* @__PURE__ */ new Set() };
+          home.ownerComponents.add(comp.id);
+          for (const id of scopeOf(comp)) home.scope.add(id);
+          homes.set(key, home);
         }
         if (homes.size === 0) return;
         const ownersDesc = (h) => [...h.ownerComponents].map((c) => `"${c}"`).join(", ");
@@ -13439,16 +13950,7 @@ var init_technology_boundaries = __esm({
           }
           for (const impl of ctx.implementations) {
             if (home.scope.has(impl.id)) continue;
-            const parts = [impl.description, ...implementationSourceFiles(impl)];
-            for (const m of impl.methods) {
-              parts.push(m.intent);
-              for (const s of m.narrative ?? []) {
-                parts.push(s.description, s.targetComponent, s.targetMethod, s.condition, s.over, s.on, s.outcome, s.error);
-                for (const c of s.cases ?? []) parts.push(c.value);
-                for (const c of s.catches ?? []) parts.push(c.error);
-              }
-            }
-            if (home.match(parts.filter(Boolean).join(" "))) {
+            if (home.match(implementationText(impl))) {
               ctx.addIssue(
                 "warning",
                 "TECH_LEAKAGE",
@@ -14137,12 +14639,15 @@ var init_repository = __esm({
   "src/core/rules/repository.ts"() {
     "use strict";
     init_hierarchy_integrity();
-    init_namespace_hygiene();
+    init_reserved_id_segments();
+    init_namespace_shadowing();
     init_roundtrip_serialization();
     init_type_declarations();
     init_field_type_references();
     init_signature_type_references();
-    init_public_surface();
+    init_public_surface_binding();
+    init_public_surface_declared_type();
+    init_public_surface_bound_contract();
     init_lint_allows();
     init_contract_symmetry();
     init_narrative_target_references();
@@ -14152,14 +14657,19 @@ var init_repository = __esm({
     init_narrative_step_config();
     init_narrative_reachability();
     init_narrative_jump_edges();
-    init_narrative_antipatterns();
+    init_meaningless_branches();
+    init_inescapable_cycles();
+    init_unconditional_call_cycles();
     init_narrative_detail();
+    init_detail_sufficiency();
     init_portal_fields();
     init_durability_declaration();
     init_logic_declaration();
     init_retired_stereotypes();
     init_portal_endpoints();
+    init_non_portal_endpoints();
     init_portal_call_auth();
+    init_auth_source_wiring();
     init_subsystem_boundary_dependencies();
     init_logic_dependency_class();
     init_data_block_dependencies();
@@ -14175,7 +14685,9 @@ var init_repository = __esm({
     init_pack_profile_stereotypes();
     init_pattern_references();
     init_component_variants();
-    init_declarative_assertions();
+    init_assertion_forbidden_edges();
+    init_assertion_required_fields();
+    init_assertion_endpoint_shapes();
     init_pack_resolution();
     init_pack_reproducibility();
     init_dependency_cycles();
@@ -14183,10 +14695,14 @@ var init_repository = __esm({
     init_dispatch_step_routing();
     init_lifecycle_entrypoints();
     init_unused_detection();
+    init_invoked_by_description();
+    init_unused_types();
     init_durability_round_trip();
     init_untyped_seams();
     init_prose_claims();
+    init_unique_invariant_ids();
     init_invariant_backing();
+    init_invariant_references();
     init_event_topology();
     init_source_file_linkage();
     init_method_realization();
@@ -14194,9 +14710,14 @@ var init_repository = __esm({
     init_call_conformance();
     init_hidden_state();
     init_dependency_conformance();
-    init_integration_conformance();
+    init_integration_sim_declaration();
+    init_integration_sim_file();
+    init_integration_sim_wiring();
+    init_integration_sim_coverage();
     init_coupling_health();
-    init_target_language();
+    init_signature_language_builtins();
+    init_narrative_language_constructs();
+    init_technology_binding();
     init_technology_boundaries();
     init_naming_conventions();
     init_complexity_and_metadata();
@@ -14206,8 +14727,11 @@ var init_repository = __esm({
     SDD_RULES = [
       hierarchyRule,
       // Namespace integrity right after hierarchy: unresolvable/unwritable ids
-      // explain many downstream findings, so surface them early in the list.
-      namespaceHygieneRule,
+      // explain many downstream findings, so surface them early in the list. Two
+      // questions of the same ids: the segment no id may spend, and the local name
+      // that would anchor a bare reference to the root instead.
+      reservedIdSegmentsRule,
+      namespaceShadowingRule,
       roundtripRule,
       // The type vocabulary in three questions: what a type declares about
       // itself, then the identifiers its fields name, then the ones its
@@ -14233,18 +14757,30 @@ var init_repository = __esm({
       narrativeStepConfigRule,
       narrativeReachabilityRule,
       narrativeJumpEdgesRule,
-      // Antipatterns right after flow soundness: they analyze the same step
-      // graphs and only make sense once the graphs are structurally valid.
-      narrativeAntipatternsRule,
+      // Antipatterns right after flow soundness: they read the same step graphs
+      // and only make sense once the graphs are structurally valid. Three things
+      // structure alone can prove, in widening scope: a decision that decides
+      // nothing, a step cycle nothing leaves, and a call cycle with no guard.
+      meaninglessBranchesRule,
+      inescapableCyclesRule,
+      unconditionalCallCyclesRule,
+      // The detail dial in two questions: does a method carry the detail its level
+      // promises, and is that level low enough to be hiding something.
       narrativeDetailRule,
+      detailSufficiencyRule,
       // Field shape before endpoint bindings: a Portal-only field on the wrong
       // stereotype explains the endpoint findings around it, and this half is
       // spec-scoped so the write boundary refuses it first.
       portalFieldsRule,
+      // Endpoints from both sides: a Portal binds every method to its transport,
+      // and nothing that is not a Portal may bind one at all.
       portalsRule,
-      // Cross-call auth: a narrative call into an authed Portal must name its
-      // credential source (rides with the portal family).
+      nonPortalEndpointsRule,
+      // Cross-call auth rides with the portal family, in two questions: does a
+      // call into an authed Portal present a credential properly, and does the
+      // source it names resolve to a provider it is wired to.
       portalCallAuthRule,
+      authSourceWiringRule,
       // Dependencies in five questions, one owner each: where an edge is
       // allowed to LAND (the boundary, and what an unresolved id means), then
       // the intra-subsystem matrix by the layer that answers for it — an
@@ -14274,9 +14810,18 @@ var init_repository = __esm({
       patternReferencesRule,
       variantReferencesRule,
       // Pack-instantiated declarative doctrine rides with the pack-reference
-      // family: same data source, same provenance-bearing findings.
-      declarativeAssertionsRule,
-      publicSurfaceRule,
+      // family: same data source, same provenance-bearing findings. One rule per
+      // assertion kind — the kind is what a pack author writes, and each kind
+      // asks its own question of its own collection.
+      assertionForbiddenEdgesRule,
+      assertionRequiredFieldsRule,
+      assertionEndpointShapesRule,
+      // The published surface in three questions: what backs the entry, whether
+      // that component's stereotype can realize the type it declares, and whether
+      // the contract it binds is that component's own.
+      publicSurfaceBindingRule,
+      publicSurfaceDeclaredTypeRule,
+      publicSurfaceBoundContractRule,
       cyclesRule,
       // Semantic-edge family: dispatch/lifecycle validity BEFORE reachability so a
       // reader sees the broken edge finding next to the unused-detection fallout
@@ -14284,7 +14829,11 @@ var init_repository = __esm({
       dispatchTableBindingsRule,
       dispatchStepRoutingRule,
       lifecycleRule,
+      // The declared entrypoint's own prose before the walk that its declaration
+      // silences, then the walk, then the types no walk can reach.
+      invokedByDescriptionRule,
       reachabilityRule,
+      unusedTypesRule,
       // The declaration (spec-scoped, refused at the write boundary) before the
       // round-trip consequences it enables.
       durabilityDeclarationRule,
@@ -14296,8 +14845,13 @@ var init_repository = __esm({
       untypedSeamRule,
       proseClaimRule,
       // Invariant registry rides with the semantic-edge family: declared entity
-      // invariants must be asserted on every write path (declarations, not proofs).
+      // invariants must be asserted on every write path (declarations, not
+      // proofs). Three questions of one registry: are the entity's ids unique,
+      // does each invariant reach every write path of its owner, and does every
+      // asserted reference name something declared.
+      uniqueInvariantIdsRule,
       invariantBackingRule,
+      invariantReferencesRule,
       // Pub/sub completeness: emitted topics need subscribers and vice versa.
       eventTopologyRule,
       // Code↔spec: structural conformance consumes the injected CodeModel (built
@@ -14316,10 +14870,22 @@ var init_repository = __esm({
       hiddenStateRule,
       dependencyConformanceRule,
       // Integration wiring proof rides after the code↔spec family: it consumes
-      // the same code model and speaks about the same sourcePath modules.
-      integrationConformanceRule,
+      // the same code model and speaks about the same sourcePath modules. Four
+      // questions about one harness, in the order a reader meets them: is one
+      // expected here, does the declared one exist, does it wire the real
+      // modules, does it name every narrated path.
+      integrationSimDeclarationRule,
+      integrationSimFileRule,
+      integrationSimWiringRule,
+      integrationSimCoverageRule,
       couplingRule,
-      languageRule,
+      // Target-language fit in two questions: what a CONTRACT may name, and what
+      // a NARRATIVE may describe.
+      signatureLanguageBuiltinsRule,
+      narrativeLanguageConstructsRule,
+      // The declaration before the consequences: which stereotype may bind a
+      // technology at all, then where its name may appear.
+      technologyBindingRule,
       technologyRule,
       namingRule,
       complexityRule,
@@ -15156,6 +15722,10 @@ function buildRuleContext(opts) {
   const ownershipIndex = () => ownershipMemo ??= buildOwnershipIndex(ctx);
   let dependencyEdgesMemo;
   const dependencyEdges = () => dependencyEdgesMemo ??= buildDependencyEdges(ctx);
+  let specIdsMemo;
+  const specIds = () => specIdsMemo ??= buildSpecIds(ctx);
+  let implementationMethodsMemo;
+  const implementationMethods = () => implementationMethodsMemo ??= buildImplementationMethods(ctx);
   const ctx = {
     system,
     subsystems,
@@ -15190,6 +15760,8 @@ function buildRuleContext(opts) {
     importGraph,
     ownershipIndex,
     dependencyEdges,
+    specIds,
+    implementationMethods,
     complexityConfigFor,
     documentationConfigFor,
     namingConfigFor,
@@ -17054,8 +17626,8 @@ function generateSequenceDiagram(componentId, methodName, options) {
   const componentById = new Map(graph.components.map((c) => [c.id, c]));
   const resolveComponent = (id) => {
     if (componentById.has(id)) return componentById.get(id);
-    const matches2 = graph.components.filter((c) => c.id.endsWith(`::${id}`));
-    return matches2.length === 1 ? matches2[0] : void 0;
+    const matches = graph.components.filter((c) => c.id.endsWith(`::${id}`));
+    return matches.length === 1 ? matches[0] : void 0;
   };
   const entry = resolveComponent(componentId);
   if (!entry) {
@@ -18316,9 +18888,9 @@ var init_specs2 = __esm({
           }
         }
         const suffix = `::${id}`;
-        const matches2 = Object.keys(index.paths.subsystem).filter((key) => key.endsWith(suffix));
-        if (matches2.length === 1) {
-          return index.paths.subsystem[matches2[0]];
+        const matches = Object.keys(index.paths.subsystem).filter((key) => key.endsWith(suffix));
+        if (matches.length === 1) {
+          return index.paths.subsystem[matches[0]];
         }
         if (pathExists(this.paths.specsSubsystemsDir()) && listFiles(this.paths.specsSubsystemsDir(), ".yaml").length > 0) {
           return path16.join(this.paths.specsSubsystemsDir(), `${id}.yaml`);