hoi4-agent-tools 2.1.1 → 2.3.0

package/dist/hoi4_agent_tools/core/source/ast-path.js

@@ -0,0 +1,41 @@
+const cachedPaths = new WeakMap();
+function indexBlock(block, path, output) {
+    output.set(block, path);
+    const occurrences = new Map();
+    for (const [index, entry] of block.entries.entries()) {
+        if (entry.type === 'assignment') {
+            const key = entry.key.value;
+            const occurrence = occurrences.get(key) ?? 0;
+            occurrences.set(key, occurrence + 1);
+            const entryPath = [...path, `${key}[${occurrence}]`];
+            output.set(entry, entryPath);
+            output.set(entry.key, [...entryPath, '$key']);
+            output.set(entry.value, entryPath);
+            if (entry.value.type === 'block')
+                indexBlock(entry.value, entryPath, output);
+            continue;
+        }
+        const entryPath = [...path, `#${entry.type}[${index}]`];
+        output.set(entry, entryPath);
+        if (entry.type === 'block')
+            indexBlock(entry, entryPath, output);
+    }
+}
+function pathsFor(document) {
+    const existing = cachedPaths.get(document);
+    if (existing !== undefined)
+        return existing;
+    const indexed = new WeakMap();
+    indexBlock(document.root, [], indexed);
+    cachedPaths.set(document, indexed);
+    return indexed;
+}
+/** Stable key-and-occurrence path for a node inside one parsed Clausewitz document. */
+export function astPathFor(document, node) {
+    const path = pathsFor(document).get(node);
+    return path === undefined ? undefined : [...path];
+}
+/** Test and diagnostic helper for callers that already hold a generic source entry. */
+export function sourceEntryAstPath(document, entry) {
+    return astPathFor(document, entry);
+}

package/dist/hoi4_agent_tools/core/source/index.js

@@ -1,4 +1,5 @@
 export * from './encoding.js';
+export * from './ast-path.js';
 export * from './lexer.js';
 export * from './limits.js';
 export * from './localisation.js';

package/dist/hoi4_agent_tools/event/limits.js

@@ -1,5 +1,5 @@
 import { ServiceError } from '../core/result.js';
-export const EVENT_GRAPH_MAX_NODES = 100_000;
+export const EVENT_GRAPH_MAX_NODES = 250_000;
 export const EVENT_GRAPH_MAX_EDGES = 500_000;
 export const EVENT_GRAPH_MAX_STATE_ACCESSES = 250_000;
 export const EVENT_GRAPH_MAX_STATE_LINKS = 250_000;

package/dist/hoi4_agent_tools/focus/render.js

@@ -143,6 +143,22 @@ function focusIconDataUri(focus, options) {
         ? undefined
         : (options.presentation?.icons[icon.sprite]?.dataUri ?? options.iconDataUris?.[icon.sprite]);
 }
+function focusTitleLayout(renderer, value, maximumWidth) {
+    const title = value.trim().replace(/\s+/gu, ' ');
+    if (renderer.measure(title, 11) <= maximumWidth)
+        return { lines: [title], fontSize: 11 };
+    const words = title.split(' ');
+    if (words.length < 2)
+        return { lines: [title], fontSize: 10 };
+    let best = { lines: [title], width: renderer.measure(title, 10) };
+    for (let index = 1; index < words.length; index += 1) {
+        const lines = [words.slice(0, index).join(' '), words.slice(index).join(' ')];
+        const width = Math.max(...lines.map((line) => renderer.measure(line, 10)));
+        if (width < best.width)
+            best = { lines, width };
+    }
+    return { lines: best.lines, fontSize: 10 };
+}
 function svgDocument(plan, layout, diagnostics, options) {
     const horizontal = options.horizontalSpacing ?? FOCUS_HORIZONTAL_GRID_PIXELS;
     const vertical = options.verticalSpacing ?? FOCUS_VERTICAL_GRID_PIXELS;
@@ -160,10 +176,10 @@ function svgDocument(plan, layout, diagnostics, options) {
     const nodeWidth = FOCUS_NODE_WIDTH_PIXELS;
     const nodeHeight = FOCUS_NODE_HEIGHT_PIXELS;
     const nodes = [...layout.nodes].sort((left, right) => compareCodeUnits(left.id, right.id));
-    const minimumX = Math.min(0, ...nodes.map(({ x }) => x));
-    const minimumY = Math.min(0, ...nodes.map(({ y }) => y));
-    const maximumX = Math.max(0, ...nodes.map(({ x }) => x));
-    const maximumY = Math.max(0, ...nodes.map(({ y }) => y));
+    const minimumX = nodes.length === 0 ? 0 : Math.min(...nodes.map(({ x }) => x));
+    const minimumY = nodes.length === 0 ? 0 : Math.min(...nodes.map(({ y }) => y));
+    const maximumX = nodes.length === 0 ? 0 : Math.max(...nodes.map(({ x }) => x));
+    const maximumY = nodes.length === 0 ? 0 : Math.max(...nodes.map(({ y }) => y));
     const logicalWidth = Math.max(320, (maximumX - minimumX) * horizontal + nodeWidth + padding * 2);
     const logicalHeight = Math.max(240, (maximumY - minimumY) * vertical + nodeHeight + padding * 2);
     const width = Math.max(1, Math.round(logicalWidth * outputScale));
@@ -268,6 +284,8 @@ function svgDocument(plan, layout, diagnostics, options) {
             .map(({ code }) => code)
             .sort()
             .join(' ');
+        const titleWidth = nodeWidth - 72;
+        const titleLayout = focusTitleLayout(toolText, title, titleWidth);
         parts.push(`<g class="focus-node ${escapeXml(focus.visibility)} ${severity}" id="focus-${escapeXml(node.id)}" data-focus-id="${escapeXml(node.id)}" data-branch="${escapeXml(focus.branchId ?? '')}" data-lane="${escapeXml(node.laneId)}" data-diagnostics="${escapeXml(diagnosticCodes)}" transform="translate(${point.x} ${point.y})" filter="url(#shadow)">`, `<title>${escapeXml(`${title} (${node.id}) at ${node.x},${node.y}`)}</title>`, `<rect width="${nodeWidth}" height="${nodeHeight}" rx="8" fill="${fill}" stroke="${stroke}" stroke-width="${severity === 'clean' ? 1.5 : 3}"/>`);
         if (iconUri !== undefined) {
             parts.push(`<image href="${escapeXml(iconUri)}" x="8" y="10" width="48" height="48" preserveAspectRatio="xMidYMid meet"/>`);
@@ -281,20 +299,26 @@ function svgDocument(plan, layout, diagnostics, options) {
                 fill: '#91a0b4',
             }));
         }
-        parts.push(toolText.render(title.slice(0, 18), {
-            x: 64,
-            y: 25,
-            fontSize: 12,
-            weight: 700,
-            fill: '#f2f5fa',
-        }), toolText.render(node.id.slice(0, 22), {
+        const titleY = titleLayout.lines.length === 1 ? 25 : 20;
+        for (const [index, line] of titleLayout.lines.entries()) {
+            const measuredWidth = toolText.measure(line, titleLayout.fontSize);
+            parts.push(toolText.render(line, {
+                x: 64,
+                y: titleY + index * 13,
+                fontSize: titleLayout.fontSize,
+                weight: 700,
+                fill: '#f2f5fa',
+                ...(measuredWidth <= titleWidth ? {} : { targetWidth: titleWidth }),
+            }));
+        }
+        parts.push(toolText.render(node.id.slice(0, 22), {
             x: 64,
-            y: 43,
+            y: 49,
             fontSize: 9,
             fill: '#aeb9c8',
         }), toolText.render(`(${node.x}, ${node.y}) · ${node.laneId}`, {
             x: 64,
-            y: 59,
+            y: 64,
             fontSize: 9,
             fill: '#8391a5',
         }), '</g>');

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

@@ -4,8 +4,10 @@ import { registerFocusTools } from '../tools/focus.js';
 import { registerGuiTools } from '../tools/gui.js';
 import { registerMapTools } from '../tools/map.js';
 import { registerEventTools } from '../tools/event.js';
+import { registerTechnologyTools } from '../tools/technology.js';
+import { registerProbabilityTools } from '../tools/probability.js';
 import { registerMcpResources } from '../resources/register.js';
-export const SERVER_INSTRUCTIONS = 'Use hoi4.focus_inspect and hoi4.focus_render for fast structural work; hoi4.focus_raster adds decoded icons and PNG output. Use hoi4.event_inspect to analyze event chains. Event tools are read-only. Focus, GUI, and map rewrite tools edit the current mod. Large evidence is returned through linked 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 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. Large evidence is linked as resources.';
 export function createMcpServer(engine, context = {}) {
     const server = new McpServer({
         name: PACKAGE_NAME,
@@ -19,6 +21,8 @@ export function createMcpServer(engine, context = {}) {
     registerGuiTools(server, engine, context);
     registerMapTools(server, engine, context);
     registerEventTools(server, engine, context);
+    registerTechnologyTools(server, engine, context);
+    registerProbabilityTools(server, engine, context);
     registerMcpResources(server, engine, context);
     return server;
 }

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

@@ -44,13 +44,13 @@ const compactPublicOperationResultSchema = z
     status: z.enum(['ok', 'blocked', 'error']),
     code: z.string(),
     workspaceId: z.string(),
-    filesScanned: z.array(z.unknown()).max(MAX_INLINE_FILES_SCANNED),
-    proposedFiles: z.array(z.unknown()).max(MAX_INLINE_PROPOSED_FILES),
-    changedFiles: z.array(z.unknown()).max(MAX_INLINE_CHANGED_FILES),
+    filesScanned: z.array(z.unknown()),
+    proposedFiles: z.array(z.unknown()),
+    changedFiles: z.array(z.unknown()),
     diagnostics: z.array(z.unknown()).max(MAX_INLINE_DIAGNOSTICS),
     artifacts: z.array(z.unknown()).max(MAX_INLINE_ARTIFACT_LINKS),
     validation: z.unknown(),
-    blockers: z.array(z.unknown()).max(MAX_INLINE_BLOCKERS),
+    blockers: z.array(z.unknown()),
     data: z.object({}).catchall(z.unknown()),
 })
     .strict();

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

@@ -1,6 +1,6 @@
 import { z } from 'zod/v4';
 import { boundedSourceHashEvidence, publicArtifactLink } from '../../core/artifacts.js';
-import { compareCodeUnits, canonicalJson } from '../../core/canonical.js';
+import { compareCodeUnits, canonicalJson, hashCanonical } from '../../core/canonical.js';
 import { RenderBudget } from '../../core/render-budget.js';
 import { emptyServiceResult, ServiceError } from '../../core/result.js';
 import { parseClausewitz } from '../../core/source/index.js';
@@ -116,6 +116,7 @@ const focusPlanOutputSchema = strictOperationResultSchema(z.discriminatedUnion('
         .strict(),
 ]));
 const compactFocusPlanSchema = compactValidatedInputSchema(z.union([focusTreePlanSchema, continuousFocusPaletteSchema]), `Complete focus plan: https://github.com/klimPaskov/hoi4-agent-tools/blob/v${PACKAGE_VERSION}/docs/focus.md`);
+const compactFocusLayoutSchema = compactValidatedInputSchema(focusLayoutSchema, 'Prior deterministic focus layout used to stabilize unchanged positions.');
 const focusInspectInput = z
     .object({
     mode: z.enum(['national', 'continuous']).optional(),
@@ -123,7 +124,7 @@ const focusInspectInput = z
     relativePath: workspaceRelativePathSchema.optional(),
     treeId: z.string().min(1).max(256).optional(),
     paletteId: z.string().min(1).max(256).optional(),
-    previous: focusLayoutSchema.optional(),
+    previous: compactFocusLayoutSchema.optional(),
     laneSpacing: z.number().int().min(1).max(100).optional(),
     nodeSpacing: z.number().int().min(1).max(100).optional(),
 })
@@ -307,6 +308,42 @@ const LARGE_FOCUS_RENDER_SCALE = 0.5;
 function automaticFocusRenderScale(focusCount) {
     return focusCount >= LARGE_FOCUS_RENDER_NODE_THRESHOLD ? LARGE_FOCUS_RENDER_SCALE : 1;
 }
+export async function computeFocusVisualRevisions(engine, context, workspaceId, snapshot, selectors, signal) {
+    const workspace = engine.resolver.get(workspaceId, context.principal);
+    const paletteImport = continuousPalettes(snapshot);
+    const revisions = [];
+    for (const selector of selectors) {
+        signal?.throwIfAborted();
+        const imported = importFocusFile(snapshot, selectedFocusFile(snapshot, workspace.registration.roots.focus, selector.relativePath), paletteImport.palettes);
+        const plan = selectPlan(imported, selector.treeId);
+        const linkedPalettes = paletteImport.palettes.filter(({ id }) => plan.continuousFocusPaletteIds.includes(id));
+        const presentation = await resolveFocusPresentation({
+            plans: [plan],
+            palettes: linkedPalettes,
+            files: snapshot.files,
+            index: snapshot.index,
+            scanner: engine.scanner,
+            workspace,
+            decodeIcons: false,
+            budget: new RenderBudget(),
+            ...(signal === undefined ? {} : { signal }),
+        });
+        const filesScanned = [
+            ...new Set([plan.provenance.sourcePath, ...presentation.filesScanned]),
+        ].sort(compareCodeUnits);
+        revisions.push({
+            relativePath: selector.relativePath,
+            treeId: plan.id,
+            revision: hashCanonical({
+                planHash: focusPlanHash(plan),
+                linkedPalettes,
+                presentationSourceHashes: presentation.sourceHashes,
+            }),
+            filesScanned,
+        });
+    }
+    return revisions;
+}
 async function executeFocusVisualTool(engine, workbench, context, input, extra, rasterize) {
     const { workspaceId: requestedWorkspaceId, relativePath } = input;
     const workspaceId = engine.resolver.resolveWorkspaceId(requestedWorkspaceId, context.principal);

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

@@ -0,0 +1,413 @@
+import { z } from 'zod/v4';
+import { emptyServiceResult } from '../../core/result.js';
+import { ProbabilityAnalyzer, } from '../../probability/service.js';
+import { customWeightedPoolManifestSchema, probabilityAcceptanceBandSchema, probabilityAdapterIdSchema, probabilityDiagnosticThresholdsSchema, probabilityMetricSchema, probabilityOutputSchema, probabilityRenderFilterSchema, probabilityScenarioSetSchema, probabilitySamplingMethodSchema, probabilitySourceSchema, } from '../../schemas/probability.js';
+import { workspaceIdSchema } from '../../schemas/common.js';
+import { compactValidatedInputSchema } from '../server/context-schemas.js';
+import { nonNegativeIntegerSchema, sha256Schema } from '../server/output-schemas.js';
+import { progressReporter } from '../server/progress.js';
+import { errorResult, setInlineFilesScanned, strictOperationResultSchema, toolResult, } from '../server/result.js';
+const nestedSource = compactValidatedInputSchema(probabilitySourceSchema, 'Source selector or proposed source.');
+const nestedScenarios = compactValidatedInputSchema(probabilityScenarioSetSchema, 'Explicit world-state scenarios.');
+const nestedManifest = compactValidatedInputSchema(customWeightedPoolManifestSchema, 'Declared custom weighted pool and state transitions.');
+const nestedRenderFilter = compactValidatedInputSchema(probabilityRenderFilterSchema, 'Optional scenario, candidate, metric, diagnostic, source, and page filter.');
+const nestedAcceptanceBands = compactValidatedInputSchema(z.array(probabilityAcceptanceBandSchema).max(100_000), 'Optional named metric acceptance bands.');
+const nestedDiagnosticThresholds = compactValidatedInputSchema(probabilityDiagnosticThresholdsSchema, 'Optional diagnostic thresholds.');
+const candidatePool = z.array(z.string().min(1).max(512)).max(100_000).optional();
+const outputs = z.array(probabilityOutputSchema).max(10).optional();
+const commonShape = {
+    workspaceId: workspaceIdSchema,
+    adapter: probabilityAdapterIdSchema,
+    source: nestedSource,
+    scenarioSet: nestedScenarios,
+    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,
+    refresh: z.boolean().optional(),
+};
+const inspectInput = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    adapter: probabilityAdapterIdSchema.optional(),
+    source: nestedSource.optional(),
+    candidatePool,
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if ((value.adapter === undefined) !== (value.source === undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'Provide adapter and source together, or omit both to list adapters',
+        });
+});
+const evaluateInput = z.object(commonShape).strict();
+const sweepInput = z
+    .object({
+    ...commonShape,
+    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).default(25),
+        pairwise: z.boolean().default(false),
+        findRankReversals: z.boolean().default(true),
+    })
+        .strict(),
+})
+    .strict();
+const simulateInput = z
+    .object({
+    ...commonShape,
+    samples: z.number().int().min(100).max(10_000_000).default(100_000),
+    seed: z.number().int().min(-2_147_483_648).max(2_147_483_647).default(1),
+    confidenceLevel: z.number().min(0.5).max(0.9999).default(0.95),
+    samplingMethod: probabilitySamplingMethodSchema.default('latin_hypercube'),
+})
+    .strict();
+const sequenceInput = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    scenarioSet: nestedScenarios,
+    customPoolManifest: nestedManifest,
+    horizonDays: z.number().positive().max(1_000_000),
+    maxSteps: z.number().int().min(1).max(100_000).default(1_000),
+    samples: z.number().int().min(100).max(10_000_000).default(100_000),
+    seed: z.number().int().min(-2_147_483_648).max(2_147_483_647).default(1),
+    confidenceLevel: z.number().min(0.5).max(0.9999).default(0.95),
+    acceptanceBands: nestedAcceptanceBands.optional(),
+    diagnosticThresholds: nestedDiagnosticThresholds.optional(),
+    outputs,
+})
+    .strict();
+const compareInput = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    adapter: probabilityAdapterIdSchema,
+    before: nestedSource,
+    after: nestedSource,
+    scenarioSet: nestedScenarios,
+    candidatePool,
+    horizonDays: z.number().positive().max(1_000_000).optional(),
+    acceptanceBands: nestedAcceptanceBands.optional(),
+    diagnosticThresholds: nestedDiagnosticThresholds.optional(),
+    outputs,
+    refresh: z.boolean().optional(),
+})
+    .strict();
+const renderInput = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    analysisId: z.string().min(1).max(256),
+    expectedScenarioHash: sha256Schema.optional(),
+    outputs: z.array(probabilityOutputSchema).min(1).max(10),
+    includeHtml: z.boolean().default(false),
+    filter: nestedRenderFilter.optional(),
+})
+    .strict();
+const analysisDataSchema = z
+    .object({
+    operation: z.enum(['evaluate', 'sweep', 'simulate', 'sequence', 'compare', 'render']),
+    analysisId: z.string().max(256),
+    analysisStatus: z.enum(['complete', 'partial', 'blocked', 'cancelled', 'stale']),
+    adapterId: z.string().max(256),
+    sourceRevision: sha256Schema,
+    sourceHash: sha256Schema,
+    scenarioHash: sha256Schema,
+    cacheKey: sha256Schema,
+    scenarios: nonNegativeIntegerSchema,
+    candidates: nonNegativeIntegerSchema,
+    unresolved: nonNegativeIntegerSchema,
+    diagnostics: nonNegativeIntegerSchema,
+    sweepPoints: nonNegativeIntegerSchema.optional(),
+    samples: nonNegativeIntegerSchema.optional(),
+    sequenceMethod: z
+        .enum(['exact_state_distribution', 'bounded_beam', 'seeded_monte_carlo'])
+        .optional(),
+    comparisonChanges: nonNegativeIntegerSchema.optional(),
+    visualResources: nonNegativeIntegerSchema.optional(),
+})
+    .strict();
+const inspectDataSchema = z
+    .object({
+    adapters: nonNegativeIntegerSchema,
+    adapterId: z.string().max(256).optional(),
+    sourceRevision: sha256Schema.optional(),
+    sourceHash: sha256Schema.optional(),
+    candidates: nonNegativeIntegerSchema,
+    poolComplete: z.boolean().optional(),
+    requiredInputs: nonNegativeIntegerSchema,
+    unresolved: nonNegativeIntegerSchema,
+})
+    .strict();
+const analysisOutput = strictOperationResultSchema(analysisDataSchema);
+const inspectOutput = strictOperationResultSchema(inspectDataSchema);
+const readOnly = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+function requestContext(engine, context, workspaceId, refresh, signal) {
+    return {
+        workspaceId: engine.resolver.resolveWorkspaceId(workspaceId, context.principal),
+        ...(context.principal === undefined ? {} : { principal: context.principal }),
+        ...(refresh === undefined ? {} : { refresh }),
+        signal,
+    };
+}
+function analysisData(result) {
+    return {
+        operation: result.operation,
+        analysisId: result.analysisId,
+        analysisStatus: result.status,
+        adapterId: result.adapter.id,
+        sourceRevision: result.metadata.sourceRevision,
+        sourceHash: result.metadata.sourceHash,
+        scenarioHash: result.metadata.scenarioHash,
+        cacheKey: result.metadata.cacheKey,
+        scenarios: result.scenarios.length,
+        candidates: result.scenarios.reduce((sum, scenario) => sum + scenario.candidates.length, 0),
+        unresolved: result.unresolved.length,
+        diagnostics: result.diagnostics.length,
+        ...(result.sweep === undefined ? {} : { sweepPoints: result.sweep.points.length }),
+        ...(result.metadata.samples === undefined ? {} : { samples: result.metadata.samples }),
+        ...(result.sequence === undefined ? {} : { sequenceMethod: result.sequence.method }),
+        ...(result.comparison === undefined
+            ? {}
+            : { comparisonChanges: result.comparison.scenarioChanges.length }),
+        visualResources: result.resources.filter(({ mimeType }) => mimeType.startsWith('image/'))
+            .length,
+    };
+}
+function analysisServiceResult(workspaceId, result) {
+    const output = emptyServiceResult(workspaceId, analysisData(result));
+    output.code =
+        result.status === 'complete'
+            ? 'PROBABILITY_ANALYZED'
+            : result.status === 'stale'
+                ? result.diagnostics.some(({ code }) => code === 'PROBABILITY_SCENARIO_STALE')
+                    ? 'PROBABILITY_SCENARIO_STALE'
+                    : 'PROBABILITY_ANALYSIS_STALE'
+                : 'PROBABILITY_ANALYZED_PARTIAL';
+    output.artifacts = result.resources;
+    output.diagnostics = result.diagnostics;
+    output.validation = {
+        passed: result.status !== 'blocked' && result.status !== 'cancelled',
+        checks: [
+            {
+                id: 'uncertainty-visible',
+                passed: true,
+                message: `${result.unresolved.length} unresolved or bounded analysis item(s) are explicit`,
+            },
+        ],
+    };
+    return output;
+}
+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.',
+        inputSchema: inspectInput,
+        outputSchema: inspectOutput,
+        annotations: readOnly,
+    }, async (input, extra) => {
+        const progress = progressReporter(extra);
+        const base = requestContext(engine, context, input.workspaceId, input.refresh, progress.signal);
+        try {
+            await progress.report(0, 2, 'Inspecting weighted source');
+            const inspected = await analyzer.inspect(base, input.adapter, input.source, input.candidatePool);
+            const result = emptyServiceResult(base.workspaceId, {
+                adapters: inspected.adapters.length,
+                ...(inspected.surface === undefined
+                    ? {}
+                    : {
+                        adapterId: inspected.surface.adapter.id,
+                        sourceRevision: inspected.surface.sourceRevision,
+                        sourceHash: inspected.surface.sourceHash,
+                        poolComplete: inspected.surface.poolComplete,
+                    }),
+                candidates: inspected.surface?.candidateCount ?? 0,
+                requiredInputs: inspected.surface?.requiredInputs.length ?? 0,
+                unresolved: inspected.surface?.unsupported.length ?? 0,
+            });
+            result.code =
+                inspected.surface === undefined
+                    ? 'PROBABILITY_ADAPTERS_LISTED'
+                    : 'PROBABILITY_SOURCE_INSPECTED';
+            result.artifacts = inspected.artifacts;
+            setInlineFilesScanned(result, inspected.filesScanned);
+            await progress.report(2, 2, 'Weighted source inspection complete');
+            return toolResult(result);
+        }
+        catch (error) {
+            return errorResult(error, base.workspaceId);
+        }
+    });
+    server.registerTool('hoi4.probability_evaluate', {
+        title: 'Evaluate AI and MTTH scenarios',
+        description: 'Evaluate eligibility, modifier traces, exact values, proven probabilities, MTTH timing, bounds, and unresolved inputs.',
+        inputSchema: evaluateInput,
+        outputSchema: analysisOutput,
+        annotations: readOnly,
+    }, async (input, extra) => {
+        const progress = progressReporter(extra);
+        const base = requestContext(engine, context, input.workspaceId, input.refresh, progress.signal);
+        try {
+            await progress.report(0, 3, 'Scanning and evaluating weighted source');
+            const request = {
+                ...base,
+                ...input,
+                workspaceId: base.workspaceId,
+            };
+            const analyzed = await analyzer.evaluate(request);
+            await progress.report(3, 3, 'Scenario evaluation complete');
+            return toolResult(analysisServiceResult(base.workspaceId, analyzed));
+        }
+        catch (error) {
+            return errorResult(error, base.workspaceId);
+        }
+    });
+    server.registerTool('hoi4.probability_sweep', {
+        title: 'Sweep AI and MTTH parameters',
+        description: 'Evaluate declared ranges, sensitivity, breakpoints, and rank reversals without inventing world state.',
+        inputSchema: sweepInput,
+        outputSchema: analysisOutput,
+        annotations: readOnly,
+    }, async (input, extra) => {
+        const progress = progressReporter(extra);
+        const base = requestContext(engine, context, input.workspaceId, input.refresh, progress.signal);
+        try {
+            await progress.report(0, 3, 'Evaluating parameter sweep');
+            const request = {
+                ...base,
+                ...input,
+                workspaceId: base.workspaceId,
+            };
+            const analyzed = await analyzer.sweep(request);
+            await progress.report(3, 3, 'Parameter sweep complete');
+            return toolResult(analysisServiceResult(base.workspaceId, analyzed));
+        }
+        catch (error) {
+            return errorResult(error, base.workspaceId);
+        }
+    });
+    server.registerTool('hoi4.probability_simulate', {
+        title: 'Simulate uncertain weighted scenarios',
+        description: 'Run reproducible seeded Monte Carlo analysis with distributions, supported correlations, and confidence intervals.',
+        inputSchema: simulateInput,
+        outputSchema: analysisOutput,
+        annotations: readOnly,
+    }, async (input, extra) => {
+        const progress = progressReporter(extra);
+        const base = requestContext(engine, context, input.workspaceId, input.refresh, progress.signal);
+        try {
+            await progress.report(0, input.samples, 'Sampling uncertain scenarios');
+            const request = {
+                ...base,
+                ...input,
+                workspaceId: base.workspaceId,
+            };
+            const analyzed = await analyzer.simulate(request);
+            await progress.report(input.samples, input.samples, 'Seeded simulation complete');
+            return toolResult(analysisServiceResult(base.workspaceId, analyzed));
+        }
+        catch (error) {
+            return errorResult(error, base.workspaceId);
+        }
+    });
+    server.registerTool('hoi4.probability_sequence', {
+        title: 'Analyze a declared weighted sequence',
+        description: 'Analyze only manifest-declared recovery, caps, cooldowns, removals, resets, timers, and terminal states.',
+        inputSchema: sequenceInput,
+        outputSchema: analysisOutput,
+        annotations: readOnly,
+    }, async (input, extra) => {
+        const progress = progressReporter(extra);
+        const base = requestContext(engine, context, input.workspaceId, undefined, progress.signal);
+        try {
+            await progress.report(0, input.maxSteps, 'Analyzing declared sequence');
+            const request = {
+                ...base,
+                ...input,
+                workspaceId: base.workspaceId,
+            };
+            const analyzed = await analyzer.sequence(request);
+            await progress.report(input.maxSteps, input.maxSteps, 'Sequence analysis complete');
+            return toolResult(analysisServiceResult(base.workspaceId, analyzed));
+        }
+        catch (error) {
+            return errorResult(error, base.workspaceId);
+        }
+    });
+    server.registerTool('hoi4.probability_compare', {
+        title: 'Compare weighted source patches',
+        description: 'Compare real or proposed source under identical scenarios with modifier, score, probability, timing, and rank attribution.',
+        inputSchema: compareInput,
+        outputSchema: analysisOutput,
+        annotations: readOnly,
+    }, async (input, extra) => {
+        const progress = progressReporter(extra);
+        const base = requestContext(engine, context, input.workspaceId, input.refresh, progress.signal);
+        try {
+            await progress.report(0, 4, 'Comparing weighted source');
+            const request = {
+                ...base,
+                ...input,
+                workspaceId: base.workspaceId,
+            };
+            const analyzed = await analyzer.compare(request);
+            await progress.report(4, 4, 'Weighted source comparison complete');
+            return toolResult(analysisServiceResult(base.workspaceId, analyzed));
+        }
+        catch (error) {
+            return errorResult(error, base.workspaceId);
+        }
+    });
+    server.registerTool('hoi4.probability_render', {
+        title: 'Render AI and MTTH analysis',
+        description: 'Render cached analysis data as deterministic ranking, matrix, waterfall, timing, sensitivity, sequence, comparison, or unresolved resources.',
+        inputSchema: renderInput,
+        outputSchema: analysisOutput,
+        annotations: readOnly,
+    }, async (input, extra) => {
+        const progress = progressReporter(extra);
+        const base = requestContext(engine, context, input.workspaceId, undefined, progress.signal);
+        try {
+            await progress.report(0, input.outputs.length, 'Rendering analysis resources');
+            const request = {
+                ...base,
+                ...input,
+                workspaceId: base.workspaceId,
+                outputs: input.outputs.filter((output) => output !== 'json'),
+            };
+            const analyzed = await analyzer.render(request);
+            await progress.report(input.outputs.length, input.outputs.length, 'Analysis rendering complete');
+            return toolResult(analysisServiceResult(base.workspaceId, analyzed));
+        }
+        catch (error) {
+            return errorResult(error, base.workspaceId);
+        }
+    });
+    server.registerPrompt('hoi4.probability_analysis', {
+        title: 'Analyze HOI4 weighted logic',
+        description: 'Plan one source-linked AI, MTTH, random, or declared-pool analysis and return to the owning modding workflow.',
+        argsSchema: {
+            objective: z.string().min(1).max(4096),
+            sourceHint: z.string().max(1024).optional(),
+        },
+    }, ({ objective, sourceHint }) => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Analyze this HOI4 weighted-logic task: ${objective}${sourceHint === undefined ? '' : `\nSource hint: ${sourceHint}`}\nIdentify the exact weighted surface and adapter, declare representative world-state scenarios and every required candidate or external factor, inspect first, run the narrowest useful evaluate/sweep/simulate/sequence/compare operation, review linked uncertainty and provenance, then return the findings to the normal owning modding workflow. Do not infer missing state, execute effects, or edit source through probability tools.`,
+                },
+            },
+        ],
+    }));
+}