hoi4-agent-tools 2.0.0 → 2.1.1

package/dist/hoi4_agent_tools/gui/layout.js

@@ -7,6 +7,8 @@ import { GUI_GRAPH_MAX_EDGES, GUI_GRAPH_MAX_ELEMENTS, GUI_GRAPH_MAX_NODES, GUI_S
 import { guiElementAttributeFidelity } from './source-graph.js';
 import { emptyFidelityReport } from './types.js';
 const clickableTypes = /(?:button|checkbox|editbox|scrollbar|progressbar)/iu;
+const numericDynamicPlaceholder = '[X]';
+const textDynamicPlaceholder = '[dynamic_loc]';
 const partialSpriteSemantics = {
     textSpriteType: {
         field: 'text_sprite_semantics',
@@ -215,13 +217,15 @@ function resolveTokenText(value, scenario, localisation, rowValues) {
         const replacement = rowValues?.[key] ?? scenario.variables[key] ?? scenario.scriptedGui[key];
         if (replacement === undefined) {
             unresolved.push(match[0]);
-            return '[X]';
+            return /(?:^|\.)Get[A-Za-z0-9_]+$/u.test(key)
+                ? textDynamicPlaceholder
+                : numericDynamicPlaceholder;
         }
         return String(replacement);
     }, 'GUI variable substitution');
     text = replaceTextBounded(text, /\[([A-Za-z0-9_.:-]+)\]/gu, (match) => {
         const key = match[1] ?? '';
-        if (key === 'X')
+        if (key === 'X' || key === 'dynamic_loc')
             return match[0];
         const countryKey = key.replace(/^(?:ROOT|This)\./u, '');
         const replacement = rowValues?.[countryKey] ??
@@ -230,7 +234,7 @@ function resolveTokenText(value, scenario, localisation, rowValues) {
             scenario.scriptedGui[key];
         if (replacement === undefined) {
             unresolved.push(match[0]);
-            return '[X]';
+            return textDynamicPlaceholder;
         }
         return String(replacement);
     }, 'GUI scope substitution');

package/dist/hoi4_agent_tools/gui/source-graph.js

@@ -736,19 +736,19 @@ function linkGraph(nodes, edges, elements, sprites, fonts, scriptedGuis, scripte
         }
     }
     for (const element of elements) {
-        const spriteName = [element.attributes.spriteType, element.attributes.quadTextureSprite].find((value) => typeof value === 'string');
+        const spriteName = [element.attributes.spriteType, element.attributes.quadTextureSprite].find((value) => typeof value === 'string' && value.trim().length > 0);
         if (spriteName !== undefined) {
             const sprite = spriteByName.get(spriteName);
             addEdge(edges, 'uses_sprite', element.id, sprite?.id ?? `sprite:${spriteName}`, sprite !== undefined, { spriteName }, element.location);
         }
-        const fontName = [element.attributes.font, element.attributes.buttonFont].find((value) => typeof value === 'string');
+        const fontName = [element.attributes.font, element.attributes.buttonFont].find((value) => typeof value === 'string' && value.trim().length > 0);
         if (fontName !== undefined) {
             const font = fontByName.get(fontName);
             addEdge(edges, 'uses_font', element.id, font?.id ?? `font:${fontName}`, font !== undefined, { fontName }, element.location);
         }
-        for (const key of ['text', 'buttonText', 'pdx_tooltip', 'pdx_tooltip_delayed', 'hint_tag']) {
+        for (const key of localisationAttributeNames) {
             const value = element.attributes[key];
-            if (typeof value !== 'string')
+            if (typeof value !== 'string' || value.trim().length === 0)
                 continue;
             const entry = localisationByKey.get(value);
             addEdge(edges, 'uses_localisation', element.id, entry === undefined ? `localisation:${value}` : deterministicId('gui_loc', entry), entry !== undefined, { field: key, key: value }, element.location);
@@ -800,6 +800,24 @@ function linkGraph(nodes, edges, elements, sprites, fonts, scriptedGuis, scripte
         addEdge(edges, 'decision_category_entry', pending.from, target?.id ?? `scripted_gui:${pending.target}`, target !== undefined, { scriptedGui: pending.target }, pending.location);
     }
 }
+const localisationAttributeNames = [
+    'text',
+    'buttonText',
+    'pdx_tooltip',
+    'pdx_tooltip_delayed',
+    'hint_tag',
+];
+function referencedGuiLocalisationKeys(elements, scriptedLocalisation) {
+    const keys = new Set(scriptedLocalisation.flatMap(({ localisationKeys }) => localisationKeys));
+    for (const element of elements) {
+        for (const attribute of localisationAttributeNames) {
+            const value = element.attributes[attribute];
+            if (typeof value === 'string' && value.trim().length > 0)
+                keys.add(value);
+        }
+    }
+    return keys;
+}
 function skippedInventoryCouldResolve(edge, sharedIndex) {
     switch (edge.kind) {
         case 'uses_sprite':
@@ -837,6 +855,10 @@ function* referenceDiagnostics(edges) {
             edge.kind === 'animation_source_frame' ||
             (edge.kind === 'uses_font' && edge.metadata.assetPath !== undefined))
             continue;
+        if (edge.location !== undefined &&
+            !edge.location.path.startsWith('mod:') &&
+            !edge.location.path.startsWith('fixture:'))
+            continue;
         const partial = edge.partialInventory === true;
         yield {
             code: partial ? 'GUI_REFERENCE_UNRESOLVED_PARTIAL' : 'GUI_REFERENCE_UNRESOLVED',
@@ -905,6 +927,7 @@ export function buildGuiSourceGraph(files, sharedIndex) {
     const fontAssetNodes = new Map();
     const animationFrameNodes = new Map();
     const pendingDecisionEdges = [];
+    const localisationFiles = [];
     for (const file of [...activeFiles].sort((a, b) => compareCodeUnits(a.displayPath, b.displayPath))) {
         sourceHashes[file.displayPath] = file.sha256;
         if (sharedIndex.isSourceSkipped(file.displayPath))
@@ -968,28 +991,7 @@ export function buildGuiSourceGraph(files, sharedIndex) {
             }
         }
         if (kind === 'localisation_file' && fileNodeId !== undefined) {
-            const document = parseLocalisation(file.bytes, file.displayPath);
-            diagnostics.pushMany(document.diagnostics);
-            for (const entry of document.entries) {
-                const value = {
-                    key: entry.key,
-                    language: entry.language,
-                    value: entry.value,
-                    sourcePath: file.displayPath,
-                    location: locationFor(file.displayPath, document.lineIndex, entry.start, entry.end),
-                };
-                addDomainEntry(localisation, value, 'localisation');
-                const id = deterministicId('gui_loc', value);
-                addNode(nodes, {
-                    id,
-                    kind: 'localisation',
-                    name: entry.key,
-                    path: file.displayPath,
-                    ...(value.location === undefined ? {} : { location: value.location }),
-                    metadata: { language: entry.language, value: entry.value },
-                });
-                addEdge(edges, 'contains', fileNodeId, id, true, {}, value.location);
-            }
+            localisationFiles.push({ file, fileNodeId });
             continue;
         }
         if (kind === 'animation_source_manifest' && fileNodeId !== undefined) {
@@ -999,13 +1001,15 @@ export function buildGuiSourceGraph(files, sharedIndex) {
         if (kind === undefined || fileNodeId === undefined) {
             if (/\.(?:txt|gui|gfx)$/u.test(normalized)) {
                 const document = parseClausewitz(file.bytes, file.displayPath);
-                diagnostics.pushMany(document.diagnostics);
+                if (file.rootKind === 'mod' || file.rootKind === 'fixture')
+                    diagnostics.pushMany(document.diagnostics);
                 indexDecisionEntries(document, file, nodes, pendingDecisionEdges);
             }
             continue;
         }
         const document = parseClausewitz(file.bytes, file.displayPath);
-        diagnostics.pushMany(document.diagnostics);
+        if (file.rootKind === 'mod' || file.rootKind === 'fixture')
+            diagnostics.pushMany(document.diagnostics);
         if (kind === 'gui_file')
             indexGuiElements(document, file, fileNodeId, nodes, edges, elements);
         if (kind === 'gfx_file') {
@@ -1019,6 +1023,35 @@ export function buildGuiSourceGraph(files, sharedIndex) {
         }
         indexDecisionEntries(document, file, nodes, pendingDecisionEdges);
     }
+    const referencedLocalisationKeys = referencedGuiLocalisationKeys(elements, scriptedLocalisation);
+    for (const { file, fileNodeId } of localisationFiles.sort((left, right) => right.file.loadOrder - left.file.loadOrder ||
+        compareCodeUnits(left.file.displayPath, right.file.displayPath))) {
+        const document = parseLocalisation(file.bytes, file.displayPath);
+        if (file.rootKind === 'mod' || file.rootKind === 'fixture')
+            diagnostics.pushMany(document.diagnostics);
+        for (const entry of document.entries) {
+            if (!referencedLocalisationKeys.has(entry.key))
+                continue;
+            const value = {
+                key: entry.key,
+                language: entry.language,
+                value: entry.value,
+                sourcePath: file.displayPath,
+                location: locationFor(file.displayPath, document.lineIndex, entry.start, entry.end),
+            };
+            addDomainEntry(localisation, value, 'localisation');
+            const id = deterministicId('gui_loc', value);
+            addNode(nodes, {
+                id,
+                kind: 'localisation',
+                name: entry.key,
+                path: file.displayPath,
+                ...(value.location === undefined ? {} : { location: value.location }),
+                metadata: { language: entry.language, value: entry.value },
+            });
+            addEdge(edges, 'contains', fileNodeId, id, true, {}, value.location);
+        }
+    }
     linkGraph(nodes, edges, elements, sprites, fonts, scriptedGuis, scriptedLocalisation, localisation, textureNodes, fontAssetNodes, pendingDecisionEdges);
     linkAnimationSources(nodes, edges, animationSources, sprites, textureNodes, animationFrameNodes);
     markPartialReferenceEdges(edges, sharedIndex);

package/dist/hoi4_agent_tools/gui/studio.js

@@ -125,7 +125,18 @@ function under(roots, suffixes) {
         return suffixes.map((suffix) => `${normalized}/${suffix}`);
     });
 }
-function guiDefinitionPatterns(workspace, languages = ['l_english']) {
+function guiDefinitionPatterns(workspace) {
+    const roots = workspace.registration.roots;
+    return [
+        ...new Set([
+            ...under(roots.interface, ['**/*.gui', '**/*.gfx']),
+            ...under(roots.gfx, ['**/*.gfx']),
+            ...under(roots.scriptedGui, ['**/*.txt']),
+            ...staticGuiDefinitionPatterns,
+        ]),
+    ].sort((left, right) => compareCodeUnits(left, right));
+}
+function guiLocalisationPatterns(workspace, languages = ['l_english']) {
     const roots = workspace.registration.roots;
     const languageDirectories = [...new Set(languages)].map((language) => {
         if (!/^l_[a-z_]+$/u.test(language)) {
@@ -135,9 +146,6 @@ function guiDefinitionPatterns(workspace, languages = ['l_english']) {
     });
     return [
         ...new Set([
-            ...under(roots.interface, ['**/*.gui', '**/*.gfx']),
-            ...under(roots.gfx, ['**/*.gfx']),
-            ...under(roots.scriptedGui, ['**/*.txt']),
             ...under(roots.localisation, [
                 '*.{yml,yaml}',
                 ...languageDirectories.flatMap((directory) => [
@@ -145,7 +153,6 @@ function guiDefinitionPatterns(workspace, languages = ['l_english']) {
                     `${directory}/**/*.yaml`,
                 ]),
             ]),
-            ...staticGuiDefinitionPatterns,
         ]),
     ].sort((left, right) => compareCodeUnits(left, right));
 }
@@ -395,11 +402,18 @@ export class ScriptedGuiStudio {
     async scan(workspaceId, principal, signal, languages = ['l_english']) {
         signal?.throwIfAborted();
         const workspace = this.resolver.get(workspaceId, principal);
-        const snapshot = await this.engine.scan(workspaceId, { patterns: guiDefinitionPatterns(workspace, languages) }, principal, signal);
+        const [snapshot, localisationFiles] = await Promise.all([
+            this.engine.scan(workspaceId, { patterns: guiDefinitionPatterns(workspace) }, principal, signal),
+            this.scanner.scan(workspace, {
+                patterns: guiLocalisationPatterns(workspace, languages),
+                ...(signal === undefined ? {} : { signal }),
+            }),
+        ]);
         signal?.throwIfAborted();
+        const files = mergeScannedFiles(snapshot.files, localisationFiles);
         return {
-            files: snapshot.files,
-            graph: buildGuiSourceGraph(snapshot.files, snapshot.index),
+            files,
+            graph: buildGuiSourceGraph(files, snapshot.index),
         };
     }
     async scanWindow(workspaceId, windowName, principal, signal, languages = ['l_english']) {
@@ -599,6 +613,7 @@ export class ScriptedGuiStudio {
         const stored = await this.artifacts.withAtomicChunkedWrites(workspace, writes, (artifacts) => Promise.resolve([...artifacts]), input.signal);
         return {
             artifacts: stored,
+            filesScanned: scanned.graph.filesScanned,
             render,
             stateScenes,
             resolutionScenes,

package/dist/hoi4_agent_tools/map/diagnostic-limit.js

@@ -1,18 +1,99 @@
 export const MAP_DIAGNOSTIC_LIMIT = 2_000;
-export function addMapDiagnostic(diagnostics, diagnostic) {
-    if (diagnostics.at(-1)?.code === 'MAP_DIAGNOSTICS_TRUNCATED')
+function isHardDiagnostic(diagnostic) {
+    return diagnostic.severity === 'error' || diagnostic.severity === 'blocker';
+}
+function isWorkspacePath(path) {
+    return path.startsWith('mod:') || path.startsWith('fixture:');
+}
+function isBaselineOnlyDiagnostic(diagnostic) {
+    if (diagnostic.location === undefined || isWorkspacePath(diagnostic.location.path))
+        return false;
+    return !(diagnostic.related ?? []).some(({ path }) => isWorkspacePath(path));
+}
+function addOmittedDiagnostic(details, diagnostic) {
+    details.omitted += 1;
+    details.omittedBySeverity[diagnostic.severity] =
+        (details.omittedBySeverity[diagnostic.severity] ?? 0) + 1;
+    details.omittedByCode[diagnostic.code] = (details.omittedByCode[diagnostic.code] ?? 0) + 1;
+}
+function truncationDiagnostic(omitted) {
+    const details = {
+        limit: MAP_DIAGNOSTIC_LIMIT,
+        retained: MAP_DIAGNOSTIC_LIMIT - 1,
+        omitted: 0,
+        omittedBySeverity: {},
+        omittedByCode: {},
+    };
+    for (const diagnostic of omitted)
+        addOmittedDiagnostic(details, diagnostic);
+    const hardOmitted = omitted.some(isHardDiagnostic);
+    return {
+        code: 'MAP_DIAGNOSTICS_TRUNCATED',
+        severity: hardOmitted ? 'blocker' : 'info',
+        category: 'map',
+        message: hardOmitted
+            ? 'Map diagnostic detail exceeded the result ceiling and omitted an error or blocker'
+            : 'Map diagnostic detail exceeded the result ceiling; deterministic samples and omission counts were retained',
+        details,
+    };
+}
+function existingTruncationDiagnostic(diagnostics) {
+    const marker = diagnostics.at(-1);
+    return marker?.code === 'MAP_DIAGNOSTICS_TRUNCATED'
+        ? marker
+        : undefined;
+}
+function addBoundedDiagnostic(diagnostics, diagnostic, includeBaseline) {
+    if (!includeBaseline && isBaselineOnlyDiagnostic(diagnostic))
+        return;
+    const marker = existingTruncationDiagnostic(diagnostics);
+    if (marker !== undefined) {
+        if (isHardDiagnostic(diagnostic)) {
+            const replaceIndex = diagnostics
+                .slice(0, -1)
+                .findLastIndex((retained) => !isHardDiagnostic(retained));
+            if (replaceIndex >= 0) {
+                const replaced = diagnostics[replaceIndex];
+                diagnostics[replaceIndex] = diagnostic;
+                addOmittedDiagnostic(marker.details, replaced);
+                return;
+            }
+            marker.severity = 'blocker';
+            marker.message =
+                'Map diagnostic detail exceeded the result ceiling and omitted an error or blocker';
+        }
+        addOmittedDiagnostic(marker.details, diagnostic);
         return;
+    }
     if (diagnostics.length < MAP_DIAGNOSTIC_LIMIT) {
         diagnostics.push(diagnostic);
         return;
     }
-    diagnostics[MAP_DIAGNOSTIC_LIMIT - 1] = {
-        code: 'MAP_DIAGNOSTICS_TRUNCATED',
-        severity: 'blocker',
-        category: 'map',
-        message: 'Map diagnostics exceeded the configured output limit',
-        details: { limit: MAP_DIAGNOSTIC_LIMIT, retained: MAP_DIAGNOSTIC_LIMIT - 1 },
-    };
+    const candidates = [...diagnostics, diagnostic];
+    const hard = candidates.filter(isHardDiagnostic);
+    const soft = candidates.filter((candidate) => !isHardDiagnostic(candidate));
+    const retained = hard.length >= MAP_DIAGNOSTIC_LIMIT - 1
+        ? hard.slice(0, MAP_DIAGNOSTIC_LIMIT - 1)
+        : [...hard, ...soft.slice(0, MAP_DIAGNOSTIC_LIMIT - 1 - hard.length)];
+    const retainedCounts = new Map();
+    for (const item of retained)
+        retainedCounts.set(item, (retainedCounts.get(item) ?? 0) + 1);
+    const omitted = candidates.filter((candidate) => {
+        const count = retainedCounts.get(candidate) ?? 0;
+        if (count === 0)
+            return true;
+        retainedCounts.set(candidate, count - 1);
+        return false;
+    });
+    diagnostics.splice(0, diagnostics.length, ...retained, truncationDiagnostic(omitted));
+}
+export function addMapDiagnostic(diagnostics, diagnostic) {
+    addBoundedDiagnostic(diagnostics, diagnostic, false);
+}
+/** Active topology validation must report failures in whichever source wins
+ * precedence, including inherited game and dependency files. */
+export function addActiveMapDiagnostic(diagnostics, diagnostic) {
+    addBoundedDiagnostic(diagnostics, diagnostic, true);
 }
 export function addMapDiagnostics(diagnostics, additions) {
     for (const diagnostic of additions)

package/dist/hoi4_agent_tools/map/model.js

@@ -24,11 +24,13 @@ const MAP_TEXT_FIELD_LIMIT = 10_000;
 const MAP_MODEL_MAX_SCRIPT_FILES = 5_000;
 const MAP_MODEL_MAX_SOURCE_TOKENS = 1_000_000;
 const MAP_MODEL_MAX_RECORDS = 500_000;
+const MAP_MODEL_MAX_LOCALISATION_RECORDS = 2_000_000;
 const MAP_MODEL_MAX_MEMBERSHIP_EDGES = 1_000_000;
 class MapModelBudget {
     #documents = new Set();
     #tokens = 0;
     #records = 0;
+    #localisationRecords = 0;
     #membershipEdges = 0;
     assertScriptFiles(count) {
         if (count > MAP_MODEL_MAX_SCRIPT_FILES) {
@@ -50,6 +52,13 @@ class MapModelBudget {
             this.block('domain records', this.#records, MAP_MODEL_MAX_RECORDS);
         }
     }
+    addLocalisationRecords(count) {
+        this.#localisationRecords += count;
+        if (!Number.isSafeInteger(this.#localisationRecords) ||
+            this.#localisationRecords > MAP_MODEL_MAX_LOCALISATION_RECORDS) {
+            this.block('localisation records', this.#localisationRecords, MAP_MODEL_MAX_LOCALISATION_RECORDS);
+        }
+    }
     addMembershipEdges(count) {
         this.#membershipEdges += count;
         if (!Number.isSafeInteger(this.#membershipEdges) ||
@@ -869,7 +878,9 @@ export class MapWorkspaceIndex {
         const modelBudget = new MapModelBudget();
         modelBudget.assertScriptFiles(this.sourceFiles.filter((file) => inConfiguredRoot(file.relativePath, this.sourceRoots.states) ||
             this.sourceRoots.map.some((root) => normalizedPath(file.relativePath).startsWith(`${root}/strategicregions/`)) ||
-            normalizedPath(file.relativePath).endsWith('.asset')).length);
+            ((file.rootKind === 'mod' || file.rootKind === 'fixture') &&
+                normalizedPath(file.relativePath).endsWith('.asset') &&
+                file.bytes.includes('locator'))).length);
         this.defaultMapFile = fileInRoots(this.activeFiles, this.sourceRoots.map, 'default.map');
         const definitionsName = defaultMapSelectorValue(this.defaultMapFile, 'definitions', 'definition.csv');
         const provincesName = defaultMapSelectorValue(this.defaultMapFile, 'provinces', 'provinces.bmp');
@@ -1031,7 +1042,9 @@ export class MapWorkspaceIndex {
             weatherFile === undefined ? [] : parseWeatherPositions(weatherFile, this.diagnostics);
         modelBudget.addRecords(this.weatherPositions.length);
         this.entityLocators = this.activeFiles.all
-            .filter((file) => normalizedPath(file.relativePath).endsWith('.asset'))
+            .filter((file) => (file.rootKind === 'mod' || file.rootKind === 'fixture') &&
+            normalizedPath(file.relativePath).endsWith('.asset') &&
+            file.bytes.includes('locator'))
             .flatMap((file) => {
             const locators = parseEntityLocators(file, this.diagnostics);
             if (locators[0] !== undefined)
@@ -1042,8 +1055,13 @@ export class MapWorkspaceIndex {
         for (const file of this.activeFiles.all.filter((entry) => inConfiguredRoot(entry.relativePath, this.sourceRoots.localisation) &&
             normalizedPath(entry.relativePath).endsWith('.yml'))) {
             const document = parseLocalisation(file.bytes, file.displayPath);
-            addMapDiagnostics(this.diagnostics, document.diagnostics);
-            modelBudget.addRecords(document.entries.length);
+            if (file.rootKind === 'mod' || file.rootKind === 'fixture') {
+                addMapDiagnostics(this.diagnostics, document.diagnostics);
+            }
+            // Localisation is a supporting lookup table rather than connected map topology. Account for
+            // it separately so a normal full-game language database cannot exhaust the domain-record
+            // budget before provinces, states, regions, railways, and adjacencies are available.
+            modelBudget.addLocalisationRecords(document.entries.length);
             for (const entry of document.entries) {
                 this.localisationKeys.add(`${entry.language}:${entry.key}`);
                 const indexed = { file, document, entry };

package/dist/hoi4_agent_tools/map/service.js

@@ -4,6 +4,7 @@ import { ArtifactStore, boundedSourceHashEvidence, publicArtifactLink, } from '.
 import { canonicalJson, compareCodeUnits, hashCanonical, sha256Bytes } from '../core/canonical.js';
 import { sortDiagnostics } from '../core/diagnostics.js';
 import { CoreEngine } from '../core/engine.js';
+import { SymbolIndex } from '../core/index.js';
 import { RenderBudget } from '../core/render-budget.js';
 import { ServiceError } from '../core/result.js';
 import { WorkspaceScanner } from '../core/scanner.js';
@@ -386,7 +387,6 @@ function sourceTextPatterns(roots) {
             const normalized = normalizeSourceRoot(root);
             return [`${normalized}/english/**/*.{yml,yaml}`, `${normalized}/*.{yml,yaml}`];
         }),
-        '**/*.asset',
     ];
 }
 function provinceBitmapPatterns(defaultMaps, mapRoots) {
@@ -491,14 +491,15 @@ export class AgentNudger {
         const selectorSnapshot = await this.engine.scan(workspaceId, { patterns: defaultMapPatterns(sourceRoots) }, principal, signal);
         const bitmapPatterns = provinceBitmapPatterns(selectorSnapshot.files, sourceRoots.map);
         const contentSnapshot = await this.engine.scan(workspaceId, { patterns: [...sourceTextPatterns(sourceRoots), ...bitmapPatterns] }, principal, signal);
+        const locatorSnapshot = await this.engine.scan(workspaceId, { patterns: ['**/*.asset'], rootKinds: ['mod', 'fixture'] }, principal, signal);
         signal?.throwIfAborted();
-        const files = contentSnapshot.files;
+        const files = [...contentSnapshot.files, ...locatorSnapshot.files].sort((left, right) => left.loadOrder - right.loadOrder || compareCodeUnits(left.displayPath, right.displayPath));
         const revision = hashCanonical(files.map(({ displayPath, loadOrder, sha256 }) => ({ displayPath, loadOrder, sha256 })));
         return {
             workspaceId,
             revision,
             files,
-            index: MapWorkspaceIndex.build(files, sourceRoots, contentSnapshot.index),
+            index: MapWorkspaceIndex.build(files, sourceRoots, SymbolIndex.build(files)),
         };
     }
     async validate(workspaceId, principal, signal) {

package/dist/hoi4_agent_tools/map/validation.js

@@ -1,7 +1,7 @@
 import { setImmediate as yieldToEventLoop } from 'node:timers/promises';
 import { sortDiagnostics } from '../core/diagnostics.js';
 import { assertRenderDimensions } from '../core/render-budget.js';
-import { addMapDiagnostic as addBoundedMapDiagnostic } from './diagnostic-limit.js';
+import { addActiveMapDiagnostic, addMapDiagnostic } from './diagnostic-limit.js';
 import { rgbKey } from './bmp.js';
 import { MAP_PROVINCE_ENGINE_MAX_PIXELS } from './model.js';
 const MAP_DIAGNOSTIC_DETAIL_SAMPLE_LIMIT = 100;
@@ -53,7 +53,8 @@ function definitionLocation(definition) {
     return requiredLineLocation(definition.document, definition.line);
 }
 function addDiagnostic(diagnostics, options, diagnostic) {
-    addBoundedMapDiagnostic(diagnostics, {
+    const add = options.includeBaselineDiagnostics === true ? addActiveMapDiagnostic : addMapDiagnostic;
+    add(diagnostics, {
         ...diagnostic,
         ...(diagnostic.operationId !== undefined || options.operationId === undefined
             ? {}

package/dist/hoi4_agent_tools/mcp/server/create.js

@@ -5,7 +5,7 @@ import { registerGuiTools } from '../tools/gui.js';
 import { registerMapTools } from '../tools/map.js';
 import { registerEventTools } from '../tools/event.js';
 import { registerMcpResources } from '../resources/register.js';
-export const SERVER_INSTRUCTIONS = 'The workspace defaults to the mod containing the MCP working directory; pass workspaceId only when selecting another configured mod. Use hoi4.event_inspect for scan, roots, trace, explain_path, state_flow, lint, and impact; hoi4.event_render and hoi4.event_compare return linked evidence. JSON resources are authoritative. Event tools are read-only. Only focus, GUI, and map rewrite tools edit configured mods.';
+export const SERVER_INSTRUCTIONS = 'Use hoi4.focus_inspect and hoi4.focus_render for fast structural work; hoi4.focus_raster adds decoded icons and PNG output. Use hoi4.event_inspect to analyze event chains. Event tools are read-only. Focus, GUI, and map rewrite tools edit the current mod. Large evidence is returned through linked resources.';
 export function createMcpServer(engine, context = {}) {
     const server = new McpServer({
         name: PACKAGE_NAME,

package/dist/hoi4_agent_tools/mcp/server/output-schemas.js

@@ -16,7 +16,7 @@ export const renderHashesSchema = z
     .object({
     html: sha256Schema,
     svg: sha256Schema,
-    png: sha256Schema,
+    png: sha256Schema.optional(),
     json: sha256Schema,
 })
     .strict();