hoi4-agent-tools 2.3.0 → 2.3.3

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 2.3.3 - 2026-07-26
+
+- Regenerated the npm lockfile with the pinned release npm so clean installs include the patched optional native runtime packages.
+
+## 2.3.2 - 2026-07-26
+
+- Pinned patched transitive `brace-expansion` and `postcss` releases so the CI and release audit remain clean without changing the MCP Inspector surface.
+
+## 2.3.1 - 2026-07-26
+
+- Fixed large vanilla-plus-mod technology scans that could consume multiple gigabytes and leave the MCP transport open until a client timeout closed it.
+- Added automatic focused technology analysis for game-backed and large workspaces, retaining direct source evidence and helper-call indexing while deferring workspace-wide scripted-effect projections.
+
 ## 2.3.0 - 2026-07-22
 
 - Added a read-only AI and MTTH Scenario Analyzer with inspect, evaluate, sweep, simulate, sequence, compare, and render tools.

package/dist/bin/stdio.js

@@ -8,6 +8,10 @@ async function main() {
     const engine = await createEngine();
     const context = {};
     const server = createMcpServer(engine, context);
+    if (process.env.HOI4_AGENT_TOOLS_CHAOSX === '1') {
+        const { registerChaosxTools } = await import('../hoi4_agent_tools/mcp/tools/chaosx.js');
+        registerChaosxTools(server, engine, context);
+    }
     server.server.onerror = (error) => {
         const fatalInputError = error instanceof StdioFrameLimitError || error instanceof StdioInvalidUtf8Error;
         const rejectedMessage = error instanceof StdioInvalidMessageError;

package/dist/hoi4_agent_tools/event/algorithms.js

@@ -1,4 +1,4 @@
-import { compareCodeUnits } from '../core/canonical.js';
+import { compareCodeUnits, hashCanonical } from '../core/canonical.js';
 import { EventAnalysisBudget } from './limits.js';
 import { iterativeStronglyConnectedComponents } from './scc.js';
 function sortedUnique(values) {
@@ -41,6 +41,178 @@ function edgeMaps(edges) {
     }
     return { outgoing, incoming };
 }
+function helperName(node) {
+    const name = node.metadata.name;
+    if (typeof name === 'string')
+        return name;
+    return node.label || node.id.replace(/^helper:/u, '');
+}
+function collapsedHelperEdge(path, helperStack, from, to) {
+    const first = path[0];
+    const last = path.at(-1);
+    if (helperStack.length === 0)
+        return first;
+    return {
+        id: `edge:lazy-helper-projection:${hashCanonical({
+            from,
+            to,
+            edges: path.map(({ id }) => id),
+        }).slice(0, 32)}`,
+        from,
+        to,
+        reason: 'scripted_effect_expansion',
+        conditions: path.flatMap(({ conditions }) => conditions),
+        helperStack: [...helperStack],
+        location: first.location,
+        provenance: path.flatMap(({ provenance }) => provenance),
+        confidence: last.confidence,
+        derived: true,
+        ...(last.timing === undefined ? {} : { timing: last.timing }),
+        ...(last.weight === undefined ? {} : { weight: last.weight }),
+        ...(last.scope === undefined ? {} : { scope: last.scope }),
+        metadata: { structuralEdgeIds: path.map(({ id }) => id) },
+    };
+}
+/**
+ * Build only the helper projections reached by one bounded trace. Full-workspace
+ * helper materialisation is useful for broad reports, but it is unnecessarily
+ * expensive when an agent asks for one route in a large installed game.
+ */
+function lazyCollapsedEdges(graph, nodeId, direction, maps, maximumPaths, signal) {
+    const nodes = nodeMap(graph);
+    const retained = new Map();
+    let pathVisits = 0;
+    const add = (edge) => {
+        retained.set(edge.id, edge);
+    };
+    const downstream = (edge, path, stack, visited) => {
+        signal?.throwIfAborted();
+        if (++pathVisits > maximumPaths)
+            return;
+        if (path.length > 64)
+            return;
+        const target = nodes.get(edge.to);
+        if (target?.kind !== 'helper') {
+            add(collapsedHelperEdge(path, stack, nodeId, edge.to));
+            return;
+        }
+        if (visited.has(target.id))
+            return;
+        for (const next of maps.outgoing.get(target.id) ?? []) {
+            downstream(next, [...path, next], [...stack, helperName(target)], new Set([...visited, target.id]));
+        }
+    };
+    const upstream = (edge, path, stack, visited) => {
+        signal?.throwIfAborted();
+        if (++pathVisits > maximumPaths)
+            return;
+        if (path.length > 64)
+            return;
+        const source = nodes.get(edge.from);
+        if (source?.kind !== 'helper') {
+            const forwardPath = [...path].reverse();
+            add(collapsedHelperEdge(forwardPath, [...stack].reverse(), edge.from, nodeId));
+            return;
+        }
+        if (visited.has(source.id))
+            return;
+        for (const previous of maps.incoming.get(source.id) ?? []) {
+            upstream(previous, [...path, previous], [...stack, helperName(source)], new Set([...visited, source.id]));
+        }
+    };
+    if (direction !== 'upstream') {
+        for (const edge of maps.outgoing.get(nodeId) ?? [])
+            downstream(edge, [edge], [], new Set());
+    }
+    if (direction !== 'downstream') {
+        for (const edge of maps.incoming.get(nodeId) ?? [])
+            upstream(edge, [edge], [], new Set());
+    }
+    return [...retained.values()].sort((left, right) => compareCodeUnits(left.id, right.id));
+}
+function traceCollapsedHelpers(graph, starts, boundary, signal) {
+    const byId = nodeMap(graph);
+    const maps = edgeMaps(graph.edges.filter(({ derived }) => !derived));
+    const edgeCache = new Map();
+    const edgesFor = (nodeId) => {
+        const key = `${nodeId}\0${boundary.direction}`;
+        const cached = edgeCache.get(key);
+        if (cached !== undefined)
+            return cached;
+        const edges = lazyCollapsedEdges(graph, nodeId, boundary.direction, maps, Math.max(256, boundary.maxEdges * 2), signal);
+        edgeCache.set(key, edges);
+        return edges;
+    };
+    const depthByNode = new Map(starts.map((id) => [id, 0]));
+    const queue = [...starts];
+    const retainedEdges = new Map();
+    const boundaryNodes = new Set();
+    let truncated = false;
+    let cursor = 0;
+    while (cursor < queue.length) {
+        if ((cursor & 255) === 0)
+            signal?.throwIfAborted();
+        const current = queue[cursor++];
+        const depth = depthByNode.get(current) ?? 0;
+        const nextEdges = edgesFor(current);
+        if (depth >= boundary.maxDepth) {
+            if (nextEdges.length > 0) {
+                boundaryNodes.add(current);
+                truncated = true;
+            }
+            continue;
+        }
+        for (const edge of nextEdges) {
+            if (retainedEdges.size >= boundary.maxEdges) {
+                boundaryNodes.add(current);
+                truncated = true;
+                break;
+            }
+            const next = boundary.direction === 'upstream'
+                ? edge.from
+                : boundary.direction === 'downstream'
+                    ? edge.to
+                    : edge.from === current
+                        ? edge.to
+                        : edge.from;
+            const known = depthByNode.has(next);
+            if (!known && depthByNode.size >= boundary.maxNodes) {
+                boundaryNodes.add(current);
+                truncated = true;
+                continue;
+            }
+            retainedEdges.set(edge.id, edge);
+            if (!known) {
+                depthByNode.set(next, depth + 1);
+                queue.push(next);
+            }
+        }
+    }
+    const retainedNodes = [...depthByNode.keys()]
+        .flatMap((id) => {
+        const node = byId.get(id);
+        return node === undefined ? [] : [node];
+    })
+        .sort((left, right) => compareCodeUnits(left.id, right.id));
+    const layers = [...new Set(depthByNode.values())]
+        .sort((left, right) => left - right)
+        .map((depth) => ({
+        depth,
+        nodeIds: [...depthByNode.entries()]
+            .filter(([, value]) => value === depth)
+            .map(([id]) => id)
+            .sort(compareCodeUnits),
+    }));
+    return {
+        startNodeIds: [...starts],
+        nodes: retainedNodes,
+        edges: [...retainedEdges.values()].sort((left, right) => compareCodeUnits(left.id, right.id)),
+        layers,
+        boundary,
+        boundaryNodeIds: [...boundaryNodes].sort(compareCodeUnits),
+        truncated,
+    };
+}
 function edgesForDirection(nodeId, direction, maps) {
     const results = [];
     if (direction !== 'upstream') {
@@ -58,6 +230,11 @@ export function traceEventGraph(graph, startNodeIds, boundary, signal) {
     const byId = nodeMap(graph);
     const resolvedStarts = sortedUnique(startNodeIds).filter((id) => byId.has(id));
     const starts = resolvedStarts.slice(0, Math.max(0, boundary.maxNodes));
+    if (!boundary.expandHelpers &&
+        !graph.edges.some(({ derived }) => derived) &&
+        starts.every((id) => byId.get(id)?.kind !== 'helper')) {
+        return traceCollapsedHelpers(graph, starts, boundary, signal);
+    }
     const edges = eventFlowEdges(graph, boundary.expandHelpers);
     const maps = edgeMaps(edges);
     const depthByNode = new Map(starts.map((id) => [id, 0]));

package/dist/hoi4_agent_tools/event/graph.js

@@ -29,6 +29,14 @@ function activeFiles(snapshot) {
         !/(?:^|\/)(?:supply_nodes|railways|buildings|unitstacks|weatherpositions)\.txt$/iu.test(relativePath.replaceAll('\\', '/')))
         .sort((left, right) => compareCodeUnits(left.displayPath, right.displayPath));
 }
+const EVENT_SETUP_CALL_PATTERN = /\b(?:country_event|news_event|state_event|unit_leader_event|operative_leader_event|fire_event|event)\s*=/iu;
+function shouldAnalyzeEventFile(file) {
+    const sourcePath = file.relativePath.replaceAll('\\', '/').toLowerCase();
+    if (!sourcePath.startsWith('history/countries/') && !sourcePath.startsWith('history/states/')) {
+        return true;
+    }
+    return EVENT_SETUP_CALL_PATTERN.test(file.bytes.toString('utf8'));
+}
 function catalogFor(snapshot) {
     const unshadowedEventSymbols = snapshot.index
         .findAll('event')
@@ -1444,6 +1452,8 @@ function analyzeFragments(snapshot, files, catalog, options, budget) {
     const fragments = [];
     for (const file of files) {
         budget.spend('source_fragment');
+        if (!shouldAnalyzeEventFile(file))
+            continue;
         if (snapshot.index.isSourceSkipped(file.displayPath))
             continue;
         const cacheKey = eventSemanticFragmentCacheKey(file, catalog.fingerprint);
@@ -1560,14 +1570,17 @@ export function buildEventGraph(snapshot, options = {}) {
     graph.edges = stableUnique(graph.edges);
     graph.stateAccesses = stableUnique(graph.stateAccesses);
     graph.unresolved = stableUnique(graph.unresolved);
-    const stateLinks = stateLinksFor(graph, budget);
-    duplicateAndReferenceIssues(graph);
-    unresolvedIssues(graph);
-    structuralCallIssues(graph, budget);
-    localisationIssues(graph);
-    stateLifecycleIssues(graph, stateLinks, budget);
-    unreachableIssues(graph, budget);
-    normalizeIssueSubjects(graph);
+    const focused = options.analysisMode === 'focused';
+    const stateLinks = focused ? [] : stateLinksFor(graph, budget);
+    if (!focused) {
+        duplicateAndReferenceIssues(graph);
+        unresolvedIssues(graph);
+        structuralCallIssues(graph, budget);
+        localisationIssues(graph);
+        stateLifecycleIssues(graph, stateLinks, budget);
+        unreachableIssues(graph, budget);
+        normalizeIssueSubjects(graph);
+    }
     graph.issues = stableIssues(graph.issues);
     assertGraphLimit(graph.nodes.length, EVENT_GRAPH_MAX_NODES, 'EVENT_NODE_LIMIT', 'node count');
     assertGraphLimit(graph.edges.length, EVENT_GRAPH_MAX_EDGES, 'EVENT_EDGE_LIMIT', 'edge count');
@@ -1577,7 +1590,8 @@ export function buildEventGraph(snapshot, options = {}) {
     assertGraphLimit(graph.unresolved.length, EVENT_GRAPH_MAX_UNRESOLVED, 'EVENT_UNRESOLVED_LIMIT', 'unresolved-analysis count');
     budget.check();
     const diagnostics = sortDiagnostics([...snapshot.diagnostics, ...partial.diagnostics]);
-    const complete = snapshot.complete &&
+    const complete = !focused &&
+        snapshot.complete &&
         graph.unresolved.length === 0 &&
         !graph.issues.some(({ classification, severity }) => classification === 'unresolved_analysis' || severity === 'blocker');
     const nodes = sortNodes(graph.nodes);
@@ -1588,6 +1602,7 @@ export function buildEventGraph(snapshot, options = {}) {
     return {
         schemaVersion: EVENT_GRAPH_SCHEMA_VERSION,
         parserVersion: EVENT_GRAPH_PARSER_VERSION,
+        analysisMode: options.analysisMode ?? 'full',
         workspaceId: snapshot.workspaceId,
         workspaceIdentity: options.workspaceIdentity ?? hashCanonical({ workspaceId: snapshot.workspaceId }),
         revision: snapshot.revision,

package/dist/hoi4_agent_tools/event/limits.js

@@ -4,7 +4,10 @@ export const EVENT_GRAPH_MAX_EDGES = 500_000;
 export const EVENT_GRAPH_MAX_STATE_ACCESSES = 250_000;
 export const EVENT_GRAPH_MAX_STATE_LINKS = 250_000;
 export const EVENT_GRAPH_MAX_STATE_LINK_CANDIDATES = 500_000;
-export const EVENT_GRAPH_MAX_ISSUES = 20_000;
+// Installed-game scans can legitimately produce more than twenty thousand source-linked
+// findings before an agent narrows the query. Keep the graph bounded, but do not reject a
+// complete large workspace merely because its diagnostics are numerous.
+export const EVENT_GRAPH_MAX_ISSUES = 100_000;
 export const EVENT_GRAPH_MAX_UNRESOLVED = 50_000;
 export const EVENT_GRAPH_MAX_HELPER_DEPTH = 64;
 export const EVENT_GRAPH_MAX_HELPER_PROJECTIONS = 200_000;

package/dist/hoi4_agent_tools/event/service.js

@@ -42,14 +42,16 @@ class BoundedEventFragmentCache {
         }
     }
 }
-function eventGraphCacheKey(workspaceId, projectHelpers) {
-    return `${workspaceId}\0${projectHelpers ? 'expanded' : 'structural'}`;
+function eventGraphCacheKey(workspaceId, projectHelpers, analysisMode = 'full') {
+    return `${workspaceId}\0${projectHelpers ? 'expanded' : 'structural'}\0${analysisMode}`;
 }
 const serviceState = new WeakMap();
 const EVENT_GRAPH_ARTIFACT_MAX_BYTES = 67_108_864;
 const EVENT_GRAPH_ARTIFACT_MAX_CHUNKS = 1_024;
 const EVENT_SCAN_FULL_GRAPH_RECORD_LIMIT = 100_000;
 const EVENT_SCAN_SUMMARY_SAMPLE_LIMIT = 100;
+const EVENT_FOCUSED_EVIDENCE_LIMIT = 2_000;
+const EVENT_FOCUSED_GRAPH_FILE_THRESHOLD = 1_000;
 const SHA256_PATTERN = /^[a-f0-9]{64}$/u;
 const graphHashCache = new WeakMap();
 function groupedCounts(values, key) {
@@ -116,7 +118,16 @@ function cachedEventGraphHash(graph, signal) {
     const cached = graphHashCache.get(graph);
     if (cached !== undefined)
         return cached;
-    const computed = eventGraphHash(graph, signal);
+    const computed = graph.analysisMode === 'focused'
+        ? hashCanonical({
+            schemaVersion: graph.schemaVersion,
+            parserVersion: graph.parserVersion,
+            workspaceIdentity: graph.workspaceIdentity,
+            revision: graph.revision,
+            statistics: graph.statistics,
+            sourceHashes: graph.sourceHashes,
+        })
+        : eventGraphHash(graph, signal);
     graphHashCache.set(graph, computed);
     return computed;
 }
@@ -135,6 +146,55 @@ function sharedState(engine) {
 function engineGeneration(engine, workspaceId) {
     return engine.generation(workspaceId);
 }
+function eventScanPatterns(workspace) {
+    const roots = workspace.registration.roots;
+    const under = (values, glob) => values.map((root) => `${root.replaceAll('\\', '/').replace(/\/$/u, '')}/${glob}`);
+    return [
+        'events/**/*.txt',
+        'history/countries/**/*.txt',
+        ...under(roots.states, '**/*.txt'),
+        'common/continuous_focus/**/*.txt',
+        'common/decisions/**/*.txt',
+        'common/ideas/**/*.txt',
+        'common/characters/**/*.txt',
+        'common/operations/**/*.txt',
+        'common/raids/**/*.txt',
+        'common/bop/**/*.txt',
+        'common/resistance_compliance_modifiers/**/*.txt',
+        'common/abilities/**/*.txt',
+        'common/on_actions/**/*.txt',
+        'common/special_projects/**/*.txt',
+        'common/scripted_effects/**/*.txt',
+        ...under(roots.focus, '**/*.txt'),
+        ...under(roots.scriptedGui, '**/*.txt'),
+        ...under(roots.localisation, 'english/**/*.{yml,yaml}'),
+        ...under(roots.localisation, '*.{yml,yaml}'),
+    ].sort(compareCodeUnits);
+}
+async function scanEventSources(engine, workspaceId, workspace, principal, signal) {
+    const patterns = eventScanPatterns(workspace);
+    const sourceKinds = ['mod', 'dependency', 'fixture'];
+    const scans = await Promise.all([
+        engine.scan(workspaceId, { patterns, rootKinds: sourceKinds }, principal, signal),
+        ...(workspace.roots.some(({ kind }) => kind === 'game')
+            ? [engine.scan(workspaceId, { patterns, rootKinds: ['game'] }, principal, signal)]
+            : []),
+    ]);
+    const files = scans.flatMap(({ files }) => files.map((file) => ({ ...file })));
+    recomputeShadowing(files);
+    files.sort((left, right) => left.loadOrder - right.loadOrder || compareCodeUnits(left.displayPath, right.displayPath));
+    const index = engine.indexFiles(files);
+    return {
+        workspaceId,
+        revision: snapshotRevision(files),
+        files,
+        index,
+        complete: scans.every(({ complete }) => complete) && index.complete,
+        skippedSourceCount: index.skippedSourceCount,
+        skippedSources: index.skippedSources,
+        diagnostics: [...scans.flatMap(({ diagnostics }) => diagnostics), ...index.diagnostics],
+    };
+}
 function rememberGraph(state, workspaceId, graph) {
     const history = state.history.get(workspaceId) ?? new Map();
     history.delete(graph.revision);
@@ -163,6 +223,20 @@ function eventIssueDiagnostic(issue) {
         },
     };
 }
+function boundedEvidence(values, limit = EVENT_FOCUSED_EVIDENCE_LIMIT) {
+    if (values.length <= limit)
+        return { values: [...values] };
+    return {
+        values: values.slice(0, limit),
+        inventory: { count: values.length, retainedCount: limit, truncated: true },
+    };
+}
+function boundedUnresolved(graph, selectedNodeIds) {
+    const relevant = selectedNodeIds === undefined
+        ? graph.unresolved
+        : graph.unresolved.filter(({ id, ownerId }) => selectedNodeIds.has(id) || (ownerId !== undefined && selectedNodeIds.has(ownerId)));
+    return boundedEvidence(relevant);
+}
 export function eventDiagnostics(graph) {
     const existing = new Set(graph.diagnostics.map(({ code, location }) => `${code}:${location?.path ?? ''}:${location?.start.offset ?? -1}`));
     return [
@@ -618,37 +692,56 @@ export class EventChainViewer {
         const workspace = this.engine.resolver.get(workspaceId, options.principal);
         const generation = engineGeneration(this.engine, workspaceId);
         const projectHelpers = options.projectHelpers ?? true;
-        const cacheKey = eventGraphCacheKey(workspaceId, projectHelpers);
+        const analysisMode = options.analysisMode ?? 'full';
+        const cacheKey = eventGraphCacheKey(workspaceId, projectHelpers, analysisMode);
         const cached = this.#state.current.get(cacheKey);
         if (options.refresh !== true && cached?.generation === generation) {
             return cached.graph;
         }
-        const sibling = this.#state.current.get(eventGraphCacheKey(workspaceId, !projectHelpers));
+        const sibling = this.#state.current.get(eventGraphCacheKey(workspaceId, !projectHelpers, analysisMode)) ??
+            this.#state.current.get(eventGraphCacheKey(workspaceId, !projectHelpers)) ??
+            this.#state.current.get(eventGraphCacheKey(workspaceId, projectHelpers));
         const snapshot = options.refresh !== true && sibling?.generation === generation
             ? sibling.snapshot
-            : await this.engine.scan(workspaceId, {}, options.principal, options.signal);
+            : await scanEventSources(this.engine, workspaceId, workspace, options.principal, options.signal);
         options.signal?.throwIfAborted();
         if (cached?.snapshot.revision === snapshot.revision && cached.generation === generation) {
             return cached.graph;
         }
+        const buildAnalysisMode = analysisMode === 'focused' && snapshot.files.length > EVENT_FOCUSED_GRAPH_FILE_THRESHOLD
+            ? 'focused'
+            : 'full';
         const graph = buildEventGraph(snapshot, {
             ...(options.signal === undefined ? {} : { signal: options.signal }),
             cache: this.#state.fragments,
             workspaceIdentity: workspace.workspaceIdentity,
             projectHelpers,
+            analysisMode: buildAnalysisMode,
         });
         this.#state.current.set(cacheKey, { generation, snapshot, graph });
-        rememberGraph(this.#state, workspaceId, graph);
+        if (analysisMode === 'full')
+            rememberGraph(this.#state, workspaceId, graph);
         return graph;
     }
     async inspect(input) {
         input.signal?.throwIfAborted();
-        const graph = await this.scan(input.workspaceId, {
+        const scannedGraph = await this.scan(input.workspaceId, {
             refresh: input.refresh ?? input.mode === 'scan',
-            projectHelpers: input.mode !== 'scan' && input.mode !== 'roots',
+            // Focused routes traverse helper nodes directly and collapse only the
+            // selected path. Avoid materialising the full workspace projection first.
+            projectHelpers: input.mode !== 'scan' &&
+                input.mode !== 'roots' &&
+                input.mode !== 'trace' &&
+                input.mode !== 'explain_path',
+            ...(input.mode === 'trace' || input.mode === 'explain_path'
+                ? { analysisMode: 'focused' }
+                : {}),
             ...(input.principal === undefined ? {} : { principal: input.principal }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
         });
+        // Keep the service result's graph identity distinct from a prior scan while
+        // reusing its structural cache and avoiding a second large graph build.
+        const graph = input.mode === 'trace' || input.mode === 'explain_path' ? { ...scannedGraph } : scannedGraph;
         const maxDepth = input.maxDepth ?? 8;
         const maxNodes = input.maxNodes ?? 500;
         const maxEdges = input.maxEdges ?? 2_000;
@@ -671,28 +764,41 @@ export class EventChainViewer {
                 report = eventScanReport(graph);
                 break;
             case 'roots':
-                report = {
-                    graphRevision: graph.revision,
-                    sourceHashes: graph.sourceHashes,
-                    roots: discoverEventRoots(graph, input.signal),
-                    unresolved: graph.unresolved,
-                };
+                {
+                    const unresolved = boundedUnresolved(graph);
+                    report = {
+                        graphRevision: graph.revision,
+                        sourceHashes: graph.sourceHashes,
+                        roots: discoverEventRoots(graph, input.signal),
+                        unresolved: unresolved.values,
+                        ...(unresolved.inventory === undefined
+                            ? {}
+                            : { unresolvedInventory: unresolved.inventory }),
+                    };
+                }
                 break;
             case 'trace':
                 if (input.selector === undefined)
                     throw new ServiceError('EVENT_SELECTOR_REQUIRED', 'Trace requires a selector');
-                report = {
-                    graphRevision: graph.revision,
-                    sourceHashes: graph.sourceHashes,
-                    trace: traceSelectedEvents(graph, input.selector, {
+                {
+                    const trace = traceSelectedEvents(graph, input.selector, {
                         maxDepth,
                         maxNodes,
                         maxEdges,
                         direction: input.direction ?? 'both',
                         expandHelpers: input.expandHelpers ?? false,
-                    }, input.signal),
-                    unresolved: graph.unresolved,
-                };
+                    }, input.signal);
+                    const unresolved = boundedUnresolved(graph, new Set(trace.nodes.map(({ id }) => id)));
+                    report = {
+                        graphRevision: graph.revision,
+                        sourceHashes: graph.sourceHashes,
+                        trace,
+                        unresolved: unresolved.values,
+                        ...(unresolved.inventory === undefined
+                            ? {}
+                            : { unresolvedInventory: unresolved.inventory }),
+                    };
+                }
                 break;
             case 'explain_path':
                 if (input.from === undefined || input.to === undefined)
@@ -704,31 +810,54 @@ export class EventChainViewer {
                 };
                 break;
             case 'state_flow':
-                report = {
-                    graphRevision: graph.revision,
-                    sourceHashes: graph.sourceHashes,
-                    flow: inspectEventStateFlow(graph, input.selector, input.stateSubject, input.signal),
-                    issues: lintEventGraph(graph, input.selector, input.signal).filter(({ code }) => /(?:STATE|FLAG|VARIABLE|ARRAY|TARGET|SCOPE)/u.test(code)),
-                };
+                {
+                    const unresolved = boundedUnresolved(graph);
+                    const issues = boundedEvidence(lintEventGraph(graph, input.selector, input.signal).filter(({ code }) => /(?:STATE|FLAG|VARIABLE|ARRAY|TARGET|SCOPE)/u.test(code)));
+                    report = {
+                        graphRevision: graph.revision,
+                        sourceHashes: graph.sourceHashes,
+                        flow: inspectEventStateFlow(graph, input.selector, input.stateSubject, input.signal),
+                        issues: issues.values,
+                        unresolved: unresolved.values,
+                        ...(issues.inventory === undefined ? {} : { issueInventory: issues.inventory }),
+                        ...(unresolved.inventory === undefined
+                            ? {}
+                            : { unresolvedInventory: unresolved.inventory }),
+                    };
+                }
                 break;
             case 'lint':
-                report = {
-                    graphRevision: graph.revision,
-                    sourceHashes: graph.sourceHashes,
-                    issues: lintEventGraph(graph, input.selector, input.signal),
-                    complete: graph.complete,
-                    unresolved: graph.unresolved,
-                };
+                {
+                    const issues = boundedEvidence(lintEventGraph(graph, input.selector, input.signal));
+                    const unresolved = boundedUnresolved(graph);
+                    report = {
+                        graphRevision: graph.revision,
+                        sourceHashes: graph.sourceHashes,
+                        issues: issues.values,
+                        complete: graph.complete,
+                        unresolved: unresolved.values,
+                        ...(issues.inventory === undefined ? {} : { issueInventory: issues.inventory }),
+                        ...(unresolved.inventory === undefined
+                            ? {}
+                            : { unresolvedInventory: unresolved.inventory }),
+                    };
+                }
                 break;
             case 'impact':
                 if (input.impactSubject === undefined)
                     throw new ServiceError('EVENT_IMPACT_SUBJECT_REQUIRED', 'Impact analysis requires a subject');
-                report = {
-                    graphRevision: graph.revision,
-                    sourceHashes: graph.sourceHashes,
-                    impact: analyzeEventImpact(graph, input.impactSubject, input.signal),
-                    unresolved: graph.unresolved,
-                };
+                {
+                    const unresolved = boundedUnresolved(graph);
+                    report = {
+                        graphRevision: graph.revision,
+                        sourceHashes: graph.sourceHashes,
+                        impact: analyzeEventImpact(graph, input.impactSubject, input.signal),
+                        unresolved: unresolved.values,
+                        ...(unresolved.inventory === undefined
+                            ? {}
+                            : { unresolvedInventory: unresolved.inventory }),
+                    };
+                }
                 break;
         }
         const graphHash = cachedEventGraphHash(graph, input.signal);
@@ -742,7 +871,7 @@ export class EventChainViewer {
             : undefined;
         const artifactUnresolved = projectedScan
             ? graph.unresolved.slice(0, EVENT_SCAN_SUMMARY_SAMPLE_LIMIT)
-            : graph.unresolved;
+            : boundedUnresolved(graph).values;
         const reportJson = `${canonicalJson({
             schemaVersion: 'event-analysis.v1',
             graphSchemaVersion: graph.schemaVersion,
@@ -759,12 +888,12 @@ export class EventChainViewer {
             complete: graph.complete,
             filters: analysisFilters,
             unresolved: artifactUnresolved,
-            ...(projectedScan
+            ...(artifactUnresolved.length !== graph.unresolved.length
                 ? {
                     unresolvedInventory: {
                         count: graph.unresolved.length,
                         retainedCount: artifactUnresolved.length,
-                        truncated: artifactUnresolved.length !== graph.unresolved.length,
+                        truncated: true,
                     },
                 }
                 : {}),
@@ -950,7 +1079,15 @@ export class EventChainViewer {
                 includeHtml: input.includeHtml ?? false,
                 refresh: input.refresh ?? false,
             },
-            unresolved: graph.unresolved,
+            ...(() => {
+                const unresolved = boundedUnresolved(graph, new Set(render.selectedNodeIds));
+                return {
+                    unresolved: unresolved.values,
+                    ...(unresolved.inventory === undefined
+                        ? {}
+                        : { unresolvedInventory: unresolved.inventory }),
+                };
+            })(),
             resources: { ...resourceNames, artifacts: resourceLinks },
             overview: {
                 selectedNodeIds: render.selectedNodeIds,