@contorium/mcp 0.8.1

package/node_modules/@contora/state-core/dist/understanding/knowledgeGraph/knowledgeGraphBuilder.js

@@ -0,0 +1,415 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProjectKnowledgeGraph = buildProjectKnowledgeGraph;
+const intentFunctionMapper_js_1 = require("./intentFunctionMapper.js");
+const normalize_js_1 = require("./normalize.js");
+const hotspotBuilder_js_1 = require("./hotspotBuilder.js");
+const snapshotBuilder_js_1 = require("./snapshotBuilder.js");
+const confidence_js_1 = require("./confidence.js");
+const MAX_INTENTS = 6;
+const MAX_FUNCTIONS = 80;
+function norm(p) {
+    return p.replace(/\\/g, '/');
+}
+function basename(p) {
+    const parts = norm(p).split('/').filter(Boolean);
+    return parts[parts.length - 1] ?? p;
+}
+function moduleFromPath(file) {
+    const parts = norm(file).split('/').filter(Boolean);
+    if (parts.length <= 1) {
+        return parts[0] ?? 'root';
+    }
+    if (parts[0] === 'packages' && parts[1]) {
+        return parts[1];
+    }
+    if (parts[0] === 'src' && parts[1]) {
+        return parts[1];
+    }
+    return parts[0];
+}
+function intentId(name, idx) {
+    return `intent_${idx}_${name.slice(0, 24).replace(/\W+/g, '_')}`;
+}
+function moduleId(name) {
+    return `mod::${name}`;
+}
+function fileId(file) {
+    return `file::${norm(file)}`;
+}
+function fnNodeId(file, name, kind) {
+    return `${norm(file)}::${kind}::${name}`;
+}
+function collectIntents(args) {
+    const out = [];
+    const seen = new Set();
+    const add = (text) => {
+        const t = text.trim();
+        if (t.length < 4 || seen.has(t.toLowerCase())) {
+            return;
+        }
+        seen.add(t.toLowerCase());
+        out.push({ id: intentId(t, out.length), text: t });
+    };
+    if (args.goal) {
+        add(args.goal);
+    }
+    const focusBase = args.intent.focus.split('—')[0]?.trim() ?? args.intent.focus;
+    if (focusBase && focusBase.toLowerCase() !== args.goal.toLowerCase()) {
+        add(focusBase);
+    }
+    for (const mod of args.built?.active_modules ?? []) {
+        const label = mod.includes('/') ? basename(mod) : mod;
+        if (/doc|mcp|auth|ui|test|build/i.test(label) || label.length > 3) {
+            add(`${label} integration`.replace(/ integration integration/, ' integration'));
+        }
+    }
+    for (const action of args.built?.next_actions ?? []) {
+        if (/documentation|mcp|auth|build|test/i.test(action)) {
+            add(action);
+        }
+    }
+    return out.slice(0, MAX_INTENTS);
+}
+function edgeConfidence(type, weight) {
+    if (type === 'supports_intent') {
+        return weight;
+    }
+    if (type === 'calls') {
+        return 0.8;
+    }
+    return 0.95;
+}
+function mappingByFn(mappings) {
+    const out = new Map();
+    for (const m of mappings) {
+        const prev = out.get(m.functionId);
+        if (!prev || prev.score < m.score) {
+            out.set(m.functionId, m);
+        }
+    }
+    return out;
+}
+function buildIntentTrees(intents, nodes, edges, mappings) {
+    const nodeById = new Map(nodes.map((n) => [n.id, n]));
+    const childrenOf = (id, type) => edges
+        .filter((e) => e.source === id && (!type || e.type === type))
+        .sort((a, b) => b.weight - a.weight)
+        .map((e) => e.target);
+    const fnToIntent = new Map();
+    const confidenceByFn = mappingByFn(mappings);
+    for (const m of mappings) {
+        if (!fnToIntent.has(m.functionId) || (mappings.find((x) => x.functionId === m.functionId)?.score ?? 0) < m.score) {
+            fnToIntent.set(m.functionId, m.intentId);
+        }
+    }
+    const trees = [];
+    for (const intent of intents) {
+        const intentModules = childrenOf(intent.id, 'supports_intent');
+        const modChildren = [];
+        for (const modNodeId of intentModules) {
+            const modNode = nodeById.get(modNodeId);
+            if (!modNode) {
+                continue;
+            }
+            const fileNodes = childrenOf(modNodeId, 'contains');
+            const fileChildren = [];
+            for (const fId of fileNodes) {
+                const fNode = nodeById.get(fId);
+                if (!fNode || fNode.type !== 'file') {
+                    continue;
+                }
+                const fnIds = childrenOf(fId, 'contains').filter((id) => {
+                    const n = nodeById.get(id);
+                    return n && (n.type === 'function' || n.type === 'class') && fnToIntent.get(id) === intent.id;
+                });
+                const fnChildren = fnIds.slice(0, 8).map((id) => {
+                    const n = nodeById.get(id);
+                    const map = confidenceByFn.get(id);
+                    const callIds = childrenOf(id, 'calls').slice(0, 6);
+                    return {
+                        id: n.id,
+                        type: n.type,
+                        name: n.name + (n.type === 'function' ? '()' : ''),
+                        path: n.path,
+                        confidence: map?.confidence,
+                        children: callIds.map((cid) => {
+                            const c = nodeById.get(cid);
+                            return {
+                                id: c.id,
+                                type: c.type,
+                                name: c.name + (c.type === 'function' ? '()' : ''),
+                                path: c.path,
+                                children: [],
+                            };
+                        }),
+                    };
+                });
+                if (fnChildren.length) {
+                    fileChildren.push({
+                        id: fNode.id,
+                        type: 'file',
+                        name: basename(fNode.path ?? fNode.name),
+                        path: fNode.path,
+                        children: fnChildren,
+                    });
+                }
+            }
+            if (fileChildren.length) {
+                modChildren.push({
+                    id: modNode.id,
+                    type: 'module',
+                    name: modNode.name,
+                    children: fileChildren,
+                });
+            }
+        }
+        if (modChildren.length) {
+            trees.push({
+                id: intent.id,
+                type: 'intent',
+                name: intent.text,
+                expanded: trees.length === 0,
+                children: modChildren,
+            });
+        }
+    }
+    return trees;
+}
+function buildReasonTraces(functions, mappings, edges, editCounts, intentById) {
+    const intentForFn = new Map();
+    for (const m of mappings) {
+        const prev = intentForFn.get(m.functionId);
+        if (!prev || prev.score < m.score) {
+            intentForFn.set(m.functionId, m);
+        }
+    }
+    const depCount = (fnId) => edges.filter((e) => e.source === fnId && e.type === 'calls').length +
+        edges.filter((e) => e.target === fnId && e.type === 'calls').length;
+    const out = [];
+    for (const fn of functions) {
+        const edits = editCounts.get(norm(fn.file)) ?? 0;
+        const deps = depCount(fn.id);
+        const map = intentForFn.get(fn.id);
+        const reasons = [];
+        if (edits >= 3) {
+            reasons.push(`edited ${edits} times in recent activity`);
+        }
+        else if (edits > 0) {
+            reasons.push('recently edited file');
+        }
+        if (map) {
+            reasons.push(`linked to active intent (confidence ${Math.round(map.confidence * 100)}%)`);
+            if (map.signals.length) {
+                reasons.push(map.signals.join(', '));
+            }
+        }
+        if (deps >= 4) {
+            reasons.push(`high dependency count (${deps})`);
+        }
+        if (!reasons.length) {
+            continue;
+        }
+        const intent = map ? intentById.get(map.intentId) : undefined;
+        out.push({
+            targetId: fn.id,
+            targetName: fn.name,
+            targetType: 'function',
+            reasons,
+            editCount: edits,
+            dependencyCount: deps,
+            linkedIntent: intent?.text,
+            confidence: map?.confidence,
+        });
+    }
+    return out
+        .sort((a, b) => b.editCount - a.editCount || b.dependencyCount - a.dependencyCount)
+        .slice(0, 10);
+}
+/**
+ * Build Project Knowledge Graph from L1/L2 sources only.
+ * L3 (intelligence / intent-graph / AI speculation) must never feed this builder.
+ */
+function buildProjectKnowledgeGraph(input) {
+    const now = input.now ?? Date.now();
+    const editCounts = input.editCounts ?? new Map();
+    for (const f of input.change.changed_files) {
+        const k = norm(f);
+        editCounts.set(k, (editCounts.get(k) ?? 0) + 1);
+    }
+    const intents = collectIntents(input);
+    const intentById = new Map(intents.map((i) => [i.id, i]));
+    const nodes = [];
+    const edges = [];
+    const moduleSet = new Set();
+    for (const intent of intents) {
+        nodes.push({
+            id: intent.id,
+            type: 'intent',
+            name: intent.text,
+            updatedAt: now,
+        });
+    }
+    for (const n of input.graph.nodes) {
+        if (n.kind === 'module') {
+            const mod = moduleFromPath(n.file);
+            moduleSet.add(mod);
+        }
+    }
+    for (const f of input.change.changed_files) {
+        moduleSet.add(moduleFromPath(f));
+    }
+    for (const mod of input.built?.active_modules ?? []) {
+        moduleSet.add(basename(mod) || mod);
+    }
+    for (const mod of moduleSet) {
+        nodes.push({
+            id: moduleId(mod),
+            type: 'module',
+            name: mod,
+            path: mod,
+            updatedAt: now,
+        });
+    }
+    const fileNodes = new Set();
+    const functions = [];
+    for (const n of input.graph.nodes) {
+        if (n.kind === 'module') {
+            const fid = fileId(n.file);
+            if (!fileNodes.has(fid)) {
+                fileNodes.add(fid);
+                nodes.push({
+                    id: fid,
+                    type: 'file',
+                    name: basename(n.file),
+                    path: norm(n.file),
+                    updatedAt: now,
+                });
+            }
+            const mod = moduleId(moduleFromPath(n.file));
+            edges.push({
+                source: mod,
+                target: fid,
+                type: 'contains',
+                weight: 1,
+                confidence: edgeConfidence('contains', 1),
+            });
+        }
+        if (n.kind === 'function' || n.kind === 'class') {
+            const fid = fileId(n.file);
+            if (!fileNodes.has(fid)) {
+                fileNodes.add(fid);
+                nodes.push({
+                    id: fid,
+                    type: 'file',
+                    name: basename(n.file),
+                    path: norm(n.file),
+                    updatedAt: now,
+                });
+                const mod = moduleId(moduleFromPath(n.file));
+                edges.push({
+                    source: mod,
+                    target: fid,
+                    type: 'contains',
+                    weight: 1,
+                    confidence: edgeConfidence('contains', 1),
+                });
+            }
+            nodes.push({
+                id: n.id,
+                type: n.kind,
+                name: n.name,
+                path: norm(n.file),
+                metadata: n.line ? { line: n.line } : undefined,
+                updatedAt: now,
+            });
+            edges.push({
+                source: fid,
+                target: n.id,
+                type: 'contains',
+                weight: 1,
+                confidence: edgeConfidence('contains', 1),
+            });
+            if (n.kind === 'function') {
+                const callTargets = input.graph.edges
+                    .filter((e) => e.from === n.id && e.kind === 'calls')
+                    .map((e) => input.graph.nodes.find((x) => x.id === e.to)?.name)
+                    .filter((x) => !!x);
+                functions.push({
+                    id: n.id,
+                    name: n.name,
+                    file: norm(n.file),
+                    moduleHint: moduleFromPath(n.file),
+                    callTargets,
+                });
+            }
+        }
+    }
+    for (const e of input.graph.edges) {
+        if (e.kind === 'calls') {
+            edges.push({
+                source: e.from,
+                target: e.to,
+                type: 'calls',
+                weight: 0.8,
+                confidence: edgeConfidence('calls', 0.8),
+            });
+        }
+    }
+    const ctx = {
+        recentEditFiles: new Set(input.change.changed_files.map(norm)),
+        gitFrequency: input.gitFrequency,
+    };
+    const rawMappings = (0, intentFunctionMapper_js_1.mapIntentsToFunctions)(intents, functions.slice(0, MAX_FUNCTIONS), ctx);
+    const { canonical: intentMappings, inference: inferenceMappings } = (0, confidence_js_1.splitMappingsByCanonicalThreshold)(rawMappings);
+    for (const m of intentMappings) {
+        const fn = functions.find((f) => f.id === m.functionId);
+        if (!fn) {
+            continue;
+        }
+        const mod = moduleId(fn.moduleHint ?? moduleFromPath(fn.file));
+        edges.push({
+            source: m.intentId,
+            target: mod,
+            type: 'supports_intent',
+            weight: m.score,
+            confidence: m.confidence,
+        });
+    }
+    const canonicalEdges = (0, confidence_js_1.filterCanonicalEdges)(edges);
+    const reasonTraces = buildReasonTraces(functions, [...intentMappings, ...inferenceMappings], canonicalEdges, editCounts, intentById);
+    const intentTrees = buildIntentTrees(intents, nodes, canonicalEdges, intentMappings);
+    const hotspots = (0, hotspotBuilder_js_1.buildHotspots)({
+        nodes,
+        edges: canonicalEdges,
+        intentMappings,
+        editCounts,
+        gitFrequency: input.gitFrequency ?? new Map(),
+        now,
+    });
+    const snapshot = (0, snapshotBuilder_js_1.buildKnowledgeSnapshot)({
+        nodes,
+        edges: canonicalEdges,
+        intentMappings,
+        hotspots,
+        nextActions: input.built?.next_actions ?? [],
+        now,
+    });
+    return {
+        meta: (0, normalize_js_1.buildGraphMetadata)({
+            workspaceRoot: input.workspaceRoot ?? 'unknown',
+            now,
+            sourceVersion: input.sourceVersion,
+            rebuildTrigger: input.rebuildTrigger,
+            lastCommitHash: input.lastCommitHash,
+        }),
+        nodes,
+        edges: canonicalEdges,
+        intentMappings,
+        inferenceMappings,
+        reasonTraces,
+        intentTrees,
+        hotspots,
+        snapshot,
+    };
+}

package/node_modules/@contora/state-core/dist/understanding/knowledgeGraph/normalize.d.ts

@@ -0,0 +1,11 @@
+import { type GraphMetadata, type ProjectKnowledgeGraph } from './types.js';
+export declare function buildGraphMetadata(args: {
+    workspaceRoot: string;
+    now: number;
+    sourceVersion?: string;
+    rebuildTrigger?: string;
+    lastCommitHash?: string;
+}): GraphMetadata;
+/** schemaVersion switch — upgrade legacy graphs on read. */
+export declare function normalizeKnowledgeGraph(raw: unknown, workspaceRoot?: string): ProjectKnowledgeGraph | undefined;
+//# sourceMappingURL=normalize.d.ts.map

package/node_modules/@contora/state-core/dist/understanding/knowledgeGraph/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/understanding/knowledgeGraph/normalize.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,aAAa,EAIlB,KAAK,qBAAqB,EAC3B,MAAM,YAAY,CAAC;AAgBpB,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,aAAa,CAYhB;AAgBD,4DAA4D;AAC5D,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,OAAO,EACZ,aAAa,CAAC,EAAE,MAAM,GACrB,qBAAqB,GAAG,SAAS,CAuCnC"}

package/node_modules/@contora/state-core/dist/understanding/knowledgeGraph/normalize.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGraphMetadata = buildGraphMetadata;
+exports.normalizeKnowledgeGraph = normalizeKnowledgeGraph;
+const types_js_1 = require("./types.js");
+const version_js_1 = require("../../version.js");
+const snapshotBuilder_js_1 = require("./snapshotBuilder.js");
+const hotspotBuilder_js_1 = require("./hotspotBuilder.js");
+const closureConstants_js_1 = require("./closureConstants.js");
+const confidence_js_1 = require("./confidence.js");
+function workspaceIdFromRoot(root) {
+    let h = 0;
+    const s = root.replace(/\\/g, '/');
+    for (let i = 0; i < s.length; i++) {
+        h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+    }
+    return Math.abs(h).toString(16).slice(0, 12);
+}
+function buildGraphMetadata(args) {
+    return {
+        version: types_js_1.KNOWLEDGE_ENGINE_VERSION,
+        schemaVersion: types_js_1.KNOWLEDGE_SCHEMA_VERSION,
+        closureVersion: closureConstants_js_1.CLOSURE_VERSION,
+        generatedAt: args.now,
+        workspaceId: workspaceIdFromRoot(args.workspaceRoot),
+        graphBuildId: `graph_${args.now.toString(36)}`,
+        sourceVersion: args.sourceVersion ?? (0, version_js_1.getContoriumPackageVersion)(),
+        rebuildTrigger: args.rebuildTrigger,
+        lastCommitHash: args.lastCommitHash,
+    };
+}
+function withEdgeConfidence(edges) {
+    return edges.map((e) => ({
+        ...e,
+        confidence: e.confidence ?? (e.type === 'supports_intent' ? e.weight : 0.85),
+    }));
+}
+function withMappingConfidence(mappings) {
+    return mappings.map((m) => ({
+        ...m,
+        confidence: m.confidence ?? m.score,
+    }));
+}
+/** schemaVersion switch — upgrade legacy graphs on read. */
+function normalizeKnowledgeGraph(raw, workspaceRoot) {
+    if (!raw || typeof raw !== 'object') {
+        return undefined;
+    }
+    const r = raw;
+    if (r.meta && typeof r.meta === 'object') {
+        const kg = raw;
+        const schema = (kg.meta.schemaVersion ?? types_js_1.KNOWLEDGE_SCHEMA_VERSION).toString();
+        if (schema !== types_js_1.KNOWLEDGE_SCHEMA_VERSION) {
+            return upgradeSchema(kg, workspaceRoot);
+        }
+        return {
+            ...kg,
+            edges: (0, confidence_js_1.filterCanonicalEdges)(withEdgeConfidence(kg.edges ?? [])),
+            intentMappings: withMappingConfidence(kg.intentMappings ?? []),
+            inferenceMappings: kg.inferenceMappings ?? [],
+            hotspots: (kg.hotspots ?? []).map((h) => ({
+                ...h,
+                lifecycle: h.lifecycle ?? 'active',
+            })),
+            snapshot: kg.snapshot ??
+                (0, snapshotBuilder_js_1.buildKnowledgeSnapshot)({
+                    nodes: kg.nodes,
+                    edges: kg.edges,
+                    intentMappings: kg.intentMappings,
+                    hotspots: kg.hotspots ?? [],
+                    nextActions: [],
+                    now: kg.meta.generatedAt,
+                }),
+        };
+    }
+    if (r.version === 1) {
+        return migrateLegacyV1(raw, workspaceRoot);
+    }
+    return undefined;
+}
+function upgradeSchema(kg, workspaceRoot) {
+    return normalizeKnowledgeGraph({
+        ...kg,
+        meta: { ...kg.meta, schemaVersion: types_js_1.KNOWLEDGE_SCHEMA_VERSION },
+    }, workspaceRoot);
+}
+function migrateLegacyV1(legacy, workspaceRoot) {
+    const edges = (legacy.edges ?? []).map((e) => ({
+        source: e.source,
+        target: e.target,
+        type: e.type,
+        weight: e.weight,
+        confidence: e.confidence ?? (e.type === 'supports_intent' ? e.weight : 0.85),
+    }));
+    const intentMappings = (legacy.intentMappings ?? []).map((m) => ({
+        intentId: m.intentId,
+        functionId: m.functionId,
+        score: m.score,
+        confidence: m.confidence ?? m.score,
+        signals: m.signals,
+    }));
+    const { canonical, inference } = (0, confidence_js_1.splitMappingsByCanonicalThreshold)(intentMappings);
+    const partial = {
+        nodes: legacy.nodes ?? [],
+        edges: (0, confidence_js_1.filterCanonicalEdges)(edges),
+        intentMappings: canonical,
+        inferenceMappings: inference,
+        reasonTraces: legacy.reasonTraces ?? [],
+        intentTrees: legacy.intentTrees ?? [],
+    };
+    const hotspots = (0, hotspotBuilder_js_1.buildHotspots)({
+        nodes: partial.nodes,
+        edges: partial.edges,
+        intentMappings: partial.intentMappings,
+        editCounts: new Map(),
+        gitFrequency: new Map(),
+        now: legacy.generatedAt,
+    });
+    const snapshot = (0, snapshotBuilder_js_1.buildKnowledgeSnapshot)({
+        nodes: partial.nodes,
+        edges: partial.edges,
+        intentMappings: partial.intentMappings,
+        hotspots,
+        nextActions: [],
+        now: legacy.generatedAt,
+    });
+    return {
+        meta: buildGraphMetadata({
+            workspaceRoot: workspaceRoot ?? 'unknown',
+            now: legacy.generatedAt,
+        }),
+        ...partial,
+        hotspots,
+        snapshot,
+    };
+}

package/node_modules/@contora/state-core/dist/understanding/knowledgeGraph/rebuildTrigger.d.ts

@@ -0,0 +1,13 @@
+export type KnowledgeRebuildTrigger = 'git_commit' | 'file_batch' | 'intent_change' | 'idle' | 'initial' | 'change';
+export interface RebuildTriggerInput {
+    changedFileCount: number;
+    intentChanged: boolean;
+    lastBuildAt?: number;
+    now: number;
+    hasNewCommit?: boolean;
+    isInitial?: boolean;
+}
+/** When to rebuild knowledge.json (Closure §9.3). */
+export declare function resolveKnowledgeRebuildTrigger(input: RebuildTriggerInput): KnowledgeRebuildTrigger;
+export declare function shouldRebuildKnowledgeGraph(input: RebuildTriggerInput): boolean;
+//# sourceMappingURL=rebuildTrigger.d.ts.map

package/node_modules/@contora/state-core/dist/understanding/knowledgeGraph/rebuildTrigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebuildTrigger.d.ts","sourceRoot":"","sources":["../../../src/understanding/knowledgeGraph/rebuildTrigger.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,uBAAuB,GAC/B,YAAY,GACZ,YAAY,GACZ,eAAe,GACf,MAAM,GACN,SAAS,GACT,QAAQ,CAAC;AAEb,MAAM,WAAW,mBAAmB;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,qDAAqD;AACrD,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,mBAAmB,GAAG,uBAAuB,CAiBlG;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAS/E"}

package/node_modules/@contora/state-core/dist/understanding/knowledgeGraph/rebuildTrigger.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveKnowledgeRebuildTrigger = resolveKnowledgeRebuildTrigger;
+exports.shouldRebuildKnowledgeGraph = shouldRebuildKnowledgeGraph;
+const closureConstants_js_1 = require("./closureConstants.js");
+/** When to rebuild knowledge.json (Closure §9.3). */
+function resolveKnowledgeRebuildTrigger(input) {
+    if (input.isInitial) {
+        return 'initial';
+    }
+    if (input.hasNewCommit) {
+        return 'git_commit';
+    }
+    if (input.changedFileCount >= closureConstants_js_1.REBUILD_FILE_THRESHOLD) {
+        return 'file_batch';
+    }
+    if (input.intentChanged) {
+        return 'intent_change';
+    }
+    if (input.lastBuildAt != null && input.now - input.lastBuildAt >= closureConstants_js_1.REBUILD_IDLE_MS) {
+        return 'idle';
+    }
+    return 'change';
+}
+function shouldRebuildKnowledgeGraph(input) {
+    if (input.isInitial || !input.lastBuildAt) {
+        return true;
+    }
+    const trigger = resolveKnowledgeRebuildTrigger(input);
+    if (trigger === 'idle' && input.changedFileCount === 0) {
+        return true;
+    }
+    return input.changedFileCount > 0 || input.intentChanged || !!input.hasNewCommit;
+}

package/node_modules/@contora/state-core/dist/understanding/knowledgeGraph/snapshotBuilder.d.ts

@@ -0,0 +1,17 @@
+import type { HotspotNode, IntentFunctionMapping, KnowledgeEdge, KnowledgeNode, KnowledgeSnapshot } from './types.js';
+export interface SnapshotBuildInput {
+    nodes: KnowledgeNode[];
+    edges: KnowledgeEdge[];
+    intentMappings: IntentFunctionMapping[];
+    hotspots: HotspotNode[];
+    nextActions: string[];
+    now: number;
+}
+/**
+ * Snapshot Layer — compression projection from canonical graph only (Closure §9).
+ * snapshot = compression(graph, weight); never a second truth source.
+ */
+export declare function buildKnowledgeSnapshot(input: SnapshotBuildInput): KnowledgeSnapshot;
+/** Filter graph relations by minimum confidence (MCP / export projection). */
+export declare function filterMappingsByConfidence(mappings: IntentFunctionMapping[], minConfidence: number): IntentFunctionMapping[];
+//# sourceMappingURL=snapshotBuilder.d.ts.map

package/node_modules/@contora/state-core/dist/understanding/knowledgeGraph/snapshotBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotBuilder.d.ts","sourceRoot":"","sources":["../../../src/understanding/knowledgeGraph/snapshotBuilder.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,WAAW,EACX,qBAAqB,EACrB,aAAa,EACb,aAAa,EACb,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,cAAc,EAAE,qBAAqB,EAAE,CAAC;IACxC,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;CACb;AAkBD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,iBAAiB,CAqDnF;AAED,8EAA8E;AAC9E,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,qBAAqB,EAAE,EACjC,aAAa,EAAE,MAAM,GACpB,qBAAqB,EAAE,CAEzB"}