hoi4-agent-tools 2.1.1 → 2.3.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 2.3.0 - 2026-07-22
+
+- Added a read-only AI and MTTH Scenario Analyzer with inspect, evaluate, sweep, simulate, sequence, compare, and render tools.
+- Added versioned adapters for event MTTH and options, decisions, missions, focuses, technologies, doctrines, direct random chance, `random_list`, supported AI strategy factors, and declared custom weighted pools without treating unlike HOI4 systems as one probability formula.
+- Added exact and bounded scenario evaluation, AST-path provenance, nested-random path probabilities, ranges, alternatives, distributions, numeric correlations, configurable diagnostics, named acceptance bands, and explicit external-factor support.
+- Added threshold-aware sweeps with trigger-adjacent breakpoints, local elasticities, pairwise interactions, rank reversals, cliffs, and missed target bands.
+- Added constant-memory Latin hypercube and seeded pseudo-random simulation, global input importance, Wilson intervals, and discrete daily-hazard MTTH samples with bounded quantile retention and uncertainty evidence.
+- Added declared-manifest sequence analysis for recovery, caps, cooldowns, removal, resets, timer changes, terminal states, and per-category outcomes without executing effects or inferring campaign state.
+- Added scenario-hash-bound deterministic ranking, matrix, waterfall, timing-survival, sensitivity, threshold, sequence, comparison, and unresolved renders with scenario, candidate, and metric filters.
+- Added fail-closed installed-game build verification for the versioned probability adapters.
+- Added generated public schemas, callable examples, source evidence, deterministic artifacts, and a project-owned fixture containing more than 150 weighted blocks, 250 scenarios, exact expectations, unresolved cases, and a stateful pool.
+- Verified analyzer discovery and workflows over stdio and authenticated Streamable HTTP, package installation, resource retrieval, cancellation, stale-result handling, workspace isolation, large candidate pools, and the official MCP Inspector.
+- Expanded event-graph capacity for installed-game and large-mod analysis beyond 100,000 nodes while retaining bounded artifact validation.
+- Reconfirmed MCP protocol `2025-11-25`, TypeScript SDK 1.29.0, Inspector 1.0.0, Registry schema `2025-12-11`, and Registry publisher 1.8.0 for this release.
+
+## 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, technology systems, AI weights, and MTTH timing 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,8 @@ 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.
+- AI and MTTH: evaluate weighted choices and timing across explicit scenarios, sweep uncertain inputs, simulate distributions, compare patches, and analyze declared stateful pools.
 
 ## Setup
 
@@ -29,29 +31,39 @@ Paste the printed Codex or generic global-install entry into your MCP client, th
 
 ## Tools
 
-| Tool                 | Purpose                                                                                 |
-| -------------------- | --------------------------------------------------------------------------------------- |
-| `hoi4.focus_inspect` | Read focus trees and report structural or reference problems.                           |
-| `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.                                              |
-| `hoi4.gui_rewrite`   | Create or update a GUI source package.                                                  |
-| `hoi4.map_inspect`   | Read map, state, province, region, supply, and railway data.                            |
-| `hoi4.map_render`    | Render map layers and overlays.                                                         |
-| `hoi4.map_rewrite`   | Create or update map data from an ordered list of exact changes.                        |
-| `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.                         |
+| Tool                        | Purpose                                                                                 |
+| --------------------------- | --------------------------------------------------------------------------------------- |
+| `hoi4.focus_inspect`        | Read focus trees and report structural or reference problems.                           |
+| `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.                                              |
+| `hoi4.gui_rewrite`          | Create or update a GUI source package.                                                  |
+| `hoi4.map_inspect`          | Read map, state, province, region, supply, and railway data.                            |
+| `hoi4.map_render`           | Render map layers and overlays.                                                         |
+| `hoi4.map_rewrite`          | Create or update map data from an ordered list of exact changes.                        |
+| `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.    |
+| `hoi4.probability_inspect`  | Locate weighted logic, candidates, required inputs, and supported analysis.             |
+| `hoi4.probability_evaluate` | Evaluate exact values, probabilities, timing, bounds, and unresolved inputs.            |
+| `hoi4.probability_sweep`    | Find sensitivity, breakpoints, cliffs, and rank reversals across declared ranges.       |
+| `hoi4.probability_simulate` | Run deterministic sampled analysis with confidence and convergence data.                |
+| `hoi4.probability_sequence` | Analyze declared recovery, caps, cooldowns, resets, timers, and terminal states.        |
+| `hoi4.probability_compare`  | Attribute AI-weight and MTTH changes between real or proposed source.                   |
+| `hoi4.probability_render`   | Render cached rankings, matrices, timing, sensitivity, sequence, and comparisons.       |
 
 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>`.
 
 ## Coexistence with agent workflows
 
-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.
+HOI4 Agent Tools provides HOI4 domain operations without replacing repository instructions such as `AGENTS.md`, skills, plans, or subagents. Its optional weighted-logic prompt helps an agent scope one probability analysis and then returns control to the normal 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, technology, and probability tools analyze source without editing it; only `hoi4.*_rewrite` calls edit mod source.
 
 ## Create or clean content
 
@@ -61,6 +73,8 @@ 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).
+- AI and MTTH: "Compare these focus weights across peace, defensive-war, and low-stability scenarios," or "Show when this MTTH event becomes likely and which unknown inputs control the result." See [AI and MTTH analysis](docs/probability.md).
 
 ## HTTP
 

package/dist/bin/stdio.js

@@ -6,7 +6,8 @@ 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);
     server.server.onerror = (error) => {
         const fatalInputError = error instanceof StdioFrameLimitError || error instanceof StdioInvalidUtf8Error;
         const rejectedMessage = error instanceof StdioInvalidMessageError;

package/dist/hoi4_agent_tools/core/clausewitz-evaluation.js

@@ -0,0 +1,90 @@
+import { compareCodeUnits } from './canonical.js';
+import { assignments, parseClausewitz, } from './source/index.js';
+const definitionCache = new WeakMap();
+function activeTextFiles(snapshot, prefix) {
+    return snapshot.files
+        .filter(({ relativePath, shadowedBy }) => shadowedBy === undefined &&
+        relativePath.replaceAll('\\', '/').toLowerCase().startsWith(prefix) &&
+        relativePath.toLowerCase().endsWith('.txt'))
+        .sort((left, right) => left.loadOrder - right.loadOrder || compareCodeUnits(left.displayPath, right.displayPath));
+}
+function scalarAssignments(block) {
+    return assignments(block).filter(({ value }) => value.type === 'scalar');
+}
+function flattenConstants(block, prefix, output, file, document) {
+    for (const assignment of assignments(block)) {
+        if (assignment.key.value === 'schema')
+            continue;
+        const id = prefix === '' ? assignment.key.value : `${prefix}.${assignment.key.value}`;
+        if (assignment.value.type === 'scalar') {
+            output.set(id, { id, value: assignment.value.value, node: assignment, file, document });
+        }
+        else {
+            flattenConstants(assignment.value, id, output, file, document);
+        }
+    }
+}
+/** Shared, source-linked definitions used by analysis domains. */
+export class ClausewitzEvaluationDefinitions {
+    scriptConstants = new Map();
+    mtthVariables = new Map();
+    scriptedTriggers = new Map();
+    localConstants = new Map();
+    static build(snapshot) {
+        const cached = definitionCache.get(snapshot);
+        if (cached !== undefined)
+            return cached;
+        const result = new ClausewitzEvaluationDefinitions();
+        for (const file of snapshot.files.filter(({ shadowedBy, relativePath }) => shadowedBy === undefined && relativePath.toLowerCase().endsWith('.txt'))) {
+            const document = parseClausewitz(file.bytes, file.displayPath);
+            const locals = new Map();
+            for (const assignment of scalarAssignments(document.root)) {
+                if (!assignment.key.value.startsWith('@') || assignment.value.type !== 'scalar')
+                    continue;
+                locals.set(assignment.key.value, {
+                    id: assignment.key.value,
+                    value: assignment.value.value,
+                    node: assignment,
+                    file,
+                    document,
+                });
+            }
+            if (locals.size > 0)
+                result.localConstants.set(file.displayPath, locals);
+        }
+        for (const file of activeTextFiles(snapshot, 'common/script_constants/')) {
+            const document = parseClausewitz(file.bytes, file.displayPath);
+            flattenConstants(document.root, '', result.scriptConstants, file, document);
+        }
+        for (const file of activeTextFiles(snapshot, 'common/mtth/')) {
+            const document = parseClausewitz(file.bytes, file.displayPath);
+            for (const assignment of assignments(document.root)) {
+                if (assignment.value.type !== 'block' || assignment.key.value.startsWith('@'))
+                    continue;
+                result.mtthVariables.set(assignment.key.value, {
+                    id: assignment.key.value,
+                    value: assignment.value,
+                    node: assignment,
+                    file,
+                    document,
+                });
+            }
+        }
+        for (const file of activeTextFiles(snapshot, 'common/scripted_triggers/')) {
+            const document = parseClausewitz(file.bytes, file.displayPath);
+            for (const assignment of assignments(document.root)) {
+                if (assignment.value.type !== 'block')
+                    continue;
+                result.scriptedTriggers.set(assignment.key.value, {
+                    id: assignment.key.value,
+                    value: assignment.value,
+                    node: assignment,
+                    file,
+                    document,
+                });
+            }
+        }
+        definitionCache.set(snapshot, result);
+        return result;
+    }
+}

package/dist/hoi4_agent_tools/core/engine.js

@@ -33,12 +33,26 @@ function defaultPatterns(workspace) {
             'common/characters/**/*.txt',
             'common/scripted_effects/**/*.txt',
             'common/scripted_triggers/**/*.txt',
+            'common/script_constants/**/*.txt',
+            'common/mtth/**/*.txt',
+            'common/ai_strategy/**/*.txt',
+            'common/ai_strategy_plans/**/*.txt',
+            'common/ai_focuses/**/*.txt',
             'common/on_actions/**/*.txt',
             'common/operations/**/*.txt',
             'common/raids/**/*.txt',
             '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');
@@ -79,6 +109,14 @@ function possibleSymbolKinds(file, definitionFiles) {
             kinds.add('scripted_effect');
         if (sourcePath.startsWith('common/scripted_triggers/'))
             kinds.add('scripted_trigger');
+        if (sourcePath.startsWith('common/script_constants/'))
+            kinds.add('script_constant');
+        if (sourcePath.startsWith('common/mtth/'))
+            kinds.add('mtth_variable');
+        if (sourcePath.startsWith('common/ai_strategy/'))
+            kinds.add('ai_strategy');
+        if (sourcePath.startsWith('common/ai_strategy_plans/'))
+            kinds.add('ai_strategy_plan');
         if (sourcePath.startsWith('common/decisions/')) {
             kinds.add('decision');
             kinds.add('decision_category');
@@ -437,8 +475,23 @@ export class SymbolIndex {
         const sourcePath = file.relativePath.replaceAll('\\', '/').toLowerCase();
         for (const assignment of assignments(block)) {
             const key = assignment.key.value;
-            if (assignment.value.type !== 'block')
+            if (assignment.value.type !== 'block') {
+                if (sourcePath.startsWith('common/script_constants/') &&
+                    key !== 'schema' &&
+                    !ancestors.includes('schema')) {
+                    const id = [...ancestors, key].join('.');
+                    this.addSymbol({
+                        kind: 'script_constant',
+                        id,
+                        path: file.displayPath,
+                        rootKind: file.rootKind,
+                        loadOrder: file.loadOrder,
+                        location: nodeLocation(document, assignment, id),
+                        metadata: { value: assignment.value.value },
+                    });
+                }
                 continue;
+            }
             const child = assignment.value;
             const id = firstScalar(child, 'id')?.value;
             if (key === 'focus_tree' && id !== undefined) {
@@ -463,6 +516,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') {
@@ -582,6 +896,39 @@ export class SymbolIndex {
                     metadata: {},
                 });
             }
+            else if (sourcePath.startsWith('common/mtth/') && ancestors.length === 0) {
+                this.addSymbol({
+                    kind: 'mtth_variable',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {},
+                });
+            }
+            else if (sourcePath.startsWith('common/ai_strategy/') && ancestors.length === 0) {
+                this.addSymbol({
+                    kind: 'ai_strategy',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {},
+                });
+            }
+            else if (sourcePath.startsWith('common/ai_strategy_plans/') && ancestors.length === 0) {
+                this.addSymbol({
+                    kind: 'ai_strategy_plan',
+                    id: key,
+                    path: file.displayPath,
+                    rootKind: file.rootKind,
+                    loadOrder: file.loadOrder,
+                    location: nodeLocation(document, assignment, key),
+                    metadata: {},
+                });
+            }
             else if (sourcePath.startsWith('common/decisions/') && ancestors.length === 0) {
                 this.addSymbol({
                     kind: 'decision_category',
@@ -936,7 +1283,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;
             }