hoi4-agent-tools 2.4.0 → 2.5.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 2.5.1 - 2026-08-13
+
+- Published artifact contents and provenance manifests atomically across independent MCP processes, preventing event, probability, GUI, and other concurrent inspections from observing partially written manifests.
+- Recovered clearly interrupted zero-filled or truncated provenance manifests during matching writes and storage pruning while continuing to reject arbitrary malformed or tampered manifests.
+- Tolerated temporary-file disappearance during concurrent storage scans without weakening artifact integrity validation.
+- Added cross-process publication, interrupted-write recovery, and fail-closed integrity regressions, then verified event inspection, probability inspection, and artifact-resource workflows against the repaired store.
+
+## 2.5.0 - 2026-08-09
+
+- Added exact continuous-focus coordinates and linked palette IDs to compact national focus inspection results.
+- Added source-first probability inspection that discovers compatible adapters, candidate counts, and selector examples without requiring the caller to guess a surface type.
+- Changed empty or mismatched probability inspection into an actionable discovery result with a reason and suggested adapter while keeping evaluation, sweeps, and simulation strict.
+- Prevented focus-tree blocks from being misclassified as decision or mission weighted surfaces.
+
 ## 2.4.0 - 2026-08-09
 
 - Added named value-driven scripted-GUI scenario matrices with deterministic SVG, PNG, JSON, and per-element visibility, movement, size, text, and frame-change evidence.

package/README.md

@@ -31,31 +31,31 @@ Paste the printed Codex or generic global-install entry into your MCP client, th
 
 ## Tools
 
-| Tool                        | Purpose                                                                                 |
-| --------------------------- | --------------------------------------------------------------------------------------- |
-| `hoi4.focus_inspect`        | Read focus trees and report structural or reference problems.                           |
-| `hoi4.focus_render`         | Produce fast HTML, SVG, JSON, and source-linked layout artifacts.                       |
-| `hoi4.focus_raster`         | Produce a high-fidelity PNG review with decoded source icons.                           |
-| `hoi4.focus_rewrite`        | Create or update a focus tree.                                                          |
-| `hoi4.gui_inspect`          | Read a scripted GUI and its linked assets and logic.                                    |
-| `hoi4.gui_render`           | Render GUI scenario variants, states, resolutions, hierarchy, and layout diagnostics.   |
-| `hoi4.gui_rewrite`          | Create or update a GUI source package.                                                  |
-| `hoi4.map_inspect`          | Read map, state, province, region, supply, and railway data.                            |
-| `hoi4.map_render`           | Render map layers and overlays.                                                         |
-| `hoi4.map_rewrite`          | Create or update map data from an ordered list of exact changes.                        |
-| `hoi4.event_inspect`        | Scan, trace, explain, lint, or assess event chains and their state flow.                |
-| `hoi4.event_render`         | Render source-linked event routes, options, timing, state, scope, and unresolved edges. |
-| `hoi4.event_compare`        | Compare event-chain topology and diagnostics between revisions.                         |
-| `hoi4.tech_inspect`         | Scan, trace, explain, lint, and assess technology and doctrine systems.                 |
-| `hoi4.tech_render`          | Render source layouts, dependency paths, unlocks, grants, metadata, and asset coverage. |
-| `hoi4.tech_compare`         | Compare technology graphs, placements, references, diagnostics, and source overlays.    |
-| `hoi4.probability_inspect`  | Locate weighted logic, candidates, required inputs, and supported analysis.             |
-| `hoi4.probability_evaluate` | Evaluate exact values, probabilities, timing, bounds, and unresolved inputs.            |
-| `hoi4.probability_sweep`    | Find sensitivity, breakpoints, cliffs, and rank reversals across declared ranges.       |
-| `hoi4.probability_simulate` | Run deterministic sampled analysis with confidence and convergence data.                |
-| `hoi4.probability_sequence` | Analyze declared recovery, caps, cooldowns, resets, timers, and terminal states.        |
-| `hoi4.probability_compare`  | Attribute AI-weight and MTTH changes between real or proposed source.                   |
-| `hoi4.probability_render`   | Render cached rankings, matrices, timing, sensitivity, sequence, and comparisons.       |
+| Tool                        | Purpose                                                                                  |
+| --------------------------- | ---------------------------------------------------------------------------------------- |
+| `hoi4.focus_inspect`        | Read focus trees, continuous-focus placement, and structural or reference problems.      |
+| `hoi4.focus_render`         | Produce fast HTML, SVG, JSON, and source-linked layout artifacts.                        |
+| `hoi4.focus_raster`         | Produce a high-fidelity PNG review with decoded source icons.                            |
+| `hoi4.focus_rewrite`        | Create or update a focus tree.                                                           |
+| `hoi4.gui_inspect`          | Read a scripted GUI and its linked assets and logic.                                     |
+| `hoi4.gui_render`           | Render GUI scenario variants, states, resolutions, hierarchy, and layout diagnostics.    |
+| `hoi4.gui_rewrite`          | Create or update a GUI source package.                                                   |
+| `hoi4.map_inspect`          | Read map, state, province, region, supply, and railway data.                             |
+| `hoi4.map_render`           | Render map layers and overlays.                                                          |
+| `hoi4.map_rewrite`          | Create or update map data from an ordered list of exact changes.                         |
+| `hoi4.event_inspect`        | Scan, trace, explain, lint, or assess event chains and their state flow.                 |
+| `hoi4.event_render`         | Render source-linked event routes, options, timing, state, scope, and unresolved edges.  |
+| `hoi4.event_compare`        | Compare event-chain topology and diagnostics between revisions.                          |
+| `hoi4.tech_inspect`         | Scan, trace, explain, lint, and assess technology and doctrine systems.                  |
+| `hoi4.tech_render`          | Render source layouts, dependency paths, unlocks, grants, metadata, and asset coverage.  |
+| `hoi4.tech_compare`         | Compare technology graphs, placements, references, diagnostics, and source overlays.     |
+| `hoi4.probability_inspect`  | Locate weighted logic and discover compatible adapters, candidates, and required inputs. |
+| `hoi4.probability_evaluate` | Evaluate exact values, probabilities, timing, bounds, and unresolved inputs.             |
+| `hoi4.probability_sweep`    | Find sensitivity, breakpoints, cliffs, and rank reversals across declared ranges.        |
+| `hoi4.probability_simulate` | Run deterministic sampled analysis with confidence and convergence data.                 |
+| `hoi4.probability_sequence` | Analyze declared recovery, caps, cooldowns, resets, timers, and terminal states.         |
+| `hoi4.probability_compare`  | Attribute AI-weight and MTTH changes between real or proposed source.                    |
+| `hoi4.probability_render`   | Render cached rankings, matrices, timing, sensitivity, sequence, and comparisons.        |
 
 Large outputs are linked `hoi4-agent://` resources. For resources over 1 MiB, follow the `continuationUri` returned in `_meta` until it is `null`; clients may also request byte ranges with `?offset=<bytes>&length=<bytes>`.
 

package/dist/hoi4_agent_tools/core/artifacts.js

@@ -1,5 +1,5 @@
-import { createHash } from 'node:crypto';
-import { lstat, mkdir, open, readFile, readdir, stat, unlink, writeFile } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import { link, lstat, mkdir, open, readFile, readdir, stat, unlink } from 'node:fs/promises';
 import path from 'node:path';
 import { z } from 'zod/v4';
 import { canonicalJson, compareCodeUnits, sha256Bytes } from './canonical.js';
@@ -159,6 +159,8 @@ const artifactManifestMaxBytes = 1_048_576;
 const artifactLogicalBatchMaxBytes = 536_870_912;
 const artifactHashYieldBytes = 16_777_216;
 const artifactPreflightYieldEntries = 256;
+const interruptedManifestMinimumAgeMs = 1_000;
+const artifactTemporaryPrefix = '.artifact-tmp-';
 const ownedArtifactContent = Symbol('ownedArtifactContent');
 const precomputedArtifactSha256 = Symbol('precomputedArtifactSha256');
 export const chunkedArtifactIndexMimeType = 'application/json';
@@ -320,11 +322,22 @@ async function artifactUsage(root, signal) {
             if (child.isSymbolicLink()) {
                 throw new ServiceError('ARTIFACT_STORAGE_UNSAFE', 'Artifact storage contains a symbolic link or junction');
             }
+            if (child.isFile() && child.name.startsWith(artifactTemporaryPrefix))
+                continue;
             const candidate = await containedGeneratedPath(root, path.relative(root, path.join(directory, child.name)));
             if (child.isDirectory())
                 await walk(candidate);
             else if (child.isFile()) {
-                bytes += (await stat(candidate)).size;
+                let size;
+                try {
+                    size = (await stat(candidate)).size;
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        continue;
+                    throw error;
+                }
+                bytes += size;
                 if (child.name.endsWith('.manifest.json'))
                     entries += 1;
                 if (!Number.isSafeInteger(bytes)) {
@@ -375,6 +388,101 @@ async function readArtifactManifest(filePath, signal) {
         throw new ServiceError('ARTIFACT_MANIFEST_INVALID', 'Artifact provenance manifest is invalid');
     }
 }
+async function readBoundedManifestBytes(filePath, signal) {
+    signal?.throwIfAborted();
+    let metadata;
+    try {
+        metadata = await lstat(filePath);
+    }
+    catch {
+        throw new ServiceError('ARTIFACT_NOT_FOUND', 'Artifact provenance manifest is unavailable');
+    }
+    if (metadata.isSymbolicLink() || !metadata.isFile()) {
+        throw new ServiceError('ARTIFACT_MANIFEST_INVALID', 'Artifact provenance manifest is invalid');
+    }
+    if (metadata.size > artifactManifestMaxBytes) {
+        throw new ServiceError('ARTIFACT_MANIFEST_LIMIT', 'Artifact provenance manifest exceeds its fixed byte limit');
+    }
+    try {
+        const bytes = signal === undefined ? await readFile(filePath) : await readFile(filePath, { signal });
+        return { bytes, metadata };
+    }
+    catch (error) {
+        if (error.name === 'AbortError')
+            throw error;
+        throw new ServiceError('ARTIFACT_NOT_FOUND', 'Artifact provenance manifest is unavailable');
+    }
+}
+function zeroFilled(bytes) {
+    return bytes.length === 0 || bytes.every((value) => value === 0);
+}
+async function interruptedManifestState(filePath, expectedBytes, signal) {
+    const { bytes, metadata } = await readBoundedManifestBytes(filePath, signal);
+    const expected = expectedBytes === undefined ? undefined : Buffer.from(expectedBytes, 'utf8');
+    const expectedPrefix = expected !== undefined &&
+        bytes.length < expected.length &&
+        expected.subarray(0, bytes.length).equals(bytes);
+    const staleZeroFill = zeroFilled(bytes) && Date.now() - Number(metadata.mtimeMs) >= interruptedManifestMinimumAgeMs;
+    return { interrupted: expectedPrefix || staleZeroFill, size: Number(metadata.size) };
+}
+async function existingManifestMatches(filePath, expectedBytes, signal) {
+    if (!(await fileExists(filePath)))
+        return false;
+    try {
+        const manifest = await readArtifactManifest(filePath, signal);
+        if (`${canonicalJson(manifest)}\n` !== expectedBytes) {
+            throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Immutable artifact provenance manifest contains different bytes');
+        }
+        return true;
+    }
+    catch (error) {
+        if (error instanceof ServiceError && error.code === 'ARTIFACT_NOT_FOUND')
+            return false;
+        if (!(error instanceof ServiceError) || error.code !== 'ARTIFACT_MANIFEST_INVALID')
+            throw error;
+        const state = await interruptedManifestState(filePath, expectedBytes, signal);
+        if (!state.interrupted)
+            throw error;
+        try {
+            await unlink(filePath);
+        }
+        catch (unlinkError) {
+            if (unlinkError.code !== 'ENOENT')
+                throw unlinkError;
+        }
+        return false;
+    }
+}
+async function publishExclusiveFile(target, bytes, signal) {
+    signal?.throwIfAborted();
+    const temporary = path.join(path.dirname(target), `${artifactTemporaryPrefix}${process.pid}-${randomUUID().replaceAll('-', '')}`);
+    let handle;
+    try {
+        handle = await open(temporary, 'wx');
+        await handle.writeFile(bytes, signal === undefined ? undefined : { signal });
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
+        signal?.throwIfAborted();
+        try {
+            await link(temporary, target);
+            return true;
+        }
+        catch (error) {
+            if (error.code === 'EEXIST')
+                return false;
+            throw error;
+        }
+    }
+    finally {
+        if (handle !== undefined)
+            await handle.close().catch(() => undefined);
+        await unlink(temporary).catch((error) => {
+            if (error.code !== 'ENOENT')
+                throw error;
+        });
+    }
+}
 async function readVerifiedArtifactRange(filePath, expectedSha256, range, verifiedIdentity, signal) {
     signal?.throwIfAborted();
     if (range !== undefined &&
@@ -495,8 +603,47 @@ export class ArtifactStore {
                 }
                 if (!child.isFile() || !child.name.endsWith('.manifest.json'))
                     continue;
-                const metadata = await lstat(candidate);
-                const manifest = await readArtifactManifest(candidate, signal);
+                let metadata;
+                try {
+                    metadata = await lstat(candidate);
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        continue;
+                    throw error;
+                }
+                let manifest;
+                try {
+                    manifest = await readArtifactManifest(candidate, signal);
+                }
+                catch (error) {
+                    if (error instanceof ServiceError && error.code === 'ARTIFACT_NOT_FOUND')
+                        continue;
+                    if (!(error instanceof ServiceError) || error.code !== 'ARTIFACT_MANIFEST_INVALID')
+                        throw error;
+                    let interrupted;
+                    try {
+                        interrupted = await interruptedManifestState(candidate, undefined, signal);
+                    }
+                    catch (interruptedError) {
+                        if (interruptedError instanceof ServiceError &&
+                            interruptedError.code === 'ARTIFACT_NOT_FOUND')
+                            continue;
+                        throw interruptedError;
+                    }
+                    if (!interrupted.interrupted)
+                        throw error;
+                    try {
+                        await unlink(candidate);
+                    }
+                    catch (unlinkError) {
+                        if (unlinkError.code !== 'ENOENT')
+                            throw unlinkError;
+                    }
+                    usage.entries = Math.max(0, usage.entries - 1);
+                    usage.bytes = Math.max(0, usage.bytes - interrupted.size);
+                    continue;
+                }
                 if (child.name !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`) {
                     throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest filename does not match its contents');
                 }
@@ -993,13 +1140,8 @@ export class ArtifactStore {
                     throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact batch maps different provenance to the same immutable manifest');
                 }
                 if (duplicateManifest === undefined) {
-                    const exists = await fileExists(artifact.manifestPath);
+                    const exists = await existingManifestMatches(artifact.manifestPath, artifact.manifestBytes, signal);
                     signal?.throwIfAborted();
-                    if (exists &&
-                        `${canonicalJson(await readArtifactManifest(artifact.manifestPath, signal))}\n` !==
-                            artifact.manifestBytes) {
-                        throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Immutable artifact provenance manifest contains different bytes');
-                    }
                     uniqueManifests.set(artifact.manifestPath, { ...artifact, exists });
                 }
             }
@@ -1020,18 +1162,19 @@ export class ArtifactStore {
                         continue;
                     await mkdir(artifact.directory, { recursive: true });
                     signal?.throwIfAborted();
-                    try {
-                        await writeFile(artifact.target, artifact.bytes, {
-                            flag: 'wx',
-                            ...(signal === undefined ? {} : { signal }),
-                        });
+                    const created = await publishExclusiveFile(artifact.target, artifact.bytes, signal);
+                    if (created) {
                         createdTargets.push(artifact.target);
                     }
-                    catch (error) {
-                        if (error.code !== 'EEXIST') {
-                            createdTargets.push(artifact.target);
+                    else {
+                        try {
+                            await readVerifiedArtifactRange(artifact.target, artifact.artifact.sha256, { offset: 0, length: 1 }, undefined, signal);
+                        }
+                        catch (error) {
+                            if (error.name === 'AbortError')
+                                throw error;
+                            throw new ServiceError('ARTIFACT_HASH_COLLISION', 'Artifact path contains different bytes');
                         }
-                        throw error;
                     }
                 }
                 for (const artifact of uniqueManifests.values()) {
@@ -1040,18 +1183,12 @@ export class ArtifactStore {
                         continue;
                     await mkdir(artifact.directory, { recursive: true });
                     signal?.throwIfAborted();
-                    try {
-                        await writeFile(artifact.manifestPath, artifact.manifestBytes, {
-                            flag: 'wx',
-                            ...(signal === undefined ? {} : { signal }),
-                        });
+                    const created = await publishExclusiveFile(artifact.manifestPath, artifact.manifestBytes, signal);
+                    if (created) {
                         createdManifests.push(artifact.manifestPath);
                     }
-                    catch (error) {
-                        if (error.code !== 'EEXIST') {
-                            createdManifests.push(artifact.manifestPath);
-                        }
-                        throw error;
+                    else if (!(await existingManifestMatches(artifact.manifestPath, artifact.manifestBytes, signal))) {
+                        throw new ServiceError('ARTIFACT_MANIFEST_INVALID', 'Concurrent artifact provenance manifest publication did not complete');
                     }
                 }
                 signal?.throwIfAborted();

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

@@ -31,6 +31,11 @@ const focusInspectOutputSchema = strictOperationResultSchema(z
         branchCount: nonNegativeIntegerSchema,
         continuousPaletteCount: nonNegativeIntegerSchema,
         continuousFocusCount: nonNegativeIntegerSchema,
+        continuousFocusPosition: z
+            .object({ x: z.number().int(), y: z.number().int() })
+            .strict()
+            .nullable(),
+        continuousFocusPaletteIds: z.array(z.string().max(256)).max(100),
         resolvedTitleCount: nonNegativeIntegerSchema,
         layoutHash: sha256Schema,
         layoutDecisionCount: nonNegativeIntegerSchema,
@@ -601,7 +606,7 @@ export function registerFocusTools(server, engine, context) {
     const workbench = new FocusWorkbench(engine.resolver, engine.transactions, engine.artifacts);
     server.registerTool('hoi4.focus_inspect', {
         title: 'Inspect focus trees',
-        description: 'Inspect national trees or continuous palettes for creation and cleanup, including complete plans, references, diagnostics, and stable layout decisions.',
+        description: 'Inspect national trees or continuous palettes for creation and cleanup, including continuous-focus placement, complete plans, references, diagnostics, and stable layout decisions.',
         inputSchema: focusInspectInput,
         outputSchema: focusInspectOutputSchema,
         annotations: artifactProducing,
@@ -791,6 +796,8 @@ export function registerFocusTools(server, engine, context) {
                     branchCount: plan.branchGroups.length,
                     continuousPaletteCount: plan.continuousFocusPaletteIds.length,
                     continuousFocusCount: plan.continuousFocusIds.length,
+                    continuousFocusPosition: plan.continuousFocusPosition ?? null,
+                    continuousFocusPaletteIds: plan.continuousFocusPaletteIds.slice(0, 100),
                     resolvedTitleCount: plan.focuses.filter(({ id }) => presentation.entries[id]?.titleSourceLocation !== undefined).length,
                     layoutHash: layout.layoutHash,
                     layoutDecisionCount: layout.decisions.length,

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

@@ -39,10 +39,10 @@ const inspectInput = z
 })
     .strict()
     .superRefine((value, context) => {
-    if ((value.adapter === undefined) !== (value.source === undefined))
+    if (value.adapter !== undefined && value.source === undefined)
         context.addIssue({
             code: 'custom',
-            message: 'Provide adapter and source together, or omit both to list adapters',
+            message: 'An adapter requires a source; provide a source alone to discover compatible adapters',
         });
 });
 const evaluateInput = z.object(commonShape).strict();
@@ -135,9 +135,32 @@ const inspectDataSchema = z
     .object({
     adapters: nonNegativeIntegerSchema,
     adapterId: z.string().max(256).optional(),
+    requestedAdapter: z.string().max(256).optional(),
+    suggestedAdapter: z.string().max(256).optional(),
+    discoveryReason: z
+        .enum([
+        'source_inventory',
+        'requested_adapter_empty',
+        'identifier_not_found',
+        'candidate_pool_not_found',
+        'no_weighted_surfaces',
+    ])
+        .optional(),
     sourceRevision: sha256Schema.optional(),
     sourceHash: sha256Schema.optional(),
     candidates: nonNegativeIntegerSchema,
+    availableCandidates: nonNegativeIntegerSchema,
+    availableAdapters: z
+        .array(z
+        .object({
+        adapterId: z.string().max(256),
+        candidates: nonNegativeIntegerSchema,
+        identifierMatches: nonNegativeIntegerSchema,
+        candidatePoolMatches: nonNegativeIntegerSchema,
+    })
+        .strict())
+        .max(10),
+    candidateExamples: z.array(z.string().max(512)).max(10),
     poolComplete: z.boolean().optional(),
     requiredInputs: nonNegativeIntegerSchema,
     unresolved: nonNegativeIntegerSchema,
@@ -211,7 +234,7 @@ export function registerProbabilityTools(server, engine, context) {
     const analyzer = new ProbabilityAnalyzer(engine);
     server.registerTool('hoi4.probability_inspect', {
         title: 'Inspect AI and MTTH weighted logic',
-        description: 'List versioned adapters or discover weighted blocks, candidate pools, capabilities, provenance, and unsupported constructs.',
+        description: 'List versioned adapters, or provide a source alone to discover compatible weighted adapters, candidate pools, capabilities, provenance, and unsupported constructs before narrowing the request.',
         inputSchema: inspectInput,
         outputSchema: inspectOutput,
         annotations: readOnly,
@@ -231,14 +254,37 @@ export function registerProbabilityTools(server, engine, context) {
                         sourceHash: inspected.surface.sourceHash,
                         poolComplete: inspected.surface.poolComplete,
                     }),
+                ...(inspected.discovery === undefined
+                    ? {}
+                    : {
+                        ...(inspected.discovery.requestedAdapter === undefined
+                            ? {}
+                            : { requestedAdapter: inspected.discovery.requestedAdapter }),
+                        ...(inspected.discovery.suggestedAdapter === undefined
+                            ? {}
+                            : { suggestedAdapter: inspected.discovery.suggestedAdapter }),
+                        discoveryReason: inspected.discovery.reason,
+                        sourceRevision: inspected.discovery.sourceRevision,
+                        sourceHash: inspected.discovery.sourceHash,
+                    }),
                 candidates: inspected.surface?.candidateCount ?? 0,
+                availableCandidates: inspected.discovery?.availableAdapters.reduce((sum, { candidateCount }) => sum + candidateCount, 0) ?? 0,
+                availableAdapters: inspected.discovery?.availableAdapters.map((available) => ({
+                    adapterId: available.adapterId,
+                    candidates: available.candidateCount,
+                    identifierMatches: available.identifierMatchCount,
+                    candidatePoolMatches: available.candidatePoolMatchCount,
+                })) ?? [],
+                candidateExamples: inspected.discovery?.exampleCandidateIds ?? [],
                 requiredInputs: inspected.surface?.requiredInputs.length ?? 0,
                 unresolved: inspected.surface?.unsupported.length ?? 0,
             });
             result.code =
-                inspected.surface === undefined
-                    ? 'PROBABILITY_ADAPTERS_LISTED'
-                    : 'PROBABILITY_SOURCE_INSPECTED';
+                inspected.surface !== undefined
+                    ? 'PROBABILITY_SOURCE_INSPECTED'
+                    : inspected.discovery !== undefined
+                        ? 'PROBABILITY_SOURCE_DISCOVERED'
+                        : 'PROBABILITY_ADAPTERS_LISTED';
             result.artifacts = inspected.artifacts;
             setInlineFilesScanned(result, inspected.filesScanned);
             await progress.report(2, 2, 'Weighted source inspection complete');

package/dist/hoi4_agent_tools/probability/service.js

@@ -1,6 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { canonicalJson, hashCanonical } from '../core/canonical.js';
+import { canonicalJson, compareCodeUnits, hashCanonical } from '../core/canonical.js';
 import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.js';
 import { probabilityDomainScanPatterns } from '../core/domain-scan-patterns.js';
 import { publicArtifactLink } from '../core/artifacts.js';
@@ -13,7 +13,7 @@ import { VERIFIED_GAME_CHECKSUM, VERIFIED_GAME_RAW_VERSION, VERIFIED_GAME_VERSIO
 import { renderProbabilityResult } from './render.js';
 import { analyzeSequence } from './sequence.js';
 import { simulateSurface } from './simulation.js';
-import { discoverWeightedSurface } from './source-analysis.js';
+import { discoverWeightedSurface, inventoryWeightedSurfaces, } from './source-analysis.js';
 import { sweepSurface } from './sweep.js';
 const states = new WeakMap();
 function analyzerState(engine) {
@@ -775,18 +775,92 @@ export class ProbabilityAnalyzer {
         return complete;
     }
     async inspect(context, adapter, source, candidatePool = []) {
-        if (adapter === undefined || source === undefined)
+        if (source === undefined)
             return { adapters: probabilityAdapters(), artifacts: [], filesScanned: [] };
-        const gameVersionVerification = await this.verifyGameVersion(context, adapter);
         const snapshot = await this.scan(context, [source.path]);
-        const surface = discoverWeightedSurface(snapshot, adapter, source, candidatePool);
+        const storeDiscovery = async (inventory, reason) => {
+            const availableAdapters = inventory.adapters.filter(({ candidateCount }) => candidateCount > 0);
+            const matchingIdentifier = availableAdapters.filter(({ identifierMatchCount }) => source.identifier !== undefined && identifierMatchCount > 0);
+            const matchingPool = availableAdapters.filter(({ candidatePoolMatchCount }) => candidatePool.length > 0 && candidatePoolMatchCount > 0);
+            const requested = availableAdapters.find(({ adapterId }) => adapterId === adapter);
+            const ranked = [
+                ...(matchingIdentifier.length > 0
+                    ? matchingIdentifier
+                    : matchingPool.length > 0
+                        ? matchingPool
+                        : requested === undefined
+                            ? availableAdapters
+                            : [requested]),
+            ].sort((left, right) => right.identifierMatchCount - left.identifierMatchCount ||
+                right.candidatePoolMatchCount - left.candidatePoolMatchCount ||
+                right.candidateCount - left.candidateCount ||
+                compareCodeUnits(left.adapterId, right.adapterId));
+            const suggested = ranked[0];
+            const discovery = {
+                ...(adapter === undefined ? {} : { requestedAdapter: adapter }),
+                reason,
+                sourceRevision: inventory.sourceRevision,
+                sourceHash: inventory.sourceHash,
+                availableAdapters,
+                ...(suggested === undefined ? {} : { suggestedAdapter: suggested.adapterId }),
+                exampleCandidateIds: suggested?.exampleCandidateIds ?? [],
+            };
+            const report = {
+                schemaVersion: 'probability-inspection.v2',
+                workspaceId: context.workspaceId,
+                discovery,
+            };
+            const workspace = this.engine.resolver.get(context.workspaceId, context.principal);
+            const artifact = await this.engine.artifacts.putChunked(workspace, `probability-inspect-${inventory.sourceHash.slice(0, 12)}.json`, 'application/json', `${canonicalJson(report)}\n`, {
+                kind: 'probability-inspection',
+                toolVersion: PACKAGE_VERSION,
+                schemaVersion: 'probability-inspection.v2',
+                sourceHashes: { aggregate: inventory.sourceHash },
+            }, 'Weighted-source adapter inventory and candidate examples', context.signal);
+            return {
+                adapters: probabilityAdapters(),
+                discovery,
+                artifacts: [publicArtifactLink(artifact)],
+                filesScanned: inventory.filesScanned,
+            };
+        };
+        if (adapter === undefined) {
+            const inventory = inventoryWeightedSurfaces(snapshot, source, candidatePool);
+            return storeDiscovery(inventory, inventory.adapters.some(({ candidateCount }) => candidateCount > 0)
+                ? 'source_inventory'
+                : 'no_weighted_surfaces');
+        }
+        const gameVersionVerification = await this.verifyGameVersion(context, adapter);
+        let surface;
+        try {
+            surface = discoverWeightedSurface(snapshot, adapter, source, candidatePool);
+        }
+        catch (error) {
+            if (!(error instanceof ServiceError) ||
+                (error.code !== 'PROBABILITY_SURFACE_EMPTY' &&
+                    error.code !== 'PROBABILITY_IDENTIFIER_NOT_FOUND'))
+                throw error;
+            const inventory = inventoryWeightedSurfaces(snapshot, source, candidatePool);
+            const requested = inventory.adapters.find(({ adapterId }) => adapterId === adapter);
+            const reason = error.code === 'PROBABILITY_IDENTIFIER_NOT_FOUND'
+                ? 'identifier_not_found'
+                : requested !== undefined &&
+                    requested.candidateCount > 0 &&
+                    candidatePool.length > 0 &&
+                    requested.candidatePoolMatchCount === 0
+                    ? 'candidate_pool_not_found'
+                    : inventory.adapters.every(({ candidateCount }) => candidateCount === 0)
+                        ? 'no_weighted_surfaces'
+                        : 'requested_adapter_empty';
+            return storeDiscovery(inventory, reason);
+        }
         const definitions = ClausewitzEvaluationDefinitions.build(snapshot);
         const inspectedCandidates = evaluateExactCandidates(surface, { id: 'inspection', state: {} }, definitions);
         const requiredInputs = [
             ...new Set(inspectedCandidates.flatMap(({ unresolved }) => unresolved.flatMap(({ path }) => (path === undefined ? [] : [path])))),
         ].sort();
         const report = {
-            schemaVersion: 'probability-inspection.v1',
+            schemaVersion: 'probability-inspection.v2',
             workspaceId: context.workspaceId,
             surface: {
                 id: surface.id,
@@ -826,7 +900,7 @@ export class ProbabilityAnalyzer {
         const artifact = await this.engine.artifacts.putChunked(workspace, `probability-inspect-${surface.sourceHash.slice(0, 12)}.json`, 'application/json', `${canonicalJson(report)}\n`, {
             kind: 'probability-inspection',
             toolVersion: PACKAGE_VERSION,
-            schemaVersion: 'probability-inspection.v1',
+            schemaVersion: 'probability-inspection.v2',
             sourceHashes: { aggregate: surface.sourceHash },
         }, 'Discovered weighted surfaces and adapter capabilities', context.signal);
         return {

package/dist/hoi4_agent_tools/probability/source-analysis.js

@@ -2,6 +2,18 @@ import { compareCodeUnits, hashCanonical } from '../core/canonical.js';
 import { ServiceError } from '../core/result.js';
 import { assignments, astPathFor, childBlocks, firstScalar, nodeLocation, parseClausewitz, } from '../core/source/index.js';
 import { probabilityAdapter } from './adapters.js';
+const sourceBackedAdapterIds = [
+    'event_mean_time_to_happen',
+    'event_option_ai_chance',
+    'decision_ai_will_do',
+    'mission_ai_will_do',
+    'national_focus_ai_will_do',
+    'technology_ai_will_do',
+    'doctrine_ai_will_do',
+    'direct_random',
+    'random_list',
+    'ai_strategy_factor',
+];
 const eventKeys = new Set([
     'country_event',
     'news_event',
@@ -116,6 +128,9 @@ function focusCandidates(context) {
     return output;
 }
 function decisionCandidates(context, adapterId) {
+    const sourcePath = normalized(context.file.relativePath);
+    if (context.file.absolutePath !== '<inline>' && !sourcePath.startsWith('common/decisions/'))
+        return [];
     const output = [];
     const ignored = new Set([
         'allowed',
@@ -131,6 +146,10 @@ function decisionCandidates(context, adapterId) {
     for (const { assignment, ancestors } of walkAssignments(context.document.root)) {
         if (assignment.value.type !== 'block' ||
             ancestors.length !== 1 ||
+            ancestors[0].key === 'focus_tree' ||
+            ancestors[0].key === 'continuous_focus_palette' ||
+            ancestors[0].key === 'technologies' ||
+            eventKeys.has(ancestors[0].key) ||
             ignored.has(assignment.key.value))
             continue;
         const mission = firstScalar(assignment.value, 'is_mission')?.value === 'yes' ||
@@ -353,42 +372,74 @@ function samePool(candidate, selected) {
         return candidate.metadata.randomListId === selected.metadata.randomListId;
     return candidate.id === selected.id;
 }
+function candidatesAtSourceLine(candidates, adapterId, line) {
+    if (line === undefined)
+        return candidates;
+    let selected = candidates.filter(({ metadata, provenance: [first] }) => {
+        const location = first?.location;
+        const poolStartLine = metadata.poolStartLine;
+        const poolEndLine = metadata.poolEndLine;
+        return ((location !== undefined && line >= location.start.line && line <= location.end.line) ||
+            (typeof poolStartLine === 'number' &&
+                typeof poolEndLine === 'number' &&
+                line >= poolStartLine &&
+                line <= poolEndLine));
+    });
+    if (adapterId !== 'event_option_ai_chance' && adapterId !== 'random_list')
+        return selected;
+    const poolProperty = adapterId === 'event_option_ai_chance' ? 'eventId' : 'randomListId';
+    const pools = new Map();
+    for (const candidate of selected) {
+        const start = candidate.metadata.poolStartLine;
+        const end = candidate.metadata.poolEndLine;
+        const span = typeof start === 'number' && typeof end === 'number' ? end - start : Number.MAX_SAFE_INTEGER;
+        const key = candidate.metadata[poolProperty];
+        const existing = pools.get(key);
+        if (existing === undefined || span < existing.span)
+            pools.set(key, { span });
+    }
+    const selectedPool = [...pools].sort(([leftKey, left], [rightKey, right]) => left.span - right.span || compareCodeUnits(String(leftKey), String(rightKey)))[0]?.[0];
+    if (selectedPool !== undefined)
+        selected = selected.filter((candidate) => candidate.metadata[poolProperty] === selectedPool);
+    return selected;
+}
+export function inventoryWeightedSurfaces(snapshot, source, candidatePool = [], adapterIds = sourceBackedAdapterIds) {
+    const contexts = sourceContexts(snapshot, source);
+    const wanted = new Set(candidatePool);
+    const adapters = adapterIds
+        .filter((adapterId) => adapterId !== 'custom_weighted_pool')
+        .map((adapterId) => {
+        const candidates = candidatesAtSourceLine(contexts.flatMap((context) => candidatesFor(context, adapterId)), adapterId, source.line).sort((left, right) => compareCodeUnits(left.id, right.id));
+        return {
+            adapterId,
+            candidateCount: candidates.length,
+            identifierMatchCount: source.identifier === undefined
+                ? candidates.length
+                : candidates.filter((candidate) => identifierMatches(candidate, source.identifier))
+                    .length,
+            candidatePoolMatchCount: candidatePool.length === 0
+                ? candidates.length
+                : candidates.filter(({ id }) => wanted.has(id)).length,
+            exampleCandidateIds: [...new Set(candidates.map(({ id }) => id))].slice(0, 10),
+            sourcePaths: [
+                ...new Set(candidates.flatMap(({ provenance }) => provenance.map(({ path }) => path))),
+            ].sort(compareCodeUnits),
+        };
+    })
+        .sort((left, right) => compareCodeUnits(left.adapterId, right.adapterId));
+    const hashes = Object.fromEntries(contexts.map(({ file }) => [file.displayPath, file.sha256]));
+    return {
+        sourceRevision: snapshot.revision,
+        sourceHash: hashCanonical(hashes),
+        filesScanned: contexts.map(({ file }) => file.displayPath),
+        adapters,
+    };
+}
 export function discoverWeightedSurface(snapshot, adapterId, source, candidatePool = []) {
     const contexts = sourceContexts(snapshot, source);
     let candidates = contexts.flatMap((context) => candidatesFor(context, adapterId));
     candidates.sort((left, right) => compareCodeUnits(left.id, right.id));
-    if (source.line !== undefined) {
-        candidates = candidates.filter(({ metadata, provenance: [first] }) => {
-            const location = first?.location;
-            const poolStartLine = metadata.poolStartLine;
-            const poolEndLine = metadata.poolEndLine;
-            return ((location !== undefined &&
-                source.line >= location.start.line &&
-                source.line <= location.end.line) ||
-                (typeof poolStartLine === 'number' &&
-                    typeof poolEndLine === 'number' &&
-                    source.line >= poolStartLine &&
-                    source.line <= poolEndLine));
-        });
-        if (adapterId === 'event_option_ai_chance' || adapterId === 'random_list') {
-            const poolProperty = adapterId === 'event_option_ai_chance' ? 'eventId' : 'randomListId';
-            const pools = new Map();
-            for (const candidate of candidates) {
-                const start = candidate.metadata.poolStartLine;
-                const end = candidate.metadata.poolEndLine;
-                const span = typeof start === 'number' && typeof end === 'number'
-                    ? end - start
-                    : Number.MAX_SAFE_INTEGER;
-                const key = candidate.metadata[poolProperty];
-                const existing = pools.get(key);
-                if (existing === undefined || span < existing.span)
-                    pools.set(key, { span });
-            }
-            const selectedPool = [...pools].sort(([leftKey, left], [rightKey, right]) => left.span - right.span || compareCodeUnits(String(leftKey), String(rightKey)))[0]?.[0];
-            if (selectedPool !== undefined)
-                candidates = candidates.filter((candidate) => candidate.metadata[poolProperty] === selectedPool);
-        }
-    }
+    candidates = candidatesAtSourceLine(candidates, adapterId, source.line);
     const localCategoricalPool = adapterId === 'event_option_ai_chance' || adapterId === 'random_list';
     let completeLocalPoolIds;
     if (source.identifier !== undefined) {

package/dist/hoi4_agent_tools/version.js

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

package/docs/focus.md

@@ -44,7 +44,7 @@ If malformed or unsupported script makes a requested change ambiguous, the rewri
 
 ## What inspection checks
 
-Inspection and rendering can report missing references, invalid prerequisite structure, duplicate or overlapping positions, insufficient spacing, long or crossing connectors, branch asymmetry, route conflicts, missing localisation or sprites, weak terminal branches, repeated rewards, and missing AI metadata. Renders are offline review artifacts, not game screenshots.
+Inspection and rendering can report missing references, invalid prerequisite structure, duplicate or overlapping positions, insufficient spacing, long or crossing connectors, branch asymmetry, route conflicts, missing localisation or sprites, weak terminal branches, repeated rewards, and missing AI metadata. National-tree inspection also returns the exact `continuous_focus_position` coordinates and linked palette IDs in its compact result, so an agent can identify and move the continuous-focus area without opening the full artifact. Renders are offline review artifacts, not game screenshots.
 
 `hoi4.focus_render` is the normal structural view and writes complete HTML, SVG, JSON, and source-map artifacts without decoding every icon or creating a PNG. `hoi4.focus_raster` adds decoded icons and the high-fidelity PNG. National trees with 200 or more focuses raster at half scale by default; pass `reviewScale` from `0.25` through `1` when a different PNG size is needed.
 

package/docs/probability.md

@@ -6,7 +6,7 @@ Use them for event timing and option weights, decision and mission scores, focus
 
 | Tool                        | Use                                                                                                                             |
 | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| `hoi4.probability_inspect`  | Discover weighted blocks, adapters, candidates, provenance, capabilities, and unsupported constructs.                           |
+| `hoi4.probability_inspect`  | Discover weighted blocks, compatible adapters, candidates, provenance, capabilities, and unsupported constructs.                |
 | `hoi4.probability_evaluate` | Evaluate eligibility, modifier traces, raw values, proven probabilities, and MTTH horizon chances across scenarios.             |
 | `hoi4.probability_sweep`    | Sweep declared ranges and locate sensitivity changes, breakpoints, and rank reversals.                                          |
 | `hoi4.probability_simulate` | Sample declared distributions with a deterministic seed and confidence intervals.                                               |
@@ -16,6 +16,8 @@ Use them for event timing and option weights, decision and mission scores, focus
 
 All seven tools are read-only. Proposed source is parsed in memory and never written. When an installed game root is configured, evaluation fails closed unless `launcher-settings.json` identifies the supported HOI4 build and checksum. Results otherwise state that they target the adapter version without claiming local-game verification.
 
+Pass a source without an adapter when the surface type is not yet known. Inspection returns every compatible adapter, candidate counts, and example candidate IDs. If a requested adapter, identifier, or candidate pool does not match the source, inspection returns the same discovery result with an explanation and suggested adapter instead of `PROBABILITY_SURFACE_EMPTY`; evaluation, sweeps, and simulation remain strict and still reject an empty requested surface.
+
 ## Scenarios
 
 A scenario contains only state the caller is willing to declare. Missing values stay unresolved. Alternatives and ranges produce exact branches or bounds; probability distributions require `hoi4.probability_simulate`.

package/package.json

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

package/schemas/configuration.schema.json

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

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

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

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

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

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

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

package/schemas/focus-plan.schema.json

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

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

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

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

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

package/schemas/gui-helper.schema.json

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

package/schemas/gui-scenario.schema.json

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

package/schemas/map-operation.schema.json

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

package/schemas/operation-result.schema.json

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/server.json

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