hoi4-agent-tools 3.2.0 → 3.4.0

package/dist/hoi4_agent_tools/map/render.js

@@ -357,7 +357,50 @@ export async function renderMap(index, options = {}) {
         throw new ServiceError('MAP_RENDER_SCALE_INVALID', 'Map render scale must be an integer from 1 through 16');
     const budget = options.budget ?? new RenderBudget();
     assertRenderDimensions(raster.width, raster.height, 'map RGBA source plane');
-    const outputDimensions = budget.reserve(raster.width * resolved.scale, raster.height * resolved.scale, 'map PNG output');
+    let tile = options.tile;
+    if (options.area !== undefined) {
+        if (tile !== undefined)
+            throw new ServiceError('MAP_RENDER_AREA_CONFLICT', 'Choose a map tile or entity area');
+        const ids = new Set(options.area.provinceIds ?? []);
+        for (const stateId of options.area.stateIds ?? []) {
+            const state = index.statesById.get(stateId);
+            if (state === undefined)
+                throw new ServiceError('MAP_AREA_STATE_MISSING', 'Map area state ID is missing', {
+                    stateId,
+                });
+            for (const id of state.provinces)
+                ids.add(id);
+        }
+        for (const regionId of options.area.regionIds ?? []) {
+            const region = index.regionsById.get(regionId);
+            if (region === undefined)
+                throw new ServiceError('MAP_AREA_REGION_MISSING', 'Map area region ID is missing', {
+                    regionId,
+                });
+            for (const id of region.provinces)
+                ids.add(id);
+        }
+        if (ids.size === 0)
+            throw new ServiceError('MAP_AREA_EMPTY', 'Map area has no provinces');
+        const geometry = [...ids].map((id) => {
+            const province = raster.geometry.get(id);
+            if (province === undefined)
+                throw new ServiceError('MAP_AREA_PROVINCE_MISSING', 'Map area province ID has no raster geometry', { provinceId: id });
+            return province;
+        });
+        const padding = options.area.padding ?? 32;
+        const x = Math.max(0, Math.min(...geometry.map(({ minX }) => minX)) - padding);
+        const y = Math.max(0, Math.min(...geometry.map(({ minY }) => minY)) - padding);
+        const right = Math.min(raster.width, Math.max(...geometry.map(({ maxX }) => maxX)) + padding + 1);
+        const bottom = Math.min(raster.height, Math.max(...geometry.map(({ maxY }) => maxY)) + padding + 1);
+        tile = { x, y, width: right - x, height: bottom - y };
+        if (tile.width > 2_048 || tile.height > 2_048)
+            throw new ServiceError('MAP_AREA_TOO_LARGE', 'Map area exceeds the tile limit; select fewer entities', { tile });
+    }
+    if (tile !== undefined &&
+        (tile.x + tile.width > raster.width || tile.y + tile.height > raster.height))
+        throw new ServiceError('MAP_TILE_OUT_OF_BOUNDS', 'Map tile extends beyond the province raster', { tile, rasterWidth: raster.width, rasterHeight: raster.height });
+    const outputDimensions = budget.reserve((tile?.width ?? raster.width) * resolved.scale, (tile?.height ?? raster.height) * resolved.scale, 'map PNG output');
     const raw = Buffer.alloc(raster.width * raster.height * 4);
     for (let offset = 0; offset < raster.provinceIds.length; offset += 1) {
         if (offset % Math.max(raster.width * 32, 1) === 0)
@@ -371,6 +414,32 @@ export async function renderMap(index, options = {}) {
     }
     await applyOverlays(index, raw, new Set(resolved.overlays), options.signal);
     options.signal?.throwIfAborted();
+    if (tile !== undefined) {
+        const tileRaw = Buffer.alloc(tile.width * tile.height * 4);
+        const provinceIds = new Set();
+        for (let row = 0; row < tile.height; row += 1) {
+            if (row % 32 === 0)
+                await renderCheckpoint(options.signal);
+            raw.copy(tileRaw, row * tile.width * 4, ((tile.y + row) * raster.width + tile.x) * 4, ((tile.y + row) * raster.width + tile.x + tile.width) * 4);
+            for (let column = 0; column < tile.width; column += 1) {
+                const id = raster.provinceIds[(tile.y + row) * raster.width + tile.x + column];
+                if (id !== undefined && id >= 0)
+                    provinceIds.add(id);
+            }
+        }
+        const png = await encodePng(tileRaw, tile.width, tile.height, resolved.scale);
+        const json = `${canonicalJson({ schemaVersion: 'map-tile.v1', layer: resolved.layer, overlays: resolved.overlays, scale: resolved.scale, tile, raster: { width: raster.width, height: raster.height }, provinceIds: [...provinceIds].sort((left, right) => left - right) })}\n`;
+        const html = diffHtmlDocument(`HOI4 map tile - ${resolved.layer}`, png, json);
+        return {
+            width: outputDimensions.width,
+            height: outputDimensions.height,
+            tile,
+            png,
+            json,
+            html,
+            hashes: { png: sha256Bytes(png), json: sha256Bytes(json), html: sha256Bytes(html) },
+        };
+    }
     const png = await encodePng(raw, raster.width, raster.height, resolved.scale);
     options.signal?.throwIfAborted();
     const json = `${canonicalJson(await renderMetadata(index, resolved, options.signal))}\n`;

package/dist/hoi4_agent_tools/map/service.js

@@ -481,7 +481,7 @@ export class AgentNudger {
         this.scanner = this.engine.scanner;
         this.transactions = this.engine.transactions;
     }
-    async scan(workspaceId, principal, signal) {
+    async scan(workspaceId, principal, signal, includeExternalScriptReferences = false) {
         signal?.throwIfAborted();
         const workspace = this.resolver.get(workspaceId, principal);
         const sourceRoots = {
@@ -493,8 +493,27 @@ export class AgentNudger {
         const bitmapPatterns = provinceBitmapPatterns(selectorSnapshot.files, sourceRoots.map);
         const contentSnapshot = await this.engine.scan(workspaceId, { patterns: [...sourceTextPatterns(sourceRoots), ...bitmapPatterns] }, principal, signal);
         const locatorSnapshot = await this.engine.scan(workspaceId, { patterns: ['**/*.asset'], rootKinds: ['mod', 'fixture'] }, principal, signal);
+        const externalScriptSnapshot = includeExternalScriptReferences
+            ? await this.engine.scan(workspaceId, {
+                patterns: [
+                    'events/**/*.txt',
+                    'common/national_focus/**/*.txt',
+                    'common/decisions/**/*.txt',
+                    'common/scripted_effects/**/*.txt',
+                    'common/scripted_triggers/**/*.txt',
+                    'common/on_actions/**/*.txt',
+                    'common/ideas/**/*.txt',
+                    'common/characters/**/*.txt',
+                    'history/countries/**/*.txt',
+                ],
+            }, principal, signal)
+            : undefined;
         signal?.throwIfAborted();
-        const files = [...contentSnapshot.files, ...locatorSnapshot.files].sort((left, right) => left.loadOrder - right.loadOrder || compareCodeUnits(left.displayPath, right.displayPath));
+        const files = [
+            ...contentSnapshot.files,
+            ...locatorSnapshot.files,
+            ...(externalScriptSnapshot?.files ?? []),
+        ].sort((left, right) => left.loadOrder - right.loadOrder || compareCodeUnits(left.displayPath, right.displayPath));
         const revision = hashCanonical(files.map(({ displayPath, loadOrder, sha256 }) => ({ displayPath, loadOrder, sha256 })));
         return {
             workspaceId,
@@ -512,7 +531,7 @@ export class AgentNudger {
     }
     async prepareOperations(workspaceId, operations, principal, signal) {
         signal?.throwIfAborted();
-        const snapshot = await this.scan(workspaceId, principal, signal);
+        const snapshot = await this.scan(workspaceId, principal, signal, operations.some(({ kind }) => kind === 'renumber_map_entity'));
         const plan = await planMapOperationsAsync(snapshot.index, operations, signal);
         const baselineValidation = await validateMapAsync(snapshot.index, signal === undefined ? {} : { signal });
         const rawValidation = await validateMapAsync(plan.finalIndex, {
@@ -614,6 +633,9 @@ export class AgentNudger {
         const bundle = mapBundleWithSourceHashes(rawBundle, completeSourceHashes);
         const workspace = this.resolver.get(workspaceId, options.principal);
         const layer = options.layer ?? 'province';
+        const tileSuffix = options.tile === undefined && options.area === undefined
+            ? ''
+            : `-tile-${hashCanonical({ tile: bundle.tile, area: options.area, overlays: [...new Set(options.overlays ?? [])].sort(), scale: options.scale ?? 1 }).slice(0, 12)}`;
         const provenance = {
             kind: 'map-render',
             toolVersion: PACKAGE_VERSION,
@@ -624,24 +646,26 @@ export class AgentNudger {
                 layer,
                 overlays: [...new Set(options.overlays ?? [])].sort(),
                 scale: options.scale ?? 1,
+                ...(bundle.tile === undefined ? {} : { tile: bundle.tile }),
+                ...(options.area === undefined ? {} : { area: options.area }),
             },
             metadata: { sourceHashInventory: sourceEvidence.inventory },
         };
         const writes = [
             {
-                name: `map-${layer}.png`,
+                name: `map-${layer}${tileSuffix}.png`,
                 mimeType: 'image/png',
                 content: bundle.png,
                 provenance,
             },
             {
-                name: `map-${layer}.json`,
+                name: `map-${layer}${tileSuffix}.json`,
                 mimeType: 'application/json',
                 content: bundle.json,
                 provenance,
             },
             {
-                name: `map-${layer}.html`,
+                name: `map-${layer}${tileSuffix}.html`,
                 mimeType: 'text/html',
                 content: bundle.html,
                 provenance,

package/dist/hoi4_agent_tools/map/tool-operations.js

@@ -1,7 +1,7 @@
 import { boundedSourceHashEvidence, publicArtifactLink, } from '../core/artifacts.js';
 import { canonicalJson, hashCanonical } from '../core/canonical.js';
 import { autonomousResultArtifacts, } from '../core/transaction-execution.js';
-import { emptyServiceResult } from '../core/result.js';
+import { emptyServiceResult, ServiceError } from '../core/result.js';
 import { setInlineFilesScanned } from '../core/operation-result.js';
 import { PACKAGE_VERSION } from '../version.js';
 import { allocateMapIdentifiersAsync, } from './operations.js';
@@ -299,6 +299,69 @@ export function completeMapRewrite(workspaceId, execution, recipe) {
 }
 export async function inspectMap(engine, nudger, input, context) {
     await context.progress(0, 3, 'Inspecting and validating the map');
+    if (input.lookupOnly) {
+        if (input.allocationRequests.length > 0)
+            throw new ServiceError('MAP_LOOKUP_ALLOCATION_UNSUPPORTED', 'Use full map inspection for identifier allocation previews');
+        const snapshot = await nudger.scan(context.workspaceId, context.principal, context.signal);
+        const catalog = input.query === undefined ? undefined : buildMapCatalog(snapshot.index);
+        const queryMatches = catalog === undefined ? [] : searchMapCatalog(catalog, input.query, input.queryLimit);
+        const coordinateMatches = input.coordinates.map((coordinate) => lookupMapCoordinate(snapshot.index, coordinate));
+        const selected = selectedMapEntities(snapshot, input.provinceIds, input.stateIds, input.regionIds);
+        const workspace = engine.resolver.get(context.workspaceId, context.principal);
+        const sourceEvidence = mapArtifactSourceEvidence(snapshot.files);
+        const selectorHash = hashCanonical({
+            provinceIds: input.provinceIds,
+            stateIds: input.stateIds,
+            regionIds: input.regionIds,
+            query: input.query,
+            coordinates: input.coordinates,
+        }).slice(0, 16);
+        const artifact = await engine.artifacts.putChunked(workspace, `map-lookup.${snapshot.revision.slice(0, 16)}.${selectorHash}.json`, 'application/json', `${canonicalJson({ schemaVersion: 1, revision: snapshot.revision, lookupOnly: true, queryMatches, coordinateMatches, selected, sourceHashes: sourceEvidence.complete })}\n`, {
+            kind: 'map-lookup',
+            toolVersion: PACKAGE_VERSION,
+            schemaVersion: 'map-lookup.v1',
+            sourceHashes: sourceEvidence.bounded.sourceHashes,
+            metadata: { sourceHashInventory: sourceEvidence.bounded.inventory },
+        }, 'Bounded map coordinate, catalog, and entity lookup without full validation or overview rendering', context.signal);
+        const result = emptyServiceResult(context.workspaceId, {
+            revision: snapshot.revision,
+            sharedRevision: snapshot.revision,
+            width: snapshot.index.raster?.width ?? null,
+            height: snapshot.index.raster?.height ?? null,
+            definitions: snapshot.index.definitions.length,
+            states: snapshot.index.states.length,
+            regions: snapshot.index.regions.length,
+            ports: snapshot.index.ports.length,
+            inspectedProvinceCount: selected.provinces.length,
+            inspectedStateCount: selected.states.length,
+            inspectedRegionCount: selected.regions.length,
+            allocationCount: 0,
+            queryMatchCount: queryMatches.length,
+            coordinateMatchCount: coordinateMatches.length,
+            overviewRendered: false,
+            provinceGeometryCount: 0,
+            provinceGeometryPixelCount: 0,
+            provinceGeometryRowRunCount: 0,
+            unknownProvinceIds: [],
+            missingGeometryProvinceIds: [],
+            lookupOnly: true,
+        });
+        result.code = 'MAP_LOOKUP_COMPLETED';
+        result.validation = {
+            passed: true,
+            checks: [
+                {
+                    id: 'lookup-only',
+                    passed: true,
+                    message: 'Lookup completed; full map validation was not requested',
+                },
+            ],
+        };
+        setInlineFilesScanned(result, snapshot.files.map(({ displayPath }) => displayPath));
+        result.artifacts = [publicArtifactLink(artifact)];
+        await context.progress(3, 3, 'Map lookup complete');
+        return result;
+    }
     const { snapshot, validation } = await nudger.validate(context.workspaceId, context.principal, context.signal);
     const sharedRevision = snapshot.revision;
     const catalog = buildMapCatalog(snapshot.index);
@@ -474,6 +537,8 @@ export async function renderMapView(nudger, input, context) {
         ...(input.layer === undefined ? {} : { layer: input.layer }),
         ...(input.overlays === undefined ? {} : { overlays: input.overlays }),
         ...(input.scale === undefined ? {} : { scale: input.scale }),
+        ...(input.tile === undefined ? {} : { tile: input.tile }),
+        ...(input.area === undefined ? {} : { area: input.area }),
         ...(context.principal === undefined ? {} : { principal: context.principal }),
         ...(context.signal === undefined ? {} : { signal: context.signal }),
     });
@@ -483,6 +548,7 @@ export async function renderMapView(nudger, input, context) {
         height: rendered.bundle.height,
         hashes: rendered.bundle.hashes,
         offlineRepresentation: true,
+        ...(rendered.bundle.tile === undefined ? {} : { tile: rendered.bundle.tile }),
     });
     result.code = 'MAP_RENDERED';
     setInlineFilesScanned(result, rendered.filesScanned);

package/dist/hoi4_agent_tools/mcp/server/instructions.js

@@ -1,2 +1,2 @@
 /** Shared agent-facing guidance for both MCP protocol generations. */
-export const SERVER_INSTRUCTIONS = 'Use focus tools for focus trees, GUI tools for interfaces, and map tools for map data. Start unfamiliar event chains with hoi4.event_inspect. Event tools are read-only. Start cross-system source review with hoi4.impact_inspect and decision or mission scenarios with hoi4.decision_inspect. Impact and decision tools are read-only. Start technology and doctrine work with hoi4.tech_inspect. Technology tools are read-only. Start weighted AI, MTTH, random, and declared-pool analysis with hoi4.probability_inspect. Probability tools are read-only. Concurrent calls queue automatically and emit periodic progress when the client requests it. Long operations support negotiated MCP tasks; native background rewrites require a stable requestKey. Large evidence is linked as resources.';
+export const SERVER_INSTRUCTIONS = 'Use focus tools for focus trees, GUI tools for interfaces, and map tools for map data. Start unfamiliar event chains with hoi4.event_inspect. Event tools are read-only. Start cross-system source review with hoi4.impact_inspect and decision or mission scenarios with hoi4.decision_inspect. Test declared mechanic steps with hoi4.mechanic_test, package connections with hoi4.package_check, and named suites with hoi4.scenario_test. These analysis tools are read-only. Start technology and doctrine work with hoi4.tech_inspect. Technology tools are read-only. Start weighted AI, MTTH, random, and declared-pool analysis with hoi4.probability_inspect. Probability tools are read-only. Concurrent calls queue automatically and emit periodic progress when the client requests it. Long operations support negotiated MCP tasks; native background rewrites require a stable requestKey. Large evidence is linked as resources.';

package/dist/hoi4_agent_tools/mcp/server/request-lifecycle.js

@@ -7,6 +7,9 @@ const controlTools = new Set(['hoi4.job_inspect', 'hoi4.job_cancel']);
 const backgroundTools = new Set([
     'hoi4.impact_inspect',
     'hoi4.decision_inspect',
+    'hoi4.mechanic_test',
+    'hoi4.package_check',
+    'hoi4.scenario_test',
     'hoi4.event_inspect',
     'hoi4.event_render',
     'hoi4.event_compare',

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

@@ -1,5 +1,7 @@
 import { z } from 'zod/v4';
 import { decisionInspectRequestSchema, impactInspectRequestSchema, } from '../../schemas/analysis.js';
+import { mechanicCaseSchema, mechanicTestRequestSchema, packageManifestSchema, packageCheckRequestSchema, scenarioSuiteSchema, scenarioTestRequestSchema, } from '../../schemas/scenarios.js';
+import { compactValidatedInputSchema } from '../server/context-schemas.js';
 import { nonNegativeIntegerSchema, sha256Schema } from '../server/output-schemas.js';
 import { strictOperationResultSchema } from '../server/result.js';
 import { registerLegacyTaskTools } from '../server/legacy-task-tools.js';
@@ -36,6 +38,70 @@ const decisionOutputSchema = strictOperationResultSchema(z
     unresolvedDefinitions: nonNegativeIntegerSchema,
 })
     .strict());
+const mechanicOutputSchema = strictOperationResultSchema(z
+    .object({
+    sourceRevision: sha256Schema,
+    reportHash: sha256Schema,
+    status: z.enum(['passed', 'failed', 'unresolved']),
+    assertions: nonNegativeIntegerSchema,
+    passed: nonNegativeIntegerSchema,
+    failed: nonNegativeIntegerSchema,
+    unresolved: nonNegativeIntegerSchema,
+    steps: nonNegativeIntegerSchema,
+})
+    .strict());
+const packageOutputSchema = strictOperationResultSchema(z
+    .object({
+    sourceRevision: sha256Schema,
+    reportHash: sha256Schema,
+    complete: z.boolean(),
+    items: nonNegativeIntegerSchema,
+    present: nonNegativeIntegerSchema,
+    absent: nonNegativeIntegerSchema,
+    shadowed: nonNegativeIntegerSchema,
+    unresolved: nonNegativeIntegerSchema,
+})
+    .strict());
+const scenarioOutputSchema = strictOperationResultSchema(z
+    .object({
+    sourceRevision: sha256Schema,
+    suiteHash: sha256Schema,
+    reportHash: sha256Schema,
+    start: nonNegativeIntegerSchema,
+    end: nonNegativeIntegerSchema,
+    total: nonNegativeIntegerSchema,
+    completed: nonNegativeIntegerSchema,
+    failed: nonNegativeIntegerSchema,
+    unresolved: nonNegativeIntegerSchema,
+    pending: nonNegativeIntegerSchema,
+    continuation: z.string().optional(),
+})
+    .strict());
+const mechanicInputSchema = z
+    .object({
+    ...mechanicTestRequestSchema.shape,
+    test: compactValidatedInputSchema(mechanicCaseSchema, 'Versioned declared scenario, explicit effect steps, and typed assertions. See docs/mechanics.md.'),
+})
+    .strict();
+const packageInputSchema = z
+    .object({
+    ...packageCheckRequestSchema.shape,
+    manifest: compactValidatedInputSchema(packageManifestSchema, 'Declarative definitions, calls, registrations, localisation, assets, and required cases. See docs/mechanics.md.'),
+})
+    .strict();
+const scenarioInputSchema = z
+    .object({
+    ...scenarioTestRequestSchema.shape,
+    suite: compactValidatedInputSchema(scenarioSuiteSchema, 'Named mechanic, package, or fixed read-only tool cases. See docs/mechanics.md.').optional(),
+})
+    .strict()
+    .superRefine((input, context) => {
+    if ((input.suite === undefined) === (input.suitePath === undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'Specify exactly one inline suite or suitePath',
+        });
+});
 const readOnlyAnalysisTool = {
     readOnlyHint: true,
     destructiveHint: false,
@@ -59,6 +125,30 @@ export const analysisTaskTools = [
         outputSchema: decisionOutputSchema,
         annotations: readOnlyAnalysisTool,
     },
+    {
+        name: 'hoi4.mechanic_test',
+        title: 'Test declared mechanic steps',
+        description: 'Interpret bounded, source-backed effect steps on isolated declared state and check typed invariants. Unsupported effects remain unresolved; no game or mod source is changed.',
+        inputSchema: mechanicInputSchema,
+        outputSchema: mechanicOutputSchema,
+        annotations: readOnlyAnalysisTool,
+    },
+    {
+        name: 'hoi4.package_check',
+        title: 'Check package connections',
+        description: 'Check a declarative package manifest against active definitions, references, registrations, localisation, assets, and required suite cases.',
+        inputSchema: packageInputSchema,
+        outputSchema: packageOutputSchema,
+        annotations: readOnlyAnalysisTool,
+    },
+    {
+        name: 'hoi4.scenario_test',
+        title: 'Run scenario suite',
+        description: 'Run named inline or workspace-relative cases through bounded typed read-only domain services. Large suites return an authenticated continuation.',
+        inputSchema: scenarioInputSchema,
+        outputSchema: scenarioOutputSchema,
+        annotations: readOnlyAnalysisTool,
+    },
 ];
 export function registerAnalysisTools(server) {
     registerLegacyTaskTools(server, analysisTaskTools);

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

@@ -31,6 +31,7 @@ const eventRenderInputSchema = z
 const eventCompareInputSchema = z
     .object({
     ...eventCompareRequestSchema.shape,
+    selector: nestedSelectorSchema.optional(),
     before: nestedGraphReferenceSchema.optional(),
     after: nestedGraphReferenceSchema.optional(),
     proposedSources: z.array(nestedProposedSourceSchema).min(1).max(64).optional(),
@@ -119,6 +120,11 @@ const eventCompareOutputSchema = strictOperationResultSchema(z
     counts: z
         .object({
         changes: nonNegativeIntegerSchema,
+        selectedChanges: nonNegativeIntegerSchema.optional(),
+        omittedChanges: nonNegativeIntegerSchema.optional(),
+        unattributedChanges: nonNegativeIntegerSchema.optional(),
+        selectedBeforeNodes: nonNegativeIntegerSchema.optional(),
+        selectedAfterNodes: nonNegativeIntegerSchema.optional(),
         addedNodes: nonNegativeIntegerSchema,
         removedNodes: nonNegativeIntegerSchema,
         changedNodes: nonNegativeIntegerSchema,
@@ -146,6 +152,9 @@ const eventCompareOutputSchema = strictOperationResultSchema(z
     boundary: z
         .object({
         proposedSources: nonNegativeIntegerSchema,
+        selector: eventSelectorSchema.optional(),
+        maxChainNodes: nonNegativeIntegerSchema.optional(),
+        selectionTruncated: z.boolean().optional(),
         render: z.boolean(),
         maxRenderNodes: nonNegativeIntegerSchema,
         refresh: z.boolean(),
@@ -179,7 +188,7 @@ export const eventTaskTools = [
     {
         name: 'hoi4.event_compare',
         title: 'Compare event chains',
-        description: 'Compare cached, artifact-backed, current, or in-memory proposed event graphs without writing source. Full changes are resources.',
+        description: 'Compare cached, artifact-backed, current, or in-memory proposed event graphs, optionally selecting one downstream chain. Full changes and explicit selection coverage are resources.',
         inputSchema: eventCompareInputSchema,
         outputSchema: eventCompareOutputSchema,
         annotations: readOnlyEventTool,

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

@@ -30,6 +30,16 @@ const focusInspectOutputSchema = strictOperationResultSchema(z
         layoutDecisionCount: nonNegativeIntegerSchema,
         layoutMetrics: focusLayoutMetricsSchema,
         diagnosticCount: nonNegativeIntegerSchema,
+        scenarioSummary: z
+            .object({
+            completed: nonNegativeIntegerSchema,
+            blocked: nonNegativeIntegerSchema,
+            unresolved: nonNegativeIntegerSchema,
+            structuralCandidates: nonNegativeIntegerSchema,
+            choiceConflictCount: nonNegativeIntegerSchema,
+        })
+            .strict()
+            .optional(),
     })
         .strict())
         .max(100),
@@ -125,7 +135,7 @@ export const focusTaskTools = [
     {
         name: 'hoi4.focus_inspect',
         title: 'Inspect focus trees',
-        description: 'Inspect national trees or continuous palettes for creation and cleanup, including continuous-focus placement, complete plans, references, diagnostics, and stable layout decisions.',
+        description: 'Inspect focus trees and continuous palettes, including source references, diagnostics, and layout.',
         inputSchema: focusInspectRequestSchema,
         outputSchema: focusInspectOutputSchema,
         annotations: artifactProducing,
@@ -133,7 +143,7 @@ export const focusTaskTools = [
     {
         name: 'hoi4.focus_render',
         title: 'Render focus review artifacts',
-        description: 'Render a national tree or continuous palette as fast deterministic HTML, SVG, JSON, and source-map artifacts. Use hoi4.focus_raster when decoded icons and PNG output are needed.',
+        description: 'Render focus HTML, SVG, JSON, and source maps. Use hoi4.focus_raster for decoded icons and PNG.',
         inputSchema: focusRenderRequestSchema,
         outputSchema: focusRenderOutputSchema,
         annotations: artifactProducing,
@@ -141,7 +151,7 @@ export const focusTaskTools = [
     {
         name: 'hoi4.focus_raster',
         title: 'Rasterize focus review artifacts',
-        description: 'Produce the high-fidelity focus review with decoded source icons and deterministic PNG output. Use focus_render for the faster structural HTML, SVG, and JSON view.',
+        description: 'Render focus PNG with decoded source icons; also returns HTML, SVG, and JSON.',
         inputSchema: focusRenderRequestSchema,
         outputSchema: focusRenderOutputSchema,
         annotations: artifactProducing,
@@ -149,7 +159,7 @@ export const focusTaskTools = [
     {
         name: 'hoi4.focus_rewrite',
         title: 'Create or clean up focus content',
-        description: 'Create or clean up a national tree or continuous palette, validate it, and apply it in one call. Supply a complete plan; set layoutMode compact for automatic arrangement. Existing national trees can omit the plan and use treeId plus layoutMode compact. Set createIfMissing for a new file.',
+        description: 'Create or compact a focus tree or palette from a complete plan. Use treeId for existing trees and createIfMissing for new files.',
         inputSchema: focusRewriteRequestSchema,
         outputSchema: focusPlanOutputSchema,
         annotations: {

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

@@ -43,6 +43,10 @@ const guiRenderOutputSchema = strictOperationResultSchema(z
     comparison: z
         .object({ changedPixels: nonNegativeIntegerSchema, changedRatio: z.number().min(0).max(1) })
         .strict(),
+    sourceComparison: z
+        .object({ changedPixels: nonNegativeIntegerSchema, changedRatio: z.number().min(0).max(1) })
+        .strict()
+        .optional(),
     fidelityCounts: countRecordSchema,
     offlineRepresentation: z.literal(true),
 })
@@ -76,7 +80,7 @@ export const guiTaskTools = [
     {
         name: 'hoi4.gui_render',
         title: 'Render scripted GUI artifacts',
-        description: 'Render GUI states, resolutions, generated or explicit scenarios, dynamic flags and text icons, hierarchy, comparisons, and diagnostics.',
+        description: 'Render GUI states, resolutions, scenarios, hierarchy, comparisons, and diagnostics.',
         inputSchema: guiRenderRequestSchema,
         outputSchema: guiRenderOutputSchema,
         annotations: artifactProducing,

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

@@ -75,6 +75,7 @@ const mapWorkspaceInspectOutputSchema = strictOperationResultSchema(z
     provinceGeometryCount: nonNegativeIntegerSchema,
     provinceGeometryPixelCount: nonNegativeIntegerSchema,
     provinceGeometryRowRunCount: nonNegativeIntegerSchema,
+    lookupOnly: z.boolean().optional(),
     unknownProvinceIds: z.array(nonNegativeIntegerSchema).max(512),
     missingGeometryProvinceIds: z.array(nonNegativeIntegerSchema).max(512),
 })
@@ -86,6 +87,15 @@ const mapRenderOutputSchema = strictOperationResultSchema(z
     height: nonNegativeIntegerSchema,
     hashes: bitmapRenderHashesSchema,
     offlineRepresentation: z.literal(true),
+    tile: z
+        .object({
+        x: nonNegativeIntegerSchema,
+        y: nonNegativeIntegerSchema,
+        width: nonNegativeIntegerSchema,
+        height: nonNegativeIntegerSchema,
+    })
+        .strict()
+        .optional(),
 })
     .strict());
 const mapPlanOutputSchema = strictOperationResultSchema(z
@@ -113,7 +123,7 @@ export const mapTaskTools = [
     {
         name: 'hoi4.map_inspect',
         title: 'Inspect HOI4 map',
-        description: 'Render, validate, search, and click the complete map.',
+        description: 'Validate and inspect the complete map, or use lookupOnly for bounded coordinate and entity lookups.',
         inputSchema: mapInspectRequestSchema,
         outputSchema: mapWorkspaceInspectOutputSchema,
         annotations: artifactProducing,
@@ -121,7 +131,7 @@ export const mapTaskTools = [
     {
         name: 'hoi4.map_render',
         title: 'Render map inspection artifacts',
-        description: 'Render searchable full-map PNG, JSON, and HTML.',
+        description: 'Render searchable full-map PNG, JSON, and HTML, or a reusable source-coordinate tile.',
         inputSchema: mapRenderRequestSchema,
         outputSchema: mapRenderOutputSchema,
         annotations: artifactProducing,

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

@@ -16,6 +16,9 @@ const analysisDataSchema = z
     cacheKey: sha256Schema,
     scenarios: nonNegativeIntegerSchema,
     candidates: nonNegativeIntegerSchema,
+    eligibleCandidates: nonNegativeIntegerSchema,
+    excludedCandidates: nonNegativeIntegerSchema,
+    unresolvedCandidates: nonNegativeIntegerSchema,
     scopePools: nonNegativeIntegerSchema.optional(),
     scopePoolCandidates: nonNegativeIntegerSchema.optional(),
     unresolved: nonNegativeIntegerSchema,
@@ -61,6 +64,8 @@ const inspectDataSchema = z
     candidateExamples: z.array(z.string().max(512)).max(10),
     poolComplete: z.boolean().optional(),
     requiredInputs: nonNegativeIntegerSchema,
+    requiredInputPaths: z.array(z.string().max(1024)).max(32),
+    requiredInputPathsTruncated: z.boolean(),
     unresolved: nonNegativeIntegerSchema,
 })
     .strict();