hoi4-agent-tools 2.1.1 → 2.2.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 2.2.0 - 2026-07-22
+
+- Added a read-only Technology Tree Viewer for classic technologies, legacy and current doctrines, source folder layouts, prerequisites, exclusive choices, categories, tags, unlocks, bonuses, grants, metadata, localisation, icons, and cross-file references.
+- Added `hoi4.tech_inspect`, `hoi4.tech_render`, and `hoi4.tech_compare`, with complete graph resources, bounded large-tree overviews, focused folder renders, in-memory source comparison, and rename or removal impact analysis.
+- Added source-linked diagnostic classification for structural, placement, reference, unlock, bonus, doctrine, AI, localisation, icon, and unresolved static-analysis findings.
+- Added a deterministic 1,040-technology acceptance workspace with 13 folders, expected graph and reference manifests, stable SVG and PNG evidence, cancellation, incremental indexing, resource retrieval, and stdio, secured Streamable HTTP, package, and agent-workflow coverage.
+- Pinned patched transitive HTTP, URI, and shell parsing dependencies; the release dependency audit reports no known vulnerabilities.
+- 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.
+
 ## 2.1.1 - 2026-07-18
 
 - Updated container attestation verification for current in-toto `Statement/v1` documents emitted by BuildKit.

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. Start it in a mod folder and it works there immediately, with offline renders for review.
+HOI4 Agent Tools is an MCP server for coding agents to understand Hearts of Iron IV event chains and technology systems and to 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
 
@@ -8,6 +8,7 @@ HOI4 Agent Tools is an MCP server for coding agents to analyze Hearts of Iron IV
 - Scripted GUIs: trace GUI, GFX, scripted-GUI, and localisation links; render states; create or repair interface source.
 - Maps: inspect provinces, states, regions, adjacency, supply, and railways; render layers; create and repair exact map data.
 - Event chains: scan definitions and call sites, trace routes and state flow, lint references, render graphs, and compare revisions without editing event source.
+- Technology trees: reconstruct technology and doctrine paths, folder layouts, unlocks, bonuses, grants, metadata, assets, and structural changes.
 
 ## Setup
 
@@ -44,6 +45,9 @@ Paste the printed Codex or generic global-install entry into your MCP client, th
 | `hoi4.event_inspect` | Scan, trace, explain, lint, or assess event chains and their state flow.                |
 | `hoi4.event_render`  | Render source-linked event routes, options, timing, state, scope, and unresolved edges. |
 | `hoi4.event_compare` | Compare event-chain topology and diagnostics between revisions.                         |
+| `hoi4.tech_inspect`  | Scan, trace, explain, lint, and assess technology and doctrine systems.                 |
+| `hoi4.tech_render`   | Render source layouts, dependency paths, unlocks, grants, metadata, and asset coverage. |
+| `hoi4.tech_compare`  | Compare technology graphs, placements, references, diagnostics, and source overlays.    |
 
 Large outputs are linked `hoi4-agent://` resources. For resources over 1 MiB, follow the `continuationUri` returned in `_meta` until it is `null`; clients may also request byte ranges with `?offset=<bytes>&length=<bytes>`.
 
@@ -51,7 +55,7 @@ Large outputs are linked `hoi4-agent://` resources. For resources over 1 MiB, fo
 
 HOI4 Agent Tools provides HOI4 domain operations; it does not register MCP prompts, replace repository instructions such as `AGENTS.md`, manage skills or plans, or start subagents. The coding agent decides when to call it as part of its existing workflow.
 
-Connecting and listing tools does not scan mod source. Compact tool schemas and linked resources keep large diagnostics, renders, and diffs out of the agent's working context until needed. The event tools are read-only; only `hoi4.*_rewrite` calls edit mod source.
+Connecting and listing tools does not scan mod source. Compact tool schemas and linked resources keep large diagnostics, renders, and diffs out of the agent's working context until needed. Event and technology tools analyze source without editing it; only `hoi4.*_rewrite` calls edit mod source.
 
 ## Create or clean content
 
@@ -61,6 +65,7 @@ Ask your agent in normal task language. A typical workflow is inspect, render, r
 - 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).
 - Maps: "Create a state from these exact provinces," or "Inspect this state and split these provinces while keeping supply and railway references valid." See [Maps](docs/map.md).
 - Event chains: "Trace every route from this event and explain where its flags and variables change," or "Compare the workspace event graph with its previous revision and render the affected routes." See [Event chains](docs/events.md).
+- Technology trees: "Explain everything this technology requires and unlocks," or "Compare this technology patch and render every affected folder and doctrine branch." See [Technology trees](docs/technology.md).
 
 ## HTTP
 

package/dist/bin/stdio.js

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

package/dist/hoi4_agent_tools/core/engine.js

@@ -39,6 +39,15 @@ function defaultPatterns(workspace) {
             'common/bop/**/*.txt',
             'common/resistance_compliance_modifiers/**/*.txt',
             'common/special_projects/**/*.txt',
+            'common/technologies/**/*.txt',
+            'common/technology_tags/**/*.txt',
+            'common/technology_sharing/**/*.txt',
+            'common/doctrines/**/*.txt',
+            'common/units/**/*.txt',
+            'common/unit_tags/**/*.txt',
+            'common/buildings/**/*.txt',
+            'common/abilities/**/*.txt',
+            'common/combat_tactics.txt',
             'events/**/*.txt',
             'history/countries/**/*.txt',
             'history/states/**/*.txt',

package/dist/hoi4_agent_tools/core/index.js

@@ -67,6 +67,36 @@ function possibleSymbolKinds(file, definitionFiles) {
     if (sourcePath.endsWith('.gui'))
         kinds.add('gui_element');
     if (sourcePath.endsWith('.txt')) {
+        if (sourcePath.startsWith('common/technologies/'))
+            kinds.add('technology');
+        if (sourcePath.startsWith('common/technology_tags/')) {
+            kinds.add('technology_folder');
+            kinds.add('technology_category');
+            kinds.add('technology_tag');
+        }
+        if (sourcePath.startsWith('common/units/equipment/modules/'))
+            kinds.add('equipment_module');
+        else if (sourcePath.startsWith('common/units/equipment/'))
+            kinds.add('equipment');
+        else if (sourcePath.startsWith('common/units/'))
+            kinds.add('sub_unit');
+        if (sourcePath.startsWith('common/unit_tags/'))
+            kinds.add('unit_category');
+        if (sourcePath.startsWith('common/buildings/'))
+            kinds.add('building');
+        if (sourcePath.startsWith('common/abilities/'))
+            kinds.add('ability');
+        if (sourcePath === 'common/combat_tactics.txt' ||
+            sourcePath.startsWith('common/combat_tactics/'))
+            kinds.add('combat_tactic');
+        if (sourcePath.startsWith('common/doctrines/folders/'))
+            kinds.add('doctrine_folder');
+        if (sourcePath.startsWith('common/doctrines/grand_doctrines/'))
+            kinds.add('grand_doctrine');
+        if (sourcePath.startsWith('common/doctrines/tracks/'))
+            kinds.add('doctrine_track');
+        if (sourcePath.startsWith('common/doctrines/subdoctrines/'))
+            kinds.add('subdoctrine');
         if (/(?:^|\/)focus(?:es)?(?:\/|$)|national_focus|continuous_focus/u.test(sourcePath)) {
             kinds.add('focus_tree');
             kinds.add('focus');
@@ -463,6 +493,267 @@ export class SymbolIndex {
                     metadata: {},
                 });
             }
+            else if (sourcePath.startsWith('common/technologies/') &&
+                ancestors.length === 1 &&
+                ancestors[0] === 'technologies' &&
+                !key.startsWith('@')) {
+                this.addSymbol({
+                    kind: 'technology',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {
+                        startYear: firstScalar(child, 'start_year')?.value,
+                        researchCost: firstScalar(child, 'research_cost')?.value,
+                        doctrine: firstScalar(child, 'doctrine')?.value === 'yes',
+                        icon: `GFX_${key}_medium`,
+                    },
+                });
+                for (const pathBlock of childBlocks(child, 'path')) {
+                    const target = firstScalar(pathBlock, 'leads_to_tech');
+                    if (target !== undefined)
+                        this.addReference({
+                            kind: 'technology_prerequisite',
+                            from: key,
+                            toKind: 'technology',
+                            to: target.value,
+                            path: file.displayPath,
+                            location: nodeLocation(document, target, key),
+                        });
+                }
+                for (const xor of childBlocks(child, 'xor'))
+                    for (const target of scalars(xor))
+                        this.addReference({
+                            kind: 'technology_exclusive',
+                            from: key,
+                            toKind: 'technology',
+                            to: target,
+                            path: file.displayPath,
+                            location: nodeLocation(document, xor, key),
+                        });
+                for (const folder of childBlocks(child, 'folder')) {
+                    const target = firstScalar(folder, 'name');
+                    if (target !== undefined)
+                        this.addReference({
+                            kind: 'technology_folder',
+                            from: key,
+                            toKind: 'technology_folder',
+                            to: target.value,
+                            path: file.displayPath,
+                            location: nodeLocation(document, target, key),
+                        });
+                }
+                for (const categories of childBlocks(child, 'categories'))
+                    for (const target of scalars(categories))
+                        this.addReference({
+                            kind: 'technology_category',
+                            from: key,
+                            toKind: 'technology_category',
+                            to: target,
+                            path: file.displayPath,
+                            location: nodeLocation(document, categories, key),
+                        });
+                for (const tags of childBlocks(child, 'tags'))
+                    for (const target of scalars(tags))
+                        this.addReference({
+                            kind: 'technology_tag',
+                            from: key,
+                            toKind: 'technology_tag',
+                            to: target,
+                            path: file.displayPath,
+                            location: nodeLocation(document, tags, key),
+                        });
+                for (const [field, targetKind] of [
+                    ['enable_equipments', 'equipment'],
+                    ['enable_equipment_modules', 'equipment_module'],
+                    ['enable_subunits', 'sub_unit'],
+                ])
+                    for (const unlockBlock of childBlocks(child, field))
+                        for (const target of scalars(unlockBlock))
+                            this.addReference({
+                                kind: `technology_${field}`,
+                                from: key,
+                                toKind: targetKind,
+                                to: target,
+                                path: file.displayPath,
+                                location: nodeLocation(document, unlockBlock, key),
+                            });
+                for (const building of childBlocks(child, 'enable_building')) {
+                    const target = firstScalar(building, 'building');
+                    if (target !== undefined)
+                        this.addReference({
+                            kind: 'technology_enable_building',
+                            from: key,
+                            toKind: 'building',
+                            to: target.value,
+                            path: file.displayPath,
+                            location: nodeLocation(document, target, key),
+                        });
+                }
+            }
+            else if (sourcePath.startsWith('common/technology_tags/') &&
+                key === 'technology_categories') {
+                for (const category of child.entries.filter((entry) => entry.type === 'scalar'))
+                    this.addSymbol({
+                        kind: 'technology_category',
+                        id: category.value,
+                        path: file.displayPath,
+                        rootKind: file.rootKind,
+                        loadOrder: file.loadOrder,
+                        location: nodeLocation(document, category, category.value),
+                        metadata: {},
+                    });
+            }
+            else if (sourcePath.startsWith('common/technology_tags/') && key === 'technology_tags') {
+                for (const tag of child.entries.filter((entry) => entry.type === 'scalar'))
+                    this.addSymbol({
+                        kind: 'technology_tag',
+                        id: tag.value,
+                        path: file.displayPath,
+                        rootKind: file.rootKind,
+                        loadOrder: file.loadOrder,
+                        location: nodeLocation(document, tag, tag.value),
+                        metadata: {},
+                    });
+            }
+            else if (sourcePath.startsWith('common/technology_tags/') &&
+                ancestors.at(-1) === 'technology_folders') {
+                this.addSymbol({
+                    kind: 'technology_folder',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {
+                        doctrine: firstScalar(child, 'doctrine')?.value === 'yes',
+                        ledger: firstScalar(child, 'ledger')?.value,
+                    },
+                });
+            }
+            else if (sourcePath.startsWith('common/units/equipment/modules/') &&
+                ancestors.at(-1) === 'equipment_modules' &&
+                key !== 'limit') {
+                this.addSymbol({
+                    kind: 'equipment_module',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {},
+                });
+            }
+            else if (sourcePath.startsWith('common/units/equipment/') &&
+                !sourcePath.startsWith('common/units/equipment/modules/') &&
+                ancestors.at(-1) === 'equipments' &&
+                key !== 'limit') {
+                this.addSymbol({
+                    kind: 'equipment',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {},
+                });
+            }
+            else if (sourcePath.startsWith('common/units/') &&
+                !sourcePath.startsWith('common/units/equipment/') &&
+                ancestors.at(-1) === 'sub_units') {
+                this.addSymbol({
+                    kind: 'sub_unit',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {},
+                });
+            }
+            else if (sourcePath.startsWith('common/buildings/') && ancestors.at(-1) === 'buildings') {
+                this.addSymbol({
+                    kind: 'building',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {},
+                });
+            }
+            else if (sourcePath.startsWith('common/abilities/') && ancestors.at(-1) === 'ability') {
+                this.addSymbol({
+                    kind: 'ability',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {},
+                });
+            }
+            else if ((sourcePath === 'common/combat_tactics.txt' ||
+                sourcePath.startsWith('common/combat_tactics/')) &&
+                ancestors.at(-1) === 'combat_tactics') {
+                this.addSymbol({
+                    kind: 'combat_tactic',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {},
+                });
+            }
+            else if (sourcePath.startsWith('common/doctrines/folders/') && ancestors.length === 0) {
+                this.addSymbol({
+                    kind: 'doctrine_folder',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {},
+                });
+            }
+            else if (sourcePath.startsWith('common/doctrines/grand_doctrines/') &&
+                ancestors.length === 0) {
+                this.addSymbol({
+                    kind: 'grand_doctrine',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: { folder: firstScalar(child, 'folder')?.value },
+                });
+            }
+            else if (sourcePath.startsWith('common/doctrines/tracks/') && ancestors.length === 0) {
+                this.addSymbol({
+                    kind: 'doctrine_track',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {},
+                });
+            }
+            else if (sourcePath.startsWith('common/doctrines/subdoctrines/') &&
+                ancestors.length === 0) {
+                this.addSymbol({
+                    kind: 'subdoctrine',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {},
+                });
+            }
             else if (key === 'focus' &&
                 id !== undefined &&
                 ancestors.at(-1) === 'continuous_focus_palette') {
@@ -936,7 +1227,7 @@ export class SymbolIndex {
                 continue;
             const active = candidates[0];
             this.#active.set(key, active);
-            const additiveCategory = active.kind === 'decision_category';
+            const additiveCategory = active.kind === 'decision_category' || active.kind === 'technology_category';
             for (const candidate of group) {
                 candidate.overridden = additiveCategory ? candidate.sourceShadowed : candidate !== active;
             }

package/dist/hoi4_agent_tools/focus/render.js

@@ -143,6 +143,22 @@ function focusIconDataUri(focus, options) {
         ? undefined
         : (options.presentation?.icons[icon.sprite]?.dataUri ?? options.iconDataUris?.[icon.sprite]);
 }
+function focusTitleLayout(renderer, value, maximumWidth) {
+    const title = value.trim().replace(/\s+/gu, ' ');
+    if (renderer.measure(title, 11) <= maximumWidth)
+        return { lines: [title], fontSize: 11 };
+    const words = title.split(' ');
+    if (words.length < 2)
+        return { lines: [title], fontSize: 10 };
+    let best = { lines: [title], width: renderer.measure(title, 10) };
+    for (let index = 1; index < words.length; index += 1) {
+        const lines = [words.slice(0, index).join(' '), words.slice(index).join(' ')];
+        const width = Math.max(...lines.map((line) => renderer.measure(line, 10)));
+        if (width < best.width)
+            best = { lines, width };
+    }
+    return { lines: best.lines, fontSize: 10 };
+}
 function svgDocument(plan, layout, diagnostics, options) {
     const horizontal = options.horizontalSpacing ?? FOCUS_HORIZONTAL_GRID_PIXELS;
     const vertical = options.verticalSpacing ?? FOCUS_VERTICAL_GRID_PIXELS;
@@ -160,10 +176,10 @@ function svgDocument(plan, layout, diagnostics, options) {
     const nodeWidth = FOCUS_NODE_WIDTH_PIXELS;
     const nodeHeight = FOCUS_NODE_HEIGHT_PIXELS;
     const nodes = [...layout.nodes].sort((left, right) => compareCodeUnits(left.id, right.id));
-    const minimumX = Math.min(0, ...nodes.map(({ x }) => x));
-    const minimumY = Math.min(0, ...nodes.map(({ y }) => y));
-    const maximumX = Math.max(0, ...nodes.map(({ x }) => x));
-    const maximumY = Math.max(0, ...nodes.map(({ y }) => y));
+    const minimumX = nodes.length === 0 ? 0 : Math.min(...nodes.map(({ x }) => x));
+    const minimumY = nodes.length === 0 ? 0 : Math.min(...nodes.map(({ y }) => y));
+    const maximumX = nodes.length === 0 ? 0 : Math.max(...nodes.map(({ x }) => x));
+    const maximumY = nodes.length === 0 ? 0 : Math.max(...nodes.map(({ y }) => y));
     const logicalWidth = Math.max(320, (maximumX - minimumX) * horizontal + nodeWidth + padding * 2);
     const logicalHeight = Math.max(240, (maximumY - minimumY) * vertical + nodeHeight + padding * 2);
     const width = Math.max(1, Math.round(logicalWidth * outputScale));
@@ -268,6 +284,8 @@ function svgDocument(plan, layout, diagnostics, options) {
             .map(({ code }) => code)
             .sort()
             .join(' ');
+        const titleWidth = nodeWidth - 72;
+        const titleLayout = focusTitleLayout(toolText, title, titleWidth);
         parts.push(`<g class="focus-node ${escapeXml(focus.visibility)} ${severity}" id="focus-${escapeXml(node.id)}" data-focus-id="${escapeXml(node.id)}" data-branch="${escapeXml(focus.branchId ?? '')}" data-lane="${escapeXml(node.laneId)}" data-diagnostics="${escapeXml(diagnosticCodes)}" transform="translate(${point.x} ${point.y})" filter="url(#shadow)">`, `<title>${escapeXml(`${title} (${node.id}) at ${node.x},${node.y}`)}</title>`, `<rect width="${nodeWidth}" height="${nodeHeight}" rx="8" fill="${fill}" stroke="${stroke}" stroke-width="${severity === 'clean' ? 1.5 : 3}"/>`);
         if (iconUri !== undefined) {
             parts.push(`<image href="${escapeXml(iconUri)}" x="8" y="10" width="48" height="48" preserveAspectRatio="xMidYMid meet"/>`);
@@ -281,20 +299,26 @@ function svgDocument(plan, layout, diagnostics, options) {
                 fill: '#91a0b4',
             }));
         }
-        parts.push(toolText.render(title.slice(0, 18), {
-            x: 64,
-            y: 25,
-            fontSize: 12,
-            weight: 700,
-            fill: '#f2f5fa',
-        }), toolText.render(node.id.slice(0, 22), {
+        const titleY = titleLayout.lines.length === 1 ? 25 : 20;
+        for (const [index, line] of titleLayout.lines.entries()) {
+            const measuredWidth = toolText.measure(line, titleLayout.fontSize);
+            parts.push(toolText.render(line, {
+                x: 64,
+                y: titleY + index * 13,
+                fontSize: titleLayout.fontSize,
+                weight: 700,
+                fill: '#f2f5fa',
+                ...(measuredWidth <= titleWidth ? {} : { targetWidth: titleWidth }),
+            }));
+        }
+        parts.push(toolText.render(node.id.slice(0, 22), {
             x: 64,
-            y: 43,
+            y: 49,
             fontSize: 9,
             fill: '#aeb9c8',
         }), toolText.render(`(${node.x}, ${node.y}) · ${node.laneId}`, {
             x: 64,
-            y: 59,
+            y: 64,
             fontSize: 9,
             fill: '#8391a5',
         }), '</g>');

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

@@ -4,8 +4,9 @@ import { registerFocusTools } from '../tools/focus.js';
 import { registerGuiTools } from '../tools/gui.js';
 import { registerMapTools } from '../tools/map.js';
 import { registerEventTools } from '../tools/event.js';
+import { registerTechnologyTools } from '../tools/technology.js';
 import { registerMcpResources } from '../resources/register.js';
-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 const SERVER_INSTRUCTIONS = 'Use focus tools for focus trees, GUI tools for interfaces, and map tools for map data. Use hoi4.event_inspect, hoi4.event_render, and hoi4.event_compare for event chains. Use hoi4.tech_inspect, hoi4.tech_render, and hoi4.tech_compare for technology and doctrines. Event tools are read-only. Technology tools are read-only. Large evidence is linked as resources.';
 export function createMcpServer(engine, context = {}) {
     const server = new McpServer({
         name: PACKAGE_NAME,
@@ -19,6 +20,7 @@ export function createMcpServer(engine, context = {}) {
     registerGuiTools(server, engine, context);
     registerMapTools(server, engine, context);
     registerEventTools(server, engine, context);
+    registerTechnologyTools(server, engine, context);
     registerMcpResources(server, engine, context);
     return server;
 }

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

@@ -44,13 +44,13 @@ const compactPublicOperationResultSchema = z
     status: z.enum(['ok', 'blocked', 'error']),
     code: z.string(),
     workspaceId: z.string(),
-    filesScanned: z.array(z.unknown()).max(MAX_INLINE_FILES_SCANNED),
-    proposedFiles: z.array(z.unknown()).max(MAX_INLINE_PROPOSED_FILES),
-    changedFiles: z.array(z.unknown()).max(MAX_INLINE_CHANGED_FILES),
+    filesScanned: z.array(z.unknown()),
+    proposedFiles: z.array(z.unknown()),
+    changedFiles: z.array(z.unknown()),
     diagnostics: z.array(z.unknown()).max(MAX_INLINE_DIAGNOSTICS),
     artifacts: z.array(z.unknown()).max(MAX_INLINE_ARTIFACT_LINKS),
     validation: z.unknown(),
-    blockers: z.array(z.unknown()).max(MAX_INLINE_BLOCKERS),
+    blockers: z.array(z.unknown()),
     data: z.object({}).catchall(z.unknown()),
 })
     .strict();