@planu/cli 4.10.12 → 4.11.1

package/dist/engine/project-graph/cache.js

@@ -1,10 +1,29 @@
-// @crash-shield-ignore-file — graph artifacts are Planu-owned JSON written by this subsystem.
+/* eslint-disable max-lines -- cache validation, collection, and freshness share one artifact contract. */
+// @crash-shield-ignore-file - graph artifacts are Planu-owned JSON written by this subsystem.
 import { createHash } from 'node:crypto';
-import { readdir, readFile, stat } from 'node:fs/promises';
-import { dirname, join, relative, resolve } from 'node:path';
+import { open, readdir, readFile, stat } from 'node:fs/promises';
+import { dirname, extname, join, relative, resolve } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
 import { fileURLToPath } from 'node:url';
 import { projectDataDir, readJson, writeJson } from '../../storage/base-store.js';
+import { LockBusyError, withSpecLock } from '../safety/cross-process-lock.js';
 const POLICY_PATH = join(dirname(fileURLToPath(import.meta.url)), '../../config/project-knowledge-graph.json');
+const CACHE_VERSION = 2;
+const PROJECT_CODE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.json', '.md']);
+const PROJECT_CODE_IGNORED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    'target',
+    'npm',
+]);
+const CONTENT_HASH_PATTERN = /^[a-f0-9]{64}$/;
+const PROJECT_GRAPH_LOCK_WAIT_MS = 30_000;
+const buildTails = new Map();
+const activeBuilds = new Map();
 export async function loadProjectGraphPolicy() {
     const raw = await readFile(POLICY_PATH, 'utf-8');
     return JSON.parse(raw);
@@ -12,6 +31,9 @@ export async function loadProjectGraphPolicy() {
 export function hashText(text) {
     return createHash('sha256').update(text, 'utf8').digest('hex');
 }
+export function projectGraphExtractorVersion(kind) {
+    return `project-graph-${kind}-v2`;
+}
 export function projectGraphDir(projectId, policy) {
     return join(projectDataDir(projectId), policy.artifactPaths.directory);
 }
@@ -21,44 +43,282 @@ export function projectGraphPath(projectId, policy) {
 export function projectGraphCachePath(projectId, policy) {
     return join(projectGraphDir(projectId, policy), policy.artifactPaths.sourceHashes);
 }
-export async function readProjectGraph(projectId, policy) {
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isCacheRecord(value) {
+    if (!isObject(value)) {
+        return false;
+    }
+    return (typeof value.sourceId === 'string' &&
+        typeof value.path === 'string' &&
+        typeof value.kind === 'string' &&
+        typeof value.contentHash === 'string' &&
+        CONTENT_HASH_PATTERN.test(value.contentHash) &&
+        typeof value.extractorVersion === 'string' &&
+        typeof value.nativeCoreVersion === 'string' &&
+        typeof value.size === 'number' &&
+        Number.isFinite(value.size) &&
+        typeof value.mtimeMs === 'number' &&
+        Number.isFinite(value.mtimeMs));
+}
+function isCacheFragment(value) {
+    if (!isObject(value)) {
+        return false;
+    }
+    return (value.version === 1 &&
+        typeof value.sourceId === 'string' &&
+        typeof value.kind === 'string' &&
+        typeof value.contentHash === 'string' &&
+        CONTENT_HASH_PATTERN.test(value.contentHash) &&
+        typeof value.extractorVersion === 'string' &&
+        typeof value.nativeCoreVersion === 'string' &&
+        Array.isArray(value.nodes) &&
+        value.nodes.every((node) => isObject(node) && typeof node.id === 'string' && typeof node.type === 'string') &&
+        Array.isArray(value.edges) &&
+        value.edges.every((edge) => isObject(edge) &&
+            typeof edge.id === 'string' &&
+            typeof edge.from === 'string' &&
+            typeof edge.to === 'string' &&
+            typeof edge.type === 'string'));
+}
+function kindFromLegacySourceId(sourceId) {
+    if (sourceId.startsWith('spec:')) {
+        return 'spec';
+    }
+    if (sourceId.startsWith('handoff:')) {
+        return 'handoff';
+    }
+    if (sourceId.startsWith('project-code:')) {
+        return 'project-code';
+    }
+    if (sourceId === 'decisions') {
+        return 'decisions';
+    }
+    if (sourceId === 'release-events') {
+        return 'release-events';
+    }
+    return sourceId;
+}
+function legacyRecords(raw) {
+    const records = {};
+    for (const [sourceId, value] of Object.entries(raw)) {
+        const objectValue = isObject(value) ? value : {};
+        const contentHash = typeof value === 'string'
+            ? value
+            : typeof objectValue.contentHash === 'string'
+                ? objectValue.contentHash
+                : '';
+        records[sourceId] = {
+            sourceId,
+            path: typeof objectValue.path === 'string' ? objectValue.path : sourceId,
+            kind: typeof objectValue.kind === 'string' ? objectValue.kind : kindFromLegacySourceId(sourceId),
+            contentHash,
+            extractorVersion: 'legacy',
+            nativeCoreVersion: 'legacy',
+            size: -1,
+            mtimeMs: -1,
+        };
+    }
+    return records;
+}
+export async function readProjectGraphCache(projectId, policy) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(projectGraphCachePath(projectId, policy), 'utf-8'));
+    }
+    catch {
+        return { cache: null, knownSourceIds: [], legacy: false };
+    }
+    if (!isObject(parsed)) {
+        return { cache: null, knownSourceIds: [], legacy: false };
+    }
+    if (parsed.version !== CACHE_VERSION) {
+        const records = legacyRecords(parsed);
+        return {
+            cache: {
+                version: CACHE_VERSION,
+                generation: '',
+                records,
+                fragments: {},
+            },
+            knownSourceIds: Object.keys(parsed),
+            legacy: true,
+        };
+    }
+    const rawRecords = isObject(parsed.records) ? parsed.records : {};
+    const rawFragments = isObject(parsed.fragments) ? parsed.fragments : {};
+    const records = Object.fromEntries(Object.entries(rawRecords).filter((entry) => isCacheRecord(entry[1])));
+    const fragments = Object.fromEntries(Object.entries(rawFragments).filter((entry) => isCacheFragment(entry[1])));
+    return {
+        cache: {
+            version: CACHE_VERSION,
+            generation: typeof parsed.generation === 'string' ? parsed.generation : '',
+            records,
+            fragments,
+        },
+        knownSourceIds: Object.keys(rawRecords),
+        legacy: false,
+    };
+}
+export async function readProjectGraphArtifact(projectId, policy) {
     return readJson(projectGraphPath(projectId, policy), null);
 }
+export async function readProjectGraph(projectId, policy) {
+    const key = projectGraphDir(projectId, policy);
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        const active = activeBuilds.get(key);
+        if (active !== undefined) {
+            await active;
+        }
+        const [graph, cacheResult] = await Promise.all([
+            readProjectGraphArtifact(projectId, policy),
+            readProjectGraphCache(projectId, policy),
+        ]);
+        if (graph === null) {
+            return null;
+        }
+        if (typeof graph.generation === 'string' &&
+            graph.generation.length > 0 &&
+            cacheResult.cache?.generation === graph.generation) {
+            return graph;
+        }
+        if (!activeBuilds.has(key)) {
+            return null;
+        }
+    }
+    return null;
+}
 export async function writeProjectGraph(projectId, policy, graph) {
     await writeJson(projectGraphPath(projectId, policy), graph);
 }
 export async function readProjectGraphSourceHashes(projectId, policy) {
-    return readJson(projectGraphCachePath(projectId, policy), {});
+    const active = activeBuilds.get(projectGraphDir(projectId, policy));
+    if (active !== undefined) {
+        await active;
+    }
+    return (await readProjectGraphCache(projectId, policy)).cache?.records ?? {};
 }
 export async function writeProjectGraphSourceHashes(projectId, policy, hashes) {
-    await writeJson(projectGraphCachePath(projectId, policy), hashes);
+    const current = await readProjectGraphCache(projectId, policy);
+    await writeJson(projectGraphCachePath(projectId, policy), {
+        version: CACHE_VERSION,
+        generation: current.cache?.generation ?? '',
+        records: hashes,
+        fragments: current.cache?.fragments ?? {},
+    });
 }
-export function diffSourceHashes(sources, previous) {
+export async function writeProjectGraphArtifacts(args) {
+    if (args.graph.generation.length === 0 ||
+        args.cache.generation.length === 0 ||
+        args.graph.generation !== args.cache.generation) {
+        throw new Error('[Planu] Project graph/cache generation mismatch');
+    }
+    // Readers verify the shared generation, so neither write order can expose a mixed snapshot.
+    await writeJson(projectGraphCachePath(args.projectId, args.policy), args.cache);
+    await writeJson(projectGraphPath(args.projectId, args.policy), args.graph);
+}
+export async function withProjectGraphBuildLock(projectId, policy, task) {
+    const key = projectGraphDir(projectId, policy);
+    const previous = buildTails.get(key) ?? Promise.resolve();
+    let release;
+    const slot = new Promise((resolveSlot) => {
+        release = resolveSlot;
+    });
+    const tail = previous.then(() => slot);
+    buildTails.set(key, tail);
+    await previous;
+    activeBuilds.set(key, slot);
+    try {
+        const startedAt = Date.now();
+        for (;;) {
+            try {
+                return await withSpecLock(key, 'PROJECT-GRAPH-BUILD', async () => task(), {
+                    reason: `project graph build for ${projectId}`,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof LockBusyError) ||
+                    Date.now() - startedAt >= PROJECT_GRAPH_LOCK_WAIT_MS) {
+                    throw error;
+                }
+                await delay(25);
+            }
+        }
+    }
+    finally {
+        if (activeBuilds.get(key) === slot) {
+            activeBuilds.delete(key);
+        }
+        release?.();
+        if (buildTails.get(key) === tail) {
+            buildTails.delete(key);
+        }
+    }
+}
+function nativeVersionForSource(kind, nativeCoreVersion) {
+    return kind === 'project-code' ? (nativeCoreVersion ?? 'typescript-fallback') : 'not-applicable';
+}
+function recordMatchesSource(record, source, nativeCoreVersion) {
+    return (record?.sourceId === source.id &&
+        record.path === source.path &&
+        record.kind === source.kind &&
+        record.contentHash === source.hash &&
+        record.extractorVersion === projectGraphExtractorVersion(source.kind) &&
+        (source.kind !== 'project-code' ||
+            nativeCoreVersion === undefined ||
+            record.nativeCoreVersion === nativeCoreVersion));
+}
+function fragmentMatchesSource(fragment, source, nativeCoreVersion) {
+    return (fragment?.sourceId === source.id &&
+        fragment.kind === source.kind &&
+        fragment.contentHash === source.hash &&
+        fragment.extractorVersion === projectGraphExtractorVersion(source.kind) &&
+        (source.kind !== 'project-code' ||
+            nativeCoreVersion === undefined ||
+            fragment.nativeCoreVersion === nativeCoreVersion));
+}
+export function diffSourceHashes(sources, previous, nativeCoreVersion, options = {}) {
     const next = Object.fromEntries(sources.map((source) => [source.id, source.hash]));
-    const changed = sources
-        .filter((source) => previous[source.id] !== source.hash)
-        .map((source) => source.id);
-    const skipped = sources
-        .filter((source) => previous[source.id] === source.hash)
-        .map((source) => source.id);
-    return { changed, skipped, next };
+    const records = Object.fromEntries(sources.map((source) => [
+        source.id,
+        {
+            sourceId: source.id,
+            path: source.path,
+            kind: source.kind,
+            contentHash: source.hash,
+            extractorVersion: projectGraphExtractorVersion(source.kind),
+            nativeCoreVersion: nativeVersionForSource(source.kind, nativeCoreVersion),
+            size: source.size ?? Buffer.byteLength(source.content),
+            mtimeMs: source.mtimeMs ?? 0,
+        },
+    ]));
+    const canReuse = (source) => recordMatchesSource(previous[source.id], source, nativeCoreVersion) &&
+        (options.fragments === undefined ||
+            fragmentMatchesSource(options.fragments[source.id], source, nativeCoreVersion));
+    const changed = sources.filter((source) => !canReuse(source)).map((source) => source.id);
+    const skipped = sources.filter(canReuse).map((source) => source.id);
+    const currentIds = new Set(sources.map((source) => source.id));
+    const removed = [...new Set(options.knownSourceIds ?? Object.keys(previous))]
+        .filter((sourceId) => !currentIds.has(sourceId))
+        .sort();
+    return { changed, removed, skipped, next, records };
 }
 async function fileExists(path) {
     try {
-        const info = await stat(path);
-        return info.isFile();
+        return (await stat(path)).isFile();
     }
     catch {
         return false;
     }
 }
-async function collectFiles(dir, predicate) {
+async function collectFiles(dir, predicate, descend = () => true) {
     try {
-        const entries = await readdir(dir, { withFileTypes: true });
+        const entries = (await readdir(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
         const nested = await Promise.all(entries.map(async (entry) => {
             const path = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                return collectFiles(path, predicate);
+            if (entry.isDirectory() && descend(entry.name)) {
+                return collectFiles(path, predicate, descend);
             }
             return entry.isFile() && predicate(path) ? [path] : [];
         }));
@@ -68,46 +328,160 @@ async function collectFiles(dir, predicate) {
         return [];
     }
 }
+async function readBoundedFile(descriptor, path, maxFileBytes) {
+    const info = await descriptor.stat();
+    if (info.size > maxFileBytes) {
+        throw new Error(`PROJECT_GRAPH_FILE_TOO_LARGE: ${path} exceeds maxFileBytes (${String(maxFileBytes)})`);
+    }
+    const chunks = [];
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    let total = 0;
+    for (;;) {
+        const { bytesRead } = await descriptor.read(buffer, 0, buffer.length, null);
+        if (bytesRead === 0) {
+            break;
+        }
+        total += bytesRead;
+        if (total > maxFileBytes) {
+            throw new Error(`PROJECT_GRAPH_FILE_TOO_LARGE: ${path} grew beyond maxFileBytes (${String(maxFileBytes)})`);
+        }
+        chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
+    }
+    return {
+        content: Buffer.concat(chunks, total).toString('utf8'),
+        size: total,
+        mtimeMs: info.mtimeMs,
+    };
+}
 async function sourceFromFile(args) {
     try {
-        const content = await readFile(args.path, 'utf-8');
-        return { ...args, content, hash: hashText(content) };
+        const info = await stat(args.filePath);
+        if (!info.isFile()) {
+            return null;
+        }
+        if (info.size > args.maxFileBytes) {
+            throw new Error(`PROJECT_GRAPH_FILE_TOO_LARGE: ${args.path} exceeds maxFileBytes (${String(args.maxFileBytes)})`);
+        }
+        const previous = args.previous;
+        const expectedNativeVersion = nativeVersionForSource(args.kind, args.nativeCoreVersion);
+        if (previous?.path === args.path &&
+            previous.kind === args.kind &&
+            CONTENT_HASH_PATTERN.test(previous.contentHash) &&
+            previous.size === info.size &&
+            previous.mtimeMs === info.mtimeMs &&
+            previous.extractorVersion === projectGraphExtractorVersion(args.kind) &&
+            (args.kind !== 'project-code' ||
+                args.nativeCoreVersion === undefined ||
+                previous.nativeCoreVersion === expectedNativeVersion)) {
+            return {
+                id: args.id,
+                kind: args.kind,
+                path: args.path,
+                content: '',
+                hash: previous.contentHash,
+                size: info.size,
+                mtimeMs: info.mtimeMs,
+                contentLoaded: false,
+            };
+        }
+        const descriptor = await open(args.filePath, 'r');
+        let bounded;
+        try {
+            bounded = await readBoundedFile(descriptor, args.path, args.maxFileBytes);
+        }
+        finally {
+            await descriptor.close();
+        }
+        return {
+            id: args.id,
+            kind: args.kind,
+            path: args.path,
+            content: bounded.content,
+            hash: hashText(bounded.content),
+            size: bounded.size,
+            mtimeMs: bounded.mtimeMs,
+            contentLoaded: true,
+        };
     }
-    catch {
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('PROJECT_GRAPH_')) {
+            throw error;
+        }
         return null;
     }
 }
+export async function hydrateProjectGraphSource(source, maxFileBytes) {
+    if (source.contentLoaded !== false || source.kind === 'project-code') {
+        return source;
+    }
+    return sourceFromFile({
+        id: source.id,
+        kind: source.kind,
+        path: source.path,
+        filePath: source.path,
+        maxFileBytes,
+    });
+}
+// eslint-disable-next-line max-lines-per-function -- source inventory is normalized in one deterministic pass.
 export async function collectProjectGraphSources(args) {
     const projectRoot = resolve(args.projectPath);
     const dataRoot = projectDataDir(args.projectId);
     const specFiles = await collectFiles(join(projectRoot, 'planu', 'specs'), (path) => path.endsWith('/spec.md'));
     const handoffFiles = await collectFiles(join(dataRoot, 'handoffs'), (path) => /\.(json|md)$/.test(path));
-    const validationFiles = handoffFiles.filter((path) => path.includes('validation'));
+    const validationFiles = new Set(handoffFiles.filter((path) => path.includes('validation')));
     const decisions = join(dataRoot, 'decisions.json');
     const transitionLog = join(dataRoot, 'transition-log.jsonl');
     const releaseEvents = join(dataRoot, '..', '..', 'release-events.jsonl');
+    const maxFiles = args.policy.limits.operational.maxFiles;
+    const maxFileBytes = args.policy.limits.operational.maxFileBytes;
+    const codeFiles = (await collectFiles(projectRoot, (path) => PROJECT_CODE_EXTENSIONS.has(extname(path).toLowerCase()), (name) => !PROJECT_CODE_IGNORED_DIRS.has(name) && !name.startsWith('.'))).slice(0, maxFiles);
     const raw = [
         ...specFiles.map((path) => ({
             id: `spec:${relative(projectRoot, path)}`,
             kind: 'spec',
             path,
+            filePath: path,
         })),
         ...handoffFiles.map((path) => ({
             id: `handoff:${relative(dataRoot, path)}`,
-            kind: validationFiles.includes(path) ? 'validation' : 'handoff',
+            kind: validationFiles.has(path) ? 'validation' : 'handoff',
             path,
+            filePath: path,
         })),
         ...((await fileExists(transitionLog))
-            ? [{ id: 'transition-log', kind: 'transition-log', path: transitionLog }]
+            ? [
+                {
+                    id: 'transition-log',
+                    kind: 'transition-log',
+                    path: transitionLog,
+                    filePath: transitionLog,
+                },
+            ]
             : []),
         ...((await fileExists(decisions))
-            ? [{ id: 'decisions', kind: 'decisions', path: decisions }]
+            ? [{ id: 'decisions', kind: 'decisions', path: decisions, filePath: decisions }]
             : []),
         ...((await fileExists(releaseEvents))
-            ? [{ id: 'release-events', kind: 'release-events', path: releaseEvents }]
+            ? [
+                {
+                    id: 'release-events',
+                    kind: 'release-events',
+                    path: releaseEvents,
+                    filePath: releaseEvents,
+                },
+            ]
             : []),
-    ];
-    const sources = await Promise.all(raw.map((source) => sourceFromFile(source)));
+        ...codeFiles.map((filePath) => {
+            const path = relative(projectRoot, filePath).split('\\').join('/');
+            return { id: `project-code:${path}`, kind: 'project-code', path, filePath };
+        }),
+    ].sort((a, b) => a.id.localeCompare(b.id));
+    const sources = await Promise.all(raw.map((source) => sourceFromFile({
+        ...source,
+        previous: args.previous?.[source.id],
+        nativeCoreVersion: args.nativeCoreVersion,
+        maxFileBytes,
+    })));
     return sources.filter((source) => source !== null);
 }
 export async function getProjectGraphFreshness(args) {
@@ -134,14 +508,19 @@ export async function getProjectGraphFreshness(args) {
             };
         }
     }
+    const cacheResult = await readProjectGraphCache(args.projectId, policy);
+    const previous = cacheResult.cache?.records ?? {};
     const sources = await collectProjectGraphSources({
         projectId: args.projectId,
         projectPath: args.projectPath,
         policy,
+        previous,
+    });
+    const diff = diffSourceHashes(sources, previous, undefined, {
+        fragments: cacheResult.cache?.fragments,
+        knownSourceIds: cacheResult.knownSourceIds,
     });
-    const changedSources = sources
-        .filter((source) => graph.sourceHashes[source.id] !== source.hash)
-        .map((source) => source.id);
+    const changedSources = [...diff.changed, ...diff.removed];
     if (changedSources.length > 0) {
         return {
             exists: true,

package/dist/engine/project-graph/index.d.ts

@@ -1,5 +1,6 @@
 export { buildProjectKnowledgeGraph } from './builder.js';
 export { queryProjectGraphSlice, formatProjectGraphContext, getProjectGraphFreshnessHint, } from './query.js';
 export { redactGraphText } from './redaction.js';
+export { createNativeProjectGraphRuntime } from './native.js';
 export { getProjectGraphFreshness, loadProjectGraphPolicy, projectGraphPath, projectGraphCachePath, } from './cache.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/engine/project-graph/index.js

@@ -1,5 +1,6 @@
 export { buildProjectKnowledgeGraph } from './builder.js';
 export { queryProjectGraphSlice, formatProjectGraphContext, getProjectGraphFreshnessHint, } from './query.js';
 export { redactGraphText } from './redaction.js';
+export { createNativeProjectGraphRuntime } from './native.js';
 export { getProjectGraphFreshness, loadProjectGraphPolicy, projectGraphPath, projectGraphCachePath, } from './cache.js';
 //# sourceMappingURL=index.js.map

package/dist/engine/project-graph/native.d.ts

@@ -0,0 +1,3 @@
+import type { NativeProjectGraphRuntime, ProjectGraphPolicy } from '../../types/project-knowledge-graph.js';
+export declare function createNativeProjectGraphRuntime(limitsPolicy: ProjectGraphPolicy['limits']): NativeProjectGraphRuntime;
+//# sourceMappingURL=native.d.ts.map

package/dist/engine/project-graph/native.js

@@ -0,0 +1,36 @@
+import { fastExtractTsRelations, fastQueryAffectedNodes, fastQueryShortestPath, fastScanProjectGraphSources, fastSelectCompactGraphSlice, isNativeActive, } from '../core-bridge.js';
+function toNativeNodes(nodes) {
+    return nodes.map((node) => ({ id: node.id }));
+}
+function toNativeEdges(edges) {
+    return edges.map((edge) => ({
+        id: edge.id,
+        from: edge.from,
+        to: edge.to,
+        relation: edge.type,
+    }));
+}
+export function createNativeProjectGraphRuntime(limitsPolicy) {
+    return {
+        nativeActive: isNativeActive(),
+        scanSources(projectPath, maxFiles) {
+            return fastScanProjectGraphSources(projectPath, limitsPolicy, maxFiles === undefined ? {} : { maxFiles });
+        },
+        extractTypeScriptRelations(projectPath, paths = [], maxFiles) {
+            return fastExtractTsRelations(projectPath, paths, limitsPolicy, maxFiles === undefined ? {} : { maxFiles });
+        },
+        affectedNodes(seed, edges, depth, relationFilter = []) {
+            return fastQueryAffectedNodes(seed, toNativeEdges(edges), relationFilter, limitsPolicy, depth === undefined ? {} : { maxDepth: depth });
+        },
+        shortestPath(from, to, edges, relationFilter = []) {
+            return fastQueryShortestPath(from, to, toNativeEdges(edges), relationFilter, limitsPolicy);
+        },
+        compactSlice(seeds, nodes, edges, maxNodes, maxEdges) {
+            return fastSelectCompactGraphSlice(seeds, toNativeNodes(nodes), toNativeEdges(edges), limitsPolicy, {
+                ...(maxNodes === undefined ? {} : { maxNodes }),
+                ...(maxEdges === undefined ? {} : { maxEdges }),
+            });
+        },
+    };
+}
+//# sourceMappingURL=native.js.map

package/dist/engine/project-graph/query.js

@@ -1,6 +1,7 @@
 import { hashProjectPath } from '../../storage/base-store.js';
 import { buildProjectKnowledgeGraph } from './builder.js';
 import { getProjectGraphFreshness, loadProjectGraphPolicy, readProjectGraph } from './cache.js';
+import { createNativeProjectGraphRuntime } from './native.js';
 import { escapeInert, redactGraphText } from './redaction.js';
 function sanitizeLabel(label, policy) {
     return escapeInert(redactGraphText(label, policy));
@@ -44,6 +45,8 @@ function summarize(nodes) {
         risks: count('risk'),
         tools: count('tool'),
         releases: count('release'),
+        symbols: count('symbol'),
+        toolHandlers: count('tool_handler'),
     };
 }
 export async function queryProjectGraphSlice(input) {
@@ -74,10 +77,27 @@ export async function queryProjectGraphSlice(input) {
     const maxNodes = input.maxNodes ?? policy.query.maxNodes;
     const maxEdges = input.maxEdges ?? policy.query.maxEdges;
     const ids = relatedNodeIds(graph.nodes, graph.edges, input);
-    const nodes = graph.nodes.filter((node) => ids.has(node.id)).slice(0, maxNodes);
+    const runtime = createNativeProjectGraphRuntime(policy.limits);
+    const candidateNodes = graph.nodes
+        .filter((node) => ids.has(node.id))
+        .sort((left, right) => left.id.localeCompare(right.id))
+        .slice(0, policy.limits.hard.maxNodes);
+    const candidateNodeIds = new Set(candidateNodes.map((node) => node.id));
+    const candidateEdges = graph.edges
+        .filter((edge) => candidateNodeIds.has(edge.from) && candidateNodeIds.has(edge.to))
+        .sort((left, right) => left.id.localeCompare(right.id))
+        .slice(0, policy.limits.hard.maxEdges);
+    const candidateSeeds = [...ids]
+        .filter((id) => candidateNodeIds.has(id))
+        .sort((left, right) => left.localeCompare(right));
+    const sliceIds = runtime.compactSlice(candidateSeeds, candidateNodes, candidateEdges, maxNodes, maxEdges);
+    const compactIds = sliceIds.nodeIds.length > 0 ? new Set(sliceIds.nodeIds) : ids;
+    const nodes = graph.nodes.filter((node) => compactIds.has(node.id)).slice(0, maxNodes);
     const nodeIds = new Set(nodes.map((node) => node.id));
     const edges = graph.edges
-        .filter((edge) => nodeIds.has(edge.from) && nodeIds.has(edge.to))
+        .filter((edge) => nodeIds.has(edge.from) &&
+        nodeIds.has(edge.to) &&
+        (sliceIds.edgeIds.length === 0 || sliceIds.edgeIds.includes(edge.id)))
         .slice(0, maxEdges);
     return {
         graphVersion: graph.graphVersion,
@@ -107,6 +127,9 @@ export async function formatProjectGraphContext(slice) {
     const risks = listByType(slice, 'risk', policy);
     const specs = listByType(slice, 'spec', policy);
     const tools = listByType(slice, 'tool', policy);
+    const symbols = listByType(slice, 'symbol', policy);
+    const toolHandlers = listByType(slice, 'tool_handler', policy);
+    const confidences = [...new Set(slice.edges.map((edge) => edge.classification))].slice(0, policy.query.maxListItems);
     const lines = ['## Graph Context', ''];
     lines.push(`Freshness: ${slice.freshness.stale ? `stale (${slice.freshness.reason})` : 'fresh'}; compact slice: ${String(slice.nodes.length)} nodes / ${String(slice.edges.length)} edges.`);
     if (files.length > 0) {
@@ -127,6 +150,15 @@ export async function formatProjectGraphContext(slice) {
     if (tools.length > 0) {
         lines.push(`Tools: ${tools.join(', ')}`);
     }
+    if (toolHandlers.length > 0) {
+        lines.push(`Tool handlers: ${toolHandlers.join(', ')}`);
+    }
+    if (symbols.length > 0) {
+        lines.push(`Symbols: ${symbols.join(', ')}`);
+    }
+    if (confidences.length > 0) {
+        lines.push(`Confidence labels: ${confidences.join(', ')}`);
+    }
     lines.push('');
     return lines.join('\n');
 }