hoi4-agent-tools 3.10.0 → 4.0.1

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([]),

package/dist/hoi4_agent_tools/schemas/script-validation.js

@@ -18,7 +18,7 @@ const scope = z.enum([
 export const scriptValidateRequestSchema = z
     .object({
     workspaceId: workspaceIdSchema,
-    /** Snippet mode: an effect or trigger body checked under `kind` and `scope`. */
+    /** Snippet mode: an effect or trigger body checked under `scope`; a missing `kind` is inferred. */
     source: z.string().min(1).max(64_000).optional(),
     /** File mode: a scanned mod file whose blocks are checked under the scope its structure fixes. */
     path: z.string().trim().min(1).max(4096).optional(),
@@ -39,11 +39,11 @@ export const scriptValidateRequestSchema = z
             path: ['source'],
             message: 'Provide either source with kind and scope, or a mod file path',
         });
-    if (value.source !== undefined && (value.kind === undefined || value.scope === undefined))
+    if (value.source !== undefined && value.scope === undefined)
         context.addIssue({
             code: 'custom',
-            path: ['kind'],
-            message: 'A snippet check requires kind and scope',
+            path: ['scope'],
+            message: 'A snippet check requires a scope, such as country or state',
         });
     if (value.path !== undefined &&
         (value.kind !== undefined || value.scope !== undefined || value.bindings.length > 0))
@@ -56,7 +56,14 @@ export const scriptValidateRequestSchema = z
 export const scriptValidateDataSchema = z
     .object({
     valid: z.boolean().nullable(),
-    checksPerformed: z.array(z.enum(['syntax', 'command_kind', 'declared_scope', 'player_text', 'event_popups'])),
+    checksPerformed: z.array(z.enum([
+        'syntax',
+        'command_kind',
+        'declared_scope',
+        'player_text',
+        'event_popups',
+        'known_mistakes',
+    ])),
     parametersChecked: z.literal(false),
     documentation: z
         .object({
@@ -73,7 +80,7 @@ export const scriptValidateDataSchema = z
         code: z.string().max(80),
         status: z.enum(['supported', 'error', 'unresolved', 'warning']),
         command: z.string().max(256),
-        kind: z.enum(['effect', 'trigger', 'text']),
+        kind: z.enum(['effect', 'trigger', 'text', 'definition']),
         scope: z.string().max(64),
         line: z.number().int().min(1),
         column: z.number().int().min(1),

package/dist/hoi4_agent_tools/schemas/technology.js

@@ -102,27 +102,6 @@ export function validateTechnologyInspectRequest(value, context) {
             message: 'Impact mode requires impact',
         });
 }
-export const technologyInspectRequestSchema = z
-    .object({
-    workspaceId: workspaceIdSchema,
-    mode: technologyAnalysisModeSchema,
-    folderId: technologyIdSchema.optional(),
-    technologyId: technologyIdSchema.optional(),
-    categoryId: technologyIdSchema.optional(),
-    targetKind: technologyUnlockKindSchema.optional(),
-    targetId: technologyIdSchema.optional(),
-    direction: technologyDirectionSchema.optional(),
-    maxDepth: z.number().int().min(1).max(256).optional(),
-    maxNodes: z.number().int().min(1).max(25_000).optional(),
-    includeSubTechnologies: z.boolean().optional(),
-    classifications: z.array(technologyDefectClassSchema).max(4).optional(),
-    codes: z.array(z.string().min(1).max(256)).max(100).optional(),
-    impact: technologyImpactSchema.optional(),
-    helperExpansion: helperExpansionRequestSchema.optional(),
-    refresh: z.boolean().optional(),
-})
-    .strict()
-    .superRefine(validateTechnologyInspectRequest);
 export const technologyRenderRequestSchema = z
     .object({
     workspaceId: workspaceIdSchema,
@@ -173,3 +152,82 @@ export const technologyCompareRequestSchema = z
 })
     .strict()
     .superRefine(validateTechnologyCompareRequest);
+export const technologyInspectToolModeSchema = z.enum([
+    ...technologyAnalysisModeSchema.options,
+    'compare',
+]);
+const technologyCompareOnlyFields = [
+    'before',
+    'after',
+    'proposedSources',
+    'render',
+    'maxRenderNodes',
+];
+const technologyInspectOnlyFields = [
+    'folderId',
+    'technologyId',
+    'categoryId',
+    'targetKind',
+    'targetId',
+    'direction',
+    'maxDepth',
+    'maxNodes',
+    'includeSubTechnologies',
+    'classifications',
+    'codes',
+    'impact',
+    'helperExpansion',
+];
+/** Inspection and graph comparison share one tool; mode compare selects the comparison. */
+export const technologyInspectRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    mode: technologyInspectToolModeSchema,
+    folderId: technologyIdSchema.optional(),
+    technologyId: technologyIdSchema.optional(),
+    categoryId: technologyIdSchema.optional(),
+    targetKind: technologyUnlockKindSchema.optional(),
+    targetId: technologyIdSchema.optional(),
+    direction: technologyDirectionSchema.optional(),
+    maxDepth: z.number().int().min(1).max(256).optional(),
+    maxNodes: z.number().int().min(1).max(25_000).optional(),
+    includeSubTechnologies: z.boolean().optional(),
+    classifications: z.array(technologyDefectClassSchema).max(4).optional(),
+    codes: z.array(z.string().min(1).max(256)).max(100).optional(),
+    impact: technologyImpactSchema.optional(),
+    helperExpansion: helperExpansionRequestSchema.optional(),
+    before: technologyGraphReferenceSchema.optional(),
+    after: technologyGraphReferenceSchema.optional(),
+    proposedSources: z.array(technologyProposedSourceSchema).min(1).max(128).optional(),
+    render: z.boolean().optional(),
+    maxRenderNodes: z.number().int().min(1).max(2_000).optional(),
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine(validateTechnologyInspectToolRequest);
+export function validateTechnologyInspectToolRequest(value, context) {
+    const compare = value.mode === 'compare';
+    for (const field of compare ? technologyInspectOnlyFields : technologyCompareOnlyFields)
+        if (value[field] !== undefined)
+            context.addIssue({
+                code: 'custom',
+                path: [field],
+                message: compare
+                    ? `${field} is not used by mode compare`
+                    : `${field} is used only by mode compare`,
+            });
+    if (compare)
+        validateTechnologyCompareRequest(value, context);
+    else
+        validateTechnologyInspectRequest(value, context);
+}
+/** Split an inspect request into a comparison or an analysis of the current graph. */
+export function splitTechnologyInspectRequest(input) {
+    if (input.mode !== 'compare')
+        return { compare: false, request: input };
+    const request = { workspaceId: input.workspaceId };
+    for (const field of [...technologyCompareOnlyFields, 'refresh'])
+        if (input[field] !== undefined)
+            request[field] = input[field];
+    return { compare: true, request: technologyCompareRequestSchema.parse(request) };
+}

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

@@ -2,8 +2,8 @@ import { z } from 'zod/v4';
 import { IdleCacheLifetime } from '../core/idle-cache-lifetime.js';
 import { errorResult, toolResult } from '../core/operation-result.js';
 import { ServiceError } from '../core/result.js';
-import { technologyCompareRequestSchema, technologyInspectRequestSchema, technologyRenderRequestSchema, } from '../schemas/technology.js';
-import { compareTechnologies, inspectTechnologies, normalizeTechnologyCompareRequest, normalizeTechnologyInspectionRequest, normalizeTechnologyRenderRequest, renderTechnologies, } from './operations.js';
+import { technologyInspectRequestSchema, technologyRenderRequestSchema, } from '../schemas/technology.js';
+import { inspectOrCompareTechnologies, normalizeTechnologyInspectionRequest, normalizeTechnologyRenderRequest, renderTechnologies, } from './operations.js';
 import { TechnologyTreeViewer } from './service.js';
 const wireResult = z.record(z.string(), z.json());
 /** Registers typed technology operations without invoking transport handlers. */
@@ -54,7 +54,6 @@ export function registerTechnologyJobs(operations, engine) {
             }
         });
     }
-    register('hoi4.tech_inspect', technologyInspectRequestSchema, normalizeTechnologyInspectionRequest, inspectTechnologies, 'Analyzing technology trees');
+    register('hoi4.tech_inspect', technologyInspectRequestSchema, normalizeTechnologyInspectionRequest, inspectOrCompareTechnologies, 'Analyzing technology trees');
     register('hoi4.tech_render', technologyRenderRequestSchema, normalizeTechnologyRenderRequest, renderTechnologies, 'Rendering technology-tree view');
-    register('hoi4.tech_compare', technologyCompareRequestSchema, normalizeTechnologyCompareRequest, compareTechnologies, 'Comparing technology-tree graphs');
 }

package/dist/hoi4_agent_tools/technology/operations.js

@@ -3,11 +3,24 @@ import { helperExpansionValidation } from '../core/helper-expansion.js';
 import { compareCodeUnits, hashCanonical } from '../core/canonical.js';
 import { emptyServiceResult } from '../core/result.js';
 import { setInlineFilesScanned } from '../core/operation-result.js';
-import { technologyCompareRequestSchema, technologyInspectRequestSchema, technologyRenderRequestSchema, } from '../schemas/technology.js';
+import { technologyCompareRequestSchema, technologyInspectRequestSchema, splitTechnologyInspectRequest, technologyRenderRequestSchema, } from '../schemas/technology.js';
 import { technologyDiagnostics } from './service.js';
 export function normalizeTechnologyInspectionRequest(input) {
     return JSON.parse(JSON.stringify(technologyInspectRequestSchema.parse(input)));
 }
+/** Route mode compare to the graph comparison and every other mode to analysis. */
+export function inspectOrCompareTechnologies(viewer, input) {
+    const split = splitTechnologyInspectRequest(input);
+    if (!split.compare)
+        return inspectTechnologies(viewer, input);
+    const { signal, principal } = input;
+    return compareTechnologies(viewer, {
+        ...JSON.parse(JSON.stringify(split.request)),
+        workspaceId: input.workspaceId,
+        ...(principal === undefined ? {} : { principal }),
+        ...(signal === undefined ? {} : { signal }),
+    });
+}
 export function normalizeTechnologyRenderRequest(input) {
     return JSON.parse(JSON.stringify(technologyRenderRequestSchema.parse(input)));
 }

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 = '3.10.0';
+export const PACKAGE_VERSION = '4.0.1';
 export const MCP_PROTOCOL_VERSION = LATEST_PROTOCOL_VERSION;
 export const CONFIG_VERSION = 1;
 export const TRANSACTION_VERSION = 1;

package/docs/README.md

@@ -16,21 +16,24 @@ You can ask your coding agent for these tasks in ordinary language; you do not n
 | Inspect or edit the map                              | [Maps](map.md)                            |
 | Compare weights, chances or timing                   | [AI and probability](probability.md)      |
 | Test a mechanic or check a content package           | [Mechanic tests](mechanics.md)            |
+| Read the game's error log or pick a free event ID    | [Local references](reference.md)          |
 
 ## See the results
 
 - [Examples](examples.md): practical prompts with real renders.
 - [Latest release](https://github.com/klimPaskov/hoi4-agent-tools/releases/latest): a short introduction to the published server.
-- [Focus and technology comparisons](visual-comparisons.md): supplied game captures beside source renders.
-- [Interface comparisons](gui-comparisons.md): vanilla and Chaos Redux windows.
+- [Focus and technology comparisons](https://github.com/klimPaskov/hoi4-agent-tools/blob/main/docs/visual-comparisons.md): supplied game captures beside source renders.
+- [Interface comparisons](https://github.com/klimPaskov/hoi4-agent-tools/blob/main/docs/gui-comparisons.md): vanilla and mod windows.
 
 ## Detailed reference
 
-- [Tool reference](tools.md): tool names and what each one does.
+- [Tool reference](tools.md): tool names, what each one does, and an example call for each.
+- [Troubleshooting](troubleshooting.md): error codes and what to do about them.
+- [Configuration](configuration.md): every setting, default location and environment variable.
 - [Background jobs](jobs.md): inspect, cancel or retrieve long operations.
 - [Large event and technology queries](helper-expansion.md): follow bounded results without losing coverage.
 - [Remote hosting](http.md): share the server over HTTP.
 - [Development](development.md): build, test and contribute.
-- [Architecture decisions](adr/README.md): implementation rationale for contributors.
+- [Architecture decisions](https://github.com/klimPaskov/hoi4-agent-tools/blob/main/docs/adr/README.md): implementation rationale for contributors.
 
 For vulnerability reporting, use the [security policy](../SECURITY.md).

package/docs/analysis.md

@@ -1,7 +1,7 @@
 # Cross-system impact and decisions
 
-`hoi4.impact_inspect` and `hoi4.decision_inspect` analyze authorized HOI4 source without changing it or running the game.
-Both tools return a compact result and a linked JSON report containing source locations, hashes, unresolved cases, and the full analysis.
+Find out why a decision is hidden or unavailable, and see what a script change affects elsewhere in the mod.
+`hoi4.impact_inspect` and `hoi4.decision_inspect` return a summary and a linked JSON report with source locations, hashes and unresolved cases.
 They support ordinary calls and persistent MCP tasks through stdio and HTTP.
 
 ## Cross-system impact
@@ -18,6 +18,19 @@ Use a symbol when you know the definition you plan to change:
 
 Use `changedFiles` with scanned display paths such as `mod:common/ideas/rationing.txt` to seed every active definition in a file.
 Use `proposedSources` to add, replace, or remove files in memory under the authorized mod root; a `null` content removes a source from the proposed snapshot.
+Each entry is an object with `relativePath` and `content`, and a request takes between 1 and 64 entries of at most 8 MiB each:
+
+```json
+{
+  "proposedSources": [
+    { "relativePath": "common/ideas/my_ideas.txt", "content": "ideas = { ... }" },
+    { "relativePath": "common/ideas/my_old_ideas.txt", "content": null }
+  ]
+}
+```
+
+Impact and decision proposals name the text field `content`.
+Event and technology proposals for `hoi4.event_inspect` and `hoi4.tech_inspect` with `mode: compare` name the same field `source` and also accept an optional `expectedSourceHash`.
 When `changedFiles` is omitted, each proposed file seeds all its active definitions alongside any selected symbols.
 The report compares the original and proposed consumer graph, including added and removed consumers and affected files.
 Moving a source location within one file does not count an unchanged reference as a new or removed consumer.