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

package/dist/index.js

@@ -1113,7 +1113,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.24";
+    WAIRON_VERSION = "5.1.1-dev.26";
     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();
   }
@@ -8550,6 +8694,209 @@ var init_types = __esm({
   }
 });
 
+// src/core/rules/read-model.ts
+function appendUnique(map, key, value, same) {
+  const list = map.get(key);
+  if (!list) {
+    map.set(key, [value]);
+    return;
+  }
+  if (same ? list.some((v) => same(v, value)) : list.includes(value)) return;
+  list.push(value);
+}
+function buildCodeIndex(model) {
+  const facts = /* @__PURE__ */ new Map();
+  const paths = /* @__PURE__ */ new Set();
+  const exactPaths = /* @__PURE__ */ new Set();
+  for (const f of model.files) {
+    const key = pathKey(f.path);
+    facts.set(key, f);
+    paths.add(key);
+    if (f.status === "analyzed" && f.analysisGrade === "exact") exactPaths.add(key);
+  }
+  const declarations = /* @__PURE__ */ new Map();
+  const anchors = /* @__PURE__ */ new Map();
+  const findingAnchors = /* @__PURE__ */ new Map();
+  const namesAt = (cache, path27, make) => {
+    const cached = cache.get(path27);
+    if (cached) return cached;
+    const f = facts.get(path27);
+    if (!f) return NO_NAMES;
+    const built = make(f);
+    cache.set(path27, built);
+    return built;
+  };
+  return {
+    paths,
+    exactPaths,
+    factsAt: (path27) => facts.get(pathKey(path27)),
+    declarationsAt: (path27) => namesAt(declarations, pathKey(path27), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames])),
+    anchorsAt: (path27) => namesAt(anchors, pathKey(path27), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
+    findingAnchorsAt: (path27) => namesAt(findingAnchors, pathKey(path27), (f) => new Set(f.anchoredNames))
+  };
+}
+function buildRealizationIndex(ctx) {
+  const implsByComponent = /* @__PURE__ */ new Map();
+  const implsByPath = /* @__PURE__ */ new Map();
+  const filesByComponent = /* @__PURE__ */ new Map();
+  const filesBySubsystem = /* @__PURE__ */ new Map();
+  const componentsByPath = /* @__PURE__ */ new Map();
+  const paths = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  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;
+    appendUnique(implsByComponent, component.id, impl);
+    for (const file of implementationSourceFiles(impl)) {
+      const p = pathKey(file);
+      if (!seenPaths.has(p)) {
+        seenPaths.add(p);
+        paths.push(p);
+      }
+      appendUnique(implsByPath, p, impl);
+      appendUnique(filesByComponent, component.id, p);
+      appendUnique(filesBySubsystem, component.subsystem, p);
+      appendUnique(componentsByPath, p, component, (a, b) => a.id === b.id);
+    }
+  }
+  const NONE_IMPL = [];
+  const NONE_COMP = [];
+  const NONE_PATH = [];
+  return {
+    paths,
+    implementationsOf: (compId) => implsByComponent.get(compId) ?? NONE_IMPL,
+    implementationsAt: (path27) => implsByPath.get(pathKey(path27)) ?? NONE_IMPL,
+    filesOf: (compId) => filesByComponent.get(compId) ?? NONE_PATH,
+    filesIn: (subsystemId) => filesBySubsystem.get(subsystemId) ?? NONE_PATH,
+    componentsAt: (path27) => componentsByPath.get(pathKey(path27)) ?? NONE_COMP
+  };
+}
+function buildImportGraph(index, universe) {
+  const imports = /* @__PURE__ */ new Map();
+  const traces = /* @__PURE__ */ new Map();
+  const resolveAll = (from, specifiers, into) => {
+    for (const specifier of specifiers) {
+      const to = resolveImport(from, specifier, universe);
+      if (to && to !== from) into.add(to);
+    }
+  };
+  const importsOf = (path27) => {
+    const cached = imports.get(path27);
+    if (cached) return cached;
+    const facts = index.factsAt(path27);
+    const out = /* @__PURE__ */ new Set();
+    if (facts?.status === "analyzed") resolveAll(path27, facts.imports, out);
+    imports.set(path27, out);
+    return out;
+  };
+  const tracesOf = (path27) => {
+    const cached = traces.get(path27);
+    if (cached) return cached;
+    const facts = index.factsAt(path27);
+    const out = new Set(importsOf(path27));
+    if (facts?.status === "analyzed") resolveAll(path27, facts.reexports, out);
+    traces.set(path27, out);
+    return out;
+  };
+  return {
+    paths: [...universe],
+    importsOf,
+    tracesOf,
+    connects: (from, to, allowReverse) => {
+      for (const f of from) {
+        const forward = tracesOf(f);
+        for (const t of to) if (forward.has(t)) return true;
+      }
+      if (allowReverse) {
+        for (const t of to) {
+          const reverse = tracesOf(t);
+          for (const f of from) if (reverse.has(f)) return true;
+        }
+      }
+      return false;
+    },
+    reachFrom: (start) => {
+      const seen = /* @__PURE__ */ new Set([start]);
+      const stack = [start];
+      while (stack.length) {
+        const from = stack.pop();
+        for (const to of tracesOf(from)) {
+          if (seen.has(to)) continue;
+          seen.add(to);
+          stack.push(to);
+        }
+      }
+      return seen;
+    }
+  };
+}
+function buildOwnershipIndex(ctx) {
+  const ownedBy = /* @__PURE__ */ new Map();
+  for (const comp of ctx.components) {
+    if (isRetired(comp) || !isPattern(comp)) continue;
+    for (const memberId of comp.owns) {
+      const member = ctx.componentMap.get(memberId);
+      if (!member || isPattern(member)) continue;
+      if (!ownedBy.has(memberId)) ownedBy.set(memberId, comp.id);
+    }
+  }
+  return {
+    ownedMembers: new Set(ownedBy.keys()),
+    ownerOf: (memberId) => ownedBy.get(memberId)
+  };
+}
+function buildDependencyEdges(ctx) {
+  const all = [];
+  const matrix = [];
+  for (const from of ctx.components) {
+    const fromDraft = ctx.isComponentDraft(from.id);
+    const profile = ctx.ext.profiles[ctx.getComponentProfile(from.id)];
+    for (const ref of from.dependsOn) {
+      const to = ctx.componentMap.get(ref);
+      if (!to) {
+        all.push(offTreeEdge(ctx, from, ref, fromDraft));
+        continue;
+      }
+      const edge = {
+        from,
+        ref,
+        to,
+        reach: to.subsystem === from.subsystem ? "internal" : "cross-subsystem",
+        retired: isRetired(from) || isRetired(to),
+        draftContext: fromDraft || ctx.isComponentDraft(to.id),
+        licensed: profile?.allowedEdges?.some(
+          (e) => e.from.includes(from.componentType) && e.to.includes(to.componentType)
+        ) ?? false
+      };
+      all.push(edge);
+      if (edge.reach === "internal" && !edge.retired && !edge.licensed) matrix.push(edge);
+    }
+  }
+  return { all, matrix };
+}
+function offTreeEdge(ctx, from, ref, fromDraft) {
+  const base = { from, ref, retired: false, draftContext: fromDraft, licensed: false };
+  const external = ctx.isExternalNamespaceRef(ref);
+  if (external || ctx.isCollapsedCrossTreeRef(ref, from.subsystem)) {
+    const surface = ctx.resolveSurfaceRef(ref, from.subsystem);
+    if (surface.kind === "ambiguous") return { ...base, reach: "ambiguous", surface };
+    if (surface.kind === "resolved") return { ...base, reach: "surface", surface };
+    if (external) return { ...base, reach: "unpinned" };
+  }
+  return { ...base, reach: "missing" };
+}
+var NO_NAMES;
+var init_read_model = __esm({
+  "src/core/rules/read-model.ts"() {
+    "use strict";
+    init_models();
+    NO_NAMES = /* @__PURE__ */ new Set();
+  }
+});
+
 // src/core/rules/integrity/hierarchy-integrity.ts
 var hierarchyRule;
 var init_hierarchy_integrity = __esm({
@@ -8697,18 +9044,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 +9078,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 +9289,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 +9330,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 +9371,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 +9410,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,21 +9432,184 @@ 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 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) {
+            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(
+                    "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;
+              }
+              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";
+    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: "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) {
+            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",
+                  "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 || ctx.isComponentDraft(caller.id),
+                  true
+                );
+              }
+              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
+                  );
+                }
+                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
+                  );
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// 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) {
@@ -9215,166 +9649,68 @@ var init_guarantee_tokens = __esm({
   }
 });
 
-// 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"() {
+// 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();
-    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.',
+    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: "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" }
       ],
+      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 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) {
-                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.`,
-                  impl.id,
-                  isDraftCtx
-                );
-              } 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;
-                }
-                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;
-                }
-                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;
-                  ctx.addIssue(
-                    "error",
-                    "INVALID_STEP_JUMP",
-                    `${where}step ${s.stepNumber} "${field}" targets step ${target}, which does not exist in this narrative.`,
-                    impl.id,
-                    isDraftCtx
-                  );
-                }
-              }
-            }
-            if (!sound) continue;
             const graph = stepGraph(implMethod);
+            const nums = graph.stepNumbers;
             const visited = /* @__PURE__ */ new Set();
             const stack = [nums[0]];
             while (stack.length) {
@@ -9395,13 +9731,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 +9745,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 +9814,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));
@@ -9724,8 +10105,7 @@ var init_narrative_detail = __esm({
         { code: "DETAIL_BELOW_STEREOTYPE", defaultSeverity: "warning", summary: "Method explicitly dialed below the full narrative floor of its logic stereotype, with no narrative" }
       ],
       check(ctx) {
-        const factsByPath = /* @__PURE__ */ new Map();
-        for (const f of ctx.codeModel.files) factsByPath.set(pathKey(f.path), f);
+        const code = ctx.codeIndex();
         for (const impl of ctx.implementations) {
           const contract = ctx.interfaceMap.get(impl.contract);
           if (!contract) continue;
@@ -9751,7 +10131,7 @@ var init_narrative_detail = __esm({
             const tier = implMethod.conformance ?? impl.conformance ?? defaultConformanceTier(component);
             const file = methodSourceFile(implMethod, impl.sourcePath);
             if (file && tier !== "off" && !(component && ctx.isInChainedSubproject(component.subsystem))) {
-              const facts = factsByPath.get(pathKey(file));
+              const facts = code.factsAt(file);
               const symbol = implMethod.symbol ?? implMethod.name;
               const complexity = facts?.status === "analyzed" && facts.analysisGrade === "exact" && facts.functionComplexity && Object.prototype.hasOwnProperty.call(facts.functionComplexity, symbol) ? facts.functionComplexity[symbol] : void 0;
               const limit = ctx.complexityConfigFor(component?.subsystem)?.maxUnnarratedComplexity ?? DEFAULT_MAX_UNNARRATED_COMPLEXITY;
@@ -9897,7 +10277,7 @@ var init_logic_declaration = __esm({
     logicDeclarationRule = {
       name: "logic-declaration",
       scope: "spec",
-      description: "Only an Orchestrator may declare a dependencyClass (DEPENDENCY_CLASS_ON_NON_ORCHESTRATOR); what the class allows is judged by stereotype-dependencies. Intrinsic to one component: no tree required.",
+      description: "Only an Orchestrator may declare a dependencyClass (DEPENDENCY_CLASS_ON_NON_ORCHESTRATOR); what the class allows is judged by logic-dependency-class. Intrinsic to one component: no tree required.",
       codes: [
         { code: "DEPENDENCY_CLASS_ON_NON_ORCHESTRATOR", defaultSeverity: "error", summary: "dependencyClass declared on a component that is not an Orchestrator" }
       ],
@@ -10123,257 +10503,341 @@ var init_portal_call_auth = __esm({
   }
 });
 
-// src/core/rules/doctrine/stereotype-dependencies.ts
-var NEVER_INLINE_STATE, storeResolutionHint, isPureLogic, isReadLogic, stereotypeOf, stereotypeDepsRule;
-var init_stereotype_dependencies = __esm({
-  "src/core/rules/doctrine/stereotype-dependencies.ts"() {
+// src/core/rules/doctrine/subsystem-boundary-dependencies.ts
+var subsystemBoundaryDepsRule;
+var init_subsystem_boundary_dependencies = __esm({
+  "src/core/rules/doctrine/subsystem-boundary-dependencies.ts"() {
     "use strict";
     init_models();
-    NEVER_INLINE_STATE = " Never resolve this by merging the store's state into the consuming component \u2014 state hidden inside a logic block is invisible to the spec and unrecoverable.";
-    storeResolutionHint = (consumerType, storeId) => {
-      if (consumerType === "Orchestrator") {
-        return ` Resolution: wrap "${storeId}" in a Repository pattern (owns: Store + Registry + Index) and depend on that Repository facade instead.${NEVER_INLINE_STATE}`;
-      }
-      return ` Resolution: wrap "${storeId}" in a Repository pattern and reach it through an Orchestrator that uses the Repository facade.${NEVER_INLINE_STATE}`;
-    };
-    isPureLogic = (comp) => comp.componentType === "Orchestrator" && comp.dependencyClass === "pure";
-    isReadLogic = (comp) => comp.componentType === "Orchestrator" && comp.dependencyClass === "read";
-    stereotypeOf = (comp) => comp.dependencyClass ? `${comp.componentType} (dependencyClass ${comp.dependencyClass})` : comp.componentType;
-    stereotypeDepsRule = {
-      name: "stereotype-dependencies",
-      description: "Enforces the component-stereotype interaction matrix and the cross-subsystem shape. The matrix: a Portal reaches the data layer only through Repository/Index READ faces, and writes route through Orchestrators (PORTAL_WRITE_SHORTCUT); Stores are depended upon; Registries write their Store; Adapters are sinks; Views stay passive; an Orchestrator's dependencyClass bounds what it may depend on; a Supervisor reaches data only through workflows; a live Actor is reached through a Supervisor that supervises it; a Query reads its Store; any block may use pure logic. Across subsystems: client Adapter \u2192 published remote Portal, OR a direct in-process edge licensed by a trustedLink declared on the SOURCE subsystem (the published-Portal target requirement applies either way). A governing pack profile may license intra-subsystem edges the matrix refuses via allowedEdges (its platform idiom, with the stated reason); boundary rules stay unrelaxable.",
+    subsystemBoundaryDepsRule = {
+      name: "subsystem-boundary-dependencies",
+      description: "Judges every dependsOn edge that leaves its own subsystem, and every one that resolves nowhere. Across subsystems the shape is client Adapter \u2192 published remote Portal, OR a direct in-process edge licensed by a trustedLink declared on the SOURCE subsystem (the published-Portal target requirement applies either way). A reference that names nothing in this tree is resolved against the stored surface snapshots: a hit is a DECLARED remote portal and the same Adapter requirement applies to it, snapshots of several providers that disagree make the reference ambiguous, and a reference authored to leave this root that no snapshot covers warns instead of erroring. Boundary rules are never relaxed by a pack profile.",
       codes: [
         { code: "INVALID_DEPENDENCY_REFERENCE", defaultSeverity: "error", summary: "dependsOn names a non-existent component" },
         { code: "CROSS_TREE_REF_UNRESOLVED", defaultSeverity: "warning", summary: "Cross-tree dependsOn (super::/:: form) with no surface snapshot covering it" },
         { code: "SURFACE_REF_AMBIGUOUS", defaultSeverity: "error", summary: "Cross-tree dependsOn matched by surface snapshots of several providers with different contracts" },
         { code: "CROSS_SUBSYSTEM_NON_ADAPTER", defaultSeverity: "error", summary: "Non-Adapter component crossing a subsystem boundary" },
         { code: "CROSS_SUBSYSTEM_PRIVATE_ACCESS", defaultSeverity: "error", summary: "Cross-subsystem dependency on an unpublished component" },
-        { code: "CROSS_SUBSYSTEM_TARGET_NON_PORTAL", defaultSeverity: "error", summary: "Cross-subsystem hop entering through a non-Portal" },
-        { code: "ARCHITECTURE_VIOLATION_PORTAL_DEP", defaultSeverity: "error", summary: "Component depending on a Portal/Observer" },
-        { code: "ARCHITECTURE_VIOLATION_PORTAL_FORBIDDEN_DEP", defaultSeverity: "error", summary: "Portal/Observer reaching the data layer directly" },
-        { code: "ARCHITECTURE_VIOLATION_STORE_DEP", defaultSeverity: "error", summary: "Store depending on anything but another Store, a backend Adapter or pure logic" },
-        { code: "ARCHITECTURE_VIOLATION_REGISTRY_DEP", defaultSeverity: "warning", summary: "Registry depending on anything but its Store, a backend Adapter or pure logic (warning while new; aligned to the standard \xA77 validate\u2192write path)" },
-        { code: "ARCHITECTURE_VIOLATION_ADAPTER_DEP", defaultSeverity: "error", summary: "Adapter depending on a Store or on an Orchestrator that is not pure" },
-        { code: "ARCHITECTURE_VIOLATION_INDEX_DEP", defaultSeverity: "error", summary: "Index depending on anything but its Store, an Adapter or pure logic" },
-        { code: "ARCHITECTURE_VIOLATION_VIEW_DEP", defaultSeverity: "error", summary: "View depending on persistence layers or on logic that is not pure" },
-        { code: "PORTAL_WRITE_SHORTCUT", defaultSeverity: "error", summary: "Portal narrative call or dispatch-table binding reaches a write-effect method on a Repository/Index directly \u2014 reads may shortcut, writes route through an Orchestrator (judged on effect-tagged facade methods; untagged methods are not yet judged)" },
-        { code: "DEPENDENCY_CLASS_VIOLATION", defaultSeverity: "error", summary: "Orchestrator depending on a component its dependencyClass does not allow: pure logic depends only on pure Orchestrators; read logic also on read Orchestrators, Repositories, Indexes and Adapters" },
-        { code: "ARCHITECTURE_VIOLATION_SUPERVISOR_DEP", defaultSeverity: "error", summary: "Supervisor depending on anything but Actors, Orchestrators, Adapters or other Supervisors \u2014 it reaches data only through workflows" },
-        { code: "ACTOR_REACHED_WITHOUT_SUPERVISOR", defaultSeverity: "error", summary: "Component depending on a live Actor it does not supervise, without also depending on a Supervisor that supervises it \u2014 a live Actor is reached by id through its Supervisor" },
-        { code: "ARCHITECTURE_VIOLATION_QUERY_DEP", defaultSeverity: "error", summary: "Query depending on anything but its Store, a backend Adapter or pure logic" }
+        { code: "CROSS_SUBSYSTEM_TARGET_NON_PORTAL", defaultSeverity: "error", summary: "Cross-subsystem hop entering through a non-Portal" }
       ],
       check(ctx) {
-        for (const comp of ctx.components) {
-          const isDraftCtx = ctx.isComponentDraft(comp.id);
-          const dependencies = comp.dependsOn;
-          for (const depId of dependencies) {
-            const depComp = ctx.componentMap.get(depId);
-            if (!depComp) {
-              const external = ctx.isExternalNamespaceRef(depId);
-              if (external || ctx.isCollapsedCrossTreeRef(depId, comp.subsystem)) {
-                const resolved = ctx.resolveSurfaceRef(depId, comp.subsystem);
-                if (resolved.kind === "ambiguous") {
-                  ctx.addIssue("error", "SURFACE_REF_AMBIGUOUS", ambiguityMessage(resolved, `Component "${comp.id}" depends on`, depId), comp.id, isDraftCtx);
-                  continue;
-                }
-                if (resolved.kind === "resolved") {
-                  if (comp.componentType !== "Adapter") {
-                    ctx.addIssue(
-                      "error",
-                      "CROSS_SUBSYSTEM_NON_ADAPTER",
-                      `Boundary violation: ${comp.componentType} "${comp.id}" depends directly on "${depId}", a surface of project "${resolved.snapshot.projectName}". Only a local client Adapter may cross a project boundary \u2014 route this hop through an Adapter.`,
-                      comp.id,
-                      isDraftCtx,
-                      true
-                    );
-                  }
-                  continue;
-                }
-                if (external) {
-                  ctx.addIssue(
-                    "warning",
-                    "CROSS_TREE_REF_UNRESOLVED",
-                    `Component "${comp.id}" depends on cross-tree component "${depId}", 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.`,
-                    comp.id,
-                    isDraftCtx
-                  );
-                  continue;
-                }
-              }
+        for (const edge of ctx.dependencyEdges().all) {
+          if (edge.retired) continue;
+          const comp = edge.from;
+          switch (edge.reach) {
+            case "missing":
               ctx.addIssue(
                 "error",
                 "INVALID_DEPENDENCY_REFERENCE",
-                `Component "${comp.id}" lists dependency "${depId}" which does not exist.`,
+                `Component "${comp.id}" lists dependency "${edge.ref}" which does not exist.`,
                 comp.id,
-                isDraftCtx
+                edge.draftContext
               );
               continue;
-            }
-            if (isRetired(comp) || isRetired(depComp)) continue;
-            if (depComp.subsystem !== comp.subsystem) {
-              const crossDraft = isDraftCtx || ctx.isComponentDraft(depComp.id);
-              const sourceSub = ctx.subsystems.find((s) => s.id === comp.subsystem);
-              const licensed = sourceSub?.trustedLinks?.some((t) => t.subsystem === depComp.subsystem) ?? false;
-              if (comp.componentType !== "Adapter" && !licensed) {
-                ctx.addIssue(
-                  "error",
-                  "CROSS_SUBSYSTEM_NON_ADAPTER",
-                  `Boundary violation: ${comp.componentType} "${comp.id}" (subsystem "${comp.subsystem}") depends directly on "${depComp.id}" in subsystem "${depComp.subsystem}". Only a local client Adapter may cross a subsystem boundary \u2014 route this hop through an Adapter that calls "${depComp.subsystem}"'s public interface, or declare a trustedLink on "${comp.subsystem}" (with the reason) to license a direct in-process edge to that peer's published Portal.`,
-                  comp.id,
-                  crossDraft
-                );
-              }
-              const targetIsPublic = ctx.publicSet.get(depComp.subsystem)?.has(depComp.id) ?? false;
-              if (!targetIsPublic) {
-                ctx.addIssue(
-                  "error",
-                  "CROSS_SUBSYSTEM_PRIVATE_ACCESS",
-                  `Boundary violation: "${comp.id}" depends on "${depComp.id}", which is not part of subsystem "${depComp.subsystem}"'s published public surface. Depend on one of its publicInterfaces components instead.`,
-                  comp.id,
-                  crossDraft
-                );
-              } else if (depComp.componentType !== "Portal") {
-                const crosser = comp.componentType === "Adapter" ? "client Adapter" : comp.componentType;
-                ctx.addIssue(
-                  "error",
-                  "CROSS_SUBSYSTEM_TARGET_NON_PORTAL",
-                  `Boundary violation: ${crosser} "${comp.id}" enters subsystem "${depComp.subsystem}" through "${depComp.id}" (${depComp.componentType}), not its inbound Portal. A cross-subsystem hop must target the remote subsystem's Portal (its front door), which dispatches inward \u2014 publishing/depending on an internal ${depComp.componentType} leaks the boundary and breaks the distribution seam. Expose a Portal for "${depComp.subsystem}" and point "${comp.id}" at it.`,
-                  comp.id,
-                  crossDraft
-                );
-              }
-              continue;
-            }
-            const governingProfile2 = ctx.ext.profiles[ctx.getComponentProfile(comp.id)];
-            if (governingProfile2?.allowedEdges?.some((e) => e.from.includes(comp.componentType) && e.to.includes(depComp.componentType))) {
+            case "unpinned":
+              ctx.addIssue(
+                "warning",
+                "CROSS_TREE_REF_UNRESOLVED",
+                `Component "${comp.id}" depends on cross-tree component "${edge.ref}", 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.`,
+                comp.id,
+                edge.draftContext
+              );
               continue;
-            }
-            const edgeDraft = isDraftCtx || ctx.isComponentDraft(depComp.id);
-            const depPure = isPureLogic(depComp);
-            const depRead = isReadLogic(depComp);
-            const storeHint = depComp.componentType === "Store" ? storeResolutionHint(comp.componentType, depComp.id) : "";
-            if (depComp.componentType === "Portal" || depComp.componentType === "Observer") {
+            case "ambiguous":
               ctx.addIssue(
                 "error",
-                "ARCHITECTURE_VIOLATION_PORTAL_DEP",
-                `Architectural violation: Component "${comp.id}" cannot depend on ${depComp.componentType} component "${depComp.id}". ${depComp.componentType}s are top-level entry points/subscribers and cannot be dependencies.`,
+                "SURFACE_REF_AMBIGUOUS",
+                ambiguityMessage(edge.surface, `Component "${comp.id}" depends on`, edge.ref),
                 comp.id,
-                edgeDraft
+                edge.draftContext
               );
               continue;
-            }
-            if (comp.componentType === "Portal" || comp.componentType === "Observer") {
-              const forbiddenTypes = comp.componentType === "Portal" ? ["Store", "Registry", "Adapter", "Query"] : ["Store", "Registry", "Repository", "Index", "Query"];
-              if (forbiddenTypes.includes(depComp.componentType)) {
+            case "surface":
+              if (comp.componentType !== "Adapter") {
+                const provider = edge.surface.kind === "resolved" ? edge.surface.snapshot.projectName : "";
                 ctx.addIssue(
                   "error",
-                  "ARCHITECTURE_VIOLATION_PORTAL_FORBIDDEN_DEP",
-                  `Architectural violation: ${comp.componentType} component "${comp.id}" cannot depend directly on "${depComp.componentType}" component "${depComp.id}". ${comp.componentType}s coordinate through Orchestrators (and Supervisors); they do not reach the data layer directly.` + storeHint,
+                  "CROSS_SUBSYSTEM_NON_ADAPTER",
+                  `Boundary violation: ${comp.componentType} "${comp.id}" depends directly on "${edge.ref}", a surface of project "${provider}". Only a local client Adapter may cross a project boundary \u2014 route this hop through an Adapter.`,
                   comp.id,
-                  edgeDraft
+                  edge.draftContext,
+                  true
                 );
               }
-            }
-            if (isPureLogic(comp) && !depPure) {
-              ctx.addIssue(
-                "error",
-                "DEPENDENCY_CLASS_VIOLATION",
-                `Architectural violation: Orchestrator "${comp.id}" (dependencyClass pure) cannot depend on ${stereotypeOf(depComp)} "${depComp.id}". Pure logic depends only on pure Orchestrators \u2014 move that dependency to the workflow that calls "${comp.id}", or declare "${comp.id}" read when it reads through read logic, a Repository, an Index or an Adapter.` + storeHint,
-                comp.id,
-                edgeDraft
-              );
-            }
-            if (isReadLogic(comp) && !depPure && !depRead && !["Repository", "Index", "Adapter"].includes(depComp.componentType)) {
-              ctx.addIssue(
-                "error",
-                "DEPENDENCY_CLASS_VIOLATION",
-                `Architectural violation: Orchestrator "${comp.id}" (dependencyClass read) cannot depend on ${stereotypeOf(depComp)} "${depComp.id}". Read logic depends only on pure or read Orchestrators, Repositories, Indexes and Adapters \u2014 move that dependency to the workflow that calls "${comp.id}", or unset the dependencyClass of "${comp.id}" when it is itself a workflow.` + storeHint,
-                comp.id,
-                edgeDraft
-              );
-            }
-            if (comp.componentType === "Store" && depComp.componentType !== "Store" && depComp.componentType !== "Adapter" && !depPure) {
-              ctx.addIssue(
-                "error",
-                "ARCHITECTURE_VIOLATION_STORE_DEP",
-                `Architectural violation: Store component "${comp.id}" cannot depend on "${depComp.componentType}" component "${depComp.id}". Stores may only depend on other Stores, a backend Adapter or pure logic \u2014 Registries and Indexes depend on the Store, never the reverse.`,
-                comp.id,
-                edgeDraft
-              );
-            }
-            if (comp.componentType === "Registry" && depComp.componentType !== "Store" && depComp.componentType !== "Adapter" && !depPure) {
-              ctx.addIssue(
-                "warning",
-                "ARCHITECTURE_VIOLATION_REGISTRY_DEP",
-                `Architectural violation: Registry component "${comp.id}" should not depend on "${depComp.componentType}" component "${depComp.id}". A Registry is the write path to its Store and may depend only on that Store, a backend Adapter, or pure logic that validates the write \u2014 the Registry never updates Indexes and never drives workflow.`,
-                comp.id,
-                edgeDraft
-              );
-            }
-            if (comp.componentType === "Adapter" && (depComp.componentType === "Store" || depComp.componentType === "Orchestrator" && !depPure)) {
-              ctx.addIssue(
-                "error",
-                "ARCHITECTURE_VIOLATION_ADAPTER_DEP",
-                `Architectural violation: Adapter component "${comp.id}" cannot depend on ${stereotypeOf(depComp)} component "${depComp.id}". An Adapter may use pure logic, but never a Store or any other Orchestrator.`,
-                comp.id,
-                edgeDraft
-              );
-            }
-            if (comp.componentType === "Index" && depComp.componentType !== "Store" && depComp.componentType !== "Adapter" && !depPure) {
-              ctx.addIssue(
-                "error",
-                "ARCHITECTURE_VIOLATION_INDEX_DEP",
-                `Architectural violation: Index component "${comp.id}" cannot depend on "${depComp.componentType}" component "${depComp.id}". An Index is a read projection and may depend only on its Store, a backend Adapter or pure logic.`,
-                comp.id,
-                edgeDraft
-              );
-            }
-            if (comp.componentType === "Query" && depComp.componentType !== "Store" && depComp.componentType !== "Adapter" && !depPure) {
-              ctx.addIssue(
-                "error",
-                "ARCHITECTURE_VIOLATION_QUERY_DEP",
-                `Architectural violation: Query "${comp.id}" cannot depend on ${stereotypeOf(depComp)} "${depComp.id}". A Query computes reads over its Store, through a backend Adapter where one serves it, with pure logic \u2014 move any other dependency to the workflow that calls the Repository facade.`,
-                comp.id,
-                edgeDraft
-              );
-            }
-            if (comp.componentType === "View" && (["Store", "Registry", "Index", "Query", "Adapter", "Repository"].includes(depComp.componentType) || depComp.componentType === "Orchestrator" && !depPure)) {
+              continue;
+            case "cross-subsystem":
+              break;
+            default:
+              continue;
+          }
+          const depComp = edge.to;
+          const sourceSub = ctx.subsystems.find((s) => s.id === comp.subsystem);
+          const licensed = sourceSub?.trustedLinks?.some((t) => t.subsystem === depComp.subsystem) ?? false;
+          if (comp.componentType !== "Adapter" && !licensed) {
+            ctx.addIssue(
+              "error",
+              "CROSS_SUBSYSTEM_NON_ADAPTER",
+              `Boundary violation: ${comp.componentType} "${comp.id}" (subsystem "${comp.subsystem}") depends directly on "${depComp.id}" in subsystem "${depComp.subsystem}". Only a local client Adapter may cross a subsystem boundary \u2014 route this hop through an Adapter that calls "${depComp.subsystem}"'s public interface, or declare a trustedLink on "${comp.subsystem}" (with the reason) to license a direct in-process edge to that peer's published Portal.`,
+              comp.id,
+              edge.draftContext
+            );
+          }
+          const targetIsPublic = ctx.publicSet.get(depComp.subsystem)?.has(depComp.id) ?? false;
+          if (!targetIsPublic) {
+            ctx.addIssue(
+              "error",
+              "CROSS_SUBSYSTEM_PRIVATE_ACCESS",
+              `Boundary violation: "${comp.id}" depends on "${depComp.id}", which is not part of subsystem "${depComp.subsystem}"'s published public surface. Depend on one of its publicInterfaces components instead.`,
+              comp.id,
+              edge.draftContext
+            );
+          } else if (depComp.componentType !== "Portal") {
+            const crosser = comp.componentType === "Adapter" ? "client Adapter" : comp.componentType;
+            ctx.addIssue(
+              "error",
+              "CROSS_SUBSYSTEM_TARGET_NON_PORTAL",
+              `Boundary violation: ${crosser} "${comp.id}" enters subsystem "${depComp.subsystem}" through "${depComp.id}" (${depComp.componentType}), not its inbound Portal. A cross-subsystem hop must target the remote subsystem's Portal (its front door), which dispatches inward \u2014 publishing/depending on an internal ${depComp.componentType} leaks the boundary and breaks the distribution seam. Expose a Portal for "${depComp.subsystem}" and point "${comp.id}" at it.`,
+              comp.id,
+              edge.draftContext
+            );
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/doctrine/stereotype-terms.ts
+var NEVER_INLINE_STATE, storeResolutionHint, isPureLogic, isReadLogic, stereotypeOf;
+var init_stereotype_terms = __esm({
+  "src/core/rules/doctrine/stereotype-terms.ts"() {
+    "use strict";
+    NEVER_INLINE_STATE = " Never resolve this by merging the store's state into the consuming component \u2014 state hidden inside a logic block is invisible to the spec and unrecoverable.";
+    storeResolutionHint = (consumerType, storeId) => {
+      if (consumerType === "Orchestrator") {
+        return ` Resolution: wrap "${storeId}" in a Repository pattern (owns: Store + Registry + Index) and depend on that Repository facade instead.${NEVER_INLINE_STATE}`;
+      }
+      return ` Resolution: wrap "${storeId}" in a Repository pattern and reach it through an Orchestrator that uses the Repository facade.${NEVER_INLINE_STATE}`;
+    };
+    isPureLogic = (comp) => comp.componentType === "Orchestrator" && comp.dependencyClass === "pure";
+    isReadLogic = (comp) => comp.componentType === "Orchestrator" && comp.dependencyClass === "read";
+    stereotypeOf = (comp) => comp.dependencyClass ? `${comp.componentType} (dependencyClass ${comp.dependencyClass})` : comp.componentType;
+  }
+});
+
+// src/core/rules/doctrine/logic-dependency-class.ts
+var logicDependencyClassRule;
+var init_logic_dependency_class = __esm({
+  "src/core/rules/doctrine/logic-dependency-class.ts"() {
+    "use strict";
+    init_stereotype_terms();
+    logicDependencyClassRule = {
+      name: "logic-dependency-class",
+      description: "Bounds an Orchestrator's dependencies by the dependencyClass it declares: pure logic depends only on pure Orchestrators; read logic also on read Orchestrators, Repositories, Indexes and Adapters; an Orchestrator that declares no class is a workflow and may depend on anything the rest of the matrix allows. Whether read logic calls a WRITE method on one of those is judged only once facade methods carry effect tags.",
+      codes: [
+        { code: "DEPENDENCY_CLASS_VIOLATION", defaultSeverity: "error", summary: "Orchestrator depending on a component its dependencyClass does not allow: pure logic depends only on pure Orchestrators; read logic also on read Orchestrators, Repositories, Indexes and Adapters" }
+      ],
+      check(ctx) {
+        for (const edge of ctx.dependencyEdges().matrix) {
+          const comp = edge.from;
+          const depComp = edge.to;
+          if (depComp.componentType === "Portal" || depComp.componentType === "Observer") continue;
+          const depPure = isPureLogic(depComp);
+          const storeHint = depComp.componentType === "Store" ? storeResolutionHint(comp.componentType, depComp.id) : "";
+          if (isPureLogic(comp) && !depPure) {
+            ctx.addIssue(
+              "error",
+              "DEPENDENCY_CLASS_VIOLATION",
+              `Architectural violation: Orchestrator "${comp.id}" (dependencyClass pure) cannot depend on ${stereotypeOf(depComp)} "${depComp.id}". Pure logic depends only on pure Orchestrators \u2014 move that dependency to the workflow that calls "${comp.id}", or declare "${comp.id}" read when it reads through read logic, a Repository, an Index or an Adapter.` + storeHint,
+              comp.id,
+              edge.draftContext
+            );
+          }
+          if (isReadLogic(comp) && !depPure && !isReadLogic(depComp) && !["Repository", "Index", "Adapter"].includes(depComp.componentType)) {
+            ctx.addIssue(
+              "error",
+              "DEPENDENCY_CLASS_VIOLATION",
+              `Architectural violation: Orchestrator "${comp.id}" (dependencyClass read) cannot depend on ${stereotypeOf(depComp)} "${depComp.id}". Read logic depends only on pure or read Orchestrators, Repositories, Indexes and Adapters \u2014 move that dependency to the workflow that calls "${comp.id}", or unset the dependencyClass of "${comp.id}" when it is itself a workflow.` + storeHint,
+              comp.id,
+              edge.draftContext
+            );
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/doctrine/data-block-dependencies.ts
+var dataBlockDepsRule;
+var init_data_block_dependencies = __esm({
+  "src/core/rules/doctrine/data-block-dependencies.ts"() {
+    "use strict";
+    init_stereotype_terms();
+    dataBlockDepsRule = {
+      name: "data-block-dependencies",
+      description: "Keeps the data layer facing down. A Store may depend only on another Store, a backend Adapter or pure logic \u2014 Registries and Indexes depend on the Store, never the reverse. A Registry is the write path to its Store and may depend on that Store, a backend Adapter, or the pure logic that validates the write. An Index is a read projection and a Query a computed read, each over its Store through a backend Adapter where one serves it. An Adapter is a sink toward the system: it may use pure logic, but never a Store or any other Orchestrator.",
+      codes: [
+        { code: "ARCHITECTURE_VIOLATION_STORE_DEP", defaultSeverity: "error", summary: "Store depending on anything but another Store, a backend Adapter or pure logic" },
+        { code: "ARCHITECTURE_VIOLATION_REGISTRY_DEP", defaultSeverity: "warning", summary: "Registry depending on anything but its Store, a backend Adapter or pure logic (warning while new; aligned to the standard \xA77 validate\u2192write path)" },
+        { code: "ARCHITECTURE_VIOLATION_ADAPTER_DEP", defaultSeverity: "error", summary: "Adapter depending on a Store or on an Orchestrator that is not pure" },
+        { code: "ARCHITECTURE_VIOLATION_INDEX_DEP", defaultSeverity: "error", summary: "Index depending on anything but its Store, an Adapter or pure logic" },
+        { code: "ARCHITECTURE_VIOLATION_QUERY_DEP", defaultSeverity: "error", summary: "Query depending on anything but its Store, a backend Adapter or pure logic" }
+      ],
+      check(ctx) {
+        for (const edge of ctx.dependencyEdges().matrix) {
+          const comp = edge.from;
+          const depComp = edge.to;
+          if (depComp.componentType === "Portal" || depComp.componentType === "Observer") continue;
+          const depPure = isPureLogic(depComp);
+          const ownStoreOnly = depComp.componentType !== "Store" && depComp.componentType !== "Adapter" && !depPure;
+          if (comp.componentType === "Store" && ownStoreOnly) {
+            ctx.addIssue(
+              "error",
+              "ARCHITECTURE_VIOLATION_STORE_DEP",
+              `Architectural violation: Store component "${comp.id}" cannot depend on "${depComp.componentType}" component "${depComp.id}". Stores may only depend on other Stores, a backend Adapter or pure logic \u2014 Registries and Indexes depend on the Store, never the reverse.`,
+              comp.id,
+              edge.draftContext
+            );
+          }
+          if (comp.componentType === "Registry" && ownStoreOnly) {
+            ctx.addIssue(
+              "warning",
+              "ARCHITECTURE_VIOLATION_REGISTRY_DEP",
+              `Architectural violation: Registry component "${comp.id}" should not depend on "${depComp.componentType}" component "${depComp.id}". A Registry is the write path to its Store and may depend only on that Store, a backend Adapter, or pure logic that validates the write \u2014 the Registry never updates Indexes and never drives workflow.`,
+              comp.id,
+              edge.draftContext
+            );
+          }
+          if (comp.componentType === "Adapter" && (depComp.componentType === "Store" || depComp.componentType === "Orchestrator" && !depPure)) {
+            ctx.addIssue(
+              "error",
+              "ARCHITECTURE_VIOLATION_ADAPTER_DEP",
+              `Architectural violation: Adapter component "${comp.id}" cannot depend on ${stereotypeOf(depComp)} component "${depComp.id}". An Adapter may use pure logic, but never a Store or any other Orchestrator.`,
+              comp.id,
+              edge.draftContext
+            );
+          }
+          if (comp.componentType === "Index" && ownStoreOnly) {
+            ctx.addIssue(
+              "error",
+              "ARCHITECTURE_VIOLATION_INDEX_DEP",
+              `Architectural violation: Index component "${comp.id}" cannot depend on "${depComp.componentType}" component "${depComp.id}". An Index is a read projection and may depend only on its Store, a backend Adapter or pure logic.`,
+              comp.id,
+              edge.draftContext
+            );
+          }
+          if (comp.componentType === "Query" && ownStoreOnly) {
+            ctx.addIssue(
+              "error",
+              "ARCHITECTURE_VIOLATION_QUERY_DEP",
+              `Architectural violation: Query "${comp.id}" cannot depend on ${stereotypeOf(depComp)} "${depComp.id}". A Query computes reads over its Store, through a backend Adapter where one serves it, with pure logic \u2014 move any other dependency to the workflow that calls the Repository facade.`,
+              comp.id,
+              edge.draftContext
+            );
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/doctrine/entrypoint-dependencies.ts
+var entrypointDepsRule;
+var init_entrypoint_dependencies = __esm({
+  "src/core/rules/doctrine/entrypoint-dependencies.ts"() {
+    "use strict";
+    init_stereotype_terms();
+    entrypointDepsRule = {
+      name: "entrypoint-dependencies",
+      description: "Judges the edges at the system's entry points and its process layer. Portals and Observers are top-level entry points and subscribers, so nothing may depend on them \u2014 and that is the edge's one finding, which is why no other matrix rule judges it. Downward, a Portal dispatches to Orchestrators and may READ through Indexes and Repository facades but never reaches Store/Registry/Query or an Adapter, while an Observer forwards to one Orchestrator or Supervisor over a message-bus Adapter. A View stays a passive presenter. A Supervisor reaches data only through workflows, and a component depending on a live Actor must also depend on a Supervisor that supervises it.",
+      codes: [
+        { code: "ARCHITECTURE_VIOLATION_PORTAL_DEP", defaultSeverity: "error", summary: "Component depending on a Portal/Observer" },
+        { code: "ARCHITECTURE_VIOLATION_PORTAL_FORBIDDEN_DEP", defaultSeverity: "error", summary: "Portal/Observer reaching the data layer directly" },
+        { code: "ARCHITECTURE_VIOLATION_VIEW_DEP", defaultSeverity: "error", summary: "View depending on persistence layers or on logic that is not pure" },
+        { code: "ARCHITECTURE_VIOLATION_SUPERVISOR_DEP", defaultSeverity: "error", summary: "Supervisor depending on anything but Actors, Orchestrators, Adapters or other Supervisors \u2014 it reaches data only through workflows" },
+        { code: "ACTOR_REACHED_WITHOUT_SUPERVISOR", defaultSeverity: "error", summary: "Component depending on a live Actor it does not supervise, without also depending on a Supervisor that supervises it \u2014 a live Actor is reached by id through its Supervisor" }
+      ],
+      check(ctx) {
+        for (const edge of ctx.dependencyEdges().matrix) {
+          const comp = edge.from;
+          const depComp = edge.to;
+          const storeHint = depComp.componentType === "Store" ? storeResolutionHint(comp.componentType, depComp.id) : "";
+          if (depComp.componentType === "Portal" || depComp.componentType === "Observer") {
+            ctx.addIssue(
+              "error",
+              "ARCHITECTURE_VIOLATION_PORTAL_DEP",
+              `Architectural violation: Component "${comp.id}" cannot depend on ${depComp.componentType} component "${depComp.id}". ${depComp.componentType}s are top-level entry points/subscribers and cannot be dependencies.`,
+              comp.id,
+              edge.draftContext
+            );
+            continue;
+          }
+          if (comp.componentType === "Portal" || comp.componentType === "Observer") {
+            const forbiddenTypes = comp.componentType === "Portal" ? ["Store", "Registry", "Adapter", "Query"] : ["Store", "Registry", "Repository", "Index", "Query"];
+            if (forbiddenTypes.includes(depComp.componentType)) {
               ctx.addIssue(
                 "error",
-                "ARCHITECTURE_VIOLATION_VIEW_DEP",
-                `Architectural violation: View component "${comp.id}" cannot depend on ${stereotypeOf(depComp)} component "${depComp.id}". Views must remain passive UI blocks that use pure logic at most.` + storeHint,
+                "ARCHITECTURE_VIOLATION_PORTAL_FORBIDDEN_DEP",
+                `Architectural violation: ${comp.componentType} component "${comp.id}" cannot depend directly on "${depComp.componentType}" component "${depComp.id}". ${comp.componentType}s coordinate through Orchestrators (and Supervisors); they do not reach the data layer directly.` + storeHint,
                 comp.id,
-                edgeDraft
+                edge.draftContext
               );
             }
-            if (comp.componentType === "Supervisor" && ["Store", "Registry", "Repository", "Index", "Query", "View", "FeatureComponent", "RouterComponent"].includes(depComp.componentType)) {
+          }
+          if (comp.componentType === "View" && (["Store", "Registry", "Index", "Query", "Adapter", "Repository"].includes(depComp.componentType) || depComp.componentType === "Orchestrator" && !isPureLogic(depComp))) {
+            ctx.addIssue(
+              "error",
+              "ARCHITECTURE_VIOLATION_VIEW_DEP",
+              `Architectural violation: View component "${comp.id}" cannot depend on ${stereotypeOf(depComp)} component "${depComp.id}". Views must remain passive UI blocks that use pure logic at most.` + storeHint,
+              comp.id,
+              edge.draftContext
+            );
+          }
+          if (comp.componentType === "Supervisor" && ["Store", "Registry", "Repository", "Index", "Query", "View", "FeatureComponent", "RouterComponent"].includes(depComp.componentType)) {
+            ctx.addIssue(
+              "error",
+              "ARCHITECTURE_VIOLATION_SUPERVISOR_DEP",
+              `Architectural violation: Supervisor "${comp.id}" cannot depend on ${stereotypeOf(depComp)} "${depComp.id}". A Supervisor reaches data only through workflows \u2014 depend on the Orchestrator, Actor or Adapter that does that work instead.` + storeHint,
+              comp.id,
+              edge.draftContext
+            );
+          }
+          if (depComp.componentType === "Actor" && comp.componentType !== "Supervisor") {
+            const reachedThroughSupervisor = comp.dependsOn.some((id) => {
+              const supervisor = ctx.componentMap.get(id);
+              return supervisor?.componentType === "Supervisor" && supervisor.dependsOn.includes(depComp.id);
+            });
+            if (!reachedThroughSupervisor) {
+              const supervisors = ctx.components.filter((c) => c.componentType === "Supervisor" && c.dependsOn.includes(depComp.id)).map((c) => `"${c.id}"`);
+              const remedy = supervisors.length > 0 ? `also depend on ${supervisors.length === 1 ? "its Supervisor" : "one of its Supervisors"} (${supervisors.join(", ")})` : `no Supervisor depends on "${depComp.id}" yet, so give the Actor a Supervisor that depends on it and depend on that Supervisor`;
               ctx.addIssue(
                 "error",
-                "ARCHITECTURE_VIOLATION_SUPERVISOR_DEP",
-                `Architectural violation: Supervisor "${comp.id}" cannot depend on ${stereotypeOf(depComp)} "${depComp.id}". A Supervisor reaches data only through workflows \u2014 depend on the Orchestrator, Actor or Adapter that does that work instead.` + storeHint,
+                "ACTOR_REACHED_WITHOUT_SUPERVISOR",
+                `Architectural violation: ${stereotypeOf(comp)} "${comp.id}" depends on the live Actor "${depComp.id}" without a Supervisor that supervises it. A live Actor is reached by id through a Supervisor that supervises it \u2014 ${remedy}.`,
                 comp.id,
-                edgeDraft
+                edge.draftContext
               );
             }
-            if (depComp.componentType === "Actor" && comp.componentType !== "Supervisor") {
-              const reachedThroughSupervisor = comp.dependsOn.some((id) => {
-                const supervisor = ctx.componentMap.get(id);
-                return supervisor?.componentType === "Supervisor" && supervisor.dependsOn.includes(depComp.id);
-              });
-              if (!reachedThroughSupervisor) {
-                const supervisors = ctx.components.filter((c) => c.componentType === "Supervisor" && c.dependsOn.includes(depComp.id)).map((c) => `"${c.id}"`);
-                const remedy = supervisors.length > 0 ? `also depend on ${supervisors.length === 1 ? "its Supervisor" : "one of its Supervisors"} (${supervisors.join(", ")})` : `no Supervisor depends on "${depComp.id}" yet, so give the Actor a Supervisor that depends on it and depend on that Supervisor`;
-                ctx.addIssue(
-                  "error",
-                  "ACTOR_REACHED_WITHOUT_SUPERVISOR",
-                  `Architectural violation: ${stereotypeOf(comp)} "${comp.id}" depends on the live Actor "${depComp.id}" without a Supervisor that supervises it. A live Actor is reached by id through a Supervisor that supervises it \u2014 ${remedy}.`,
-                  comp.id,
-                  edgeDraft
-                );
-              }
-            }
           }
         }
+      }
+    };
+  }
+});
+
+// src/core/rules/doctrine/portal-write-shortcut.ts
+var portalWriteShortcutRule;
+var init_portal_write_shortcut = __esm({
+  "src/core/rules/doctrine/portal-write-shortcut.ts"() {
+    "use strict";
+    portalWriteShortcutRule = {
+      name: "portal-write-shortcut",
+      description: "A Portal narrative call step or dispatch-table binding that reaches a write-effect method on a Repository or Index directly is the write shortcut: the Portal\u2192data-facade edge is licensed for reads only, and a write routes through an Orchestrator that owns the workflow. A dispatch step reaches its server only through a table binding, so judging every binding judges each dispatch step that takes it, once, where the route is declared. Methods that carry no effect tag are not judged.",
+      codes: [
+        { code: "PORTAL_WRITE_SHORTCUT", defaultSeverity: "error", summary: "Portal narrative call or dispatch-table binding reaches a write-effect method on a Repository/Index directly \u2014 reads may shortcut, writes route through an Orchestrator (judged on effect-tagged facade methods; untagged methods are not yet judged)" }
+      ],
+      check(ctx) {
         for (const impl of ctx.implementations) {
           const contract = ctx.interfaceMap.get(impl.contract);
           const component = contract ? ctx.componentMap.get(contract.component) : void 0;
@@ -10418,31 +10882,23 @@ var init_stereotype_dependencies = __esm({
   }
 });
 
-// src/core/rules/doctrine/pattern-ownership.ts
-var patternsRule;
-var init_pattern_ownership = __esm({
-  "src/core/rules/doctrine/pattern-ownership.ts"() {
+// src/core/rules/doctrine/pattern-membership.ts
+var patternMembershipRule;
+var init_pattern_membership = __esm({
+  "src/core/rules/doctrine/pattern-membership.ts"() {
     "use strict";
     init_models();
-    patternsRule = {
-      name: "pattern-ownership",
-      description: "Patterns (Repository/FeatureComponent/RouterComponent) own member blocks with the containment their definition prescribes; blocks own nothing; a member has exactly one owner; and private members are reachable only via their facade or siblings.",
+    patternMembershipRule = {
+      name: "pattern-membership",
+      description: "Only patterns (Repository/FeatureComponent/RouterComponent) own member blocks, and every pattern owns at least one. Each claim must name a component that exists and is itself a building block \u2014 patterns compose at the subsystem (L1) level, never by owning one another \u2014 and a block has exactly one owner, the first pattern to claim it.",
       codes: [
         { code: "EMPTY_PATTERN", defaultSeverity: "error", summary: "Pattern with no owned member blocks" },
         { code: "BLOCK_OWNS_MEMBERS", defaultSeverity: "error", summary: "Building block using owns" },
         { code: "INVALID_OWNED_MEMBER", defaultSeverity: "error", summary: "owns names a non-existent component" },
-        { code: "PATTERN_OWNS_PATTERN", defaultSeverity: "error", summary: "Pattern owning another pattern" },
-        { code: "SHARED_OWNED_MEMBER", defaultSeverity: "error", summary: "Block owned by two patterns" },
-        { code: "REPOSITORY_CONTAINMENT", defaultSeverity: "error", summary: "Repository owning a non Store/Registry/Index/Query/Adapter member" },
-        { code: "FEATURE_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "FeatureComponent not owning exactly one Orchestrator + one or more Views" },
-        { code: "ROUTER_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "RouterComponent not owning exactly one Portal facade, or owning no children to route to" },
-        { code: "VISIBILITY_VIOLATION", defaultSeverity: "error", summary: "Dependency on a block privately owned by another pattern" },
-        { code: "UNOWNED_STORE", defaultSeverity: "warning", summary: "Store not owned by any pattern \u2014 recommended shape is a Repository; a deliberate standalone Store needs a lint.allow" },
-        { code: "REGISTRY_WITHOUT_STORE", defaultSeverity: "warning", summary: "Standalone Registry with no Store to write to \u2014 either mistyped (a fused file-backed store belongs typed Store) or orphaned" },
-        { code: "UNOWNED_QUERY", defaultSeverity: "error", summary: "Query not owned by a Repository \u2014 a Query computes reads over its own Repository's Store" }
+        { code: "PATTERN_OWNS_PATTERN", defaultSeverity: "error", summary: "Pattern owning another pattern" },
+        { code: "SHARED_OWNED_MEMBER", defaultSeverity: "error", summary: "Block owned by two patterns" }
       ],
       check(ctx) {
-        const ownedBy = /* @__PURE__ */ new Map();
         for (const comp of ctx.components) {
           if (isRetired(comp)) continue;
           const isDraftCtx = ctx.isComponentDraft(comp.id);
@@ -10453,6 +10909,12 @@ var init_pattern_ownership = __esm({
           if (!pattern && comp.owns.length > 0) {
             ctx.addIssue("error", "BLOCK_OWNS_MEMBERS", `Building block "${comp.id}" (${comp.componentType}) cannot own members; only patterns (${Array.from(PATTERN_TYPES).join("/")}) use "owns".`, comp.id, isDraftCtx);
           }
+        }
+        const ownership = ctx.ownershipIndex();
+        for (const comp of ctx.components) {
+          if (isRetired(comp)) continue;
+          const isDraftCtx = ctx.isComponentDraft(comp.id);
+          const pattern = isPattern(comp);
           for (const memberId of comp.owns) {
             const member = ctx.componentMap.get(memberId);
             if (!member) {
@@ -10464,26 +10926,50 @@ var init_pattern_ownership = __esm({
               ctx.addIssue("error", "PATTERN_OWNS_PATTERN", `Pattern "${comp.id}" owns "${memberId}", which is itself a pattern. Patterns own only building blocks \u2014 compose patterns at the subsystem (L1) level.`, comp.id, isDraftCtx);
               continue;
             }
-            const firstOwner = ownedBy.get(memberId);
+            const firstOwner = ownership.ownerOf(memberId);
             if (firstOwner && firstOwner !== comp.id) {
               ctx.addIssue("error", "SHARED_OWNED_MEMBER", `Block "${memberId}" is owned by both "${firstOwner}" and "${comp.id}"; a block has exactly one owner.`, comp.id, isDraftCtx);
             }
-            if (!firstOwner) ownedBy.set(memberId, comp.id);
           }
-          if ((comp.componentType === "FeatureComponent" || comp.componentType === "RouterComponent") && comp.owns.some((memberId) => {
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/doctrine/pattern-containment.ts
+var REPOSITORY_MEMBERS, patternContainmentRule;
+var init_pattern_containment = __esm({
+  "src/core/rules/doctrine/pattern-containment.ts"() {
+    "use strict";
+    init_models();
+    REPOSITORY_MEMBERS = /* @__PURE__ */ new Set(["Store", "Registry", "Index", "Query", "Adapter"]);
+    patternContainmentRule = {
+      name: "pattern-containment",
+      description: "Holds each pattern to the containment its definition prescribes. A Repository may own only Store, Registry, Index, Query and (optionally) Adapter, judged member by member. A FeatureComponent owns exactly one Orchestrator (the logic side) and one or more Views (its faces \u2014 list, detail, form \u2014 sharing the one logic component), and nothing else. A RouterComponent owns exactly one Portal as its facade and at least one other child to route to. A counting pattern that still owns a retired member is not judged until that member is migrated: its counts change with the migration, and STEREOTYPE_RETIRED is the one finding.",
+      codes: [
+        { code: "REPOSITORY_CONTAINMENT", defaultSeverity: "error", summary: "Repository owning a non Store/Registry/Index/Query/Adapter member" },
+        { code: "FEATURE_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "FeatureComponent not owning exactly one Orchestrator + one or more Views" },
+        { code: "ROUTER_COMPONENT_CONTAINMENT", defaultSeverity: "error", summary: "RouterComponent not owning exactly one Portal facade, or owning no children to route to" }
+      ],
+      check(ctx) {
+        for (const comp of ctx.components) {
+          if (comp.componentType !== "Repository" || isRetired(comp)) continue;
+          const isDraftCtx = ctx.isComponentDraft(comp.id);
+          for (const memberId of comp.owns) {
             const member = ctx.componentMap.get(memberId);
-            return member !== void 0 && isRetired(member);
-          })) {
-            continue;
-          }
-          if (comp.componentType === "Repository") {
-            const allowed = /* @__PURE__ */ new Set(["Store", "Registry", "Index", "Query", "Adapter"]);
-            for (const memberId of comp.owns) {
-              const member = ctx.componentMap.get(memberId);
-              if (!member || isRetired(member) || allowed.has(member.componentType)) continue;
-              ctx.addIssue("error", "REPOSITORY_CONTAINMENT", `Repository "${comp.id}" owns "${memberId}" of type ${member.componentType}; a Repository may own only Store, Registry, Index, Query, and (optionally) Adapter.`, comp.id, isDraftCtx);
-            }
+            if (!member || isRetired(member) || REPOSITORY_MEMBERS.has(member.componentType)) continue;
+            ctx.addIssue("error", "REPOSITORY_CONTAINMENT", `Repository "${comp.id}" owns "${memberId}" of type ${member.componentType}; a Repository may own only Store, Registry, Index, Query, and (optionally) Adapter.`, comp.id, isDraftCtx);
           }
+        }
+        for (const comp of ctx.components) {
+          if (comp.componentType !== "FeatureComponent" && comp.componentType !== "RouterComponent") continue;
+          if (isRetired(comp)) continue;
+          if (comp.owns.some((memberId) => {
+            const member = ctx.componentMap.get(memberId);
+            return member !== void 0 && isRetired(member);
+          })) continue;
+          const isDraftCtx = ctx.isComponentDraft(comp.id);
           if (comp.componentType === "FeatureComponent") {
             let orchestrators = 0;
             let views = 0;
@@ -10514,45 +11000,83 @@ var init_pattern_ownership = __esm({
             }
           }
         }
+      }
+    };
+  }
+});
+
+// src/core/rules/doctrine/unowned-blocks.ts
+var unownedBlocksRule;
+var init_unowned_blocks = __esm({
+  "src/core/rules/doctrine/unowned-blocks.ts"() {
+    "use strict";
+    unownedBlocksRule = {
+      name: "unowned-blocks",
+      description: `Judges the data blocks no pattern owns. A Store may stand alone deliberately \u2014 the sanctioned lightweight form for genuinely simple state, acknowledged with a lint.allow \u2014 while the recommended shape stays a Repository; what must never happen is folding the state into a consuming component, where no spec, diagram or conformance check can see it again. A Registry standing alone with no Store to write to is either mistyped (the "file-backed Registry" idiom, a fused persistent store that belongs typed Store) or orphaned. A Query has no standalone form at all: it computes reads over its own Repository's Store.`,
+      codes: [
+        { code: "UNOWNED_STORE", defaultSeverity: "warning", summary: "Store not owned by any pattern \u2014 recommended shape is a Repository; a deliberate standalone Store needs a lint.allow" },
+        { code: "REGISTRY_WITHOUT_STORE", defaultSeverity: "warning", summary: "Standalone Registry with no Store to write to \u2014 either mistyped (a fused file-backed store belongs typed Store) or orphaned" },
+        { code: "UNOWNED_QUERY", defaultSeverity: "error", summary: "Query not owned by a Repository \u2014 a Query computes reads over its own Repository's Store" }
+      ],
+      check(ctx) {
+        const ownership = ctx.ownershipIndex();
         for (const comp of ctx.components) {
-          if (comp.componentType !== "Store" || ownedBy.has(comp.id)) continue;
-          ctx.addIssue(
-            "warning",
-            "UNOWNED_STORE",
-            `Store "${comp.id}" is not owned by any pattern. The recommended shape for held state is a Repository (owns: ["${comp.id}", its Registry, its Index]) with consumers on the facade. For genuinely simple state a deliberately standalone Store is the sanctioned lightweight form \u2014 keep it visible as this Store, reachable from the workflow layer (Orchestrator/Supervisor/Actor), and acknowledge it with a lint.allow reason. Never take the third path of merging the state into a consuming component: state hidden inside a logic block disappears from the architecture permanently.`,
-            comp.id,
-            ctx.isComponentDraft(comp.id)
-          );
-        }
-        for (const comp of ctx.components) {
-          if (comp.componentType !== "Registry" || ownedBy.has(comp.id)) continue;
-          const hasStoreDep = comp.dependsOn.some((depId) => ctx.componentMap.get(depId)?.componentType === "Store");
-          if (hasStoreDep) continue;
-          ctx.addIssue(
-            "warning",
-            "REGISTRY_WITHOUT_STORE",
-            `Registry "${comp.id}" stands alone with no Store to write to. A Registry is the write path to a Store \u2014 if this component itself holds the persisted state (a file-backed record/config store), retype it as a Store with the honest durability (read-through for no-RAM-copy file I/O) so the durability machinery can see it; otherwise wire its Store, or lint.allow with a reason.`,
-            comp.id,
-            ctx.isComponentDraft(comp.id)
-          );
-        }
-        for (const comp of ctx.components) {
-          if (comp.componentType !== "Query" || ownedBy.has(comp.id)) continue;
-          ctx.addIssue(
-            "error",
-            "UNOWNED_QUERY",
-            `Query "${comp.id}" is not owned by any pattern. A Query computes reads over its own Repository's Store \u2014 make it a member of the Repository whose Store it reads (owns: ["${comp.id}", \u2026]).`,
-            comp.id,
-            ctx.isComponentDraft(comp.id)
-          );
+          if (ownership.ownedMembers.has(comp.id)) continue;
+          const isDraftCtx = ctx.isComponentDraft(comp.id);
+          if (comp.componentType === "Store") {
+            ctx.addIssue(
+              "warning",
+              "UNOWNED_STORE",
+              `Store "${comp.id}" is not owned by any pattern. The recommended shape for held state is a Repository (owns: ["${comp.id}", its Registry, its Index]) with consumers on the facade. For genuinely simple state a deliberately standalone Store is the sanctioned lightweight form \u2014 keep it visible as this Store, reachable from the workflow layer (Orchestrator/Supervisor/Actor), and acknowledge it with a lint.allow reason. Never take the third path of merging the state into a consuming component: state hidden inside a logic block disappears from the architecture permanently.`,
+              comp.id,
+              isDraftCtx
+            );
+          }
+          if (comp.componentType === "Registry" && !comp.dependsOn.some((depId) => ctx.componentMap.get(depId)?.componentType === "Store")) {
+            ctx.addIssue(
+              "warning",
+              "REGISTRY_WITHOUT_STORE",
+              `Registry "${comp.id}" stands alone with no Store to write to. A Registry is the write path to a Store \u2014 if this component itself holds the persisted state (a file-backed record/config store), retype it as a Store with the honest durability (read-through for no-RAM-copy file I/O) so the durability machinery can see it; otherwise wire its Store, or lint.allow with a reason.`,
+              comp.id,
+              isDraftCtx
+            );
+          }
+          if (comp.componentType === "Query") {
+            ctx.addIssue(
+              "error",
+              "UNOWNED_QUERY",
+              `Query "${comp.id}" is not owned by any pattern. A Query computes reads over its own Repository's Store \u2014 make it a member of the Repository whose Store it reads (owns: ["${comp.id}", \u2026]).`,
+              comp.id,
+              isDraftCtx
+            );
+          }
         }
+      }
+    };
+  }
+});
+
+// src/core/rules/doctrine/member-visibility.ts
+var memberVisibilityRule;
+var init_member_visibility = __esm({
+  "src/core/rules/doctrine/member-visibility.ts"() {
+    "use strict";
+    init_models();
+    memberVisibilityRule = {
+      name: "member-visibility",
+      description: "A component may depend on a block within its own group (it is the owning pattern, or a sibling member of the same pattern), on any pattern facade, or on a standalone block \u2014 never on a block privately owned by ANOTHER pattern, which must be reached through that pattern's facade. A retired depending component is skipped, as everywhere in this family.",
+      codes: [
+        { code: "VISIBILITY_VIOLATION", defaultSeverity: "error", summary: "Dependency on a block privately owned by another pattern" }
+      ],
+      check(ctx) {
+        const ownership = ctx.ownershipIndex();
         for (const comp of ctx.components) {
           if (isRetired(comp)) continue;
           for (const depId of comp.dependsOn) {
-            const owner = ownedBy.get(depId);
+            const owner = ownership.ownerOf(depId);
             if (!owner) continue;
             if (owner === comp.id) continue;
-            if (ownedBy.get(comp.id) === owner) continue;
+            if (ownership.ownerOf(comp.id) === owner) continue;
             ctx.addIssue("error", "VISIBILITY_VIOLATION", `Component "${comp.id}" depends on "${depId}", which is privately owned by pattern "${owner}". Depend on the facade "${owner}" instead.`, comp.id, ctx.isComponentDraft(comp.id) || ctx.isComponentDraft(depId));
           }
         }
@@ -10607,28 +11131,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 +11163,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 +11223,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 +11603,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 +11683,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 +12456,25 @@ 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 code = ctx.codeIndex();
         const degradedTsFiles = ctx.codeModel.files.filter(
           (f) => f.status === "analyzed" && (f.language === "typescript" || f.language === "javascript") && f.analysisGrade !== "exact"
         );
@@ -11925,8 +12492,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 +12522,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 = code.factsAt(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,25 +12553,45 @@ 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 code = ctx.codeIndex();
+        for (const impl of ctx.implementations) {
+          const contract = ctx.interfaceMap.get(impl.contract);
+          if (!contract) continue;
+          const component = ctx.componentMap.get(contract.component);
+          if (!component) continue;
+          if (ctx.isInChainedSubproject(component.subsystem)) continue;
+          const 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;
-            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 (!file) continue;
+            const facts = code.factsAt(file);
+            if (!facts || facts.status !== "analyzed") continue;
             const symbol = methodImpl?.symbol ?? method.name;
-            const inDeclared = lookup.declared.has(symbol);
-            const inAnchored = inDeclared || lookup.anchored.has(symbol);
+            const inDeclared = code.declarationsAt(file).has(symbol);
+            const inAnchored = inDeclared || code.anchorsAt(file).has(symbol);
             const realized = tier === "declared" ? inDeclared : inAnchored;
             if (realized) continue;
             const label = methodImpl?.symbol ? `"${method.name}" (symbol "${symbol}")` : `"${method.name}"`;
@@ -12013,22 +12599,55 @@ var init_structural_conformance = __esm({
             ctx.addIssue(
               "warning",
               "UNREALIZED_METHOD",
-              `Method ${label} of contract "${impl.contract}" is not realized in "${file}" at the "${tier}" tier (analysis grade: ${lookup.facts.analysisGrade}).${weakHint}`,
+              `Method ${label} of contract "${impl.contract}" is not realized in "${file}" at the "${tier}" tier (analysis grade: ${facts.analysisGrade}).${weakHint}`,
               impl.id,
               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 code = ctx.codeIndex();
+        for (const impl of ctx.implementations) {
+          const contract = ctx.interfaceMap.get(impl.contract);
+          if (!contract) continue;
+          const component = ctx.componentMap.get(contract.component);
+          if (!component) continue;
+          if (ctx.isInChainedSubproject(component.subsystem)) continue;
+          const 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 facts = code.factsAt(file);
+            if (!facts || facts.status !== "analyzed") continue;
+            const findingAnchors = code.findingAnchorsAt(file);
             for (const finding of method.findings) {
-              if (lookup.findingAnchors.has(finding.code)) continue;
+              if (findingAnchors.has(finding.code)) continue;
               ctx.addIssue(
                 "warning",
                 "UNREALIZED_FINDING",
-                `Method "${method.name}" of contract "${impl.contract}" declares finding "${finding.code}", but "${file}" has no string literal or property-access name "${finding.code}" (analysis grade: ${lookup.facts.analysisGrade}) \u2014 report the finding under its declared code, or remove the declaration.`,
+                `Method "${method.name}" of contract "${impl.contract}" declares finding "${finding.code}", but "${file}" has no string literal or property-access name "${finding.code}" (analysis grade: ${facts.analysisGrade}) \u2014 report the finding under its declared code, or remove the declaration.`,
                 impl.id,
                 draft
               );
@@ -12072,8 +12691,7 @@ var init_call_conformance = __esm({
         { code: "CALL_STEP_UNREALIZED", defaultSeverity: "warning", summary: "Narrative call step whose target method name (or symbol) never appears among the realized function's callees in the method's source file (exact grade, set membership)" }
       ],
       check(ctx) {
-        const factsByPath = /* @__PURE__ */ new Map();
-        for (const f of ctx.codeModel.files) factsByPath.set(pathKey(f.path), f);
+        const code = ctx.codeIndex();
         for (const impl of ctx.implementations) {
           const contract = ctx.interfaceMap.get(impl.contract);
           if (!contract) continue;
@@ -12088,7 +12706,7 @@ var init_call_conformance = __esm({
             if (!implMethod.narrative.length) continue;
             const file = methodSourceFile(implMethod, impl.sourcePath);
             if (!file) continue;
-            const facts = factsByPath.get(pathKey(file));
+            const facts = code.factsAt(file);
             if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
             const fnSymbol = implMethod.symbol ?? implMethod.name;
             const callees = closedCallees(facts, fnSymbol);
@@ -12142,6 +12760,7 @@ var init_hidden_state = __esm({
         { code: "HIDDEN_STATE", defaultSeverity: "warning", summary: "Module-scope mutable binding in a file mapped only to stateless logic (Orchestrators) \u2014 held state hiding outside a Store, Supervisor or Actor" }
       ],
       check(ctx) {
+        const code = ctx.codeIndex();
         const byPath = /* @__PURE__ */ new Map();
         for (const impl of ctx.implementations) {
           const contract = ctx.interfaceMap.get(impl.contract);
@@ -12163,11 +12782,11 @@ var init_hidden_state = __esm({
             byPath.set(key, list);
           }
         }
-        for (const facts of ctx.codeModel.files) {
-          if (facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
+        for (const path27 of code.exactPaths) {
+          const facts = code.factsAt(path27);
           const bindings = facts.topLevelMutableBindings ?? [];
           if (bindings.length === 0) continue;
-          const mapped = byPath.get(pathKey(facts.path)) ?? [];
+          const mapped = byPath.get(path27) ?? [];
           if (mapped.length === 0) continue;
           if (!mapped.every((m) => isStatelessLogic(m.component))) continue;
           const anchor = [...mapped].sort((a, b) => a.impl.id.localeCompare(b.impl.id))[0];
@@ -12199,54 +12818,21 @@ var init_dependency_conformance = __esm({
         { code: "UNREALIZED_DEPENDENCY", defaultSeverity: "warning", summary: "A declared dependsOn/owns edge between components in different files is realized by no import between any of their files" }
       ],
       check(ctx) {
-        const factsByPath = new Map(ctx.codeModel.files.map((f) => [pathKey(f.path), f]));
-        const nodes = /* @__PURE__ */ new Map();
-        const filesByComponent = /* @__PURE__ */ new Map();
-        const implsByComponent = /* @__PURE__ */ new Map();
-        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;
-          let mapped = false;
-          for (const file of implementationSourceFiles(impl)) {
-            const p = pathKey(file);
-            const facts = factsByPath.get(p);
-            if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
-            let node = nodes.get(p);
-            if (!node) {
-              node = { path: p, components: [], anchorImplId: impl.id, imports: facts.imports, reexports: facts.reexports, draft: false };
-              nodes.set(p, node);
-            }
-            if (!node.components.some((c) => c.id === component.id)) node.components.push(component);
-            node.draft = node.draft || ctx.isImplementationDraft(impl);
-            if (!filesByComponent.has(component.id)) filesByComponent.set(component.id, /* @__PURE__ */ new Set());
-            filesByComponent.get(component.id).add(p);
-            mapped = true;
-          }
-          if (mapped) {
-            if (!implsByComponent.has(component.id)) implsByComponent.set(component.id, []);
-            implsByComponent.get(component.id).push(impl);
-          }
-        }
-        const mappedPaths = new Set(nodes.keys());
-        const edges = /* @__PURE__ */ new Map();
-        const realizationEdges = /* @__PURE__ */ new Map();
-        for (const node of nodes.values()) {
-          const targets = /* @__PURE__ */ new Set();
-          for (const spec of node.imports) {
-            const resolved = resolveImport(node.path, spec, mappedPaths);
-            if (resolved && resolved !== node.path) targets.add(resolved);
-          }
-          edges.set(node.path, targets);
-          const realized = new Set(targets);
-          for (const spec of node.reexports) {
-            const resolved = resolveImport(node.path, spec, mappedPaths);
-            if (resolved && resolved !== node.path) realized.add(resolved);
-          }
-          realizationEdges.set(node.path, realized);
-        }
+        const code = ctx.codeIndex();
+        const realization = ctx.realizationIndex();
+        const isExact = (p) => code.exactPaths.has(p);
+        const mappedPaths = new Set(realization.paths.filter(isExact));
+        const graph = ctx.importGraph(mappedPaths);
+        const exactFiles = /* @__PURE__ */ new Map();
+        const filesOf = (compId) => {
+          let files = exactFiles.get(compId);
+          if (!files) {
+            files = realization.filesOf(compId).filter(isExact);
+            exactFiles.set(compId, files);
+          }
+          return files;
+        };
+        const mappedImplsOf = (compId) => realization.implementationsOf(compId).filter((impl) => implementationSourceFiles(impl).some((f) => isExact(pathKey(f))));
         const dependsOrOwns = (from, toId) => from.dependsOn.includes(toId) || (from.owns ?? []).includes(toId);
         const ownerOf = /* @__PURE__ */ new Map();
         for (const c of ctx.components) {
@@ -12257,9 +12843,9 @@ var init_dependency_conformance = __esm({
           if (!published || published.size === 0) return false;
           return from.dependsOn.some((d) => published.has(d));
         };
-        const edgeJustified = (fromNode, toNode) => {
-          for (const cf of fromNode.components) {
-            for (const cg of toNode.components) {
+        const edgeJustified = (from, to) => {
+          for (const cf of from) {
+            for (const cg of to) {
               if (cf.id === cg.id) return true;
               if (dependsOrOwns(cf, cg.id)) return true;
               if (cf.subsystem === cg.subsystem && dependsOrOwns(cg, cf.id) && (cg.componentType === "Portal" || cg.componentType === "Observer")) return true;
@@ -12273,60 +12859,35 @@ var init_dependency_conformance = __esm({
           }
           return false;
         };
-        for (const [fromPath, targets] of edges) {
-          const fromNode = nodes.get(fromPath);
-          for (const toPath of targets) {
-            const toNode = nodes.get(toPath);
-            if (edgeJustified(fromNode, toNode)) continue;
+        const draftAt = (path27) => realization.implementationsAt(path27).some((impl) => ctx.isImplementationDraft(impl));
+        for (const fromPath of mappedPaths) {
+          const fromComponents = realization.componentsAt(fromPath);
+          for (const toPath of graph.importsOf(fromPath)) {
+            const toComponents = realization.componentsAt(toPath);
+            if (edgeJustified(fromComponents, toComponents)) continue;
             ctx.addIssue(
               "warning",
               "UNDECLARED_DEPENDENCY",
-              `"${fromPath}" (realizing ${fromNode.components.map((c) => c.id).join(", ")}) imports "${toPath}" (realizing ${toNode.components.map((c) => c.id).join(", ")}) but no declared dependsOn/owns edge justifies it \u2014 declare the collaboration on the component that actually uses it, or route the cross-subsystem hop through the target's published surface.`,
-              fromNode.anchorImplId,
-              fromNode.draft || toNode.draft
+              `"${fromPath}" (realizing ${fromComponents.map((c) => c.id).join(", ")}) imports "${toPath}" (realizing ${toComponents.map((c) => c.id).join(", ")}) but no declared dependsOn/owns edge justifies it \u2014 declare the collaboration on the component that actually uses it, or route the cross-subsystem hop through the target's published surface.`,
+              realization.implementationsAt(fromPath)[0]?.id,
+              draftAt(fromPath) || draftAt(toPath)
             );
           }
         }
-        const hasImportBetween = (fromFiles, toFiles, allowReverse) => {
-          for (const f of fromFiles) {
-            const targets = realizationEdges.get(f);
-            if (!targets) continue;
-            for (const t of toFiles) if (targets.has(t)) return true;
-          }
-          if (allowReverse) {
-            for (const t of toFiles) {
-              const reverse = realizationEdges.get(t);
-              if (!reverse) continue;
-              for (const f of fromFiles) if (reverse.has(f)) return true;
-            }
-          }
-          return false;
-        };
         for (const component of ctx.components) {
-          const fromFiles = filesByComponent.get(component.id);
-          if (!fromFiles) continue;
+          const fromFiles = filesOf(component.id);
+          if (fromFiles.length === 0) continue;
           const isMountingDeclarer = component.componentType === "Portal" || component.componentType === "Observer";
           const declaredTargets = [.../* @__PURE__ */ new Set([...component.dependsOn, ...component.owns ?? []])];
           for (const targetId of declaredTargets) {
             const target = ctx.componentMap.get(targetId);
             if (!target) continue;
-            if (component.subsystem !== target.subsystem) {
-              const subsystemFiles = /* @__PURE__ */ new Set();
-              for (const node of nodes.values()) {
-                if (node.components.some((c) => c.subsystem === target.subsystem)) subsystemFiles.add(node.path);
-              }
-              if (subsystemFiles.size === 0) continue;
-              for (const f of fromFiles) subsystemFiles.delete(f);
-              if (subsystemFiles.size === 0) continue;
-              if (hasImportBetween(fromFiles, subsystemFiles, isMountingDeclarer)) continue;
-            } else {
-              const toFiles = filesByComponent.get(targetId);
-              if (!toFiles) continue;
-              if ([...fromFiles].some((f) => toFiles.has(f))) continue;
-              if (hasImportBetween(fromFiles, toFiles, isMountingDeclarer)) continue;
-            }
-            const impls = implsByComponent.get(component.id) ?? [];
-            const anchor = impls[0];
+            const crossSubsystem = component.subsystem !== target.subsystem;
+            const toFiles = crossSubsystem ? realization.filesIn(target.subsystem).filter((p) => isExact(p) && !fromFiles.includes(p)) : filesOf(targetId);
+            if (toFiles.length === 0) continue;
+            if (fromFiles.some((f) => toFiles.includes(f))) continue;
+            if (graph.connects(fromFiles, toFiles, isMountingDeclarer)) continue;
+            const impls = mappedImplsOf(component.id);
             const declaredDependsOn = component.dependsOn.includes(targetId);
             const declaredOwns = (component.owns ?? []).includes(targetId);
             const relation = declaredDependsOn && declaredOwns ? "dependsOn and owns" : declaredDependsOn ? "dependsOn" : "owns";
@@ -12334,8 +12895,8 @@ var init_dependency_conformance = __esm({
             ctx.addIssue(
               "warning",
               "UNREALIZED_DEPENDENCY",
-              `Component "${component.id}" declares ${relation} "${targetId}", but no runtime import connects their source files (${[...fromFiles].join(", ")} \u219B ${target.subsystem !== component.subsystem ? `subsystem ${target.subsystem}` : [...filesByComponent.get(targetId) ?? []].join(", ")}) \u2014 either the collaboration is wired indirectly (DI) or the declared edge is stale.`,
-              anchor?.id ?? component.id,
+              `Component "${component.id}" declares ${relation} "${targetId}", but no runtime import connects their source files (${fromFiles.join(", ")} \u219B ${crossSubsystem ? `subsystem ${target.subsystem}` : filesOf(targetId).join(", ")}) \u2014 either the collaboration is wired indirectly (DI) or the declared edge is stale.`,
+              impls[0]?.id ?? component.id,
               draft
             );
           }
@@ -12361,50 +12922,24 @@ var init_integration_conformance = __esm({
         { code: "SIM_PATH_UNCOVERED", defaultSeverity: "warning", summary: "A narrative path has no sim:<component>.<method>[:<label>] anchor in the component's coverage-opted harness" }
       ],
       check(ctx) {
-        const factsByPath = new Map(ctx.codeModel.files.map((f) => [pathKey(f.path), f]));
-        const allPaths = new Set(factsByPath.keys());
-        const filesByComponent = /* @__PURE__ */ new Map();
-        const filesBySubsystem = /* @__PURE__ */ new Map();
-        const implsByComponent = /* @__PURE__ */ new Map();
-        const adopted = /* @__PURE__ */ new Set();
+        const code = ctx.codeIndex();
+        const realization = ctx.realizationIndex();
+        const graph = ctx.importGraph();
         const exists = (p) => {
-          const status = factsByPath.get(p)?.status;
+          const status = code.factsAt(p)?.status;
           return status === "analyzed" || status === "unreadable";
         };
+        const modulesOf = (compId) => realization.filesOf(compId).filter(exists);
+        const modulesIn = (subsystemId) => realization.filesIn(subsystemId).filter(exists);
+        const adopted = /* @__PURE__ */ new Set();
         for (const impl of ctx.implementations) {
+          if (!impl.simPath) continue;
           const contract = ctx.interfaceMap.get(impl.contract);
           const comp = contract ? ctx.componentMap.get(contract.component) : void 0;
           if (!comp || ctx.isInChainedSubproject(comp.subsystem)) continue;
-          if (!implsByComponent.has(comp.id)) implsByComponent.set(comp.id, []);
-          implsByComponent.get(comp.id).push(impl);
-          for (const file of implementationSourceFiles(impl)) {
-            const p = pathKey(file);
-            if (!exists(p)) continue;
-            if (!filesByComponent.has(comp.id)) filesByComponent.set(comp.id, /* @__PURE__ */ new Set());
-            filesByComponent.get(comp.id).add(p);
-            if (!filesBySubsystem.has(comp.subsystem)) filesBySubsystem.set(comp.subsystem, /* @__PURE__ */ new Set());
-            filesBySubsystem.get(comp.subsystem).add(p);
-          }
-          if (impl.simPath) adopted.add(comp.subsystem);
-        }
-        const isTechBoundary = (compId) => (implsByComponent.get(compId) ?? []).some((i) => (i.technologies ?? []).length > 0);
-        const reachFrom = (start) => {
-          const seen = /* @__PURE__ */ new Set([start]);
-          const stack = [start];
-          while (stack.length) {
-            const from = stack.pop();
-            const facts = factsByPath.get(from);
-            if (!facts || facts.status !== "analyzed") continue;
-            for (const spec of [...facts.imports, ...facts.reexports]) {
-              const to = resolveImport(from, spec, allPaths);
-              if (to && !seen.has(to)) {
-                seen.add(to);
-                stack.push(to);
-              }
-            }
-          }
-          return seen;
-        };
+          adopted.add(comp.subsystem);
+        }
+        const isTechBoundary = (compId) => realization.implementationsOf(compId).some((i) => (i.technologies ?? []).length > 0);
         for (const impl of ctx.implementations) {
           const contract = ctx.interfaceMap.get(impl.contract);
           const comp = contract ? ctx.componentMap.get(contract.component) : void 0;
@@ -12424,7 +12959,7 @@ var init_integration_conformance = __esm({
             continue;
           }
           const simPath = pathKey(impl.simPath);
-          const facts = factsByPath.get(simPath);
+          const facts = code.factsAt(simPath);
           const isDraftCtx = ctx.isImplementationDraft(impl);
           if (!facts || facts.status === "missing" || facts.status === "escaped" || facts.status === "unreadable") {
             const why = !facts || facts.status === "missing" ? "resolves to no file" : facts.status === "escaped" ? "escapes the project root \u2014 sims are project-relative, committed files" : "is not readable as source text";
@@ -12438,19 +12973,19 @@ var init_integration_conformance = __esm({
             continue;
           }
           if (facts.analysisGrade !== "exact") continue;
-          const reach = reachFrom(simPath);
-          const ownFiles = filesByComponent.get(comp.id) ?? /* @__PURE__ */ new Set();
+          const reach = graph.reachFrom(simPath);
+          const ownFiles = modulesOf(comp.id);
           const missing = [];
-          if (ownFiles.size > 0 && ![...ownFiles].some((f) => reach.has(f))) {
-            missing.push(`the component's own module (${[...ownFiles].join(" | ")})`);
+          if (ownFiles.length > 0 && !ownFiles.some((f) => reach.has(f))) {
+            missing.push(`the component's own module (${ownFiles.join(" | ")})`);
           }
           for (const dep of deps) {
             if (isTechBoundary(dep)) continue;
             const depComp = ctx.componentMap.get(dep);
-            const depFiles = depComp.subsystem !== comp.subsystem ? filesBySubsystem.get(depComp.subsystem) : filesByComponent.get(dep);
-            if (!depFiles || depFiles.size === 0) continue;
-            if (![...depFiles].some((f) => reach.has(f))) {
-              const label = depComp.subsystem !== comp.subsystem ? `"${dep}" (any module of subsystem "${depComp.subsystem}")` : `"${dep}" (${[...depFiles].join(" | ")})`;
+            const depFiles = depComp.subsystem !== comp.subsystem ? modulesIn(depComp.subsystem) : modulesOf(dep);
+            if (depFiles.length === 0) continue;
+            if (!depFiles.some((f) => reach.has(f))) {
+              const label = depComp.subsystem !== comp.subsystem ? `"${dep}" (any module of subsystem "${depComp.subsystem}")` : `"${dep}" (${depFiles.join(" | ")})`;
               missing.push(label);
             }
           }
@@ -13604,12 +14139,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();
@@ -13618,17 +14160,27 @@ var init_repository = __esm({
     init_retired_stereotypes();
     init_portal_endpoints();
     init_portal_call_auth();
-    init_stereotype_dependencies();
-    init_pattern_ownership();
+    init_subsystem_boundary_dependencies();
+    init_logic_dependency_class();
+    init_data_block_dependencies();
+    init_entrypoint_dependencies();
+    init_portal_write_shortcut();
+    init_pattern_membership();
+    init_pattern_containment();
+    init_unowned_blocks();
+    init_member_visibility();
     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 +14188,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 +14209,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,
@@ -13673,11 +14245,32 @@ var init_repository = __esm({
       // Cross-call auth: a narrative call into an authed Portal must name its
       // credential source (rides with the portal family).
       portalCallAuthRule,
-      stereotypeDepsRule,
-      patternsRule,
+      // Dependencies in five questions, one owner each: where an edge is
+      // allowed to LAND (the boundary, and what an unresolved id means), then
+      // the intra-subsystem matrix by the layer that answers for it — an
+      // Orchestrator's declared class, the data blocks, the entry points and
+      // the process layer — and finally the Portal read-face guard, the one
+      // that reads narratives and dispatch tables rather than dependsOn.
+      subsystemBoundaryDepsRule,
+      logicDependencyClassRule,
+      dataBlockDepsRule,
+      entrypointDepsRule,
+      portalWriteShortcutRule,
+      // Patterns in four questions: who may own and what a claim must name,
+      // what each pattern must contain, which data blocks are left standing
+      // alone, and who may see a private member.
+      patternMembershipRule,
+      patternContainmentRule,
+      unownedBlocksRule,
+      memberVisibilityRule,
       // 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 +14281,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 +14301,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,
@@ -14434,11 +15033,15 @@ function buildRuleContext(opts) {
     }
     return { kind: "unresolved" };
   };
+  const contractMethods = /* @__PURE__ */ new Map();
   const interfaceMethodsOf = (compId) => {
+    const cached = contractMethods.get(compId);
+    if (cached) return cached;
     const out = [];
     for (const intf of interfacesByComponent.get(compId) ?? []) {
       out.push(...intf.methods);
     }
+    contractMethods.set(compId, out);
     return out;
   };
   const profileDefFor = (subsystemId) => {
@@ -14534,7 +15137,26 @@ function buildRuleContext(opts) {
       ...surfaceResolved ? { surfaceResolved: true } : {}
     });
   };
-  return {
+  let codeIndexMemo;
+  const codeIndex = () => codeIndexMemo ??= buildCodeIndex(ctx.codeModel);
+  let realizationMemo;
+  const realizationIndex = () => realizationMemo ??= buildRealizationIndex(ctx);
+  const importGraphs = /* @__PURE__ */ new Map();
+  const importGraph = (paths) => {
+    const universe = paths ?? codeIndex().paths;
+    const key = `${universe.size}\0${[...universe].join("\0")}`;
+    let graph = importGraphs.get(key);
+    if (!graph) {
+      graph = buildImportGraph(codeIndex(), universe);
+      importGraphs.set(key, graph);
+    }
+    return graph;
+  };
+  let ownershipMemo;
+  const ownershipIndex = () => ownershipMemo ??= buildOwnershipIndex(ctx);
+  let dependencyEdgesMemo;
+  const dependencyEdges = () => dependencyEdgesMemo ??= buildDependencyEdges(ctx);
+  const ctx = {
     system,
     subsystems,
     components,
@@ -14563,6 +15185,11 @@ function buildRuleContext(opts) {
     isCollapsedCrossTreeRef,
     resolveSurfaceRef,
     interfaceMethodsOf,
+    codeIndex,
+    realizationIndex,
+    importGraph,
+    ownershipIndex,
+    dependencyEdges,
     complexityConfigFor,
     documentationConfigFor,
     namingConfigFor,
@@ -14577,6 +15204,7 @@ function buildRuleContext(opts) {
     knownIssueCodes: opts.knownIssueCodes,
     addIssue
   };
+  return ctx;
 }
 var DEPTH_RANK, DEPTH_GATED_CODES, COMPLETENESS_RULES;
 var init_rules = __esm({
@@ -14585,6 +15213,7 @@ var init_rules = __esm({
     init_models();
     init_extensions();
     init_types();
+    init_read_model();
     init_repository();
     init_lint_allows();
     init_source_analysis();
@@ -24867,6 +25496,7 @@ __export(src_exports, {
   splitNamespace: () => splitNamespace,
   stateIdEquals: () => stateIdEquals,
   stateIdString: () => stateIdString,
+  stepConfigVerdict: () => stepConfigVerdict,
   stepGraph: () => stepGraph,
   syncContextFiles: () => syncContextFiles,
   toMarkdown: () => toMarkdown,
@@ -25586,6 +26216,7 @@ function loadProjectConfig4() {
   splitNamespace,
   stateIdEquals,
   stateIdString,
+  stepConfigVerdict,
   stepGraph,
   syncContextFiles,
   toMarkdown,