hoi4-agent-tools 1.2.0 → 2.1.0

package/CHANGELOG.md

@@ -1,9 +1,29 @@
 # 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.
+- 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
 
 - Added a read-only Event Chain Viewer for scanning, tracing, explaining, linting, rendering, and comparing large HOI4 event chains.
-- Kept the event surface to three tools with seven inspect modes and linked authoritative graph artifacts, bringing the public surface to thirteen tools within the fixed discovery budget.
+- Kept the event surface to three tools with seven inspect modes and linked authoritative graph artifacts, keeping the public surface to twelve tools within the fixed discovery budget. Local calls now resolve the mod containing the MCP working directory.
 - Added event workflow documentation, package and Registry metadata, and project-owned acceptance coverage for more than 300 event definitions.
 - Reconfirmed MCP protocol `2025-11-25`, TypeScript SDK 1.29.0, Registry schema `2025-12-11`, and Registry publisher 1.7.9 for this release.
 

package/README.md

@@ -1,6 +1,6 @@
 # HOI4 Agent Tools
 
-HOI4 Agent Tools is an MCP server for coding agents to analyze Hearts of Iron IV event chains and inspect, create, or clean up focus trees, scripted GUIs, and maps. It works directly with configured mod folders and produces offline renders for review.
+HOI4 Agent Tools is an MCP server for coding agents to analyze Hearts of Iron IV event chains and inspect, create, or clean up focus trees, scripted GUIs, and maps. Start it in a mod folder and it works there immediately, with offline renders for review.
 
 ## What it does
 
@@ -14,11 +14,10 @@ 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@1.2.0
-hoi4-agent-tools-setup --init
+npm install --global hoi4-agent-tools@latest
 ```
 
-`--init` discovers the usual HOI4 game and mod locations and writes the default per-user configuration. No `HOI4_AGENT_CONFIG` environment variable is needed. For custom paths, multiple mod roots, or a custom config location, see [Setup](docs/setup.md).
+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).
 
 ## Connect your agent
 
@@ -32,9 +31,9 @@ Paste the printed Codex or generic global-install entry into your MCP client, th
 
 | Tool                 | Purpose                                                                                 |
 | -------------------- | --------------------------------------------------------------------------------------- |
-| `hoi4.mods`          | List the writable mods available to the coding agent.                                   |
 | `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.                                              |
@@ -56,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/core/workspace.js

@@ -4,6 +4,8 @@ import { WORKSPACE_MAX_REGISTRATIONS, workspaceRegistrationSchema, } from './con
 import { compareCodeUnits, hashCanonical, sha256Bytes } from './canonical.js';
 import { ServiceError } from './result.js';
 import { ServerState } from './server-state.js';
+/** Omitted MCP workspace arguments resolve to the mod containing the server cwd. */
+export const CURRENT_WORKSPACE_ID = 'current';
 async function exists(value, signal) {
     signal?.throwIfAborted();
     try {
@@ -185,6 +187,9 @@ export class WorkspaceResolver {
             }
         }
         for (const configured of configuration.workspaces) {
+            if (configured.id === CURRENT_WORKSPACE_ID) {
+                throw new ServiceError('WORKSPACE_ID_RESERVED', `Workspace ID is reserved for the current working mod: ${CURRENT_WORKSPACE_ID}`);
+            }
             const registration = resolver.withGlobalWorkspaceDefaults(configured);
             const workspace = await resolver.resolveRegistration(registration);
             if (resolver.#byId.has(workspace.id)) {
@@ -203,6 +208,28 @@ export class WorkspaceResolver {
     config() {
         return this.configuration;
     }
+    /** Resolve the implicit workspace used by local coding-agent calls. */
+    resolveCurrentWorkspaceId(principal) {
+        const workspaces = this.list(principal).filter(({ registration }) => registration.kind === 'mod');
+        if (workspaces.length === 0) {
+            throw new ServiceError('WORKSPACE_CONTEXT_NOT_FOUND', 'No writable mod workspace is configured for the MCP server');
+        }
+        const currentDirectory = path.normalize(process.cwd());
+        const containing = workspaces.filter((workspace) => isWithin(workspace.modRoot, currentDirectory));
+        if (containing.length === 1)
+            return containing[0].id;
+        if (containing.length > 1) {
+            throw new ServiceError('WORKSPACE_CONTEXT_AMBIGUOUS', 'The MCP working directory is inside more than one writable mod workspace', { currentDirectory });
+        }
+        if (workspaces.length === 1)
+            return workspaces[0].id;
+        throw new ServiceError('WORKSPACE_CONTEXT_REQUIRED', 'The MCP working directory does not identify one writable mod workspace', { currentDirectory, workspaceIds: workspaces.map(({ id }) => id) });
+    }
+    resolveWorkspaceId(workspaceId, principal) {
+        return workspaceId === CURRENT_WORKSPACE_ID
+            ? this.resolveCurrentWorkspaceId(principal)
+            : workspaceId;
+    }
     serverState() {
         return this.#serverState;
     }
@@ -276,15 +303,16 @@ export class WorkspaceResolver {
             .sort((a, b) => compareCodeUnits(a.id, b.id));
     }
     get(workspaceId, principal) {
-        if (principal !== undefined && !this.allowedWorkspaceIds(principal).has(workspaceId)) {
+        const resolvedWorkspaceId = this.resolveWorkspaceId(workspaceId, principal);
+        if (principal !== undefined && !this.allowedWorkspaceIds(principal).has(resolvedWorkspaceId)) {
             throw new ServiceError('WORKSPACE_INACCESSIBLE', 'Workspace is unavailable to the authenticated principal');
         }
-        const workspace = this.#byId.get(workspaceId);
+        const workspace = this.#byId.get(resolvedWorkspaceId);
         if (workspace === undefined) {
             if (principal !== undefined) {
                 throw new ServiceError('WORKSPACE_INACCESSIBLE', 'Workspace is unavailable to the authenticated principal');
             }
-            throw new ServiceError('WORKSPACE_NOT_REGISTERED', `Workspace is not registered: ${workspaceId}`);
+            throw new ServiceError('WORKSPACE_NOT_REGISTERED', `Workspace is not registered: ${resolvedWorkspaceId}`);
         }
         return workspace;
     }