hoi4-agent-tools 3.9.0 → 4.0.0

package/dist/hoi4_agent_tools/mcp/tools/map.js

@@ -1,6 +1,6 @@
 import { registerLegacyTaskTools } from '../server/legacy-task-tools.js';
 import { z } from 'zod/v4';
-import { mapInspectRequestSchema, mapRenderRequestSchema, mapRewriteRequestSchema, } from '../../schemas/map-requests.js';
+import { mapInspectRequestSchema, mapRewriteRequestSchema } from '../../schemas/map-requests.js';
 import { allocationEvidenceSchema, bitmapRenderHashesSchema, nonNegativeIntegerSchema, operationBlockerDataSchema, sha256Schema, } from '../server/output-schemas.js';
 import { strictOperationResultSchema } from '../server/result.js';
 const changedBoundsSchema = z
@@ -55,7 +55,7 @@ const mapSemanticDiffSchema = z
     normalAdjacenciesChanged: z.boolean(),
 })
     .strict();
-const mapWorkspaceInspectOutputSchema = strictOperationResultSchema(z
+const mapWorkspaceInspectDataSchema = z
     .object({
     revision: sha256Schema,
     sharedRevision: sha256Schema,
@@ -78,9 +78,13 @@ const mapWorkspaceInspectOutputSchema = strictOperationResultSchema(z
     lookupOnly: z.boolean().optional(),
     unknownProvinceIds: z.array(nonNegativeIntegerSchema).max(512),
     missingGeometryProvinceIds: z.array(nonNegativeIntegerSchema).max(512),
+    scriptReferences: z
+        .object({ references: nonNegativeIntegerSchema, missing: nonNegativeIntegerSchema })
+        .strict()
+        .optional(),
 })
-    .strict());
-const mapRenderOutputSchema = strictOperationResultSchema(z
+    .strict();
+const mapRenderDataSchema = z
     .object({
     revision: sha256Schema,
     width: nonNegativeIntegerSchema,
@@ -97,7 +101,8 @@ const mapRenderOutputSchema = strictOperationResultSchema(z
         .strict()
         .optional(),
 })
-    .strict());
+    .strict();
+const mapInspectOutputSchema = strictOperationResultSchema(z.union([mapWorkspaceInspectDataSchema, mapRenderDataSchema]));
 const mapPlanOutputSchema = strictOperationResultSchema(z
     .object({
     execution: z.enum(['applied', 'blocked', 'unchanged']),
@@ -123,23 +128,15 @@ export const mapTaskTools = [
     {
         name: 'hoi4.map_inspect',
         title: 'Inspect HOI4 map',
-        description: 'Validate and inspect the complete map, or use lookupOnly for bounded coordinate and entity lookups.',
+        description: 'Validate the map with a searchable navigator, look up provinces, states, regions, names or coordinates (lookupOnly for speed), render a layer, tile or area, or check script references (references:true). Example: {"query":"Brandenburg","lookupOnly":true}. Returns counts and matches inline; PNG, HTML and the catalog are artifacts.',
         inputSchema: mapInspectRequestSchema,
-        outputSchema: mapWorkspaceInspectOutputSchema,
-        annotations: artifactProducing,
-    },
-    {
-        name: 'hoi4.map_render',
-        title: 'Render map inspection artifacts',
-        description: 'Render searchable full-map PNG, JSON, and HTML, or a reusable source-coordinate tile.',
-        inputSchema: mapRenderRequestSchema,
-        outputSchema: mapRenderOutputSchema,
+        outputSchema: mapInspectOutputSchema,
         annotations: artifactProducing,
     },
     {
         name: 'hoi4.map_rewrite',
         title: 'Create or clean up map content',
-        description: 'Apply map creation, edits, and ID swaps with visual and semantic evidence.',
+        description: 'Create a world, or create, split, merge, move and renumber states and provinces, regenerate positions and supply, and remap script references. Example: {"operations":[{"id":"s1","kind":"create_state","provinceIds":[120,121],"displayName":"New State"}]}. All or nothing: a failed operation leaves no partial files. Returns changed IDs, semantic diff and a render.',
         inputSchema: mapRewriteRequestSchema,
         outputSchema: mapPlanOutputSchema,
         annotations: {

package/dist/hoi4_agent_tools/mcp/tools/probability.js

@@ -1,9 +1,19 @@
 import { registerLegacyTaskTools } from '../server/legacy-task-tools.js';
 import { probabilityPrompt, probabilityPromptArguments, probabilityPromptDefinition, } from '../prompts/probability.js';
 import { z } from 'zod/v4';
-import { probabilityCompareRequestSchema, probabilityEvaluateRequestSchema, probabilityInspectRequestSchema, probabilityRenderRequestSchema, probabilitySequenceRequestSchema, probabilitySimulateRequestSchema, probabilitySweepRequestSchema, } from '../../schemas/probability-requests.js';
+import { probabilityAnalyzeRequestSchema, probabilityInspectRequestSchema, } from '../../schemas/probability-requests.js';
 import { nonNegativeIntegerSchema, sha256Schema } from '../server/output-schemas.js';
 import { strictOperationResultSchema } from '../server/result.js';
+const rankedCandidateSchema = z
+    .object({
+    id: z.string().max(512),
+    eligible: z.enum(['true', 'false', 'unresolved']),
+    weight: z.number().nullable(),
+    weightRange: z.array(z.number().nullable()).length(2).optional(),
+    probability: z.number().nullable(),
+    mtthDays: z.number().nullable().optional(),
+})
+    .strict();
 const analysisDataSchema = z
     .object({
     operation: z.enum(['evaluate', 'sweep', 'simulate', 'sequence', 'compare', 'render']),
@@ -30,6 +40,29 @@ const analysisDataSchema = z
         .optional(),
     comparisonChanges: nonNegativeIntegerSchema.optional(),
     visualResources: nonNegativeIntegerSchema.optional(),
+    ranking: z
+        .array(z
+        .object({
+        scenarioId: z.string().max(512),
+        poolComplete: z.boolean(),
+        candidates: z.array(rankedCandidateSchema).max(12),
+        omittedCandidates: nonNegativeIntegerSchema.optional(),
+    })
+        .strict())
+        .max(4),
+    missingInputs: z.array(z.string().max(1024)).max(16),
+    changes: z
+        .array(z
+        .object({
+        scenarioId: z.string().max(512),
+        candidateId: z.string().max(512),
+        weightDelta: z.number().nullable().optional(),
+        probabilityDelta: z.number().nullable().optional(),
+        eligibility: z.string().max(64).optional(),
+    })
+        .strict())
+        .max(12)
+        .optional(),
 })
     .strict();
 const inspectDataSchema = z
@@ -66,11 +99,12 @@ const inspectDataSchema = z
     requiredInputs: nonNegativeIntegerSchema,
     requiredInputPaths: z.array(z.string().max(1024)).max(32),
     requiredInputPathsTruncated: z.boolean(),
+    adapterRequiredInputPaths: z.array(z.string().max(1024)).max(32).optional(),
     unresolved: nonNegativeIntegerSchema,
 })
     .strict();
 const analysisOutput = strictOperationResultSchema(analysisDataSchema);
-const inspectOutput = strictOperationResultSchema(inspectDataSchema);
+const inspectOutput = strictOperationResultSchema(z.union([analysisDataSchema, inspectDataSchema]));
 const readOnly = {
     readOnlyHint: true,
     destructiveHint: false,
@@ -80,57 +114,17 @@ const readOnly = {
 export const probabilityTaskTools = [
     {
         name: 'hoi4.probability_inspect',
-        title: 'Inspect AI and MTTH weighted logic',
-        description: 'Discover weighted adapters, candidates, provenance, and required inputs.',
+        title: 'Inspect and evaluate AI weights and MTTH',
+        description: 'Find weighted logic (ai_will_do, ai_chance, MTTH, random_list, strategy factors) by path, ID or candidate IDs and evaluate it under declared scenarios, or none: weights, probabilities and the facts still missing. Example: {"candidatePool":["my_decision"],"scenarioSet":[{"actor":"GER","state":{"has_war":false}}]}. Ranks the strongest candidates inline.',
         inputSchema: probabilityInspectRequestSchema,
         outputSchema: inspectOutput,
         annotations: readOnly,
     },
     {
-        name: 'hoi4.probability_evaluate',
-        title: 'Evaluate AI and MTTH scenarios',
-        description: 'Evaluate weights and probabilities under explicit scenarios.',
-        inputSchema: probabilityEvaluateRequestSchema,
-        outputSchema: analysisOutput,
-        annotations: readOnly,
-    },
-    {
-        name: 'hoi4.probability_sweep',
-        title: 'Sweep AI and MTTH parameters',
-        description: 'Evaluate declared ranges, breakpoints, and rank reversals.',
-        inputSchema: probabilitySweepRequestSchema,
-        outputSchema: analysisOutput,
-        annotations: readOnly,
-    },
-    {
-        name: 'hoi4.probability_simulate',
-        title: 'Simulate uncertain weighted scenarios',
-        description: 'Run seeded simulations with distributions and confidence intervals.',
-        inputSchema: probabilitySimulateRequestSchema,
-        outputSchema: analysisOutput,
-        annotations: readOnly,
-    },
-    {
-        name: 'hoi4.probability_sequence',
-        title: 'Analyze a declared weighted sequence',
-        description: 'Analyze a manifest-declared dynamic weighted sequence.',
-        inputSchema: probabilitySequenceRequestSchema,
-        outputSchema: analysisOutput,
-        annotations: readOnly,
-    },
-    {
-        name: 'hoi4.probability_compare',
-        title: 'Compare weighted source patches',
-        description: 'Compare sources or declared pools under identical scenarios.',
-        inputSchema: probabilityCompareRequestSchema,
-        outputSchema: analysisOutput,
-        annotations: readOnly,
-    },
-    {
-        name: 'hoi4.probability_render',
-        title: 'Render AI and MTTH analysis',
-        description: 'Render retained probability analysis as deterministic resources.',
-        inputSchema: probabilityRenderRequestSchema,
+        name: 'hoi4.probability_analyze',
+        title: 'Compare, sweep, simulate, or sequence weighted logic',
+        description: 'Deeper weighted analysis: compare before and after source under the same scenarios, sweep input ranges for breakpoints and rank reversals, simulate uncertain inputs, run a declared pool over time, or render a retained analysis. Example: {"analysis":"sweep","source":"common/decisions/my_decisions.txt","candidatePool":["my_decision"],"scenarioSet":[{"actor":"GER","state":{"variable.pressure":10}}],"sweep":{"paths":["variable.pressure"],"steps":10}}.',
+        inputSchema: probabilityAnalyzeRequestSchema,
         outputSchema: analysisOutput,
         annotations: readOnly,
     },

package/dist/hoi4_agent_tools/mcp/tools/reference.js

@@ -1,6 +1,7 @@
 import { errorResult, strictOperationResultSchema } from '../../core/operation-result.js';
 import { ReferenceToolService } from '../../reference/operations.js';
 import { referenceContextRequestSchema, referenceReadRequestSchema, referenceSearchRequestSchema, sourceLookupRequestSchema, referenceContextDataSchema, referenceReadDataSchema, referenceSearchDataSchema, sourceLookupDataSchema, } from '../../schemas/reference.js';
+import { errorLogDataSchema, errorLogRequestSchema, modIndexDataSchema, modIndexRequestSchema, } from '../../schemas/mod-tools.js';
 import { scriptValidateDataSchema, scriptValidateRequestSchema, } from '../../schemas/script-validation.js';
 const readOnly = {
     readOnlyHint: true,
@@ -12,7 +13,7 @@ export const referenceTools = [
     {
         name: 'hoi4.reference_search',
         title: 'Search local HOI4 references',
-        description: 'Search bounded, cited sections of the configured offline wiki and installed game documentation.',
+        description: 'Search the offline wiki and installed game documentation by words or script names; each hit gives its file, lines, revision and answering line. Example: {"query":"add_timed_idea"}. Returns 6 hits by default (up to 12); read one with hoi4.reference_read using its id and revision.',
         inputSchema: referenceSearchRequestSchema,
         outputSchema: strictOperationResultSchema(referenceSearchDataSchema),
         annotations: readOnly,
@@ -20,7 +21,7 @@ export const referenceTools = [
     {
         name: 'hoi4.reference_read',
         title: 'Read cited HOI4 reference section',
-        description: 'Read at most 80 lines from one revision-bound local documentation section.',
+        description: 'Read one cited documentation section: pass the id and revision of a reference_search or reference_context hit. Example: {"id":"<hit id>","revision":"<hit revision>"}. Returns at most 80 lines (40 by default) and 8,000 bytes, with a line to continue from.',
         inputSchema: referenceReadRequestSchema,
         outputSchema: strictOperationResultSchema(referenceReadDataSchema),
         annotations: readOnly,
@@ -28,7 +29,7 @@ export const referenceTools = [
     {
         name: 'hoi4.reference_context',
         title: 'Get HOI4 task references',
-        description: 'Return a compact bundle of offline wiki and installed game documentation citations for a modding surface.',
+        description: 'Cited wiki and installed-documentation sections for one modding surface (event, decision, idea, focus, technology, gui, map, localisation, ai, general). Example: {"surface":"event","question":"fire an event after a delay"}. Returns up to 16 short sections; read more with hoi4.reference_read.',
         inputSchema: referenceContextRequestSchema,
         outputSchema: strictOperationResultSchema(referenceContextDataSchema),
         annotations: readOnly,
@@ -36,7 +37,7 @@ export const referenceTools = [
     {
         name: 'hoi4.source_lookup',
         title: 'Look up HOI4 source symbol',
-        description: 'Find exact Clausewitz definitions and usages; navigate nested keyPath blocks or list bounded child structure with view=structure. Or pass path and line to get the definitions and keyPath containing that line.',
+        description: 'Find where a script symbol is defined across game, DLC and mod, and where it is used; or pass path and line for the definition containing that line. Example: {"symbol":"my_scripted_effect"}. Returns up to 3 definitions with source text and 10 usages; keyPath and view=structure navigate nested blocks.',
         inputSchema: sourceLookupRequestSchema,
         outputSchema: strictOperationResultSchema(sourceLookupDataSchema),
         annotations: readOnly,
@@ -44,11 +45,27 @@ export const referenceTools = [
     {
         name: 'hoi4.script_validate',
         title: 'Check HOI4 script commands and scopes',
-        description: 'Check an effect or trigger snippet (source, kind, scope) or a whole mod file (path) for syntax, native command kinds and scopes against cited installed documentation. Unknown helpers and native argument blocks remain explicit.',
+        description: 'Check an effect or trigger snippet, or a whole mod file, against the installed documentation: syntax, command kinds and scopes. Unknown helpers and native argument blocks stay marked unresolved, never valid. Example: {"source":"add_political_power = 10","kind":"effect","scope":"country"} or {"path":"events/a.txt"}. Returns up to 12 findings.',
         inputSchema: scriptValidateRequestSchema,
         outputSchema: strictOperationResultSchema(scriptValidateDataSchema),
         annotations: readOnly,
     },
+    {
+        name: 'hoi4.error_log',
+        title: 'Read the game error log',
+        description: 'Group the game\'s logs/error.log from its last launch by category, with each entry\'s source file, line, layer and whether that file changed since; mod entries first. Example: {"scope":"mod","category":"effect"}. Returns at most 20 entries (limit 50) with fix hints and which entries are new since the previous launch.',
+        inputSchema: errorLogRequestSchema,
+        outputSchema: strictOperationResultSchema(errorLogDataSchema),
+        annotations: readOnly,
+    },
+    {
+        name: 'hoi4.mod_index',
+        title: 'Index mod definitions and free IDs',
+        description: 'overview: the mod descriptor, definition counts by kind, folders and event namespace ranges. next_id: the next free numbered ID for an event namespace or prefix across every layer. Example: {"mode":"next_id","kind":"event","namespace":"my_mod"}. Returns a compact summary; the first call indexes the mod, which takes seconds on a large one.',
+        inputSchema: modIndexRequestSchema,
+        outputSchema: strictOperationResultSchema(modIndexDataSchema),
+        annotations: readOnly,
+    },
 ];
 export function registerReferenceTools(server, engine, context) {
     const service = new ReferenceToolService(engine);

package/dist/hoi4_agent_tools/mcp/tools/technology.js

@@ -1,7 +1,7 @@
 import { registerLegacyTaskTools } from '../server/legacy-task-tools.js';
 import { z } from 'zod/v4';
 import { helperExpansionRequestSchema, helperExpansionSummarySchema, } from '../../schemas/helper-expansion.js';
-import { technologyAnalysisModeSchema, technologyCompareRequestSchema, technologyGraphReferenceSchema, technologyImpactSchema, technologyInspectRequestSchema, technologyProposedSourceSchema, technologyRenderRequestSchema, technologyRenderViewSchema, validateTechnologyCompareRequest, validateTechnologyInspectRequest, } from '../../schemas/technology.js';
+import { technologyAnalysisModeSchema, technologyGraphReferenceSchema, technologyImpactSchema, technologyInspectRequestSchema, technologyProposedSourceSchema, technologyRenderRequestSchema, validateTechnologyRenderRequest, technologyRenderViewSchema, validateTechnologyInspectToolRequest, } from '../../schemas/technology.js';
 import { compactValidatedInputSchema } from '../server/context-schemas.js';
 import { nonNegativeIntegerSchema, sha256Schema } from '../server/output-schemas.js';
 import { strictOperationResultSchema } from '../server/result.js';
@@ -10,23 +10,20 @@ const inspectInputSchema = z
     ...technologyInspectRequestSchema.shape,
     helperExpansion: compactValidatedInputSchema(helperExpansionRequestSchema, 'Bounded helper paths; opaque continuationUri resumes the same source and roots. See docs/technology.md.').optional(),
     impact: compactValidatedInputSchema(technologyImpactSchema, 'Rename or removal subject.').optional(),
-})
-    .strict()
-    .superRefine(validateTechnologyInspectRequest);
-const renderInputSchema = z.object({ ...technologyRenderRequestSchema.shape }).strict();
-const compareInputSchema = z
-    .object({
-    ...technologyCompareRequestSchema.shape,
-    before: compactValidatedInputSchema(technologyGraphReferenceSchema, 'Revision or graph resource.').optional(),
-    after: compactValidatedInputSchema(technologyGraphReferenceSchema, 'Revision or graph resource.').optional(),
+    before: compactValidatedInputSchema(technologyGraphReferenceSchema, 'Mode compare: revision or graph resource.').optional(),
+    after: compactValidatedInputSchema(technologyGraphReferenceSchema, 'Mode compare: revision or graph resource.').optional(),
     proposedSources: z
-        .array(compactValidatedInputSchema(technologyProposedSourceSchema, 'In-memory source overlay.'))
+        .array(compactValidatedInputSchema(technologyProposedSourceSchema, 'Mode compare: in-memory source overlay.'))
         .min(1)
         .max(128)
         .optional(),
 })
     .strict()
-    .superRefine(validateTechnologyCompareRequest);
+    .superRefine(validateTechnologyInspectToolRequest);
+const renderInputSchema = z
+    .object({ ...technologyRenderRequestSchema.shape })
+    .strict()
+    .superRefine(validateTechnologyRenderRequest);
 const countsSchema = z
     .object({
     technologies: nonNegativeIntegerSchema,
@@ -41,7 +38,7 @@ const countsSchema = z
     artifacts: nonNegativeIntegerSchema,
 })
     .strict();
-const analysisOutputSchema = strictOperationResultSchema(z
+const analysisDataSchema = z
     .object({
     mode: technologyAnalysisModeSchema,
     revision: sha256Schema,
@@ -49,7 +46,7 @@ const analysisOutputSchema = strictOperationResultSchema(z
     counts: countsSchema,
     helperExpansion: helperExpansionSummarySchema.optional(),
 })
-    .strict());
+    .strict();
 const renderOutputSchema = strictOperationResultSchema(z
     .object({
     view: technologyRenderViewSchema,
@@ -69,7 +66,7 @@ const renderOutputSchema = strictOperationResultSchema(z
     sourceAccurate: z.boolean(),
 })
     .strict());
-const compareOutputSchema = strictOperationResultSchema(z
+const compareDataSchema = z
     .object({
     beforeRevision: sha256Schema,
     afterRevision: sha256Schema,
@@ -84,7 +81,8 @@ const compareOutputSchema = strictOperationResultSchema(z
         .strict()
         .optional(),
 })
-    .strict());
+    .strict();
+const analysisOutputSchema = strictOperationResultSchema(z.union([analysisDataSchema, compareDataSchema]));
 const readOnlyTechnologyTool = {
     readOnlyHint: true,
     destructiveHint: false,
@@ -95,7 +93,7 @@ export const technologyTaskTools = [
     {
         name: 'hoi4.tech_inspect',
         title: 'Inspect technology trees',
-        description: 'Scan, discover folders, trace, explain, inspect unlocks or bonuses, lint, and assess impact.',
+        description: 'Scan, trace, explain, list unlocks and bonus coverage, lint, assess impact or compare (mode compare) technology and doctrine graphs. Example: {"mode":"explain","technologyId":"my_tech"}. Returns counts and the main findings inline; the full report is a linked resource.',
         inputSchema: inspectInputSchema,
         outputSchema: analysisOutputSchema,
         annotations: readOnlyTechnologyTool,
@@ -103,19 +101,11 @@ export const technologyTaskTools = [
     {
         name: 'hoi4.tech_render',
         title: 'Render technology trees',
-        description: 'Render source-linked JSON, SVG, PNG, and optional HTML technology views.',
+        description: 'Render a technology folder, dependencies, doctrine, bonuses, grants, unlocks or unresolved view as JSON, SVG and PNG with real item sizes and year guides. Example: {"view":"folder","folderId":"my_folder"}. Images are linked artifacts.',
         inputSchema: renderInputSchema,
         outputSchema: renderOutputSchema,
         annotations: readOnlyTechnologyTool,
     },
-    {
-        name: 'hoi4.tech_compare',
-        title: 'Compare technology trees',
-        description: 'Compare cached, resource-backed, current, or proposed source graphs without writes.',
-        inputSchema: compareInputSchema,
-        outputSchema: compareOutputSchema,
-        annotations: readOnlyTechnologyTool,
-    },
 ];
 export function registerTechnologyTools(server) {
     registerLegacyTaskTools(server, technologyTaskTools);

package/dist/hoi4_agent_tools/mcp/transports/http.js

@@ -54,10 +54,18 @@ export function rateLimitClientAddress(request, configuration) {
     const forwarded = request.headers['x-forwarded-for'];
     if (typeof forwarded !== 'string')
         return undefined;
-    const client = forwarded.split(',')[0]?.trim();
-    if (client === undefined || isIP(client) === 0)
-        return undefined;
-    return normalizeIpAddress(client);
+    // Proxies append to the right, so only the entries after the last untrusted hop are
+    // trustworthy; the leftmost entry is whatever the client sent.
+    const hops = forwarded.split(',').map((hop) => hop.trim());
+    for (let index = hops.length - 1; index >= 0; index -= 1) {
+        const hop = hops[index];
+        if (isIP(hop) === 0)
+            return undefined;
+        const normalized = normalizeIpAddress(hop);
+        if (!trusted.has(normalized))
+            return normalized;
+    }
+    return undefined;
 }
 export function requiredScopesForMcpRequest(configuration, body) {
     const scopes = [...(configuration.http.oauth?.requiredScopes ?? ['hoi4:read'])];
@@ -502,6 +510,22 @@ export async function startHttpServer(engine, configuration, serverFactory) {
     // Supplying a defined parsed body to handleRequest prevents the SDK from falling back to
     // an unbounded Request.json() parse for alternate media types or empty established-session
     // requests. GET and DELETE deliberately remain bodyless.
+    // Authenticate before reading the body, so an unauthenticated caller cannot hold a request
+    // slot and body budget while it sends one slowly. Scopes that depend on the parsed body are
+    // checked again afterwards.
+    app.post('/mcp', async (request, response, next) => {
+        const baseScopes = requiredScopesForMcpRequest(configuration, undefined);
+        try {
+            const authorization = request.headers.authorization;
+            await authenticate(Array.isArray(authorization) ? undefined : authorization, configuration, baseScopes);
+            next();
+        }
+        catch (error) {
+            sendAuthError(response, configuration, error instanceof HttpAuthError
+                ? error
+                : new HttpAuthError(401, 'AUTH_INVALID', 'Authentication failed', 'invalid_token', baseScopes));
+        }
+    });
     app.post('/mcp', express.json({
         limit: http.maxBodyBytes,
         strict: true,

package/dist/hoi4_agent_tools/mcp/transports/stdio-lifetime.js

@@ -5,20 +5,14 @@
  * pipe, and a client keeps an idle connection it will never use again. The first is detected
  * by polling the parent process; the second by an optional idle limit.
  */
+import { processAlive } from '../../core/server-registry.js';
 const PARENT_POLL_MS = 5_000;
-/** Whether a process exists; a permission refusal still proves it exists. */
-export function processAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return error.code === 'EPERM';
-    }
-}
+export { processAlive };
 export class StdioLifetime {
     #options;
-    #open = new Set();
+    /** Open client requests and when each arrived. */
+    #open = new Map();
+    #parentGone = false;
     #lastActivity;
     #timer;
     #stopped = false;
@@ -48,7 +42,11 @@ export class StdioLifetime {
         this.#lastActivity = this.#options.now();
         const id = requestId(message, 'method');
         if (id !== undefined)
-            this.#open.add(id);
+            this.#open.set(id, this.#lastActivity);
+        // A cancelled request gets no response, so the cancellation closes it.
+        const cancelled = cancelledRequestId(message);
+        if (cancelled !== undefined)
+            this.#open.delete(cancelled);
     }
     /** A server message: a response closes its request. */
     sent(message) {
@@ -57,24 +55,45 @@ export class StdioLifetime {
         if (id !== undefined)
             this.#open.delete(id);
     }
+    /** When the client last sent or received a message, in epoch milliseconds. */
+    lastActivity() {
+        return this.#lastActivity;
+    }
     check() {
         if (this.#stopped)
             return;
-        const { parentPid, isAlive, idleExitMinutes, now, onExit } = this.#options;
-        // A parent pid of 0 or 1 means the server was already reparented at start.
-        if (parentPid > 1 && !isAlive(parentPid)) {
+        const { parentPid, isAlive, idleExitMinutes, now, onExit, pollMs } = this.#options;
+        const idleMs = idleExitMinutes * 60_000;
+        // A request open for twice the idle limit was abandoned by its client.
+        if (idleMs > 0)
+            for (const [id, openedAt] of this.#open)
+                if (now() - openedAt > 2 * idleMs)
+                    this.#open.delete(id);
+        // A parent pid of 0 or 1 means the server was already reparented at start. Once the
+        // parent is gone, the server finishes open requests and waits for a quiet poll first,
+        // since some launchers exit while the client keeps using the pipes.
+        if (parentPid > 1 && !this.#parentGone && !isAlive(parentPid))
+            this.#parentGone = true;
+        if (this.#parentGone && this.#open.size === 0 && now() - this.#lastActivity >= pollMs) {
             this.stop();
             onExit('parent_exited');
             return;
         }
-        if (idleExitMinutes > 0 &&
-            this.#open.size === 0 &&
-            now() - this.#lastActivity > idleExitMinutes * 60_000) {
+        if (idleMs > 0 && this.#open.size === 0 && now() - this.#lastActivity > idleMs) {
             this.stop();
             onExit('idle');
         }
     }
 }
+function cancelledRequestId(message) {
+    if (typeof message !== 'object' || message === null)
+        return undefined;
+    const { method, params } = message;
+    if (method !== 'notifications/cancelled')
+        return undefined;
+    const id = params?.requestId;
+    return typeof id === 'string' || typeof id === 'number' ? id : undefined;
+}
 function requestId(message, field) {
     if (typeof message !== 'object' || message === null || !(field in message))
         return undefined;

package/dist/hoi4_agent_tools/probability/job-operations.js

@@ -2,8 +2,8 @@ import { z } from 'zod/v4';
 import { IdleCacheLifetime } from '../core/idle-cache-lifetime.js';
 import { errorResult, toolResult } from '../core/operation-result.js';
 import { ServiceError } from '../core/result.js';
-import { probabilityCompareRequestSchema, probabilityEvaluateRequestSchema, probabilityInspectRequestSchema, probabilityRenderRequestSchema, probabilitySequenceRequestSchema, probabilitySimulateRequestSchema, probabilitySweepRequestSchema, } from '../schemas/probability-requests.js';
-import { compareProbabilities, evaluateProbabilities, inspectProbabilities, normalizeProbabilityCompareRequest, normalizeProbabilityEvaluateRequest, normalizeProbabilityInspectRequest, normalizeProbabilityRenderRequest, normalizeProbabilitySequenceRequest, normalizeProbabilitySimulateRequest, normalizeProbabilitySweepRequest, renderProbabilities, sequenceProbabilities, simulateProbabilities, sweepProbabilities, } from './operations.js';
+import { probabilityAnalyzeRequestSchema, probabilityInspectRequestSchema, } from '../schemas/probability-requests.js';
+import { analyzeProbabilities, inspectProbabilities, normalizeProbabilityAnalyzeRequest, normalizeProbabilityInspectRequest, } from './operations.js';
 import { ProbabilityAnalyzer } from './service.js';
 const wireResult = z.record(z.string(), z.json());
 /** Registers probability operations without invoking transport handlers. */
@@ -48,11 +48,6 @@ export function registerProbabilityJobs(operations, engine) {
             }
         });
     }
-    register('hoi4.probability_inspect', probabilityInspectRequestSchema, normalizeProbabilityInspectRequest, inspectProbabilities, 'Inspecting weighted source');
-    register('hoi4.probability_evaluate', probabilityEvaluateRequestSchema, normalizeProbabilityEvaluateRequest, evaluateProbabilities, 'Evaluating weighted scenarios');
-    register('hoi4.probability_sweep', probabilitySweepRequestSchema, normalizeProbabilitySweepRequest, sweepProbabilities, 'Evaluating parameter sweep');
-    register('hoi4.probability_simulate', probabilitySimulateRequestSchema, normalizeProbabilitySimulateRequest, simulateProbabilities, 'Sampling uncertain scenarios');
-    register('hoi4.probability_sequence', probabilitySequenceRequestSchema, normalizeProbabilitySequenceRequest, sequenceProbabilities, 'Analyzing declared sequence');
-    register('hoi4.probability_compare', probabilityCompareRequestSchema, normalizeProbabilityCompareRequest, compareProbabilities, 'Comparing weighted source');
-    register('hoi4.probability_render', probabilityRenderRequestSchema, normalizeProbabilityRenderRequest, renderProbabilities, 'Rendering analysis resources');
+    register('hoi4.probability_inspect', probabilityInspectRequestSchema, normalizeProbabilityInspectRequest, inspectProbabilities, 'Inspecting and evaluating weighted source');
+    register('hoi4.probability_analyze', probabilityAnalyzeRequestSchema, normalizeProbabilityAnalyzeRequest, analyzeProbabilities, 'Analyzing weighted source');
 }