hoi4-agent-tools 4.0.5 → 4.2.0

package/dist/hoi4_agent_tools/decision/service.js

@@ -99,7 +99,20 @@ export class DecisionAnalyzer {
                 }));
         const ai = input.mode === 'inventory'
             ? undefined
-            : await inspectDecisionAi(this.engine, before, input.id, scenarios, overlay, input.principal, input.signal);
+            : await inspectDecisionAi(this.engine, before, input.id, scenarios, overlay, input.principal, input.signal).catch((error) => {
+                // AI weights depend on adapters verified for one game version. A game patch leaves
+                // the AI score unresolved; visibility, availability and cost evidence still stand.
+                if (error instanceof ServiceError &&
+                    (error.code === 'PROBABILITY_GAME_VERSION_UNSUPPORTED' ||
+                        error.code === 'PROBABILITY_GAME_VERSION_UNVERIFIED'))
+                    return {
+                        status: 'unresolved',
+                        code: error.code,
+                        message: error.message,
+                        details: error.details,
+                    };
+                throw error;
+            });
         const sourceComplete = input.mode === 'inventory'
             ? inventory.complete
             : input.mode === 'compare'
@@ -180,6 +193,14 @@ export class DecisionAnalyzer {
                 : {}),
         });
         result.code = complete ? 'DECISION_ANALYZED' : 'DECISION_ANALYZED_PARTIAL';
+        if (ai !== undefined && 'code' in ai)
+            result.diagnostics.push({
+                category: 'configuration',
+                code: ai.code,
+                severity: 'warning',
+                message: `${ai.message}; AI weights are unresolved, the remaining evidence is unaffected`,
+                details: ai.details,
+            });
         result.artifacts = [publicArtifactLink(artifact)];
         result.proposedFiles = overlay?.changes.map(({ path }) => path).slice(0, 64) ?? [];
         setInlineFilesScanned(result, before.files.map(({ displayPath }) => displayPath));

package/dist/hoi4_agent_tools/event/algorithms.js

@@ -362,10 +362,11 @@ export function eventStronglyConnectedComponents(graph, expandHelpers = false, s
     const budget = new EventAnalysisBudget(signal);
     const components = iterativeStronglyConnectedComponents(retainedNodes, adjacency, () => budget.spend('strongly_connected_components'));
     budget.check();
+    // Collect self-loops once: scanning every edge per component is quadratic on large mods.
+    const selfLoops = new Set(edges.filter(({ from, to }) => from === to).map(({ from }) => from));
     return components
         .map((nodeIds) => {
-        const members = new Set(nodeIds);
-        const selfLoop = edges.some(({ from, to }) => from === to && members.has(from));
+        const selfLoop = nodeIds.some((nodeId) => selfLoops.has(nodeId));
         return {
             id: `scc:${nodeIds.join('|')}`,
             nodeIds,

package/dist/hoi4_agent_tools/event/graph.js

@@ -5,6 +5,7 @@ import { beginSemanticAnalysis, semanticFragment, SemanticCatalog, } from '../co
 import { runDependencyAnalysis, runDependencyAnalysisAsync, } from '../core/dependency-walk.js';
 import { EVENT_GRAPH_MAX_EDGES, EVENT_GRAPH_MAX_HELPER_DEPTH, EVENT_GRAPH_MAX_HELPER_PROJECTIONS, EVENT_GRAPH_MAX_HELPER_STATE_PROJECTIONS, EVENT_GRAPH_MAX_ISSUES, EVENT_GRAPH_MAX_NODES, EVENT_GRAPH_MAX_STATE_ACCESSES, EVENT_GRAPH_MAX_STATE_LINK_CANDIDATES, EVENT_GRAPH_MAX_STATE_LINKS, EVENT_GRAPH_MAX_UNRESOLVED, EVENT_GRAPH_WORK_LIMIT, EventAnalysisBudget, } from './limits.js';
 import { EVENT_GRAPH_PARSER_VERSION, EVENT_GRAPH_SCHEMA_VERSION, } from './model.js';
+import { compatibleProducerKeys, hasUnknownSavedScopeStorage, stateKey } from './state-keys.js';
 import { iterativeStronglyConnectedComponents } from './scc.js';
 import { analyzeEventSource, eventSemanticFragmentCacheKey } from './source-analysis.js';
 const confidenceRank = {
@@ -117,11 +118,14 @@ function locationKey(location) {
     return `${location?.path ?? ''}:${location?.start.offset ?? -1}:${location?.end.offset ?? -1}`;
 }
 function issueKey(issue) {
-    const subjectIds = issue.details.subjectIds;
+    // One finding per owner and subject: repeated accesses to the same named state collapse,
+    // while different events, targets, flags or expressions in one owner stay separate findings.
+    const { subjectIds, accessId: _accessId, stateLinkId: _stateLinkId, ...subject } = issue.details;
     return hashCanonical({
         code: issue.code,
         classification: issue.classification,
         subjectIds: Array.isArray(subjectIds) ? subjectIds : [],
+        subject,
     });
 }
 function stableIssues(values) {
@@ -360,6 +364,7 @@ function helperWalkInput(graph, revision) {
         maximumSteps: EVENT_GRAPH_WORK_LIMIT,
         visitPolicy: 'node',
         reverseEdges: true,
+        onWorkLimit: 'truncate',
     };
 }
 function helperCallerScope(nodes, parents, start) {
@@ -391,11 +396,17 @@ function helperProjections(graph, budget, walk) {
         const final = structural.at(-1);
         const helpers = structural.slice(0, -1).map(({ to }) => nodes.get(to));
         if (record.kind === 'cycle' || record.kind === 'depth') {
-            const key = `${record.kind}:${start.id}:${final.to}`;
+            const cycle = record.kind === 'cycle';
+            // One finding per recursive loop, identified by its member helpers, rather than one per
+            // caller that reaches it.
+            const chain = helpers.map(({ id }) => id);
+            const members = chain.slice(Math.max(0, chain.indexOf(final.to)));
+            const key = cycle
+                ? `cycle:${[...members].sort(compareCodeUnits).join('\0')}`
+                : `depth:${start.id}:${final.to}`;
             if (reported.has(key))
                 continue;
             reported.add(key);
-            const cycle = record.kind === 'cycle';
             addIssue(graph.issues, {
                 code: cycle ? 'EVENT_HELPER_CYCLE' : 'EVENT_HELPER_DEPTH_LIMIT',
                 classification: 'unresolved_analysis',
@@ -415,9 +426,7 @@ function helperProjections(graph, budget, walk) {
                         ...(cycle ? {} : { details: { maximumDepth: EVENT_GRAPH_MAX_HELPER_DEPTH } }),
                     },
                 ],
-                subjectIds: cycle
-                    ? [start.from, ...helpers.map(({ id }) => id), final.to]
-                    : [start.from, final.to],
+                subjectIds: cycle ? members : [start.from, final.to],
             });
             continue;
         }
@@ -617,32 +626,6 @@ function addTerminalNodes(graph) {
         });
     }
 }
-function stateKey(value) {
-    const scope = value.kind === 'variable' || value.kind === 'array' ? `:${value.scope}` : '';
-    const storage = value.kind === 'saved_scope'
-        ? `:${value.metadata.storage === 'global' || value.metadata.storage === 'local'
-            ? value.metadata.storage
-            : 'unknown'}`
-        : '';
-    return `${value.kind}:${value.name}${scope}${storage}`;
-}
-function compatibleProducerKeys(value) {
-    if (value.kind !== 'saved_scope' ||
-        value.metadata.storage === 'global' ||
-        value.metadata.storage === 'local') {
-        return [stateKey(value)];
-    }
-    return [
-        `saved_scope:${value.name}:global`,
-        `saved_scope:${value.name}:local`,
-        `saved_scope:${value.name}:unknown`,
-    ];
-}
-function hasUnknownSavedScopeStorage(value) {
-    return (value.kind === 'saved_scope' &&
-        value.metadata.storage !== 'global' &&
-        value.metadata.storage !== 'local');
-}
 function collapsedFlowEdges(nodes, edges) {
     return edges
         .filter((edge) => {
@@ -999,9 +982,23 @@ function structuralCallIssues(graph, budget) {
     for (const values of cyclicOutgoing.values())
         values.sort(compareCodeUnits);
     const flowComponents = iterativeStronglyConnectedComponents(collapsed.flatMap(({ from, to }) => [from, to]), cyclicOutgoing, () => budget.spend('event_cycle'));
-    for (const component of flowComponents) {
-        const members = new Set(component);
-        const internal = collapsed.filter(({ from, to }) => members.has(from) && members.has(to));
+    // Group each edge under its component once instead of filtering every edge per component.
+    const componentOf = new Map();
+    flowComponents.forEach((component, index) => {
+        for (const member of component)
+            componentOf.set(member, index);
+    });
+    const internalEdges = new Map();
+    for (const edge of collapsed) {
+        const component = componentOf.get(edge.from);
+        if (component === undefined || componentOf.get(edge.to) !== component)
+            continue;
+        const values = internalEdges.get(component) ?? [];
+        values.push(edge);
+        internalEdges.set(component, values);
+    }
+    for (const [componentIndex, component] of flowComponents.entries()) {
+        const internal = internalEdges.get(componentIndex) ?? [];
         const cyclic = component.length > 1 || internal.some(({ from, to }) => from === to);
         if (!cyclic)
             continue;
@@ -1487,6 +1484,26 @@ function* eventGraphAnalysis(snapshot, options) {
     ensureReferencedNodes(graph);
     if (options.projectHelpers !== false) {
         const walk = yield helperWalkInput(graph, snapshot.revision);
+        if (walk.state.truncated === true)
+            addIssue(graph.issues, {
+                code: 'EVENT_HELPER_PROJECTION_LIMIT',
+                classification: 'unresolved_analysis',
+                severity: 'blocker',
+                message: 'Helper expansion reached its fixed work ceiling; helper calls from the remaining roots stay structural.',
+                confidence: 'unresolved',
+                blockers: [
+                    {
+                        code: 'HELPER_PROJECTION_LIMIT',
+                        message: 'Select a namespace, event or file, or use helper_expansion mode, for paths beyond the ceiling.',
+                        details: {
+                            maximum: EVENT_GRAPH_WORK_LIMIT,
+                            completedRoots: walk.state.root,
+                            totalRoots: walk.input.roots.length,
+                        },
+                    },
+                ],
+                details: { completedRoots: walk.state.root, totalRoots: walk.input.roots.length },
+            });
         for (const edge of helperProjections(graph, budget, walk))
             graph.edges.push(edge);
         for (const access of projectHelperStateAccesses(graph, budget, walk))

package/dist/hoi4_agent_tools/event/limits.js

@@ -17,6 +17,10 @@ export const EVENT_GRAPH_WORK_LIMIT = 10_000_000;
 export const EVENT_FRAGMENT_CACHE_MAX_ENTRIES = 10_000;
 export const EVENT_FRAGMENT_CACHE_MAX_SOURCE_BYTES = 134_217_728;
 export const EVENT_PROPOSED_SOURCE_MAX_FILES = 64;
+// The full graph snapshot of a scan is retained only up to this size. Larger graphs, such as a
+// mod with several thousand events and hundreds of thousands of state accesses, would exceed a
+// JavaScript string and the artifact preparation ceiling.
+export const EVENT_GRAPH_SNAPSHOT_MAX_BYTES = 134_217_728;
 export const EVENT_PROPOSED_SOURCE_MAX_BYTES = 67_108_864;
 /** One cooperative, deterministic work ceiling shared by extraction and graph construction. */
 export class EventAnalysisBudget {

package/dist/hoi4_agent_tools/event/operations.js

@@ -4,6 +4,7 @@ import { publicArtifactLink } from '../core/artifacts.js';
 import { setInlineFilesScanned } from '../core/operation-result.js';
 import { emptyServiceResult } from '../core/result.js';
 import { eventInspectRequestSchema, splitEventInspectRequest, eventRenderRequestSchema, eventCompareRequestSchema, } from '../schemas/event.js';
+import { EVENT_GRAPH_SNAPSHOT_MAX_BYTES } from './limits.js';
 import { eventDiagnostics, } from './service.js';
 export function normalizeEventInspectionRequest(input) {
     // Validated request fields are JSON-only. Match wire semantics by removing optional
@@ -87,6 +88,7 @@ export async function inspectEvents(viewer, input) {
         ...(inspected.helperExpansion === undefined
             ? {}
             : { helperExpansion: inspected.helperExpansion }),
+        ...(inspected.summary === undefined ? {} : { summary: inspected.summary }),
         boundary: {
             direction: input.direction ?? 'both',
             maxDepth: inspected.helperExpansion?.maxDepth ?? input.maxDepth ?? 8,
@@ -103,6 +105,14 @@ export async function inspectEvents(viewer, input) {
             : 'EVENT_INSPECTED_PARTIAL';
     setInlineFilesScanned(result, inspected.graph.filesScanned);
     result.artifacts = inspected.artifacts.map(publicArtifactLink);
+    if (inspected.graphSnapshotOmitted === true)
+        result.diagnostics.push({
+            category: 'configuration',
+            code: 'EVENT_GRAPH_SNAPSHOT_OMITTED',
+            severity: 'info',
+            message: 'The workspace graph is too large to retain as a snapshot artifact; the scan report is linked, and comparisons use revisions held by this server',
+            details: { maximumBytes: EVENT_GRAPH_SNAPSHOT_MAX_BYTES },
+        });
     result.validation = eventGraphValidation(inspected.graph);
     if (inspected.helperExpansion !== undefined)
         result.validation = helperExpansionValidation(inspected.helperExpansion);
@@ -122,6 +132,7 @@ export async function renderEvents(viewer, input) {
             selectedNodes: rendered.render.selectedNodeIds.length,
             omittedNodes: rendered.render.omittedNodeCount,
             branchRenders: rendered.branches.length,
+            omittedBranchRenders: rendered.budgetOmittedBranches,
         },
         boundary: {
             direction: input.direction ?? 'both',

package/dist/hoi4_agent_tools/event/queries.js

@@ -1,5 +1,6 @@
 import { compareCodeUnits } from '../core/canonical.js';
 import { eventFlowEdges, eventStronglyConnectedComponents, reachableEventNodeIds, shortestEventPath, traceEventGraph, } from './algorithms.js';
+import { compatibleProducerKeys, hasUnknownSavedScopeStorage, stateKey } from './state-keys.js';
 function reachableFromRootsWithout(graph, rootIds, removedNodeIds, signal) {
     signal?.throwIfAborted();
     const retainedNodeIds = new Set(graph.nodes.filter(({ id }) => !removedNodeIds.has(id)).map(({ id }) => id));
@@ -348,32 +349,6 @@ export function explainEventPath(graph, from, to, boundary, signal) {
         boundary,
     };
 }
-function stateKey(access) {
-    const scope = access.kind === 'variable' || access.kind === 'array' ? `:${access.scope}` : '';
-    const storage = access.kind === 'saved_scope'
-        ? `:${access.metadata.storage === 'global' || access.metadata.storage === 'local'
-            ? access.metadata.storage
-            : 'unknown'}`
-        : '';
-    return `${access.kind}:${access.name}${scope}${storage}`;
-}
-function compatibleProducerKeys(access) {
-    if (access.kind !== 'saved_scope' ||
-        access.metadata.storage === 'global' ||
-        access.metadata.storage === 'local') {
-        return [stateKey(access)];
-    }
-    return [
-        `saved_scope:${access.name}:global`,
-        `saved_scope:${access.name}:local`,
-        `saved_scope:${access.name}:unknown`,
-    ];
-}
-function hasUnknownSavedScopeStorage(access) {
-    return (access.kind === 'saved_scope' &&
-        access.metadata.storage !== 'global' &&
-        access.metadata.storage !== 'local');
-}
 function compatibleProducers(producers, consumer) {
     const compatible = new Map();
     for (const key of compatibleProducerKeys(consumer)) {
@@ -544,20 +519,24 @@ export function lintEventGraph(graph, selector, signal) {
     if (selector === undefined)
         return [...graph.issues];
     const selected = selectedOwnershipIds(graph, selector, signal);
-    const selectedNodes = graph.nodes.filter(({ id }, index) => {
+    // Source ranges of the selected nodes, grouped by file so each issue checks only its own file.
+    const selectedRanges = new Map();
+    for (const [index, { id, location }] of graph.nodes.entries()) {
         if ((index & 255) === 0)
             signal?.throwIfAborted();
-        return selected.has(id);
-    });
+        if (location === undefined || !selected.has(id))
+            continue;
+        const ranges = selectedRanges.get(location.path) ?? [];
+        ranges.push({ start: location.start.offset, end: location.end.offset });
+        selectedRanges.set(location.path, ranges);
+    }
     return graph.issues.filter((issue, index) => {
         if ((index & 255) === 0)
             signal?.throwIfAborted();
+        const location = issue.location;
         return (issueSubjectIds(issue).some((id) => selected.has(id)) ||
-            (issue.location !== undefined &&
-                selectedNodes.some(({ location }) => location !== undefined &&
-                    location.path === issue.location?.path &&
-                    issue.location.start.offset >= location.start.offset &&
-                    issue.location.end.offset <= location.end.offset)));
+            (location !== undefined &&
+                (selectedRanges.get(location.path) ?? []).some(({ start, end }) => location.start.offset >= start && location.end.offset <= end)));
     });
 }
 export function issueSubjectIds(issue) {

package/dist/hoi4_agent_tools/event/render.js

@@ -103,12 +103,14 @@ function boundedSelection(graph, options) {
     else if (options.view === 'terminals') {
         const terminals = withinSelector(graph.nodes.filter(({ kind }) => kind === 'terminal').map(({ id }) => id));
         add(terminals);
-        add(graph.edges.filter(({ to }) => terminals.includes(to)).flatMap(({ from, to }) => [from, to]));
+        const terminalIds = new Set(terminals);
+        add(graph.edges.filter(({ to }) => terminalIds.has(to)).flatMap(({ from, to }) => [from, to]));
     }
     else if (options.view === 'unresolved') {
         const unresolved = withinSelector(graph.nodes.filter(({ kind }) => kind === 'unresolved').map(({ id }) => id));
         add(unresolved);
-        add(graph.edges.filter(({ to }) => unresolved.includes(to)).flatMap(({ from, to }) => [from, to]));
+        const unresolvedIds = new Set(unresolved);
+        add(graph.edges.filter(({ to }) => unresolvedIds.has(to)).flatMap(({ from, to }) => [from, to]));
     }
     else if (options.view === 'neighborhood' || options.view === 'reachability') {
         add(selectorTrace);

package/dist/hoi4_agent_tools/event/service.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import { inspectHelperExpansion } from '../core/helper-expansion.js';
 import { eventHelperInventory } from './helper-expansion.js';
 import { clearSemanticDependencies } from '../core/semantic-dependencies.js';
-import { canonicalJson, compareCodeUnits, hashCanonical, sha256Bytes } from '../core/canonical.js';
+import { canonicalJson, canonicalJsonByteLength, compareCodeUnits, hashCanonical, sha256Bytes, } from '../core/canonical.js';
 import { boundedSourceHashEvidence, publicArtifactLink, } from '../core/artifacts.js';
 import { ServiceError } from '../core/result.js';
 import { RenderBudget } from '../core/render-budget.js';
@@ -10,7 +10,8 @@ import { SOURCE_MAX_BYTES } from '../core/source/index.js';
 import { isPortablePathSegment } from '../core/workspace.js';
 import { PACKAGE_VERSION } from '../version.js';
 import { buildEventGraph, buildEventGraphAsync } from './graph.js';
-import { EVENT_FRAGMENT_CACHE_MAX_ENTRIES, EVENT_FRAGMENT_CACHE_MAX_SOURCE_BYTES, EVENT_PROPOSED_SOURCE_MAX_BYTES, EVENT_PROPOSED_SOURCE_MAX_FILES, } from './limits.js';
+import { summarizeEventImpact, summarizeEventIssues, summarizeEventPath, summarizeEventRoots, summarizeEventTrace, } from './summary.js';
+import { EVENT_FRAGMENT_CACHE_MAX_ENTRIES, EVENT_FRAGMENT_CACHE_MAX_SOURCE_BYTES, EVENT_GRAPH_SNAPSHOT_MAX_BYTES, EVENT_PROPOSED_SOURCE_MAX_BYTES, EVENT_PROPOSED_SOURCE_MAX_FILES, } from './limits.js';
 import { analyzeEventImpact, discoverEventRoots, explainEventPath, inspectEventStateFlow, lintEventGraph, traceSelectedEvents, } from './queries.js';
 import { compareEventGraphs, eventGraphHash } from './compare.js';
 import { selectEventComparison } from './comparison-selection.js';
@@ -210,9 +211,23 @@ async function scanEventSources(engine, workspaceId, workspace, focused = false,
         complete: index.complete,
         skippedSourceCount: index.skippedSourceCount,
         skippedSources: index.skippedSources,
-        diagnostics: index.diagnostics,
+        diagnostics: diagnosticsWithinScannedKinds(index),
     };
 }
+/**
+ * Event analysis indexes only event-relevant folders, so it holds no sprite, interface or
+ * scripted-trigger definitions. A reference to a kind with no definition in this file set says
+ * nothing about the workspace and is left to the full index, which scans those folders.
+ */
+function diagnosticsWithinScannedKinds(index) {
+    const indexedKinds = new Set(index.symbols.map(({ kind }) => kind));
+    return index.diagnostics.filter(({ code, details }) => {
+        if (code !== 'INDEX_UNRESOLVED_REFERENCE' && code !== 'INDEX_UNRESOLVED_REFERENCE_PARTIAL')
+            return true;
+        const toKind = details?.toKind;
+        return typeof toKind !== 'string' || indexedKinds.has(toKind);
+    });
+}
 function rememberGraph(state, workspaceId, graph) {
     const history = state.history.get(workspaceId) ?? new Map();
     history.delete(graph.revision);
@@ -808,17 +823,21 @@ export class EventChainViewer {
             refresh: input.refresh ?? input.mode === 'scan',
         };
         let report;
+        let summary;
         switch (input.mode) {
             case 'scan':
                 report = eventScanReport(graph);
+                summary = summarizeEventIssues(graph.issues);
                 break;
             case 'roots':
                 {
                     const unresolved = boundedUnresolved(graph);
+                    const roots = discoverEventRoots(graph, input.signal);
+                    summary = summarizeEventRoots(roots);
                     report = {
                         graphRevision: graph.revision,
                         sourceHashes: graph.sourceHashes,
-                        roots: discoverEventRoots(graph, input.signal),
+                        roots,
                         unresolved: unresolved.values,
                         ...(unresolved.inventory === undefined
                             ? {}
@@ -838,6 +857,10 @@ export class EventChainViewer {
                         expandHelpers: input.expandHelpers ?? false,
                     }, input.signal);
                     const unresolved = boundedUnresolved(graph, new Set(trace.nodes.map(({ id }) => id)));
+                    summary = {
+                        trace: summarizeEventTrace(trace),
+                        ...summarizeEventIssues(lintEventGraph(graph, input.selector, input.signal)),
+                    };
                     report = {
                         graphRevision: graph.revision,
                         sourceHashes: graph.sourceHashes,
@@ -852,16 +875,22 @@ export class EventChainViewer {
             case 'explain_path':
                 if (input.from === undefined || input.to === undefined)
                     throw new ServiceError('EVENT_PATH_SELECTORS_REQUIRED', 'Path explanation requires from and to selectors');
-                report = {
-                    graphRevision: graph.revision,
-                    sourceHashes: graph.sourceHashes,
-                    explanation: explainEventPath(graph, input.from, input.to, { maxDepth, maxNodes, expandHelpers: input.expandHelpers ?? true }, input.signal),
-                };
+                {
+                    const explanation = explainEventPath(graph, input.from, input.to, { maxDepth, maxNodes, expandHelpers: input.expandHelpers ?? true }, input.signal);
+                    summary = summarizeEventPath(explanation);
+                    report = {
+                        graphRevision: graph.revision,
+                        sourceHashes: graph.sourceHashes,
+                        explanation,
+                    };
+                }
                 break;
             case 'state_flow':
                 {
                     const unresolved = boundedUnresolved(graph);
-                    const issues = boundedEvidence(lintEventGraph(graph, input.selector, input.signal).filter(({ code }) => /(?:STATE|FLAG|VARIABLE|ARRAY|TARGET|SCOPE)/u.test(code)));
+                    const stateIssues = lintEventGraph(graph, input.selector, input.signal).filter(({ code }) => /(?:STATE|FLAG|VARIABLE|ARRAY|TARGET|SCOPE|WRITER)/u.test(code));
+                    summary = summarizeEventIssues(stateIssues);
+                    const issues = boundedEvidence(stateIssues);
                     report = {
                         graphRevision: graph.revision,
                         sourceHashes: graph.sourceHashes,
@@ -877,7 +906,9 @@ export class EventChainViewer {
                 break;
             case 'lint':
                 {
-                    const issues = boundedEvidence(lintEventGraph(graph, input.selector, input.signal));
+                    const selectedIssues = lintEventGraph(graph, input.selector, input.signal);
+                    summary = summarizeEventIssues(selectedIssues);
+                    const issues = boundedEvidence(selectedIssues);
                     const unresolved = boundedUnresolved(graph);
                     report = {
                         graphRevision: graph.revision,
@@ -897,10 +928,12 @@ export class EventChainViewer {
                     throw new ServiceError('EVENT_IMPACT_SUBJECT_REQUIRED', 'Impact analysis requires a subject');
                 {
                     const unresolved = boundedUnresolved(graph);
+                    const impact = analyzeEventImpact(graph, input.impactSubject, input.signal);
+                    summary = summarizeEventImpact(impact);
                     report = {
                         graphRevision: graph.revision,
                         sourceHashes: graph.sourceHashes,
-                        impact: analyzeEventImpact(graph, input.impactSubject, input.signal),
+                        impact,
                         unresolved: unresolved.values,
                         ...(unresolved.inventory === undefined
                             ? {}
@@ -912,6 +945,13 @@ export class EventChainViewer {
         const graphHash = cachedEventGraphHash(graph, input.signal);
         const name = `${safeSlug(`event-${input.mode}`)}-${graph.revision.slice(0, 12)}.json`;
         const graphSnapshotName = `event-graph-${graph.revision}.json`;
+        // A large workspace graph cannot be held as one JSON string or artifact. Measure it first and
+        // retain it only when it fits; comparisons then use the in-memory revision history.
+        const graphSnapshot = input.mode === 'scan' ? { schemaVersion: 'event-graph-snapshot.v1', graph } : undefined;
+        const graphSnapshotBytes = graphSnapshot === undefined
+            ? undefined
+            : canonicalJsonByteLength(graphSnapshot, EVENT_GRAPH_SNAPSHOT_MAX_BYTES);
+        const snapshotOmitted = graphSnapshot !== undefined && graphSnapshotBytes === undefined;
         const projectedScan = input.mode === 'scan' &&
             typeof report === 'object' &&
             report !== null &&
@@ -949,10 +989,13 @@ export class EventChainViewer {
                 : {}),
             resources: [
                 { name, mimeType: 'application/json' },
-                ...(input.mode === 'scan'
+                ...(input.mode === 'scan' && !snapshotOmitted
                     ? [{ name: graphSnapshotName, mimeType: 'application/json' }]
                     : []),
             ],
+            ...(snapshotOmitted
+                ? { graphSnapshotOmitted: { maximumBytes: EVENT_GRAPH_SNAPSHOT_MAX_BYTES } }
+                : {}),
             report,
         })}\n`;
         const workspace = this.engine.resolver.get(input.workspaceId, input.principal);
@@ -960,8 +1003,8 @@ export class EventChainViewer {
             mode: input.mode,
             ...(input.selector === undefined ? {} : { selector: input.selector }),
         }, input.signal), `Authoritative Event Chain Viewer ${input.mode.replaceAll('_', ' ')} report`, input.signal);
-        const graphArtifact = input.mode === 'scan'
-            ? await this.engine.artifacts.putChunked(workspace, graphSnapshotName, 'application/json', `${canonicalJson({ schemaVersion: 'event-graph-snapshot.v1', graph })}\n`, eventProvenance(graph, 'event-graph-snapshot', { revision: graph.revision, graphHash }, input.signal), 'Revision-addressed Event Chain Viewer graph snapshot', input.signal)
+        const graphArtifact = graphSnapshot !== undefined && !snapshotOmitted
+            ? await this.engine.artifacts.putChunked(workspace, graphSnapshotName, 'application/json', `${canonicalJson(graphSnapshot)}\n`, eventProvenance(graph, 'event-graph-snapshot', { revision: graph.revision, graphHash }, input.signal), 'Revision-addressed Event Chain Viewer graph snapshot', input.signal)
             : undefined;
         return {
             graph,
@@ -970,6 +1013,8 @@ export class EventChainViewer {
             report,
             reportJson,
             artifacts: [artifact, ...(graphArtifact === undefined ? [] : [graphArtifact])],
+            ...(snapshotOmitted ? { graphSnapshotOmitted: true } : {}),
+            summary,
         };
     }
     async renderAndStore(input) {
@@ -1001,25 +1046,38 @@ export class EventChainViewer {
             graph.nodes.length > render.selectedNodeIds.length
             ? coherentBranchPartitions(graph, branchNodeLimit, 64, input.signal)
             : { groups: [], omittedNodeIds: [] };
-        const branchGroups = partitions.groups;
-        for (const [branchIndex, nodeIds] of branchGroups.entries()) {
+        // Branch images share the request's raster budget with the overview. When it is spent, the
+        // remaining branches are listed as omitted instead of failing the whole render.
+        let budgetOmittedBranches = 0;
+        for (const [branchIndex, nodeIds] of partitions.groups.entries()) {
             input.signal?.throwIfAborted();
-            branches.push(await renderEventGraph(graph, {
-                view: 'neighborhood',
-                selector: {
-                    kind: 'manifest',
-                    manifest: { id: `overview-branch-${branchIndex + 1}`, nodeIds },
-                },
-                direction: 'both',
-                maxDepth: 0,
-                maxNodes: branchNodeLimit,
-                expandHelpers: input.expandHelpers ?? false,
-                includeHtml: false,
-                compactLayout: true,
-                budget,
-                ...(input.signal === undefined ? {} : { signal: input.signal }),
-            }));
+            let branch;
+            try {
+                branch = await renderEventGraph(graph, {
+                    view: 'neighborhood',
+                    selector: {
+                        kind: 'manifest',
+                        manifest: { id: `overview-branch-${branchIndex + 1}`, nodeIds },
+                    },
+                    direction: 'both',
+                    maxDepth: 0,
+                    maxNodes: branchNodeLimit,
+                    expandHelpers: input.expandHelpers ?? false,
+                    includeHtml: false,
+                    compactLayout: true,
+                    budget,
+                    ...(input.signal === undefined ? {} : { signal: input.signal }),
+                });
+            }
+            catch (error) {
+                if (!(error instanceof ServiceError) || error.code !== 'RENDER_AGGREGATE_BLOCKED')
+                    throw error;
+                budgetOmittedBranches = partitions.groups.length - branchIndex;
+                break;
+            }
+            branches.push(branch);
         }
+        const branchGroups = partitions.groups.slice(0, branches.length);
         const prefix = safeSlug(`event-${input.view}-${graph.revision.slice(0, 12)}`);
         const manifestName = `${prefix}-manifest.json`;
         const resourceNames = {
@@ -1165,7 +1223,8 @@ export class EventChainViewer {
                 omittedNodeCount: partitions.omittedNodeIds.length,
                 omittedNodeIds: partitions.omittedNodeIds,
                 omittedNodeHash: hashCanonical(partitions.omittedNodeIds),
-                truncated: partitions.omittedNodeIds.length > 0,
+                budgetOmittedBranches,
+                truncated: partitions.omittedNodeIds.length > 0 || budgetOmittedBranches > 0,
             },
         })}\n`;
         const manifestArtifact = await this.engine.artifacts.putChunked(workspace, manifestName, 'application/json', manifestJson, provenance, `Event-chain ${input.view} render and bounded branch manifest`, input.signal);
@@ -1175,6 +1234,7 @@ export class EventChainViewer {
             graphHash: cachedEventGraphHash(graph, input.signal),
             render,
             branches,
+            budgetOmittedBranches,
             manifestJson,
             artifacts,
         };