hoi4-agent-tools 3.0.8 → 3.0.9

package/CHANGELOG.md

@@ -4,6 +4,18 @@
 
 No unreleased changes.
 
+## 3.0.9 - 2026-09-08
+
+- Evaluate GUI scripted-localisation branches through the shared structured condition evaluator instead of regex threshold guesses.
+- Correct inclusive boundaries, compound conditions, negation, variable operands, constants, and named scopes; retain the existing probability API through core compatibility exports.
+- Resolve source-backed scripted-trigger calls, including declared scalar parameters, and retain helper provenance and unresolved conditions.
+- Keep an unknown earlier localisation branch unresolved instead of selecting a ranked candidate or an unproven fallback.
+- Preserve explicit values and seeded exploratory previews, expose optional named GUI scope bindings, and include per-choice condition evidence in scenario artifacts.
+- Add independent condition truth-table tests and generated-scenario-to-render regressions for the reported failures, colours, scoped helpers, placeholders, and repeatable SVG/PNG output.
+- Align the sparse-mod stdio test's overall budget with its RPC waits and honor matching progress notifications without removing the finite test deadline.
+- Avoid Windows path-resolution races while concurrent stdio processes release capacity slots, retaining private-root validation and explicit linked-slot rejection.
+- Retry Windows delete-pending capacity-slot creation without admitting duplicate work; persistent permission failures remain bounded errors.
+
 ## 3.0.8 - 2026-09-05
 
 - Queue simultaneous tool calls fairly across HTTP sessions and coordinate expensive operations across local task processes sharing private server state.

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

@@ -0,0 +1,399 @@
+import { assignments, astPathFor, firstScalar, nodeLocation, } from './source/index.js';
+import { resolveScopeContext, rootScopeContext, rootStateValue, scopeIdentity, scopeStateValue, } from './scenario-state.js';
+function helperWithArguments(block, invocation) {
+    const parameters = new Map();
+    for (const entry of invocation.entries) {
+        if (entry.type !== 'assignment' || entry.value.type !== 'scalar')
+            return undefined;
+        parameters.set(entry.key.value, entry.value.value);
+    }
+    const missing = new Set();
+    const substitute = (value) => value.replace(/\$([A-Za-z0-9_]+)\$/gu, (match, key) => {
+        const replacement = parameters.get(key);
+        if (replacement === undefined) {
+            missing.add(key);
+            return match;
+        }
+        return replacement;
+    });
+    const visit = (entry) => {
+        if (entry.type === 'scalar')
+            return { ...entry, value: substitute(entry.value) };
+        if (entry.type === 'block')
+            return { ...entry, entries: entry.entries.map(visit) };
+        return {
+            ...entry,
+            key: { ...entry.key, value: substitute(entry.key.value) },
+            value: entry.value.type === 'scalar'
+                ? { ...entry.value, value: substitute(entry.value.value) }
+                : { ...entry.value, entries: entry.value.entries.map(visit) },
+        };
+    };
+    const expanded = { ...block, entries: block.entries.map(visit) };
+    return missing.size === 0 ? expanded : undefined;
+}
+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 numberValue(expression, scenario, context, definitions, path, seen = new Set()) {
+    const literal = numeric(expression);
+    if (literal !== undefined)
+        return literal;
+    const identity = `${path ?? ''}:${expression}`;
+    if (seen.has(identity))
+        return undefined;
+    seen.add(identity);
+    const constant = expression.startsWith('constant:')
+        ? definitions.scriptConstants.get(expression.slice(9))
+        : expression.startsWith('@') && path !== undefined
+            ? definitions.localConstants.get(path)?.get(expression)
+            : undefined;
+    if (constant !== undefined)
+        return numberValue(constant.value, scenario, context, definitions, constant.file.displayPath, seen);
+    const direct = scopeStateValue(scenario, expression, context) ??
+        scopeStateValue(scenario, `variable.${expression}`, context);
+    if (direct !== undefined)
+        return numeric(direct);
+    for (let split = expression.lastIndexOf('.'); split > 0; split = expression.lastIndexOf('.', split - 1)) {
+        const scope = resolveScopeContext(scenario, expression.slice(0, split), context);
+        if (scope !== undefined)
+            return numberValue(expression.slice(split + 1), scenario, scope, definitions, path, seen);
+    }
+    return undefined;
+}
+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 malformedBlock(block, candidate) {
+    if (block.entries.every(({ type }) => type === 'assignment'))
+        return undefined;
+    return {
+        state: 'unresolved',
+        unresolved: [
+            {
+                code: 'TRIGGER_UNRESOLVED',
+                message: 'Condition contains a bare value or block instead of a trigger assignment',
+                candidateId: candidate.id,
+                ...(candidate.provenance[0] === undefined ? {} : { provenance: candidate.provenance[0] }),
+            },
+        ],
+    };
+}
+function evaluateCheckVariable(block, scenario, candidate, assignment, scopeContext, definitions) {
+    const short = assignments(block).find(({ key }) => !['var', 'value', 'compare', 'tooltip'].includes(key.value));
+    const variable = firstScalar(block, 'var')?.value ?? short?.key.value;
+    const target = firstScalar(block, 'value')?.value ??
+        (short?.value.type === 'scalar' ? short.value.value : undefined);
+    if (variable === undefined || target === undefined)
+        return unresolved(assignment, candidate, 'check_variable requires declared var and value');
+    const path = candidate.provenance[0]?.path;
+    const leftNumber = numberValue(variable, scenario, scopeContext, definitions, path);
+    const rightNumber = numberValue(target, scenario, scopeContext, definitions, path);
+    if (leftNumber === undefined || rightNumber === undefined)
+        return unresolved(assignment, candidate, `Scenario does not resolve numeric operands ${variable} and ${target}`);
+    const compareName = firstScalar(block, 'compare')?.value ??
+        (short?.operator.text === '>'
+            ? 'greater_than'
+            : short?.operator.text === '<'
+                ? 'less_than'
+                : 'equals');
+    if (![
+        'greater_than',
+        'greater_than_or_equals',
+        'less_than',
+        'less_than_or_equals',
+        'not_equals',
+        'equals',
+    ].includes(compareName))
+        return unresolved(assignment, candidate, `Unsupported check_variable comparison ${compareName}`);
+    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') {
+        const malformed = malformedBlock(assignment.value, candidate);
+        if (malformed !== undefined)
+            return malformed;
+        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, definitions);
+        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}`);
+            const expanded = helperWithArguments(helper.value, assignment.value);
+            if (expanded === undefined)
+                return unresolved(assignment, candidate, `Scripted trigger ${key} requires declared scalar arguments for every parameter`);
+            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(expanded, 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 explicit = bool(scopeStateValue(scenario, `flag.${right}`, scopeContext));
+        if (explicit !== undefined)
+            return { state: explicit ? 'true' : 'false', unresolved: [] };
+        const flags = scopeContext.expression === 'ROOT' ? scenario.flags : scopeContext.binding.flags;
+        if (scenario.closedFlags === false && flags?.includes(right) !== true)
+            return unresolved(assignment, candidate, `Scenario does not declare flag ${right}`);
+        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 dateNumber = (value) => {
+            const parts = /^(\d+)\.(\d{1,2})\.(\d{1,2})$/u.exec(value);
+            if (parts === null)
+                return undefined;
+            const month = Number(parts[2]);
+            const day = Number(parts[3]);
+            return month < 1 || month > 12 || day < 1 || day > 31
+                ? undefined
+                : Number(parts[1]) * 10_000 + month * 100 + day;
+        };
+        const leftDate = dateNumber(scenario.date);
+        const rightDate = dateNumber(right);
+        if (leftDate === undefined || rightDate === undefined)
+            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) !== undefined) {
+        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,
+            state: bool(right) === false ? invert(evaluated.state) : evaluated.state,
+            helperProvenance: [helperProvenance, ...(evaluated.helperProvenance ?? [])],
+        };
+    }
+    const declared = scopeStateValue(scenario, key, scopeContext) ??
+        numberValue(key, scenario, scopeContext, definitions, candidate.provenance[0]?.path);
+    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 = numberValue(right, scenario, scopeContext, definitions, candidate.provenance[0]?.path);
+    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 malformed = malformedBlock(block, candidate);
+    if (malformed !== undefined)
+        return malformed;
+    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 ?? []),
+    };
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export const ScenarioScalarSchema = z.union([
+    z.string().max(16_384),
+    z.number(),
+    z.boolean(),
+    z.null(),
+]);
+export const ScenarioValueSchema = z.union([
+    ScenarioScalarSchema,
+    z.array(ScenarioScalarSchema).max(10_000),
+]);
+export const ConditionScopeBindingSchema = z
+    .object({
+    id: z.string().min(1).max(256),
+    type: z
+        .enum([
+        'country',
+        'state',
+        'character',
+        'unit_leader',
+        'operative',
+        'strategic_region',
+        'province',
+        'unknown',
+    ])
+        .optional(),
+    actor: z.string().max(256).optional(),
+    state: z.record(z.string(), ScenarioValueSchema).default({}),
+    flags: z.array(z.string().max(256)).max(10_000).optional(),
+    eventTargets: z.record(z.string(), z.string().max(256)).optional(),
+    weight: z.union([z.number(), z.string().max(256)]).optional(),
+})
+    .strict();
+export const ConditionResultSchema = z
+    .object({
+    token: z.string(),
+    sourcePath: z.string(),
+    state: z.enum(['true', 'false', 'unresolved']),
+    localisationKey: z.string().optional(),
+    unresolved: z.array(z.string()),
+})
+    .strict();

package/dist/hoi4_agent_tools/core/scenario-state.js

@@ -0,0 +1,97 @@
+function caseInsensitiveEntry(record, key) {
+    if (record === undefined)
+        return undefined;
+    if (Object.hasOwn(record, key))
+        return record[key];
+    const normalized = key.toLowerCase();
+    const found = Object.entries(record).find(([candidate]) => candidate.toLowerCase() === normalized);
+    return found?.[1];
+}
+export function rootScopeContext(scenario) {
+    return {
+        expression: 'ROOT',
+        binding: {
+            id: scenario.actor ?? 'ROOT',
+            ...(scenario.actor === undefined ? {} : { actor: scenario.actor }),
+            state: scenario.state,
+            ...(scenario.flags === undefined ? {} : { flags: scenario.flags }),
+            ...(scenario.eventTargets === undefined ? {} : { eventTargets: scenario.eventTargets }),
+        },
+    };
+}
+function explicitScope(scenario, expression, parent) {
+    const binding = caseInsensitiveEntry(scenario.scopes, expression);
+    return binding === undefined ? undefined : { expression, binding, parent };
+}
+export function resolveScopeContext(scenario, expression, current) {
+    const upper = expression.toUpperCase();
+    if (upper === 'ROOT')
+        return current.expression === 'ROOT'
+            ? current
+            : { ...rootScopeContext(scenario), parent: current };
+    if (upper === 'THIS')
+        return current;
+    if (upper === 'PREV')
+        return current.parent ?? explicitScope(scenario, expression, current);
+    const chained = current.expression === 'ROOT' || current.expression === 'THIS'
+        ? expression
+        : `${current.expression}.${expression}`;
+    const chainedBinding = explicitScope(scenario, chained, current);
+    if (chainedBinding !== undefined)
+        return chainedBinding;
+    const direct = explicitScope(scenario, expression, current);
+    if (direct !== undefined)
+        return direct;
+    const targetMatch = /^(?:event_target|scope):(.+)$/iu.exec(expression);
+    const targetId = targetMatch === null
+        ? undefined
+        : (caseInsensitiveEntry(current.binding.eventTargets, targetMatch[1]) ??
+            caseInsensitiveEntry(scenario.eventTargets, targetMatch[1]));
+    if (targetId !== undefined) {
+        const declaredBinding = Object.values(scenario.scopes ?? {}).find((binding) => binding.id === targetId || binding.actor === targetId);
+        return {
+            expression,
+            binding: declaredBinding ?? { id: targetId, actor: targetId, state: {} },
+            parent: current,
+        };
+    }
+    return undefined;
+}
+export function scopeStateValue(scenario, key, current) {
+    if (Object.hasOwn(current.binding.state, key))
+        return current.binding.state[key];
+    if (Object.hasOwn(current.binding.state, `trigger.${key}`))
+        return current.binding.state[`trigger.${key}`];
+    if (current.expression !== 'ROOT')
+        return undefined;
+    if (Object.hasOwn(scenario.state, key))
+        return scenario.state[key];
+    if (Object.hasOwn(scenario.state, `trigger.${key}`))
+        return scenario.state[`trigger.${key}`];
+    return undefined;
+}
+export function rootStateValue(scenario, key) {
+    if (Object.hasOwn(scenario.state, key))
+        return scenario.state[key];
+    if (Object.hasOwn(scenario.state, `trigger.${key}`))
+        return scenario.state[`trigger.${key}`];
+    return undefined;
+}
+export function scopeIdentity(current) {
+    return current.binding.actor ?? current.binding.id;
+}
+export function scopedExpressionValue(scenario, expression) {
+    const scopes = Object.entries(scenario.scopes ?? {}).sort(([left], [right]) => right.length - left.length);
+    for (const [scope, binding] of scopes) {
+        for (const prefix of [`${scope}.`, `scope.${scope}.`, `scopes.${scope}.`]) {
+            if (!expression.toLowerCase().startsWith(prefix.toLowerCase()))
+                continue;
+            const key = expression.slice(prefix.length).replace(/^state\./u, '');
+            if (Object.hasOwn(binding.state, key))
+                return binding.state[key];
+            if (Object.hasOwn(binding.state, `variable.${key}`))
+                return binding.state[`variable.${key}`];
+        }
+    }
+    return undefined;
+}

package/dist/hoi4_agent_tools/core/shared-request-capacity.js

@@ -1,9 +1,11 @@
 import { randomUUID } from 'node:crypto';
-import { mkdir, readdir, rmdir, stat, unlink, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, readdir, rmdir, unlink, writeFile } from 'node:fs/promises';
 import { hostname } from 'node:os';
+import path from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { sha256Bytes } from './canonical.js';
 import { canonicalPath, containedGeneratedPath } from './workspace.js';
+import { ServiceError } from './result.js';
 function processAlive(pid) {
     try {
         process.kill(pid, 0);
@@ -28,31 +30,40 @@ export class SharedRequestCapacity {
         const root = await containedGeneratedPath(await canonicalPath(this.stateRoot, signal), 'request-capacity', sha256Bytes(hostname().toLowerCase()).slice(0, 16));
         await mkdir(root, { recursive: true });
         const lease = `${process.pid}-${randomUUID()}.lease`;
+        const pendingDeletionFailures = new Map();
         for (;;) {
             signal.throwIfAborted();
             for (let index = 0; index < this.capacity; index += 1) {
-                let slot;
-                try {
-                    slot = await containedGeneratedPath(root, String(index));
-                }
-                catch (error) {
-                    // Another process can finish a slot while canonical containment is checked.
-                    if (error.code === 'ENOENT')
-                        continue;
-                    throw error;
-                }
+                // Only the stable private parent is canonicalized. A slot can disappear during
+                // another owner's release; realpath on that ephemeral directory races on Windows.
+                // The numeric component cannot escape, and mkdir atomically proves new ownership.
+                const slot = path.join(root, String(index));
                 try {
                     await mkdir(slot);
+                    pendingDeletionFailures.delete(index);
                 }
                 catch (error) {
-                    if (error.code !== 'EEXIST')
+                    const code = error.code;
+                    // Windows can retain a delete-pending directory handle after rmdir
+                    // returns. Recreating that slot reports EPERM/EBUSY, not EEXIST.
+                    // No work is admitted until a later mkdir actually succeeds.
+                    if (process.platform === 'win32' && ['EPERM', 'EBUSY'].includes(code ?? '')) {
+                        const failures = (pendingDeletionFailures.get(index) ?? 0) + 1;
+                        pendingDeletionFailures.set(index, failures);
+                        if (failures >= 50)
+                            throw error;
+                        await this.reap(slot);
+                        continue;
+                    }
+                    if (code !== 'EEXIST')
                         throw error;
+                    pendingDeletionFailures.delete(index);
                     await this.reap(slot);
                     continue;
                 }
                 let owner;
                 try {
-                    owner = await containedGeneratedPath(slot, lease);
+                    owner = path.join(slot, lease);
                     await writeFile(owner, '', { flag: 'wx', mode: 0o600 });
                 }
                 catch (error) {
@@ -71,7 +82,8 @@ export class SharedRequestCapacity {
                     await unlink(owner);
                     await rmdir(slot).catch((error) => {
                         const code = error.code;
-                        if (code !== 'ENOENT' && code !== 'ENOTEMPTY')
+                        if (!['ENOENT', 'ENOTEMPTY'].includes(code ?? '') &&
+                            !(process.platform === 'win32' && ['EPERM', 'EBUSY'].includes(code ?? '')))
                             throw error;
                     });
                 }
@@ -81,9 +93,12 @@ export class SharedRequestCapacity {
     }
     async reap(slot) {
         try {
+            const metadata = await lstat(slot);
+            if (metadata.isSymbolicLink() || !metadata.isDirectory())
+                throw new ServiceError('PATH_GENERATED_ROOT_ESCAPE', 'Execution capacity slot must be a real directory beneath its private root');
             const owners = await readdir(slot);
             if (owners.length === 0) {
-                if (Date.now() - (await stat(slot)).mtimeMs < 30_000)
+                if (Date.now() - metadata.mtimeMs < 30_000)
                     return;
             }
             else {
@@ -92,7 +107,7 @@ export class SharedRequestCapacity {
                     if (match === null || processAlive(Number(match[1])))
                         return;
                     // Unique owner names prevent a concurrent reaper from deleting a new lease.
-                    await unlink(await containedGeneratedPath(slot, name)).catch((error) => {
+                    await unlink(path.join(slot, name)).catch((error) => {
                         if (error.code !== 'ENOENT')
                             throw error;
                     });
@@ -101,7 +116,9 @@ export class SharedRequestCapacity {
             await rmdir(slot);
         }
         catch (error) {
-            if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(error.code ?? ''))
+            const code = error.code ?? '';
+            if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(code) &&
+                !(process.platform === 'win32' && ['EPERM', 'EBUSY'].includes(code)))
                 throw error;
         }
     }