hoi4-agent-tools 3.10.0 → 4.0.0

package/dist/hoi4_agent_tools/schemas/map-requests.js

@@ -32,6 +32,33 @@ export const mapOverlaySchema = z.enum([
     'unit-positions',
     'weather-positions',
 ]);
+const mapTileSchema = z
+    .object({
+    x: z.number().int().min(0),
+    y: z.number().int().min(0),
+    width: z.number().int().min(1).max(2_048),
+    height: z.number().int().min(1).max(2_048),
+})
+    .strict();
+const mapAreaSchema = z
+    .object({
+    provinceIds: z.array(z.number().int().nonnegative()).max(256).optional(),
+    stateIds: z.array(z.number().int().nonnegative()).max(64).optional(),
+    regionIds: z.array(z.number().int().nonnegative()).max(64).optional(),
+    padding: z.number().int().min(0).max(256).optional(),
+})
+    .strict()
+    .refine(({ provinceIds, stateIds, regionIds }) => (provinceIds?.length ?? 0) + (stateIds?.length ?? 0) + (regionIds?.length ?? 0) > 0, 'Map area requires at least one province, state, or region ID');
+/** Fields that select a rendered map view instead of validation and lookups. */
+export const MAP_VIEW_FIELDS = ['layer', 'overlays', 'scale', 'tile', 'area'];
+const MAP_LOOKUP_FIELDS = [
+    'provinceIds',
+    'stateIds',
+    'regionIds',
+    'query',
+    'coordinates',
+    'allocationRequests',
+];
 export const mapInspectRequestSchema = z
     .object({
     workspaceId: workspaceIdSchema,
@@ -66,33 +93,49 @@ export const mapInspectRequestSchema = z
     lookupOnly: z.boolean().default(false),
     includeOverview: z.boolean().default(true),
     allocationRequests: z.array(mapAllocationRequestSchema).max(100).default([]),
+    references: z
+        .boolean()
+        .default(false)
+        .describe('Also check events, focuses, decisions, history and AI areas for states, provinces and regions the map lacks, and state tags without a country.'),
+    layer: mapLayerSchema
+        .optional()
+        .describe('Render this base layer instead of validating; combine with overlays, tile or area.'),
+    overlays: z.array(mapOverlaySchema).max(12).optional(),
+    scale: z.number().int().min(1).max(16).optional(),
+    tile: mapTileSchema.optional().describe('Render one top-left bitmap area.'),
+    area: mapAreaSchema
+        .optional()
+        .describe('Render the bounding area of these provinces, states or regions.'),
 })
-    .strict();
+    .strict()
+    .superRefine((value, context) => {
+    if (value.tile !== undefined && value.area !== undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['area'],
+            message: 'Choose tile or area, not both',
+        });
+    if (!MAP_VIEW_FIELDS.some((field) => value[field] !== undefined))
+        return;
+    for (const field of MAP_LOOKUP_FIELDS) {
+        const fieldValue = value[field];
+        if (fieldValue !== undefined && !(Array.isArray(fieldValue) && fieldValue.length === 0))
+            context.addIssue({
+                code: 'custom',
+                path: [field],
+                message: `${field} is a lookup; request a rendered view (layer, overlays, tile, area, scale) in a separate call`,
+            });
+    }
+});
+/** Internal render request derived from a map inspection that names a view. */
 export const mapRenderRequestSchema = z
     .object({
     workspaceId: workspaceIdSchema,
     layer: mapLayerSchema.optional(),
     overlays: z.array(mapOverlaySchema).max(12).optional(),
     scale: z.number().int().min(1).max(16).optional(),
-    tile: z
-        .object({
-        x: z.number().int().min(0),
-        y: z.number().int().min(0),
-        width: z.number().int().min(1).max(2_048),
-        height: z.number().int().min(1).max(2_048),
-    })
-        .strict()
-        .optional(),
-    area: z
-        .object({
-        provinceIds: z.array(z.number().int().nonnegative()).max(256).optional(),
-        stateIds: z.array(z.number().int().nonnegative()).max(64).optional(),
-        regionIds: z.array(z.number().int().nonnegative()).max(64).optional(),
-        padding: z.number().int().min(0).max(256).optional(),
-    })
-        .strict()
-        .refine(({ provinceIds, stateIds, regionIds }) => (provinceIds?.length ?? 0) + (stateIds?.length ?? 0) + (regionIds?.length ?? 0) > 0, 'Map area requires at least one province, state, or region ID')
-        .optional(),
+    tile: mapTileSchema.optional(),
+    area: mapAreaSchema.optional(),
 })
     .strict()
     .refine(({ tile, area }) => tile === undefined || area === undefined, 'Choose tile or area, not both');

package/dist/hoi4_agent_tools/schemas/map.js

@@ -20,7 +20,7 @@ const operationBase = {
 };
 const moveStateDistributionSchema = z
     .object({
-    stateValues: z.literal('retain-in-current-states'),
+    stateValues: z.enum(['retain-in-current-states', 'proportional-by-land-pixels']),
     ownership: z.literal('retain-in-current-states'),
     provinceBuildings: z.literal('follow-province'),
     victoryPoints: z.literal('follow-province'),
@@ -276,6 +276,7 @@ const splitStateOperation = (kind) => z
     fileName: z.string().max(255).optional(),
     localisation: stateLocalisationSchema.optional(),
     distribution: splitStateDistributionSchema,
+    remapReferences: z.enum(['refuse', 'override']).optional(),
 })
     .strict();
 const createStateOperation = z
@@ -290,6 +291,7 @@ const createStateOperation = z
     fileName: z.string().max(255).optional(),
     localisation: stateLocalisationSchema.optional(),
     distribution: z.union([z.literal('proportional'), splitStateDistributionSchema]).optional(),
+    remapReferences: z.enum(['refuse', 'override']).optional(),
 })
     .strict()
     .refine((value) => value.name !== undefined || value.displayName !== undefined, {
@@ -329,7 +331,7 @@ export const mapOperationSchema = z.discriminatedUnion('kind', [
         sourceStateId: stateId,
         targetStateId: stateId,
         provinceIds: z.array(provinceId).min(1).max(100_000),
-        distribution: moveStateDistributionSchema,
+        distribution: z.union([z.literal('proportional'), moveStateDistributionSchema]).optional(),
     })
         .strict(),
     z
@@ -408,7 +410,22 @@ export const mapOperationSchema = z.discriminatedUnion('kind', [
         kind: z.literal('merge_states'),
         sourceStateIds: z.array(stateId).min(1).max(100_000),
         targetStateId: stateId,
-        distribution: mergeStateDistributionSchema,
+        // Every merge policy has one allowed value, so the whole object may be omitted.
+        distribution: mergeStateDistributionSchema.default({
+            stateValues: 'sum-into-target',
+            ownership: 'retain-target',
+            controller: 'retain-target',
+            cores: 'union',
+            claims: 'union',
+            victoryPoints: 'follow-province',
+            provinceBuildings: 'follow-province',
+            ports: 'follow-province',
+            supplyNodes: 'follow-province',
+            railways: 'follow-province',
+            positions: 'follow-province',
+            strategicRegion: 'require-same',
+        }),
+        remapReferences: z.enum(['refuse', 'override']).optional(),
     })
         .strict(),
     splitProvinceOperation('split_province'),
@@ -452,6 +469,108 @@ export const mapOperationSchema = z.discriminatedUnion('kind', [
         distribution: z.literal('move-membership'),
     })
         .strict(),
+    z
+        .object({
+        ...operationBase,
+        kind: z.literal('create_world'),
+        width: z.number().int().min(256).max(8_192).multipleOf(256).default(1_024),
+        height: z.number().int().min(256).max(4_096).multipleOf(256).default(512),
+        seed: z.number().int().min(0).max(2_147_483_647).default(1),
+        landCoverage: z.number().min(0.05).max(0.9).default(0.35),
+        continents: z.number().int().min(1).max(12).default(3),
+        landPolygons: z
+            .array(z.array(pointSchema).min(3).max(10_000))
+            .max(64)
+            .optional()
+            .describe('Land outlines in top-left pixel coordinates; omit for generated continents.'),
+        landProvincePixels: z.number().int().min(60).max(50_000).default(400),
+        seaProvincePixels: z.number().int().min(200).max(200_000).default(2_500),
+        provincesPerState: z.number().int().min(1).max(64).default(5),
+        landProvincesPerRegion: z.number().int().min(2).max(400).default(25),
+        seaProvincesPerRegion: z.number().int().min(1).max(200).default(10),
+        countries: z
+            .array(z
+            .object({
+            tag: z.string().regex(/^[A-Z][A-Z0-9]{2}$/u),
+            name: z.string().min(1).max(64),
+            adjective: z.string().min(1).max(64).optional(),
+            color: rgbSchema.optional(),
+            share: z.number().min(0.05).max(100).optional(),
+            ideology: z.enum(['democratic', 'communism', 'fascism', 'neutrality']).optional(),
+        })
+            .strict())
+            .min(1)
+            .max(200),
+        continentNames: z.array(z.string().min(1).max(64)).max(12).optional(),
+        startDate: z
+            .string()
+            .regex(/^\d{3,4}\.\d{1,2}\.\d{1,2}$/u)
+            .default('1936.1.1'),
+        rivers: z.number().int().min(0).max(500).default(8),
+        replaceBaseGame: z
+            .boolean()
+            .default(true)
+            .describe('Add replace_path for the base game states, countries, units, strategic regions, supply areas and bookmarks to descriptor.mod.'),
+    })
+        .strict(),
+    z
+        .object({
+        ...operationBase,
+        kind: z.literal('remap_map_references'),
+        entity: z.enum(['province', 'state', 'strategic-region']),
+        mapping: z
+            .array(z
+            .object({
+            from: z.number().int().min(0),
+            to: z
+                .union([
+                z.number().int().min(0),
+                z.array(z.number().int().min(0)).min(1).max(16),
+                z.null(),
+            ])
+                .describe('One ID replaces; several IDs copy the referencing assignment once per ID; null removes it.'),
+        })
+            .strict())
+            .min(1)
+            .max(1_000),
+        readOnlySources: z
+            .enum(['refuse', 'override'])
+            .default('refuse')
+            .describe('override copies game or dependency files that need the change into the mod.'),
+        pathPrefixes: z.array(z.string().min(1).max(256)).max(32).optional(),
+    })
+        .strict(),
+    z
+        .object({
+        ...operationBase,
+        kind: z.literal('regenerate_map_positions'),
+        positions: z
+            .array(z.enum(['buildings', 'units', 'weather']))
+            .min(1)
+            .max(3)
+            .default(['buildings', 'units', 'weather']),
+        stateIds: z.array(stateId).max(10_000).optional(),
+        provinceIds: z.array(provinceId).max(100_000).optional(),
+        regionIds: z.array(z.number().int().positive()).max(10_000).optional(),
+        mode: z
+            .enum(['missing', 'replace'])
+            .default('missing')
+            .describe('missing adds only absent positions; replace rewrites them for the selection.'),
+    })
+        .strict(),
+    z
+        .object({
+        ...operationBase,
+        kind: z.literal('rebuild_supply'),
+        stateIds: z.array(stateId).max(10_000).optional(),
+        mode: z
+            .enum(['connect', 'replace'])
+            .default('connect')
+            .describe('connect adds a supply node to each selected state without one and links unconnected nodes by railway; replace rebuilds the whole network.'),
+        railwayLevel: z.number().int().min(1).max(5).default(1),
+        capitalRailwayLevel: z.number().int().min(1).max(5).default(3),
+    })
+        .strict(),
     z
         .object({
         ...operationBase,

package/dist/hoi4_agent_tools/schemas/mod-tools.js

@@ -0,0 +1,181 @@
+import { z } from 'zod/v4';
+import { workspaceIdSchema } from './common.js';
+export const errorLogCategorySchema = z.enum([
+    'syntax',
+    'duplicate',
+    'localisation',
+    'effect',
+    'trigger',
+    'scope',
+    'graphics',
+    'interface',
+    'map',
+    'missing_reference',
+    'other',
+]);
+export const errorLogRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    /** mod: entries located in the mod's own files; unlocated: entries naming no file. */
+    scope: z.enum(['all', 'mod', 'unlocated']).default('all'),
+    category: errorLogCategorySchema.optional(),
+    query: z.string().min(1).max(200).optional(),
+    limit: z.number().int().min(1).max(50).default(20),
+    offset: z.number().int().min(0).max(1_000_000).default(0),
+})
+    .strict();
+export const errorLogDataSchema = z
+    .object({
+    log: z
+        .object({
+        path: z.string().max(64),
+        modifiedAt: z.string().max(64),
+        bytes: z.number().int().min(0),
+        truncated: z.boolean(),
+        entries: z.number().int().min(0),
+    })
+        .strict(),
+    scope: z.enum(['all', 'mod', 'unlocated']),
+    totalEntries: z.number().int().min(0),
+    distinctEntries: z.number().int().min(0),
+    modEntries: z.number().int().min(0),
+    changedSinceLog: z.number().int().min(0),
+    categories: z.array(z
+        .object({
+        category: errorLogCategorySchema,
+        entries: z.number().int().min(0),
+        distinct: z.number().int().min(0),
+        hint: z.string().max(300),
+    })
+        .strict()),
+    /** Messages that differ only in names, numbers and paths, grouped by their shape. */
+    patterns: z
+        .array(z
+        .object({
+        pattern: z.string().max(300),
+        category: errorLogCategorySchema,
+        distinct: z.number().int().min(0),
+        entries: z.number().int().min(0),
+        example: z.string().max(600),
+    })
+        .strict())
+        .max(8),
+    /** Compared with the previous launch's log this server read, when there was one. */
+    sinceLastLaunch: z
+        .object({
+        previousLogAt: z.string().max(64),
+        newEntries: z.number().int().min(0),
+        persistingEntries: z.number().int().min(0),
+        resolvedEntries: z.number().int().min(0),
+        resolvedExamples: z
+            .array(z
+            .object({
+            category: errorLogCategorySchema,
+            message: z.string().max(300),
+            relativePath: z.string().max(1024).optional(),
+        })
+            .strict())
+            .max(5),
+    })
+        .strict()
+        .optional(),
+    entries: z
+        .array(z
+        .object({
+        category: errorLogCategorySchema,
+        module: z.string().max(128),
+        message: z.string().max(600),
+        count: z.number().int().min(1),
+        firstLogLine: z.number().int().min(1),
+        time: z.string().max(16).optional(),
+        /** Absent from the previous launch's log. */
+        new: z.boolean().optional(),
+        /** A reviewed known mistake this message reports, with its documented fix. */
+        knownMistake: z
+            .object({ id: z.string().max(64), fix: z.string().max(300) })
+            .strict()
+            .optional(),
+        source: z
+            .object({
+            relativePath: z.string().max(1024),
+            line: z.number().int().min(0).optional(),
+            layer: z.enum(['mod', 'dependency', 'game', 'unknown']),
+            changedSinceLog: z.boolean(),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict())
+        .max(50),
+    offset: z.number().int().min(0),
+    nextOffset: z.number().int().min(0).optional(),
+})
+    .strict();
+export const modIndexRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    mode: z.enum(['overview', 'next_id']).default('overview'),
+    /** overview: the mod's own files, or every layer. */
+    layer: z.enum(['mod', 'all']).default('mod'),
+    /** next_id: the symbol kind whose numbered identifiers are counted. */
+    kind: z.enum(['event', 'focus', 'decision', 'idea', 'leader', 'technology']).default('event'),
+    prefix: z.string().min(1).max(256).optional(),
+    namespace: z.string().min(1).max(256).optional(),
+})
+    .strict();
+export const modIndexDataSchema = z
+    .object({
+    mode: z.enum(['overview', 'next_id']),
+    complete: z.boolean(),
+    layer: z.enum(['mod', 'all']).optional(),
+    /** The mod's descriptor.mod metadata. */
+    descriptor: z
+        .object({
+        name: z.string().max(256).optional(),
+        version: z.string().max(256).optional(),
+        supportedVersion: z.string().max(256).optional(),
+        remoteFileId: z.string().max(256).optional(),
+        tags: z.array(z.string().max(256)).max(64),
+        dependencies: z.array(z.string().max(256)).max(64),
+        replacePaths: z.array(z.string().max(256)).max(64),
+    })
+        .strict()
+        .optional(),
+    files: z.number().int().min(0).optional(),
+    kinds: z
+        .array(z.object({ kind: z.string().max(64), count: z.number().int().min(0) }).strict())
+        .optional(),
+    folders: z
+        .array(z
+        .object({
+        folder: z.string().max(256),
+        files: z.number().int().min(0),
+        bytes: z.number().int().min(0),
+    })
+        .strict())
+        .optional(),
+    namespaces: z
+        .array(z
+        .object({
+        namespace: z.string().max(256),
+        events: z.number().int().min(0),
+        lowest: z.number().int().min(0),
+        highest: z.number().int().min(0),
+        files: z.number().int().min(0),
+    })
+        .strict())
+        .optional(),
+    omittedNamespaces: z.number().int().min(0).optional(),
+    next: z
+        .object({
+        kind: z.string().max(64),
+        prefix: z.string().max(256),
+        used: z.number().int().min(0),
+        highest: z.number().int().min(0).optional(),
+        nextId: z.string().max(300),
+        firstGapId: z.string().max(300).optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();

package/dist/hoi4_agent_tools/schemas/probability-requests.js

@@ -5,7 +5,7 @@ function compact(schema, description) {
     return z.unknown().describe(description).pipe(schema);
 }
 const nestedSource = compact(probabilitySourceSchema, 'Source selector; snapshotPath binds frozen bytes to path with expectedSourceHash.');
-const nestedScenarios = compact(probabilityScenarioSetSchema, 'Explicit world-state scenarios.');
+const nestedScenarios = compact(probabilityScenarioSetSchema, 'World-state facts: { id, scenarios: [{ id, actor?, date?, state: { "path": value }, flags?: [names] }] }. Missing ids get defaults; a bare scenario array is accepted.');
 const nestedManifest = compact(customWeightedPoolManifestSchema, 'Declared custom weighted pool and state transitions.');
 const nestedRenderFilter = compact(probabilityRenderFilterSchema, 'Optional scenario, candidate, metric, diagnostic, source, and page filter.');
 const nestedAcceptanceBands = compact(z.array(probabilityAcceptanceBandSchema).max(100_000), 'Optional named metric acceptance bands.');
@@ -24,26 +24,37 @@ const commonShape = {
     outputs,
     refresh: z.boolean().optional(),
 };
+const evaluationShape = {
+    scenarioSet: nestedScenarios.optional(),
+    horizonDays: z.number().positive().max(1_000_000).optional(),
+    metrics: z.array(probabilityMetricSchema).min(1).max(4).optional(),
+    acceptanceBands: nestedAcceptanceBands.optional(),
+    diagnosticThresholds: nestedDiagnosticThresholds.optional(),
+    outputs,
+};
+/**
+ * One call finds the weighted source and, when a single surface matches, evaluates it.
+ * Without a scenarioSet the evaluation uses one fact-free scenario, so the result shows base
+ * weights and the facts each condition still needs.
+ */
 export const probabilityInspectRequestSchema = z
     .object({
     workspaceId: workspaceIdSchema,
     adapter: probabilityAdapterIdSchema.optional(),
     source: nestedSource.optional(),
     customPoolManifest: nestedManifest.optional(),
-    candidatePool,
+    candidatePool: candidatePool.describe('Candidate IDs; an event ID selects all of its options, a decision ID finds its file.'),
+    evaluate: z
+        .boolean()
+        .optional()
+        .describe('Default true: evaluate the matched surface. False returns only the inventory.'),
+    ...evaluationShape,
     refresh: z.boolean().optional(),
 })
     .strict()
     .superRefine((value, context) => {
     if (value.source !== undefined && value.customPoolManifest !== undefined)
         context.addIssue({ code: 'custom', message: 'Provide either source or customPoolManifest' });
-    if (value.adapter !== undefined &&
-        value.source === undefined &&
-        value.customPoolManifest === undefined)
-        context.addIssue({
-            code: 'custom',
-            message: 'An adapter requires a source; provide a source alone to discover compatible adapters',
-        });
     if (value.customPoolManifest !== undefined &&
         value.adapter !== undefined &&
         value.adapter !== 'custom_weighted_pool')
@@ -52,6 +63,15 @@ export const probabilityInspectRequestSchema = z
             path: ['adapter'],
             message: 'customPoolManifest requires adapter custom_weighted_pool',
         });
+    if (value.source === undefined &&
+        value.customPoolManifest === undefined &&
+        (value.candidatePool?.length ?? 0) === 0 &&
+        value.adapter !== undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['source'],
+            message: 'Name what to inspect: source.path, source.identifier, or candidatePool IDs such as a decision or event ID',
+        });
 });
 export const probabilityEvaluateRequestSchema = z
     .object({
@@ -166,3 +186,93 @@ export const probabilityRenderRequestSchema = z
     filter: nestedRenderFilter.optional(),
 })
     .strict();
+export const probabilityAnalysisKindSchema = z.enum([
+    'compare',
+    'sweep',
+    'simulate',
+    'sequence',
+    'render',
+]);
+const analysisVariants = {
+    compare: probabilityCompareRequestSchema,
+    sweep: probabilitySweepRequestSchema,
+    simulate: probabilitySimulateRequestSchema,
+    sequence: probabilitySequenceRequestSchema,
+    render: probabilityRenderRequestSchema,
+};
+/**
+ * Deeper weighted analysis behind one tool. The listed schema is the flat union of every
+ * analysis's fields; each request is validated against the schema of its own analysis.
+ */
+export const probabilityAnalyzeRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    analysis: probabilityAnalysisKindSchema.describe('compare: before/after source or manifests; sweep: input ranges; simulate: sampled uncertainty; sequence: declared pool over time; render: images for a retained analysisId.'),
+    adapter: probabilityAdapterIdSchema.optional(),
+    source: nestedSource.optional(),
+    before: nestedSource.optional(),
+    after: nestedSource.optional(),
+    beforeManifest: nestedManifest.optional(),
+    afterManifest: nestedManifest.optional(),
+    customPoolManifest: nestedManifest.optional(),
+    scenarioSet: nestedScenarios.optional(),
+    candidatePool,
+    horizonDays: z.number().positive().max(1_000_000).optional(),
+    metrics: z.array(probabilityMetricSchema).min(1).max(4).optional(),
+    acceptanceBands: nestedAcceptanceBands.optional(),
+    diagnosticThresholds: nestedDiagnosticThresholds.optional(),
+    outputs,
+    sweep: z
+        .object({
+        paths: z.array(z.string().min(1).max(1024)).min(1).max(32),
+        steps: z.number().int().min(2).max(10_000).optional(),
+        pairwise: z.boolean().optional(),
+        findRankReversals: z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
+    samples: z.number().int().min(100).max(10_000_000).optional(),
+    seed: z.number().int().min(-2_147_483_648).max(2_147_483_647).optional(),
+    confidenceLevel: z.number().min(0.5).max(0.9999).optional(),
+    samplingMethod: probabilitySamplingMethodSchema.optional(),
+    maxSteps: z.number().int().min(1).max(100_000).optional(),
+    analysisId: z.string().min(1).max(256).optional(),
+    expectedScenarioHash: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional(),
+    includeHtml: z.boolean().optional(),
+    filter: nestedRenderFilter.optional(),
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const { analysis, ...rest } = value;
+    const parsed = analysisVariants[analysis].safeParse(rest);
+    if (parsed.success)
+        return;
+    for (const issue of parsed.error.issues)
+        context.addIssue({
+            code: 'custom',
+            path: issue.path,
+            message: issue.code === 'unrecognized_keys'
+                ? `${issue.message} (not used by analysis ${analysis})`
+                : issue.message,
+        });
+});
+/** Split one analyze request into its analysis kind and that analysis's own request. */
+export function splitProbabilityAnalyzeRequest(input) {
+    const { analysis, ...rest } = probabilityAnalyzeRequestSchema.parse(input);
+    switch (analysis) {
+        case 'compare':
+            return { analysis, request: probabilityCompareRequestSchema.parse(rest) };
+        case 'sweep':
+            return { analysis, request: probabilitySweepRequestSchema.parse(rest) };
+        case 'simulate':
+            return { analysis, request: probabilitySimulateRequestSchema.parse(rest) };
+        case 'sequence':
+            return { analysis, request: probabilitySequenceRequestSchema.parse(rest) };
+        case 'render':
+            return { analysis, request: probabilityRenderRequestSchema.parse(rest) };
+    }
+}

package/dist/hoi4_agent_tools/schemas/reference.js

@@ -171,6 +171,19 @@ export const referenceContextDataSchema = z
     missing: z.array(z.string().max(256)).max(32),
     coverage: coverageBySource,
     skipped: count,
+    /**
+     * Reviewed mistakes for this surface that `hoi4.script_validate` flags in a checked file,
+     * each with its fix; the cited wiki heading is in the rule list the server ships.
+     */
+    knownMistakes: z
+        .array(z
+        .object({
+        id: z.string().max(64),
+        title: z.string().max(120),
+        fix: z.string().max(300),
+    })
+        .strict())
+        .max(16),
 })
     .strict();
 export const sourceLookupDataSchema = z

package/dist/hoi4_agent_tools/schemas/scenarios.js

@@ -167,14 +167,12 @@ const readOnlySuiteTool = z.enum([
     'hoi4.tech_inspect',
     'hoi4.tech_render',
     'hoi4.probability_inspect',
-    'hoi4.probability_evaluate',
-    'hoi4.probability_render',
+    'hoi4.probability_analyze',
     'hoi4.focus_inspect',
     'hoi4.focus_render',
     'hoi4.gui_inspect',
     'hoi4.gui_render',
     'hoi4.map_inspect',
-    'hoi4.map_render',
 ]);
 const suiteCaseMetadata = {
     sourceSelectors: z.array(manifestItem).max(64).default([]),