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

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.25";
+    WAIRON_VERSION = "5.1.1-dev.26";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -8748,6 +8748,209 @@ var init_types = __esm({
   }
 });
 
+// src/core/rules/read-model.ts
+function appendUnique(map, key, value, same) {
+  const list2 = map.get(key);
+  if (!list2) {
+    map.set(key, [value]);
+    return;
+  }
+  if (same ? list2.some((v) => same(v, value)) : list2.includes(value)) return;
+  list2.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 = (cache2, path70, make) => {
+    const cached = cache2.get(path70);
+    if (cached) return cached;
+    const f = facts.get(path70);
+    if (!f) return NO_NAMES;
+    const built = make(f);
+    cache2.set(path70, built);
+    return built;
+  };
+  return {
+    paths,
+    exactPaths,
+    factsAt: (path70) => facts.get(pathKey(path70)),
+    declarationsAt: (path70) => namesAt(declarations, pathKey(path70), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames])),
+    anchorsAt: (path70) => namesAt(anchors, pathKey(path70), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
+    findingAnchorsAt: (path70) => namesAt(findingAnchors, pathKey(path70), (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: (path70) => implsByPath.get(pathKey(path70)) ?? NONE_IMPL,
+    filesOf: (compId) => filesByComponent.get(compId) ?? NONE_PATH,
+    filesIn: (subsystemId) => filesBySubsystem.get(subsystemId) ?? NONE_PATH,
+    componentsAt: (path70) => componentsByPath.get(pathKey(path70)) ?? 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 = (path70) => {
+    const cached = imports.get(path70);
+    if (cached) return cached;
+    const facts = index.factsAt(path70);
+    const out = /* @__PURE__ */ new Set();
+    if (facts?.status === "analyzed") resolveAll(path70, facts.imports, out);
+    imports.set(path70, out);
+    return out;
+  };
+  const tracesOf = (path70) => {
+    const cached = traces.get(path70);
+    if (cached) return cached;
+    const facts = index.factsAt(path70);
+    const out = new Set(importsOf(path70));
+    if (facts?.status === "analyzed") resolveAll(path70, facts.reexports, out);
+    traces.set(path70, 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: (start2) => {
+      const seen = /* @__PURE__ */ new Set([start2]);
+      const stack = [start2];
+      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({
@@ -9956,8 +10159,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;
@@ -9983,7 +10185,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;
@@ -10129,7 +10331,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" }
       ],
@@ -10355,257 +10557,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;
@@ -10650,31 +10936,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: "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);
@@ -10685,6 +10963,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) {
@@ -10696,26 +10980,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;
@@ -10746,45 +11054,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));
           }
         }
@@ -12182,8 +12528,7 @@ var init_source_file_linkage = __esm({
         { 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 factsByPath = /* @__PURE__ */ new Map();
-        for (const facts of ctx.codeModel.files) factsByPath.set(pathKey(facts.path), facts);
+        const code = ctx.codeIndex();
         const degradedTsFiles = ctx.codeModel.files.filter(
           (f) => f.status === "analyzed" && (f.language === "typescript" || f.language === "javascript") && f.analysisGrade !== "exact"
         );
@@ -12231,7 +12576,7 @@ var init_source_file_linkage = __esm({
             const key = pathKey(file);
             if (reported.has(key)) continue;
             reported.add(key);
-            const facts = factsByPath.get(key);
+            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);
@@ -12281,14 +12626,7 @@ var init_method_realization = __esm({
         { code: "UNREALIZED_METHOD", defaultSeverity: "warning", summary: "An L3 contract method has no anchor in its own source file (the method's sourcePath, else the implementation's) at the required conformance tier" }
       ],
       check(ctx) {
-        const lookups = /* @__PURE__ */ new Map();
-        for (const facts of ctx.codeModel.files) {
-          lookups.set(pathKey(facts.path), {
-            declared: /* @__PURE__ */ new Set([...facts.declaredNames, ...facts.exportedNames]),
-            anchored: /* @__PURE__ */ new Set([...facts.declaredNames, ...facts.exportedNames, ...facts.anchoredNames]),
-            facts
-          });
-        }
+        const code = ctx.codeIndex();
         for (const impl of ctx.implementations) {
           const contract = ctx.interfaceMap.get(impl.contract);
           if (!contract) continue;
@@ -12303,11 +12641,11 @@ var init_method_realization = __esm({
             if (tier === "off") continue;
             const file = methodSourceFile(methodImpl ?? {}, impl.sourcePath);
             if (!file) continue;
-            const lookup = lookups.get(pathKey(file));
-            if (!lookup || lookup.facts.status !== "analyzed") continue;
+            const facts = code.factsAt(file);
+            if (!facts || facts.status !== "analyzed") continue;
             const symbol = methodImpl?.symbol ?? method2.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 ? `"${method2.name}" (symbol "${symbol}")` : `"${method2.name}"`;
@@ -12315,7 +12653,7 @@ var init_method_realization = __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
             );
@@ -12339,10 +12677,7 @@ var init_finding_realization = __esm({
         { code: "UNREALIZED_FINDING", defaultSeverity: "warning", summary: "A finding code a contract method declares appears in the method's source file neither as a string literal nor as a property-access name (below exact grade, any identifier counts)" }
       ],
       check(ctx) {
-        const lookups = /* @__PURE__ */ new Map();
-        for (const facts of ctx.codeModel.files) {
-          lookups.set(pathKey(facts.path), { findingAnchors: new Set(facts.anchoredNames), facts });
-        }
+        const code = ctx.codeIndex();
         for (const impl of ctx.implementations) {
           const contract = ctx.interfaceMap.get(impl.contract);
           if (!contract) continue;
@@ -12358,14 +12693,15 @@ var init_finding_realization = __esm({
             if (tier === "off") continue;
             const file = methodSourceFile(methodImpl ?? {}, impl.sourcePath);
             if (!file) continue;
-            const lookup = lookups.get(pathKey(file));
-            if (!lookup || lookup.facts.status !== "analyzed") continue;
+            const facts = code.factsAt(file);
+            if (!facts || facts.status !== "analyzed") continue;
+            const findingAnchors = code.findingAnchorsAt(file);
             for (const finding of method2.findings) {
-              if (lookup.findingAnchors.has(finding.code)) continue;
+              if (findingAnchors.has(finding.code)) continue;
               ctx.addIssue(
                 "warning",
                 "UNREALIZED_FINDING",
-                `Method "${method2.name}" of contract "${impl.contract}" declares finding "${finding.code}", but "${file}" has no string literal or property-access name "${finding.code}" (analysis grade: ${lookup.facts.analysisGrade}) \u2014 report the finding under its declared code, or remove the declaration.`,
+                `Method "${method2.name}" of contract "${impl.contract}" declares finding "${finding.code}", but "${file}" has no string literal or property-access name "${finding.code}" (analysis grade: ${facts.analysisGrade}) \u2014 report the finding under its declared code, or remove the declaration.`,
                 impl.id,
                 draft
               );
@@ -12409,8 +12745,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;
@@ -12425,7 +12760,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);
@@ -12479,6 +12814,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);
@@ -12500,11 +12836,11 @@ var init_hidden_state = __esm({
             byPath.set(key, list2);
           }
         }
-        for (const facts of ctx.codeModel.files) {
-          if (facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
+        for (const path70 of code.exactPaths) {
+          const facts = code.factsAt(path70);
           const bindings = facts.topLevelMutableBindings ?? [];
           if (bindings.length === 0) continue;
-          const mapped = byPath.get(pathKey(facts.path)) ?? [];
+          const mapped = byPath.get(path70) ?? [];
           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];
@@ -12536,54 +12872,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) {
@@ -12594,9 +12897,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;
@@ -12610,60 +12913,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 = (path70) => realization.implementationsAt(path70).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";
@@ -12671,8 +12949,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
             );
           }
@@ -12698,50 +12976,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 status2 = factsByPath.get(p)?.status;
+          const status2 = code.factsAt(p)?.status;
           return status2 === "analyzed" || status2 === "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 = (start2) => {
-          const seen = /* @__PURE__ */ new Set([start2]);
-          const stack = [start2];
-          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;
@@ -12761,7 +13013,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";
@@ -12775,19 +13027,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);
             }
           }
@@ -13962,8 +14214,15 @@ 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_profile_registration();
     init_profile_stereotype_fencing();
@@ -14040,8 +14299,24 @@ 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,
       // Profiles in three questions, three owners: is the name real (the
@@ -14808,11 +15083,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) => {
@@ -14908,7 +15187,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,
@@ -14937,6 +15235,11 @@ function buildRuleContext(opts) {
     isCollapsedCrossTreeRef,
     resolveSurfaceRef,
     interfaceMethodsOf,
+    codeIndex,
+    realizationIndex,
+    importGraph,
+    ownershipIndex,
+    dependencyEdges,
     complexityConfigFor,
     documentationConfigFor,
     namingConfigFor,
@@ -14951,6 +15254,7 @@ function buildRuleContext(opts) {
     knownIssueCodes: opts.knownIssueCodes,
     addIssue
   };
+  return ctx;
 }
 var DEPTH_RANK, DEPTH_GATED_CODES, COMPLETENESS_RULES;
 var init_rules = __esm({
@@ -14959,6 +15263,7 @@ var init_rules = __esm({
     init_models();
     init_extensions();
     init_types();
+    init_read_model();
     init_repository();
     init_lint_allows();
     init_source_analysis();