hoi4-agent-tools 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -1,11 +1,24 @@
 # Changelog
 
+## 2.1.0 - 2026-07-18
+
+- Added `hoi4.focus_raster` for decoded focus icons and deterministic PNG reviews while keeping inspection, vector rendering, and rewrites responsive on very large trees.
+- Added public MCP regressions that create, compact, inspect, render, and rasterize 1,024-focus trees, including a separate 1,024-distinct-icon raster workload.
+- Replaced the quadratic large-source diff ceiling with a deterministic linear-memory patience diff so large rewrites still return exact review artifacts.
+- Raised distinct raster-operation capacity for large icon sets and deduplicated GUI sprite-frame raster work by texture and frame.
+- Separated full localisation inventories from connected map topology limits and raised the shared index capacity for installed-game scale.
+- Added automatic generated-artifact retention so long-running agent workflows reclaim older artifacts instead of stopping at the storage ceiling.
+- Made broad GUI inspection index only connected localisation, reuse decoded textures, and return bounded workspace projections for very large source graphs.
+- Made broad event scans structural by default, with helper expansion in focused queries and compact indexed resources for very large graphs.
+- Suppressed unrelated vanilla parser noise while retaining mod and dependency diagnostics that affect the requested content.
+- Added regressions for 500,100 localisation records, 1,024 distinct focus textures, large GUI and event graphs, raster discovery, package installation, and agent workflows.
+
 ## 2.0.0 - 2026-07-15
 
 - Removed the workspace inventory tool and made the current mod implicit for local MCP calls.
 - Starting the server inside any mod now works without a config file or per-mod setup command.
 - Updated the published client examples, Registry metadata, and installation verification for the twelve-tool surface.
-- Rendered unresolved scripted localisation values as `[X]` and applied supported HOI4 `§` text colours in offline GUI previews.
+- Distinguished unresolved numeric values (`[X]`) from unresolved text-returning dynamic localisation (`[dynamic_loc]`) and applied supported HOI4 `§` text colours in offline GUI previews.
 
 ## 1.2.0 - 2026-07-13
 

package/README.md

@@ -14,7 +14,7 @@ HOI4 Agent Tools is an MCP server for coding agents to analyze Hearts of Iron IV
 Requires Node.js 22 or 24.
 
 ```bash
-npm install --global hoi4-agent-tools@2.0.0
+npm install --global hoi4-agent-tools@latest
 ```
 
 Start the MCP with its working directory set to the mod you are editing. No config or per-mod registration is required: the server finds that mod automatically. Run `hoi4-agent-tools-setup --init` only when you want persistent discovery for several mod roots, a custom game path, or a remote deployment; see [Setup](docs/setup.md).
@@ -32,7 +32,8 @@ Paste the printed Codex or generic global-install entry into your MCP client, th
 | Tool                 | Purpose                                                                                 |
 | -------------------- | --------------------------------------------------------------------------------------- |
 | `hoi4.focus_inspect` | Read focus trees and report structural or reference problems.                           |
-| `hoi4.focus_render`  | Render an existing focus tree or continuous palette.                                    |
+| `hoi4.focus_render`  | Produce fast HTML, SVG, JSON, and source-linked layout artifacts.                       |
+| `hoi4.focus_raster`  | Produce a high-fidelity PNG review with decoded source icons.                           |
 | `hoi4.focus_rewrite` | Create or update a focus tree.                                                          |
 | `hoi4.gui_inspect`   | Read a scripted GUI and its linked assets and logic.                                    |
 | `hoi4.gui_render`    | Render GUI states and resolutions offline.                                              |
@@ -54,7 +55,7 @@ Connecting and listing tools does not scan mod source. Compact tool schemas and
 
 ## Create or clean content
 
-Ask your agent in normal task language. A typical workflow is inspect, render, rewrite, then inspect the result.
+Ask your agent in normal task language. A typical workflow is inspect, render, rewrite, then inspect the result. The agent can call a raster tool when a pixel review is useful without paying that cost during every structural operation.
 
 - Focus trees: "Create a complete national focus tree for this route specification," or "Compact this existing tree into a balanced, readable layout." Existing trees can use a plan-free compact reflow; new trees use a complete plan. See [Focus trees](docs/focus.md).
 - Scripted GUIs: "Create a scripted GUI for this mechanic," or "Render this window at common resolutions and fix clipping, missing assets, and click-region conflicts." See [Scripted GUIs](docs/gui.md).

package/dist/hoi4_agent_tools/core/artifacts.js

@@ -462,6 +462,114 @@ export class ArtifactStore {
         this.maxEntries = maxEntries;
         this.maxSingleBytes = maxSingleBytes;
     }
+    async pruneForAdmission(workspace, usage, additionalBytes, additionalEntries, protectedManifests, protectedTargets, signal) {
+        if (usage.entries + additionalEntries <= this.maxEntries &&
+            usage.bytes <= this.maxBytes - additionalBytes) {
+            return usage;
+        }
+        // Reclaim to a low-water mark so a busy agent workflow does not rescan and evict one artifact
+        // for every subsequent tool call. The incoming batch itself remains protected and atomic.
+        const targetBytes = Math.max(0, Math.min(this.maxBytes - additionalBytes, Math.floor(this.maxBytes * 0.75)));
+        const targetEntries = Math.max(0, Math.min(this.maxEntries - additionalEntries, Math.floor(this.maxEntries * 0.75)));
+        const retained = [];
+        const walk = async (directory) => {
+            signal?.throwIfAborted();
+            let children;
+            try {
+                children = await readdir(directory, { withFileTypes: true });
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    return;
+                throw error;
+            }
+            for (const child of children) {
+                signal?.throwIfAborted();
+                if (child.isSymbolicLink()) {
+                    throw new ServiceError('ARTIFACT_STORAGE_UNSAFE', 'Artifact storage contains a symbolic link or junction');
+                }
+                const candidate = await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, path.join(directory, child.name)));
+                if (child.isDirectory()) {
+                    await walk(candidate);
+                    continue;
+                }
+                if (!child.isFile() || !child.name.endsWith('.manifest.json'))
+                    continue;
+                const metadata = await lstat(candidate);
+                const manifest = await readArtifactManifest(candidate, signal);
+                if (child.name !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`) {
+                    throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest filename does not match its contents');
+                }
+                assertManifestIntegrity(manifest, {
+                    sha256: path.basename(directory),
+                    provenanceHash: manifest.provenanceHash,
+                    name: manifest.name,
+                }, workspace);
+                const targetPath = await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, path.join(directory, manifest.name)));
+                let targetBytes = 0;
+                try {
+                    targetBytes = (await stat(targetPath)).size;
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+                retained.push({
+                    manifest,
+                    manifestPath: candidate,
+                    manifestBytes: metadata.size,
+                    modifiedAt: metadata.mtimeMs,
+                    targetPath,
+                    targetBytes,
+                });
+            }
+        };
+        await walk(await containedGeneratedPath(workspace.artifactRoot));
+        retained.sort((left, right) => left.modifiedAt - right.modifiedAt ||
+            compareCodeUnits(left.manifestPath, right.manifestPath));
+        const current = { ...usage };
+        for (const candidate of retained) {
+            signal?.throwIfAborted();
+            if (current.bytes <= targetBytes && current.entries <= targetEntries)
+                break;
+            if (protectedManifests.has(candidate.manifestPath))
+                continue;
+            try {
+                await unlink(candidate.manifestPath);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            current.entries = Math.max(0, current.entries - 1);
+            current.bytes = Math.max(0, current.bytes - candidate.manifestBytes);
+            if (protectedTargets.has(candidate.targetPath))
+                continue;
+            const prefix = `${candidate.manifest.name}.`;
+            const hasManifest = (await readdir(path.dirname(candidate.targetPath), { withFileTypes: true })).some((entry) => entry.isFile() && entry.name.startsWith(prefix) && entry.name.endsWith('.manifest.json'));
+            if (hasManifest)
+                continue;
+            try {
+                await unlink(candidate.targetPath);
+                current.bytes = Math.max(0, current.bytes - candidate.targetBytes);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            const verificationPrefix = `${workspace.workspaceIdentity}\0${workspace.ownerIdentity}\0${candidate.targetPath}\0`;
+            for (const key of this.#verifiedContent.keys()) {
+                if (key.startsWith(verificationPrefix))
+                    this.#verifiedContent.delete(key);
+            }
+        }
+        if (current.entries + additionalEntries > this.maxEntries ||
+            current.bytes > this.maxBytes - additionalBytes) {
+            throw new ServiceError('ARTIFACT_STORAGE_LIMIT', 'Artifact batch cannot fit after reclaiming expired artifacts');
+        }
+        return current;
+    }
     async list(workspace, signal) {
         signal?.throwIfAborted();
         const usage = await artifactUsage(workspace.artifactRoot, signal);
@@ -902,10 +1010,7 @@ export class ArtifactStore {
             }
             const usage = await artifactUsage(workspace.artifactRoot, signal);
             const additionalEntries = [...uniqueManifests.values()].filter((artifact) => !artifact.exists).length;
-            if (usage.entries + additionalEntries > this.maxEntries ||
-                usage.bytes > this.maxBytes - additionalBytes) {
-                throw new ServiceError('ARTIFACT_STORAGE_LIMIT', 'Artifact storage retention limit has been reached');
-            }
+            await this.pruneForAdmission(workspace, usage, additionalBytes, additionalEntries, new Set(uniqueManifests.keys()), new Set(uniqueTargets.keys()), signal);
             const createdTargets = [];
             const createdManifests = [];
             try {

package/dist/hoi4_agent_tools/core/diagnostic-collector.js

@@ -4,6 +4,8 @@ export class DiagnosticCollector {
     truncation;
     items = [];
     dropped = 0;
+    droppedBySeverity = {};
+    droppedByCode = {};
     constructor(maximum, truncation) {
         this.maximum = maximum;
         this.truncation = truncation;
@@ -17,27 +19,45 @@ export class DiagnosticCollector {
             if (this.items.length < Math.max(0, this.maximum - 1))
                 this.items.push(diagnostic);
             else {
-                this.dropped += 1;
-                if (diagnostic.severity === 'blocker' &&
-                    !this.items.some(({ code, severity }) => code === diagnostic.code && severity === 'blocker')) {
-                    const replacement = this.items.findLastIndex(({ severity }) => severity !== 'blocker');
-                    if (replacement >= 0)
-                        this.items[replacement] = diagnostic;
+                const hard = diagnostic.severity === 'error' || diagnostic.severity === 'blocker';
+                const replacement = hard
+                    ? this.items.findLastIndex(({ severity }) => severity !== 'error' && severity !== 'blocker')
+                    : -1;
+                if (replacement >= 0) {
+                    const replaced = this.items[replacement];
+                    this.items[replacement] = diagnostic;
+                    this.recordDropped(replaced);
+                }
+                else {
+                    this.recordDropped(diagnostic);
                 }
             }
         }
     }
+    recordDropped(diagnostic) {
+        this.dropped += 1;
+        this.droppedBySeverity[diagnostic.severity] =
+            (this.droppedBySeverity[diagnostic.severity] ?? 0) + 1;
+        this.droppedByCode[diagnostic.code] = (this.droppedByCode[diagnostic.code] ?? 0) + 1;
+    }
     values() {
         if (this.dropped === 0)
             return [...this.items];
+        const hardDropped = (this.droppedBySeverity.error ?? 0) + (this.droppedBySeverity.blocker ?? 0) > 0;
         return [
             ...this.items,
             {
                 code: this.truncation.code,
-                severity: 'blocker',
+                severity: hardDropped ? 'blocker' : 'info',
                 category: this.truncation.category,
                 message: this.truncation.message,
-                details: { retained: this.items.length, dropped: this.dropped, maximum: this.maximum },
+                details: {
+                    retained: this.items.length,
+                    dropped: this.dropped,
+                    maximum: this.maximum,
+                    droppedBySeverity: this.droppedBySeverity,
+                    droppedByCode: this.droppedByCode,
+                },
             },
         ];
     }

package/dist/hoi4_agent_tools/core/diff.js

@@ -25,9 +25,13 @@ function lcsDiff(oldLines, newLines, options) {
     const columns = newLines.length + 1;
     const cells = (oldLines.length + 1) * columns;
     const maxMatrixCells = options.maxMatrixCells ?? defaultMaxMatrixCells;
-    if (!Number.isSafeInteger(cells) || cells > maxMatrixCells) {
-        throw new ServiceError('DIFF_COMPLEXITY_LIMIT', 'Exact source diff exceeds the configured deterministic memory bound', { oldLines: oldLines.length, newLines: newLines.length, cells, maxMatrixCells });
-    }
+    if (!Number.isSafeInteger(cells) || cells > maxMatrixCells)
+        return patienceDiff(oldLines, newLines, maxMatrixCells, options.signal);
+    return matrixDiff(oldLines, newLines, options);
+}
+function matrixDiff(oldLines, newLines, options) {
+    const columns = newLines.length + 1;
+    const cells = (oldLines.length + 1) * columns;
     const table = new Uint32Array(cells);
     for (let oldIndex = oldLines.length - 1; oldIndex >= 0; oldIndex -= 1) {
         if ((oldIndex & 0x3f) === 0)
@@ -68,6 +72,161 @@ function lcsDiff(oldLines, newLines, options) {
     }
     return result;
 }
+function uniqueLineIndexes(lines, start, end) {
+    const indexes = new Map();
+    const repeated = new Set();
+    for (let index = start; index < end; index += 1) {
+        const line = lines[index];
+        if (repeated.has(line))
+            continue;
+        if (indexes.has(line)) {
+            indexes.delete(line);
+            repeated.add(line);
+        }
+        else
+            indexes.set(line, index);
+    }
+    return indexes;
+}
+function patienceAnchors(oldLines, newLines, range, signal) {
+    const oldUnique = uniqueLineIndexes(oldLines, range.oldStart, range.oldEnd);
+    const newUnique = uniqueLineIndexes(newLines, range.newStart, range.newEnd);
+    const candidates = [];
+    let visited = 0;
+    for (const [line, oldIndex] of oldUnique) {
+        if ((visited & 0x3ff) === 0)
+            signal?.throwIfAborted();
+        visited += 1;
+        const newIndex = newUnique.get(line);
+        if (newIndex !== undefined)
+            candidates.push({ oldIndex, newIndex });
+    }
+    candidates.sort((left, right) => left.oldIndex - right.oldIndex);
+    if (candidates.length <= 1)
+        return candidates;
+    const tails = [];
+    const previous = new Int32Array(candidates.length);
+    previous.fill(-1);
+    for (let index = 0; index < candidates.length; index += 1) {
+        if ((index & 0x3ff) === 0)
+            signal?.throwIfAborted();
+        const newIndex = candidates[index].newIndex;
+        let low = 0;
+        let high = tails.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if (candidates[tails[middle]].newIndex < newIndex)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        if (low > 0)
+            previous[index] = tails[low - 1];
+        tails[low] = index;
+    }
+    const anchors = new Array(tails.length);
+    let current = tails.at(-1);
+    for (let index = anchors.length - 1; index >= 0; index -= 1) {
+        anchors[index] = candidates[current];
+        current = previous[current];
+    }
+    return anchors;
+}
+function patienceDiff(oldLines, newLines, matrixThreshold, signal) {
+    const result = [];
+    const tasks = [
+        {
+            kind: 'range',
+            oldStart: 0,
+            oldEnd: oldLines.length,
+            newStart: 0,
+            newEnd: newLines.length,
+        },
+    ];
+    let iterations = 0;
+    while (tasks.length > 0) {
+        if ((iterations & 0xff) === 0)
+            signal?.throwIfAborted();
+        iterations += 1;
+        const task = tasks.pop();
+        if (task.kind !== 'range') {
+            const lines = task.kind === 'add' ? newLines : oldLines;
+            const prefix = task.kind === 'same' ? ' ' : task.kind === 'add' ? '+' : '-';
+            for (let index = task.start; index < task.end; index += 1)
+                result.push(`${prefix}${lineContent(lines[index])}`);
+            continue;
+        }
+        let { oldStart, oldEnd, newStart, newEnd } = task;
+        while (oldStart < oldEnd && newStart < newEnd && oldLines[oldStart] === newLines[newStart]) {
+            result.push(` ${lineContent(oldLines[oldStart])}`);
+            oldStart += 1;
+            newStart += 1;
+        }
+        let commonSuffix = 0;
+        while (oldStart < oldEnd - commonSuffix &&
+            newStart < newEnd - commonSuffix &&
+            oldLines[oldEnd - commonSuffix - 1] === newLines[newEnd - commonSuffix - 1])
+            commonSuffix += 1;
+        oldEnd -= commonSuffix;
+        newEnd -= commonSuffix;
+        if (commonSuffix > 0)
+            tasks.push({ kind: 'same', start: oldEnd, end: oldEnd + commonSuffix });
+        if (oldStart === oldEnd) {
+            if (newStart < newEnd)
+                tasks.push({ kind: 'add', start: newStart, end: newEnd });
+            continue;
+        }
+        if (newStart === newEnd) {
+            tasks.push({ kind: 'delete', start: oldStart, end: oldEnd });
+            continue;
+        }
+        const rangeCells = (oldEnd - oldStart + 1) * (newEnd - newStart + 1);
+        if (Number.isSafeInteger(rangeCells) && rangeCells <= matrixThreshold) {
+            const rows = matrixDiff(oldLines.slice(oldStart, oldEnd), newLines.slice(newStart, newEnd), {
+                maxMatrixCells: matrixThreshold,
+                ...(signal === undefined ? {} : { signal }),
+            });
+            result.push(...rows);
+            continue;
+        }
+        const range = { kind: 'range', oldStart, oldEnd, newStart, newEnd };
+        const anchors = patienceAnchors(oldLines, newLines, range, signal);
+        if (anchors.length === 0) {
+            tasks.push({ kind: 'add', start: newStart, end: newEnd });
+            tasks.push({ kind: 'delete', start: oldStart, end: oldEnd });
+            continue;
+        }
+        const ordered = [];
+        let previousOld = oldStart;
+        let previousNew = newStart;
+        for (const anchor of anchors) {
+            if (previousOld < anchor.oldIndex || previousNew < anchor.newIndex) {
+                ordered.push({
+                    kind: 'range',
+                    oldStart: previousOld,
+                    oldEnd: anchor.oldIndex,
+                    newStart: previousNew,
+                    newEnd: anchor.newIndex,
+                });
+            }
+            ordered.push({ kind: 'same', start: anchor.oldIndex, end: anchor.oldIndex + 1 });
+            previousOld = anchor.oldIndex + 1;
+            previousNew = anchor.newIndex + 1;
+        }
+        if (previousOld < oldEnd || previousNew < newEnd) {
+            ordered.push({
+                kind: 'range',
+                oldStart: previousOld,
+                oldEnd,
+                newStart: previousNew,
+                newEnd,
+            });
+        }
+        for (let index = ordered.length - 1; index >= 0; index -= 1)
+            tasks.push(ordered[index]);
+    }
+    return result;
+}
 export function binaryDiff(oldBytes, newBytes) {
     const length = Math.max(oldBytes.length, newBytes.length);
     let changedBytes = 0;
@@ -89,4 +248,3 @@ export function binaryDiff(oldBytes, newBytes) {
             : { firstChangedOffset, lastChangedOffset: lastChangedOffset }),
     };
 }
-import { ServiceError } from './result.js';

package/dist/hoi4_agent_tools/core/engine.js

@@ -119,6 +119,7 @@ export class CoreEngine {
         const requestKey = `${workspaceId}:${generation}:${hashCanonical({
             patterns: [...patterns].sort(),
             ignore: [...(ignore ?? [])].sort(),
+            rootKinds: [...(options.rootKinds ?? [])].sort(),
             maxFiles: options.maxFiles ?? this.resolver.config().scanMaxFiles,
             maxBytes: options.maxBytes ?? this.resolver.config().scanMaxBytes,
         })}`;
@@ -130,6 +131,7 @@ export class CoreEngine {
                     const files = await this.scanner.scan(workspace, {
                         patterns,
                         ...(ignore === undefined ? {} : { ignore }),
+                        ...(options.rootKinds === undefined ? {} : { rootKinds: options.rootKinds }),
                         ...(options.maxFiles === undefined ? {} : { maxFiles: options.maxFiles }),
                         ...(options.maxBytes === undefined ? {} : { maxBytes: options.maxBytes }),
                         signal: controller.signal,

package/dist/hoi4_agent_tools/core/index.js

@@ -39,7 +39,7 @@ const decisionCategoryFields = new Set([
 // before the higher-precedence mod roots are reached. Keep the inventory
 // bounded, but leave enough headroom for the supported game build and a large
 // external workspace so valid mod symbols are never discarded behind vanilla.
-const INDEX_RECORD_LIMIT = 500_000;
+const INDEX_RECORD_LIMIT = 2_000_000;
 const INDEX_DIAGNOSTIC_LIMIT = 10_000;
 const INDEX_RELATED_LOCATION_LIMIT = 100;
 const INDEX_TABLE_RECORD_LIMIT = 100_000;
@@ -125,6 +125,9 @@ function normalizedRelative(value) {
 function sourceIdentity(file) {
     return `${file.rootKind}:${file.loadOrder}`;
 }
+function isWorkspaceOwnedSource(file) {
+    return file?.rootKind === 'mod' || file?.rootKind === 'fixture';
+}
 function selectedDefinitionFiles(files) {
     const defaults = files.filter(({ relativePath }) => path.posix.basename(normalizedRelative(relativePath)) === 'default.map');
     const directories = [
@@ -257,11 +260,15 @@ export class SymbolIndex {
     recordSkippedSource(file, diagnostics) {
         if (file.shadowedBy !== undefined || this.#skippedSourcePaths.has(file.displayPath))
             return;
+        const candidates = possibleSymbolKinds(file, this.#definitionFiles);
+        // Files outside indexed HOI4 domains may still match broad text globs. A parsing ceiling in one
+        // of those files does not make the symbol inventory partial.
+        if (candidates.length === 0)
+            return;
         this.#skippedSourcePaths.add(file.displayPath);
         this.#complete = false;
         this.#skippedSourceCount += 1;
         const reasonCodes = [...new Set(diagnostics.map(({ code }) => code))].sort((left, right) => compareCodeUnits(left, right));
-        const candidates = possibleSymbolKinds(file, this.#definitionFiles);
         for (const kind of candidates)
             this.#skippedPossibleSymbolKinds.add(kind);
         if (this.skippedSources.length >= INDEX_SKIPPED_SOURCE_SAMPLE_LIMIT)
@@ -361,7 +368,8 @@ export class SymbolIndex {
                 this.recordSkippedSource(file, limitDiagnostics);
                 return;
             }
-            this.addDiagnostics(document.diagnostics);
+            if (isWorkspaceOwnedSource(file))
+                this.addDiagnostics(document.diagnostics);
             for (const entry of document.entries) {
                 this.addSymbol({
                     kind: 'localisation',
@@ -401,7 +409,8 @@ export class SymbolIndex {
             this.recordSkippedSource(file, limitDiagnostics);
             return;
         }
-        this.addDiagnostics(document.diagnostics);
+        if (isWorkspaceOwnedSource(file))
+            this.addDiagnostics(document.diagnostics);
         this.walkBlock(document, document.root, file, []);
         if (this.#currentFileShadowed) {
             this.diagnostics.splice(diagnosticStart);
@@ -932,7 +941,9 @@ export class SymbolIndex {
                 candidate.overridden = additiveCategory ? candidate.sourceShadowed : candidate !== active;
             }
             const sameLevel = candidates.filter(({ loadOrder }) => loadOrder === active.loadOrder);
-            if (!additiveCategory && sameLevel.length > 1) {
+            if (!additiveCategory &&
+                sameLevel.length > 1 &&
+                sameLevel.some((candidate) => isWorkspaceOwnedSource(this.files.get(candidate.path)))) {
                 this.addDiagnostic({
                     code: 'INDEX_SYMBOL_COLLISION',
                     severity: 'error',
@@ -945,7 +956,7 @@ export class SymbolIndex {
                 });
             }
         }
-        for (const reference of this.unresolvedReferences()) {
+        for (const reference of this.unresolvedReferences().filter((candidate) => isWorkspaceOwnedSource(this.files.get(candidate.path)))) {
             const mayResolveFromSkippedSource = this.#skippedPossibleSymbolKinds.has(reference.toKind);
             this.addDiagnostic({
                 code: mayResolveFromSkippedSource

package/dist/hoi4_agent_tools/core/render-budget.js

@@ -3,7 +3,7 @@ import { ServiceError } from './result.js';
  * Fixed process-safety ceilings for decoded rasters and offline render artifacts.
  *
  * The per-artifact ceiling permits the vanilla 5632x2048 map at scale 2 and the
- * committed 255-focus benchmark. Aggregate reservations account for every
+ * committed 1,024-focus benchmarks. Aggregate reservations account for every
  * variant in one service request and cap their combined RGBA-equivalent area.
  */
 export const RENDER_MAX_DIMENSION = 16_384;
@@ -14,8 +14,10 @@ export const RENDER_MAX_DECODED_PIXELS = 16_777_216;
 export const RENDER_MAX_ENCODED_IMAGE_BYTES = 33_554_432;
 // 64 Mi pixels preserves one vanilla scale-1 before/proposed/diff map request.
 export const RENDER_MAX_AGGREGATE_PIXELS = 67_108_864;
-// A selected scene may reuse assets freely, but cannot trigger graph-scale decoder work.
-export const RENDER_MAX_DISTINCT_RASTER_OPERATIONS = 512;
+// Large focus and GUI surfaces can legitimately contain hundreds of distinct textures and frames.
+// The aggregate pixel budget remains the primary memory bound while this ceiling prevents runaway
+// decoder fan-out from malformed graphs.
+export const RENDER_MAX_DISTINCT_RASTER_OPERATIONS = 4_096;
 /** Return a deterministic violation without allocating or throwing. */
 export function renderDimensionViolation(width, height, label = 'render artifact', limits = {}) {
     const maximumDimension = Math.min(RENDER_MAX_DIMENSION, limits.maximumDimension ?? RENDER_MAX_DIMENSION);

package/dist/hoi4_agent_tools/core/scanner.js

@@ -43,10 +43,11 @@ export class WorkspaceScanner {
             throw new ServiceError('SCAN_LIMIT_EXCEEDS_POLICY', 'Requested scan limits exceed the configured server ceiling');
         }
         const roots = workspace.roots
-            .filter((root) => root.kind === 'game' ||
+            .filter((root) => (root.kind === 'game' ||
             root.kind === 'dependency' ||
             root.kind === 'mod' ||
-            root.kind === 'fixture')
+            root.kind === 'fixture') &&
+            (options.rootKinds === undefined || options.rootKinds.includes(root.kind)))
             .sort((a, b) => a.loadOrder - b.loadOrder || compareCodeUnits(a.path, b.path));
         const result = [];
         let totalBytes = 0;

package/dist/hoi4_agent_tools/core/source/limits.js

@@ -1,7 +1,10 @@
 export const SOURCE_DIAGNOSTIC_LIMIT = 100;
 export const SOURCE_MAX_NESTING = 256;
 export const SOURCE_MAX_BYTES = 8_388_608;
-export const SOURCE_TOKEN_LIMIT = 250_000;
+// Large authored HOI4 focus and scripted-effect files can exceed 250k tokens while remaining well
+// below the byte and nesting ceilings. Keep enough room for those files without allowing an
+// unbounded token inventory.
+export const SOURCE_TOKEN_LIMIT = 1_000_000;
 export const SOURCE_ENTRY_LIMIT = 100_000;
 export const SOURCE_LINE_LIMIT = 250_000;
 /**

package/dist/hoi4_agent_tools/event/graph.js

@@ -451,6 +451,26 @@ function helperProjections(graph, budget) {
                 if (projectedKeys.has(projectionKey))
                     continue;
                 projectedKeys.add(projectionKey);
+                if (projected.length >= EVENT_GRAPH_MAX_HELPER_PROJECTIONS) {
+                    addIssue(graph.issues, {
+                        code: 'EVENT_HELPER_PROJECTION_LIMIT',
+                        classification: 'unresolved_analysis',
+                        severity: 'blocker',
+                        message: 'Collapsed helper projection reached its materialization ceiling; structural helper calls remain available.',
+                        confidence: 'unresolved',
+                        location: start.location,
+                        blockers: [
+                            {
+                                code: 'HELPER_PROJECTION_LIMIT',
+                                message: 'Use a bounded helper-expanded trace for paths omitted from the collapsed workspace graph.',
+                                location: start.location,
+                                details: { maximum: EVENT_GRAPH_MAX_HELPER_PROJECTIONS },
+                            },
+                        ],
+                        subjectIds: [start.from, start.to],
+                    });
+                    return stableUnique(projected);
+                }
                 projected.push({
                     id: `edge:helper-projection:${hashCanonical({
                         from: start.from,
@@ -480,9 +500,6 @@ function helperProjections(graph, budget) {
                         terminalDispatchLocation: locationKey(final.location),
                     },
                 });
-                if (projected.length > EVENT_GRAPH_MAX_HELPER_PROJECTIONS) {
-                    throw new ServiceError('EVENT_HELPER_PROJECTION_LIMIT', 'Event-chain helper expansion exceeds the fixed projection ceiling', { maximum: EVENT_GRAPH_MAX_HELPER_PROJECTIONS });
-                }
             }
         }
     }
@@ -1523,7 +1540,8 @@ export function buildEventGraph(snapshot, options = {}) {
     const fragments = analyzeFragments(snapshot, files, catalog, options, budget);
     const graph = mergeFragments(fragments);
     const partial = partialInventoryEvidence(snapshot);
-    graph.unresolved.push(...partial.unresolved);
+    for (const unresolved of partial.unresolved)
+        graph.unresolved.push(unresolved);
     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');
     assertGraphLimit(graph.stateAccesses.length, EVENT_GRAPH_MAX_STATE_ACCESSES, 'EVENT_STATE_ACCESS_LIMIT', 'state-access count');
@@ -1531,8 +1549,12 @@ export function buildEventGraph(snapshot, options = {}) {
     normalizePublicEventNodeIds(graph);
     normalizeCrossFileEdges(graph);
     ensureReferencedNodes(graph);
-    graph.edges.push(...helperProjections(graph, budget));
-    graph.stateAccesses.push(...projectHelperStateAccesses(graph, budget));
+    if (options.projectHelpers !== false) {
+        for (const edge of helperProjections(graph, budget))
+            graph.edges.push(edge);
+        for (const access of projectHelperStateAccesses(graph, budget))
+            graph.stateAccesses.push(access);
+    }
     addTerminalNodes(graph);
     graph.nodes = sortNodes(graph.nodes);
     graph.edges = stableUnique(graph.edges);

package/dist/hoi4_agent_tools/event/limits.js

@@ -1,6 +1,6 @@
 import { ServiceError } from '../core/result.js';
 export const EVENT_GRAPH_MAX_NODES = 100_000;
-export const EVENT_GRAPH_MAX_EDGES = 250_000;
+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;