hoi4-agent-tools 3.0.7 → 3.0.9

package/CHANGELOG.md

@@ -4,6 +4,32 @@
 
 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.
+- Rotate across every waiting session and canonicalize configured storage aliases, including Windows short-name paths, before acquiring shared execution capacity.
+- Keep every tool call responsive with strictly increasing MCP progress notifications during execution and queue waits; allow cancellation and discovery while tool capacity is occupied.
+- Separate HTTP request admission and body-byte reservations from expensive execution capacity, replacing the two-request ceiling with defaults suitable for parallel agents.
+- Keep active HTTP sessions alive, yield during shared source indexing, and serialize backpressured stdio output without leaking listeners or leaving sends pending after a disconnect.
+- Share cached GUI source graphs across sessions using the same engine instead of retaining a separate graph per client.
+- Reverify artifacts after metadata changes caused by concurrent publication-link cleanup, avoiding false hash collisions while still rejecting altered bytes.
+- Serialize artifact admission, publication, and failed-batch cleanup across processes so one writer cannot remove evidence committed by another.
+- Add concurrent production workflows spanning focus, GUI, map, event, technology, and probability tools over both transports, including shared artifacts, session expiry, cancelled queue entries, and abandoned process recovery.
+- Qualify each map layer separately from semantic and pixel diffs so failures and deadlines identify the affected operation rather than an aggregate rendering loop.
+- Update `fast-uri` and `qs` to patched releases identified by the dependency audit.
+
 ## 3.0.7 - 2026-09-01
 
 - Reclaim detached parser, graph, and render memory after the idle cache window so parallel coding-agent tasks do not retain large V8 heaps and trigger `Transport closed` through host memory exhaustion. Idle cleanup is coordinated across every MCP domain and never compacts during an active tool call.

package/dist/hoi4_agent_tools/core/artifacts.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { z } from 'zod/v4';
 import { canonicalJson, compareCodeUnits, sha256Bytes } from './canonical.js';
 import { ServiceError } from './result.js';
+import { SharedRequestCapacity } from './shared-request-capacity.js';
 import { containedGeneratedPath, isPortablePathSegment } from './workspace.js';
 const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/u);
 const artifactProvenanceSchema = z
@@ -329,7 +330,9 @@ async function withArtifactQueue(root, action, signal) {
     artifactQueues.set(root, tail);
     try {
         await waitForArtifactTurn(previous, signal);
-        return await action();
+        // Admission, publication, and rollback must be one critical section across
+        // processes too: another writer may reuse the same immutable address.
+        return await new SharedRequestCapacity(root, 1).run(signal ?? new AbortController().signal, action);
     }
     finally {
         release();
@@ -607,6 +610,23 @@ async function publishExclusiveFile(target, bytes, signal) {
     }
 }
 async function readVerifiedArtifactRange(filePath, expectedSha256, range, verifiedIdentity, signal) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return await readArtifactRangeOnce(filePath, expectedSha256, range, attempt === 0 ? verifiedIdentity : undefined, signal);
+        }
+        catch (error) {
+            if (attempt >= 2 ||
+                !(error instanceof ServiceError) ||
+                error.code !== 'ARTIFACT_READ_INCOMPLETE')
+                throw error;
+            // Removing the temporary hard link after atomic publication changes ctime
+            // without changing content. Retry from a fresh handle and hash all bytes;
+            // never reuse cached verification after an identity change.
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+    }
+}
+async function readArtifactRangeOnce(filePath, expectedSha256, range, verifiedIdentity, signal) {
     signal?.throwIfAborted();
     if (range !== undefined &&
         (!Number.isSafeInteger(range.offset) ||

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/configuration.js

@@ -3,7 +3,8 @@ import path from 'node:path';
 import { z } from 'zod/v4';
 import { CONFIG_VERSION } from '../version.js';
 import { ServiceError } from './result.js';
-export const HTTP_MAX_SAFE_CONCURRENT_REQUESTS = 2;
+export const HTTP_MAX_SAFE_CONCURRENT_REQUESTS = 1024;
+export const HTTP_DEFAULT_CONCURRENT_REQUESTS = 128;
 export const HTTP_MAX_BODY_BYTES = 67_108_864;
 export const HTTP_MAX_AGGREGATE_BODY_BYTES = 134_217_728;
 export const HTTP_DEFAULT_SESSION_EVENT_BYTES = 2_097_152;
@@ -132,6 +133,8 @@ export const serverConfigurationSchema = z
     })
         .optional(),
     scanMaxFiles: z.number().int().min(1).max(1_000_000).default(DEFAULT_SCAN_MAX_FILES),
+    maxConcurrentTools: z.number().int().min(1).max(32).default(2),
+    maxSharedTools: z.number().int().min(1).max(128).default(4),
     scanMaxBytes: z
         .number()
         .int()
@@ -193,18 +196,18 @@ export const serverConfigurationSchema = z
         headersTimeoutMs: z.number().int().min(1_000).max(120_000).default(10_000),
         requestTimeoutMs: z.number().int().min(1_000).max(300_000).default(30_000),
         keepAliveTimeoutMs: z.number().int().min(1_000).max(120_000).default(5_000),
-        maxConnections: z.number().int().min(1).max(100_000).default(64),
+        maxConnections: z.number().int().min(1).max(100_000).default(512),
         maxRequestsPerSocket: z.number().int().min(1).max(100_000).default(100),
         maxConcurrentRequests: z
             .number()
             .int()
             .min(1)
             .max(HTTP_MAX_SAFE_CONCURRENT_REQUESTS)
-            .default(HTTP_MAX_SAFE_CONCURRENT_REQUESTS),
+            .default(HTTP_DEFAULT_CONCURRENT_REQUESTS),
         maxSessions: z.number().int().min(1).max(10_000).default(128),
         maxSessionsPerPrincipal: z.number().int().min(1).max(10_000).default(32),
-        maxEventStreams: z.number().int().min(1).max(10_000).default(32),
-        maxEventStreamsPerPrincipal: z.number().int().min(1).max(10_000).default(4),
+        maxEventStreams: z.number().int().min(1).max(10_000).default(128),
+        maxEventStreamsPerPrincipal: z.number().int().min(1).max(10_000).default(32),
         maxSessionEventBytes: z
             .number()
             .int()
@@ -212,7 +215,7 @@ export const serverConfigurationSchema = z
             .max(67_108_864)
             .default(HTTP_DEFAULT_SESSION_EVENT_BYTES),
         maxEventStoreBytes: z.number().int().min(65_536).max(268_435_456).default(16_777_216),
-        requestsPerMinute: z.number().int().min(1).max(100_000).default(120),
+        requestsPerMinute: z.number().int().min(1).max(100_000).default(6_000),
         sessionTtlSeconds: z.number().int().min(60).max(86_400).default(3600),
     })
         .strict()
@@ -274,16 +277,16 @@ export const serverConfigurationSchema = z
         headersTimeoutMs: 10_000,
         requestTimeoutMs: 30_000,
         keepAliveTimeoutMs: 5_000,
-        maxConnections: 64,
+        maxConnections: 512,
         maxRequestsPerSocket: 100,
-        maxConcurrentRequests: HTTP_MAX_SAFE_CONCURRENT_REQUESTS,
+        maxConcurrentRequests: HTTP_DEFAULT_CONCURRENT_REQUESTS,
         maxSessions: 128,
         maxSessionsPerPrincipal: 32,
-        maxEventStreams: 32,
-        maxEventStreamsPerPrincipal: 4,
+        maxEventStreams: 128,
+        maxEventStreamsPerPrincipal: 32,
         maxSessionEventBytes: HTTP_DEFAULT_SESSION_EVENT_BYTES,
         maxEventStoreBytes: 16_777_216,
-        requestsPerMinute: 120,
+        requestsPerMinute: 6_000,
         sessionTtlSeconds: 3600,
     }),
 })
@@ -332,23 +335,6 @@ export const serverConfigurationSchema = z
             message: 'HTTP keep-alive timeout must be shorter than the header timeout',
         });
     }
-    const concurrentScanBytes = value.scanMaxBytes * value.http.maxConcurrentRequests;
-    if (!Number.isSafeInteger(concurrentScanBytes) || concurrentScanBytes > 536_870_912) {
-        context.addIssue({
-            code: 'custom',
-            path: ['scanMaxBytes'],
-            message: 'Scan-byte ceiling multiplied by HTTP concurrency must not exceed 512 MiB',
-        });
-    }
-    const concurrentBodyBytes = value.http.maxBodyBytes * value.http.maxConcurrentRequests;
-    if (!Number.isSafeInteger(concurrentBodyBytes) ||
-        concurrentBodyBytes > HTTP_MAX_AGGREGATE_BODY_BYTES) {
-        context.addIssue({
-            code: 'custom',
-            path: ['http', 'maxBodyBytes'],
-            message: 'HTTP body-byte ceiling multiplied by concurrency must not exceed 128 MiB',
-        });
-    }
 });
 export async function loadConfiguration(filePath) {
     const absolute = path.resolve(filePath);

package/dist/hoi4_agent_tools/core/engine.js

@@ -3,6 +3,8 @@ import { SymbolIndex } from './index.js';
 import { WorkspaceScanner } from './scanner.js';
 import { ArtifactStore } from './artifacts.js';
 import { TransactionManager } from './transactions.js';
+import { RequestScheduler } from './request-scheduler.js';
+import { SharedRequestCapacity } from './shared-request-capacity.js';
 const RECOVERY_TTL_SECONDS = 3_600;
 const RECOVERY_MAX_BYTES = 536_870_912;
 const RECOVERY_MAX_RECORDS = 128;
@@ -74,6 +76,8 @@ function defaultPatterns(workspace) {
 }
 export class CoreEngine {
     resolver;
+    requests;
+    sharedRequests;
     scanner;
     artifacts;
     transactions;
@@ -84,6 +88,8 @@ export class CoreEngine {
     #activeScanAdmissions = new Set();
     constructor(resolver, services = {}) {
         this.resolver = resolver;
+        this.requests = new RequestScheduler(resolver.config().maxConcurrentTools);
+        this.sharedRequests = new SharedRequestCapacity(resolver.serverState()?.root, resolver.config().maxSharedTools);
         this.scanner =
             services.scanner ??
                 new WorkspaceScanner(resolver.config().scanMaxFiles, resolver.config().scanMaxBytes, resolver.config().scanMaxFileBytes);
@@ -159,7 +165,7 @@ export class CoreEngine {
                     const cached = this.#scanCache.get(cacheKey);
                     if (cached !== undefined)
                         return cached;
-                    const index = SymbolIndex.build(files);
+                    const index = await SymbolIndex.buildAsync(files, controller.signal);
                     const snapshot = {
                         workspaceId,
                         revision,