@memoarchitect/tools 0.6.7 → 0.7.2

package/packages/tools/lib/model/ontology-loader.js

@@ -9,14 +9,17 @@
 //   const model = buildMemoModel(documents, config, errors, registries);
 // ─────────────────────────────────────────────────────────────────────────────
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { resolve, dirname, join, basename } from 'node:path';
+import { resolve, dirname, join, basename, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { parse as parseYaml } from 'yaml';
+import { isConnectionDefinition, isDocComment, isEndDeclaration, isPackageDeclaration, } from '../language/generated/ast.js';
 import { KindRegistry } from './kind-registry.js';
 import { RelationshipRegistry } from './relationship-registry.js';
-import { parseFiles } from './parser-utils.js';
+import { parseFileToAstSync } from './parser-utils.js';
 import { VENDOR_ONTOLOGY_DIR } from './paths.js';
 import { discoverMemoManifests, findMemoManifests, resolveManifestPath } from './manifest.js';
+import { CONFIG_SEARCH_ORDER, readPackageManifest, } from './package-manifest.js';
+import { ProvenanceTable } from './source-provenance.js';
+import { discoverLibraryRoots, resolveNativeProject } from './native-project.js';
 /** Layer color palette (mirrors web constants) */
 const LAYER_COLORS = {
     // ontology-core layers
@@ -42,48 +45,106 @@ const LAYER_COLORS = {
     artifacts: '#D97706',
 };
 /**
- * Parse SysML constructs (part def, requirement def, action def, connection def)
- * from a single SysML file, extracting specialization and doc comments.
+ * AST node `$type` → the `<construct> def` spelling reported in catalog DTOs.
+ *
+ * Kept separate from kind-registry's own map because that one deliberately
+ * omits connection/metadata definitions (they classify relationships and
+ * annotations, not model elements) while the catalog view lists them.
+ */
+const CATALOG_CONSTRUCTS = {
+    PartDefinition: 'part def',
+    RequirementDefinition: 'requirement def',
+    VerificationDefinition: 'verification def',
+    StateDefinition: 'state def',
+    UseCaseDeclaration: 'use case def',
+    ActionDefinition: 'action def',
+    AttributeDefinition: 'attribute def',
+    ItemDefinition: 'item def',
+    PortDefinition: 'port def',
+    InterfaceDefinition: 'interface def',
+    EnumDefinition: 'enum def',
+    ConnectionDefinition: 'connection def',
+    MetadataDefinition: 'metadata def',
+    // ConstraintDefinition is deliberately absent: rules are not catalog kinds,
+    // and including them would add 33 entries to the ontology browser that the
+    // previous scanner never listed. Session 1 changes no output.
+};
+/**
+ * Read the definitions and connection endpoints declared in one SysML file.
+ *
+ * This walks the parsed AST. The previous implementation pattern-matched the
+ * source text, which meant a definition inside a block comment counted, a
+ * `connection def` whose body contained a nested brace truncated at the wrong
+ * place, and a qualified supertype (`:> memo::core::MemoPart`) was recorded as
+ * the bare last segment only by accident of the character class. Reading the
+ * tree removes all three failure modes and costs one parse per file.
  */
 function parseConstructsInFile(filePath) {
     const kinds = [];
     const relationships = [];
-    try {
-        const content = readFileSync(filePath, 'utf-8');
-        // Match kind definitions with optional :> (specializes) and preceding doc comments
-        // Pattern: [doc /* ... */] <construct> def Name [:> SuperType] { ... }
-        const kindRegex = /(?:doc\s+\/\*\s*([\s\S]*?)\s*\*\/\s*)?^\s*(?:abstract\s+)?(?:part|requirement|verification|state|use\s+case|action|attribute|item|port|interface|enum|connection|metadata)\s+def\s+(\w+)(?:\s*(?::>|specializes)\s+(\w+))?/gm;
-        for (const m of content.matchAll(kindRegex)) {
-            const construct = m[0].match(/(?:abstract\s+)?(part|requirement|verification|state|use\s+case|action|attribute|item|port|interface|enum|connection|metadata)\s+def/)?.[0]?.trim() ?? 'part def';
-            kinds.push({
-                name: m[2],
-                construct,
-                derivesFrom: m[3] || undefined,
-                description: m[1]?.replace(/\s+/g, ' ').trim() || undefined,
-                isAbstract: /\babstract\s+(?:part|requirement|verification|state|use\s+case|action|attribute|item|port|interface|enum|connection|metadata)\s+def\b/.test(m[0]),
-            });
-        }
-        // Match connection defs with endpoint type annotations
-        // Pattern: connection def Name { end name : TypeName [mult]; end name : TypeName [mult]; }
-        const connBlockRegex = /(?:connection|binding|allocation)\s+def\s+(\w+)\s*\{([^}]*)\}/g;
-        for (const m of content.matchAll(connBlockRegex)) {
-            const name = m[1];
-            const body = m[2];
-            // Extract typed ends: `end <name> : <TypeName> [` — ignore untyped ends like `end subject[1]`
-            const endRegex = /end\s+\w+\s*:\s*(\w+)\s*\[/g;
+    const model = parseFileToAstSync(filePath);
+    if (!model)
+        return { kinds, relationships };
+    for (const { node, doc } of walkDefinitions(model)) {
+        const construct = CATALOG_CONSTRUCTS[node.$type];
+        if (!construct)
+            continue;
+        const name = node.name;
+        if (!name)
+            continue;
+        // The catalog reports the bare supertype name, matching how kinds are
+        // keyed in the browser DTO; the qualified form is preserved in the
+        // registry, which is what conformance walks.
+        const superType = node.specialization?.superType;
+        kinds.push({
+            name,
+            construct,
+            derivesFrom: superType ? superType.split('::').pop() : undefined,
+            description: doc,
+            isAbstract: node.isAbstract || undefined,
+        });
+        if (isConnectionDefinition(node)) {
             const typedEnds = [];
-            for (const em of body.matchAll(endRegex))
-                typedEnds.push(em[1]);
-            relationships.push({
-                name,
-                sourceKind: typedEnds[0],
-                targetKind: typedEnds[1],
-            });
+            for (const member of node.body) {
+                if (isEndDeclaration(member) && member.type) {
+                    typedEnds.push(member.type.split('::').pop() ?? member.type);
+                }
+            }
+            relationships.push({ name, sourceKind: typedEnds[0], targetKind: typedEnds[1] });
         }
     }
-    catch { /* skip */ }
     return { kinds, relationships };
 }
+/**
+ * Yield every definition in a model with the doc comment that precedes it.
+ *
+ * Packages nest arbitrarily, so this recurses rather than assuming the
+ * ontology's current two-level shape.
+ */
+function* walkDefinitions(container) {
+    const members = (container.members ?? container.body ?? []);
+    let pendingDoc;
+    for (const member of members) {
+        if (!member || typeof member !== 'object')
+            continue;
+        if (isDocComment(member)) {
+            pendingDoc = cleanDoc(String(member.content ?? ''));
+            continue;
+        }
+        if (isPackageDeclaration(member)) {
+            yield* walkDefinitions(member);
+            pendingDoc = undefined;
+            continue;
+        }
+        if (typeof member.$type === 'string' && CATALOG_CONSTRUCTS[member.$type]) {
+            yield { node: member, doc: pendingDoc };
+        }
+        pendingDoc = undefined;
+    }
+}
+function cleanDoc(content) {
+    return content.replace(/\s+/g, ' ').trim() || undefined;
+}
 /**
  * Build layer info by scanning the sysml/ directory tree.
  * Apollo-11 convention: sysml/<layer>/<file>.sysml
@@ -185,326 +246,195 @@ function buildRelationshipTypes(sysmlDir) {
     return result;
 }
 /**
- * Read a YAML file and extract a simple string field.
+ * Build OntologyPackageInfo for a single package directory.
  */
-function readYamlField(content, field) {
-    const m = content.match(new RegExp(`^${field}:\\s*["']?([^"'\\n]+)["']?`, 'm'));
-    return m ? m[1].trim() : '';
+function buildPackageInfo(pkgDir, selected) {
+    const { path, manifest } = readPackageManifest(pkgDir);
+    if (!path)
+        return null;
+    const sysmlDir = manifest.sysmlDir
+        ? resolve(pkgDir, manifest.sysmlDir)
+        : join(pkgDir, 'sysml');
+    // Authority is decided by the resolved root a package sits under, from the
+    // native import graph. The manifest `type:` that used to declare it is gone.
+    const type = suppliesMethodology(sysmlDir) ? 'methodology' : 'ontology';
+    const layers = applyExplorerClassification(buildLayers(sysmlDir), sysmlDir);
+    const kindCount = layers.reduce((s, l) => s + l.kindCount, 0);
+    const relationshipTypes = buildRelationshipTypes(sysmlDir);
+    return {
+        name: manifest.name ?? basename(pkgDir),
+        version: manifest.version ?? '0.0.0',
+        type,
+        description: manifest.description ?? '',
+        layers,
+        kindCount,
+        relationshipCount: relationshipTypes.length,
+        relationshipTypes,
+        selected,
+        rootDir: pkgDir,
+    };
 }
 /**
- * Read the `methodology:` field from a project config.
- * Returns a Set of package names: the methodology pkg + every pkg on its
- * extends chain. Used to mark them as selected in getPackageMetadata.
+ * Does this source tree supply a methodology?
+ *
+ * A package that declares a `MethodologyDefinition` usage is a methodology
+ * package. This is derived from what the SysML says, because the manifest field
+ * that used to declare it selected model content and was removed with the rest.
  */
-function readMethodologyChain(configPath) {
-    const out = new Set();
-    let methodologyName;
-    try {
-        const content = readFileSync(configPath, 'utf-8');
-        const m = content.match(/^methodology:\s*"?([^"\s#]+)"?/m);
-        if (!m)
-            return out;
-        const raw = m[1];
-        const lastAt = raw.lastIndexOf('@');
-        methodologyName = lastAt > 0 ? raw.slice(0, lastAt) : raw;
-        if (!methodologyName.startsWith('@memoarchitect/'))
-            methodologyName = `@memoarchitect/${methodologyName}`;
-    }
-    catch {
-        return out;
-    }
-    if (!methodologyName)
-        return out;
-    // Walk the extends chain starting at the methodology pkg.
-    const stack = [methodologyName];
-    const visited = new Set();
-    while (stack.length) {
-        const pkgName = stack.pop();
-        if (visited.has(pkgName))
-            continue;
-        visited.add(pkgName);
-        out.add(pkgName);
-        const pkgCfg = resolvePackageConfig(pkgName, dirname(configPath));
-        if (!pkgCfg)
-            continue;
+function suppliesMethodology(sysmlDir) {
+    for (const file of collectSysmlFiles(sysmlDir)) {
         let content = '';
         try {
-            content = readFileSync(pkgCfg, 'utf-8');
+            content = readFileSync(file, 'utf-8');
         }
         catch {
             continue;
         }
-        const single = content.match(/^extends:\s*"?(@[\w-]+\/[\w-]+)"?/m);
-        if (single) {
-            stack.push(single[1]);
+        // Prefilter on the name, then confirm against the AST. A file that
+        // merely mentions `MethodologyDefinition` in a comment or an import
+        // does not supply one.
+        if (!content.includes('MethodologyDefinition'))
             continue;
-        }
-        const arr = content.match(/^extends:\s*\n((?:\s+-\s+.+\n?)+)/m);
-        if (arr) {
-            for (const em of arr[1].matchAll(/^\s+-\s+"?(@[\w-]+\/[\w-]+)"?/gm))
-                stack.push(em[1]);
-        }
+        const model = parseFileToAstSync(file);
+        if (!model)
+            continue;
+        for (const _ of usagesOfType(model, 'MethodologyDefinition'))
+            return true;
     }
-    return out;
+    return false;
 }
 /**
- * Get the list of selected ontology package names from a project config file.
+ * Read a string attribute from a usage body in the AST.
+ *
+ * Both the `:>>` redefinition and the plain declaration forms appear in
+ * authored ontology source, so both are accepted.
  */
-function readSelectedOntologies(configPath) {
-    const selected = new Set();
-    try {
-        const content = readFileSync(configPath, 'utf-8');
-        const section = content.split(/^ontologies:/m)[1];
-        if (section) {
-            const matches = section.matchAll(/^\s*-\s*name:\s*["']?([\w@\/-]+)["']?/gm);
-            for (const m of matches)
-                selected.add(m[1]);
+function usageAttr(body, name) {
+    for (const member of (body ?? [])) {
+        if (!member || member.$type !== 'AttributeMember' || member.name !== name)
+            continue;
+        const value = member.value;
+        if (!value || value.$type !== 'StringValue')
+            continue;
+        try {
+            return JSON.parse(value.value ?? '""');
         }
-    }
-    catch { /* skip */ }
-    return selected;
-}
-/**
- * Build OntologyPackageInfo for a single package directory.
- */
-function buildPackageInfo(pkgDir, selected) {
-    const configCandidates = ['memo.package.yaml', 'memo.package.yml', 'memo.config.yaml', 'memo.config.yml'];
-    let configContent = '';
-    for (const name of configCandidates) {
-        const p = join(pkgDir, name);
-        if (existsSync(p)) {
-            configContent = readFileSync(p, 'utf-8');
-            break;
+        catch {
+            return String(value.value ?? '').replace(/^"|"$/g, '');
         }
     }
-    if (!configContent)
-        return null;
-    const name = readYamlField(configContent, 'name') || basename(pkgDir);
-    const version = readYamlField(configContent, 'version') || '0.0.0';
-    const rawType = readYamlField(configContent, 'type') || 'ontology';
-    const type = (['ontology', 'profile', 'extension', 'methodology'].includes(rawType) ? rawType : 'ontology');
-    const description = readYamlField(configContent, 'description') || '';
-    const extendsField = readYamlField(configContent, 'extends') || undefined;
-    const sysmlDirOverride = readYamlField(configContent, 'sysmlDir');
-    const sysmlDir = sysmlDirOverride
-        ? resolve(pkgDir, sysmlDirOverride)
-        : join(pkgDir, 'sysml');
-    const layers = applyExplorerClassification(buildLayers(sysmlDir), pkgDir);
-    const kindCount = layers.reduce((s, l) => s + l.kindCount, 0);
-    const relationshipTypes = buildRelationshipTypes(sysmlDir);
-    const optionalModules = readOptionalModulesList(configContent);
-    return {
-        name, version, type, description, extends: extendsField, layers, kindCount,
-        relationshipCount: relationshipTypes.length, relationshipTypes, selected,
-        optionalModules,
-        rootDir: pkgDir,
-    };
-}
-/** Apply the ontology-declared Explorer taxonomy to discovered kinds. */
-function applyExplorerClassification(layers, pkgDir) {
-    const rendering = join(pkgDir, 'memo.rendering.yaml');
-    if (!existsSync(rendering))
-        return layers;
-    try {
-        const parsed = parseYaml(readFileSync(rendering, 'utf-8'));
-        const classifications = parsed.explorer?.classifications ?? [];
-        if (classifications.length === 0)
-            return layers;
-        const bySource = new Map(classifications.map(c => [c.source, c]));
-        const domains = new Map();
-        for (const layer of layers)
-            for (const kind of layer.kinds) {
-                const source = kind.group ?? kind.layer;
-                const placement = bySource.get(source);
-                if (!placement)
-                    continue;
-                let domain = domains.get(placement.domain);
-                if (!domain) {
-                    domain = { id: placement.domain, label: placement.domain.charAt(0).toUpperCase() + placement.domain.slice(1), color: '#6B7280', kindCount: 0, kinds: [] };
-                    domains.set(placement.domain, domain);
-                }
-                domain.kinds.push({ ...kind, layer: placement.domain, group: placement.group });
-            }
-        for (const domain of domains.values())
-            domain.kindCount = domain.kinds.length;
-        return [...domains.values()];
-    }
-    catch {
-        return layers;
-    }
-}
-/** Parse `optionalModules:` list from a manifest file content. */
-function readOptionalModulesList(content) {
-    const out = [];
-    const section = content.split(/^optionalModules:/m)[1];
-    if (!section)
-        return out;
-    for (const m of section.matchAll(/^\s*-\s*"?([@\w/-]+)"?/gm)) {
-        out.push(m[1]);
-        // Guard: stop if we leave the list (no leading `-`)
-        if (!m[0].match(/^\s*-/))
-            break;
-    }
-    return out;
+    return undefined;
 }
-/**
- * Get ontology package metadata for all packages in the project's extends chain
- * plus any available-but-unselected packages under packages/ or node_modules/@memoarchitect/.
- *
- * @param projectRoot - Absolute path to the project root (where memo.package.yaml lives)
- */
-export function getPackageMetadata(projectRoot) {
-    const configCandidates = ['memo.package.yaml', 'memo.package.yml', 'memo.config.yaml', 'memo.config.yml'];
-    let primaryConfig = '';
-    for (const name of configCandidates) {
-        const p = join(projectRoot, name);
-        if (existsSync(p)) {
-            primaryConfig = p;
-            break;
+/** Every `part <name> : <Type> { … }` usage of `typeName`, from the AST. */
+function* usagesOfType(container, typeName) {
+    const members = (container.members ?? container.body ?? []);
+    for (const member of members) {
+        if (!member || typeof member !== 'object')
+            continue;
+        if (isPackageDeclaration(member)) {
+            yield* usagesOfType(member, typeName);
+            continue;
+        }
+        const type = typeof member.type === 'string' ? member.type.split('::').pop() : undefined;
+        if (type === typeName && Array.isArray(member.body)) {
+            yield { name: member.name, body: member.body };
         }
     }
-    if (!primaryConfig)
-        return [];
-    const selectedNames = readSelectedOntologies(primaryConfig);
-    const result = [];
-    const seen = new Set();
-    // The active ontology often lives behind a logical package manifest. For
-    // example, the medical profile resolves to MEMO's `ontology/` directory
-    // rather than a sibling `packages/` directory. Follow the actual extends
-    // chain first, so the Explorer receives the same canonical types that the
-    // model builder uses to resolve usages.
-    const inheritedDirs = new Set();
-    const visitExtends = (configPath, visited = new Set()) => {
-        const normalized = resolve(configPath);
-        if (visited.has(normalized))
-            return;
-        visited.add(normalized);
+}
+function readRenderingMetadata(sysmlDir) {
+    const placements = new Map();
+    const palette = new Map();
+    for (const file of collectSysmlFiles(sysmlDir)) {
+        // Cheap textual prefilter, then a real parse. Section 13.1 forbids
+        // regex as a semantic DISCOVERY mechanism; deciding whether a file is
+        // worth parsing is not discovery, and the values below are read from
+        // the AST.
         let content = '';
         try {
-            content = readFileSync(normalized, 'utf-8');
+            content = readFileSync(file, 'utf-8');
         }
         catch {
-            return;
-        }
-        const parentNames = [];
-        const single = content.match(/^extends:\s*"?(@[\w-]+\/[\w-]+)"?/m);
-        if (single)
-            parentNames.push(single[1]);
-        const array = content.match(/^extends:\s*\n((?:\s+-\s+.+\n?)+)/m);
-        if (array)
-            for (const entry of array[1].matchAll(/^\s+-\s+"?(@[\w-]+\/[\w-]+)"?/gm))
-                parentNames.push(entry[1]);
-        for (const parentName of parentNames) {
-            const parentConfig = resolvePackageConfig(parentName, dirname(normalized));
-            if (!parentConfig)
-                continue;
-            inheritedDirs.add(dirname(parentConfig));
-            visitExtends(parentConfig, visited);
+            continue;
         }
-    };
-    visitExtends(primaryConfig);
-    // Gather package directories from the tools repo and its memo submodule.
-    const candidates = [];
-    candidates.push(...inheritedDirs);
-    let searchDir = resolve(projectRoot);
-    while (true) {
-        const pkgsDir = join(searchDir, 'packages');
-        if (existsSync(pkgsDir)) {
-            try {
-                for (const entry of readdirSync(pkgsDir, { withFileTypes: true })) {
-                    if (!entry.isDirectory())
-                        continue;
-                    candidates.push(join(pkgsDir, entry.name));
-                }
+        if (!content.includes('ExplorerClassification') && !content.includes('LayerRendering'))
+            continue;
+        const model = parseFileToAstSync(file);
+        if (!model)
+            continue;
+        for (const usage of usagesOfType(model, 'ExplorerClassification')) {
+            const sourceNamespace = usageAttr(usage.body, 'sourceNamespace');
+            const explorerDomain = usageAttr(usage.body, 'explorerDomain');
+            const explorerGroup = usageAttr(usage.body, 'explorerGroup');
+            if (sourceNamespace && explorerDomain && explorerGroup) {
+                placements.set(sourceNamespace, { sourceNamespace, explorerDomain, explorerGroup });
             }
-            catch { /* skip */ }
-            break;
         }
-        const parent = dirname(searchDir);
-        if (parent === searchDir)
-            break;
-        searchDir = parent;
-    }
-    // Scan memo_packages/ for locally installed packages
-    const memoPkgsDir = join(projectRoot, 'memo_packages');
-    if (existsSync(memoPkgsDir)) {
-        try {
-            for (const entry of readdirSync(memoPkgsDir, { withFileTypes: true })) {
-                if (entry.isDirectory())
-                    candidates.push(join(memoPkgsDir, entry.name));
+        for (const usage of usagesOfType(model, 'LayerRendering')) {
+            const layerId = usageAttr(usage.body, 'layerId');
+            const layerLabel = usageAttr(usage.body, 'layerLabel');
+            const layerColor = usageAttr(usage.body, 'layerColor');
+            if (layerId && layerLabel && layerColor) {
+                palette.set(layerId, { layerId, layerLabel, layerColor });
             }
         }
-        catch { /* skip */ }
     }
-    // Also scan node_modules/@memoarchitect/ for installed packages
-    const nmMemo = join(projectRoot, 'node_modules', '@memoarchitect');
-    if (existsSync(nmMemo)) {
-        try {
-            for (const entry of readdirSync(nmMemo, { withFileTypes: true })) {
-                if (entry.isDirectory())
-                    candidates.push(join(nmMemo, entry.name));
-            }
+    return { placements, palette };
+}
+/** Apply the ontology-declared Explorer taxonomy to discovered kinds. */
+function applyExplorerClassification(layers, sysmlDir) {
+    const { placements, palette } = readRenderingMetadata(sysmlDir);
+    for (const layer of layers) {
+        const authored = palette.get(layer.id);
+        if (authored) {
+            layer.label = authored.layerLabel;
+            layer.color = authored.layerColor;
         }
-        catch { /* skip */ }
-    }
-    // A bundled example runs from a disposable directory and intentionally has
-    // no node_modules of its own. Its packages are nevertheless resolvable via
-    // its methodology/extends chain, so use that same authoritative resolution
-    // path when publishing metadata to clients such as Memo Architect.
-    for (const packageDir of findOntologyPackageDirs(primaryConfig)) {
-        candidates.push(packageDir);
     }
-    // Collect which packages are declared as optionalModules by any base pkg.
-    const optionalModuleNames = new Set();
-    for (const pkgDir of candidates) {
-        for (const cfg of configCandidates) {
-            const manifestPath = join(pkgDir, cfg);
-            if (!existsSync(manifestPath))
+    if (placements.size === 0)
+        return layers;
+    const domains = new Map();
+    for (const layer of layers)
+        for (const kind of layer.kinds) {
+            const source = kind.group ?? kind.layer;
+            const placement = placements.get(source);
+            if (!placement)
                 continue;
-            try {
-                const content = readFileSync(manifestPath, 'utf-8');
-                for (const m of readOptionalModulesList(content))
-                    optionalModuleNames.add(m);
-            }
-            catch { /* skip */ }
-            break;
-        }
-    }
-    // Also collect project-declared modules so they get selected=true.
-    const projectModules = new Set(readDeclaredModules(primaryConfig));
-    // Phase C: methodology field also marks packages selected — methodology
-    // pkg itself plus everything on its extends chain.
-    const methodologySelected = readMethodologyChain(primaryConfig);
-    for (const pkgDir of candidates) {
-        let sysmlPath = join(pkgDir, 'sysml');
-        for (const cfg of CONFIG_SEARCH_ORDER) {
-            const cp = join(pkgDir, cfg);
-            if (existsSync(cp)) {
-                const ov = readYamlField(readFileSync(cp, 'utf-8'), 'sysmlDir');
-                if (ov)
-                    sysmlPath = resolve(pkgDir, ov);
-                break;
+            let domain = domains.get(placement.explorerDomain);
+            if (!domain) {
+                domain = {
+                    id: placement.explorerDomain,
+                    label: placement.explorerDomain.charAt(0).toUpperCase() + placement.explorerDomain.slice(1),
+                    color: '#6B7280',
+                    kindCount: 0,
+                    kinds: [],
+                };
+                domains.set(placement.explorerDomain, domain);
             }
+            domain.kinds.push({ ...kind, layer: placement.explorerDomain, group: placement.explorerGroup });
         }
-        const hasSysml = existsSync(sysmlPath);
-        if (!hasSysml)
-            continue;
-        if (seen.has(pkgDir))
-            continue;
-        seen.add(pkgDir);
-        const info = buildPackageInfo(pkgDir, false);
-        if (!info)
-            continue;
-        // Mark as selected if name is in project's ontologies list, or inferred heuristic
-        info.selected = inheritedDirs.has(pkgDir)
-            || selectedNames.has(info.name)
-            || selectedNames.has(info.name.replace('@memoarchitect/', ''))
-            || projectModules.has(info.name)
-            || methodologySelected.has(info.name);
-        info.isOptionalModule = optionalModuleNames.has(info.name);
-        result.push(info);
+    if (domains.size === 0)
+        return layers;
+    for (const domain of domains.values())
+        domain.kindCount = domain.kinds.length;
+    return [...domains.values()];
+}
+/**
+ * Describe every package a project could resolve, marking the ones it does.
+ *
+ * "Available" comes from locators — distribution manifests, node_modules,
+ * workspace package directories. "Selected" comes from the native import
+ * closure and nothing else: a package a manifest points at but no import
+ * reaches is listed here as available and unselected, which is exactly what it
+ * is. Before the flip, selection was read out of `ontologies:`, `modules:`,
+ * `methodology:`, and the `extends` chain.
+ */
+export function getPackageMetadata(projectRoot, selectedRootDirs) {
+    const result = [];
+    for (const root of discoverLibraryRoots(resolve(projectRoot))) {
+        const info = buildPackageInfo(root.dir, selectedRootDirs?.has(root.dir) ?? false);
+        if (info)
+            result.push(info);
     }
-    // Sort: selected first, then by name
     result.sort((a, b) => {
         if (a.selected !== b.selected)
             return a.selected ? -1 : 1;
@@ -534,255 +464,14 @@ function collectSysmlFiles(dir) {
     }
     return files;
 }
-/**
- * Walk the config `extends` chain to find ontology package directories.
- * Returns absolute paths to directories containing `sysml/` subdirectories.
- *
- * Strategy:
- * 1. Start from the config file's directory
- * 2. Follow `extends` references (@memoarchitect/package-name → packages/package-name)
- * 3. For each package in the chain, check if it has a sysml/ directory
- * 4. Also check for ontology-core (may not be in extends chain directly)
- */
-export function findOntologyPackageDirs(configPath) {
-    const dirs = [];
-    const seen = new Set();
-    // 0. (Phase C) If project pins a `methodology:`, resolve it and walk its
-    // extends chain. The methodology package brings in its own SysML and
-    // chain-pulls the kinds ontology (e.g. @memoarchitect/ontology).
-    try {
-        const content = readFileSync(configPath, 'utf-8');
-        const methodologyMatch = content.match(/^methodology:\s*"?([^"\s#]+)"?/m);
-        if (methodologyMatch) {
-            // Strip optional version range "@^1.0" → just the package name.
-            // The leading @memoarchitect/ scope must be preserved, so only strip the LAST `@`.
-            const raw = methodologyMatch[1];
-            const lastAt = raw.lastIndexOf('@');
-            const methodologyName = lastAt > 0 ? raw.slice(0, lastAt) : raw;
-            const fullName = methodologyName.startsWith('@memoarchitect/')
-                ? methodologyName
-                : `@memoarchitect/${methodologyName}`;
-            const pkgConfig = resolvePackageConfig(fullName, dirname(configPath));
-            if (pkgConfig)
-                walkExtendsChain(pkgConfig, dirs, seen);
-        }
-    }
-    catch { /* skip */ }
-    // 1. Walk the primary extends chain
-    walkExtendsChain(configPath, dirs, seen);
-    // 2. Load additional ontologies from the config file's `ontologies` array.
-    // This allows for a "Base + Plugin" model where users can add multiple domain-specific ontologies.
-    try {
-        const content = readFileSync(configPath, 'utf-8');
-        // Lightweight YAML parsing for ontologies:
-        const ontologySection = content.split(/^ontologies:/m)[1];
-        if (ontologySection) {
-            const matches = ontologySection.matchAll(/^\s*-\s*name:\s*"?([\w@\/-]+)"?/gm);
-            for (const match of matches) {
-                let ontologyName = match[1];
-                // Ensure name has @memoarchitect/ prefix for resolution if missing
-                if (!ontologyName.startsWith('@memoarchitect/')) {
-                    ontologyName = `@memoarchitect/${ontologyName}`;
-                }
-                const pkgConfig = resolvePackageConfig(ontologyName, dirname(configPath));
-                if (pkgConfig) {
-                    walkExtendsChain(pkgConfig, dirs, seen);
-                }
-            }
-        }
-    }
-    catch {
-        // Skip inaccessible configs
-    }
-    // 3. Resolve optional modules declared under `modules:` in the project config.
-    // Modules follow OWL import semantics — declared in the base ontology's
-    // `optionalModules:` list, loaded only when the project opts in.
-    for (const moduleName of readDeclaredModules(configPath)) {
-        const pkgConfig = resolvePackageConfig(moduleName, dirname(configPath));
-        if (pkgConfig)
-            walkExtendsChain(pkgConfig, dirs, seen);
-    }
-    return dirs;
-}
-/**
- * Read the `modules:` array from a project config, resolving short aliases
- * (e.g. "ros") against the base ontology's `optionalModules:` list.
- * Returns fully-qualified @memoarchitect/... package names.
- */
-function readDeclaredModules(configPath) {
-    const out = [];
-    let rawModules = [];
-    try {
-        const content = readFileSync(configPath, 'utf-8');
-        // Match `modules:\n  - foo\n  - "@memoarchitect/bar"`
-        const section = content.split(/^modules:/m)[1];
-        if (section) {
-            const matches = section.matchAll(/^\s*-\s*"?([@\w/-]+)"?/gm);
-            // Stop at the first non-list YAML key
-            for (const m of matches) {
-                const line = m[0];
-                if (!line.match(/^\s*-/))
-                    break;
-                rawModules.push(m[1]);
-            }
-        }
-    }
-    catch {
-        return out;
-    }
-    if (rawModules.length === 0)
-        return out;
-    // Gather optional-module allowlist from the extends chain
-    const allowlist = collectOptionalModules(configPath);
-    const byShort = new Map(); // short → full name
-    for (const full of allowlist) {
-        const short = full.split('/').pop() ?? full;
-        byShort.set(short, full);
-    }
-    for (const entry of rawModules) {
-        if (entry.startsWith('@')) {
-            out.push(entry);
-        }
-        else {
-            out.push(byShort.get(entry) ?? entry);
-        }
-    }
-    return out;
-}
-/**
- * Walk the extends chain of a config and collect all `optionalModules:` entries.
- */
-function collectOptionalModules(configPath) {
-    const modules = new Set();
-    const visited = new Set();
-    const stack = [resolve(configPath)];
-    while (stack.length) {
-        const p = stack.pop();
-        if (visited.has(p))
-            continue;
-        visited.add(p);
-        let content = '';
-        try {
-            content = readFileSync(p, 'utf-8');
-        }
-        catch {
-            continue;
-        }
-        const section = content.split(/^optionalModules:/m)[1];
-        if (section) {
-            for (const m of section.matchAll(/^\s*-\s*"?([@\w/-]+)"?/gm)) {
-                const line = m[0];
-                if (!line.match(/^\s*-/))
-                    break;
-                modules.add(m[1]);
-            }
-        }
-        // Handle both single and array extends forms
-        const singleExt = content.match(/^extends:\s*"?(@[\w-]+\/[\w-]+)"?/m);
-        if (singleExt) {
-            const parent = resolvePackageConfig(singleExt[1], dirname(p));
-            if (parent)
-                stack.push(parent);
-        }
-        else {
-            const arraySection = content.match(/^extends:\s*\n((?:\s+-\s+.+\n?)+)/m);
-            if (arraySection) {
-                for (const m of arraySection[1].matchAll(/^\s+-\s+"?(@[\w-]+\/[\w-]+)"?/gm)) {
-                    const parent = resolvePackageConfig(m[1], dirname(p));
-                    if (parent)
-                        stack.push(parent);
-                }
-            }
-        }
-    }
-    return [...modules];
-}
-/**
- * Recursively walk the extends chain, collecting ontology package dirs.
- */
-function walkExtendsChain(configPath, dirs, seen) {
-    const resolvedPath = resolve(configPath);
-    if (seen.has(resolvedPath))
-        return;
-    seen.add(resolvedPath);
-    // Read the YAML to find extends (lightweight — just look for extends line)
-    let extendsPackages = [];
-    let projectType;
-    try {
-        const content = readFileSync(resolvedPath, 'utf-8');
-        // Handle both single-string extends and array extends in YAML:
-        //   extends: "@memoarchitect/ontology"
-        //   extends:
-        //     - "@memoarchitect/ontology"
-        const singleMatch = content.match(/^extends:\s*"?(@[\w-]+\/[\w-]+)"?/m);
-        if (singleMatch) {
-            extendsPackages = [singleMatch[1]];
-        }
-        else {
-            // Array form: collect all list entries under `extends:`
-            const arraySection = content.match(/^extends:\s*\n((?:\s+-\s+.+\n?)+)/m);
-            if (arraySection) {
-                const entries = [...arraySection[1].matchAll(/^\s+-\s+"?(@[\w-]+\/[\w-]+)"?/gm)];
-                extendsPackages = entries.map(m => m[1]);
-            }
-        }
-        // Match both legacy (projectType:) and new format (type:)
-        const typeMatch = content.match(/^(?:projectType|type):\s*(\w+)/m);
-        if (typeMatch) {
-            projectType = typeMatch[1];
-        }
-    }
-    catch {
-        return;
-    }
-    const packageDir = dirname(resolvedPath);
-    // Honor `sysmlDir:` override (points outside package, e.g. ../../ontology)
-    let sysmlDir;
-    try {
-        const content = readFileSync(resolvedPath, 'utf-8');
-        const override = readYamlField(content, 'sysmlDir');
-        sysmlDir = override ? resolve(packageDir, override) : resolve(packageDir, 'sysml');
-    }
-    catch {
-        sysmlDir = resolve(packageDir, 'sysml');
-    }
-    if (existsSync(sysmlDir)) {
-        dirs.push(packageDir);
-    }
-    // Follow extends chain (handles both single and array extends)
-    for (const extendsPackage of extendsPackages) {
-        const parentConfigPath = resolvePackageConfig(extendsPackage, packageDir);
-        if (parentConfigPath) {
-            walkExtendsChain(parentConfigPath, dirs, seen);
-        }
-    }
-}
 /**
  * Resolve the SysML root directory for an ontology package.
  * Honors `sysmlDir:` override in the package's manifest; falls back to `<pkgDir>/sysml`.
  */
 export function resolvePackageSysmlDir(pkgDir) {
-    for (const cfg of CONFIG_SEARCH_ORDER) {
-        const cp = resolve(pkgDir, cfg);
-        if (existsSync(cp)) {
-            try {
-                const ov = readYamlField(readFileSync(cp, 'utf-8'), 'sysmlDir');
-                if (ov)
-                    return resolve(pkgDir, ov);
-            }
-            catch { /* skip */ }
-            break;
-        }
-    }
-    return resolve(pkgDir, 'sysml');
+    const override = readPackageManifest(pkgDir).manifest.sysmlDir;
+    return override ? resolve(pkgDir, override) : resolve(pkgDir, 'sysml');
 }
-/** Ordered list of config filenames to search for (new format first, then legacy) */
-const CONFIG_SEARCH_ORDER = [
-    'memo.package.yaml',
-    'memo.package.yml',
-    'memo.config.yaml',
-    'memo.config.yml',
-];
 /**
  * Resolve a @memoarchitect/package-name to its config file path.
  * Prefers memo.package.yaml (new format), falls back to memo.config.yaml (legacy).
@@ -796,10 +485,11 @@ export function resolvePackageConfig(packageName, fromDir) {
     // A logical package config is itself inside the physical content package.
     // It is not a user-project boundary: allow sibling logical packages to be
     // resolved through the nearest enclosing manifest.
+    // A logical package descriptor sits inside the physical content package, so
+    // it is not a user-project boundary. Sibling logical packages resolve
+    // through the nearest enclosing distribution manifest.
     if (projectConfig) {
-        const type = readYamlField(readFileSync(projectConfig, 'utf-8'), 'type')
-            || readYamlField(readFileSync(projectConfig, 'utf-8'), 'projectType');
-        if (type && type !== 'device') {
+        {
             let manifestDir = dirname(projectConfig);
             while (true) {
                 for (const manifest of discoverMemoManifests([manifestDir])) {
@@ -894,72 +584,108 @@ function findNearestProjectConfig(startDir) {
     }
 }
 /**
- * Load ontology registries by walking the config extends chain,
- * finding ontology SysML files, parsing them, and populating
- * KindRegistry + RelationshipRegistry.
+ * Load the reusable registries a project actually resolves.
+ *
+ * Selection is the native import closure. This used to walk the `extends`
+ * chain, the `methodology:` field, the `ontologies:` list, and the `modules:`
+ * opt-ins; all four are gone, and a package now contributes kinds because the
+ * project imports it, not because a settings file named it.
  *
- * @param configPath - Path to the project's memo.config.yaml
- * @returns Populated registries and diagnostic info
+ * Everything in the closure is parsed, including project-owned source, because
+ * a project may declare its own definitions and those are project content the
+ * builder must see. Provenance keeps the two apart.
  */
-export async function loadOntologyRegistries(configPath) {
+export async function loadOntologyRegistries(projectRoot) {
     const kindRegistry = new KindRegistry();
     const relationshipRegistry = new RelationshipRegistry();
     const errors = [];
-    // Find ontology package directories
-    const ontologyDirs = findOntologyPackageDirs(configPath);
-    if (ontologyDirs.length === 0) {
-        return {
-            registries: { kindRegistry, relationshipRegistry },
-            fileCount: 0,
-            ontologyDirs: [],
-            errors: ['No ontology packages with sysml/ directories found in extends chain'],
-            parsedDocuments: [],
-        };
-    }
-    // Collect all SysML files from all ontology packages (honor sysmlDir override).
-    // Dedupe by absolute path — methodology and base ontology pkgs may have
-    // overlapping sysmlDirs (e.g. methodology points at ontology/methodology/memo
-    // while @memoarchitect/ontology points at src/).
-    const sysmlSet = new Set();
-    for (const pkgDir of ontologyDirs) {
-        let sysmlDir = resolve(pkgDir, 'sysml');
-        for (const cfg of CONFIG_SEARCH_ORDER) {
-            const cp = resolve(pkgDir, cfg);
-            if (existsSync(cp)) {
-                const ov = readYamlField(readFileSync(cp, 'utf-8'), 'sysmlDir');
-                if (ov)
-                    sysmlDir = resolve(pkgDir, ov);
-                break;
-            }
-        }
-        for (const f of collectSysmlFiles(sysmlDir))
-            sysmlSet.add(f);
-    }
-    const allSysmlFiles = [...sysmlSet];
-    if (allSysmlFiles.length === 0) {
+    const resolution = await resolveNativeProject(projectRoot);
+    for (const diagnostic of resolution.diagnostics) {
+        errors.push(`${diagnostic.code}: ${diagnostic.message}`);
+    }
+    // Watch both distribution descriptors and their actual SysML source
+    // roots. Native packages may publish source outside the descriptor
+    // directory (for example ontology/memo.package.yaml -> ../src).
+    const ontologyDirs = [...new Set(resolution.selectedRoots.flatMap(r => [r.dir, r.sysmlDir]))];
+    // A package is resolved in full or not at all.
+    //
+    // The closure says which roots the project reaches; everything those roots
+    // supply is then loaded, because a methodology that declares
+    // `scopeMode = allAvailable` means "everything the resolved packages
+    // provide" and cannot mean that only the files some other file happened to
+    // import exist. Loading is not selecting: effective scope decides what is
+    // active, which keeps one filter rather than two.
+    //
+    // A root no import reaches supplies nothing — that is what makes this the
+    // import graph's answer and not the locator's.
+    const selectedSysmlDirs = resolution.selectedRoots.map(r => r.sysmlDir);
+    const closureFiles = new Set();
+    for (const pkg of resolution.closure.values()) {
+        for (const file of pkg.files)
+            closureFiles.add(file);
+    }
+    const documents = resolution.documents.filter(d => closureFiles.has(d.filePath) || selectedSysmlDirs.some(dir => d.filePath.startsWith(dir + sep)));
+    if (documents.length === 0) {
         return {
             registries: { kindRegistry, relationshipRegistry },
             fileCount: 0,
             ontologyDirs,
-            errors: ['Ontology packages found but no .sysml files in sysml/ directories'],
+            errors: errors.length > 0 ? errors : [
+                'No SysML reachable from the project entrypoint. Check the imports in model/catalog/project.sysml.',
+            ],
             parsedDocuments: [],
+            kindNameCollisions: [],
+            resolution,
         };
     }
-    // Parse all ontology SysML files
-    const parseResult = await parseFiles(allSysmlFiles, '');
-    for (const err of parseResult.errors) {
-        errors.push(`${err.file}${err.line ? `:${err.line}` : ''}: ${err.message}`);
-    }
-    // Populate registries from parsed documents
-    kindRegistry.populateFromDocuments(parseResult.documents);
+    kindRegistry.populateFromDocuments(documents);
     kindRegistry.computeDerivedBy();
-    relationshipRegistry.populateFromDocuments(parseResult.documents);
+    relationshipRegistry.populateFromDocuments(documents);
     return {
         registries: { kindRegistry, relationshipRegistry },
-        fileCount: allSysmlFiles.length,
+        fileCount: documents.length,
         ontologyDirs,
         errors,
-        parsedDocuments: parseResult.documents,
+        parsedDocuments: documents,
+        kindNameCollisions: kindRegistry.getCollisions(),
+        provenance: buildProvenanceTable(resolution),
+        resolution,
     };
 }
+/**
+ * Classify each resolved package into an authority category.
+ *
+ * Origin comes from the resolved root a file sits under — never from what the
+ * file declares, what it is called, or where it sits in a directory tree.
+ * Import depth is now the real graph distance from the project entrypoint,
+ * which is what session 1 left this function waiting for; before, it was the
+ * package's position in an ordered walk.
+ */
+function buildProvenanceTable(resolution) {
+    const byDir = new Map();
+    for (const pkg of resolution.closure.values()) {
+        if (!pkg.root)
+            continue;
+        const existing = byDir.get(pkg.root.dir);
+        if (existing && existing.importDepth <= pkg.importDepth)
+            continue;
+        byDir.set(pkg.root.dir, {
+            dir: pkg.root.dir,
+            origin: pkg.origin,
+            packageName: pkg.root.packageName,
+            packageVersion: pkg.root.packageVersion,
+            importDepth: pkg.importDepth,
+        });
+    }
+    const roots = [];
+    for (const root of byDir.values()) {
+        roots.push(root);
+        // A package may publish its SysML from a directory outside its own
+        // descriptor directory. Both physical roots are the same authority.
+        const lib = resolution.selectedRoots.find(r => r.dir === root.dir);
+        if (lib && lib.sysmlDir !== root.dir)
+            roots.push({ ...root, dir: lib.sysmlDir });
+    }
+    return new ProvenanceTable(resolution.projectRoot, roots);
+}
 //# sourceMappingURL=ontology-loader.js.map