hoi4-agent-tools 3.4.0 → 3.4.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## 3.4.1 - 2026-09-25
+
+- Validate technology renders against the requested view's source placement, node coverage, and sprite resolution without inheriting unrelated graph-wide diagnostics, while reporting deferred whole-workspace helper projection as a separate analysis boundary; resolve subtechnology art from the source GUI slot before using a technology-id fallback and include every referenced slot texture in the asset scan.
+- Accept focused event inspection and render evidence when every event source was scanned and no blocking diagnostics remain, while retaining deferred workspace-wide helper and lifecycle projections as an explicit boundary.
+- Keep repeated window-local GUI control names additive in the shared index, exclude engine-owned compound-control roles from scripted click-effect requirements, and preserve compact operation summaries when linked evidence exceeds the MCP wire budget.
+- Parse each active scripted-effect source document once when building mechanic helper inventories so bounded real-workspace scenarios do not multiply parser state by the number of helpers in a file.
+- Interpret declared temporary-variable assignment, arithmetic, rounding, clamping, and scope-valued inputs with chain-wide unscoped semantics in bounded mechanic scenarios.
+- Evaluate `has_variable` against declared scenario state so guarded defaults and subsequent temporary-variable arithmetic remain deterministic.
+- Follow a live replacement worker through its terminal publication instead of returning a nonterminal job record during concurrent checkpoint recovery.
+
 ## 3.4.0 - 2026-09-20
 
 - Add branch-local focus cleanup with pinned anchors and symmetry groups, connector measurements, source-linked crops, and scenario-backed structural route diagnostics.

package/dist/hoi4_agent_tools/core/condition-evaluator.js

@@ -278,6 +278,13 @@ function evaluateAssignmentCore(assignment, scenario, candidate, definitions, he
             unresolved: [],
         };
     }
+    if (key === 'has_variable') {
+        const state = scopeContext.expression === 'ROOT' ? scenario.state : scopeContext.binding.state;
+        return {
+            state: Object.hasOwn(state, right) || Object.hasOwn(state, `variable.${right}`) ? 'true' : 'false',
+            unresolved: [],
+        };
+    }
     if (key === 'tag' || key === 'original_tag') {
         const actor = scopeContext.expression === 'ROOT'
             ? scenario.actor

package/dist/hoi4_agent_tools/core/index.js

@@ -1369,6 +1369,7 @@ export class SymbolIndex {
             this.#active.set(key, active);
             const additiveCategory = active.kind === 'decision_category' ||
                 active.kind === 'technology_category' ||
+                active.kind === 'gui_element' ||
                 active.kind === 'texture';
             for (const candidate of group) {
                 candidate.overridden = additiveCategory ? candidate.sourceShadowed : candidate !== active;

package/dist/hoi4_agent_tools/core/job-worker-host.js

@@ -73,7 +73,12 @@ export class JobWorkerHost {
         for (;;) {
             try {
                 await this.scheduler.run(this.owner, 1024, signal, () => this.capacity.run(signal, (lease) => this.launch(workspaceId, id, lease, principal)));
-                return await this.jobs.get(workspaceId, id, principal);
+                const current = await this.jobs.get(workspaceId, id, principal);
+                if (['completed', 'cancelled', 'failed'].includes(current.status))
+                    return current;
+                if (current.owner !== undefined && jobOwnerLiveness(current.owner) === 'alive')
+                    return await this.followOwner(workspaceId, id, principal);
+                throw new ServiceError('JOB_WORKER_EXIT', 'The worker stopped without publishing a terminal job outcome');
             }
             catch (error) {
                 const current = await this.jobs.get(workspaceId, id, principal);
@@ -108,6 +113,19 @@ export class JobWorkerHost {
             }
         }
     }
+    async followOwner(workspaceId, id, principal) {
+        for (;;) {
+            const record = await this.jobs.get(workspaceId, id, principal);
+            if (['completed', 'failed', 'cancelled'].includes(record.status))
+                return record;
+            const liveness = record.owner === undefined ? 'dead' : jobOwnerLiveness(record.owner);
+            if (liveness !== 'alive')
+                throw new ServiceError(liveness === 'unknown' ? 'JOB_OWNER_UNRESOLVED' : 'JOB_WORKER_EXIT', liveness === 'unknown'
+                    ? 'The replacement execution owner cannot be verified on this host'
+                    : 'The replacement worker stopped without publishing a terminal job outcome');
+            await delay(100);
+        }
+    }
     async launch(workspaceId, id, lease, principal) {
         // Resolve the same configured workspace and grants again immediately before dispatch.
         await this.jobs.get(workspaceId, id, principal);

package/dist/hoi4_agent_tools/core/operation-result.js

@@ -114,6 +114,9 @@ function boundedResult(result, actualBytes) {
             : 'Tool output exceeded the wire budget; nonessential inline details were omitted',
         details: { actualBytes, maxBytes: MAX_TOOL_RESULT_BYTES },
     };
+    const compactData = result.data !== null && typeof result.data === 'object' && !Array.isArray(result.data)
+        ? result.data
+        : {};
     return {
         status: result.status,
         code: result.code.slice(0, 256),
@@ -141,7 +144,7 @@ function boundedResult(result, actualBytes) {
                     },
                 },
             ],
-        data: {},
+        data: jsonBytesWithin(compactData, 2_048) ? compactData : {},
     };
 }
 function jsonStringBytes(value) {

package/dist/hoi4_agent_tools/event/operations.js

@@ -37,21 +37,27 @@ export function eventGraphCounts(graph, artifacts) {
 }
 export function eventGraphValidation(graph) {
     const counts = eventGraphCounts(graph, 0);
+    const analysisBoundaryPassed = graph.complete || (graph.analysisMode === 'focused' && graph.skippedSourceCount === 0);
+    const passed = analysisBoundaryPassed && counts.blockingDiagnostics === 0;
     return {
-        passed: graph.complete && counts.blockingDiagnostics === 0,
+        passed,
         checks: [
             {
                 id: 'event-analysis',
-                passed: graph.complete && counts.blockingDiagnostics === 0,
-                message: graph.analysisMode === 'focused'
-                    ? 'Large workspace analysis deferred workspace-wide helper projections and lifecycle passes; direct evidence is linked'
+                passed,
+                message: counts.blockingDiagnostics > 0
+                    ? `${counts.blockingDiagnostics} blocking event-chain diagnostics; full evidence is linked`
                     : graph.complete
-                        ? `${counts.blockingDiagnostics} blocking event-chain diagnostics; full evidence is linked`
-                        : graph.issues.some(({ code }) => code === 'EVENT_HELPER_DEPTH_LIMIT' ||
-                            code === 'EVENT_HELPER_PROJECTION_LIMIT' ||
-                            code === 'EVENT_HELPER_STATE_PROJECTION_LIMIT')
-                            ? 'Helper expansion reached a depth or materialization boundary; helper_expansion mode provides bounded source-linked continuation'
-                            : `${graph.skippedSourceCount} event-analysis source(s) were skipped; full evidence is linked`,
+                        ? 'The event-chain analysis is complete and has no blocking diagnostics'
+                        : graph.analysisMode === 'focused' && graph.skippedSourceCount === 0
+                            ? 'Whole-workspace helper projections and lifecycle passes were deferred; the requested event analysis retains direct source evidence'
+                            : graph.analysisMode === 'focused'
+                                ? `${graph.skippedSourceCount} event-analysis source(s) were skipped; linked evidence records the partial boundary`
+                                : graph.issues.some(({ code }) => code === 'EVENT_HELPER_DEPTH_LIMIT' ||
+                                    code === 'EVENT_HELPER_PROJECTION_LIMIT' ||
+                                    code === 'EVENT_HELPER_STATE_PROJECTION_LIMIT')
+                                    ? 'Helper expansion reached a depth or materialization boundary; helper_expansion mode provides bounded source-linked continuation'
+                                    : `${graph.skippedSourceCount} event-analysis source(s) were skipped; full evidence is linked`,
             },
         ],
     };

package/dist/hoi4_agent_tools/gui/validators.js

@@ -655,6 +655,9 @@ function validateReferencesAndScript(graph, scene, diagnostics) {
         const elementsById = new Map(graph.elements.map((element) => [element.id, element]));
         for (const button of scene.elements.filter(({ elementType }) => /button/iu.test(elementType))) {
             const source = elementsById.get(button.sourceId);
+            const referencedByScript = effects.has(button.name) || triggers.has(button.name);
+            if ((source === undefined || !/button/iu.test(source.elementType)) && !referencedByScript)
+                continue;
             const tooltipOnly = !effects.has(button.name) &&
                 !triggers.has(button.name) &&
                 (typeof source?.attributes.pdx_tooltip === 'string' ||

package/dist/hoi4_agent_tools/mechanic/interpreter.js

@@ -13,6 +13,22 @@ const numericEffects = new Map([
     ['add_war_support', { key: 'war_support', mode: 'add', min: 0, max: 1 }],
 ]);
 const harmlessEffects = new Set(['hidden_effect', 'custom_effect_tooltip', 'log', 'tooltip']);
+const variableEffects = new Map([
+    ['set_variable', 'set'],
+    ['set_temp_variable', 'set'],
+    ['add_to_variable', 'add'],
+    ['add_to_temp_variable', 'add'],
+    ['subtract_from_variable', 'subtract'],
+    ['subtract_from_temp_variable', 'subtract'],
+    ['multiply_variable', 'multiply'],
+    ['multiply_temp_variable', 'multiply'],
+    ['divide_variable', 'divide'],
+    ['divide_temp_variable', 'divide'],
+    ['clamp_variable', 'clamp'],
+    ['clamp_temp_variable', 'clamp'],
+    ['round_variable', 'round'],
+    ['round_temp_variable', 'round'],
+]);
 function numeric(value) {
     if (typeof value === 'number' && Number.isFinite(value))
         return value;
@@ -175,6 +191,40 @@ export class MechanicInterpreter {
         return (numeric(scenarioValue(this.state, key, targetScope)) ??
             numeric(scenarioValue(this.state, `variable.${key}`, targetScope)));
     }
+    scopeReference(expression, scope, stack) {
+        const scopeId = (name) => {
+            if (name === 'ROOT')
+                return this.state.scenario.actor ?? 'ROOT';
+            if (name === 'THIS')
+                return scope === 'ROOT'
+                    ? (this.state.scenario.actor ?? 'ROOT')
+                    : this.state.scenario.scopes?.[scope]?.id;
+            if (name === 'PREV') {
+                const previous = stack.findLast((item) => item.startsWith('scope:'))?.slice(6);
+                return previous === undefined
+                    ? undefined
+                    : previous === 'ROOT'
+                        ? (this.state.scenario.actor ?? 'ROOT')
+                        : this.state.scenario.scopes?.[previous]?.id;
+            }
+            return this.state.scenario.scopes?.[name]?.id;
+        };
+        if (expression.startsWith('event_target:'))
+            return this.state.scenario.eventTargets?.[expression.slice(13)];
+        const identifier = /^([A-Za-z0-9_:]+)(?:\.id)?$/u.exec(expression)?.[1];
+        return identifier === undefined ? undefined : scopeId(identifier.toUpperCase());
+    }
+    value(expression, path, scope, stack) {
+        const numberValue = this.number(expression, path, scope);
+        if (numberValue !== undefined)
+            return numberValue;
+        const dotted = /^(ROOT|THIS|FROM|PREV)\.(.+)$/iu.exec(expression);
+        const targetScope = dotted?.[1]?.toUpperCase() === 'THIS' ? scope : (dotted?.[1]?.toUpperCase() ?? scope);
+        const key = dotted?.[2] ?? expression;
+        const existing = scenarioValue(this.state, key, targetScope) ??
+            scenarioValue(this.state, `variable.${key}`, targetScope);
+        return existing ?? this.scopeReference(expression, scope, stack);
+    }
     mathExpression(block, path, scope) {
         const entries = entriesOnly(block);
         if (entries === undefined || entries[0]?.key.value !== 'value')
@@ -410,42 +460,53 @@ export class MechanicInterpreter {
             }
             return;
         }
-        if ([
-            'set_variable',
-            'add_to_variable',
-            'subtract_from_variable',
-            'multiply_variable',
-            'divide_variable',
-            'clamp_variable',
-        ].includes(key)) {
+        const variableMode = variableEffects.get(key);
+        if (variableMode !== undefined) {
+            const variableScope = key.includes('temp_variable') ? 'ROOT' : scope;
+            const scalarVariable = asText(entry.value);
+            if (variableMode === 'round') {
+                const variable = scalarVariable ?? (child === undefined ? undefined : firstScalar(child, 'var')?.value);
+                const before = variable === undefined
+                    ? undefined
+                    : numeric(scenarioValue(this.state, variable, variableScope));
+                const after = before === undefined ? undefined : Math.round(before);
+                if (variable === undefined) {
+                    this.unknown(key, path, scope, 'Variable must resolve');
+                    return;
+                }
+                setScenarioValue(this.state, variable, after, variableScope);
+                this.note(key, path, scope, after === undefined ? 'unresolved' : 'applied', before, after, after === undefined ? 'Variable value is not numeric' : undefined, variable);
+                return;
+            }
             if (child === undefined) {
                 this.unknown(key, path, scope, 'Variable effect requires a block');
                 return;
             }
             const short = assignments(child).find((item) => !['var', 'value', 'min', 'max', 'tooltip'].includes(item.key.value));
             const variable = firstScalar(child, 'var')?.value ?? short?.key.value;
+            if (variable === undefined) {
+                this.unknown(key, path, scope, 'Variable must resolve');
+                return;
+            }
             const expression = firstScalar(child, 'value')?.value ??
                 (short === undefined ? undefined : asText(short.value));
-            if (variable === undefined || expression === undefined) {
-                if (variable === undefined || short?.value.type !== 'block') {
-                    this.unknown(key, path, scope, 'Variable and operand must resolve');
-                    return;
-                }
-            }
-            const value = expression === undefined
-                ? this.mathExpression(short.value, path, scope)
-                : this.number(expression, path, scope);
-            const before = numeric(scenarioValue(this.state, variable, scope)) ?? 0;
-            let after = value;
-            if (value !== undefined && key === 'add_to_variable')
-                after = before + value;
-            if (value !== undefined && key === 'subtract_from_variable')
-                after = before - value;
-            if (value !== undefined && key === 'multiply_variable')
-                after = before * value;
-            if (value !== undefined && key === 'divide_variable')
-                after = value === 0 ? undefined : before / value;
-            if (value !== undefined && key === 'clamp_variable') {
+            const operand = expression === undefined
+                ? variableMode === 'set' && short?.value.type === 'block'
+                    ? this.mathExpression(short.value, path, scope)
+                    : undefined
+                : this.value(expression, path, scope, stack);
+            const previous = scenarioValue(this.state, variable, variableScope);
+            const before = numeric(previous) ?? 0;
+            let after = variableMode === 'set' ? operand : numeric(operand);
+            if (variableMode === 'add' && typeof after === 'number')
+                after = before + after;
+            if (variableMode === 'subtract' && typeof after === 'number')
+                after = before - after;
+            if (variableMode === 'multiply' && typeof after === 'number')
+                after = before * after;
+            if (variableMode === 'divide' && typeof after === 'number')
+                after = after === 0 ? undefined : before / after;
+            if (variableMode === 'clamp') {
                 const minimum = firstScalar(child, 'min')?.value;
                 const maximum = firstScalar(child, 'max')?.value;
                 const min = minimum === undefined ? -Infinity : this.number(minimum, path, scope);
@@ -453,8 +514,8 @@ export class MechanicInterpreter {
                 after =
                     min === undefined || max === undefined ? undefined : Math.max(min, Math.min(max, before));
             }
-            setScenarioValue(this.state, variable, after, scope);
-            this.note(key, path, scope, after === undefined ? 'unresolved' : 'applied', before, after, after === undefined ? 'Numeric operand is unknown or division by zero' : undefined, variable);
+            setScenarioValue(this.state, variable, after, variableScope);
+            this.note(key, path, scope, after === undefined ? 'unresolved' : 'applied', previous, after, after === undefined ? 'Numeric operand is unknown or division by zero' : undefined, variable);
             return;
         }
         if (key === 'set_country_flag' ||

package/dist/hoi4_agent_tools/mechanic/source.js

@@ -77,13 +77,28 @@ export function selectMechanicSource(snapshot, selector) {
 }
 export function scriptedEffectSources(snapshot) {
     const result = new Map();
+    const symbolsByPath = new Map();
     for (const symbol of snapshot.index.symbols) {
         if (symbol.kind !== 'scripted_effect' || symbol.overridden || symbol.sourceShadowed)
             continue;
-        const document = activeDocument(snapshot, symbol.path);
-        const block = document === undefined ? undefined : assignments(document.root, symbol.id)[0]?.value;
-        if (block?.type === 'block')
-            result.set(symbol.id, { id: symbol.id, path: symbol.path, block });
+        const symbols = symbolsByPath.get(symbol.path) ?? [];
+        symbols.push(symbol);
+        symbolsByPath.set(symbol.path, symbols);
+    }
+    for (const [sourcePath, symbols] of symbolsByPath) {
+        const document = activeDocument(snapshot, sourcePath);
+        if (document === undefined)
+            continue;
+        const blocks = new Map();
+        for (const definition of assignments(document.root)) {
+            if (definition.value.type === 'block' && !blocks.has(definition.key.value))
+                blocks.set(definition.key.value, definition.value);
+        }
+        for (const symbol of symbols) {
+            const block = blocks.get(symbol.id);
+            if (block !== undefined)
+                result.set(symbol.id, { id: symbol.id, path: symbol.path, block });
+        }
     }
     return result;
 }

package/dist/hoi4_agent_tools/technology/operations.js

@@ -58,6 +58,34 @@ export function technologyValidation(graph) {
         ],
     };
 }
+export function technologyRenderValidation(graph, render) {
+    const omitted = render.omittedNodeCount;
+    const unresolvedSprites = render.unresolvedIconSprites.length;
+    const sourcePlacementPassed = render.view !== 'folder' || render.sourceAccurate;
+    const analysisBoundaryPassed = graph.complete || (graph.analysisMode === 'focused' && graph.skippedSourceCount === 0);
+    const renderPassed = sourcePlacementPassed && omitted === 0 && unresolvedSprites === 0;
+    return {
+        passed: renderPassed && analysisBoundaryPassed,
+        checks: [
+            {
+                id: 'technology-render',
+                passed: renderPassed,
+                message: renderPassed
+                    ? 'The requested technology view rendered with complete node and sprite coverage'
+                    : `${sourcePlacementPassed ? 0 : 1} source-placement failure(s), ${omitted} omitted node(s), and ${unresolvedSprites} unresolved sprite(s) affect the requested technology view`,
+            },
+            {
+                id: 'technology-analysis-boundary',
+                passed: analysisBoundaryPassed,
+                message: graph.complete
+                    ? 'The supporting technology analysis is complete'
+                    : analysisBoundaryPassed
+                        ? 'Whole-workspace helper projections were deferred; the requested render retains direct source evidence'
+                        : `${graph.skippedSourceCount} technology source(s) were skipped; linked evidence records the partial analysis boundary`,
+            },
+        ],
+    };
+}
 export async function inspectTechnologies(viewer, input) {
     const output = await viewer.analyze(input);
     const result = emptyServiceResult(input.workspaceId, {
@@ -93,7 +121,7 @@ export async function renderTechnologies(viewer, input) {
     result.code = output.graph.complete ? 'TECH_RENDERED' : 'TECH_RENDERED_PARTIAL';
     setInlineFilesScanned(result, output.graph.filesScanned);
     result.artifacts = output.artifacts.map(publicArtifactLink);
-    result.validation = technologyValidation(output.graph);
+    result.validation = technologyRenderValidation(output.graph, output.render);
     return result;
 }
 export async function compareTechnologies(viewer, input) {

package/dist/hoi4_agent_tools/technology/render.js

@@ -72,9 +72,10 @@ function technologyNode(graph, technologyId, placement) {
                 subTechnologies: technology.subTechnologies.map((id, index) => {
                     const definition = graph.technologies.find((candidate) => candidate.id === id);
                     const slot = itemLayout?.subTechnologySlots?.find((candidate) => candidate.index === index);
+                    const iconSprite = slot?.sprite ?? definition?.icon.sprite;
                     return {
                         id,
-                        ...(definition === undefined ? {} : { iconSprite: definition.icon.sprite }),
+                        ...(iconSprite === undefined ? {} : { iconSprite }),
                         placementStatus: slot === undefined ? 'missing_source_slot' : 'source_slot',
                         ...(slot === undefined ? {} : { slot }),
                     };

package/dist/hoi4_agent_tools/technology/service.js

@@ -487,6 +487,7 @@ export class TechnologyTreeViewer {
             });
         const guiSprites = [
             ...preliminary.itemLayouts.flatMap(({ designTeamIcon }) => designTeamIcon === undefined ? [] : [designTeamIcon.sprite]),
+            ...preliminary.itemLayouts.flatMap(({ subTechnologySlots }) => (subTechnologySlots ?? []).flatMap(({ sprite }) => (sprite === undefined ? [] : [sprite]))),
             ...preliminary.itemLayouts.flatMap(({ backgroundSprite }) => backgroundSprite === undefined
                 ? []
                 : [

package/dist/hoi4_agent_tools/version.js

@@ -1,6 +1,6 @@
 import { LATEST_PROTOCOL_VERSION } from '@modelcontextprotocol/sdk/types.js';
 export const PACKAGE_NAME = 'hoi4-agent-tools';
-export const PACKAGE_VERSION = '3.4.0';
+export const PACKAGE_VERSION = '3.4.1';
 export const MCP_PROTOCOL_VERSION = LATEST_PROTOCOL_VERSION;
 export const CONFIG_VERSION = 1;
 export const TRANSACTION_VERSION = 1;

package/docs/events.md

@@ -19,7 +19,7 @@ Use the three event tools directly from the target mod.
 
 Use narrow identifiers, direction, and depth limits when the task concerns one chain.
 Broad scans build the structural event graph without expanding every scripted helper into duplicate paths.
-Focused trace, path, and selector-based inventory requests may defer workspace-wide helper projections and lifecycle passes; their linked evidence records the partial boundary.
+Focused trace, path, and selector-based inventory requests may defer workspace-wide helper projections and lifecycle passes. When every event source was scanned and no blocking diagnostics remain, validation accepts the requested direct-source evidence while the linked artifacts continue to record that deferred boundary.
 Focused trace and path calls collapse only the selected bounded route.
 For a large helper closure, use [bounded helper expansion](helper-expansion.md) to receive resumable pages without first materializing every projection.
 

package/docs/gui.md

@@ -51,6 +51,7 @@ The scene records the selected shader source, hash and entry point.
 Additional shader operations, including animated end-cap sampling, remain explicit unsupported findings rather than accepted pixel-parity evidence.
 
 Container scrollbars use referenced or inline `extendedScrollbarType` templates, including their backgrounds, inline track, thumb and end-button artwork.
+The template's slider and end-button roles are engine-owned compound controls, so scripted click-effect checks apply to authored source buttons and explicitly referenced role names rather than requiring effects for the native scrollbar internals.
 Each attachment has independent instance IDs and source provenance even when multiple containers reuse one template.
 The renderer measures direct content bounds and populated grid/list rows, retaining declared list bounds as a minimum, clamps scroll offsets, and applies `autohide_scrollbars`.
 A nested container contributes its declared bounds rather than the overflowing artwork of its descendants.

package/docs/jobs.md

@@ -57,6 +57,7 @@ Event and technology helper expansion also saves an authenticated intermediate f
 A replacement validates the saved paths, adjacency cursor, graph identity, and checkpoint bytes before continuing.
 Source changes before intermediate-frontier recovery cause a fresh analysis of the current revision; old and new graph evidence are never combined.
 An active host allows at most two replacement attempts after proven worker death, and never retries the same unchanged frontier twice.
+If another bounded host has already claimed an interrupted job, the initiating host follows that live replacement until it publishes a terminal outcome; it does not expose the replacement's intermediate `running` record as the synchronous result.
 Checkpoint recovery never overrides cancellation or live/unverifiable ownership, and never replays a rewrite.
 Event and technology scan artifacts retain revision-addressed graphs for later comparisons, and bounded responses state their requested depth, node, edge, render, helper-expansion, or candidate coverage.
 Their opt-in `helper_expansion` mode also returns [bounded continuation pages](helper-expansion.md) through both ordinary calls and persistent jobs.

package/docs/mechanics.md

@@ -41,7 +41,8 @@ An `advance_days` step only expires modeled timed flags; it never runs on action
 
 The linked trace records applied, skipped, and unresolved source operations with before and after values.
 The `single_payment` assertion checks the named balance's final change and the number and size of its traced deductions, so a compensating grant cannot hide a second charge.
-Supported operations include documented variable arithmetic, flags, event targets, arrays, conditionals, finite declared scope iteration, scripted helpers, safe meta substitutions, and selected balance effects.
+Supported operations include documented persistent and unscoped temporary-variable arithmetic, exact `has_variable` presence checks, flags, event targets, arrays, conditionals, finite declared scope iteration, scripted helpers, safe meta substitutions, and selected balance effects.
+Active scripted-effect documents are parsed once per source file and their helper blocks share that bounded source model.
 Decision engine political-power costs are applied once before `complete_effect`; custom cost triggers check affordability and their payment remains in `complete_effect`.
 Unresolved eligibility, unsupported effects, dynamic names that cannot be resolved, missing finite scope catalogs, and bounded-work limits remain unresolved rather than guessed.
 An effect with an unknown write set conservatively makes state assertions unresolved.

package/docs/technology.md

@@ -56,10 +56,14 @@ It preserves separate conditional call sites and identifies source, cycle, and d
 
 `hoi4.tech_render` returns authoritative JSON with deterministic SVG and PNG resources; set `includeHtml` when a bundled static report is useful. Folder renders read the actual `techtree_<folder>_item` and `techtree_<folder>_small_item` geometry, choose the small item for technologies that do not unlock equipment or explicitly force it, and place the source GUI's year labels. Available views are `summary`, `folder`, `dependencies`, `technology`, `doctrine`, `exclusive`, `memberships`, `bonuses`, `grants`, `unlocks`, `metadata`, `assets`, and `unresolved`.
 
-Folder renders use folder assignments, gridbox geometry, technology coordinates, and item dimensions found in source. File-local `@` constants in technology coordinates are resolved before placement. A technology with multiple prerequisite roots can use its own declared gridbox. The item template supplies its unavailable, available, or researched skin, icon center, name position, and design-team icon position when the corresponding sprites resolve. `sub_technology_slot_<index>` geometry positions each declared subtechnology icon; a missing slot stays visible as unresolved placement metadata. The folder's tiled panel sprite fills the canvas, and source `*_techtree_bg` sprites render behind technology nodes at their declared GUI positions; when the GUI omits a sprite size, the decoded dimensions supply it. Year labels retain their source font, box dimensions, alignment, orientation, and colour declarations in the graph. Sprite declarations and texture files resolve through the active load order across the mod, configured dependencies, and the detected or configured game installation. The authoritative JSON and SVG expose `layoutSize`, rendered sprite coverage, and unresolved sprite names without embedding image data in JSON. `sourceAccurate` describes source pixel placement only; it is not a percentage of visual agreement with a game screenshot. The game may change the visibility of design-team icons and status corners at runtime. Dependency and other semantic views are labelled as generated analysis layouts.
+Folder renders use folder assignments, gridbox geometry, technology coordinates, and item dimensions found in source. File-local `@` constants in technology coordinates are resolved before placement. A technology with multiple prerequisite roots can use its own declared gridbox. The item template supplies its unavailable, available, or researched skin, icon center, name position, and design-team icon position when the corresponding sprites resolve. `sub_technology_slot_<index>` geometry and its source `picture` sprite position each declared subtechnology icon; the technology-id icon is a fallback when the slot does not declare art, and a missing slot stays visible as unresolved placement metadata. The folder's tiled panel sprite fills the canvas, and source `*_techtree_bg` sprites render behind technology nodes at their declared GUI positions; when the GUI omits a sprite size, the decoded dimensions supply it. Year labels retain their source font, box dimensions, alignment, orientation, and colour declarations in the graph. Sprite declarations and texture files resolve through the active load order across the mod, configured dependencies, and the detected or configured game installation. The authoritative JSON and SVG expose `layoutSize`, rendered sprite coverage, and unresolved sprite names without embedding image data in JSON. `sourceAccurate` describes source pixel placement only; it is not a percentage of visual agreement with a game screenshot. The game may change the visibility of design-team icons and status corners at runtime. Dependency and other semantic views are labelled as generated analysis layouts.
 
 A `small` 72-pixel item can still display its source `GFX_*_medium` artwork at full card size; the layout name does not select smaller icon art.
 
+Render validation is scoped to the requested view: folder source placement, omitted nodes, and unresolved sprites determine whether that render passes. Graph-wide semantic diagnostics remain available through technology inspection and do not falsely invalidate an otherwise complete source-backed folder render. Deferred whole-workspace helper projection remains an explicit analysis boundary and does not by itself invalidate a complete direct-source render.
+
+Subtechnology cards use the sprite declared by their source GUI slot before any technology-id fallback. Slot-declared textures are included in the bounded asset scan even when no ordinary technology icon references the same file.
+
 Example folder render:
 
 ```json

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hoi4-agent-tools",
   "mcpName": "io.github.klimPaskov/hoi4-agent-tools",
-  "version": "3.4.0",
+  "version": "3.4.1",
   "description": "Analyze HOI4 events, decisions, impact, tech, AI, and MTTH; build focus trees, GUIs, and maps.",
   "type": "module",
   "license": "Apache-2.0",

package/schemas/configuration.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/configuration.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/configuration.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/continuous-focus-palette.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/continuous-focus-palette.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/continuous-focus-palette.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/custom-weighted-pool.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/custom-weighted-pool.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/custom-weighted-pool.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/decision-inspect-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/decision-inspect-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/decision-inspect-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/event-feature-manifest.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/event-feature-manifest.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/event-feature-manifest.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/focus-plan.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/focus-plan.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/focus-plan.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/focus-planning-sidecar.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/focus-planning-sidecar.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/focus-planning-sidecar.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/gui-animation-source.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/gui-animation-source.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/gui-animation-source.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/gui-helper.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/gui-helper.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/gui-helper.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/gui-scenario.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/gui-scenario.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/gui-scenario.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/helper-expansion-request.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/helper-expansion-request.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/helper-expansion-request.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/helper-expansion-summary.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/helper-expansion-summary.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/helper-expansion-summary.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/impact-inspect-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/impact-inspect-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/impact-inspect-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/map-operation.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/map-operation.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/map-operation.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "oneOf": [
     {

package/schemas/mechanic-test-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/mechanic-test-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/mechanic-test-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/operation-result.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/operation-result.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/operation-result.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/package-check-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/package-check-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/package-check-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/package-manifest.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/package-manifest.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/package-manifest.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-analysis-result.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/probability-analysis-result.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/probability-analysis-result.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-compare-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/probability-compare-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/probability-compare-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-evaluate-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/probability-evaluate-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/probability-evaluate-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-inspect-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/probability-inspect-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/probability-inspect-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-render-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/probability-render-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/probability-render-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-scenario-set.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/probability-scenario-set.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/probability-scenario-set.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-sequence-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/probability-sequence-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/probability-sequence-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-simulate-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/probability-simulate-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/probability-simulate-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-sweep-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/probability-sweep-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/probability-sweep-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/scenario-suite.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/scenario-suite.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/scenario-suite.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/scenario-test-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/scenario-test-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/scenario-test-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/shared-scenario.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.0/schemas/shared-scenario.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.4.1/schemas/shared-scenario.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.klimPaskov/hoi4-agent-tools",
   "title": "HOI4 Agent Tools",
   "description": "Analyze HOI4 events, decisions, impact, tech, AI, and MTTH; build focus trees, GUIs, and maps.",
-  "version": "3.4.0",
+  "version": "3.4.1",
   "repository": {
     "url": "https://github.com/klimPaskov/hoi4-agent-tools",
     "source": "github"
@@ -13,7 +13,7 @@
     {
       "registryType": "npm",
       "identifier": "hoi4-agent-tools",
-      "version": "3.4.0",
+      "version": "3.4.1",
       "transport": {
         "type": "stdio"
       }