hoi4-agent-tools 3.0.7 → 3.0.9

package/dist/hoi4_agent_tools/probability/trigger-evaluator.js

@@ -1,287 +1 @@
-import { assignments, astPathFor, firstScalar, nodeLocation, } from '../core/source/index.js';
-import { resolveScopeContext, rootScopeContext, rootStateValue, scopeIdentity, scopeStateValue, } from './scenario-state.js';
-function combineAnd(values) {
-    if (values.includes('false'))
-        return 'false';
-    return values.includes('unresolved') ? 'unresolved' : 'true';
-}
-function combineOr(values) {
-    if (values.includes('true'))
-        return 'true';
-    return values.includes('unresolved') ? 'unresolved' : 'false';
-}
-function invert(value) {
-    return value === 'true' ? 'false' : value === 'false' ? 'true' : 'unresolved';
-}
-function bool(value) {
-    if (typeof value === 'boolean')
-        return value;
-    if (value === 'yes' || value === 'true')
-        return true;
-    if (value === 'no' || value === 'false')
-        return false;
-    return undefined;
-}
-function numeric(value) {
-    if (typeof value === 'number' && Number.isFinite(value))
-        return value;
-    if (typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value)))
-        return Number(value);
-    return undefined;
-}
-function compare(left, right, operator) {
-    if (typeof left === 'number' && typeof right === 'number') {
-        if (operator === '>')
-            return left > right;
-        if (operator === '<')
-            return left < right;
-    }
-    return operator === '!=' ? left !== right : left === right;
-}
-function unresolved(assignment, candidate, reason) {
-    return {
-        state: 'unresolved',
-        unresolved: [
-            {
-                code: 'TRIGGER_UNRESOLVED',
-                message: reason,
-                path: assignment.key.value,
-                candidateId: candidate.id,
-                ...(candidate.provenance[0] === undefined ? {} : { provenance: candidate.provenance[0] }),
-            },
-        ],
-    };
-}
-function evaluateCheckVariable(block, scenario, candidate, assignment, scopeContext) {
-    const variable = firstScalar(block, 'var')?.value;
-    const target = firstScalar(block, 'value')?.value;
-    if (variable === undefined || target === undefined)
-        return unresolved(assignment, candidate, 'check_variable requires declared var and value');
-    const left = scopeStateValue(scenario, `variable.${variable}`, scopeContext) ??
-        scopeStateValue(scenario, variable, scopeContext);
-    const leftNumber = numeric(left);
-    const rightNumber = numeric(target);
-    if (leftNumber === undefined || rightNumber === undefined)
-        return unresolved(assignment, candidate, `Scenario does not declare numeric variable ${variable}`);
-    const compareName = firstScalar(block, 'compare')?.value ?? 'equals';
-    const result = compareName === 'greater_than'
-        ? leftNumber > rightNumber
-        : compareName === 'greater_than_or_equals'
-            ? leftNumber >= rightNumber
-            : compareName === 'less_than'
-                ? leftNumber < rightNumber
-                : compareName === 'less_than_or_equals'
-                    ? leftNumber <= rightNumber
-                    : compareName === 'not_equals'
-                        ? leftNumber !== rightNumber
-                        : leftNumber === rightNumber;
-    return { state: result ? 'true' : 'false', unresolved: [] };
-}
-function evaluateAssignmentCore(assignment, scenario, candidate, definitions, helperStack, scopeContext) {
-    const key = assignment.key.value;
-    if (assignment.value.type === 'block') {
-        if (key === 'AND')
-            return evaluateTriggerBlock(assignment.value, scenario, candidate, definitions, helperStack, scopeContext);
-        if (key === 'OR') {
-            const children = assignments(assignment.value).map((child) => evaluateAssignment(child, scenario, candidate, definitions, helperStack, scopeContext));
-            return {
-                state: combineOr(children.map(({ state }) => state)),
-                unresolved: children.flatMap(({ unresolved: items }) => items),
-                helperProvenance: children.flatMap(({ helperProvenance }) => helperProvenance ?? []),
-            };
-        }
-        if (key === 'NOT' || key === 'NOR' || key === 'NAND') {
-            const children = assignments(assignment.value).map((child) => evaluateAssignment(child, scenario, candidate, definitions, helperStack, scopeContext));
-            const base = key === 'NAND'
-                ? combineAnd(children.map(({ state }) => state))
-                : combineOr(children.map(({ state }) => state));
-            return {
-                state: invert(base),
-                unresolved: children.flatMap(({ unresolved: items }) => items),
-                helperProvenance: children.flatMap(({ helperProvenance }) => helperProvenance ?? []),
-            };
-        }
-        if (key === 'check_variable')
-            return evaluateCheckVariable(assignment.value, scenario, candidate, assignment, scopeContext);
-        if (key === 'is_in_array' || key === 'is_variable_in_array') {
-            const arrayId = firstScalar(assignment.value, 'array')?.value;
-            const declaredValue = firstScalar(assignment.value, 'value')?.value;
-            if (arrayId === undefined || declaredValue === undefined)
-                return unresolved(assignment, candidate, `${key} requires array and value`);
-            const array = scopeStateValue(scenario, `array.${arrayId}`, scopeContext) ??
-                rootStateValue(scenario, `array.${arrayId}`);
-            if (!Array.isArray(array))
-                return unresolved(assignment, candidate, `Scenario does not declare array ${arrayId}`);
-            const compared = ['THIS', 'ROOT', 'PREV'].includes(declaredValue.toUpperCase()) ||
-                resolveScopeContext(scenario, declaredValue, scopeContext) !== undefined
-                ? scopeIdentity(resolveScopeContext(scenario, declaredValue, scopeContext) ?? scopeContext)
-                : (scopeStateValue(scenario, declaredValue, scopeContext) ?? declaredValue);
-            return { state: array.includes(compared) ? 'true' : 'false', unresolved: [] };
-        }
-        const resolvedScope = resolveScopeContext(scenario, key, scopeContext);
-        if (resolvedScope !== undefined)
-            return evaluateTriggerBlock(assignment.value, scenario, candidate, definitions, helperStack, resolvedScope);
-        const helper = definitions.scriptedTriggers.get(key);
-        if (helper !== undefined) {
-            if (helperStack.includes(key))
-                return unresolved(assignment, candidate, `Scripted trigger recursion detected at ${key}`);
-            if (assignments(assignment.value).length > 0)
-                return unresolved(assignment, candidate, `Parameterized scripted trigger ${key} is not expanded without declared arguments`);
-            const helperProvenance = {
-                path: helper.file.displayPath,
-                rootKind: helper.file.rootKind,
-                loadOrder: helper.file.loadOrder,
-                sourceHash: helper.file.sha256,
-                location: nodeLocation(helper.document, helper.node, key),
-                ...(astPathFor(helper.document, helper.node) === undefined
-                    ? {}
-                    : { astPath: astPathFor(helper.document, helper.node) }),
-                symbol: key,
-                helperChain: [...helperStack, key],
-            };
-            const evaluated = evaluateTriggerBlock(helper.value, scenario, {
-                ...candidate,
-                document: helper.document,
-                provenance: [helperProvenance, ...candidate.provenance],
-            }, definitions, [...helperStack, key], scopeContext);
-            return {
-                ...evaluated,
-                helperProvenance: [helperProvenance, ...(evaluated.helperProvenance ?? [])],
-            };
-        }
-        const declaredScope = bool(rootStateValue(scenario, `scope.${key}`));
-        if (declaredScope !== undefined)
-            return { state: declaredScope ? 'true' : 'false', unresolved: [] };
-        return unresolved(assignment, candidate, `Scoped or compound trigger ${key} is not declared by the scenario`);
-    }
-    const right = assignment.value.value;
-    if (key === 'always') {
-        const value = bool(right);
-        return value === undefined
-            ? unresolved(assignment, candidate, 'always trigger is not boolean')
-            : { state: value ? 'true' : 'false', unresolved: [] };
-    }
-    if (key === 'has_country_flag' || key === 'has_global_flag' || key === 'has_state_flag') {
-        const flags = scopeContext.expression === 'ROOT' ? scenario.flags : scopeContext.binding.flags;
-        return { state: flags?.includes(right) === true ? 'true' : 'false', unresolved: [] };
-    }
-    if (key === 'has_event_target') {
-        const eventTargets = scopeContext.binding.eventTargets ?? scenario.eventTargets;
-        return {
-            state: Object.hasOwn(eventTargets ?? {}, right) ? 'true' : 'false',
-            unresolved: [],
-        };
-    }
-    if (key === 'tag' || key === 'original_tag') {
-        const actor = scopeContext.expression === 'ROOT'
-            ? scenario.actor
-            : (scopeContext.binding.actor ?? scopeContext.binding.id);
-        if (actor === undefined)
-            return unresolved(assignment, candidate, `Scenario does not declare actor for ${key}`);
-        return {
-            state: compare(actor, right, assignment.operator.text) ? 'true' : 'false',
-            unresolved: [],
-        };
-    }
-    if (key === 'date') {
-        if (scenario.date === undefined)
-            return unresolved(assignment, candidate, 'Scenario does not declare date');
-        const leftDate = Number(scenario.date.replaceAll('.', ''));
-        const rightDate = Number(right.replaceAll('.', ''));
-        if (!Number.isFinite(leftDate) || !Number.isFinite(rightDate))
-            return unresolved(assignment, candidate, 'Date comparison is not numeric');
-        return {
-            state: compare(leftDate, rightDate, assignment.operator.text) ? 'true' : 'false',
-            unresolved: [],
-        };
-    }
-    const helper = definitions.scriptedTriggers.get(key);
-    if (helper !== undefined && bool(right) === true) {
-        if (helperStack.includes(key))
-            return unresolved(assignment, candidate, `Scripted trigger recursion detected at ${key}`);
-        const helperProvenance = {
-            path: helper.file.displayPath,
-            rootKind: helper.file.rootKind,
-            loadOrder: helper.file.loadOrder,
-            sourceHash: helper.file.sha256,
-            location: nodeLocation(helper.document, helper.node, key),
-            ...(astPathFor(helper.document, helper.node) === undefined
-                ? {}
-                : { astPath: astPathFor(helper.document, helper.node) }),
-            symbol: key,
-            helperChain: [...helperStack, key],
-        };
-        const evaluated = evaluateTriggerBlock(helper.value, scenario, {
-            ...candidate,
-            document: helper.document,
-            provenance: [helperProvenance, ...candidate.provenance],
-        }, definitions, [...helperStack, key], scopeContext);
-        return {
-            ...evaluated,
-            helperProvenance: [helperProvenance, ...(evaluated.helperProvenance ?? [])],
-        };
-    }
-    const declared = scopeStateValue(scenario, key, scopeContext);
-    if (declared === undefined)
-        return unresolved(assignment, candidate, `Scenario does not declare trigger ${key}`);
-    const expectedBoolean = bool(right);
-    const actualBoolean = bool(declared);
-    if (expectedBoolean !== undefined && actualBoolean !== undefined)
-        return { state: expectedBoolean === actualBoolean ? 'true' : 'false', unresolved: [] };
-    const leftNumber = numeric(declared);
-    const rightNumber = numeric(right);
-    if (leftNumber !== undefined && rightNumber !== undefined)
-        return {
-            state: compare(leftNumber, rightNumber, assignment.operator.text) ? 'true' : 'false',
-            unresolved: [],
-        };
-    if (typeof declared === 'string')
-        return {
-            state: compare(declared, right, assignment.operator.text) ? 'true' : 'false',
-            unresolved: [],
-        };
-    return unresolved(assignment, candidate, `Trigger ${key} cannot compare the declared scenario value`);
-}
-function evaluateAssignment(assignment, scenario, candidate, definitions, helperStack, scopeContext) {
-    const evaluated = evaluateAssignmentCore(assignment, scenario, candidate, definitions, helperStack, scopeContext);
-    const source = candidate.provenance[0];
-    const provenance = candidate.document === undefined || source === undefined
-        ? source
-        : {
-            ...source,
-            location: nodeLocation(candidate.document, assignment, assignment.key.value),
-            ...(astPathFor(candidate.document, assignment) === undefined
-                ? {}
-                : { astPath: astPathFor(candidate.document, assignment) }),
-            symbol: assignment.key.value,
-        };
-    const expression = assignment.value.type === 'scalar'
-        ? `${assignment.key.value} ${assignment.operator.text} ${assignment.value.value}`
-        : assignment.key.value;
-    return {
-        ...evaluated,
-        trace: [
-            {
-                operation: 'eligibility',
-                expression,
-                applied: evaluated.state,
-                ...(provenance === undefined ? {} : { provenance }),
-            },
-            ...(evaluated.trace ?? []),
-        ],
-    };
-}
-export function evaluateTriggerBlock(block, scenario, candidate, definitions, helperStack = [], scopeContext = rootScopeContext(scenario)) {
-    const override = scenario.candidateOverrides?.[candidate.id];
-    if (override !== undefined)
-        return { state: override ? 'true' : 'false', unresolved: [] };
-    if (block === undefined)
-        return { state: 'true', unresolved: [] };
-    const children = assignments(block).map((assignment) => evaluateAssignment(assignment, scenario, candidate, definitions, helperStack, scopeContext));
-    return {
-        state: combineAnd(children.map(({ state }) => state)),
-        unresolved: children.flatMap(({ unresolved: items }) => items),
-        helperProvenance: children.flatMap(({ helperProvenance }) => helperProvenance ?? []),
-        trace: children.flatMap(({ trace }) => trace ?? []),
-    };
-}
+export { evaluateTriggerBlock } from '../core/condition-evaluator.js';

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.0.7';
+export const PACKAGE_VERSION = '3.0.9';
 export const MCP_PROTOCOL_VERSION = LATEST_PROTOCOL_VERSION;
 export const CONFIG_VERSION = 1;
 export const TRANSACTION_VERSION = 1;

package/docs/development.md

@@ -23,6 +23,8 @@ The event-chain acceptance fixture contains more than 300 project-owned event de
 
 The technology acceptance fixture contains 1,040 project-owned technologies across 13 folders and exercises classic and current doctrines, prerequisites, exclusive branches, multiple placements, unlocks, bonuses, grants, assets, unresolved references, rendering, and comparison.
 
+`npx vitest run tests/integration/mcp-concurrent-workloads.test.ts` tests simultaneous production calls across all six domains over six HTTP sessions and four independent stdio processes, including artifact retrieval and queued cancellation. Execution limits and connection behavior are described in [HTTP](http.md) and the [concurrency decision](https://github.com/klimPaskov/hoi4-agent-tools/blob/main/docs/adr/0026-concurrent-request-execution.md).
+
 The probability fixture contains more than 150 weighted blocks, 250 scenarios, and a declared stateful pool. Run `npm run benchmark` after analyzer changes. On the July 22, 2026 reference run, cold indexing took 28 ms, a cached block evaluation 29 ms, the 250-row matrix 85 ms, one million draws 9 ms, 3/12/25-candidate sequence cases 20/2,079/356 ms, and retrieval of a 1.84 MB result 3 ms. Review budgets are 250 ms, 150 ms, 750 ms, 100 ms, 200/10,000/3,000 ms, and 100 ms respectively; accuracy, method metadata, and omitted probability must not be weakened to meet them.
 
 Local opt-in tests can also read an installed game and an external mod without copying their sources:

package/docs/gui.md

@@ -41,7 +41,9 @@ Layout follows Clausewitz orientation and element-origin anchors, including `CEN
 
 Scripted-GUI composition follows `parent_scripted_gui` chains even when the linked child window is a top-level sibling in the `.gui` file. Literal `always = yes` and `always = no` visibility and click-enabled blocks are applied automatically. A scenario's `values` object supplies concrete runtime values in one place: variable names resolve numeric text, scripted-localisation names resolve dynamic labels, a progress-bar element name sets its fill value, and element keys ending in `.image`, `.frame`, `.x`, `.y`, `.visible`, or `.enabled` update that visual property. Scripted-GUI property expressions such as `image = "[GetMeterSprite]"` or `x = meter_fill_width` consume matching scenario values automatically. Dynamic text is parsed after scenario and scripted-localisation substitution, so a runtime string containing `£command_power` or `£[GetResourceIcon]` renders the resolved inline HOI4 text icon instead of literal marker text. Dynamic lists instantiate their declared `entry_container` or `country_scope_entry_container`; each scenario row can select the country template with `countryScope`, choose an explicit `entryContainer`, provide `countryTag` and `ideology` for `GetFlag`, and supply row-scoped text, image, frame, position, visibility, and enabled values. Masked country sprites use the actual mask and overlay dimensions, so custom flag sizes are discovered from GFX assets rather than assumed by the renderer.
 
-`hoi4.gui_inspect` and `hoi4.gui_render` generate a plausible seeded runtime scenario by default. The generator follows the complete `parent_scripted_gui` surface, discovers numeric and text tokens in GUI localisation and scripted-GUI properties, chooses real scripted-localisation text and sprite candidates, applies simple source thresholds, fills meters within their declared ranges, populates dynamic lists with coherent rows, selects one overlapping tab pane, keeps active and idle controls mutually exclusive, and leaves values explicitly supplied by the caller unchanged. Normal controls and animation frames remain stable unless variation is explicitly requested. Every explicit `relatedScenarios` entry is rendered beside the generated view.
+`hoi4.gui_inspect` and `hoi4.gui_render` generate a seeded exploratory preview by default. The generator follows the complete `parent_scripted_gui` surface, discovers numeric and text tokens, fills meters within their declared ranges, and populates dynamic lists with coherent rows. Scripted-localisation text and sprite branches use the same structured condition evaluator as probability analysis, including compound conditions, inclusive comparisons, constants, declared scopes, and scripted triggers. An unknown earlier condition leaves the token unresolved instead of guessing a branch. The scenario's `conditionResults` records checked choices and missing inputs. Explicit values remain authoritative; generated inputs are not verified campaign state. Normal controls and animation frames remain stable unless variation is requested. Every explicit `relatedScenarios` entry is rendered beside the generated view.
+
+Declare scoped facts with `scopes`, for example `"scopes": { "FROM": { "id": "target", "actor": "FRA", "state": { "support": 10 } } }`. Existing flat values such as `FROM.support` remain usable. Seeded pane and active/idle selection is exploratory layout sampling, not proof that every visibility branch is reachable.
 
 Generation is reproducible. Set `generatedScenarios.seed` to any stable string for an exact rerun, use `count` for several plausible versions, or configure numeric bounds, integer or decimal values, list row bounds, text samples, visibility probability, and state variation. Generated numeric values favour ordinary mid-range states, obey literal limits such as `[?capacity]/10`, keep displayed current/limit pairs coherent, and remain inside progress-bar ranges. The generated view is the default. Set `enabled` to `false` when only the supplied placeholder scenario should render, or set `preservePlaceholder` to `true` to include the placeholder beside generated scenarios.
 

package/docs/http.md

@@ -4,7 +4,11 @@ Local MCP clients should use the default stdio registration. Use `hoi4-agent-too
 
 The HTTP server exposes the MCP endpoint at `/mcp`.
 
-JSON request bodies default to and are capped at 64 MiB. This leaves transport-envelope headroom for the bounded 16 MiB GUI text package and a maximum canonical map mask while the two-request concurrency ceiling keeps aggregate body bytes at or below 128 MiB.
+The server accepts up to 128 simultaneous HTTP requests by default and queues expensive tool work automatically. Cancellation, discovery, and protocol replies retain separate admission headroom. Active requests keep their sessions alive; credential expiry still applies.
+
+JSON request bodies default to and are capped at 64 MiB, with a shared 128 MiB budget based on declared request sizes. Chunked bodies reserve their configured maximum. These byte reservations are independent of the number of accepted requests.
+
+`maxConcurrentTools` controls expensive operations per server engine (default 2), and `maxSharedTools` controls operations across local processes sharing the same `serverStateRoot` (default 4). Calls waiting for capacity remain cancellable and emit progress when requested. Increase execution capacity only when the host has enough memory for the corresponding scans and renders. HTTP admission, connection, session, and rate limits remain separately configurable.
 
 Resumable event history defaults to 2 MiB per session within the 16 MiB global store, enough to retain one framed 1 MiB artifact-resource chunk.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hoi4-agent-tools",
   "mcpName": "io.github.klimPaskov/hoi4-agent-tools",
-  "version": "3.0.7",
+  "version": "3.0.9",
   "description": "Analyze HOI4 events, tech trees, AI weights, and MTTH; build focus trees, GUIs, and maps.",
   "type": "module",
   "license": "Apache-2.0",
@@ -130,7 +130,8 @@
   "overrides": {
     "@hono/node-server": "2.1.0",
     "brace-expansion": "5.0.9",
-    "fast-uri": "3.1.5",
+    "fast-uri": "3.1.7",
+    "qs": "6.16.0",
     "hono": "4.13.1",
     "nanoid": "3.3.18",
     "ip-address": "10.4.0",