@wairon/cli 5.1.1-dev.15 → 5.1.1-dev.16

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.15";
+    WAIRON_VERSION = "5.1.1-dev.16";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -500,7 +500,7 @@ This project uses **wairon**. System specs live under \`.wai/specs/\` (L0 System
 1. **Design before code**: Complete spec and pass validator before writing source code.
 2. **Human-in-the-loop**: Ask user approval for each spec layer before proceeding.
 3. **Spec consistency**: If a 1:1 narrative match is incorrect or conflicts with L0 requirements, escalate a spec revision first. Never ship mismatched code.
-4. **No persistence shortcuts & strict layers**: A Portal must never depend directly on a Store, Registry, or Adapter. Portal reads MAY go through a Repository/Index facade (passthrough reads need no per-entity Orchestrator ceremony), but a Portal narrative calling a write-effect facade method is an error (\`PORTAL_WRITE_SHORTCUT\`) \u2014 writes always route through an Orchestrator. Held domain state always lives in a dedicated data component, never as fields inside an Orchestrator or Specialist. Two sanctioned shapes: the RECOMMENDED Repository pattern (owns Store + Registry + Index; consumers depend on the facade), or \u2014 for genuinely simple state \u2014 a deliberately standalone Store (workflow-layer consumers only, acknowledged with a lint.allow reason on the UNOWNED_STORE warning). Never combine Store/Registry/Index roles into one component, and never fold state into a consuming component because a link was refused.
+4. **No persistence shortcuts & strict layers**: A Portal must never depend directly on a Store, Registry, or Adapter. Portal reads MAY go through a Repository/Index facade (passthrough reads need no per-entity Orchestrator ceremony), but a Portal narrative call or dispatch-table binding that reaches a write-effect facade method is an error (\`PORTAL_WRITE_SHORTCUT\`) \u2014 writes always route through an Orchestrator. Held domain state always lives in a dedicated data component, never as fields inside an Orchestrator or Specialist. Two sanctioned shapes: the RECOMMENDED Repository pattern (owns Store + Registry + Index; consumers depend on the facade), or \u2014 for genuinely simple state \u2014 a deliberately standalone Store (workflow-layer consumers only, acknowledged with a lint.allow reason on the UNOWNED_STORE warning). Never combine Store/Registry/Index roles into one component, and never fold state into a consuming component because a link was refused.
 
 ### Component Vocabulary
 * **Blocks**: Portal, Orchestrator, Supervisor, Actor, Store, Index, Registry, Adapter, Observer, Specialist.
@@ -2822,15 +2822,13 @@ var init_hierarchy_integrity = __esm({
           }
         }
         for (const impl of ctx.implementations) {
-          const contract = ctx.interfaces.find((i) => i.id === impl.contract);
-          const isDraftCtx = impl.status === "draft" || impl.status === "design" || contract && (ctx.isComponentDraft(contract.component) || contract.status === "draft" || contract.status === "design");
           if (!ctx.interfaceIds.has(impl.contract)) {
             ctx.addIssue(
               "error",
               "INVALID_INTERFACE_REFERENCE",
               `Implementation "${impl.id}" references non-existent interface contract "${impl.contract}".`,
               impl.id,
-              isDraftCtx
+              ctx.isImplementationDraft(impl)
             );
           }
         }
@@ -2946,11 +2944,7 @@ var init_type_references2 = __esm({
             for (const field of t.fields) {
               const refs = fieldTypeRefs(t, field.type);
               for (const ref of refs) {
-                if (ctx.isBuiltinType(ref)) {
-                  continue;
-                }
-                const resolved = ctx.types.find((spec) => typeMatchesRef(spec, ref));
-                if (!resolved) {
+                if (!ctx.isTypeResolved(ref, /* @__PURE__ */ new Set())) {
                   ctx.addIssue(
                     "error",
                     "UNDEFINED_TYPE_REFERENCE",
@@ -3182,14 +3176,27 @@ var init_contract_symmetry_and_narratives = __esm({
                 );
                 continue;
               }
-              const isCrossTreeForm = ctx.isExternalNamespaceRef(step.targetComponent);
-              const fromSubsystem = ctx.componentMap.get(contract.component)?.subsystem;
-              const isCollapsedForm = !isCrossTreeForm && fromSubsystem !== void 0 && ctx.isCollapsedCrossTreeRef(step.targetComponent, fromSubsystem);
+              const target = step.targetComponent;
+              const isCrossTreeForm = ctx.isExternalNamespaceRef(target);
+              const caller = ctx.componentMap.get(contract.component);
+              const fromSubsystem = caller?.subsystem;
+              const isCollapsedForm = !isCrossTreeForm && fromSubsystem !== void 0 && ctx.isCollapsedCrossTreeRef(target, fromSubsystem);
+              const reportUndeclared = (reaches, surfaceResolved) => {
+                if (!caller || target === caller.id || caller.dependsOn.includes(target) || caller.owns.includes(target)) return;
+                ctx.addIssue(
+                  "error",
+                  "UNDECLARED_DEPENDENCY_CALL",
+                  `Method "${implMethod.name}" in implementation "${impl.id}" (component "${caller.id}") ${reaches} component "${target}" (step ${step.stepNumber}) but component "${caller.id}" does not list "${target}" as a dependency.`,
+                  impl.id,
+                  isDraftCtx || ctx.isComponentDraft(caller.id),
+                  surfaceResolved
+                );
+              };
               if (step.type === "dispatch") {
-                const dispatchTarget = ctx.componentMap.get(step.targetComponent);
+                const dispatchTarget = ctx.componentMap.get(target);
                 if (!dispatchTarget) {
                   if (isCrossTreeForm || isCollapsedForm) {
-                    const resolved = ctx.resolveSurfaceRef(step.targetComponent, fromSubsystem);
+                    const resolved = ctx.resolveSurfaceRef(target, fromSubsystem);
                     if (resolved.kind === "ambiguous") {
                       ctx.addIssue(
                         "error",
@@ -3197,7 +3204,7 @@ var init_contract_symmetry_and_narratives = __esm({
                         ambiguityMessage(
                           resolved,
                           `Method "${implMethod.name}" in implementation "${impl.id}" dispatches (step ${step.stepNumber}) through`,
-                          step.targetComponent
+                          target
                         ),
                         impl.id,
                         isDraftCtx
@@ -3205,11 +3212,12 @@ var init_contract_symmetry_and_narratives = __esm({
                       continue;
                     }
                     if (resolved.kind === "resolved") {
+                      reportUndeclared("dispatches through", true);
                       if (step.capability && !(resolved.entry.dispatch ?? []).some((b) => b.capability === step.capability)) {
                         ctx.addIssue(
                           "error",
                           "SURFACE_REF_NOT_EXPOSED",
-                          `Method "${implMethod.name}" in implementation "${impl.id}" dispatches capability "${step.capability}" through cross-tree portal "${step.targetComponent}" (step ${step.stepNumber}), but the surface snapshot of "${resolved.snapshot.projectName}" does not serve that capability on "${resolved.entry.id}".`,
+                          `Method "${implMethod.name}" in implementation "${impl.id}" dispatches capability "${step.capability}" through cross-tree portal "${target}" (step ${step.stepNumber}), but the surface snapshot of "${resolved.snapshot.projectName}" does not serve that capability on "${resolved.entry.id}".`,
                           impl.id,
                           isDraftCtx,
                           true
@@ -3222,7 +3230,7 @@ var init_contract_symmetry_and_narratives = __esm({
                     ctx.addIssue(
                       "warning",
                       "CROSS_TREE_REF_UNRESOLVED",
-                      `Method "${implMethod.name}" in implementation "${impl.id}" dispatches through cross-tree component "${step.targetComponent}" (step ${step.stepNumber}), and no surface snapshot covers it \u2014 validate from the parent project, pin the family surfaces ("wairon surface pin"), or import the producing project's surface.`,
+                      `Method "${implMethod.name}" in implementation "${impl.id}" dispatches through cross-tree component "${target}" (step ${step.stepNumber}), and no surface snapshot covers it \u2014 validate from the parent project, pin the family surfaces ("wairon surface pin"), or import the producing project's surface.`,
                       impl.id,
                       isDraftCtx
                     );
@@ -3230,23 +3238,14 @@ var init_contract_symmetry_and_narratives = __esm({
                     ctx.addIssue(
                       "error",
                       "INVALID_TARGET_COMPONENT_REFERENCE",
-                      `Method "${implMethod.name}" in implementation "${impl.id}" dispatches through component "${step.targetComponent}" which does not exist (step ${step.stepNumber}).`,
+                      `Method "${implMethod.name}" in implementation "${impl.id}" dispatches through component "${target}" which does not exist (step ${step.stepNumber}).`,
                       impl.id,
                       isDraftCtx
                     );
                   }
                   continue;
                 }
-                const dispatchCaller = ctx.componentMap.get(contract.component);
-                if (dispatchCaller && step.targetComponent !== dispatchCaller.id && !dispatchCaller.dependsOn.includes(step.targetComponent) && !dispatchCaller.owns.includes(step.targetComponent)) {
-                  ctx.addIssue(
-                    "error",
-                    "UNDECLARED_DEPENDENCY_CALL",
-                    `Method "${implMethod.name}" in implementation "${impl.id}" (component "${dispatchCaller.id}") dispatches through component "${step.targetComponent}" (step ${step.stepNumber}) but component "${dispatchCaller.id}" does not list "${step.targetComponent}" as a dependency.`,
-                    impl.id,
-                    isDraftCtx || ctx.isComponentDraft(dispatchCaller.id)
-                  );
-                }
+                reportUndeclared("dispatches through");
                 continue;
               }
               const verb = step.type === "register" ? "registers callback" : "calls";
@@ -3260,10 +3259,10 @@ var init_contract_symmetry_and_narratives = __esm({
                 );
                 continue;
               }
-              const targetComp = ctx.componentMap.get(step.targetComponent);
+              const targetComp = ctx.componentMap.get(target);
               if (!targetComp) {
                 if (isCrossTreeForm || isCollapsedForm) {
-                  const resolved = ctx.resolveSurfaceRef(step.targetComponent, fromSubsystem);
+                  const resolved = ctx.resolveSurfaceRef(target, fromSubsystem);
                   if (resolved.kind === "ambiguous") {
                     ctx.addIssue(
                       "error",
@@ -3271,7 +3270,7 @@ var init_contract_symmetry_and_narratives = __esm({
                       ambiguityMessage(
                         resolved,
                         `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} "${step.targetMethod}" (step ${step.stepNumber}) on`,
-                        step.targetComponent
+                        target
                       ),
                       impl.id,
                       isDraftCtx
@@ -3279,12 +3278,13 @@ var init_contract_symmetry_and_narratives = __esm({
                     continue;
                   }
                   if (resolved.kind === "resolved") {
+                    reportUndeclared(verb, true);
                     const surfaceMethod = resolved.entry.methods.find((m) => m.name === step.targetMethod);
                     if (!surfaceMethod) {
                       ctx.addIssue(
                         "error",
                         "SURFACE_REF_NOT_EXPOSED",
-                        `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} "${step.targetMethod}" on cross-tree component "${step.targetComponent}" (step ${step.stepNumber}), but the surface snapshot of "${resolved.snapshot.projectName}" does not expose that method on "${resolved.entry.id}".`,
+                        `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} "${step.targetMethod}" on cross-tree component "${target}" (step ${step.stepNumber}), but the surface snapshot of "${resolved.snapshot.projectName}" does not expose that method on "${resolved.entry.id}".`,
                         impl.id,
                         isDraftCtx,
                         true
@@ -3311,7 +3311,7 @@ var init_contract_symmetry_and_narratives = __esm({
                   ctx.addIssue(
                     "warning",
                     "CROSS_TREE_REF_UNRESOLVED",
-                    `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} cross-tree component "${step.targetComponent}" (step ${step.stepNumber}), and no surface snapshot covers it \u2014 validate from the parent project, pin the family surfaces ("wairon surface pin"), or import the producing project's surface.`,
+                    `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} cross-tree component "${target}" (step ${step.stepNumber}), and no surface snapshot covers it \u2014 validate from the parent project, pin the family surfaces ("wairon surface pin"), or import the producing project's surface.`,
                     impl.id,
                     isDraftCtx
                   );
@@ -3319,26 +3319,15 @@ var init_contract_symmetry_and_narratives = __esm({
                   ctx.addIssue(
                     "error",
                     "INVALID_TARGET_COMPONENT_REFERENCE",
-                    `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} component "${step.targetComponent}" which does not exist (step ${step.stepNumber}).`,
+                    `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} component "${target}" which does not exist (step ${step.stepNumber}).`,
                     impl.id,
                     isDraftCtx
                   );
                 }
                 continue;
               }
-              const callingComponent = ctx.componentMap.get(contract.component);
-              if (callingComponent && step.targetComponent !== callingComponent.id) {
-                if (!callingComponent.dependsOn.includes(step.targetComponent) && !callingComponent.owns.includes(step.targetComponent)) {
-                  ctx.addIssue(
-                    "error",
-                    "UNDECLARED_DEPENDENCY_CALL",
-                    `Method "${implMethod.name}" in implementation "${impl.id}" (component "${callingComponent.id}") ${verb} component "${step.targetComponent}" (step ${step.stepNumber}) but component "${callingComponent.id}" does not list "${step.targetComponent}" as a dependency.`,
-                    impl.id,
-                    isDraftCtx || ctx.isComponentDraft(callingComponent.id)
-                  );
-                }
-              }
-              const targetInterfaces = ctx.interfacesByComponent.get(step.targetComponent) ?? [];
+              reportUndeclared(verb);
+              const targetInterfaces = ctx.interfacesByComponent.get(target) ?? [];
               let targetMethodSpec;
               for (const targetIntf of targetInterfaces) {
                 const found = targetIntf.methods.find((m) => m.name === step.targetMethod);
@@ -3351,9 +3340,9 @@ var init_contract_symmetry_and_narratives = __esm({
                 ctx.addIssue(
                   "error",
                   "INVALID_TARGET_METHOD_REFERENCE",
-                  `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} method "${step.targetMethod}" on component "${step.targetComponent}" which is not defined on any of its interfaces (step ${step.stepNumber}).`,
+                  `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} method "${step.targetMethod}" on component "${target}" which is not defined on any of its interfaces (step ${step.stepNumber}).`,
                   impl.id,
-                  isDraftCtx || ctx.isComponentDraft(step.targetComponent)
+                  isDraftCtx || ctx.isComponentDraft(target)
                 );
               } else {
                 const declared = new Set(targetMethodSpec.guarantees ?? []);
@@ -3363,9 +3352,9 @@ var init_contract_symmetry_and_narratives = __esm({
                       ctx.addIssue(
                         "warning",
                         "NARRATIVE_SEMANTIC_UNBACKED",
-                        `Step ${step.stepNumber} of "${implMethod.name}" in implementation "${impl.id}" explicitly asserts guarantee "${g}", but the method it calls \u2014 "${step.targetMethod}" on "${step.targetComponent}" \u2014 does not list "${g}" among its L3 contract guarantees. Declare it on that method (and ensure its shape can deliver it), or revise the narrative.`,
+                        `Step ${step.stepNumber} of "${implMethod.name}" in implementation "${impl.id}" explicitly asserts guarantee "${g}", but the method it calls \u2014 "${step.targetMethod}" on "${target}" \u2014 does not list "${g}" among its L3 contract guarantees. Declare it on that method (and ensure its shape can deliver it), or revise the narrative.`,
                         impl.id,
-                        isDraftCtx || ctx.isComponentDraft(step.targetComponent)
+                        isDraftCtx || ctx.isComponentDraft(target)
                       );
                     }
                   }
@@ -3695,43 +3684,47 @@ var init_narrative_flow = __esm({
 });
 
 // src/core/rules/narrative/narrative-antipatterns.ts
-function isTerminal(step, nextOf) {
-  if (step.type === "return" || step.type === "throw") return true;
-  const n = step.stepNumber;
-  switch (step.type) {
-    case "local":
-    case "call":
-    case "register":
-    case "dispatch":
-      return nextOf(n) === void 0;
-    case "branch":
-      return step.onTrueStep === void 0 && nextOf(n) === void 0;
-    case "switch":
-      return step.defaultStep === void 0 && nextOf(n) === void 0;
-    case "loop":
-    case "try":
-      return step.endStep !== void 0 && nextOf(step.endStep) === void 0;
-    default:
-      return false;
-  }
+function completedStepGraph(steps) {
+  const numbers = steps.flatMap((s) => [
+    s.stepNumber,
+    s.onTrueStep,
+    s.onFalseStep,
+    s.defaultStep,
+    s.endStep,
+    s.finallyStep,
+    s.toStep,
+    ...(s.cases ?? []).map((c) => c.step),
+    ...(s.catches ?? []).map((c) => c.step),
+    ...(s.branches ?? []).map((b) => b.step)
+  ]).filter((n) => n !== void 0);
+  const completion = {
+    stepNumber: Math.max(0, ...numbers) + 1,
+    description: "The method completes by falling off the end of its narrative",
+    type: "return"
+  };
+  return stepGraph({ narrative: [...steps, completion] });
 }
 function isUnavoidable(steps, target) {
-  const { stepNumbers: nums, stepAt, nextOf, successorsOf } = stepGraph({ narrative: steps });
-  if (nums.length === 0) return false;
-  if (nums[0] === target) return true;
-  const visited = /* @__PURE__ */ new Set();
-  const stack = [nums[0]];
-  while (stack.length) {
-    const n = stack.pop();
-    if (n === target || visited.has(n)) continue;
-    visited.add(n);
-    const s = stepAt(n);
-    if (isTerminal(s, nextOf)) return false;
-    for (const t of successorsOf(n)) {
-      if (t !== target && !visited.has(t)) stack.push(t);
+  if (steps.length === 0) return false;
+  const graph = completedStepGraph(steps);
+  const completes = /* @__PURE__ */ new Set();
+  const canComplete = (n) => {
+    const s = graph.stepAt(n);
+    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));
+    return graph.successorsOf(n).some((t) => completes.has(t));
+  };
+  const order = [...graph.stepNumbers].reverse();
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const n of order) {
+      if (n === target || completes.has(n) || !canComplete(n)) continue;
+      completes.add(n);
+      grew = true;
     }
   }
-  return true;
+  return !completes.has(graph.stepNumbers[0]);
 }
 function stronglyConnected(nums, successorsOf) {
   const index = /* @__PURE__ */ new Map();
@@ -3783,11 +3776,12 @@ function stronglyConnected(nums, successorsOf) {
   }
   return sccs;
 }
-var narrativeAntipatternsRule;
+var byCodeUnit, narrativeAntipatternsRule;
 var init_narrative_antipatterns = __esm({
   "src/core/rules/narrative/narrative-antipatterns.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.",
@@ -3806,29 +3800,33 @@ var init_narrative_antipatterns = __esm({
             const steps = implMethod.narrative;
             if (!steps.length) continue;
             const where = `Method "${implMethod.name}" in implementation "${impl.id}": `;
-            const graph = stepGraph(implMethod);
+            const graph = completedStepGraph(steps);
+            const decisionTargets = (stepNumber, explicit, fallThroughField) => {
+              const targets = new Set(explicit);
+              if (fallThroughField !== void 0) targets.add(fallThroughField);
+              else for (const t of graph.successorsOf(stepNumber)) targets.add(t);
+              return [...targets];
+            };
             for (const s of steps) {
               if (s.type === "branch" && s.onFalseStep !== void 0) {
-                const onTrue = s.onTrueStep ?? graph.nextOf(s.stepNumber);
-                if (onTrue !== void 0 && onTrue === s.onFalseStep) {
+                const targets = decisionTargets(s.stepNumber, [s.onFalseStep], s.onTrueStep);
+                if (targets.length === 1) {
                   ctx.addIssue(
                     "warning",
                     "MEANINGLESS_BRANCH",
-                    `${where}branch step ${s.stepNumber} sends both arms to step ${onTrue} \u2014 the condition decides nothing. Point the arms at different steps, or replace the branch with a local step.`,
+                    `${where}branch step ${s.stepNumber} sends both arms to step ${targets[0]} \u2014 the condition decides nothing. Point the arms at different steps, or replace the branch with a local step.`,
                     impl.id,
                     isDraftCtx
                   );
                 }
               }
               if (s.type === "switch" && s.cases?.length) {
-                const targets = new Set(s.cases.map((c) => c.step));
-                const def = s.defaultStep ?? graph.nextOf(s.stepNumber);
-                if (def !== void 0) targets.add(def);
-                if (targets.size === 1) {
+                const targets = decisionTargets(s.stepNumber, s.cases.map((c) => c.step), s.defaultStep);
+                if (targets.length === 1) {
                   ctx.addIssue(
                     "warning",
                     "MEANINGLESS_BRANCH",
-                    `${where}switch step ${s.stepNumber} sends every case (and the default) to step ${[...targets][0]} \u2014 the dispatch decides nothing.`,
+                    `${where}switch step ${s.stepNumber} sends every case (and the default) to step ${targets[0]} \u2014 the dispatch decides nothing.`,
                     impl.id,
                     isDraftCtx
                   );
@@ -3901,8 +3899,8 @@ var init_narrative_antipatterns = __esm({
           if (!isCycle) continue;
           const memberEdges = keys.flatMap((k) => (adjacency.get(k) ?? []).filter((e) => inScc.has(e.toKey)));
           if (memberEdges.length === 0) continue;
-          const anchor = [...memberEdges].sort((a, b) => a.fromKey.localeCompare(b.fromKey))[0];
-          const path70 = [...keys].sort().join(" \u2192 ");
+          const anchor = [...memberEdges].sort((a, b) => byCodeUnit(a.fromKey, b.fromKey) || byCodeUnit(a.impl.id, b.impl.id) || a.stepNumber - b.stepNumber)[0];
+          const path70 = [...keys].sort(byCodeUnit).join(" \u2192 ");
           ctx.addIssue(
             "warning",
             "UNCONDITIONAL_CALL_CYCLE",
@@ -4154,14 +4152,15 @@ var init_portal_endpoints = __esm({
             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",
                   "ARCHITECTURE_VIOLATION_NON_PORTAL_ENDPOINT",
                   `Architectural violation: Component "${comp.id}" is a ${comp.componentType}, but method "${m.name}" on its interface "${intf.id}" declares an endpoint. Only Portal components may carry endpoints.`,
-                  comp.id,
-                  isDraftCtx
+                  intf.id,
+                  isDraftCtx || isIntfDraft
                 );
               }
             }
@@ -4292,7 +4291,7 @@ var init_stereotype_dependencies = __esm({
         { code: "ARCHITECTURE_VIOLATION_ADAPTER_DEP", defaultSeverity: "error", summary: "Adapter depending on Orchestrators or Stores" },
         { code: "ARCHITECTURE_VIOLATION_INDEX_DEP", defaultSeverity: "error", summary: "Index depending on anything but its Store or an Adapter" },
         { code: "ARCHITECTURE_VIOLATION_VIEW_DEP", defaultSeverity: "error", summary: "View depending on logic/persistence layers" },
-        { code: "PORTAL_WRITE_SHORTCUT", defaultSeverity: "error", summary: "Portal narrative calls a write-effect method on a Repository/Index directly \u2014 reads may shortcut, writes route through an Orchestrator (judged on effect-tagged facade methods; untagged methods are not yet judged)" }
+        { code: "PORTAL_WRITE_SHORTCUT", defaultSeverity: "error", summary: "Portal narrative call or dispatch-table binding reaches a write-effect method on a Repository/Index directly \u2014 reads may shortcut, writes route through an Orchestrator (judged on effect-tagged facade methods; untagged methods are not yet judged)" }
       ],
       check(ctx) {
         for (const comp of ctx.components) {
@@ -4364,10 +4363,11 @@ var init_stereotype_dependencies = __esm({
                   crossDraft
                 );
               } else if (depComp.componentType !== "Portal" && depComp.componentType !== "Gateway") {
+                const crosser = comp.componentType === "Adapter" ? "client Adapter" : comp.componentType;
                 ctx.addIssue(
                   "error",
                   "CROSS_SUBSYSTEM_TARGET_NON_PORTAL",
-                  `Boundary violation: client Adapter "${comp.id}" enters subsystem "${depComp.subsystem}" through "${depComp.id}" (${depComp.componentType}), not its inbound Portal. A cross-subsystem hop must target the remote subsystem's Portal (its front door), which dispatches inward \u2014 publishing/depending on an internal ${depComp.componentType} leaks the boundary and breaks the distribution seam. Expose a Portal for "${depComp.subsystem}" and point this Adapter at it.`,
+                  `Boundary violation: ${crosser} "${comp.id}" enters subsystem "${depComp.subsystem}" through "${depComp.id}" (${depComp.componentType}), not its inbound Portal. A cross-subsystem hop must target the remote subsystem's Portal (its front door), which dispatches inward \u2014 publishing/depending on an internal ${depComp.componentType} leaks the boundary and breaks the distribution seam. Expose a Portal for "${depComp.subsystem}" and point "${comp.id}" at it.`,
                   comp.id,
                   crossDraft
                 );
@@ -4491,6 +4491,23 @@ var init_stereotype_dependencies = __esm({
             }
           }
         }
+        for (const comp of ctx.components) {
+          if (comp.componentType !== "Portal" || !comp.dispatch || comp.dispatch.length === 0) continue;
+          const isDraftCtx = ctx.isComponentDraft(comp.id);
+          for (const binding of comp.dispatch) {
+            const target = ctx.componentMap.get(binding.component);
+            if (!target || target.componentType !== "Repository" && target.componentType !== "Index") continue;
+            const targetMethod = ctx.interfaceMethodsOf(target.id).find((m) => m.name === binding.method);
+            if (targetMethod?.effect !== "write") continue;
+            ctx.addIssue(
+              "error",
+              "PORTAL_WRITE_SHORTCUT",
+              `Portal "${comp.id}": dispatch binding "${binding.capability}" routes to write-effect method ${target.id}.${binding.method} directly. The Portal\u2192${target.componentType} shortcut is licensed for READS only \u2014 route the write through an Orchestrator that owns the workflow.`,
+              comp.id,
+              isDraftCtx || ctx.isComponentDraft(target.id)
+            );
+          }
+        }
       }
     };
   }
@@ -4514,7 +4531,7 @@ var init_pattern_ownership = __esm({
         { code: "REPOSITORY_CONTAINMENT", defaultSeverity: "error", summary: "Repository owning a non Store/Registry/Index/Adapter member" },
         { code: "GATEWAY_CONTAINMENT", defaultSeverity: "error", summary: "Gateway owning a non Portal/Orchestrator/Specialist member" },
         { code: "FEATURE_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "FeatureComponent not owning exactly one Orchestrator + one or more Views" },
-        { code: "ROUTER_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "RouterComponent missing its Portal facade or children" },
+        { code: "ROUTER_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "RouterComponent not owning exactly one Portal facade, or owning no children to route to" },
         { code: "VISIBILITY_VIOLATION", defaultSeverity: "error", summary: "Dependency on a block privately owned by another pattern" },
         { code: "UNOWNED_STORE", defaultSeverity: "warning", summary: "Store not owned by any pattern \u2014 recommended shape is a Repository; a deliberate standalone Store needs a lint.allow" },
         { code: "REGISTRY_WITHOUT_STORE", defaultSeverity: "warning", summary: "Standalone Registry with no Store to write to \u2014 either mistyped (a fused file-backed store belongs typed Store) or orphaned" }
@@ -4536,14 +4553,15 @@ var init_pattern_ownership = __esm({
               ctx.addIssue("error", "INVALID_OWNED_MEMBER", `Component "${comp.id}" owns "${memberId}" which does not exist.`, comp.id, isDraftCtx);
               continue;
             }
+            if (!pattern) continue;
             if (isPattern(member)) {
               ctx.addIssue("error", "PATTERN_OWNS_PATTERN", `Pattern "${comp.id}" owns "${memberId}", which is itself a pattern. Patterns own only building blocks \u2014 compose patterns at the subsystem (L1) level.`, comp.id, isDraftCtx);
             }
-            const prev = ownedBy.get(memberId);
-            if (prev && prev !== comp.id) {
-              ctx.addIssue("error", "SHARED_OWNED_MEMBER", `Block "${memberId}" is owned by both "${prev}" and "${comp.id}"; a block has exactly one owner.`, comp.id, isDraftCtx);
+            const firstOwner = ownedBy.get(memberId);
+            if (firstOwner && firstOwner !== comp.id) {
+              ctx.addIssue("error", "SHARED_OWNED_MEMBER", `Block "${memberId}" is owned by both "${firstOwner}" and "${comp.id}"; a block has exactly one owner.`, comp.id, isDraftCtx);
             }
-            ownedBy.set(memberId, comp.id);
+            if (!firstOwner) ownedBy.set(memberId, comp.id);
           }
           if (comp.componentType === "Repository") {
             const allowed = /* @__PURE__ */ new Set(["Store", "Registry", "Index", "Adapter"]);
@@ -4578,14 +4596,14 @@ var init_pattern_ownership = __esm({
             }
           }
           if (comp.componentType === "RouterComponent") {
-            let hasPortal = false;
+            let portals = 0;
             let hasChildren = false;
             for (const memberId of comp.owns) {
               const t = ctx.componentMap.get(memberId)?.componentType;
-              if (t === "Portal") hasPortal = true;
+              if (t === "Portal") portals++;
               else if (t) hasChildren = true;
             }
-            if (!hasPortal) {
+            if (portals !== 1) {
               ctx.addIssue("error", "ROUTER_COMPONENT_CONTAINMENT", `RouterComponent "${comp.id}" must own exactly one Portal component to act as its facade.`, comp.id, isDraftCtx);
             }
             if (!hasChildren) {
@@ -5087,54 +5105,43 @@ var init_dependency_cycles = __esm({
     "use strict";
     cyclesRule = {
       name: "dependency-cycles",
-      description: "The component dependsOn graph must be a DAG; the first detected cycle is reported with its full path.",
+      description: "The component dependsOn graph must be a DAG; the first cycle through a component in the run's scope is reported with its full path.",
       codes: [
         { code: "CIRCULAR_DEPENDENCY", defaultSeverity: "error", summary: "Circular dependency between components" }
       ],
       check(ctx) {
-        const visited = /* @__PURE__ */ new Set();
-        const recStack = /* @__PURE__ */ new Set();
-        const dfs = (compId, pathTrace) => {
-          visited.add(compId);
-          recStack.add(compId);
-          pathTrace.push(compId);
-          const comp = ctx.componentMap.get(compId);
-          if (comp) {
-            for (const depId of comp.dependsOn) {
-              if (!visited.has(depId)) {
-                if (dfs(depId, pathTrace)) {
-                  recStack.delete(compId);
-                  pathTrace.pop();
-                  return true;
-                }
-              } else if (recStack.has(depId)) {
+        const cycleFrom = (startId) => {
+          const visited = /* @__PURE__ */ new Set([startId]);
+          const pathTrace = [startId];
+          const search = (compId) => {
+            for (const depId of ctx.componentMap.get(compId)?.dependsOn ?? []) {
+              if (depId === startId) {
                 pathTrace.push(depId);
-                const cyclePath = pathTrace.slice(pathTrace.indexOf(depId)).join(" -> ");
-                const isDraftCtx = ctx.isComponentDraft(compId) || ctx.isComponentDraft(depId);
-                ctx.addIssue(
-                  "error",
-                  "CIRCULAR_DEPENDENCY",
-                  `Circular dependency detected: ${cyclePath}`,
-                  compId,
-                  isDraftCtx
-                );
-                pathTrace.pop();
-                recStack.delete(compId);
-                pathTrace.pop();
                 return true;
               }
+              if (visited.has(depId)) continue;
+              visited.add(depId);
+              pathTrace.push(depId);
+              if (search(depId)) return true;
+              pathTrace.pop();
             }
-          }
-          recStack.delete(compId);
-          pathTrace.pop();
-          return false;
+            return false;
+          };
+          return search(startId) ? pathTrace : void 0;
         };
         for (const comp of ctx.components) {
-          if (!visited.has(comp.id)) {
-            if (dfs(comp.id, [])) {
-              break;
-            }
-          }
+          if (!ctx.isSpecInScope(comp.id)) continue;
+          const cycle = cycleFrom(comp.id);
+          if (!cycle) continue;
+          const closing = cycle[cycle.length - 2];
+          ctx.addIssue(
+            "error",
+            "CIRCULAR_DEPENDENCY",
+            `Circular dependency detected: ${cycle.join(" -> ")}`,
+            comp.id,
+            ctx.isComponentDraft(comp.id) || ctx.isComponentDraft(closing)
+          );
+          return;
         }
       }
     };
@@ -5263,19 +5270,18 @@ var init_dispatch_tables = __esm({
                 );
                 continue;
               }
-              if (step.assertsGuarantees?.length) {
-                const boundMethod = ctx.interfaceMethodsOf(binding.component).find((m) => m.name === binding.method);
-                const declared = new Set(boundMethod?.guarantees ?? []);
-                for (const g of step.assertsGuarantees) {
-                  if (!declared.has(g)) {
-                    ctx.addIssue(
-                      "warning",
-                      "NARRATIVE_SEMANTIC_UNBACKED",
-                      `${where} asserts guarantee "${g}", but capability "${step.capability}" resolves to "${binding.component}.${binding.method}", which does not list "${g}" among its L3 contract guarantees. Declare it there (and ensure its shape can deliver it), or revise the narrative.`,
-                      impl.id,
-                      isDraftCtx || ctx.isComponentDraft(binding.component)
-                    );
-                  }
+              const boundMethod = ctx.interfaceMethodsOf(binding.component).find((m) => m.name === binding.method);
+              if (!boundMethod) continue;
+              const declared = new Set(boundMethod.guarantees ?? []);
+              for (const g of step.assertsGuarantees ?? []) {
+                if (!declared.has(g)) {
+                  ctx.addIssue(
+                    "warning",
+                    "NARRATIVE_SEMANTIC_UNBACKED",
+                    `${where} asserts guarantee "${g}", but capability "${step.capability}" resolves to "${binding.component}.${binding.method}", which does not list "${g}" among its L3 contract guarantees. Declare it there (and ensure its shape can deliver it), or revise the narrative.`,
+                    impl.id,
+                    isDraftCtx || ctx.isComponentDraft(binding.component)
+                  );
                 }
               }
             }
@@ -5480,12 +5486,11 @@ var init_unused_detection = __esm({
         const invokedBySeeds = [];
         for (const intf of ctx.interfaces) {
           if (!ctx.componentMap.has(intf.component)) continue;
-          const comp = ctx.componentMap.get(intf.component);
           for (const m of intf.methods) {
             if (!m.invokedBy) continue;
             invokedBySeeds.push({ compId: intf.component, methodName: m.name });
             if (!ctx.isSpecInScope(intf.id)) continue;
-            const isDraftCtx = comp.status === "draft" || comp.status === "design" || intf.status === "draft" || intf.status === "design";
+            const isDraftCtx = ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design";
             if (!passesIntentFloor(m.invokedBy.caller, m.name)) {
               ctx.addIssue(
                 "warning",
@@ -5510,7 +5515,7 @@ var init_unused_detection = __esm({
         for (const comp of ctx.components) {
           if (!ctx.isSpecInScope(comp.id)) continue;
           if (!reach.reachesComponent(comp.id)) {
-            const isDraftCtx = comp.status === "draft" || comp.status === "design";
+            const isDraftCtx = ctx.isComponentDraft(comp.id);
             ctx.addIssue(
               "warning",
               "UNUSED_COMPONENT",
@@ -5522,12 +5527,12 @@ var init_unused_detection = __esm({
             for (const intf of ctx.interfacesByComponent.get(comp.id) ?? []) {
               for (const m of intf.methods) {
                 if (!reach.reachesMethod(comp.id, m.name)) {
-                  const isDraftCtx = comp.status === "draft" || comp.status === "design" || intf.status === "draft" || intf.status === "design";
+                  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.`,
-                    comp.id,
+                    intf.id,
                     isDraftCtx
                   );
                 }
@@ -5638,20 +5643,20 @@ var init_durability_round_trip = __esm({
 });
 
 // src/core/rules/wiring/untyped-seams.ts
-function unwrapPromise(typeRef) {
-  const m = /^promise\s*<(.+)>$/i.exec(typeRef.trim());
-  return (m ? m[1] : typeRef).trim();
+function namesBareType(refs) {
+  return refs.some((ref) => BARE_SEAM_TYPES.has(ref.toLowerCase()));
 }
 var BARE_SEAM_TYPES, untypedSeamRule;
 var init_untyped_seams = __esm({
   "src/core/rules/wiring/untyped-seams.ts"() {
     "use strict";
+    init_models();
     BARE_SEAM_TYPES = /* @__PURE__ */ new Set(["json", "any", "unknown", "object"]);
     untypedSeamRule = {
       name: "untyped-seams",
-      description: "Methods on a subsystem's published components (its public surface) should not take or return bare Json/any/unknown \u2014 cross-subsystem contracts are the swap seam and must be typed. Generic-dispatch portals carry per-capability types via their dispatch table instead.",
+      description: "Methods on a subsystem's published components (its public surface) should not take or return bare Json/any/unknown/object, judged through each method's type references so a prose signature is judged like structured params: cross-subsystem contracts are the swap seam and must be typed. Generic-dispatch portals carry per-capability types via their dispatch table instead.",
       codes: [
-        { code: "UNTYPED_SEAM", defaultSeverity: "warning", summary: "Bare Json/any/unknown parameter or return crossing a subsystem public surface" }
+        { code: "UNTYPED_SEAM", defaultSeverity: "warning", summary: "Bare Json/any/unknown/object parameter or return crossing a subsystem public surface" }
       ],
       check(ctx) {
         for (const sub of ctx.subsystems) {
@@ -5665,14 +5670,17 @@ var init_untyped_seams = __esm({
               const isDraftCtx = ctx.isComponentDraft(compId) || intf.status === "draft" || intf.status === "design";
               for (const m of intf.methods) {
                 const offenders = [];
-                for (const p of m.params ?? []) {
-                  if (BARE_SEAM_TYPES.has(unwrapPromise(p.type).toLowerCase())) {
-                    offenders.push(`param "${p.name}: ${p.type}"`);
+                if (m.params && m.params.length > 0) {
+                  for (const p of m.params) {
+                    if (namesBareType(extractTypeIdentifiers(p.type))) {
+                      offenders.push(`param "${p.name}: ${p.type}"`);
+                    }
                   }
-                }
-                const ret = unwrapPromise(m.returns ?? "");
-                if (BARE_SEAM_TYPES.has(ret.toLowerCase())) {
-                  offenders.push(`return "${m.returns}"`);
+                  if (namesBareType(extractTypeIdentifiers(m.returns ?? ""))) {
+                    offenders.push(`return "${m.returns}"`);
+                  }
+                } else if (namesBareType(methodTypeRefs(m))) {
+                  offenders.push(`signature "${m.signature}"`);
                 }
                 if (offenders.length) {
                   ctx.addIssue(
@@ -5697,15 +5705,19 @@ function componentOfImpl(ctx, implContract) {
   const contract = ctx.interfaceMap.get(implContract);
   return contract ? ctx.componentMap.get(contract.component) : void 0;
 }
-var DATA_STEREOTYPES, CLAIM_PHRASES, proseClaimRule;
+function withoutQuotedText(text2) {
+  return text2.replace(QUOTED_SPAN, " ");
+}
+var DATA_STEREOTYPES, CLAIM_PHRASES, QUOTED_SPAN, proseClaimRule;
 var init_prose_claims = __esm({
   "src/core/rules/wiring/prose-claims.ts"() {
     "use strict";
     DATA_STEREOTYPES = /* @__PURE__ */ new Set(["Store", "Registry", "Index", "Adapter", "Repository"]);
-    CLAIM_PHRASES = /\b(persist(s|ed|ent)?|survives?\s+(a\s+)?restart|writ(es?|ten)\s+to\s+disk|registered\s+into|durabl[ey])\b/i;
+    CLAIM_PHRASES = /\b(persist(s|ed|ent|ing|ence)?|survives?\s+(a\s+)?restart|writ(es?|ten)\s+to\s+disk|registered\s+into|durabl[ey])\b/i;
+    QUOTED_SPAN = /"[^"]*"|“[^”]*”|`[^`]*`|(?<![\p{L}\p{N}])['‘](?:[^'‘’]|(?<=[\p{L}\p{N}])['’](?=[\p{L}\p{N}]))*['’](?![\p{L}\p{N}])/gu;
     proseClaimRule = {
       name: "prose-claims",
-      description: 'Flags durability/side-effect claims that exist only in prose: a local step description or an intent paragraph claiming persistence ("persisted", "survives restart", "registered into") on a logic component whose narrative has no call/dispatch edge to any data-layer component (Store/Registry/Index/Adapter/Repository). Data-layer components are exempt \u2014 they ARE the persistence.',
+      description: 'Flags durability/side-effect claims that exist only in prose: a local step description or an intent paragraph claiming persistence ("persisted", "persistence", "survives restart", "registered into") on a logic component whose narrative has no call, register or dispatch edge to any data-layer component (Store/Registry/Index/Adapter/Repository). Text inside quotes or backticks names a value or quotes a message and claims nothing. Data-layer components are exempt \u2014 they ARE the persistence.',
       codes: [
         { code: "UNREALIZED_CLAIM", defaultSeverity: "warning", summary: "Durability/side-effect claim in prose with no matching structural edge" }
       ],
@@ -5716,11 +5728,11 @@ var init_prose_claims = __esm({
           if (DATA_STEREOTYPES.has(comp.componentType)) continue;
           const isDraftCtx = ctx.isImplementationDraft(impl);
           for (const implMethod of impl.methods) {
-            const stepClaims = implMethod.narrative.filter((step) => step.type === "local").map((step) => ({ step, claim: CLAIM_PHRASES.exec(step.description) })).filter((c) => c.claim !== null);
-            const intentClaim = implMethod.intent ? CLAIM_PHRASES.exec(implMethod.intent) : null;
+            const stepClaims = implMethod.narrative.filter((step) => step.type === "local").map((step) => ({ step, claim: CLAIM_PHRASES.exec(withoutQuotedText(step.description)) })).filter((c) => c.claim !== null);
+            const intentClaim = implMethod.intent ? CLAIM_PHRASES.exec(withoutQuotedText(implMethod.intent)) : null;
             if (!stepClaims.length && !intentClaim) continue;
             const hasDataEdge = implMethod.narrative.some((step) => {
-              if (step.type !== "call" && step.type !== "dispatch") return false;
+              if (step.type !== "call" && step.type !== "register" && step.type !== "dispatch") return false;
               if (!step.targetComponent) return false;
               const target = ctx.componentMap.get(step.targetComponent);
               if (target && DATA_STEREOTYPES.has(target.componentType)) return true;
@@ -5733,7 +5745,7 @@ var init_prose_claims = __esm({
                 ctx.addIssue(
                   "warning",
                   "UNREALIZED_CLAIM",
-                  `Step ${step.stepNumber} of "${implMethod.name}" in implementation "${impl.id}" claims "${claim[0]}" but no call/dispatch edge in this narrative reaches a Store/Registry/Index/Adapter \u2014 realize the claim as a structural edge (and durability tags), or reword the prose.`,
+                  `Step ${step.stepNumber} of "${implMethod.name}" in implementation "${impl.id}" claims "${claim[0]}" but no call/register/dispatch edge in this narrative reaches a Store/Registry/Index/Adapter \u2014 realize the claim as a structural edge (and durability tags), or reword the prose.`,
                   impl.id,
                   isDraftCtx
                 );
@@ -5792,6 +5804,10 @@ function stepAsserts(impl, methodName, type, invariantId) {
     (step) => (step.assertsInvariants ?? []).some((ref) => refMatchesInvariant(ref, type, invariantId))
   );
 }
+function isEntityDraft(t, ctx) {
+  const sub = t.subsystem ? ctx.subsystems.find((s) => s.id === t.subsystem) : void 0;
+  return sub !== void 0 && isDraftSubsystem(sub);
+}
 function resolveComponentClass(t, ctx) {
   if (!t.componentClass) return void 0;
   const direct = ctx.componentMap.get(t.componentClass);
@@ -5818,6 +5834,7 @@ var init_invariant_backing = __esm({
         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)) {
@@ -5825,7 +5842,8 @@ var init_invariant_backing = __esm({
                 "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
+                t.id,
+                entityDraft
               );
             }
             seen.add(inv.id);
@@ -5836,7 +5854,8 @@ var init_invariant_backing = __esm({
               "warning",
               "INVARIANT_UNANCHORED",
               `Entity "${t.id}" declares ${invariants.length} invariant(s) but ${t.componentClass ? `its componentClass "${t.componentClass}" does not resolve to a component` : "has no componentClass"} \u2014 without an owning component there is no write path to hold the invariant against. Link the lifecycle owner via componentClass.`,
-              t.id
+              t.id,
+              entityDraft
             );
             continue;
           }
@@ -5850,13 +5869,13 @@ var init_invariant_backing = __esm({
               "INVARIANT_UNANCHORED",
               `Entity "${t.id}" declares ${invariants.length} invariant(s) anchored to "${comp.id}", but none of that component's contract methods declare effect: write \u2014 the validator cannot identify the write paths that must assert them. Tag the mutating methods with effect: write.`,
               t.id,
-              ctx.isComponentDraft(comp.id)
+              entityDraft || ctx.isComponentDraft(comp.id)
             );
             continue;
           }
           for (const { intf, method: method2 } of writeMethods) {
             for (const impl of ctx.implementationsByContract.get(intf.id) ?? []) {
-              const isDraftCtx = ctx.isImplementationDraft(impl);
+              const isDraftCtx = entityDraft || ctx.isImplementationDraft(impl);
               for (const inv of invariants) {
                 if (stepAsserts(impl, method2.name, t, inv.id)) continue;
                 ctx.addIssue(
@@ -5894,30 +5913,35 @@ var init_invariant_backing = __esm({
 
 // src/core/rules/wiring/event-topology.ts
 function collectEnds(ctx) {
-  const emitters = [];
-  const subscribers = [];
+  const emitters = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Map();
+  const addEnd = (ends, topic, compId, via) => {
+    const key = `${compId}#${topic}`;
+    const end = ends.get(key);
+    if (!end) ends.set(key, { topic, compId, vias: [via] });
+    else if (!end.vias.includes(via)) end.vias.push(via);
+  };
   for (const comp of ctx.components) {
     for (const e of comp.emits ?? []) {
-      emitters.push({ topic: e.topic, compId: comp.id, via: "emits declaration" });
+      addEnd(emitters, e.topic, comp.id, "emits declaration");
     }
     for (const s of comp.subscribesTo ?? []) {
-      subscribers.push({ topic: s.topic, compId: comp.id, via: "subscribesTo declaration" });
+      addEnd(subscribers, s.topic, comp.id, "subscribesTo declaration");
     }
   }
   for (const intf of ctx.interfaces) {
     for (const method2 of intf.methods) {
       const ep = method2.endpoint;
       if (!ep || ep.transport !== "MessageBus") continue;
-      const end = {
-        topic: ep.topic,
-        compId: intf.component,
-        via: `MessageBus endpoint on ${intf.id}.${method2.name}`
-      };
-      if (ep.direction === "publish") emitters.push(end);
-      else subscribers.push(end);
+      addEnd(
+        ep.direction === "publish" ? emitters : subscribers,
+        ep.topic,
+        intf.component,
+        `MessageBus endpoint on ${intf.id}.${method2.name}`
+      );
     }
   }
-  return { emitters, subscribers };
+  return { emitters: [...emitters.values()], subscribers: [...subscribers.values()] };
 }
 var eventTopologyRule;
 var init_event_topology = __esm({
@@ -5925,7 +5949,7 @@ var init_event_topology = __esm({
     "use strict";
     eventTopologyRule = {
       name: "event-topology",
-      description: "Bipartite completeness of the declared pub/sub graph: every topic a component emits (emits declarations, MessageBus publish endpoints) must have at least one subscriber (subscribesTo declarations, MessageBus subscribe endpoints), and every subscription must have at least one source. Pairing is by exact topic name. Trees that declare no event edges see nothing \u2014 the rule costs request/response systems zero noise. Warnings + lint.allow: a topic produced for (or consumed from) an EXTERNAL system is a legitimate, declarable exception.",
+      description: "Bipartite completeness of the declared pub/sub graph: every topic a component emits (emits declarations, MessageBus publish endpoints) must have at least one subscriber (subscribesTo declarations, MessageBus subscribe endpoints), and every subscription must have at least one source. Pairing is by exact topic name, and a topic is reported once per component however many declarations bind it there. Trees that declare no event edges see nothing \u2014 the rule costs request/response systems zero noise. Warnings + lint.allow: a topic produced for (or consumed from) an EXTERNAL system is a legitimate, declarable exception.",
       codes: [
         { code: "UNCONSUMED_TOPIC", defaultSeverity: "warning", summary: "Topic is emitted but nothing in the tree subscribes to it" },
         { code: "UNSOURCED_SUBSCRIPTION", defaultSeverity: "warning", summary: "Topic is subscribed to but nothing in the tree emits it" }
@@ -5940,7 +5964,7 @@ var init_event_topology = __esm({
           ctx.addIssue(
             "warning",
             "UNCONSUMED_TOPIC",
-            `Component "${e.compId}" emits topic "${e.topic}" (${e.via}), but nothing in this tree subscribes to it \u2014 the event goes nowhere. Wire a subscriber (subscribesTo, or a MessageBus subscribe endpoint), fix the topic name, or lint.allow with the external consumer named.`,
+            `Component "${e.compId}" emits topic "${e.topic}" (${e.vias.join(", ")}), but nothing in this tree subscribes to it \u2014 the event goes nowhere. Wire a subscriber (subscribesTo, or a MessageBus subscribe endpoint), fix the topic name, or lint.allow with the external consumer named.`,
             e.compId,
             ctx.isComponentDraft(e.compId)
           );
@@ -5950,7 +5974,7 @@ var init_event_topology = __esm({
           ctx.addIssue(
             "warning",
             "UNSOURCED_SUBSCRIPTION",
-            `Component "${s.compId}" subscribes to topic "${s.topic}" (${s.via}), but nothing in this tree emits it \u2014 the handler can never fire from inside this system. Wire the emitter (emits, or a MessageBus publish endpoint), fix the topic name, or lint.allow with the external source named.`,
+            `Component "${s.compId}" subscribes to topic "${s.topic}" (${s.vias.join(", ")}), but nothing in this tree emits it \u2014 the handler can never fire from inside this system. Wire the emitter (emits, or a MessageBus publish endpoint), fix the topic name, or lint.allow with the external source named.`,
             s.compId,
             ctx.isComponentDraft(s.compId)
           );
@@ -5969,13 +5993,13 @@ var init_structural_conformance = __esm({
     quoteList = (names) => names.map((n) => `"${n}"`).join(", ");
     structuralConformanceRule = {
       name: "structural-conformance",
-      description: "Code\u2194spec Level 1: every source file an implementation names \u2014 its own sourcePath and each method's \u2014 must resolve to a real file inside the project root, and every L3 contract method must be realized in its own source file (the method's sourcePath, else the implementation's) at its conformance tier (declared | anchored | off; Portals default to anchored, everything else to declared; per-method `symbol` maps intent-language names to code names), and every finding code a contract method declares must appear as a string literal in that file (UNREALIZED_FINDING). A file that escapes the root, is missing or cannot be read is reported once and blocks only the methods realized in it. Findings carry the analysis grade (exact AST | pattern table | generic scan) so weaker analysis is visible. Implementations under chained subsystems (projectPath) validate standalone in their own project run and are skipped here.",
+      description: "Code\u2194spec Level 1: every source file an implementation names \u2014 its own sourcePath and each method's \u2014 must resolve to a real file inside the project root, and every L3 contract method must be realized in its own source file (the method's sourcePath, else the implementation's) at its conformance tier (declared | anchored | off; Portals default to anchored, everything else to declared; per-method `symbol` maps intent-language names to code names), and every finding code a contract method declares must be anchored in that file \u2014 as a string literal or, at exact grade, a property-access name (UNREALIZED_FINDING). A file that escapes the root, is missing or cannot be read is reported once and blocks only the methods realized in it. Findings carry the analysis grade (exact AST | pattern table | generic scan) so weaker analysis is visible. Implementations under chained subsystems (projectPath) validate standalone in their own project run and are skipped here.",
       codes: [
         { code: "MISSING_SOURCE_PATH", defaultSeverity: "warning", summary: "An implementation names no source file at all, or a contract method is left without one \u2014 structural conformance cannot link it to code" },
         { code: "MISSING_SOURCE_FILE", defaultSeverity: "error", summary: "A source file an implementation or one of its methods names does not resolve to a file on disk" },
         { code: "SOURCE_PATH_ESCAPES_ROOT", defaultSeverity: "error", summary: "A source file an implementation or one of its methods names is absolute or escapes the project root (containment refusal)" },
         { code: "UNREALIZED_METHOD", defaultSeverity: "warning", summary: "An L3 contract method has no anchor in its own source file (the method's sourcePath, else the implementation's) at the required conformance tier" },
-        { code: "UNREALIZED_FINDING", defaultSeverity: "warning", summary: "A finding code a contract method declares does not appear as a string literal in the method's source file" },
+        { code: "UNREALIZED_FINDING", defaultSeverity: "warning", summary: "A finding code a contract method declares appears in the method's source file neither as a string literal nor as a property-access name (below exact grade, any identifier counts)" },
         { code: "CONFORMANCE_ANALYSIS_SKIPPED", defaultSeverity: "warning", summary: "A source file an implementation or one of its methods names could not be analyzed (binary/unreadable) \u2014 realization of the methods in it was not checked" },
         { code: "CONFORMANCE_DEGRADED", defaultSeverity: "warning", summary: "TypeScript/JavaScript files were analyzed below exact grade (compiler not resolvable) \u2014 dependency conformance skips them" }
       ],
@@ -5985,7 +6009,7 @@ var init_structural_conformance = __esm({
           lookups.set(pathKey(facts.path), {
             declared: /* @__PURE__ */ new Set([...facts.declaredNames, ...facts.exportedNames]),
             anchored: /* @__PURE__ */ new Set([...facts.declaredNames, ...facts.exportedNames, ...facts.anchoredNames]),
-            literals: new Set(facts.anchoredNames),
+            findingAnchors: new Set(facts.anchoredNames),
             facts
           });
         }
@@ -6105,11 +6129,11 @@ var init_structural_conformance = __esm({
             if (!checked) continue;
             const { file, lookup } = checked;
             for (const finding of method2.findings) {
-              if (lookup.literals.has(finding.code)) continue;
+              if (lookup.findingAnchors.has(finding.code)) continue;
               ctx.addIssue(
                 "warning",
                 "UNREALIZED_FINDING",
-                `Method "${method2.name}" of contract "${impl.contract}" declares finding "${finding.code}", but "${file}" has no string literal "${finding.code}" (analysis grade: ${lookup.facts.analysisGrade}) \u2014 report the finding under its declared code, or remove the declaration.`,
+                `Method "${method2.name}" of contract "${impl.contract}" declares finding "${finding.code}", but "${file}" has no string literal or property-access name "${finding.code}" (analysis grade: ${lookup.facts.analysisGrade}) \u2014 report the finding under its declared code, or remove the declaration.`,
                 impl.id,
                 draft
               );
@@ -6225,12 +6249,18 @@ var init_hidden_state = __esm({
       check(ctx) {
         const byPath = /* @__PURE__ */ new Map();
         for (const impl of ctx.implementations) {
-          if (impl.conformance === "off") continue;
           const contract = ctx.interfaceMap.get(impl.contract);
           const component = contract ? ctx.componentMap.get(contract.component) : void 0;
           if (!component) continue;
           if (ctx.isInChainedSubproject(component.subsystem)) continue;
-          for (const file of implementationSourceFiles(impl)) {
+          const trusted = [];
+          if (impl.sourcePath && impl.conformance !== "off") trusted.push(impl.sourcePath);
+          for (const method2 of impl.methods) {
+            if ((method2.conformance ?? impl.conformance) === "off") continue;
+            const file = methodSourceFile(method2, impl.sourcePath);
+            if (file) trusted.push(file);
+          }
+          for (const file of trusted) {
             const key = pathKey(file);
             const list2 = byPath.get(key) ?? [];
             if (list2.some((m) => m.impl === impl)) continue;
@@ -6381,7 +6411,7 @@ var init_dependency_conformance = __esm({
           const fromFiles = filesByComponent.get(component.id);
           if (!fromFiles) continue;
           const isMountingDeclarer = component.componentType === "Portal" || component.componentType === "Observer";
-          const declaredTargets = [...component.dependsOn, ...component.owns ?? []];
+          const declaredTargets = [.../* @__PURE__ */ new Set([...component.dependsOn, ...component.owns ?? []])];
           for (const targetId of declaredTargets) {
             const target = ctx.componentMap.get(targetId);
             if (!target) continue;
@@ -6402,11 +6432,14 @@ var init_dependency_conformance = __esm({
             }
             const impls = implsByComponent.get(component.id) ?? [];
             const anchor = impls[0];
+            const declaredDependsOn = component.dependsOn.includes(targetId);
+            const declaredOwns = (component.owns ?? []).includes(targetId);
+            const relation = declaredDependsOn && declaredOwns ? "dependsOn and owns" : declaredDependsOn ? "dependsOn" : "owns";
             const draft = ctx.isComponentDraft(component.id) || ctx.isComponentDraft(targetId) || impls.some((i) => ctx.isImplementationDraft(i));
             ctx.addIssue(
               "warning",
               "UNREALIZED_DEPENDENCY",
-              `Component "${component.id}" declares ${component.dependsOn.includes(targetId) ? "dependsOn" : "owns"} "${targetId}", but no runtime import connects their source files (${[...fromFiles].join(", ")} \u219B ${target.subsystem !== component.subsystem ? `subsystem ${target.subsystem}` : [...filesByComponent.get(targetId) ?? []].join(", ")}) \u2014 either the collaboration is wired indirectly (DI) or the declared edge is stale.`,
+              `Component "${component.id}" declares ${relation} "${targetId}", but no runtime import connects their source files (${[...fromFiles].join(", ")} \u219B ${target.subsystem !== component.subsystem ? `subsystem ${target.subsystem}` : [...filesByComponent.get(targetId) ?? []].join(", ")}) \u2014 either the collaboration is wired indirectly (DI) or the declared edge is stale.`,
               anchor?.id ?? component.id,
               draft
             );
@@ -6438,28 +6471,28 @@ var init_integration_conformance = __esm({
         const filesByComponent = /* @__PURE__ */ new Map();
         const filesBySubsystem = /* @__PURE__ */ new Map();
         const implsByComponent = /* @__PURE__ */ new Map();
+        const adopted = /* @__PURE__ */ new Set();
+        const exists = (p) => {
+          const status2 = factsByPath.get(p)?.status;
+          return status2 === "analyzed" || status2 === "unreadable";
+        };
         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) continue;
+          if (!comp || ctx.isInChainedSubproject(comp.subsystem)) continue;
           if (!implsByComponent.has(comp.id)) implsByComponent.set(comp.id, []);
           implsByComponent.get(comp.id).push(impl);
           for (const file of implementationSourceFiles(impl)) {
             const p = pathKey(file);
+            if (!exists(p)) continue;
             if (!filesByComponent.has(comp.id)) filesByComponent.set(comp.id, /* @__PURE__ */ new Set());
             filesByComponent.get(comp.id).add(p);
             if (!filesBySubsystem.has(comp.subsystem)) filesBySubsystem.set(comp.subsystem, /* @__PURE__ */ new Set());
             filesBySubsystem.get(comp.subsystem).add(p);
           }
+          if (impl.simPath) adopted.add(comp.subsystem);
         }
         const isTechBoundary = (compId) => (implsByComponent.get(compId) ?? []).some((i) => (i.technologies ?? []).length > 0);
-        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) adopted.add(comp.subsystem);
-        }
         const reachFrom = (start) => {
           const seen = /* @__PURE__ */ new Set([start]);
           const stack = [start];
@@ -6656,8 +6689,8 @@ var init_coupling_health = __esm({
             );
           }
         }
-        const threshold = ctx.rules?.complexity?.maxComponentDependencies ?? DEFAULT_GOD_COMPONENT_THRESHOLD;
         for (const comp of ctx.components) {
+          const threshold = ctx.complexityConfigFor(comp.subsystem)?.maxComponentDependencies ?? DEFAULT_GOD_COMPONENT_THRESHOLD;
           if (comp.dependsOn.length > threshold) {
             ctx.addIssue(
               "warning",
@@ -6785,7 +6818,7 @@ var init_target_language = __esm({
           if (!lang) continue;
           const gaps = gapsFor(lang);
           if (Object.keys(gaps).length === 0) continue;
-          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) {
             for (const step of implMethod.narrative) {
               const constructs = [
@@ -6887,7 +6920,7 @@ var init_technology_boundaries = __esm({
               "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.isComponentDraft(comp.id)
+              ctx.isImplementationDraft(impl)
             );
           }
           const compSet = ownsClosure(ownershipRoot(comp.id));
@@ -6925,7 +6958,7 @@ var init_technology_boundaries = __esm({
                 "VENDOR_NAME_IN_CONTRACT",
                 `Interface "${intf.id}" exposes technology "${home.label}" in contract identifiers (method${offending.length > 1 ? "s" : ""}: ${offending.join(", ")}). Name the intent, not the vendor \u2014 the technology is owned by component ${ownersDesc(home)} and must stay swappable behind this contract.`,
                 intf.id,
-                ctx.isComponentDraft(intf.component)
+                ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design"
               );
             }
           }
@@ -6956,7 +6989,8 @@ var init_technology_boundaries = __esm({
                 "warning",
                 "TECH_LEAKAGE",
                 `Subsystem "${sub.id}" references "${home.label}" outside the technology's owning boundary (component ${ownersDesc(home)}).`,
-                sub.id
+                sub.id,
+                isDraftSubsystem(sub)
               );
             }
           }
@@ -6969,7 +7003,7 @@ var init_technology_boundaries = __esm({
                 "TECH_LEAKAGE",
                 `Interface "${intf.id}" describes "${home.label}" outside its owning boundary (component ${ownersDesc(home)}) \u2014 consumers must not know backend specifics.`,
                 intf.id,
-                ctx.isComponentDraft(intf.component)
+                ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design"
               );
             }
           }
@@ -6989,7 +7023,8 @@ var init_technology_boundaries = __esm({
                 "warning",
                 "TECH_LEAKAGE",
                 `Implementation "${impl.id}" references "${home.label}" outside its owning boundary \u2014 call the intent interface of component ${ownersDesc(home)} instead of naming its technology.`,
-                impl.id
+                impl.id,
+                ctx.isImplementationDraft(impl)
               );
             }
           }
@@ -7052,6 +7087,7 @@ var casingPatterns, isAllUppercase, namingRule;
 var init_naming_conventions = __esm({
   "src/core/rules/heuristic/naming-conventions.ts"() {
     "use strict";
+    init_models();
     casingPatterns = {
       camelCase: /^[a-z][a-zA-Z0-9]*$/,
       PascalCase: /^[A-Z][a-zA-Z0-9]*$/,
@@ -7072,9 +7108,10 @@ var init_naming_conventions = __esm({
         for (const sub of ctx.subsystems) {
           const namingConfig = ctx.namingConfigFor(sub.id);
           if (!namingConfig?.subsystems) continue;
+          const isDraft = isDraftSubsystem(sub);
           const baseId = getBaseId(sub.id);
-          checkNamedValue(ctx, baseId, namingConfig.subsystems, `Subsystem ID "${sub.id}" does not match naming convention "${namingConfig.subsystems}".`, sub.id);
-          checkNamedValue(ctx, sub.name, namingConfig.subsystems, `Subsystem Name "${sub.name}" does not match naming convention "${namingConfig.subsystems}".`, sub.id);
+          checkNamedValue(ctx, baseId, namingConfig.subsystems, `Subsystem ID "${sub.id}" does not match naming convention "${namingConfig.subsystems}".`, sub.id, isDraft);
+          checkNamedValue(ctx, sub.name, namingConfig.subsystems, `Subsystem Name "${sub.name}" does not match naming convention "${namingConfig.subsystems}".`, sub.id, isDraft);
         }
         for (const comp of ctx.components) {
           const namingConfig = ctx.namingConfigFor(comp.subsystem);
@@ -7159,7 +7196,7 @@ var init_naming_conventions = __esm({
           const intf = ctx.interfaceMap.get(impl.contract);
           const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
           const namingConfig = ctx.namingConfigFor(comp?.subsystem);
-          const isDraft = impl.status === "draft" || impl.status === "design";
+          const isDraft = ctx.isImplementationDraft(impl);
           if (namingConfig?.methods) {
             for (const m of impl.methods) {
               checkNamedValue(ctx, m.name, namingConfig.methods, `Implementation method "${m.name}" on "${impl.id}" does not match naming convention "${namingConfig.methods}".`, impl.id, isDraft);
@@ -7223,6 +7260,7 @@ var complexityRule;
 var init_complexity_and_metadata = __esm({
   "src/core/rules/heuristic/complexity-and-metadata.ts"() {
     "use strict";
+    init_models();
     complexityRule = {
       name: "complexity-and-metadata",
       description: "Enforces metadata documentation completeness (checking if descriptions are missing or too short) and structural complexity caps (limits on methods per interface, dependencies per component, and narrative steps per method) configured globally or in architectural profiles.",
@@ -7238,7 +7276,8 @@ var init_complexity_and_metadata = __esm({
       check(ctx) {
         for (const sub of ctx.subsystems) {
           const docConfig = ctx.documentationConfigFor(sub.id);
-          checkDescription(ctx, sub.description, docConfig?.requireDescriptions ?? false, docConfig?.minDescriptionLength, sub.id, "Subsystem", false);
+          const isSubDraft = isDraftSubsystem(sub);
+          checkDescription(ctx, sub.description, docConfig?.requireDescriptions ?? false, docConfig?.minDescriptionLength, sub.id, "Subsystem", isSubDraft);
           const complexityConfig = ctx.complexityConfigFor(sub.id);
           const directComponents = ctx.components.filter((c) => c.subsystem === sub.id).length;
           if (complexityConfig?.maxSubsystemComponents !== void 0 && directComponents > complexityConfig.maxSubsystemComponents) {
@@ -7246,7 +7285,8 @@ var init_complexity_and_metadata = __esm({
               "warning",
               "EXCESSIVE_SUBSYSTEM_COMPONENTS",
               `Subsystem "${sub.id}" has ${directComponents} direct components, exceeding the configured limit of ${complexityConfig.maxSubsystemComponents}.`,
-              sub.id
+              sub.id,
+              isSubDraft
             );
           }
         }
@@ -7322,7 +7362,7 @@ var init_complexity_and_metadata = __esm({
           const intf = ctx.interfaceMap.get(impl.contract);
           const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
           const complexityConfig = ctx.complexityConfigFor(comp?.subsystem);
-          const isDraft = impl.status === "draft" || impl.status === "design";
+          const isDraft = ctx.isImplementationDraft(impl);
           if (complexityConfig?.maxNarrativeSteps !== void 0) {
             for (const m of impl.methods) {
               if (m.narrative.length > complexityConfig.maxNarrativeSteps) {
@@ -14029,7 +14069,7 @@ function buildRuleContext(opts) {
       return rules.sddRuleSeverity[ruleCode];
     }
     const sub = subsystemId ? subsystems.find((s) => s.id === subsystemId) : void 0;
-    const profileSeverity = extensions.profiles[sub?.profile ?? projectType]?.rules?.sddRuleSeverity?.[ruleCode];
+    const profileSeverity = extensions.profiles[sub?.profile || projectType]?.rules?.sddRuleSeverity?.[ruleCode];
     if (profileSeverity) {
       return profileSeverity;
     }