mdkg 0.1.3 → 0.1.5

package/dist/core/config.js

@@ -23,9 +23,11 @@ const NEXT_WORK_STRATEGIES = new Set(["chain_then_priority"]);
 const WORKSPACE_VISIBILITY_VALUES = new Set(["private", "internal", "public"]);
 const BUNDLE_PROFILE_VALUES = new Set(["private", "public"]);
 const INDEX_BACKEND_VALUES = new Set(["json", "sqlite"]);
+const SUBGRAPH_PERMISSION_VALUES = new Set(["read", "request", "propose", "mutate"]);
 const DEFAULT_ARCHIVE_LARGE_CACHE_WARNING_BYTES = 26214400;
 const DEFAULT_SQLITE_COMMIT_WARNING_BYTES = 52428800;
 const DEFAULT_LOCK_TIMEOUT_MS = 10000;
+const DEFAULT_SUBGRAPH_MAX_STALE_SECONDS = 3600;
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -172,16 +174,16 @@ function validateWorkspaceAlias(alias, errors) {
         errors.push(`workspaces.${alias} alias must be lowercase and use [a-z0-9_]`);
     }
 }
-function validateBundleImportAlias(alias, workspaces, errors) {
+function validateSubgraphAlias(alias, workspaces, errors) {
     if (alias === "all") {
-        errors.push("bundle_imports.all alias is reserved");
+        errors.push("subgraphs.all alias is reserved");
         return;
     }
     if (alias !== alias.toLowerCase() || !WORKSPACE_ALIAS_RE.test(alias)) {
-        errors.push(`bundle_imports.${alias} alias must be lowercase and use [a-z0-9_]`);
+        errors.push(`subgraphs.${alias} alias must be lowercase and use [a-z0-9_]`);
     }
     if (workspaces[alias]) {
-        errors.push(`bundle_imports.${alias} must not collide with workspaces.${alias}`);
+        errors.push(`subgraphs.${alias} must not collide with workspaces.${alias}`);
     }
 }
 function requireContainedPath(value, path, errors) {
@@ -216,9 +218,15 @@ function validateConfigSchema(raw) {
     const bundlesRaw = raw.bundles === undefined
         ? { output_dir: ".mdkg/bundles", default_profile: "private" }
         : requireObject(raw.bundles, "bundles", errors);
-    const bundleImportsRaw = raw.bundle_imports === undefined
-        ? {}
-        : requireObject(raw.bundle_imports, "bundle_imports", errors);
+    if (raw.bundle_imports !== undefined && raw.subgraphs !== undefined) {
+        errors.push("config must not define both subgraphs and legacy bundle_imports");
+    }
+    const subgraphsFromLegacyBundleImports = raw.subgraphs === undefined && raw.bundle_imports !== undefined;
+    const subgraphsRaw = raw.subgraphs === undefined
+        ? raw.bundle_imports === undefined
+            ? {}
+            : requireObject(raw.bundle_imports, "bundle_imports", errors)
+        : requireObject(raw.subgraphs, "subgraphs", errors);
     const packRaw = requireObject(raw.pack, "pack", errors);
     const templatesRaw = requireObject(raw.templates, "templates", errors);
     const workRaw = requireObject(raw.work, "work", errors);
@@ -389,48 +397,96 @@ function validateConfigSchema(raw) {
             errors.push('workspaces.root.mdkg_dir must be ".mdkg"');
         }
     }
-    const bundle_imports = {};
-    if (bundleImportsRaw) {
-        for (const [alias, entry] of Object.entries(bundleImportsRaw)) {
-            validateBundleImportAlias(alias, workspaces, errors);
-            const rawImport = requireObject(entry, `bundle_imports.${alias}`, errors);
-            if (!rawImport) {
+    const subgraphs = {};
+    if (subgraphsRaw) {
+        for (const [alias, entry] of Object.entries(subgraphsRaw)) {
+            validateSubgraphAlias(alias, workspaces, errors);
+            const basePath = subgraphsFromLegacyBundleImports ? `bundle_imports.${alias}` : `subgraphs.${alias}`;
+            const rawSubgraph = requireObject(entry, basePath, errors);
+            if (!rawSubgraph) {
                 continue;
             }
-            const importPath = requireContainedPath(rawImport.path, `bundle_imports.${alias}.path`, errors);
-            const enabled = rawImport.enabled === undefined
+            const enabled = rawSubgraph.enabled === undefined
                 ? true
-                : requireBoolean(rawImport.enabled, `bundle_imports.${alias}.enabled`, errors);
-            const visibility = rawImport.visibility === undefined
+                : requireBoolean(rawSubgraph.enabled, `${basePath}.enabled`, errors);
+            const visibility = rawSubgraph.visibility === undefined
                 ? "private"
-                : requireStringInSet(rawImport.visibility, `bundle_imports.${alias}.visibility`, WORKSPACE_VISIBILITY_VALUES, errors);
-            const expectedProfile = rawImport.expected_profile === undefined
-                ? "private"
-                : requireStringInSet(rawImport.expected_profile, `bundle_imports.${alias}.expected_profile`, BUNDLE_PROFILE_VALUES, errors);
-            const sourcePath = rawImport.source_path === undefined
-                ? undefined
-                : requireContainedPath(rawImport.source_path, `bundle_imports.${alias}.source_path`, errors);
-            const sourceRepo = rawImport.source_repo === undefined
+                : requireStringInSet(rawSubgraph.visibility, `${basePath}.visibility`, WORKSPACE_VISIBILITY_VALUES, errors);
+            const permissions = rawSubgraph.permissions === undefined || subgraphsFromLegacyBundleImports
+                ? ["read"]
+                : requireKnownLowercaseUniqueStringArray(rawSubgraph.permissions, `${basePath}.permissions`, SUBGRAPH_PERMISSION_VALUES, errors);
+            const maxStaleSeconds = rawSubgraph.max_stale_seconds === undefined
+                ? DEFAULT_SUBGRAPH_MAX_STALE_SECONDS
+                : requirePositiveInteger(rawSubgraph.max_stale_seconds, `${basePath}.max_stale_seconds`, errors);
+            const sourcePath = rawSubgraph.source_path === undefined
                 ? undefined
-                : requireString(rawImport.source_repo, `bundle_imports.${alias}.source_repo`, errors);
-            const maxStaleSeconds = rawImport.max_stale_seconds === undefined
+                : requireContainedPath(rawSubgraph.source_path, `${basePath}.source_path`, errors);
+            const sourceRepo = rawSubgraph.source_repo === undefined
                 ? undefined
-                : requirePositiveInteger(rawImport.max_stale_seconds, `bundle_imports.${alias}.max_stale_seconds`, errors);
-            if (visibility !== undefined &&
-                expectedProfile !== undefined &&
-                visibility !== "private" &&
-                expectedProfile !== "public") {
-                errors.push(`bundle_imports.${alias}.expected_profile must be public when visibility is ${visibility}`);
+                : requireString(rawSubgraph.source_repo, `${basePath}.source_repo`, errors);
+            const rawSources = subgraphsFromLegacyBundleImports
+                ? [{ path: rawSubgraph.path, enabled: true, expected_profile: rawSubgraph.expected_profile }]
+                : rawSubgraph.sources;
+            if (!Array.isArray(rawSources)) {
+                errors.push(`${basePath}.sources must be an array`);
+                continue;
+            }
+            if (rawSources.length === 0) {
+                errors.push(`${basePath}.sources must not be empty`);
+                continue;
+            }
+            const sources = [];
+            const labels = new Set();
+            for (let i = 0; i < rawSources.length; i += 1) {
+                const sourceBasePath = `${basePath}.sources[${i}]`;
+                const rawSource = requireObject(rawSources[i], sourceBasePath, errors);
+                if (!rawSource) {
+                    continue;
+                }
+                const sourceBundlePath = requireContainedPath(rawSource.path, `${sourceBasePath}.path`, errors);
+                const sourceEnabled = rawSource.enabled === undefined
+                    ? true
+                    : requireBoolean(rawSource.enabled, `${sourceBasePath}.enabled`, errors);
+                const expectedProfile = rawSource.expected_profile === undefined
+                    ? "private"
+                    : requireStringInSet(rawSource.expected_profile, `${sourceBasePath}.expected_profile`, BUNDLE_PROFILE_VALUES, errors);
+                const label = rawSource.label === undefined
+                    ? undefined
+                    : requireString(rawSource.label, `${sourceBasePath}.label`, errors);
+                if (label !== undefined) {
+                    if (label.trim().length === 0) {
+                        errors.push(`${sourceBasePath}.label must not be empty`);
+                    }
+                    if (labels.has(label)) {
+                        errors.push(`${basePath}.sources label must be unique: ${label}`);
+                    }
+                    labels.add(label);
+                }
+                if (visibility !== undefined &&
+                    expectedProfile !== undefined &&
+                    sourceEnabled !== false &&
+                    visibility !== "private" &&
+                    expectedProfile !== "public") {
+                    errors.push(`${sourceBasePath}.expected_profile must be public when ${basePath}.visibility is ${visibility}`);
+                }
+                if (sourceBundlePath && sourceEnabled !== undefined && expectedProfile) {
+                    sources.push({
+                        path: sourceBundlePath,
+                        enabled: sourceEnabled,
+                        expected_profile: expectedProfile,
+                        ...(label ? { label } : {}),
+                    });
+                }
             }
-            if (importPath && enabled !== undefined && visibility && expectedProfile) {
-                bundle_imports[alias] = {
-                    path: importPath,
+            if (enabled !== undefined && visibility && permissions && maxStaleSeconds !== undefined && sources.length > 0) {
+                subgraphs[alias] = {
                     enabled,
                     visibility: visibility,
-                    expected_profile: expectedProfile,
+                    permissions,
+                    max_stale_seconds: maxStaleSeconds,
                     ...(sourcePath ? { source_path: sourcePath } : {}),
                     ...(sourceRepo ? { source_repo: sourceRepo } : {}),
-                    ...(maxStaleSeconds !== undefined ? { max_stale_seconds: maxStaleSeconds } : {}),
+                    sources,
                 };
             }
         }
@@ -446,7 +502,7 @@ function validateConfigSchema(raw) {
         index: index,
         capabilities: capabilities,
         bundles: bundles,
-        bundle_imports,
+        subgraphs,
         pack: pack,
         templates: templates,
         work: work,

package/dist/graph/frontmatter.js

@@ -10,6 +10,14 @@ exports.DEFAULT_FRONTMATTER_KEY_ORDER = [
     "title",
     "status",
     "priority",
+    "goal_state",
+    "goal_condition",
+    "scope_refs",
+    "active_node",
+    "required_skills",
+    "required_checks",
+    "max_iterations",
+    "blocked_after_attempts",
     "epic",
     "parent",
     "prev",

package/dist/graph/goal_scope.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GOAL_SCOPE_ALLOWED_TYPES = exports.GOAL_SCOPE_ACTIONABLE_TYPES = exports.GOAL_SCOPE_CONTAINER_TYPES = void 0;
+exports.goalScopeRefs = goalScopeRefs;
+exports.collectGoalScope = collectGoalScope;
+const qid_1 = require("../util/qid");
+exports.GOAL_SCOPE_CONTAINER_TYPES = new Set(["epic", "feat"]);
+exports.GOAL_SCOPE_ACTIONABLE_TYPES = new Set(["feat", "task", "bug", "test"]);
+exports.GOAL_SCOPE_ALLOWED_TYPES = new Set([
+    ...exports.GOAL_SCOPE_CONTAINER_TYPES,
+    ...exports.GOAL_SCOPE_ACTIONABLE_TYPES,
+]);
+function toStringList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string");
+}
+function goalScopeRefs(goal) {
+    return toStringList(goal.attributes.scope_refs);
+}
+function resolveGoalScopeRef(index, value, ws) {
+    const resolved = (0, qid_1.resolveQid)(index, value, ws);
+    return resolved.status === "ok" ? resolved.qid : undefined;
+}
+function addIfPresent(values, value) {
+    if (value) {
+        values.add(value);
+    }
+}
+function collectDirectCompatibilityRefs(index, goal) {
+    const qids = new Set();
+    const edges = goal.edges;
+    addIfPresent(qids, edges.next);
+    addIfPresent(qids, edges.prev);
+    addIfPresent(qids, edges.parent);
+    addIfPresent(qids, edges.epic);
+    for (const value of edges.relates) {
+        qids.add(value);
+    }
+    for (const value of edges.blocks) {
+        qids.add(value);
+    }
+    for (const value of edges.blocked_by) {
+        qids.add(value);
+    }
+    for (const node of Object.values(index.nodes)) {
+        if (node.edges.parent === goal.qid ||
+            node.edges.epic === goal.qid ||
+            node.edges.prev === goal.qid ||
+            node.edges.next === goal.qid ||
+            node.edges.relates.includes(goal.qid) ||
+            node.edges.blocked_by.includes(goal.qid) ||
+            node.edges.blocks.includes(goal.qid)) {
+            qids.add(node.qid);
+        }
+    }
+    return qids;
+}
+function descendantQids(index, qid) {
+    const byEpic = index.reverse_edges.epic?.[qid] ?? [];
+    const byParent = index.reverse_edges.parent?.[qid] ?? [];
+    return [...new Set([...byEpic, ...byParent])].sort();
+}
+function collectGoalScope(index, goal, options = {}) {
+    const includeCompatibilityRefs = options.includeCompatibilityRefs ?? true;
+    const rootQids = [];
+    const qids = new Set();
+    const actionableQids = new Set();
+    const missingRefs = [];
+    const invalidRefs = [];
+    const queued = new Set();
+    const queue = [];
+    function enqueue(qid) {
+        if (queued.has(qid)) {
+            return;
+        }
+        queued.add(qid);
+        queue.push(qid);
+    }
+    for (const ref of goalScopeRefs(goal)) {
+        const resolved = resolveGoalScopeRef(index, ref, goal.ws);
+        if (!resolved) {
+            missingRefs.push(ref);
+            continue;
+        }
+        rootQids.push(resolved);
+        enqueue(resolved);
+    }
+    if (includeCompatibilityRefs) {
+        for (const qid of collectDirectCompatibilityRefs(index, goal)) {
+            rootQids.push(qid);
+            enqueue(qid);
+        }
+    }
+    while (queue.length > 0) {
+        const qid = queue.shift();
+        if (!qid) {
+            break;
+        }
+        const node = index.nodes[qid];
+        if (!node) {
+            continue;
+        }
+        if (!exports.GOAL_SCOPE_ALLOWED_TYPES.has(node.type)) {
+            invalidRefs.push(qid);
+            continue;
+        }
+        qids.add(qid);
+        if (exports.GOAL_SCOPE_ACTIONABLE_TYPES.has(node.type)) {
+            actionableQids.add(qid);
+        }
+        if (exports.GOAL_SCOPE_CONTAINER_TYPES.has(node.type)) {
+            for (const childQid of descendantQids(index, qid)) {
+                enqueue(childQid);
+            }
+        }
+    }
+    rootQids.sort();
+    return {
+        rootQids: [...new Set(rootQids)],
+        qids,
+        actionableQids,
+        missingRefs,
+        invalidRefs: [...new Set(invalidRefs)].sort(),
+    };
+}

package/dist/graph/index_cache.js

@@ -11,7 +11,7 @@ const sort_1 = require("../util/sort");
 const atomic_1 = require("../util/atomic");
 const indexer_1 = require("./indexer");
 const staleness_1 = require("./staleness");
-const bundle_imports_1 = require("./bundle_imports");
+const subgraphs_1 = require("./subgraphs");
 function readIndex(indexPath) {
     try {
         const raw = fs_1.default.readFileSync(indexPath, "utf8");
@@ -32,36 +32,36 @@ function loadIndex(options) {
     const tolerant = options.tolerant ?? options.config.index.tolerant;
     const includeImports = options.includeImports ?? true;
     const indexPath = path_1.default.resolve(options.root, options.config.index.global_index_path);
-    const withImports = (index, rebuilt, stale) => {
-        if (!includeImports || Object.keys(options.config.bundle_imports).length === 0) {
+    const withSubgraphs = (index, rebuilt, stale) => {
+        if (!includeImports || Object.keys(options.config.subgraphs).length === 0) {
             return { index, rebuilt, stale, warnings: [] };
         }
-        const imports = (0, bundle_imports_1.buildBundleImportsIndex)(options.root, options.config);
+        const subgraphs = (0, subgraphs_1.buildSubgraphsIndex)(options.root, options.config);
         if (allowReindex) {
-            (0, bundle_imports_1.writeBundleImportsIndex)((0, bundle_imports_1.resolveBundleImportsIndexPath)(options.root), imports.index);
+            (0, subgraphs_1.writeSubgraphsIndex)((0, subgraphs_1.resolveSubgraphsIndexPath)(options.root), subgraphs.index);
         }
         return {
-            index: (0, bundle_imports_1.mergeBundleImportsIntoIndex)(index, imports),
+            index: (0, subgraphs_1.mergeSubgraphsIntoIndex)(index, subgraphs),
             rebuilt,
-            stale: stale || (0, bundle_imports_1.isBundleImportsIndexStale)(options.root, options.config),
-            warnings: (0, bundle_imports_1.importWarnings)(imports),
+            stale: stale || (0, subgraphs_1.isSubgraphsIndexStale)(options.root, options.config),
+            warnings: (0, subgraphs_1.subgraphWarnings)(subgraphs),
         };
     };
     if (!useCache) {
         const index = (0, indexer_1.buildIndex)(options.root, options.config, { tolerant });
-        return withImports(index, true, false);
+        return withSubgraphs(index, true, false);
     }
     const stale = (0, staleness_1.isIndexStale)(options.root, options.config);
     if (fs_1.default.existsSync(indexPath) && !stale) {
-        return withImports(readIndex(indexPath), false, false);
+        return withSubgraphs(readIndex(indexPath), false, false);
     }
     if (allowReindex) {
         const index = (0, indexer_1.buildIndex)(options.root, options.config, { tolerant });
         writeIndex(indexPath, index);
-        return withImports(index, true, stale);
+        return withSubgraphs(index, true, stale);
     }
     if (fs_1.default.existsSync(indexPath)) {
-        return withImports(readIndex(indexPath), false, true);
+        return withSubgraphs(readIndex(indexPath), false, true);
     }
     throw new Error("index missing and auto-reindex is disabled");
 }

package/dist/graph/indexer.js

@@ -143,7 +143,7 @@ function buildIndex(root, config, options = {}) {
     };
     (0, validate_graph_1.validateGraph)(index, {
         allowMissing: tolerant,
-        externalWorkspaces: new Set(Object.keys(config.bundle_imports ?? {})),
+        externalWorkspaces: new Set(Object.keys(config.subgraphs ?? {})),
     });
     const latestCheckpointByWorkspace = {};
     for (const alias of workspaceAliases) {

package/dist/graph/node.js

@@ -10,7 +10,7 @@ const id_1 = require("../util/id");
 const refs_1 = require("../util/refs");
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 const DEC_ID_RE = /^dec-[0-9]+$/;
-exports.WORK_TYPES = new Set(["epic", "feat", "task", "bug", "checkpoint", "test"]);
+exports.WORK_TYPES = new Set(["goal", "epic", "feat", "task", "bug", "checkpoint", "test"]);
 exports.DEC_TYPES = new Set(["dec"]);
 exports.ALLOWED_TYPES = new Set([
     "rule",
@@ -18,6 +18,7 @@ exports.ALLOWED_TYPES = new Set([
     "edd",
     "dec",
     "prop",
+    "goal",
     "epic",
     "feat",
     "task",
@@ -28,7 +29,18 @@ exports.ALLOWED_TYPES = new Set([
     ...agent_file_types_1.AGENT_FILE_TYPES,
 ]);
 const DEC_STATUS = new Set(["proposed", "accepted", "rejected", "superseded"]);
+const GOAL_STATE = new Set(["active", "paused", "achieved", "blocked", "budget_limited"]);
 const SKILL_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const GOAL_ATTRIBUTE_KEYS = [
+    "goal_state",
+    "goal_condition",
+    "scope_refs",
+    "active_node",
+    "required_skills",
+    "required_checks",
+    "max_iterations",
+    "blocked_after_attempts",
+];
 function formatError(filePath, message) {
     return new Error(`${filePath}: ${message}`);
 }
@@ -142,6 +154,71 @@ function normalizeSkillList(values, filePath) {
         return normalized;
     });
 }
+function parsePositiveIntegerString(value, key, filePath) {
+    if (!/^[1-9][0-9]*$/.test(value)) {
+        throw formatError(filePath, `${key} must be a positive integer`);
+    }
+    return value;
+}
+function validateGoalFrontmatter(type, frontmatter, filePath) {
+    if (type !== "goal") {
+        return;
+    }
+    const goalState = requireLowercase(expectString(frontmatter, "goal_state", filePath), "goal_state", filePath);
+    if (!GOAL_STATE.has(goalState)) {
+        throw formatError(filePath, `goal_state must be one of ${Array.from(GOAL_STATE).join(", ")}`);
+    }
+    const goalCondition = expectString(frontmatter, "goal_condition", filePath);
+    if (goalCondition.length > 4000) {
+        throw formatError(filePath, "goal_condition must be 4000 characters or fewer");
+    }
+    const activeNode = optionalString(frontmatter, "active_node", filePath);
+    if (activeNode !== undefined) {
+        const normalized = requireLowercase(activeNode, "active_node", filePath);
+        if (!(0, id_1.isPortableIdRef)(normalized)) {
+            throw formatError(filePath, "active_node must be a local id or qid");
+        }
+    }
+    const scopeRefs = optionalList(frontmatter, "scope_refs", filePath);
+    for (const [index, value] of scopeRefs.entries()) {
+        if (typeof value !== "string" || value.trim().length === 0) {
+            throw formatError(filePath, `scope_refs[${index}] must not be empty`);
+        }
+        const normalized = requireLowercase(value, `scope_refs[${index}]`, filePath);
+        if (!(0, id_1.isPortableIdRef)(normalized)) {
+            throw formatError(filePath, `scope_refs[${index}] must be a local id or qid`);
+        }
+    }
+    const requiredSkills = optionalList(frontmatter, "required_skills", filePath);
+    normalizeSkillList(requiredSkills, filePath);
+    const requiredChecks = optionalList(frontmatter, "required_checks", filePath);
+    for (const [index, value] of requiredChecks.entries()) {
+        if (typeof value !== "string" || value.trim().length === 0) {
+            throw formatError(filePath, `required_checks[${index}] must not be empty`);
+        }
+    }
+    const maxIterations = optionalString(frontmatter, "max_iterations", filePath);
+    if (maxIterations !== undefined) {
+        parsePositiveIntegerString(maxIterations, "max_iterations", filePath);
+    }
+    const blockedAfterAttempts = optionalString(frontmatter, "blocked_after_attempts", filePath);
+    if (blockedAfterAttempts !== undefined) {
+        parsePositiveIntegerString(blockedAfterAttempts, "blocked_after_attempts", filePath);
+    }
+}
+function extractGoalAttributes(type, frontmatter) {
+    if (type !== "goal") {
+        return {};
+    }
+    const attributes = {};
+    for (const key of GOAL_ATTRIBUTE_KEYS) {
+        const value = frontmatter[key];
+        if (value !== undefined) {
+            attributes[key] = value;
+        }
+    }
+    return attributes;
+}
 function requireTemplateSchema(type, templateSchemas, filePath) {
     const schema = templateSchemas[type];
     if (!schema) {
@@ -185,6 +262,7 @@ function parseNode(content, filePath, options) {
     validateTemplateKeys(frontmatter, schema, filePath);
     (0, agent_file_types_1.validateAgentFrontmatter)(type, frontmatter, filePath);
     (0, archive_file_1.validateArchiveFrontmatter)(type, frontmatter, filePath);
+    validateGoalFrontmatter(type, frontmatter, filePath);
     const idValue = requireLowercase(expectString(frontmatter, "id", filePath), "id", filePath);
     const id = isPortableType
         ? requirePortableIdFormat(idValue, "id", filePath)
@@ -250,6 +328,7 @@ function parseNode(content, filePath, options) {
     }
     const edges = (0, edges_1.extractEdges)(frontmatter, filePath, { allowPortableRefs: isPortableType });
     const attributes = {
+        ...extractGoalAttributes(type, frontmatter),
         ...(0, agent_file_types_1.extractAgentAttributes)(type, frontmatter),
         ...(0, archive_file_1.extractArchiveAttributes)(type, frontmatter),
     };

package/dist/graph/reindex.js

@@ -7,7 +7,7 @@ exports.writeDerivedIndexes = writeDerivedIndexes;
 const path_1 = __importDefault(require("path"));
 const capabilities_indexer_1 = require("./capabilities_indexer");
 const capabilities_index_cache_1 = require("./capabilities_index_cache");
-const bundle_imports_1 = require("./bundle_imports");
+const subgraphs_1 = require("./subgraphs");
 const indexer_1 = require("./indexer");
 const index_cache_1 = require("./index_cache");
 const skills_index_cache_1 = require("./skills_index_cache");
@@ -17,20 +17,20 @@ function writeDerivedIndexes(root, config, nodeIndex, options) {
     const nextNodeIndex = nodeIndex ?? (0, indexer_1.buildIndex)(root, config, { tolerant: options?.tolerant ?? config.index.tolerant });
     const skillsIndex = (0, skills_indexer_1.buildSkillsIndex)(root, config);
     const capabilitiesIndex = (0, capabilities_indexer_1.buildCapabilitiesIndex)(root, config, nextNodeIndex);
-    const importsIndex = (0, bundle_imports_1.buildBundleImportsIndex)(root, config);
+    const subgraphsIndex = (0, subgraphs_1.buildSubgraphsIndex)(root, config);
     const nodesOutputPath = path_1.default.resolve(root, config.index.global_index_path);
     const skillsOutputPath = (0, skills_indexer_1.resolveSkillsIndexPath)(root);
     const capabilitiesOutputPath = (0, capabilities_indexer_1.resolveCapabilitiesIndexPath)(root, config);
-    const importsOutputPath = (0, bundle_imports_1.resolveBundleImportsIndexPath)(root);
+    const subgraphsOutputPath = (0, subgraphs_1.resolveSubgraphsIndexPath)(root);
     (0, index_cache_1.writeIndex)(nodesOutputPath, nextNodeIndex);
     (0, skills_index_cache_1.writeSkillsIndex)(skillsOutputPath, skillsIndex);
     (0, capabilities_index_cache_1.writeCapabilitiesIndex)(capabilitiesOutputPath, capabilitiesIndex);
-    (0, bundle_imports_1.writeBundleImportsIndex)(importsOutputPath, importsIndex.index);
+    (0, subgraphs_1.writeSubgraphsIndex)(subgraphsOutputPath, subgraphsIndex.index);
     const paths = {
         nodes: nodesOutputPath,
         skills: skillsOutputPath,
         capabilities: capabilitiesOutputPath,
-        imports: importsOutputPath,
+        subgraphs: subgraphsOutputPath,
     };
     if ((0, sqlite_index_1.isSqliteBackend)(config)) {
         paths.sqlite = (0, sqlite_index_1.writeSqliteIndex)({
@@ -39,7 +39,7 @@ function writeDerivedIndexes(root, config, nodeIndex, options) {
             nodeIndex: nextNodeIndex,
             skillsIndex,
             capabilitiesIndex,
-            importsIndex: importsIndex.index,
+            subgraphsIndex: subgraphsIndex.index,
         });
     }
     return { nodeIndex: nextNodeIndex, paths };

package/dist/graph/sqlite_index.js

@@ -13,7 +13,7 @@ const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const staleness_1 = require("./staleness");
-exports.SQLITE_SCHEMA_VERSION = 1;
+exports.SQLITE_SCHEMA_VERSION = 2;
 function loadDatabaseCtor() {
     try {
         const loaded = require("node:sqlite");
@@ -112,7 +112,7 @@ function createSchema(db) {
       compressed_sha256 TEXT,
       json TEXT NOT NULL
     );
-    CREATE TABLE bundle_imports (
+    CREATE TABLE subgraphs (
       alias TEXT PRIMARY KEY,
       enabled INTEGER NOT NULL,
       stale INTEGER NOT NULL,
@@ -149,7 +149,7 @@ function buildSourceFingerprint(options) {
         })),
         skills: Object.values(options.skillsIndex.skills).sort((a, b) => a.qid.localeCompare(b.qid)),
         capabilities: options.capabilitiesIndex.records,
-        imports: options.importsIndex.imports,
+        subgraphs: options.subgraphsIndex.subgraphs,
     };
     return `sha256:${crypto_1.default.createHash("sha256").update(stableCacheJson(payload)).digest("hex")}`;
 }
@@ -208,9 +208,9 @@ function writeSqliteIndex(options) {
         for (const node of Object.values(options.nodeIndex.nodes).filter((item) => item.type === "archive")) {
             insertArchive.run(node.qid, String(node.attributes.visibility ?? "private"), String(node.attributes.compressed_path ?? ""), String(node.attributes.compressed_sha256 ?? ""), stableCacheJson(node));
         }
-        const insertImport = db.prepare("INSERT INTO bundle_imports (alias, enabled, stale, error_count, warning_count, json) VALUES (?, ?, ?, ?, ?, ?)");
-        for (const item of options.importsIndex.imports) {
-            insertImport.run(item.alias, item.enabled ? 1 : 0, item.stale ? 1 : 0, item.error_count, item.warning_count, stableCacheJson(item));
+        const insertSubgraph = db.prepare("INSERT INTO subgraphs (alias, enabled, stale, error_count, warning_count, json) VALUES (?, ?, ?, ?, ?, ?)");
+        for (const item of options.subgraphsIndex.subgraphs) {
+            insertSubgraph.run(item.alias, item.enabled ? 1 : 0, item.stale ? 1 : 0, item.error_count, item.warning_count, stableCacheJson(item));
         }
     }
     finally {