@wairon/cli 5.1.1-dev.38 → 5.1.1-dev.39

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.38";
+    WAIRON_VERSION = "5.1.1-dev.39";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -770,7 +770,7 @@ function activeTargetTypes(config) {
   const targets = config.targets;
   return targets.filter((t) => typeof t === "string" || t.enabled !== false).map((t) => typeof t === "string" ? t : t.type);
 }
-var import_zod4, BuiltinTargetConfigSchema, CustomTargetConfigSchema, TargetConfigSchema, NamingRuleConfigSchema, DocumentationRuleConfigSchema, ComplexityRuleConfigSchema, DesignDepthSchema, RulesConfigSchema, PathsConfigSchema, PackSelectionSchema, ProfileSelectionSubjectSchema, ProjectProfileSelectionSchema, ProjectConfigSchema;
+var import_zod4, BuiltinTargetConfigSchema, CustomTargetConfigSchema, TargetConfigSchema, NamingRuleConfigSchema, DocumentationRuleConfigSchema, ComplexityRuleConfigSchema, ConformanceRuleConfigSchema, DesignDepthSchema, RulesConfigSchema, PathsConfigSchema, PackSelectionSchema, ProfileSelectionSubjectSchema, ProjectProfileSelectionSchema, ProjectConfigSchema;
 var init_project = __esm({
   "src/models/project.ts"() {
     "use strict";
@@ -867,6 +867,30 @@ var init_project = __esm({
        */
       maxCognitiveLevel: import_zod4.z.string().optional()
     });
+    ConformanceRuleConfigSchema = import_zod4.z.object({
+      /**
+       * Project-relative paths holding this project's own source code; a
+       * directory is walked recursively, a file names itself. Absolute or
+       * parent-escaping entries are refused by containment, exactly as a
+       * sourcePath is.
+       */
+      sourceRoots: import_zod4.z.array(import_zod4.z.string()).optional(),
+      /**
+       * Paths inside a source root that are not this project's code to claim —
+       * vendored libraries, generated output, a chained subproject's own
+       * directory (the child claims its files in its own run). A file at, or
+       * under, one of these is never walked, so it is neither reported nor
+       * carried as debt.
+       */
+      exclude: import_zod4.z.array(import_zod4.z.string()).optional(),
+      /**
+       * The files under the source roots that no spec names yet, frozen. A listed
+       * file is not reported; an unlisted one is UNCLAIMED_SOURCE_FILE; an entry
+       * that is now claimed, proven a barrel, or no longer found is
+       * STALE_UNCLAIMED_ENTRY.
+       */
+      unclaimed: import_zod4.z.array(import_zod4.z.string()).optional()
+    });
     DesignDepthSchema = import_zod4.z.enum(["components", "interfaces", "implementations", "narratives"]);
     RulesConfigSchema = import_zod4.z.object({
       /**
@@ -917,6 +941,8 @@ var init_project = __esm({
       documentation: DocumentationRuleConfigSchema.optional(),
       /** Dynamic structural complexity caps (method limit, step limit, dependency limit) */
       complexity: ComplexityRuleConfigSchema.optional(),
+      /** Where this project's own source lives and what of it no spec claims yet (see ConformanceRuleConfigSchema) */
+      conformance: ConformanceRuleConfigSchema.optional(),
       /** Project-default design depth (see DesignDepthSchema); subsystems may override. */
       designDepth: DesignDepthSchema.optional()
     });
@@ -1228,6 +1254,15 @@ function implementationSourceFiles(impl) {
   for (const method2 of impl.methods ?? []) add(method2.sourcePath);
   return files;
 }
+function typeSourceFiles(type) {
+  const files = [];
+  const add = (file) => {
+    if (file && !files.includes(file)) files.push(file);
+  };
+  add(type.sourcePath);
+  for (const method2 of type.methods ?? []) add(method2.sourcePath);
+  return files;
+}
 var import_zod7, SpecIdSchema, SpecStatusSchema, BoundaryItemSchema, RequirementItemSchema, DatabaseSpecSchema, DiagramConfigSchema, SURFACE_AUDIENCES, SurfaceAudienceSchema, SystemPublicInterfaceSchema, SystemSpecSchema, PublicInterfaceTypeSchema, PublicInterfaceSchema, TrustedLinkSchema, LintAllowSchema, LintConfigSchema, ExtDataSchema, LifecycleEntrypointSchema, SubsystemSpecSchema, ComponentTypeSchema, PATTERN_TYPES, RETIRED_STEREOTYPES, PortalTypeSchema, DispatchBindingSchema, DurabilitySchema, DependencyClassSchema, PatternRefSchema, EventBindingSchema, ExternalLinkTypeSchema, ExternalLinkSchema, PortalAuthSchemeSchema, PortalAuthSchema, ComponentSpecSchema, BLOCK_NOUNS, HttpMethodSchema, TransportSchema, EndpointSchema, SEMANTIC_GUARANTEES, GuaranteeSchema, MethodParamSchema, FindingDeclarationSchema, MethodSignatureSchema, INTENT_FLOOR_MIN_CHARS, InterfaceSpecSchema, NarrativeStepTypeSchema, LoopKindSchema, SwitchCaseSchema, CatchClauseSchema, ParallelBranchSchema, NarrativeStepSchema, NarrativeDetailSchema, ConformanceTierSchema, MethodImplementationSchema, ImplementationSpecSchema, TypeKindSchema, TypeFieldSchema, TypeMethodSchema, InvariantSchema, TypeSpecSchema, SurfaceOriginSchema, SurfaceTypeDefSchema, SurfaceContractEntrySchema, SurfaceSnapshotSchema, NamedOpenApiSpecSchema, GroupSpecSchema;
 var init_specs = __esm({
   "src/models/specs.ts"() {
@@ -1854,7 +1889,22 @@ var init_specs = __esm({
       name: import_zod7.z.string(),
       signature: import_zod7.z.string(),
       returns: import_zod7.z.string(),
-      description: import_zod7.z.string().optional()
+      description: import_zod7.z.string().optional(),
+      /**
+       * Source file realizing this method when it is not the type's own
+       * sourcePath. A type's pure methods routinely live apart from its
+       * declaration: the declaration is a struct or an interface, the methods are
+       * free functions, and a language without methods-on-data has nowhere else
+       * to put them.
+       */
+      sourcePath: import_zod7.z.string().optional(),
+      /**
+       * The code-level name realizing this method, when it legitimately differs
+       * from the method name — e.g. `narrative_step.foreignFields` realized by
+       * `narrativeStepForeignFields`, the free-function form a pure type method
+       * takes in a language whose data carries no methods.
+       */
+      symbol: import_zod7.z.string().optional()
     });
     InvariantSchema = import_zod7.z.object({
       /** Stable invariant id, unique within the entity (referenced as "<type-id>.<invariant-id>"). */
@@ -1899,6 +1949,23 @@ var init_specs = __esm({
        * logical system entity type it maps to.
        */
       linkedEntity: import_zod7.z.string().optional(),
+      /**
+       * The source file holding this type's declaration, and the default for
+       * every method that names no sourcePath of its own. Relative to the root of
+       * the project that holds the spec.
+       *
+       * Naming one turns the type into a CLAIM on code, judged exactly as an
+       * implementation's sourcePath is: the file must resolve, and the
+       * declaration must be anchored in it (UNREALIZED_TYPE). A type that names
+       * none claims nothing and is never reported.
+       */
+      sourcePath: import_zod7.z.string().optional(),
+      /**
+       * The code-level name realizing this type's declaration, when it
+       * legitimately differs from `name` — a type named "Invoice Line" declared
+       * as `InvoiceLine`.
+       */
+      symbol: import_zod7.z.string().optional(),
       /** Per-spec lint suppressions (see LintConfigSchema). */
       lint: LintConfigSchema.optional(),
       /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
@@ -3692,11 +3759,11 @@ function buildCanvasModel(issues = []) {
     if (pi.component && pi.id) apiTagOf.set(pi.component, pi.id);
   }
   const patternTypes = /* @__PURE__ */ new Set(["Repository", "FeatureComponent", "RouterComponent"]);
-  const ownerOf = /* @__PURE__ */ new Map();
+  const ownerOf2 = /* @__PURE__ */ new Map();
   for (const comp of components) {
     if (!patternTypes.has(comp.componentType)) continue;
     for (const memberId of comp.owns) {
-      if (componentIds.has(memberId)) ownerOf.set(memberId, comp.id);
+      if (componentIds.has(memberId)) ownerOf2.set(memberId, comp.id);
     }
   }
   const modelComponents = components.map((comp) => {
@@ -3752,7 +3819,7 @@ function buildCanvasModel(issues = []) {
       ...comp.status ? { status: comp.status } : {},
       public: publicComponents.has(comp.id),
       ...apiTagOf.has(comp.id) ? { apiTag: apiTagOf.get(comp.id) } : {},
-      ...ownerOf.has(comp.id) ? { owner: ownerOf.get(comp.id) } : {},
+      ...ownerOf2.has(comp.id) ? { owner: ownerOf2.get(comp.id) } : {},
       owns: comp.owns.filter((o) => componentIds.has(o)),
       dependsOn: comp.dependsOn,
       ...comp.externalLinks && comp.externalLinks.length ? { externalLinks: comp.externalLinks } : {},
@@ -13342,9 +13409,9 @@ var init_dependency_conformance = __esm({
         };
         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();
+        const ownerOf2 = /* @__PURE__ */ new Map();
         for (const c of ctx.components) {
-          for (const member of c.owns ?? []) ownerOf.set(member, c);
+          for (const member of c.owns ?? []) ownerOf2.set(member, c);
         }
         const declaresSurfaceEdge = (from, subsystemId) => {
           const published = ctx.publicSet.get(subsystemId);
@@ -13357,9 +13424,9 @@ var init_dependency_conformance = __esm({
               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;
-              const ownerG = ownerOf.get(cg.id);
+              const ownerG = ownerOf2.get(cg.id);
               if (ownerG && (dependsOrOwns(cf, ownerG.id) || cf.id === ownerG.id)) return true;
-              const ownerF = ownerOf.get(cf.id);
+              const ownerF = ownerOf2.get(cf.id);
               if (ownerF && (dependsOrOwns(ownerF, cg.id) || ownerF.id === cg.id)) return true;
               if (ownerF && ownerG && ownerF.id === ownerG.id) return true;
               if (cf.subsystem !== cg.subsystem && declaresSurfaceEdge(cf, cg.subsystem)) return true;
@@ -13613,6 +13680,150 @@ var init_integration_sim_coverage = __esm({
   }
 });
 
+// src/core/rules/conformance/type-realization.ts
+function ownerOf(type, file) {
+  if (type.sourcePath && pathKey(type.sourcePath) === pathKey(file)) return `Type "${type.id}"`;
+  const users = (type.methods ?? []).filter((m) => m.sourcePath && pathKey(m.sourcePath) === pathKey(file)).map((m) => m.name);
+  if (users.length === 0) return `Type "${type.id}"`;
+  return `Type "${type.id}" method${users.length === 1 ? "" : "s"} ${users.map((n) => `"${n}"`).join(", ")}`;
+}
+var FILE_PROBLEMS, typeRealizationRule;
+var init_type_realization = __esm({
+  "src/core/rules/conformance/type-realization.ts"() {
+    "use strict";
+    init_models();
+    FILE_PROBLEMS = {
+      escaped: {
+        code: "SOURCE_PATH_ESCAPES_ROOT",
+        severity: "error",
+        detail: "is absolute or escapes the project root \u2014 sourcePaths must stay inside the project."
+      },
+      missing: {
+        code: "MISSING_SOURCE_FILE",
+        severity: "error",
+        detail: "does not resolve to a file \u2014 the spec names code that does not exist."
+      },
+      unreadable: {
+        code: "CONFORMANCE_ANALYSIS_SKIPPED",
+        severity: "warning",
+        detail: "could not be analyzed (binary or unreadable) \u2014 what it would have realized was not checked."
+      }
+    };
+    typeRealizationRule = {
+      name: "type-realization",
+      description: "Code\u2194spec Level 1 for the data model: a type that names a sourcePath is claiming code, so every file it names \u2014 its own and each method's \u2014 must resolve to a real, readable file inside the project root, its file must PUBLISH its declaration (an exported name at exact grade, the declaration tier below it, under its `symbol` when the code-level name differs from the type's name \u2014 and a pure re-export barrel publishes nothing of its own, so a claim on one is never realized), and each of its pure methods must appear in its own file (the method's sourcePath, else the type's) at the declaration tier, under the method's `symbol`, else the method's name. A type that names no sourcePath claims nothing and is never reported. Findings carry the analysis grade (exact AST | pattern table | generic scan) so weaker analysis is visible, a file that escapes the root, is missing or could not be analyzed is reported once and blocks only what it would have realized, and types under chained subsystems (projectPath) validate standalone in their own project run.",
+      codes: [
+        { code: "UNREALIZED_TYPE", defaultSeverity: "warning", summary: "A type names a sourcePath but its declaration is nowhere in that file \u2014 the claim points at code that does not hold it" },
+        { code: "UNREALIZED_TYPE_METHOD", defaultSeverity: "warning", summary: "A pure method of a claimed type is nowhere in its own source file (the method's sourcePath, else the type's)" },
+        { code: "MISSING_SOURCE_FILE", defaultSeverity: "error", summary: "A source file a type or one of its methods names does not resolve to a file on disk" },
+        { code: "SOURCE_PATH_ESCAPES_ROOT", defaultSeverity: "error", summary: "A source file a type or one of its methods names is absolute or escapes the project root (containment refusal)" },
+        { code: "CONFORMANCE_ANALYSIS_SKIPPED", defaultSeverity: "warning", summary: "A source file a type or one of its methods names could not be analyzed (binary/unreadable) \u2014 what it would have realized was not checked" }
+      ],
+      check(ctx) {
+        const code = ctx.codeIndex();
+        for (const type of ctx.types) {
+          if (!type.sourcePath) continue;
+          if (type.subsystem && ctx.isInChainedSubproject(type.subsystem)) continue;
+          const blocked = /* @__PURE__ */ new Set();
+          for (const file of typeSourceFiles(type)) {
+            const key = pathKey(file);
+            const facts = code.factsAt(key);
+            if (!facts || facts.status === "analyzed") continue;
+            blocked.add(key);
+            const problem = FILE_PROBLEMS[facts.status];
+            if (!problem) continue;
+            ctx.addIssue(problem.severity, problem.code, `${ownerOf(type, file)} sourcePath "${file}" ${problem.detail}`, type.id);
+          }
+          const typeKey = pathKey(type.sourcePath);
+          const typeFacts = code.factsAt(typeKey);
+          if (typeFacts && !blocked.has(typeKey)) {
+            const symbol = type.symbol ?? type.name;
+            const published = typeFacts.analysisGrade === "exact" ? new Set(typeFacts.reexportOnly ? [] : typeFacts.exportedNames) : code.declarationsAt(typeKey);
+            if (!published.has(symbol)) {
+              const label = type.symbol ? `"${type.name}" (symbol "${symbol}")` : `"${type.name}"`;
+              ctx.addIssue(
+                "warning",
+                "UNREALIZED_TYPE",
+                `Type ${label} is not published by "${type.sourcePath}" (analysis grade: ${typeFacts.analysisGrade})${typeFacts.reexportOnly ? ", which is a pure re-export barrel and declares nothing of its own" : ""} \u2014 name the file the declaration lives in, or bind the code-level name with \`symbol\`.`,
+                type.id
+              );
+            }
+          }
+          for (const method2 of type.methods ?? []) {
+            const file = method2.sourcePath ?? type.sourcePath;
+            const key = pathKey(file);
+            if (blocked.has(key)) continue;
+            const facts = code.factsAt(key);
+            if (!facts || facts.status !== "analyzed") continue;
+            const symbol = method2.symbol ?? method2.name;
+            if (code.declarationsAt(key).has(symbol)) continue;
+            const label = method2.symbol ? `"${method2.name}" (symbol "${symbol}")` : `"${method2.name}"`;
+            ctx.addIssue(
+              "warning",
+              "UNREALIZED_TYPE_METHOD",
+              `Method ${label} of type "${type.id}" is not declared in "${file}" (analysis grade: ${facts.analysisGrade}) \u2014 a pure type method is often a free function named after its type; bind that name with \`symbol\`, or name the file it lives in with the method's own \`sourcePath\`.`,
+              type.id
+            );
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/core/rules/conformance/unclaimed-source.ts
+var unclaimedSourceRule;
+var init_unclaimed_source = __esm({
+  "src/core/rules/conformance/unclaimed-source.ts"() {
+    "use strict";
+    init_models();
+    unclaimedSourceRule = {
+      name: "unclaimed-source",
+      description: "Code\u2194spec Level 1, asked the other way round: every source file under the project's declared source roots must be named by some spec \u2014 an implementation's sourcePath, a method's, a simPath, or a type's \u2014 or be carried in the frozen `rules.conformance.unclaimed` list. A pure re-export barrel declares nothing of its own and only republishes other modules, so it has no code to claim and is exempt (exact grade only: a weaker grade cannot tell a barrel from a file it failed to parse). Declaring no source roots leaves the check silent, which is what makes it opt-in; the unclaimed list is a one-way debt register, so an entry the walk no longer finds unclaimed must be deleted and the list can only shrink.",
+      codes: [
+        { code: "UNCLAIMED_SOURCE_FILE", defaultSeverity: "warning", summary: "A source file under a declared source root that no spec names and the frozen unclaimed list does not carry \u2014 code nobody designed" },
+        { code: "STALE_UNCLAIMED_ENTRY", defaultSeverity: "warning", summary: "An entry of the frozen unclaimed list names a file that is now claimed, or that the source-root walk no longer finds \u2014 delete it, the list only shrinks" }
+      ],
+      check(ctx) {
+        const walked = ctx.codeModel.rootFiles;
+        const listed = (ctx.rules?.conformance?.unclaimed ?? []).map(pathKey);
+        if (walked.length === 0) return;
+        const claimed = /* @__PURE__ */ new Set();
+        for (const impl of ctx.implementations) {
+          for (const file of implementationSourceFiles(impl)) claimed.add(pathKey(file));
+          if (impl.simPath) claimed.add(pathKey(impl.simPath));
+        }
+        for (const type of ctx.types) {
+          for (const file of typeSourceFiles(type)) claimed.add(pathKey(file));
+        }
+        const code = ctx.codeIndex();
+        const isBarrel = (file) => code.factsAt(file)?.reexportOnly === true;
+        const isLiveDebt = (file) => !claimed.has(file) && !isBarrel(file);
+        const listedSet = new Set(listed);
+        for (const file of walked) {
+          if (!isLiveDebt(file)) continue;
+          if (listedSet.has(file)) continue;
+          ctx.addIssue(
+            "warning",
+            "UNCLAIMED_SOURCE_FILE",
+            `Source file "${file}" is under a declared source root but no spec names it \u2014 give it to a spec as a sourcePath (an implementation's, a method's, or a type's), or carry it in \`rules.conformance.unclaimed\` until it is designed.`
+          );
+        }
+        const walkedSet = new Set(walked);
+        for (const entry of listed) {
+          if (walkedSet.has(entry) && isLiveDebt(entry)) continue;
+          const why = !walkedSet.has(entry) ? "the source-root walk no longer finds it (deleted, renamed, excluded, or outside the declared roots)" : isBarrel(entry) ? "it is a pure re-export barrel, which has nothing to claim" : "a spec now names it";
+          ctx.addIssue(
+            "warning",
+            "STALE_UNCLAIMED_ENTRY",
+            `"${entry}" is carried in \`rules.conformance.unclaimed\` but ${why} \u2014 delete the entry; the list only shrinks.`
+          );
+        }
+      }
+    };
+  }
+});
+
 // src/core/rules/heuristic/coupling-health.ts
 var DEFAULT_GOD_COMPONENT_THRESHOLD, couplingRule;
 var init_coupling_health = __esm({
@@ -13956,14 +14167,14 @@ var init_technology_boundaries = __esm({
         { code: "VENDOR_NAME_IN_CONTRACT", defaultSeverity: "warning", summary: "Technology name in L3 contract identifiers" }
       ],
       check(ctx) {
-        const ownerOf = /* @__PURE__ */ new Map();
-        for (const c of ctx.components) for (const m of c.owns) ownerOf.set(m, c.id);
+        const ownerOf2 = /* @__PURE__ */ new Map();
+        for (const c of ctx.components) for (const m of c.owns) ownerOf2.set(m, c.id);
         const ownershipRoot = (id) => {
           const seen = /* @__PURE__ */ new Set();
           let cur = id;
-          while (ownerOf.has(cur) && !seen.has(cur)) {
+          while (ownerOf2.has(cur) && !seen.has(cur)) {
             seen.add(cur);
-            cur = ownerOf.get(cur);
+            cur = ownerOf2.get(cur);
           }
           return cur;
         };
@@ -14856,6 +15067,8 @@ var init_repository = __esm({
     init_integration_sim_file();
     init_integration_sim_wiring();
     init_integration_sim_coverage();
+    init_type_realization();
+    init_unclaimed_source();
     init_coupling_health();
     init_signature_language_builtins();
     init_narrative_language_constructs();
@@ -15020,6 +15233,11 @@ var init_repository = __esm({
       integrationSimFileRule,
       integrationSimWiringRule,
       integrationSimCoverageRule,
+      // The data model's own claim on code, and the question no spec can ask
+      // from the spec side: which files are named by nothing at all. Last in
+      // the family because the second one reads what all the others named.
+      typeRealizationRule,
+      unclaimedSourceRule,
       couplingRule,
       // Target-language fit in two questions: what a CONTRACT may name, and what
       // a NARRATIVE may describe.
@@ -15052,7 +15270,7 @@ var init_repository = __esm({
 
 // src/core/source-analysis.ts
 function emptyCodeModel() {
-  return { files: [], projectRoot: "" };
+  return { files: [], projectRoot: "", rootFiles: [] };
 }
 function stripComments(text2, patterns) {
   let out = text2;
@@ -15292,7 +15510,8 @@ function walkExact(ts, sourceText, fileName) {
     ts.forEachChild(node, visit);
   };
   visit(sf);
-  return { declared, anchors, exported, imports, reexports, starExports, complexity, calls, mutableBindings };
+  const reexportOnly = sf.statements.length > 0 && sf.statements.every((st) => ts.isExportDeclaration(st) && !!st.moduleSpecifier);
+  return { declared, anchors, exported, imports, reexports, starExports, complexity, calls, mutableBindings, reexportOnly };
 }
 function resolveRelativeModule(fromFile, specifier) {
   if (!specifier.startsWith(".")) return null;
@@ -15350,15 +15569,65 @@ function looksBinary(buffer) {
   const probe2 = buffer.subarray(0, Math.min(buffer.length, 4096));
   return probe2.includes(0);
 }
-function buildCodeModel(implementations, projectRoot2) {
+function walkSourceRoots(sourceRoots, exclude, projectRoot2) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const excluded = exclude.map(pathKey);
+  const isExcluded = (key) => excluded.some((e) => key === e || key.startsWith(`${e}/`));
+  const record2 = (absolute) => {
+    const key = pathKey(path13.relative(projectRoot2, absolute));
+    if (seen.has(key) || isExcluded(key)) return;
+    if (!EXTENSION_LANGUAGE[path13.extname(key).toLowerCase()]) return;
+    seen.add(key);
+    found.push(key);
+  };
+  const descend = (dir) => {
+    let entries;
+    try {
+      entries = fs10.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries.slice().sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+      const child = path13.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+        if (isExcluded(pathKey(path13.relative(projectRoot2, child)))) continue;
+        descend(child);
+      } else if (entry.isFile()) {
+        record2(child);
+      }
+    }
+  };
+  for (const root of sourceRoots) {
+    const key = pathKey(root);
+    if (path13.isAbsolute(key) || path13.normalize(key).split(path13.sep)[0] === "..") continue;
+    const absolute = path13.resolve(projectRoot2, key);
+    if (path13.relative(projectRoot2, absolute).startsWith("..")) continue;
+    if (isExcluded(key)) continue;
+    let stat;
+    try {
+      stat = fs10.statSync(absolute);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) descend(absolute);
+    else if (stat.isFile()) record2(absolute);
+  }
+  return found;
+}
+function buildCodeModel(implementations, types, projectRoot2, sourceRoots = [], exclude = []) {
   const files = [];
   const seen = /* @__PURE__ */ new Set();
   const exactCache = /* @__PURE__ */ new Map();
+  const rootFiles = walkSourceRoots(sourceRoots, exclude, projectRoot2);
   const declaredPaths = [];
   for (const impl of implementations) {
     declaredPaths.push(...implementationSourceFiles(impl));
     if (impl.simPath) declaredPaths.push(impl.simPath);
   }
+  for (const type of types) declaredPaths.push(...typeSourceFiles(type));
+  declaredPaths.push(...rootFiles);
   for (const declared of declaredPaths) {
     const sourcePath = pathKey(declared);
     if (seen.has(sourcePath)) continue;
@@ -15407,7 +15676,8 @@ function buildCodeModel(implementations, projectRoot2) {
             reexports: [...facts.reexports],
             functionComplexity: Object.fromEntries(facts.complexity),
             functionCalls: Object.fromEntries([...facts.calls].map(([k, v]) => [k, [...v]])),
-            topLevelMutableBindings: [...facts.mutableBindings]
+            topLevelMutableBindings: [...facts.mutableBindings],
+            reexportOnly: facts.reexportOnly
           };
         } catch {
           analyzed = analyzeGeneric(text2);
@@ -15422,7 +15692,7 @@ function buildCodeModel(implementations, projectRoot2) {
     }
     files.push({ path: sourcePath, status: "analyzed", language, ...analyzed });
   }
-  return { files, projectRoot: projectRoot2 };
+  return { files, projectRoot: projectRoot2, rootFiles };
 }
 var fs10, path13, import_module2, EXTENSION_LANGUAGE, C_FAMILY_COMMENTS, JS_PATTERNS, LANGUAGE_PATTERNS, PATTERN_ANALYSIS_MAX_BYTES, IDENTIFIER_RE, STRING_RE, tsResolutionCache, TS_RESOLUTION_RETRY_MS;
 var init_source_analysis = __esm({
@@ -22405,7 +22675,14 @@ function validateSddTree(rulesOrOptions, projectType = "backend") {
   const implementations = loadImplementationSpecs();
   const types = loadTypeSpecs();
   const surfaceSnapshots = loadSurfaceSnapshots();
-  const codeModel = buildCodeModel(implementations, getProjectRoot());
+  const conformance = rules?.conformance;
+  const codeModel = buildCodeModel(
+    implementations,
+    types,
+    getProjectRoot(),
+    conformance?.sourceRoots ?? [],
+    conformance?.exclude ?? []
+  );
   const statusBearing = treatAllAsComplete ? [...subsystems, ...components, ...interfaces, ...implementations] : settledStatusBearing({ subsystems, components, interfaces, implementations });
   const statusSnapshot = statusBearing.map((s) => s.status);
   for (const s of statusBearing) s.status = "complete";
@@ -27985,7 +28262,9 @@ function createMcpServer(options = {}) {
       name: import_zod11.z.string(),
       signature: import_zod11.z.string(),
       returns: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The type the method answers with")),
-      description: import_zod11.z.string().optional()
+      description: import_zod11.z.string().optional(),
+      sourcePath: import_zod11.z.string().optional().describe("Source file realizing this method when the type's own sourcePath does not hold it \u2014 a pure type method often lives apart from the declaration"),
+      symbol: import_zod11.z.string().optional().describe("Code-level name realizing this method when it differs from the method name, e.g. narrative_step.foreignFields realized by narrativeStepForeignFields")
     }).strict()).optional().describe("Pure intrinsic methods only"),
     componentClass: import_zod11.z.string().optional().describe("Optional component id that implements or owns this logical entity"),
     invariants: import_zod11.z.array(import_zod11.z.object({
@@ -27994,18 +28273,20 @@ function createMcpServer(options = {}) {
     }).strict()).optional().describe("Declared domain invariants (entities): every write-effect method of the componentClass must carry a narrative step asserting each (assertsInvariants) \u2014 declarations checked, enforcement never proven"),
     database: import_zod11.z.string().optional().describe("Optional database id for table-schema types"),
     table: import_zod11.z.string().optional().describe("Optional database table name for table-schema types"),
-    linkedEntity: import_zod11.z.string().optional().describe("Optional logical entity id represented by this table-schema type")
+    linkedEntity: import_zod11.z.string().optional().describe("Optional logical entity id represented by this table-schema type"),
+    sourcePath: import_zod11.z.string().optional().describe("Source file holding the declaration of this type (project-relative). Naming one turns the type into a claim on code: the file must resolve and the declaration must be anchored in it (UNREALIZED_TYPE)"),
+    symbol: import_zod11.z.string().optional().describe('Code-level name realizing the declaration when it differs from name, e.g. a type named "Invoice Line" declared as InvoiceLine')
   };
   const typeInputFields = Object.keys(typeInput);
   reg(
     server,
     "sdd_add_type",
     {
-      description: "Define an entity or value-object type (the data components operate on). Entities are owned by a subsystem; shared value objects omit subsystem (system-level). Fields are data; methods are PURE intrinsic behaviour only \u2014 anything needing a collaborator belongs on a component, taking the entity as an argument. Re-defining an existing id REPLACES fields/methods/invariants (an omitted list is CLEARED, and a dropped member is reported); lint/ext are carried forward. The answer carries a write receipt as structured content beside the sentence \u2014 whether a spec already held the id, and the notices a restatement raised, each as its own entry. A type carries no lifecycle status, so the receipt states none.",
+      description: "Define an entity or value-object type (the data components operate on). Entities are owned by a subsystem; shared value objects omit subsystem (system-level). Fields are data; methods are PURE intrinsic behaviour only \u2014 anything needing a collaborator belongs on a component, taking the entity as an argument. A type may also CLAIM code: sourcePath names the file holding its declaration (and each method may name its own), symbol binds the code-level name when it differs \u2014 the file must then resolve and the declaration must be anchored in it. Re-defining an existing id REPLACES fields/methods/invariants and restates sourcePath/symbol (an omitted list or path is CLEARED, and a dropped member is reported); lint/ext are carried forward. The answer carries a write receipt as structured content beside the sentence \u2014 whether a spec already held the id, and the notices a restatement raised, each as its own entry. A type carries no lifecycle status, so the receipt states none.",
       inputSchema: typeInput,
       outputSchema: specWriteReceiptOutput
     },
-    ({ kind, id, name, description, subsystem, group, fields, methods, componentClass, invariants, database, table, linkedEntity }) => {
+    ({ kind, id, name, description, subsystem, group, fields, methods, componentClass, invariants, database, table, linkedEntity, sourcePath, symbol }) => {
       try {
         const { loadTypeSpec: loadTypeSpec2, saveTypeSpec: saveTypeSpec2 } = requireSpecs();
         const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -28031,6 +28312,8 @@ function createMcpServer(options = {}) {
           ...database ? { database } : {},
           ...table ? { table } : {},
           ...linkedEntity ? { linkedEntity } : {},
+          ...sourcePath ? { sourcePath } : {},
+          ...symbol ? { symbol } : {},
           createdAt: now,
           updatedAt: now
         };