@wairon/cli 5.1.1-dev.23 → 5.1.1-dev.25

package/dist/index.js

@@ -1113,7 +1113,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.23";
+    WAIRON_VERSION = "5.1.1-dev.25";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     ARCHITECT_AGENT_ID = "agent-architect";
     ARCHITECT_TEMPLATE_ID = "architect";
@@ -1997,7 +1997,7 @@ var init_specs = __esm({
        * entity's write methods must carry (UNASSERTED_INVARIANT otherwise).
        */
       assertsInvariants: import_zod8.z.array(import_zod8.z.string()).optional(),
-      // --- flow config (per type; validated by the narrative-flow rule) ---------
+      // --- flow config (per type; validated by narrative-step-config) -----------
       condition: import_zod8.z.string().optional(),
       // branch; loop (while/doWhile)
       onTrueStep: import_zod8.z.number().int().positive().optional(),
@@ -2098,7 +2098,7 @@ var init_specs = __esm({
       methods: import_zod8.z.array(MethodImplementationSchema).default([]),
       /** Spec-level narrative detail default for all methods (each may override). */
       detail: NarrativeDetailSchema.optional(),
-      /** Spec-level structural-conformance tier default (each method may override). */
+      /** Spec-level conformance tier default (each method may override). */
       conformance: ConformanceTierSchema.optional(),
       /** Per-spec lint suppressions (see LintConfigSchema). */
       lint: LintConfigSchema.optional(),
@@ -2529,6 +2529,149 @@ var init_step_graph = __esm({
   }
 });
 
+// src/models/step-config.ts
+function flowConfigOn(step) {
+  return FLOW_FIELDS.filter((f) => {
+    const v = step[f];
+    if (v === void 0) return false;
+    if (Array.isArray(v) && v.length === 0) return false;
+    return true;
+  });
+}
+function stepConfigVerdict(method) {
+  const steps = method.narrative ?? [];
+  const problems = [];
+  let sound = true;
+  const malformed = (stepNumber, detail) => {
+    sound = false;
+    problems.push({ stepNumber, code: "MALFORMED_FLOW_STEP", detail });
+  };
+  const labelled = /* @__PURE__ */ new Map();
+  for (const step of steps) {
+    const label = step.label;
+    if (!label) continue;
+    const first = labelled.get(label);
+    if (first !== void 0) {
+      problems.push({
+        stepNumber: step.stepNumber,
+        code: "DUPLICATE_STEP_LABEL",
+        detail: `steps ${first} and ${step.stepNumber} share the label "${label}". A label anchors one step for later deltas to address; two steps holding it makes every symbolic reference ambiguous and blocks all further edits to this implementation. Rename one.`
+      });
+    } else {
+      labelled.set(label, step.stepNumber);
+    }
+  }
+  const byNum = /* @__PURE__ */ new Map();
+  for (const s of steps) {
+    if (byNum.has(s.stepNumber)) malformed(s.stepNumber, `duplicate stepNumber ${s.stepNumber} \u2014 jump targets would be ambiguous.`);
+    byNum.set(s.stepNumber, s);
+  }
+  const nums = [...byNum.keys()].sort((a, b) => a - b);
+  const indexOf = new Map(nums.map((n, i) => [n, i]));
+  const nextOf = (n) => {
+    const i = indexOf.get(n);
+    return i !== void 0 && i + 1 < nums.length ? nums[i + 1] : void 0;
+  };
+  for (const s of steps) {
+    if (s.detach && s.type !== "call" && s.type !== "dispatch") {
+      malformed(s.stepNumber, `step ${s.stepNumber} (${s.type}) carries "detach" \u2014 fire-and-forget applies to call/dispatch steps only.`);
+    }
+    switch (s.type) {
+      case "local":
+      case "call":
+      case "register":
+      case "dispatch": {
+        const extra = flowConfigOn(s);
+        if (extra.length) malformed(s.stepNumber, `step ${s.stepNumber} (${s.type}) carries flow config (${extra.join(", ")}) \u2014 use a flow step type instead.`);
+        break;
+      }
+      case "branch":
+        if (!s.condition) malformed(s.stepNumber, `branch step ${s.stepNumber} requires "condition".`);
+        if (s.onFalseStep === void 0) malformed(s.stepNumber, `branch step ${s.stepNumber} requires "onFalseStep" (true continues at onTrueStep or the next step).`);
+        break;
+      case "switch":
+        if (!s.cases || !s.cases.length) malformed(s.stepNumber, `switch step ${s.stepNumber} requires non-empty "cases".`);
+        break;
+      case "loop": {
+        if (s.endStep === void 0) malformed(s.stepNumber, `loop step ${s.stepNumber} requires "endStep" (last step of the body).`);
+        else if (s.endStep <= s.stepNumber) malformed(s.stepNumber, `loop step ${s.stepNumber} "endStep" (${s.endStep}) must lie beyond the header.`);
+        const kind = s.loopKind ?? (s.over ? "forEach" : "while");
+        if ((kind === "while" || kind === "doWhile") && !s.condition) malformed(s.stepNumber, `${kind} loop step ${s.stepNumber} requires "condition".`);
+        if ((kind === "forEach" || kind === "for") && !s.over) malformed(s.stepNumber, `${kind} loop step ${s.stepNumber} requires "over" (the iteration source).`);
+        break;
+      }
+      case "try":
+        if (s.endStep === void 0) malformed(s.stepNumber, `try step ${s.stepNumber} requires "endStep" (last step of the guarded body).`);
+        else if (s.endStep <= s.stepNumber) malformed(s.stepNumber, `try step ${s.stepNumber} "endStep" (${s.endStep}) must lie beyond the header.`);
+        if ((!s.catches || !s.catches.length) && s.finallyStep === void 0) malformed(s.stepNumber, `try step ${s.stepNumber} requires "catches" and/or "finallyStep" \u2014 a guard that handles nothing guards nothing.`);
+        break;
+      case "parallel": {
+        if (s.endStep === void 0) malformed(s.stepNumber, `parallel step ${s.stepNumber} requires "endStep" (last step of the fan-out body).`);
+        else if (s.endStep <= s.stepNumber) malformed(s.stepNumber, `parallel step ${s.stepNumber} "endStep" (${s.endStep}) must lie beyond the header.`);
+        const entries = (s.branches ?? []).map((b) => b.step);
+        if (entries.length < 2) {
+          malformed(s.stepNumber, `parallel step ${s.stepNumber} requires "branches" with at least two arms \u2014 a single arm is sequential flow.`);
+        } else {
+          const sorted = [...entries].sort((a, b) => a - b);
+          if (entries.some((e, i) => e !== sorted[i])) malformed(s.stepNumber, `parallel step ${s.stepNumber} "branches" must list arm entries in ascending order \u2014 arms are contiguous sub-regions of the body.`);
+          if (new Set(entries).size !== entries.length) malformed(s.stepNumber, `parallel step ${s.stepNumber} "branches" lists the same entry step twice.`);
+          const bodyStart = nextOf(s.stepNumber);
+          if (bodyStart !== void 0 && sorted[0] !== bodyStart) malformed(s.stepNumber, `parallel step ${s.stepNumber}: the first arm must start at the body's first step (${bodyStart}), got ${sorted[0]} \u2014 steps before the first arm would belong to no arm.`);
+          if (s.endStep !== void 0 && sorted.some((e) => e > s.endStep)) malformed(s.stepNumber, `parallel step ${s.stepNumber}: every arm entry must lie within the body (..${s.endStep}).`);
+        }
+        break;
+      }
+      case "jump":
+        if (s.toStep === void 0) malformed(s.stepNumber, `jump step ${s.stepNumber} requires "toStep".`);
+        break;
+    }
+    for (const [field, target] of jumpFieldsOf(s)) {
+      if (byNum.has(target)) continue;
+      sound = false;
+      problems.push({
+        stepNumber: s.stepNumber,
+        code: "INVALID_STEP_JUMP",
+        detail: `step ${s.stepNumber} "${field}" targets step ${target}, which does not exist in this narrative.`
+      });
+    }
+  }
+  return { problems, sound };
+}
+function jumpFieldsOf(s) {
+  const fields = [];
+  if (s.onTrueStep !== void 0) fields.push(["onTrueStep", s.onTrueStep]);
+  if (s.onFalseStep !== void 0) fields.push(["onFalseStep", s.onFalseStep]);
+  if (s.defaultStep !== void 0) fields.push(["defaultStep", s.defaultStep]);
+  if (s.endStep !== void 0) fields.push(["endStep", s.endStep]);
+  if (s.finallyStep !== void 0) fields.push(["finallyStep", s.finallyStep]);
+  if (s.toStep !== void 0) fields.push(["toStep", s.toStep]);
+  (s.cases ?? []).forEach((c, i) => fields.push([`cases[${i}].step`, c.step]));
+  (s.catches ?? []).forEach((c, i) => fields.push([`catches[${i}].step`, c.step]));
+  (s.branches ?? []).forEach((b, i) => fields.push([`branches[${i}].step`, b.step]));
+  return fields;
+}
+var FLOW_FIELDS;
+var init_step_config = __esm({
+  "src/models/step-config.ts"() {
+    "use strict";
+    FLOW_FIELDS = [
+      "condition",
+      "onTrueStep",
+      "onFalseStep",
+      "on",
+      "cases",
+      "defaultStep",
+      "loopKind",
+      "over",
+      "endStep",
+      "catches",
+      "finallyStep",
+      "branches",
+      "toStep"
+    ];
+  }
+});
+
 // src/models/code-model.ts
 function pathKey(sourcePath) {
   return sourcePath.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -2596,6 +2739,7 @@ var init_models = __esm({
     init_specs();
     init_type_references();
     init_step_graph();
+    init_step_config();
     init_code_model();
     init_surface_references();
   }
@@ -8697,18 +8841,16 @@ var init_roundtrip_serialization = __esm({
   }
 });
 
-// src/core/rules/integrity/type-references.ts
-var typeReferencesRule;
-var init_type_references2 = __esm({
-  "src/core/rules/integrity/type-references.ts"() {
+// src/core/rules/integrity/type-declarations.ts
+var typeDeclarationsRule;
+var init_type_declarations = __esm({
+  "src/core/rules/integrity/type-declarations.ts"() {
     "use strict";
-    init_models();
-    typeReferencesRule = {
-      name: "type-references",
-      description: "Type fields and interface method signatures may only reference builtins, in-scope generic parameters, or defined entity/value-object types. Types owned by a subsystem must reference an existing subsystem.",
+    typeDeclarationsRule = {
+      name: "type-declarations",
+      description: "A type owned by a subsystem must reference an existing one, and a type declaring neither fields nor methods is a placeholder that can inform neither implementers nor the ERD.",
       codes: [
         { code: "INVALID_SUBSYSTEM_REFERENCE", defaultSeverity: "error", summary: "Type references a non-existent owning subsystem" },
-        { code: "UNDEFINED_TYPE_REFERENCE", defaultSeverity: "error", summary: "Reference to a type that is not defined anywhere" },
         { code: "HOLLOW_TYPE", defaultSeverity: "warning", summary: "Type declares no fields and no methods \u2014 a placeholder that informs neither implementers nor the ERD" }
       ],
       check(ctx) {
@@ -8733,23 +8875,62 @@ var init_type_references2 = __esm({
               isDraftCtx
             );
           }
-          if (t.fields) {
-            for (const field of t.fields) {
-              const refs = fieldTypeRefs(t, field.type);
-              for (const ref of refs) {
-                if (!ctx.isTypeResolved(ref, /* @__PURE__ */ new Set())) {
-                  ctx.addIssue(
-                    "error",
-                    "UNDEFINED_TYPE_REFERENCE",
-                    `Type "${t.id}" field "${field.name}" references undefined type "${ref}" in "${field.type}".`,
-                    t.id,
-                    isDraftCtx
-                  );
-                }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/integrity/field-type-references.ts
+var fieldTypeReferencesRule;
+var init_field_type_references = __esm({
+  "src/core/rules/integrity/field-type-references.ts"() {
+    "use strict";
+    init_models();
+    fieldTypeReferencesRule = {
+      name: "field-type-references",
+      description: "Every type identifier a type field's declared type names must resolve to a builtin or a defined entity/value-object type \u2014 the type's own generic parameters are not field references.",
+      codes: [
+        { code: "UNDEFINED_TYPE_REFERENCE", defaultSeverity: "error", summary: "Reference to a type that is not defined anywhere" }
+      ],
+      check(ctx) {
+        for (const t of ctx.types) {
+          const sub = ctx.subsystems.find((s) => s.id === t.subsystem);
+          const isDraftCtx = sub ? sub.status === "draft" || sub.status === "design" : false;
+          if (!t.fields) continue;
+          for (const field of t.fields) {
+            const refs = fieldTypeRefs(t, field.type);
+            for (const ref of refs) {
+              if (!ctx.isTypeResolved(ref, /* @__PURE__ */ new Set())) {
+                ctx.addIssue(
+                  "error",
+                  "UNDEFINED_TYPE_REFERENCE",
+                  `Type "${t.id}" field "${field.name}" references undefined type "${ref}" in "${field.type}".`,
+                  t.id,
+                  isDraftCtx
+                );
               }
             }
           }
         }
+      }
+    };
+  }
+});
+
+// src/core/rules/integrity/signature-type-references.ts
+var signatureTypeReferencesRule;
+var init_signature_type_references = __esm({
+  "src/core/rules/integrity/signature-type-references.ts"() {
+    "use strict";
+    init_models();
+    signatureTypeReferencesRule = {
+      name: "signature-type-references",
+      description: "Every type identifier an interface method signature names must resolve to a builtin, a generic parameter in scope on the interface or the method, or a defined entity/value-object type.",
+      codes: [
+        { code: "UNDEFINED_TYPE_REFERENCE", defaultSeverity: "error", summary: "Reference to a type that is not defined anywhere" }
+      ],
+      check(ctx) {
         for (const intf of ctx.interfaces) {
           const isDraftCtx = ctx.isComponentDraft(intf.component) || intf.status === "draft" || intf.status === "design";
           const interfaceGenerics = new Set(
@@ -8905,27 +9086,17 @@ var init_lint_allows = __esm({
   }
 });
 
-// src/core/rules/narrative/contract-symmetry-and-narratives.ts
-var contractsRule;
-var init_contract_symmetry_and_narratives = __esm({
-  "src/core/rules/narrative/contract-symmetry-and-narratives.ts"() {
+// src/core/rules/narrative/contract-symmetry.ts
+var contractSymmetryRule;
+var init_contract_symmetry = __esm({
+  "src/core/rules/narrative/contract-symmetry.ts"() {
     "use strict";
-    init_models();
-    contractsRule = {
-      name: "contract-symmetry-and-narratives",
-      description: "Implementations mirror their contract method-for-method. Narrative call steps (and register handoffs, which share the identical target shape) must name an existing component and method, the caller must declare the dependency, and asserted semantic guarantees must be backed by the target contract.",
+    contractSymmetryRule = {
+      name: "contract-symmetry",
+      description: "Implementations mirror their contract method-for-method: every method an implementation declares is defined on the contract it realizes, and every contract method has an implementation.",
       codes: [
         { code: "UNEXPECTED_IMPLEMENTATION_METHOD", defaultSeverity: "error", summary: "Implementation method not present on the contract" },
-        { code: "MISSING_IMPLEMENTATION_METHOD", defaultSeverity: "error", summary: "Contract method missing from the implementation" },
-        { code: "MISSING_TARGET_COMPONENT", defaultSeverity: "error", summary: "Call/register step missing targetComponent" },
-        { code: "MISSING_TARGET_METHOD", defaultSeverity: "error", summary: "Call/register step missing targetMethod" },
-        { code: "INVALID_TARGET_COMPONENT_REFERENCE", defaultSeverity: "error", summary: "Call/register step targets a non-existent component" },
-        { code: "CROSS_TREE_REF_UNRESOLVED", defaultSeverity: "warning", summary: "Cross-tree reference (super::/:: form) with no surface snapshot covering it \u2014 only the parent project can verify it" },
-        { code: "SURFACE_REF_NOT_EXPOSED", defaultSeverity: "error", summary: "Cross-tree reference resolves to a surface snapshot that does not expose the called method/capability" },
-        { code: "SURFACE_REF_AMBIGUOUS", defaultSeverity: "error", summary: "Cross-tree call/dispatch/register target matched by surface snapshots of several providers with different contracts" },
-        { code: "UNDECLARED_DEPENDENCY_CALL", defaultSeverity: "error", summary: "Call step targets a component the caller does not depend on or own" },
-        { code: "INVALID_TARGET_METHOD_REFERENCE", defaultSeverity: "error", summary: "Call step targets a method not on any target interface" },
-        { code: "NARRATIVE_SEMANTIC_UNBACKED", defaultSeverity: "warning", summary: "Narrative asserts a guarantee the called contract does not declare" }
+        { code: "MISSING_IMPLEMENTATION_METHOD", defaultSeverity: "error", summary: "Contract method missing from the implementation" }
       ],
       check(ctx) {
         for (const impl of ctx.implementations) {
@@ -8956,6 +9127,33 @@ var init_contract_symmetry_and_narratives = __esm({
               );
             }
           }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/narrative/narrative-target-references.ts
+var narrativeTargetReferencesRule;
+var init_narrative_target_references = __esm({
+  "src/core/rules/narrative/narrative-target-references.ts"() {
+    "use strict";
+    narrativeTargetReferencesRule = {
+      name: "narrative-target-references",
+      description: "A narrative call, dispatch or register step must name a target component, and a target method unless it dispatches. A target this tree contains must be a collaborator the calling component declares, must carry the named method on one of its interfaces, and that method must declare every semantic guarantee the step asserts.",
+      codes: [
+        { code: "MISSING_TARGET_COMPONENT", defaultSeverity: "error", summary: "Call/register step missing targetComponent" },
+        { code: "MISSING_TARGET_METHOD", defaultSeverity: "error", summary: "Call/register step missing targetMethod" },
+        { code: "UNDECLARED_DEPENDENCY_CALL", defaultSeverity: "error", summary: "Call step targets a component the caller does not depend on or own" },
+        { code: "INVALID_TARGET_METHOD_REFERENCE", defaultSeverity: "error", summary: "Call step targets a method not on any target interface" },
+        { code: "NARRATIVE_SEMANTIC_UNBACKED", defaultSeverity: "warning", summary: "Narrative asserts a guarantee the called contract does not declare" }
+      ],
+      check(ctx) {
+        for (const impl of ctx.implementations) {
+          const contract = ctx.interfaceMap.get(impl.contract);
+          if (!contract) continue;
+          const isDraftCtx = ctx.isImplementationDraft(impl);
+          const caller = ctx.componentMap.get(contract.component);
           for (const implMethod of impl.methods) {
             for (const step of implMethod.narrative) {
               if (step.type !== "call" && step.type !== "dispatch" && step.type !== "register") continue;
@@ -8970,156 +9168,28 @@ var init_contract_symmetry_and_narratives = __esm({
                 continue;
               }
               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;
+              const verb = step.type === "dispatch" ? "dispatches through" : step.type === "register" ? "registers callback" : "calls";
+              if (step.type !== "dispatch" && !step.targetMethod) {
                 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.`,
+                  "MISSING_TARGET_METHOD",
+                  `Method "${implMethod.name}" in implementation "${impl.id}" has a ${step.type} step (${step.stepNumber}) missing "targetMethod".`,
                   impl.id,
-                  isDraftCtx || ctx.isComponentDraft(caller.id),
-                  surfaceResolved
+                  isDraftCtx
                 );
-              };
-              if (step.type === "dispatch") {
-                const dispatchTarget = ctx.componentMap.get(target);
-                if (!dispatchTarget) {
-                  if (isCrossTreeForm || isCollapsedForm) {
-                    const resolved = ctx.resolveSurfaceRef(target, fromSubsystem);
-                    if (resolved.kind === "ambiguous") {
-                      ctx.addIssue(
-                        "error",
-                        "SURFACE_REF_AMBIGUOUS",
-                        ambiguityMessage(
-                          resolved,
-                          `Method "${implMethod.name}" in implementation "${impl.id}" dispatches (step ${step.stepNumber}) through`,
-                          target
-                        ),
-                        impl.id,
-                        isDraftCtx
-                      );
-                      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 "${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
-                        );
-                      }
-                      continue;
-                    }
-                  }
-                  if (isCrossTreeForm) {
-                    ctx.addIssue(
-                      "warning",
-                      "CROSS_TREE_REF_UNRESOLVED",
-                      `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
-                    );
-                  } else {
-                    ctx.addIssue(
-                      "error",
-                      "INVALID_TARGET_COMPONENT_REFERENCE",
-                      `Method "${implMethod.name}" in implementation "${impl.id}" dispatches through component "${target}" which does not exist (step ${step.stepNumber}).`,
-                      impl.id,
-                      isDraftCtx
-                    );
-                  }
-                  continue;
-                }
-                reportUndeclared("dispatches through");
                 continue;
               }
-              const verb = step.type === "register" ? "registers callback" : "calls";
-              if (!step.targetMethod) {
+              if (!ctx.componentMap.get(target)) continue;
+              if (caller && target !== caller.id && !caller.dependsOn.includes(target) && !caller.owns.includes(target)) {
                 ctx.addIssue(
                   "error",
-                  "MISSING_TARGET_METHOD",
-                  `Method "${implMethod.name}" in implementation "${impl.id}" has a ${step.type} step (${step.stepNumber}) missing "targetMethod".`,
+                  "UNDECLARED_DEPENDENCY_CALL",
+                  `Method "${implMethod.name}" in implementation "${impl.id}" (component "${caller.id}") ${verb} component "${target}" (step ${step.stepNumber}) but component "${caller.id}" does not list "${target}" as a dependency.`,
                   impl.id,
-                  isDraftCtx
+                  isDraftCtx || ctx.isComponentDraft(caller.id)
                 );
-                continue;
-              }
-              const targetComp = ctx.componentMap.get(target);
-              if (!targetComp) {
-                if (isCrossTreeForm || isCollapsedForm) {
-                  const resolved = ctx.resolveSurfaceRef(target, fromSubsystem);
-                  if (resolved.kind === "ambiguous") {
-                    ctx.addIssue(
-                      "error",
-                      "SURFACE_REF_AMBIGUOUS",
-                      ambiguityMessage(
-                        resolved,
-                        `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} "${step.targetMethod}" (step ${step.stepNumber}) on`,
-                        target
-                      ),
-                      impl.id,
-                      isDraftCtx
-                    );
-                    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 "${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
-                      );
-                    } else if (step.assertsGuarantees) {
-                      const declared = new Set(surfaceMethod.guarantees ?? []);
-                      for (const g of step.assertsGuarantees) {
-                        if (!declared.has(g)) {
-                          ctx.addIssue(
-                            "warning",
-                            "NARRATIVE_SEMANTIC_UNBACKED",
-                            `Step ${step.stepNumber} of "${implMethod.name}" in implementation "${impl.id}" asserts guarantee "${g}", but the surface snapshot of "${resolved.snapshot.projectName}" does not declare it on "${resolved.entry.id}.${step.targetMethod}".`,
-                            impl.id,
-                            isDraftCtx,
-                            true
-                          );
-                        }
-                      }
-                    }
-                    continue;
-                  }
-                }
-                if (isCrossTreeForm) {
-                  ctx.addIssue(
-                    "warning",
-                    "CROSS_TREE_REF_UNRESOLVED",
-                    `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
-                  );
-                } else {
-                  ctx.addIssue(
-                    "error",
-                    "INVALID_TARGET_COMPONENT_REFERENCE",
-                    `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} component "${target}" which does not exist (step ${step.stepNumber}).`,
-                    impl.id,
-                    isDraftCtx
-                  );
-                }
-                continue;
               }
-              reportUndeclared(verb);
+              if (step.type === "dispatch") continue;
               const targetInterfaces = ctx.interfacesByComponent.get(target) ?? [];
               let targetMethodSpec;
               for (const targetIntf of targetInterfaces) {
@@ -9137,20 +9207,18 @@ var init_contract_symmetry_and_narratives = __esm({
                   impl.id,
                   isDraftCtx || ctx.isComponentDraft(target)
                 );
-              } else {
-                const declared = new Set(targetMethodSpec.guarantees ?? []);
-                if (step.assertsGuarantees) {
-                  for (const g of step.assertsGuarantees) {
-                    if (!declared.has(g)) {
-                      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 "${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(target)
-                      );
-                    }
-                  }
+                continue;
+              }
+              const declared = new Set(targetMethodSpec.guarantees ?? []);
+              for (const g of step.assertsGuarantees ?? []) {
+                if (!declared.has(g)) {
+                  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 "${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(target)
+                  );
                 }
               }
             }
@@ -9161,220 +9229,285 @@ var init_contract_symmetry_and_narratives = __esm({
   }
 });
 
-// src/core/rules/narrative/guarantee-tokens.ts
-var guaranteeTokensRule;
-var init_guarantee_tokens = __esm({
-  "src/core/rules/narrative/guarantee-tokens.ts"() {
+// src/core/rules/narrative/cross-tree-references.ts
+var crossTreeReferencesRule;
+var init_cross_tree_references = __esm({
+  "src/core/rules/narrative/cross-tree-references.ts"() {
     "use strict";
     init_models();
-    guaranteeTokensRule = {
-      name: "guarantee-tokens",
-      description: "Every semantic-guarantee token an L3 method declares or a narrative step asserts must be a builtin guarantee or one a loaded extension pack declares in its `guarantees` list. The vocabulary is open for packs, not for typos \u2014 an undeclared token is matched by nothing and silently escapes the narrative\u2194contract consistency checks.",
+    crossTreeReferencesRule = {
+      name: "cross-tree-references",
+      description: "A narrative call, dispatch or register target that is not a component of this tree must resolve against the stored surface snapshots to exactly one declared contract. Snapshots that expose the name with disagreeing contracts leave the reference ambiguous; no snapshot at all is a warning for a reference that points outside this loading root (only the parent project can verify it) and the error a genuine local typo has always got.",
       codes: [
-        { code: "UNKNOWN_GUARANTEE", defaultSeverity: "warning", summary: "Guarantee token is neither builtin nor pack-declared" }
+        { code: "INVALID_TARGET_COMPONENT_REFERENCE", defaultSeverity: "error", summary: "Call/register step targets a non-existent component" },
+        { code: "CROSS_TREE_REF_UNRESOLVED", defaultSeverity: "warning", summary: "Cross-tree reference (super::/:: form) with no surface snapshot covering it \u2014 only the parent project can verify it" },
+        { code: "SURFACE_REF_AMBIGUOUS", defaultSeverity: "error", summary: "Cross-tree call/dispatch/register target matched by surface snapshots of several providers with different contracts" }
       ],
       check(ctx) {
-        const known = /* @__PURE__ */ new Set([...SEMANTIC_GUARANTEES, ...ctx.ext.guarantees]);
-        const fixHint = `Known tokens: builtin ${SEMANTIC_GUARANTEES.join(", ")}${ctx.ext.guarantees.length ? `; pack-declared ${ctx.ext.guarantees.join(", ")}` : ""}. Fix the spelling or declare the token in an extension pack's \`guarantees\` list.`;
-        for (const intf of ctx.interfaces) {
-          const isDraftCtx = intf.status === "draft" || intf.status === "design" || ctx.isComponentDraft(intf.component);
-          for (const method of intf.methods) {
-            for (const g of method.guarantees ?? []) {
-              if (!known.has(g)) {
-                ctx.addIssue(
-                  "warning",
-                  "UNKNOWN_GUARANTEE",
-                  `Method "${method.name}" on interface "${intf.id}" declares guarantee "${g}", which is neither a builtin guarantee nor declared by any loaded extension pack \u2014 no narrative assertion can ever match it. ${fixHint}`,
-                  intf.id,
-                  isDraftCtx
-                );
-              }
-            }
-          }
-        }
         for (const impl of ctx.implementations) {
+          const contract = ctx.interfaceMap.get(impl.contract);
+          if (!contract) continue;
           const isDraftCtx = ctx.isImplementationDraft(impl);
-          for (const method of impl.methods) {
-            for (const step of method.narrative ?? []) {
-              for (const g of step.assertsGuarantees ?? []) {
-                if (!known.has(g)) {
+          const caller = ctx.componentMap.get(contract.component);
+          const fromSubsystem = caller?.subsystem;
+          for (const implMethod of impl.methods) {
+            for (const step of implMethod.narrative) {
+              if (step.type !== "call" && step.type !== "dispatch" && step.type !== "register") continue;
+              if (!step.targetComponent) continue;
+              if (step.type !== "dispatch" && !step.targetMethod) continue;
+              const target = step.targetComponent;
+              if (ctx.componentMap.get(target)) continue;
+              const verb = step.type === "dispatch" ? "dispatches through" : step.type === "register" ? "registers callback" : "calls";
+              const isCrossTreeForm = ctx.isExternalNamespaceRef(target);
+              const isCollapsedForm = !isCrossTreeForm && fromSubsystem !== void 0 && ctx.isCollapsedCrossTreeRef(target, fromSubsystem);
+              if (isCrossTreeForm || isCollapsedForm) {
+                const resolved = ctx.resolveSurfaceRef(target, fromSubsystem);
+                if (resolved.kind === "ambiguous") {
                   ctx.addIssue(
-                    "warning",
-                    "UNKNOWN_GUARANTEE",
-                    `Step ${step.stepNumber} of "${method.name}" in implementation "${impl.id}" asserts guarantee "${g}", which is neither a builtin guarantee nor declared by any loaded extension pack \u2014 no L3 contract can ever back it. ${fixHint}`,
+                    "error",
+                    "SURFACE_REF_AMBIGUOUS",
+                    ambiguityMessage(
+                      resolved,
+                      step.type === "dispatch" ? `Method "${implMethod.name}" in implementation "${impl.id}" dispatches (step ${step.stepNumber}) through` : `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} "${step.targetMethod}" (step ${step.stepNumber}) on`,
+                      target
+                    ),
                     impl.id,
                     isDraftCtx
                   );
+                  continue;
                 }
+                if (resolved.kind === "resolved") continue;
               }
-            }
-          }
-        }
-      }
-    };
-  }
-});
-
-// src/core/rules/narrative/narrative-flow.ts
-function flowConfigOn(step) {
-  return FLOW_FIELDS.filter((f) => {
-    const v = step[f];
-    if (v === void 0) return false;
-    if (Array.isArray(v) && v.length === 0) return false;
-    return true;
-  });
-}
-var FLOW_FIELDS, narrativeFlowRule;
-var init_narrative_flow = __esm({
-  "src/core/rules/narrative/narrative-flow.ts"() {
+              if (isCrossTreeForm) {
+                ctx.addIssue(
+                  "warning",
+                  "CROSS_TREE_REF_UNRESOLVED",
+                  `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
+                );
+              } else {
+                ctx.addIssue(
+                  "error",
+                  "INVALID_TARGET_COMPONENT_REFERENCE",
+                  `Method "${implMethod.name}" in implementation "${impl.id}" ${verb} component "${target}" which does not exist (step ${step.stepNumber}).`,
+                  impl.id,
+                  isDraftCtx
+                );
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/narrative/surface-reference-backing.ts
+var surfaceReferenceBackingRule;
+var init_surface_reference_backing = __esm({
+  "src/core/rules/narrative/surface-reference-backing.ts"() {
     "use strict";
-    init_models();
-    FLOW_FIELDS = [
-      "condition",
-      "onTrueStep",
-      "onFalseStep",
-      "on",
-      "cases",
-      "defaultStep",
-      "loopKind",
-      "over",
-      "endStep",
-      "catches",
-      "finallyStep",
-      "branches",
-      "toStep"
-    ];
-    narrativeFlowRule = {
-      name: "narrative-flow",
-      description: 'Control-flow soundness of L5 narratives: flow steps (branch, switch, loop, try, parallel, jump) must carry their required config, every jump field must target an existing step number in the same narrative, and every step must be reachable from the first step following fall-through and jumps. A parallel body is covered by contiguous, ordered arms (>= 2) whose last steps continue at the join after endStep; "detach" (fire-and-forget) is legal on call/dispatch steps only.',
+    surfaceReferenceBackingRule = {
+      name: "surface-reference-backing",
+      description: "The surface snapshot a cross-tree narrative target resolves to must back what the step asks of it: the calling component declares the collaborator, the snapshot exposes the called method (or serves the dispatched capability), and it declares every semantic guarantee the step asserts. A snapshot is the provider's declared contract, so these are contract verdicts rather than resolution failures.",
       codes: [
-        { code: "MALFORMED_FLOW_STEP", defaultSeverity: "error", summary: "Flow step missing required config (or flow config on a local/call step)" },
-        { code: "INVALID_STEP_JUMP", defaultSeverity: "error", summary: "Jump field targets a step number that does not exist in the narrative" },
-        { code: "UNREACHABLE_STEP", defaultSeverity: "warning", summary: "Step not reachable from the first step following fall-through and jumps" },
-        { code: "REGION_OVERLAP", defaultSeverity: "error", summary: "loop/try regions interleave \u2014 regions must nest or be disjoint to map onto structured code" },
-        { code: "JUMP_INTO_REGION", defaultSeverity: "warning", summary: "Jump lands in the middle of a loop/try body from outside \u2014 regions are entered through their header" },
-        { code: "FALLTHROUGH_INTO_HANDLER", defaultSeverity: "warning", summary: "try body falls through into its own catch/finally region on the success path" },
-        { code: "BACKWARD_JUMP", defaultSeverity: "warning", summary: "Backward jump that is not a continue to an enclosing loop header \u2014 model repetition with a loop step" },
-        { code: "DUPLICATE_STEP_LABEL", defaultSeverity: "error", summary: "Two steps in one narrative share a label \u2014 the symbolic anchor later deltas address by" }
+        { code: "SURFACE_REF_NOT_EXPOSED", defaultSeverity: "error", summary: "Cross-tree reference resolves to a surface snapshot that does not expose the called method/capability" },
+        { code: "UNDECLARED_DEPENDENCY_CALL", defaultSeverity: "error", summary: "Call step targets a component the caller does not depend on or own" },
+        { code: "NARRATIVE_SEMANTIC_UNBACKED", defaultSeverity: "warning", summary: "Narrative asserts a guarantee the called contract does not declare" }
       ],
       check(ctx) {
         for (const impl of ctx.implementations) {
+          const contract = ctx.interfaceMap.get(impl.contract);
+          if (!contract) continue;
           const isDraftCtx = ctx.isImplementationDraft(impl);
+          const caller = ctx.componentMap.get(contract.component);
+          const fromSubsystem = caller?.subsystem;
           for (const implMethod of impl.methods) {
-            const steps = implMethod.narrative;
-            if (!steps.length) continue;
-            const where = `Method "${implMethod.name}" in implementation "${impl.id}": `;
-            const labelled = /* @__PURE__ */ new Map();
-            for (const step of steps) {
-              const label = step.label;
-              if (!label) continue;
-              const first = labelled.get(label);
-              if (first !== void 0) {
+            for (const step of implMethod.narrative) {
+              if (step.type !== "call" && step.type !== "dispatch" && step.type !== "register") continue;
+              if (!step.targetComponent) continue;
+              if (step.type !== "dispatch" && !step.targetMethod) continue;
+              const target = step.targetComponent;
+              if (ctx.componentMap.get(target)) continue;
+              const isCrossTreeForm = ctx.isExternalNamespaceRef(target);
+              const isCollapsedForm = !isCrossTreeForm && fromSubsystem !== void 0 && ctx.isCollapsedCrossTreeRef(target, fromSubsystem);
+              if (!isCrossTreeForm && !isCollapsedForm) continue;
+              const resolved = ctx.resolveSurfaceRef(target, fromSubsystem);
+              if (resolved.kind !== "resolved") continue;
+              const verb = step.type === "dispatch" ? "dispatches through" : step.type === "register" ? "registers callback" : "calls";
+              if (caller && target !== caller.id && !caller.dependsOn.includes(target) && !caller.owns.includes(target)) {
                 ctx.addIssue(
                   "error",
-                  "DUPLICATE_STEP_LABEL",
-                  `${where}steps ${first} and ${step.stepNumber} share the label "${label}". A label anchors one step for later deltas to address; two steps holding it makes every symbolic reference ambiguous and blocks all further edits to this implementation. Rename one.`,
+                  "UNDECLARED_DEPENDENCY_CALL",
+                  `Method "${implMethod.name}" in implementation "${impl.id}" (component "${caller.id}") ${verb} component "${target}" (step ${step.stepNumber}) but component "${caller.id}" does not list "${target}" as a dependency.`,
                   impl.id,
-                  isDraftCtx
+                  isDraftCtx || ctx.isComponentDraft(caller.id),
+                  true
                 );
-              } else {
-                labelled.set(label, step.stepNumber);
-              }
-            }
-            let sound = true;
-            const malformed = (msg) => {
-              sound = false;
-              ctx.addIssue("error", "MALFORMED_FLOW_STEP", where + msg, impl.id, isDraftCtx);
-            };
-            const byNum = /* @__PURE__ */ new Map();
-            for (const s of steps) {
-              if (byNum.has(s.stepNumber)) malformed(`duplicate stepNumber ${s.stepNumber} \u2014 jump targets would be ambiguous.`);
-              byNum.set(s.stepNumber, s);
-            }
-            const nums = [...byNum.keys()].sort((a, b) => a - b);
-            const indexOf = new Map(nums.map((n, i) => [n, i]));
-            const nextOf = (n) => {
-              const i = indexOf.get(n);
-              return i !== void 0 && i + 1 < nums.length ? nums[i + 1] : void 0;
-            };
-            for (const s of steps) {
-              if (s.detach && s.type !== "call" && s.type !== "dispatch") {
-                malformed(`step ${s.stepNumber} (${s.type}) carries "detach" \u2014 fire-and-forget applies to call/dispatch steps only.`);
               }
-              switch (s.type) {
-                case "local":
-                case "call":
-                case "register":
-                case "dispatch": {
-                  const extra = flowConfigOn(s);
-                  if (extra.length) malformed(`step ${s.stepNumber} (${s.type}) carries flow config (${extra.join(", ")}) \u2014 use a flow step type instead.`);
-                  break;
-                }
-                case "branch":
-                  if (!s.condition) malformed(`branch step ${s.stepNumber} requires "condition".`);
-                  if (s.onFalseStep === void 0) malformed(`branch step ${s.stepNumber} requires "onFalseStep" (true continues at onTrueStep or the next step).`);
-                  break;
-                case "switch":
-                  if (!s.cases || !s.cases.length) malformed(`switch step ${s.stepNumber} requires non-empty "cases".`);
-                  break;
-                case "loop": {
-                  if (s.endStep === void 0) malformed(`loop step ${s.stepNumber} requires "endStep" (last step of the body).`);
-                  else if (s.endStep <= s.stepNumber) malformed(`loop step ${s.stepNumber} "endStep" (${s.endStep}) must lie beyond the header.`);
-                  const kind = s.loopKind ?? (s.over ? "forEach" : "while");
-                  if ((kind === "while" || kind === "doWhile") && !s.condition) malformed(`${kind} loop step ${s.stepNumber} requires "condition".`);
-                  if ((kind === "forEach" || kind === "for") && !s.over) malformed(`${kind} loop step ${s.stepNumber} requires "over" (the iteration source).`);
-                  break;
+              if (step.type === "dispatch") {
+                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 "${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
+                  );
                 }
-                case "try":
-                  if (s.endStep === void 0) malformed(`try step ${s.stepNumber} requires "endStep" (last step of the guarded body).`);
-                  else if (s.endStep <= s.stepNumber) malformed(`try step ${s.stepNumber} "endStep" (${s.endStep}) must lie beyond the header.`);
-                  if ((!s.catches || !s.catches.length) && s.finallyStep === void 0) malformed(`try step ${s.stepNumber} requires "catches" and/or "finallyStep" \u2014 a guard that handles nothing guards nothing.`);
-                  break;
-                case "parallel": {
-                  if (s.endStep === void 0) malformed(`parallel step ${s.stepNumber} requires "endStep" (last step of the fan-out body).`);
-                  else if (s.endStep <= s.stepNumber) malformed(`parallel step ${s.stepNumber} "endStep" (${s.endStep}) must lie beyond the header.`);
-                  const entries = (s.branches ?? []).map((b) => b.step);
-                  if (entries.length < 2) {
-                    malformed(`parallel step ${s.stepNumber} requires "branches" with at least two arms \u2014 a single arm is sequential flow.`);
-                  } else {
-                    const sorted = [...entries].sort((a, b) => a - b);
-                    if (entries.some((e, i) => e !== sorted[i])) malformed(`parallel step ${s.stepNumber} "branches" must list arm entries in ascending order \u2014 arms are contiguous sub-regions of the body.`);
-                    if (new Set(entries).size !== entries.length) malformed(`parallel step ${s.stepNumber} "branches" lists the same entry step twice.`);
-                    const bodyStart = nextOf(s.stepNumber);
-                    if (bodyStart !== void 0 && sorted[0] !== bodyStart) malformed(`parallel step ${s.stepNumber}: the first arm must start at the body's first step (${bodyStart}), got ${sorted[0]} \u2014 steps before the first arm would belong to no arm.`);
-                    if (s.endStep !== void 0 && sorted.some((e) => e > s.endStep)) malformed(`parallel step ${s.stepNumber}: every arm entry must lie within the body (..${s.endStep}).`);
-                  }
-                  break;
+                continue;
+              }
+              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 "${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
+                );
+                continue;
+              }
+              const declared = new Set(surfaceMethod.guarantees ?? []);
+              for (const g of step.assertsGuarantees ?? []) {
+                if (!declared.has(g)) {
+                  ctx.addIssue(
+                    "warning",
+                    "NARRATIVE_SEMANTIC_UNBACKED",
+                    `Step ${step.stepNumber} of "${implMethod.name}" in implementation "${impl.id}" asserts guarantee "${g}", but the surface snapshot of "${resolved.snapshot.projectName}" does not declare it on "${resolved.entry.id}.${step.targetMethod}".`,
+                    impl.id,
+                    isDraftCtx,
+                    true
+                  );
                 }
-                case "jump":
-                  if (s.toStep === void 0) malformed(`jump step ${s.stepNumber} requires "toStep".`);
-                  break;
               }
-              const jumpFields = [];
-              if (s.onTrueStep !== void 0) jumpFields.push(["onTrueStep", s.onTrueStep]);
-              if (s.onFalseStep !== void 0) jumpFields.push(["onFalseStep", s.onFalseStep]);
-              if (s.defaultStep !== void 0) jumpFields.push(["defaultStep", s.defaultStep]);
-              if (s.endStep !== void 0) jumpFields.push(["endStep", s.endStep]);
-              if (s.finallyStep !== void 0) jumpFields.push(["finallyStep", s.finallyStep]);
-              if (s.toStep !== void 0) jumpFields.push(["toStep", s.toStep]);
-              (s.cases ?? []).forEach((c, i) => jumpFields.push([`cases[${i}].step`, c.step]));
-              (s.catches ?? []).forEach((c, i) => jumpFields.push([`catches[${i}].step`, c.step]));
-              (s.branches ?? []).forEach((b, i) => jumpFields.push([`branches[${i}].step`, b.step]));
-              for (const [field, target] of jumpFields) {
-                if (!byNum.has(target)) {
-                  sound = false;
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/narrative/guarantee-tokens.ts
+var guaranteeTokensRule;
+var init_guarantee_tokens = __esm({
+  "src/core/rules/narrative/guarantee-tokens.ts"() {
+    "use strict";
+    init_models();
+    guaranteeTokensRule = {
+      name: "guarantee-tokens",
+      description: "Every semantic-guarantee token an L3 method declares or a narrative step asserts must be a builtin guarantee or one a loaded extension pack declares in its `guarantees` list. The vocabulary is open for packs, not for typos \u2014 an undeclared token is matched by nothing and silently escapes the narrative\u2194contract consistency checks.",
+      codes: [
+        { code: "UNKNOWN_GUARANTEE", defaultSeverity: "warning", summary: "Guarantee token is neither builtin nor pack-declared" }
+      ],
+      check(ctx) {
+        const known = /* @__PURE__ */ new Set([...SEMANTIC_GUARANTEES, ...ctx.ext.guarantees]);
+        const fixHint = `Known tokens: builtin ${SEMANTIC_GUARANTEES.join(", ")}${ctx.ext.guarantees.length ? `; pack-declared ${ctx.ext.guarantees.join(", ")}` : ""}. Fix the spelling or declare the token in an extension pack's \`guarantees\` list.`;
+        for (const intf of ctx.interfaces) {
+          const isDraftCtx = intf.status === "draft" || intf.status === "design" || ctx.isComponentDraft(intf.component);
+          for (const method of intf.methods) {
+            for (const g of method.guarantees ?? []) {
+              if (!known.has(g)) {
+                ctx.addIssue(
+                  "warning",
+                  "UNKNOWN_GUARANTEE",
+                  `Method "${method.name}" on interface "${intf.id}" declares guarantee "${g}", which is neither a builtin guarantee nor declared by any loaded extension pack \u2014 no narrative assertion can ever match it. ${fixHint}`,
+                  intf.id,
+                  isDraftCtx
+                );
+              }
+            }
+          }
+        }
+        for (const impl of ctx.implementations) {
+          const isDraftCtx = ctx.isImplementationDraft(impl);
+          for (const method of impl.methods) {
+            for (const step of method.narrative ?? []) {
+              for (const g of step.assertsGuarantees ?? []) {
+                if (!known.has(g)) {
                   ctx.addIssue(
-                    "error",
-                    "INVALID_STEP_JUMP",
-                    `${where}step ${s.stepNumber} "${field}" targets step ${target}, which does not exist in this narrative.`,
+                    "warning",
+                    "UNKNOWN_GUARANTEE",
+                    `Step ${step.stepNumber} of "${method.name}" in implementation "${impl.id}" asserts guarantee "${g}", which is neither a builtin guarantee nor declared by any loaded extension pack \u2014 no L3 contract can ever back it. ${fixHint}`,
                     impl.id,
                     isDraftCtx
                   );
                 }
               }
             }
-            if (!sound) continue;
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/narrative/narrative-step-config.ts
+var narrativeStepConfigRule;
+var init_narrative_step_config = __esm({
+  "src/core/rules/narrative/narrative-step-config.ts"() {
+    "use strict";
+    init_models();
+    narrativeStepConfigRule = {
+      name: "narrative-step-config",
+      description: 'The step configuration of L5 narratives: every flow step (branch, switch, loop, try, parallel, jump) carries the config its type requires and no simple step carries flow config, "detach" (fire-and-forget) is legal on call/dispatch steps only, a parallel body is covered by contiguous, ordered arms (>= 2), no two steps share a step number or a label, and every jump field targets an existing step number in the same narrative.',
+      codes: [
+        { code: "MALFORMED_FLOW_STEP", defaultSeverity: "error", summary: "Flow step missing required config (or flow config on a local/call step)" },
+        { code: "INVALID_STEP_JUMP", defaultSeverity: "error", summary: "Jump field targets a step number that does not exist in the narrative" },
+        { code: "DUPLICATE_STEP_LABEL", defaultSeverity: "error", summary: "Two steps in one narrative share a label \u2014 the symbolic anchor later deltas address by" }
+      ],
+      check(ctx) {
+        for (const impl of ctx.implementations) {
+          const isDraftCtx = ctx.isImplementationDraft(impl);
+          for (const implMethod of impl.methods) {
+            if (!implMethod.narrative.length) continue;
+            const where = `Method "${implMethod.name}" in implementation "${impl.id}": `;
+            for (const problem of stepConfigVerdict(implMethod).problems) {
+              ctx.addIssue("error", problem.code, where + problem.detail, impl.id, isDraftCtx);
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/narrative/narrative-reachability.ts
+function regionsOf(steps) {
+  const regions = [];
+  for (const s of steps) {
+    if ((s.type === "loop" || s.type === "try" || s.type === "parallel") && s.endStep !== void 0) {
+      regions.push({ h: s.stepNumber, end: s.endStep, kind: s.type });
+    }
+  }
+  return regions;
+}
+var narrativeReachabilityRule;
+var init_narrative_reachability = __esm({
+  "src/core/rules/narrative/narrative-reachability.ts"() {
+    "use strict";
+    init_models();
+    narrativeReachabilityRule = {
+      name: "narrative-reachability",
+      description: "Every step of an L5 narrative must be reachable from the first step following fall-through and jumps, and the loop/try/parallel regions it declares must nest or stay disjoint \u2014 interleaved regions map onto no structured code. Judged over the step graph, and only for a narrative whose step configuration is sound (narrative-step-config reports the rest).",
+      codes: [
+        { code: "UNREACHABLE_STEP", defaultSeverity: "warning", summary: "Step not reachable from the first step following fall-through and jumps" },
+        { code: "REGION_OVERLAP", defaultSeverity: "error", summary: "loop/try regions interleave \u2014 regions must nest or be disjoint to map onto structured code" }
+      ],
+      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;
+            if (!stepConfigVerdict(implMethod).sound) continue;
+            const where = `Method "${implMethod.name}" in implementation "${impl.id}": `;
             const graph = stepGraph(implMethod);
+            const nums = graph.stepNumbers;
             const visited = /* @__PURE__ */ new Set();
             const stack = [nums[0]];
             while (stack.length) {
@@ -9395,13 +9528,7 @@ var init_narrative_flow = __esm({
                 isDraftCtx
               );
             }
-            const regions = [];
-            for (const s of steps) {
-              if ((s.type === "loop" || s.type === "try" || s.type === "parallel") && s.endStep !== void 0) {
-                regions.push({ h: s.stepNumber, end: s.endStep, kind: s.type });
-              }
-            }
-            const inBody = (n, r) => n > r.h && n <= r.end;
+            const regions = regionsOf(steps);
             for (const a of regions) {
               for (const b of regions) {
                 if (b.h > a.h && b.h <= a.end && b.end > a.end) {
@@ -9415,19 +9542,63 @@ var init_narrative_flow = __esm({
                 }
               }
             }
-            const jumpEdges = [];
-            for (const s of steps) {
-              const push = (field, to) => {
-                if (to !== void 0) jumpEdges.push({ from: s.stepNumber, to, field, kind: s.type });
-              };
-              push("onTrueStep", s.onTrueStep);
-              push("onFalseStep", s.onFalseStep);
-              push("defaultStep", s.defaultStep);
-              push("toStep", s.toStep);
-              push("finallyStep", s.finallyStep);
-              (s.cases ?? []).forEach((c, i) => push(`cases[${i}].step`, c.step));
-              (s.catches ?? []).forEach((c, i) => push(`catches[${i}].step`, c.step));
-            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/narrative/narrative-jump-edges.ts
+function regionsOf2(steps) {
+  const regions = [];
+  for (const s of steps) {
+    if ((s.type === "loop" || s.type === "try" || s.type === "parallel") && s.endStep !== void 0) {
+      regions.push({ h: s.stepNumber, end: s.endStep, kind: s.type });
+    }
+  }
+  return regions;
+}
+function jumpEdgesOf(steps) {
+  const edges = [];
+  for (const s of steps) {
+    const push = (field, to) => {
+      if (to !== void 0) edges.push({ from: s.stepNumber, to, field, kind: s.type });
+    };
+    push("onTrueStep", s.onTrueStep);
+    push("onFalseStep", s.onFalseStep);
+    push("defaultStep", s.defaultStep);
+    push("toStep", s.toStep);
+    push("finallyStep", s.finallyStep);
+    (s.cases ?? []).forEach((c, i) => push(`cases[${i}].step`, c.step));
+    (s.catches ?? []).forEach((c, i) => push(`catches[${i}].step`, c.step));
+  }
+  return edges;
+}
+var narrativeJumpEdgesRule;
+var init_narrative_jump_edges = __esm({
+  "src/core/rules/narrative/narrative-jump-edges.ts"() {
+    "use strict";
+    init_models();
+    narrativeJumpEdgesRule = {
+      name: "narrative-jump-edges",
+      description: "Where an L5 narrative's jump edges land: a loop/try/parallel region is entered through its header, never into the middle of its body; a backward jump is only idiomatic as a continue to an enclosing loop header, and otherwise models repetition that belongs in a loop step; and a try body must not fall through into its own catch/finally region on the success path. Judged only for a narrative whose step configuration is sound (narrative-step-config reports the rest).",
+      codes: [
+        { code: "JUMP_INTO_REGION", defaultSeverity: "warning", summary: "Jump lands in the middle of a loop/try body from outside \u2014 regions are entered through their header" },
+        { code: "BACKWARD_JUMP", defaultSeverity: "warning", summary: "Backward jump that is not a continue to an enclosing loop header \u2014 model repetition with a loop step" },
+        { code: "FALLTHROUGH_INTO_HANDLER", defaultSeverity: "warning", summary: "try body falls through into its own catch/finally region on the success path" }
+      ],
+      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;
+            if (!stepConfigVerdict(implMethod).sound) continue;
+            const where = `Method "${implMethod.name}" in implementation "${impl.id}": `;
+            const regions = regionsOf2(steps);
+            const jumpEdges = jumpEdgesOf(steps);
+            const inBody = (n, r) => n > r.h && n <= r.end;
             for (const e of jumpEdges) {
               for (const r of regions) {
                 if (inBody(e.to, r) && e.from !== r.h && !inBody(e.from, r)) {
@@ -9440,19 +9611,26 @@ var init_narrative_flow = __esm({
                   );
                 }
               }
-              if ((e.kind === "branch" || e.kind === "switch" || e.kind === "jump") && e.to < e.from) {
-                const continueToLoop = regions.some((r) => r.kind === "loop" && r.h === e.to && inBody(e.from, r));
-                if (!continueToLoop) {
-                  ctx.addIssue(
-                    "warning",
-                    "BACKWARD_JUMP",
-                    `${where}step ${e.from} "${e.field}" jumps backwards to step ${e.to} \u2014 model repetition with a loop step (backward jumps are only idiomatic as a continue to an enclosing loop header).`,
-                    impl.id,
-                    isDraftCtx
-                  );
-                }
-              }
             }
+            for (const e of jumpEdges) {
+              if (e.kind !== "branch" && e.kind !== "switch" && e.kind !== "jump" || e.to >= e.from) continue;
+              const continueToLoop = regions.some((r) => r.kind === "loop" && r.h === e.to && inBody(e.from, r));
+              if (continueToLoop) continue;
+              ctx.addIssue(
+                "warning",
+                "BACKWARD_JUMP",
+                `${where}step ${e.from} "${e.field}" jumps backwards to step ${e.to} \u2014 model repetition with a loop step (backward jumps are only idiomatic as a continue to an enclosing loop header).`,
+                impl.id,
+                isDraftCtx
+              );
+            }
+            const byNum = /* @__PURE__ */ new Map();
+            for (const s of steps) byNum.set(s.stepNumber, s);
+            const nums = [...byNum.keys()].sort((a, b) => a - b);
+            const nextOf = (n) => {
+              const i = nums.indexOf(n);
+              return i !== -1 && i + 1 < nums.length ? nums[i + 1] : void 0;
+            };
             for (const s of steps) {
               if (s.type !== "try" || s.endStep === void 0) continue;
               const handlerStarts = new Set((s.catches ?? []).map((c) => c.step));
@@ -10607,28 +10785,28 @@ var init_facade_forwarding = __esm({
   }
 });
 
-// src/core/rules/extension/architectural-profiles.ts
-var BACKEND_LIKE, FRONTEND_LIKE, PROJECT_KINDS2, profilesRule;
-var init_architectural_profiles = __esm({
-  "src/core/rules/extension/architectural-profiles.ts"() {
+// src/core/rules/extension/profile-registration.ts
+var PROJECT_KINDS2, profileRegistrationRule;
+var init_profile_registration = __esm({
+  "src/core/rules/extension/profile-registration.ts"() {
     "use strict";
     init_types();
-    BACKEND_LIKE = /* @__PURE__ */ new Set(["backend", "lowlevel-os", "game-ecs", "realtime-embedded", "plc-cyclic"]);
-    FRONTEND_LIKE = /* @__PURE__ */ new Set(["frontend-reactive", "frontend-controller"]);
     PROJECT_KINDS2 = new Set(PROJECT_KINDS);
-    profilesRule = {
-      name: "architectural-profiles",
-      description: "Per-profile stereotype constraints: View/FeatureComponent/RouterComponent only in frontend profiles; Actor/Supervisor forbidden in plc-cyclic (single scan cycle); Actor/Supervisor in frontend profiles warned. Extension packs may register custom profiles (family + forbidden/discouraged stereotype lists); unknown profile names are flagged.",
+    profileRegistrationRule = {
+      name: "profile-registration",
+      description: "Every profile name in play \u2014 the project's own projectType and each subsystem's declared profile \u2014 must be a built-in profile, a composite project kind, or one a loaded extension pack registers. An unregistered name is flagged rather than guessed at: no doctrine is governing it.",
       codes: [
-        { code: "FRONTEND_STEREOTYPE_IN_BACKEND", defaultSeverity: "error", summary: "Frontend stereotype in a backend-oriented subsystem" },
-        { code: "PLC_CYCLIC_CONCURRENCY_VIOLATION", defaultSeverity: "error", summary: "Concurrent stereotype in a PLC-cyclic profile" },
-        { code: "BACKEND_STEREOTYPE_IN_FRONTEND", defaultSeverity: "warning", summary: "Backend runtime stereotype in a frontend subsystem" },
-        { code: "PROFILE_FORBIDDEN_STEREOTYPE", defaultSeverity: "error", summary: "Stereotype forbidden by the governing pack-defined profile" },
-        { code: "PROFILE_DISCOURAGED_STEREOTYPE", defaultSeverity: "warning", summary: "Stereotype discouraged by the governing pack-defined profile" },
         { code: "UNKNOWN_PROFILE", defaultSeverity: "warning", summary: "Profile name is neither built-in nor registered by an extension pack" }
       ],
       check(ctx) {
         const registered = /* @__PURE__ */ new Set([...BUILTIN_PROFILES, ...Object.keys(ctx.ext.profiles)]);
+        if (!registered.has(ctx.projectType) && !PROJECT_KINDS2.has(ctx.projectType)) {
+          ctx.addIssue(
+            "warning",
+            "UNKNOWN_PROFILE",
+            `projectType "${ctx.projectType}" (project.yaml) is neither a built-in profile/kind nor registered by a loaded extension pack. Components default to backend doctrine.`
+          );
+        }
         for (const sub of ctx.subsystems) {
           if (sub.profile && !registered.has(sub.profile)) {
             ctx.addIssue(
@@ -10639,13 +10817,27 @@ var init_architectural_profiles = __esm({
             );
           }
         }
-        if (!registered.has(ctx.projectType) && !PROJECT_KINDS2.has(ctx.projectType)) {
-          ctx.addIssue(
-            "warning",
-            "UNKNOWN_PROFILE",
-            `projectType "${ctx.projectType}" (project.yaml) is neither a built-in profile/kind nor registered by a loaded extension pack. Components default to backend doctrine.`
-          );
-        }
+      }
+    };
+  }
+});
+
+// src/core/rules/extension/profile-stereotype-fencing.ts
+var BACKEND_LIKE, FRONTEND_LIKE, profileStereotypeFencingRule;
+var init_profile_stereotype_fencing = __esm({
+  "src/core/rules/extension/profile-stereotype-fencing.ts"() {
+    "use strict";
+    BACKEND_LIKE = /* @__PURE__ */ new Set(["backend", "lowlevel-os", "game-ecs", "realtime-embedded", "plc-cyclic"]);
+    FRONTEND_LIKE = /* @__PURE__ */ new Set(["frontend-reactive", "frontend-controller"]);
+    profileStereotypeFencingRule = {
+      name: "profile-stereotype-fencing",
+      description: "The built-in profile families fence which stereotypes may run under them: View/FeatureComponent/RouterComponent only in a frontend-like profile; Actor/Supervisor forbidden in plc-cyclic, whose logic runs single-threaded inside one execution scan cycle; Actor/Supervisor in a frontend-like profile warned. A pack profile opts in by declaring its family; an unregistered profile is neutral, with no doctrine to guess.",
+      codes: [
+        { code: "FRONTEND_STEREOTYPE_IN_BACKEND", defaultSeverity: "error", summary: "Frontend stereotype in a backend-oriented subsystem" },
+        { code: "PLC_CYCLIC_CONCURRENCY_VIOLATION", defaultSeverity: "error", summary: "Concurrent stereotype in a PLC-cyclic profile" },
+        { code: "BACKEND_STEREOTYPE_IN_FRONTEND", defaultSeverity: "warning", summary: "Backend runtime stereotype in a frontend subsystem" }
+      ],
+      check(ctx) {
         for (const comp of ctx.components) {
           const isDraftCtx = ctx.isComponentDraft(comp.id);
           const profile = ctx.getComponentProfile(comp.id);
@@ -10685,28 +10877,50 @@ var init_architectural_profiles = __esm({
               );
             }
           }
-          if (packDef) {
-            for (const rule of packDef.forbiddenStereotypes) {
-              if (rule.types.includes(comp.componentType)) {
-                ctx.addIssue(
-                  "error",
-                  "PROFILE_FORBIDDEN_STEREOTYPE",
-                  `Component "${comp.id}" is a ${comp.componentType}, forbidden by profile "${profile}": ${rule.reason}`,
-                  comp.id,
-                  isDraftCtx
-                );
-              }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/extension/pack-profile-stereotypes.ts
+var packProfileStereotypesRule;
+var init_pack_profile_stereotypes = __esm({
+  "src/core/rules/extension/pack-profile-stereotypes.ts"() {
+    "use strict";
+    packProfileStereotypesRule = {
+      name: "pack-profile-stereotypes",
+      description: "A pack-registered profile carries its own stereotype doctrine on top of the built-in family fencing: the stereotypes it lists as forbidden are errors and the ones it discourages are warnings, each reported with the reason the pack states for it.",
+      codes: [
+        { code: "PROFILE_FORBIDDEN_STEREOTYPE", defaultSeverity: "error", summary: "Stereotype forbidden by the governing pack-defined profile" },
+        { code: "PROFILE_DISCOURAGED_STEREOTYPE", defaultSeverity: "warning", summary: "Stereotype discouraged by the governing pack-defined profile" }
+      ],
+      check(ctx) {
+        for (const comp of ctx.components) {
+          const profile = ctx.getComponentProfile(comp.id);
+          const packDef = ctx.ext.profiles[profile];
+          if (!packDef) continue;
+          const isDraftCtx = ctx.isComponentDraft(comp.id);
+          for (const rule of packDef.forbiddenStereotypes) {
+            if (rule.types.includes(comp.componentType)) {
+              ctx.addIssue(
+                "error",
+                "PROFILE_FORBIDDEN_STEREOTYPE",
+                `Component "${comp.id}" is a ${comp.componentType}, forbidden by profile "${profile}": ${rule.reason}`,
+                comp.id,
+                isDraftCtx
+              );
             }
-            for (const rule of packDef.discouragedStereotypes) {
-              if (rule.types.includes(comp.componentType)) {
-                ctx.addIssue(
-                  "warning",
-                  "PROFILE_DISCOURAGED_STEREOTYPE",
-                  `Component "${comp.id}" is a ${comp.componentType}, discouraged by profile "${profile}": ${rule.reason}`,
-                  comp.id,
-                  isDraftCtx
-                );
-              }
+          }
+          for (const rule of packDef.discouragedStereotypes) {
+            if (rule.types.includes(comp.componentType)) {
+              ctx.addIssue(
+                "warning",
+                "PROFILE_DISCOURAGED_STEREOTYPE",
+                `Component "${comp.id}" is a ${comp.componentType}, discouraged by profile "${profile}": ${rule.reason}`,
+                comp.id,
+                isDraftCtx
+              );
             }
           }
         }
@@ -11043,22 +11257,20 @@ var init_dependency_cycles = __esm({
   }
 });
 
-// src/core/rules/wiring/dispatch-tables.ts
-var dispatchRule;
-var init_dispatch_tables = __esm({
-  "src/core/rules/wiring/dispatch-tables.ts"() {
+// src/core/rules/wiring/dispatch-table-bindings.ts
+var dispatchTableBindingsRule;
+var init_dispatch_table_bindings = __esm({
+  "src/core/rules/wiring/dispatch-table-bindings.ts"() {
     "use strict";
-    dispatchRule = {
-      name: "dispatch-tables",
-      description: "Portal dispatch tables must bind every capability to an existing component.method inside the portal's own subsystem (the portal dispatches inward), with no duplicate capabilities; dispatch narrative steps must route a declared capability through a Portal that actually serves it.",
+    dispatchTableBindingsRule = {
+      name: "dispatch-table-bindings",
+      description: "A dispatch table belongs to a Portal, binds each capability once, and binds it to an existing component.method inside the portal's own subsystem (the portal dispatches inward) that the portal declares under dependsOn or owns \u2014 the table is a real runtime invocation path.",
       codes: [
         { code: "DISPATCH_ON_NON_PORTAL", defaultSeverity: "error", summary: "Dispatch table declared on a component that is not a Portal" },
         { code: "DUPLICATE_CAPABILITY", defaultSeverity: "error", summary: "Capability bound more than once in one dispatch table" },
         { code: "UNSERVED_CAPABILITY", defaultSeverity: "error", summary: "Capability has no existing server (bad table binding, or dispatch step routing a capability the target Portal does not serve)" },
         { code: "DISPATCH_CROSS_SUBSYSTEM", defaultSeverity: "error", summary: "Dispatch binding targets a component outside the portal's subsystem" },
-        { code: "UNDECLARED_DISPATCH_TARGET", defaultSeverity: "error", summary: "Dispatch binding targets a component the portal does not depend on or own" },
-        { code: "MALFORMED_DISPATCH_STEP", defaultSeverity: "error", summary: "Dispatch step missing its capability (targetComponent presence is the contracts rule's finding)" },
-        { code: "NARRATIVE_SEMANTIC_UNBACKED", defaultSeverity: "warning", summary: "Dispatch step asserts a guarantee the bound capability method does not declare" }
+        { code: "UNDECLARED_DISPATCH_TARGET", defaultSeverity: "error", summary: "Dispatch binding targets a component the portal does not depend on or own" }
       ],
       check(ctx) {
         for (const comp of ctx.components) {
@@ -11125,6 +11337,25 @@ var init_dispatch_tables = __esm({
             }
           }
         }
+      }
+    };
+  }
+});
+
+// src/core/rules/wiring/dispatch-step-routing.ts
+var dispatchStepRoutingRule;
+var init_dispatch_step_routing = __esm({
+  "src/core/rules/wiring/dispatch-step-routing.ts"() {
+    "use strict";
+    dispatchStepRoutingRule = {
+      name: "dispatch-step-routing",
+      description: "A dispatch narrative step must name the capability it routes and route it through a Portal whose dispatch table actually serves that capability; a guarantee the step asserts must be declared by the contract method the capability resolves to.",
+      codes: [
+        { code: "MALFORMED_DISPATCH_STEP", defaultSeverity: "error", summary: "Dispatch step missing its capability (targetComponent presence is narrative-target-references' finding)" },
+        { code: "UNSERVED_CAPABILITY", defaultSeverity: "error", summary: "Capability has no existing server (bad table binding, or dispatch step routing a capability the target Portal does not serve)" },
+        { code: "NARRATIVE_SEMANTIC_UNBACKED", defaultSeverity: "warning", summary: "Dispatch step asserts a guarantee the bound capability method does not declare" }
+      ],
+      check(ctx) {
         for (const impl of ctx.implementations) {
           const isDraftCtx = ctx.isImplementationDraft(impl);
           for (const implMethod of impl.methods) {
@@ -11879,35 +12110,26 @@ var init_event_topology = __esm({
   }
 });
 
-// src/core/rules/conformance/structural-conformance.ts
-var quoteList, structuralConformanceRule;
-var init_structural_conformance = __esm({
-  "src/core/rules/conformance/structural-conformance.ts"() {
+// src/core/rules/conformance/source-file-linkage.ts
+var quoteList, sourceFileLinkageRule;
+var init_source_file_linkage = __esm({
+  "src/core/rules/conformance/source-file-linkage.ts"() {
     "use strict";
     init_models();
     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 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.",
+    sourceFileLinkageRule = {
+      name: "source-file-linkage",
+      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, readable file inside the project root, and an implementation that names no file at all, or leaves a contract method without one, is linked to no code. A file that escapes the root, is missing or cannot be analyzed is reported once and blocks only the methods realized in it. A run in which TypeScript/JavaScript files were analyzed below exact grade reports that once (CONFORMANCE_DEGRADED), since dependency conformance then skips them. 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 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" }
       ],
       check(ctx) {
-        const lookups = /* @__PURE__ */ new Map();
-        for (const facts of ctx.codeModel.files) {
-          lookups.set(pathKey(facts.path), {
-            declared: /* @__PURE__ */ new Set([...facts.declaredNames, ...facts.exportedNames]),
-            anchored: /* @__PURE__ */ new Set([...facts.declaredNames, ...facts.exportedNames, ...facts.anchoredNames]),
-            findingAnchors: new Set(facts.anchoredNames),
-            facts
-          });
-        }
+        const factsByPath = /* @__PURE__ */ new Map();
+        for (const facts of ctx.codeModel.files) factsByPath.set(pathKey(facts.path), facts);
         const degradedTsFiles = ctx.codeModel.files.filter(
           (f) => f.status === "analyzed" && (f.language === "typescript" || f.language === "javascript") && f.analysisGrade !== "exact"
         );
@@ -11925,8 +12147,7 @@ var init_structural_conformance = __esm({
           if (!component) continue;
           if (ctx.isInChainedSubproject(component.subsystem)) continue;
           const draft = ctx.isImplementationDraft(impl);
-          const methodImplOf = (name) => impl.methods.find((m) => m.name === name);
-          const unlinked = contract.methods.filter((method) => !methodSourceFile(methodImplOf(method.name) ?? {}, impl.sourcePath)).map((method) => method.name);
+          const unlinked = contract.methods.filter((method) => !methodSourceFile(impl.methods.find((m) => m.name === method.name) ?? {}, impl.sourcePath)).map((method) => method.name);
           const noFileAtAll = implementationSourceFiles(impl).length === 0;
           if (unlinked.length > 0 || noFileAtAll) {
             const hasExternalSource = (component.externalLinks ?? []).some((l) => l.type === "implementation");
@@ -11956,7 +12177,7 @@ var init_structural_conformance = __esm({
             const key = pathKey(file);
             if (reported.has(key)) continue;
             reported.add(key);
-            const facts = lookups.get(key)?.facts;
+            const facts = factsByPath.get(key);
             if (!facts || facts.status === "analyzed") continue;
             const isImplementationFile = !!impl.sourcePath && pathKey(impl.sourcePath) === key;
             const users = isImplementationFile ? [] : impl.methods.filter((m) => m.sourcePath && pathKey(m.sourcePath) === key).map((m) => m.name);
@@ -11987,22 +12208,49 @@ var init_structural_conformance = __esm({
               );
             }
           }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/conformance/method-realization.ts
+var methodRealizationRule;
+var init_method_realization = __esm({
+  "src/core/rules/conformance/method-realization.ts"() {
+    "use strict";
+    init_models();
+    methodRealizationRule = {
+      name: "method-realization",
+      description: "Code\u2194spec Level 1: every L3 contract method must be realized in its own source file (the method's sourcePath, else the implementation's) at its conformance tier \u2014 declared | anchored | off; Portals default to anchored, everything else to declared, and a per-method `symbol` maps an intent-language name onto the code name. Findings carry the analysis grade (exact AST | pattern table | generic scan) so weaker analysis is visible. Methods whose file escapes the root, is missing or could not be analyzed are left to source-file-linkage, and implementations under chained subsystems (projectPath) validate standalone in their own project run.",
+      codes: [
+        { 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" }
+      ],
+      check(ctx) {
+        const lookups = /* @__PURE__ */ new Map();
+        for (const facts of ctx.codeModel.files) {
+          lookups.set(pathKey(facts.path), {
+            declared: /* @__PURE__ */ new Set([...facts.declaredNames, ...facts.exportedNames]),
+            anchored: /* @__PURE__ */ new Set([...facts.declaredNames, ...facts.exportedNames, ...facts.anchoredNames]),
+            facts
+          });
+        }
+        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 draft = ctx.isImplementationDraft(impl);
           const specTier = impl.conformance ?? defaultConformanceTier(component);
-          const checkedFile = (methodName) => {
-            const methodImpl = methodImplOf(methodName);
+          for (const method of contract.methods) {
+            const methodImpl = impl.methods.find((m) => m.name === method.name);
             const tier = methodImpl?.conformance ?? specTier;
-            if (tier === "off") return void 0;
+            if (tier === "off") continue;
             const file = methodSourceFile(methodImpl ?? {}, impl.sourcePath);
-            if (!file) return void 0;
+            if (!file) continue;
             const lookup = lookups.get(pathKey(file));
-            if (!lookup || lookup.facts.status !== "analyzed") return void 0;
-            return { file, tier, lookup };
-          };
-          for (const method of contract.methods) {
-            const checked = checkedFile(method.name);
-            if (!checked) continue;
-            const { file, tier, lookup } = checked;
-            const methodImpl = methodImplOf(method.name);
+            if (!lookup || lookup.facts.status !== "analyzed") continue;
             const symbol = methodImpl?.symbol ?? method.name;
             const inDeclared = lookup.declared.has(symbol);
             const inAnchored = inDeclared || lookup.anchored.has(symbol);
@@ -12018,11 +12266,46 @@ var init_structural_conformance = __esm({
               draft
             );
           }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/conformance/finding-realization.ts
+var findingRealizationRule;
+var init_finding_realization = __esm({
+  "src/core/rules/conformance/finding-realization.ts"() {
+    "use strict";
+    init_models();
+    findingRealizationRule = {
+      name: "finding-realization",
+      description: "Code\u2194spec Level 1: every finding code an L3 contract method declares must be anchored in the method's own source file (the method's sourcePath, else the implementation's) \u2014 as a string literal or, at exact grade, a property-access name, so a code reported through a constants object counts. Below exact grade any identifier or word counts, and the grade rides on the finding. Respects the conformance dial (off skips), leaves unresolvable files to source-file-linkage, and skips implementations under chained subsystems (projectPath), which validate standalone in their own project run.",
+      codes: [
+        { 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)" }
+      ],
+      check(ctx) {
+        const lookups = /* @__PURE__ */ new Map();
+        for (const facts of ctx.codeModel.files) {
+          lookups.set(pathKey(facts.path), { findingAnchors: new Set(facts.anchoredNames), facts });
+        }
+        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 draft = ctx.isImplementationDraft(impl);
+          const specTier = impl.conformance ?? defaultConformanceTier(component);
           for (const method of contract.methods) {
             if (!method.findings?.length) continue;
-            const checked = checkedFile(method.name);
-            if (!checked) continue;
-            const { file, lookup } = checked;
+            const methodImpl = impl.methods.find((m) => m.name === method.name);
+            const tier = methodImpl?.conformance ?? specTier;
+            if (tier === "off") continue;
+            const file = methodSourceFile(methodImpl ?? {}, impl.sourcePath);
+            if (!file) continue;
+            const lookup = lookups.get(pathKey(file));
+            if (!lookup || lookup.facts.status !== "analyzed") continue;
             for (const finding of method.findings) {
               if (lookup.findingAnchors.has(finding.code)) continue;
               ctx.addIssue(
@@ -13604,12 +13887,19 @@ var init_repository = __esm({
     init_hierarchy_integrity();
     init_namespace_hygiene();
     init_roundtrip_serialization();
-    init_type_references2();
+    init_type_declarations();
+    init_field_type_references();
+    init_signature_type_references();
     init_public_surface();
     init_lint_allows();
-    init_contract_symmetry_and_narratives();
+    init_contract_symmetry();
+    init_narrative_target_references();
+    init_cross_tree_references();
+    init_surface_reference_backing();
     init_guarantee_tokens();
-    init_narrative_flow();
+    init_narrative_step_config();
+    init_narrative_reachability();
+    init_narrative_jump_edges();
     init_narrative_antipatterns();
     init_narrative_detail();
     init_portal_fields();
@@ -13621,14 +13911,17 @@ var init_repository = __esm({
     init_stereotype_dependencies();
     init_pattern_ownership();
     init_facade_forwarding();
-    init_architectural_profiles();
+    init_profile_registration();
+    init_profile_stereotype_fencing();
+    init_pack_profile_stereotypes();
     init_pattern_references();
     init_component_variants();
     init_declarative_assertions();
     init_pack_resolution();
     init_pack_reproducibility();
     init_dependency_cycles();
-    init_dispatch_tables();
+    init_dispatch_table_bindings();
+    init_dispatch_step_routing();
     init_lifecycle_entrypoints();
     init_unused_detection();
     init_durability_round_trip();
@@ -13636,7 +13929,9 @@ var init_repository = __esm({
     init_prose_claims();
     init_invariant_backing();
     init_event_topology();
-    init_structural_conformance();
+    init_source_file_linkage();
+    init_method_realization();
+    init_finding_realization();
     init_call_conformance();
     init_hidden_state();
     init_dependency_conformance();
@@ -13655,12 +13950,30 @@ var init_repository = __esm({
       // explain many downstream findings, so surface them early in the list.
       namespaceHygieneRule,
       roundtripRule,
-      typeReferencesRule,
-      contractsRule,
+      // The type vocabulary in three questions: what a type declares about
+      // itself, then the identifiers its fields name, then the ones its
+      // contracts' signatures name.
+      typeDeclarationsRule,
+      fieldTypeReferencesRule,
+      signatureTypeReferencesRule,
+      // Contracts and the targets narratives name, in four questions with one
+      // owner each: does the implementation mirror its contract, does a target
+      // inside this tree resolve, does a target that leaves it pin to exactly one
+      // declared surface, and does that surface back what the step asks of it.
+      contractSymmetryRule,
+      narrativeTargetReferencesRule,
+      crossTreeReferencesRule,
+      surfaceReferenceBackingRule,
       // Vocabulary check right after contracts: an unknown token explains why the
       // consistency findings around it are absent, so surface them together.
       guaranteeTokensRule,
-      narrativeFlowRule,
+      // Narrative control flow in three questions: does each step carry the
+      // config its type requires, can every step be reached (and do the regions
+      // nest), and where do the jump edges land. The last two run behind the
+      // first's soundness verdict.
+      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,
@@ -13677,7 +13990,12 @@ var init_repository = __esm({
       patternsRule,
       // Facade shape rides with pattern ownership: same §7 doctrine, narrative side.
       facadeForwardingRule,
-      profilesRule,
+      // Profiles in three questions, three owners: is the name real (the
+      // project's config), does the built-in family doctrine allow this
+      // stereotype (wairon), does the pack's declared doctrine allow it (the pack).
+      profileRegistrationRule,
+      profileStereotypeFencingRule,
+      packProfileStereotypesRule,
       patternReferencesRule,
       variantReferencesRule,
       // Pack-instantiated declarative doctrine rides with the pack-reference
@@ -13688,7 +14006,8 @@ var init_repository = __esm({
       // Semantic-edge family: dispatch/lifecycle validity BEFORE reachability so a
       // reader sees the broken edge finding next to the unused-detection fallout
       // it explains.
-      dispatchRule,
+      dispatchTableBindingsRule,
+      dispatchStepRoutingRule,
       lifecycleRule,
       reachabilityRule,
       // The declaration (spec-scoped, refused at the write boundary) before the
@@ -13707,9 +14026,14 @@ var init_repository = __esm({
       // Pub/sub completeness: emitted topics need subscribers and vice versa.
       eventTopologyRule,
       // Code↔spec: structural conformance consumes the injected CodeModel (built
-      // by the source analysis adapter next to the surface snapshots); dependency
-      // conformance lifts its import edges onto the declared dependsOn/owns graph.
-      structuralConformanceRule,
+      // by the source analysis adapter next to the surface snapshots) and asks it
+      // three questions — does the spec name files that exist, does the file
+      // contain the method, does it report the codes the method declares;
+      // dependency conformance lifts its import edges onto the declared
+      // dependsOn/owns graph.
+      sourceFileLinkageRule,
+      methodRealizationRule,
+      findingRealizationRule,
       // Level 3 opener: narrative call steps must be realized as callees of the
       // realized function (set membership, exact grade).
       callConformanceRule,
@@ -24867,6 +25191,7 @@ __export(src_exports, {
   splitNamespace: () => splitNamespace,
   stateIdEquals: () => stateIdEquals,
   stateIdString: () => stateIdString,
+  stepConfigVerdict: () => stepConfigVerdict,
   stepGraph: () => stepGraph,
   syncContextFiles: () => syncContextFiles,
   toMarkdown: () => toMarkdown,
@@ -25586,6 +25911,7 @@ function loadProjectConfig4() {
   splitNamespace,
   stateIdEquals,
   stateIdString,
+  stepConfigVerdict,
   stepGraph,
   syncContextFiles,
   toMarkdown,