hoi4-agent-tools 2.8.9 → 2.8.11

package/CHANGELOG.md

@@ -4,6 +4,19 @@
 
 No unreleased changes.
 
+## 2.8.11 - 2026-08-30
+
+- Render vanilla HOI4 bitmap fonts with their native atlas masks, legacy page fallbacks, inverted-mask handling, declared glyph channels, crisp scaled sampling, borders, and localisation colours; qualify every shipped descriptor and base font family.
+- Keep large event and technology workspaces complete by separating game and mod scans, accepting large legitimate Clausewitz sources, retaining large state-access inventories, and removing automatic focused-analysis fallbacks.
+- Inspect, evaluate, and compare complete declared dynamic weighted pools with scenario-resolved candidate weights, eligibility, exact probabilities, and complete candidate inventories.
+- Authenticate GitHub release-state API checks so release publication does not fail on anonymous API limits.
+
+## 2.8.10 - 2026-08-30
+
+- Fix vanilla BMFont corruption by following declared face and outline channel coverage directly instead of guessing polarity independently for each glyph.
+- Add full-word mixed-colour raster coverage and pixel-level face/outline mask checks for glyphs with very different filled areas.
+- Keep cross-process artifact admission stable when Windows temporarily locks an in-progress artifact file, and retain tool-discovery headroom for multi-digit patch versions.
+
 ## 2.8.9 - 2026-08-29
 
 - Decode BMFont channel roles so installed HOI4 atlases render their face and outline masks separately instead of losing localisation colours.

package/dist/hoi4_agent_tools/core/artifacts.js

@@ -380,16 +380,16 @@ async function artifactUsage(root, signal) {
                 throw new ServiceError('ARTIFACT_STORAGE_UNSAFE', 'Artifact storage contains a symbolic link or junction');
             }
             if (child.isFile() && child.name.startsWith(artifactTemporaryPrefix)) {
-                const temporary = await resolveListedPath(directory, child.name);
-                if (temporary === undefined)
-                    continue;
+                const temporary = path.join(directory, child.name);
                 try {
                     const metadata = await lstat(temporary);
+                    if (metadata.isSymbolicLink())
+                        throw new ServiceError('ARTIFACT_STORAGE_UNSAFE', 'Artifact storage contains a symbolic link or junction');
                     if (Date.now() - metadata.mtimeMs >= artifactDebrisMinimumAgeMs)
                         await unlink(temporary);
                 }
                 catch (error) {
-                    if (error.code !== 'ENOENT')
+                    if (!['ENOENT', 'EPERM'].includes(error.code ?? ''))
                         throw error;
                 }
                 continue;

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

@@ -1,12 +1,11 @@
 export const SOURCE_DIAGNOSTIC_LIMIT = 100;
 export const SOURCE_MAX_NESTING = 256;
-export const SOURCE_MAX_BYTES = 8_388_608;
-// Large authored HOI4 focus and scripted-effect files can exceed 250k tokens while remaining well
-// below the byte and nesting ceilings. Keep enough room for those files without allowing an
-// unbounded token inventory.
-export const SOURCE_TOKEN_LIMIT = 1_000_000;
-export const SOURCE_ENTRY_LIMIT = 100_000;
-export const SOURCE_LINE_LIMIT = 250_000;
+// This is a parser ceiling, not the aggregate workspace-scan or remote request ceiling. Large
+// generated focus, event, and scripted-effect sources routinely exceed 8 MiB in real agentic mods.
+export const SOURCE_MAX_BYTES = 33_554_432;
+export const SOURCE_TOKEN_LIMIT = 4_000_000;
+export const SOURCE_ENTRY_LIMIT = 1_000_000;
+export const SOURCE_LINE_LIMIT = 2_000_000;
 /**
  * Parser ceilings that intentionally return no document or a structurally partial document.
  * Broad inventories may skip these sources, but targeted reads and rewrites must continue to

package/dist/hoi4_agent_tools/event/graph.js

@@ -1604,10 +1604,9 @@ export function buildEventGraph(snapshot, options = {}) {
     assertGraphLimit(graph.unresolved.length, EVENT_GRAPH_MAX_UNRESOLVED, 'EVENT_UNRESOLVED_LIMIT', 'unresolved-analysis count');
     budget.check();
     const diagnostics = sortDiagnostics([...snapshot.diagnostics, ...partial.diagnostics]);
-    const complete = !focused &&
-        snapshot.complete &&
-        graph.unresolved.length === 0 &&
-        !graph.issues.some(({ classification, severity }) => classification === 'unresolved_analysis' || severity === 'blocker');
+    // Coverage completeness is independent from defects discovered in the source. A full,
+    // untruncated analysis remains complete when it correctly reports missing or dynamic links.
+    const complete = !focused && snapshot.complete;
     const nodes = sortNodes(graph.nodes);
     const edges = stableUnique(graph.edges);
     const stateAccesses = stableUnique(graph.stateAccesses);

package/dist/hoi4_agent_tools/event/limits.js

@@ -1,9 +1,9 @@
 import { ServiceError } from '../core/result.js';
 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;
-export const EVENT_GRAPH_MAX_STATE_LINK_CANDIDATES = 500_000;
+export const EVENT_GRAPH_MAX_STATE_ACCESSES = 1_000_000;
+export const EVENT_GRAPH_MAX_STATE_LINKS = 1_000_000;
+export const EVENT_GRAPH_MAX_STATE_LINK_CANDIDATES = 2_000_000;
 // Installed-game scans can legitimately produce more than twenty thousand source-linked
 // findings before an agent narrows the query. Keep the graph bounded, but do not reject a
 // complete large workspace merely because its diagnostics are numerous.
@@ -13,7 +13,7 @@ export const EVENT_GRAPH_MAX_HELPER_DEPTH = 64;
 export const EVENT_GRAPH_MAX_HELPER_PROJECTIONS = 200_000;
 export const EVENT_GRAPH_MAX_HELPER_STATE_PROJECTIONS = 50_000;
 export const EVENT_GRAPH_MAX_CONDITION_TEXT = 16_384;
-export const EVENT_GRAPH_WORK_LIMIT = 5_000_000;
+export const EVENT_GRAPH_WORK_LIMIT = 10_000_000;
 export const EVENT_FRAGMENT_CACHE_MAX_ENTRIES = 10_000;
 export const EVENT_FRAGMENT_CACHE_MAX_SOURCE_BYTES = 134_217_728;
 export const EVENT_PROPOSED_SOURCE_MAX_FILES = 64;

package/dist/hoi4_agent_tools/event/service.js

@@ -45,16 +45,12 @@ class BoundedEventFragmentCache {
 function eventGraphCacheKey(workspaceId, projectHelpers, analysisMode = 'full') {
     return `${workspaceId}\0${projectHelpers ? 'expanded' : 'structural'}\0${analysisMode}`;
 }
-function isGameBackedWorkspace(workspace) {
-    return workspace.roots.some(({ kind }) => kind === 'game');
-}
 const serviceState = new WeakMap();
 const EVENT_GRAPH_ARTIFACT_MAX_BYTES = 67_108_864;
 const EVENT_GRAPH_ARTIFACT_MAX_CHUNKS = 1_024;
 const EVENT_SCAN_FULL_GRAPH_RECORD_LIMIT = 100_000;
 const EVENT_SCAN_SUMMARY_SAMPLE_LIMIT = 100;
 const EVENT_FOCUSED_EVIDENCE_LIMIT = 2_000;
-const EVENT_FOCUSED_GRAPH_FILE_THRESHOLD = 1_000;
 const SHA256_PATTERN = /^[a-f0-9]{64}$/u;
 const graphHashCache = new WeakMap();
 function groupedCounts(values, key) {
@@ -704,8 +700,7 @@ export class EventChainViewer {
         const generation = engineGeneration(this.engine, workspaceId);
         const requestedProjectHelpers = options.projectHelpers ?? true;
         const requestedAnalysisMode = options.analysisMode ?? 'full';
-        const autoFocused = isGameBackedWorkspace(workspace) && requestedAnalysisMode === 'full';
-        const cacheAnalysisMode = autoFocused ? 'focused' : requestedAnalysisMode;
+        const cacheAnalysisMode = requestedAnalysisMode;
         const cacheProjectHelpers = cacheAnalysisMode === 'focused' ? false : requestedProjectHelpers;
         const cacheKey = eventGraphCacheKey(workspaceId, cacheProjectHelpers, cacheAnalysisMode);
         const cached = this.#state.current.get(cacheKey);
@@ -716,7 +711,7 @@ export class EventChainViewer {
             this.#state.current.get(eventGraphCacheKey(workspaceId, requestedProjectHelpers, requestedAnalysisMode)) ??
             this.#state.current.get(eventGraphCacheKey(workspaceId, !requestedProjectHelpers)) ??
             this.#state.current.get(eventGraphCacheKey(workspaceId, requestedProjectHelpers));
-        const scanFocused = autoFocused || requestedAnalysisMode === 'focused';
+        const scanFocused = requestedAnalysisMode === 'focused';
         const snapshot = options.refresh !== true && sibling?.generation === generation
             ? sibling.snapshot
             : await scanEventSources(this.engine, workspaceId, workspace, scanFocused, options.principal, options.signal);
@@ -724,9 +719,7 @@ export class EventChainViewer {
         if (cached?.snapshot.revision === snapshot.revision && cached.generation === generation) {
             return cached.graph;
         }
-        const buildAnalysisMode = autoFocused || snapshot.files.length > EVENT_FOCUSED_GRAPH_FILE_THRESHOLD
-            ? 'focused'
-            : 'full';
+        const buildAnalysisMode = requestedAnalysisMode;
         const projectHelpers = buildAnalysisMode === 'focused' ? false : requestedProjectHelpers;
         const graph = buildEventGraph(snapshot, {
             ...(options.signal === undefined ? {} : { signal: options.signal }),
@@ -750,15 +743,10 @@ export class EventChainViewer {
                 input.mode !== 'roots' &&
                 input.mode !== 'trace' &&
                 input.mode !== 'explain_path',
-            ...(input.mode === 'trace' || input.mode === 'explain_path'
-                ? { analysisMode: 'focused' }
-                : {}),
             ...(input.principal === undefined ? {} : { principal: input.principal }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
         });
-        // Keep the service result's graph identity distinct from a prior scan while
-        // reusing its structural cache and avoiding a second large graph build.
-        const graph = input.mode === 'trace' || input.mode === 'explain_path' ? { ...scannedGraph } : scannedGraph;
+        const graph = scannedGraph;
         const maxDepth = input.maxDepth ?? 8;
         const maxNodes = input.maxNodes ?? 500;
         const maxEdges = input.maxEdges ?? 2_000;

package/dist/hoi4_agent_tools/gui/assets.js

@@ -110,6 +110,7 @@ export function parseBmFont(text) {
                             ? fields.width
                             : 0,
                     page: typeof fields.page === 'number' ? fields.page : 0,
+                    channelMask: typeof fields.chnl === 'number' ? fields.chnl : 15,
                 });
             }
             recognised = true;
@@ -471,7 +472,9 @@ export class GuiAssetCatalog {
                 if (previous !== undefined)
                     penX += (entry.bmfont.kerning.get(`${previous}:${codePoint}`) ?? 0) * scale;
                 const pagePath = entry.bmfont.pages[metric.page];
-                const pageFile = pagePath === undefined ? undefined : this.resolveBmFontPage(entry, pagePath, metric.page);
+                // Older shipped HOI4 descriptors omit the page record entirely. Page zero still uses the
+                // descriptor stem (for example garamond_12.fnt -> garamond_12.dds/tga).
+                const pageFile = this.resolveBmFontPage(entry, pagePath ?? '', metric.page);
                 const raster = pageFile === undefined
                     ? undefined
                     : await this.loadBmFontGlyph(entry, pageFile, metric, codePoint);
@@ -619,37 +622,73 @@ export class GuiAssetCatalog {
                     .raw()
                     .toBuffer({ resolveWithObject: true });
                 const channelRoles = entry.bmfont?.channelRoles;
-                let facePixels = extracted.data;
-                let borderPixels;
-                if (channelRoles?.some((role) => role === 0) === true) {
-                    facePixels = Buffer.alloc(extracted.data.length);
-                    borderPixels = channelRoles.some((role) => role === 1)
-                        ? Buffer.alloc(extracted.data.length)
-                        : undefined;
-                    let backgroundSamples = 0;
-                    let backgroundTotal = 0;
-                    for (let offset = 0; offset < extracted.data.length; offset += 4) {
-                        const borderCoverage = channelRoles.reduce((maximum, role, channel) => role === 1 ? Math.max(maximum, extracted.data[offset + channel] ?? 0) : maximum, 0);
-                        if (borderCoverage !== 0)
-                            continue;
-                        for (let channel = 0; channel < 4; channel += 1) {
-                            if (channelRoles[channel] !== 0)
-                                continue;
-                            backgroundTotal += extracted.data[offset + channel] ?? 0;
-                            backgroundSamples += 1;
-                        }
+                const channelRanges = [0, 1, 2, 3].map((channel) => {
+                    let minimum = 255;
+                    let maximum = 0;
+                    for (let offset = channel; offset < extracted.data.length; offset += 4) {
+                        const sample = extracted.data[offset] ?? 0;
+                        minimum = Math.min(minimum, sample);
+                        maximum = Math.max(maximum, sample);
                     }
-                    const invertedFace = backgroundSamples > 0 && backgroundTotal / backgroundSamples > 127;
+                    return maximum - minimum;
+                });
+                const channelSelected = (channel) => {
+                    if (metric.channelMask === 15)
+                        return true;
+                    const maskForChannel = [4, 2, 1, 8][channel] ?? 0;
+                    return (metric.channelMask & maskForChannel) !== 0;
+                };
+                const informativeChannels = (role) => channelRoles === undefined
+                    ? []
+                    : channelRoles
+                        .map((candidate, channel) => ({ candidate, channel }))
+                        .filter(({ candidate, channel }) => candidate === role &&
+                        channelSelected(channel) &&
+                        (channelRanges[channel] ?? 0) > 0)
+                        .map(({ channel }) => channel);
+                const alphaIsInformative = (channelRanges[3] ?? 0) > 0;
+                let faceChannels = informativeChannels(0);
+                let borderChannels = informativeChannels(1);
+                if (faceChannels.length === 0) {
+                    if (borderChannels.length > 0) {
+                        // Some vanilla fonts declare their only useful alpha bitmap as the outline
+                        // channel even though the atlas contains no separate face channel. In that case
+                        // the alpha bitmap is the face; treating constant-white RGB as coverage produces
+                        // an opaque rectangle for every glyph.
+                        faceChannels = borderChannels;
+                        borderChannels = [];
+                    }
+                    else {
+                        faceChannels = alphaIsInformative
+                            ? [3]
+                            : channelRanges
+                                .map((range, channel) => ({ range, channel }))
+                                .filter(({ range }) => range > 0)
+                                .map(({ channel }) => channel);
+                    }
+                }
+                const facePixels = Buffer.alloc(extracted.data.length);
+                let borderPixels;
+                if (faceChannels.length > 0) {
+                    borderPixels =
+                        borderChannels.length > 0 ? Buffer.alloc(extracted.data.length) : undefined;
+                    // BMFont role 0 is coverage, not a per-glyph light/dark bitmap. Vanilla atlases may
+                    // contain glyphs with either more filled or more empty pixels, so polarity inference
+                    // from an individual crop corrupts neighboring letters inconsistently.
                     for (let offset = 0; offset < extracted.data.length; offset += 4) {
                         let faceCoverage = 0;
                         let borderCoverage = 0;
-                        for (let channel = 0; channel < 4; channel += 1) {
+                        for (const channel of faceChannels) {
                             const sample = extracted.data[offset + channel] ?? 0;
-                            if (channelRoles[channel] === 0)
-                                faceCoverage = Math.max(faceCoverage, invertedFace ? 255 - sample : sample);
-                            if (channelRoles[channel] === 1)
-                                borderCoverage = Math.max(borderCoverage, sample);
+                            faceCoverage = Math.max(faceCoverage, sample);
                         }
+                        for (const channel of borderChannels)
+                            borderCoverage = Math.max(borderCoverage, extracted.data[offset + channel] ?? 0);
+                        // Vanilla's compressed multi-channel atlases can bleed a neighboring glyph into
+                        // an RGB face crop while the alpha silhouette remains correctly bounded. The
+                        // face is the intersection, not the union, of those declared layers.
+                        if (borderChannels.length > 0)
+                            faceCoverage = Math.min(faceCoverage, borderCoverage);
                         facePixels[offset] = 255;
                         facePixels[offset + 1] = 255;
                         facePixels[offset + 2] = 255;

package/dist/hoi4_agent_tools/gui/renderer.js

@@ -60,7 +60,7 @@ function sceneGlyphDefinitions(scene) {
             .map(([key, glyphPath]) => `<path id="${outlineDefinitionId(key)}" d="${glyphPath}"/>`),
         ...[...bitmaps.entries()]
             .sort(([left], [right]) => compareCodeUnits(left, right))
-            .map(([key, glyph]) => `<image id="${bitmapDefinitionId(key)}" width="${finite(glyph.width)}" height="${finite(glyph.height)}" href="${glyph.dataUri}" preserveAspectRatio="none"/>${glyph.borderDataUri === undefined ? '' : `<image id="${bitmapDefinitionId(key, 'border')}" width="${finite(glyph.width)}" height="${finite(glyph.height)}" href="${glyph.borderDataUri}" preserveAspectRatio="none"/>`}`),
+            .map(([key, glyph]) => `<image id="${bitmapDefinitionId(key)}" width="${finite(glyph.width)}" height="${finite(glyph.height)}" href="${glyph.dataUri}" preserveAspectRatio="none" image-rendering="optimizeSpeed"/>${glyph.borderDataUri === undefined ? '' : `<image id="${bitmapDefinitionId(key, 'border')}" width="${finite(glyph.width)}" height="${finite(glyph.height)}" href="${glyph.borderDataUri}" preserveAspectRatio="none" image-rendering="optimizeSpeed"/>`}`),
     ].join('');
 }
 function bitmapTintMarkup(id, colour, glyphs, rect) {

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

@@ -91,9 +91,9 @@ const previewStateSchema = z.enum([
     'long-text',
     'missing-localisation',
 ]);
-const compactGuiScenarioSchema = compactValidatedInputSchema(GuiPreviewScenarioSchema, `Complete GUI preview scenario: https://github.com/klimPaskov/hoi4-agent-tools/blob/v${PACKAGE_VERSION}/docs/gui.md`);
+const compactGuiScenarioSchema = compactValidatedInputSchema(GuiPreviewScenarioSchema, `GUI preview scenario: https://github.com/klimPaskov/hoi4-agent-tools/blob/v${PACKAGE_VERSION}/docs/gui.md`);
 const compactGeneratedScenarioOptionsSchema = compactValidatedInputSchema(GuiGeneratedScenarioOptionsSchema, `Options: https://github.com/klimPaskov/hoi4-agent-tools/blob/v${PACKAGE_VERSION}/docs/gui.md`);
-const compactGuiHelperSchema = compactValidatedInputSchema(GuiHelperDocumentSchema, `Complete GUI helper document: https://github.com/klimPaskov/hoi4-agent-tools/blob/v${PACKAGE_VERSION}/docs/gui.md`);
+const compactGuiHelperSchema = compactValidatedInputSchema(GuiHelperDocumentSchema, `GUI helper document: https://github.com/klimPaskov/hoi4-agent-tools/blob/v${PACKAGE_VERSION}/docs/gui.md`);
 const guiBaseInput = z
     .object({
     workspaceId: workspaceIdSchema,

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

@@ -19,7 +19,6 @@ 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(),
@@ -34,21 +33,55 @@ const inspectInput = z
     workspaceId: workspaceIdSchema,
     adapter: probabilityAdapterIdSchema.optional(),
     source: nestedSource.optional(),
+    customPoolManifest: nestedManifest.optional(),
     candidatePool,
     refresh: z.boolean().optional(),
 })
     .strict()
     .superRefine((value, context) => {
-    if (value.adapter !== undefined && value.source === undefined)
+    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 !== 'custom_weighted_pool')
+        context.addIssue({
+            code: 'custom',
+            path: ['adapter'],
+            message: 'customPoolManifest requires adapter custom_weighted_pool',
+        });
+});
+const evaluateInput = z
+    .object({
+    ...commonShape,
+    source: nestedSource.optional(),
+    customPoolManifest: nestedManifest.optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if ((value.source === undefined) === (value.customPoolManifest === undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'Provide exactly one source or customPoolManifest',
+        });
+    if (value.customPoolManifest !== undefined && value.adapter !== 'custom_weighted_pool')
+        context.addIssue({
+            code: 'custom',
+            path: ['adapter'],
+            message: 'customPoolManifest requires adapter custom_weighted_pool',
+        });
 });
-const evaluateInput = z.object(commonShape).strict();
 const sweepInput = z
     .object({
     ...commonShape,
+    source: nestedSource,
     sweep: z
         .object({
         paths: z.array(z.string().min(1).max(1024)).min(1).max(32),
@@ -62,6 +95,7 @@ const sweepInput = z
 const simulateInput = z
     .object({
     ...commonShape,
+    source: nestedSource,
     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),
@@ -87,8 +121,10 @@ const compareInput = z
     .object({
     workspaceId: workspaceIdSchema,
     adapter: probabilityAdapterIdSchema,
-    before: nestedSource,
-    after: nestedSource,
+    before: nestedSource.optional(),
+    after: nestedSource.optional(),
+    beforeManifest: nestedManifest.optional(),
+    afterManifest: nestedManifest.optional(),
     scenarioSet: nestedScenarios,
     candidatePool,
     horizonDays: z.number().positive().max(1_000_000).optional(),
@@ -97,7 +133,29 @@ const compareInput = z
     outputs,
     refresh: z.boolean().optional(),
 })
-    .strict();
+    .strict()
+    .superRefine((value, context) => {
+    const sourceMode = value.before !== undefined || value.after !== undefined;
+    const manifestMode = value.beforeManifest !== undefined || value.afterManifest !== undefined;
+    if (sourceMode === manifestMode)
+        context.addIssue({
+            code: 'custom',
+            message: 'Compare either before/after sources or beforeManifest/afterManifest',
+        });
+    if (sourceMode && (value.before === undefined || value.after === undefined))
+        context.addIssue({ code: 'custom', message: 'Source comparison requires before and after' });
+    if (manifestMode && (value.beforeManifest === undefined || value.afterManifest === undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'Custom-pool comparison requires beforeManifest and afterManifest',
+        });
+    if (manifestMode && value.adapter !== 'custom_weighted_pool')
+        context.addIssue({
+            code: 'custom',
+            path: ['adapter'],
+            message: 'Manifest comparison requires adapter custom_weighted_pool',
+        });
+});
 const renderInput = z
     .object({
     workspaceId: workspaceIdSchema,
@@ -243,7 +301,7 @@ export function registerProbabilityTools(server, engine, context) {
     const analyzer = new ProbabilityAnalyzer(engine);
     server.registerTool('hoi4.probability_inspect', {
         title: 'Inspect AI and MTTH weighted logic',
-        description: 'List versioned adapters, or provide a source alone to discover compatible weighted adapters, candidate pools, capabilities, provenance, and unsupported constructs before narrowing the request.',
+        description: 'Discover weighted adapters, candidates, provenance, and required inputs.',
         inputSchema: inspectInput,
         outputSchema: inspectOutput,
         annotations: readOnly,
@@ -252,7 +310,7 @@ export function registerProbabilityTools(server, engine, context) {
         const base = await 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 inspected = await analyzer.inspect(base, input.adapter, input.source, input.candidatePool, input.customPoolManifest);
             const result = emptyServiceResult(base.workspaceId, {
                 adapters: inspected.adapters.length,
                 ...(inspected.surface === undefined
@@ -305,7 +363,7 @@ export function registerProbabilityTools(server, engine, context) {
     });
     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.',
+        description: 'Evaluate weights and probabilities under explicit scenarios.',
         inputSchema: evaluateInput,
         outputSchema: analysisOutput,
         annotations: readOnly,
@@ -329,7 +387,7 @@ export function registerProbabilityTools(server, engine, context) {
     });
     server.registerTool('hoi4.probability_sweep', {
         title: 'Sweep AI and MTTH parameters',
-        description: 'Evaluate declared ranges, sensitivity, breakpoints, and rank reversals without inventing world state.',
+        description: 'Evaluate declared ranges, breakpoints, and rank reversals.',
         inputSchema: sweepInput,
         outputSchema: analysisOutput,
         annotations: readOnly,
@@ -353,7 +411,7 @@ export function registerProbabilityTools(server, engine, context) {
     });
     server.registerTool('hoi4.probability_simulate', {
         title: 'Simulate uncertain weighted scenarios',
-        description: 'Run reproducible seeded Monte Carlo analysis with distributions, supported correlations, and confidence intervals.',
+        description: 'Run seeded simulations with distributions and confidence intervals.',
         inputSchema: simulateInput,
         outputSchema: analysisOutput,
         annotations: readOnly,
@@ -377,7 +435,7 @@ export function registerProbabilityTools(server, engine, context) {
     });
     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.',
+        description: 'Analyze a manifest-declared dynamic weighted sequence.',
         inputSchema: sequenceInput,
         outputSchema: analysisOutput,
         annotations: readOnly,
@@ -401,7 +459,7 @@ export function registerProbabilityTools(server, engine, context) {
     });
     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.',
+        description: 'Compare sources or declared pools under identical scenarios.',
         inputSchema: compareInput,
         outputSchema: analysisOutput,
         annotations: readOnly,
@@ -425,7 +483,7 @@ export function registerProbabilityTools(server, engine, context) {
     });
     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.',
+        description: 'Render cached probability analysis as deterministic resources.',
         inputSchema: renderInput,
         outputSchema: analysisOutput,
         annotations: readOnly,

package/dist/hoi4_agent_tools/probability/sequence.js

@@ -465,22 +465,32 @@ function advance(state, manifest, selectedCandidates, unresolved) {
 }
 function initialState(manifest, scenario) {
     const candidateIds = new Set();
+    const state = {
+        day: 0,
+        step: 0,
+        values: { ...(manifest.state ?? {}), ...scenario.state },
+        candidates: [],
+        timerMinDays: manifest.selection.timerMinDays ?? 0,
+        timerMaxDays: manifest.selection.timerMaxDays ?? manifest.selection.timerMinDays ?? 0,
+        terminal: false,
+        selectedIds: [],
+        selectionDays: {},
+    };
     const candidates = manifest.candidates.map((candidate) => {
         if (candidateIds.has(candidate.id))
             throw new ServiceError('SEQUENCE_CANDIDATE_DUPLICATE', 'Custom pool candidate IDs must be unique', { id: candidate.id });
         candidateIds.add(candidate.id);
-        const weight = typeof candidate.weight === 'number' ? candidate.weight : Number(candidate.weight);
-        const cap = candidate.cap === undefined
-            ? undefined
-            : typeof candidate.cap === 'number'
-                ? candidate.cap
-                : Number(candidate.cap);
-        if (!Number.isFinite(weight) || (cap !== undefined && !Number.isFinite(cap)))
-            throw new ServiceError('SEQUENCE_INITIAL_VALUE_INVALID', 'Initial custom pool weights and caps must resolve numerically', { id: candidate.id });
+        const weight = numberExpression(candidate.weight, state);
+        const cap = candidate.cap === undefined ? undefined : numberExpression(candidate.cap, state);
+        if (weight === undefined ||
+            !Number.isFinite(weight) ||
+            (cap !== undefined && !Number.isFinite(cap)))
+            throw new ServiceError('SEQUENCE_INITIAL_VALUE_INVALID', 'Initial custom pool weights and caps must resolve from manifest or scenario state', { id: candidate.id });
+        const boundedWeight = cap === undefined ? weight : Math.min(weight, cap);
         return {
             id: candidate.id,
             ...(candidate.category === undefined ? {} : { category: candidate.category }),
-            weight: rounded(weight, manifest.selection.rounding),
+            weight: rounded(boundedWeight, manifest.selection.rounding),
             ...(cap === undefined ? {} : { cap: rounded(cap, manifest.selection.rounding) }),
             active: true,
             oneTime: candidate.oneTime ?? false,
@@ -488,16 +498,31 @@ function initialState(manifest, scenario) {
             cooldownUntil: 0,
         };
     });
+    state.candidates = candidates;
+    return state;
+}
+/** Evaluate one declared dynamic pool at the supplied scenario state before transitions run. */
+export function evaluateCustomPoolPoint(manifest, scenario) {
+    const state = initialState(manifest, scenario);
+    const unresolved = [];
+    const eligible = eligibleCandidates(state, manifest, unresolved);
+    const eligibleIds = new Set(eligible.map(({ id }) => id));
+    const poolTotal = eligible.reduce((sum, candidate) => sum + candidate.weight, 0);
     return {
-        day: 0,
-        step: 0,
-        values: { ...(manifest.state ?? {}), ...scenario.state },
-        candidates,
-        timerMinDays: manifest.selection.timerMinDays ?? 0,
-        timerMaxDays: manifest.selection.timerMaxDays ?? manifest.selection.timerMinDays ?? 0,
-        terminal: false,
-        selectedIds: [],
-        selectionDays: {},
+        candidates: state.candidates.map((candidate) => ({
+            id: candidate.id,
+            weight: candidate.weight,
+            eligible: eligibleIds.has(candidate.id),
+            probability: !eligibleIds.has(candidate.id)
+                ? 0
+                : manifest.selection.mode === 'categorical_weighted'
+                    ? poolTotal <= 0
+                        ? 0
+                        : candidate.weight / poolTotal
+                    : Math.max(0, Math.min(1, candidate.weight / 100)),
+        })),
+        poolTotal,
+        unresolved,
     };
 }
 function stateKey(state) {

package/dist/hoi4_agent_tools/probability/service.js

@@ -11,8 +11,9 @@ import { compareProbabilityResults } from './compare.js';
 import { evaluateExactCandidates, evaluateSurfaceScenarios } from './evaluation.js';
 import { VERIFIED_GAME_CHECKSUM, VERIFIED_GAME_RAW_VERSION, VERIFIED_GAME_VERSION, } from './model.js';
 import { renderProbabilityResult } from './render.js';
-import { analyzeSequence } from './sequence.js';
+import { analyzeSequence, evaluateCustomPoolPoint } from './sequence.js';
 import { simulateSurface } from './simulation.js';
+import { Rational } from './rational.js';
 import { discoverWeightedSurface, inventoryWeightedSurfaces, } from './source-analysis.js';
 import { sweepSurface } from './sweep.js';
 const states = new WeakMap();
@@ -584,6 +585,63 @@ function customSurface(manifest, sourceRevision) {
         unsupported: [],
     };
 }
+function customPoolScenarios(surface, manifest, scenarioSet) {
+    return scenarioSet.scenarios.map((scenario) => {
+        const point = evaluateCustomPoolPoint(manifest, scenario);
+        const ordered = [...point.candidates].sort((left, right) => right.probability - left.probability || compareCodeUnits(left.id, right.id));
+        const rank = new Map(ordered.map((candidate, index) => [candidate.id, index + 1]));
+        const candidates = point.candidates.map((candidate) => {
+            const exactWeight = Rational.parse(candidate.weight);
+            const exactPoolTotal = Rational.parse(point.poolTotal);
+            const exactProbability = !candidate.eligible
+                ? Rational.zero
+                : manifest.selection.mode === 'categorical_weighted'
+                    ? exactWeight !== undefined && exactPoolTotal !== undefined && !exactPoolTotal.isZero()
+                        ? exactWeight.divide(exactPoolTotal)
+                        : undefined
+                    : exactWeight?.divide(new Rational(100n)).max(Rational.zero).min(Rational.one);
+            const unresolved = point.unresolved.filter(({ candidateId }) => candidateId === undefined || candidateId === candidate.id);
+            return {
+                id: candidate.id,
+                eligibility: candidate.eligible ? 'true' : 'false',
+                supportLevel: unresolved.length === 0 ? 'exact' : 'unsupported',
+                rawValue: exactWeight?.toJSON() ?? null,
+                conditionalProbability: candidate.probability,
+                ...(exactProbability === undefined
+                    ? {}
+                    : { exactConditionalProbability: exactProbability.toJSON() }),
+                rank: candidate.eligible ? (rank.get(candidate.id) ?? null) : null,
+                trace: [],
+                provenance: surface.candidates.find(({ id }) => id === candidate.id)?.provenance ?? [],
+                unresolved,
+            };
+        });
+        const eligible = ordered.filter(({ eligible }) => eligible);
+        return {
+            id: scenario.id,
+            ...(scenario.label === undefined ? {} : { label: scenario.label }),
+            ...(scenario.prevalence === undefined ? {} : { prevalence: scenario.prevalence }),
+            poolComplete: true,
+            supportLevel: point.unresolved.length === 0 ? 'exact' : 'unsupported',
+            candidates,
+            ...(Rational.parse(point.poolTotal) === undefined
+                ? {}
+                : { poolTotal: Rational.parse(point.poolTotal).toJSON() }),
+            summary: {
+                topOutcomes: eligible.slice(0, 3).map(({ id }) => id),
+                bottomEligibleOutcomes: eligible.slice(-3).map(({ id }) => id),
+                impossibleOutcomes: ordered
+                    .filter(({ probability }) => probability === 0)
+                    .map(({ id }) => id),
+                unresolvedOutcomes: candidates
+                    .filter(({ unresolved }) => unresolved.length > 0)
+                    .map(({ id }) => id),
+                dominantFactors: [],
+            },
+            unresolved: point.unresolved,
+        };
+    });
+}
 export class ProbabilityAnalyzer {
     engine;
     state;
@@ -775,13 +833,61 @@ export class ProbabilityAnalyzer {
         }
         return complete;
     }
-    async inspect(context, adapter, source, candidatePool = []) {
-        if (source === undefined)
+    async inspect(context, adapter, source, candidatePool = [], customPoolManifest) {
+        if (source === undefined && customPoolManifest === undefined)
             return { adapters: probabilityAdapters(), artifacts: [], filesScanned: [] };
-        const snapshot = await this.scan(context, [source.path]);
+        if (customPoolManifest !== undefined && source !== undefined)
+            throw new ServiceError('PROBABILITY_INPUT_AMBIGUOUS', 'Provide either source or customPoolManifest for inspection');
+        if (customPoolManifest !== undefined && adapter !== 'custom_weighted_pool')
+            throw new ServiceError('PROBABILITY_ADAPTER_MISMATCH', 'customPoolManifest inspection requires adapter custom_weighted_pool');
+        const snapshot = await this.scan(context, [source?.path]);
+        if (customPoolManifest !== undefined) {
+            const surface = customSurface(customPoolManifest, snapshot.revision);
+            const gameVersionVerification = await this.verifyGameVersion(context, 'custom_weighted_pool');
+            const report = {
+                schemaVersion: 'probability-inspection.v2',
+                workspaceId: context.workspaceId,
+                surface: {
+                    id: surface.id,
+                    adapter: surface.adapter,
+                    poolComplete: true,
+                    sourceRevision: surface.sourceRevision,
+                    sourceHash: surface.sourceHash,
+                    gameVersionVerification,
+                    candidateCount: surface.candidates.length,
+                    candidates: surface.candidates.map((candidate) => ({
+                        id: candidate.id,
+                        sourceKind: candidate.sourceKind,
+                        provenance: candidate.provenance,
+                        hasEligibility: customPoolManifest.candidates.find(({ id }) => id === candidate.id)?.eligibleWhen !==
+                            undefined,
+                        hasWeightBlock: true,
+                        requiredInputs: [],
+                        referencedProvenance: [],
+                        analysisSupport: 'exact',
+                    })),
+                    requiredInputs: [],
+                    unsupported: [],
+                },
+            };
+            const workspace = this.engine.resolver.get(context.workspaceId, context.principal);
+            const artifact = await this.engine.artifacts.putChunked(workspace, `probability-inspect-${surface.sourceHash.slice(0, 12)}.json`, 'application/json', `${canonicalJson(report)}\n`, {
+                kind: 'probability-inspection',
+                toolVersion: PACKAGE_VERSION,
+                schemaVersion: 'probability-inspection.v2',
+                sourceHashes: { aggregate: surface.sourceHash },
+            }, 'Declared custom weighted-pool inventory', context.signal);
+            return {
+                adapters: probabilityAdapters(),
+                surface: report.surface,
+                artifacts: [publicArtifactLink(artifact)],
+                filesScanned: [],
+            };
+        }
+        const selectedSource = source;
         const storeDiscovery = async (inventory, reason) => {
             const availableAdapters = inventory.adapters.filter(({ candidateCount }) => candidateCount > 0);
-            const matchingIdentifier = availableAdapters.filter(({ identifierMatchCount }) => source.identifier !== undefined && identifierMatchCount > 0);
+            const matchingIdentifier = availableAdapters.filter(({ identifierMatchCount }) => selectedSource.identifier !== undefined && identifierMatchCount > 0);
             const matchingPool = availableAdapters.filter(({ candidatePoolMatchCount }) => candidatePool.length > 0 && candidatePoolMatchCount > 0);
             const requested = availableAdapters.find(({ adapterId }) => adapterId === adapter);
             const ranked = [
@@ -826,7 +932,7 @@ export class ProbabilityAnalyzer {
             };
         };
         if (adapter === undefined) {
-            const inventory = inventoryWeightedSurfaces(snapshot, source, candidatePool);
+            const inventory = inventoryWeightedSurfaces(snapshot, selectedSource, candidatePool);
             return storeDiscovery(inventory, inventory.adapters.some(({ candidateCount }) => candidateCount > 0)
                 ? 'source_inventory'
                 : 'no_weighted_surfaces');
@@ -834,14 +940,14 @@ export class ProbabilityAnalyzer {
         const gameVersionVerification = await this.verifyGameVersion(context, adapter);
         let surface;
         try {
-            surface = discoverWeightedSurface(snapshot, adapter, source, candidatePool);
+            surface = discoverWeightedSurface(snapshot, adapter, selectedSource, candidatePool);
         }
         catch (error) {
             if (!(error instanceof ServiceError) ||
                 (error.code !== 'PROBABILITY_SURFACE_EMPTY' &&
                     error.code !== 'PROBABILITY_IDENTIFIER_NOT_FOUND'))
                 throw error;
-            const inventory = inventoryWeightedSurfaces(snapshot, source, candidatePool);
+            const inventory = inventoryWeightedSurfaces(snapshot, selectedSource, candidatePool);
             const requested = inventory.adapters.find(({ adapterId }) => adapterId === adapter);
             const reason = error.code === 'PROBABILITY_IDENTIFIER_NOT_FOUND'
                 ? 'identifier_not_found'
@@ -916,11 +1022,22 @@ export class ProbabilityAnalyzer {
         if (request.scenarioSet.workspaceId !== undefined &&
             request.scenarioSet.workspaceId !== request.workspaceId)
             throw new ServiceError('PROBABILITY_SCENARIO_WORKSPACE_MISMATCH', 'Scenario set belongs to a different workspace');
+        const usingManifest = request.customPoolManifest !== undefined;
+        if (usingManifest !== (request.source === undefined))
+            throw new ServiceError('PROBABILITY_INPUT_AMBIGUOUS', 'Provide exactly one source or customPoolManifest');
+        if (usingManifest && request.adapter !== 'custom_weighted_pool')
+            throw new ServiceError('PROBABILITY_ADAPTER_MISMATCH', 'customPoolManifest requires the custom_weighted_pool adapter');
+        if (!usingManifest && request.adapter === 'custom_weighted_pool')
+            throw new ServiceError('PROBABILITY_MANIFEST_REQUIRED', 'custom_weighted_pool requires customPoolManifest');
         const gameVersionVerification = await this.verifyGameVersion(request, request.adapter);
-        const snapshot = await this.scan(request, [request.source.path]);
-        const surface = discoverWeightedSurface(snapshot, request.adapter, request.source, request.candidatePool ?? []);
+        const snapshot = await this.scan(request, [request.source?.path]);
+        const surface = usingManifest
+            ? customSurface(request.customPoolManifest, snapshot.revision)
+            : discoverWeightedSurface(snapshot, request.adapter, request.source, request.candidatePool ?? []);
         const definitions = ClausewitzEvaluationDefinitions.build(snapshot);
-        const metadata = this.metadata(request, snapshot, surface, request.scenarioSet, request.candidatePool ?? [], gameVersionVerification, {
+        const metadata = this.metadata(request, snapshot, surface, request.scenarioSet, usingManifest
+            ? request.customPoolManifest.candidates.map(({ id }) => id)
+            : (request.candidatePool ?? []), gameVersionVerification, {
             operation,
             horizonDays: request.horizonDays,
             requestedMetrics: request.metrics,
@@ -931,7 +1048,9 @@ export class ProbabilityAnalyzer {
         const cached = this.state.byCacheKey.get(metadata.cacheKey);
         if (cached !== undefined)
             return { result: cached, surface, definitions, snapshot };
-        const scenarios = evaluateSurfaceScenarios(surface, request.scenarioSet.scenarios, definitions, request.horizonDays);
+        const scenarios = usingManifest
+            ? customPoolScenarios(surface, request.customPoolManifest, request.scenarioSet)
+            : evaluateSurfaceScenarios(surface, request.scenarioSet.scenarios, definitions, request.horizonDays);
         return {
             result: this.buildResult(operation, metadata, surface, scenarios, {
                 ...(request.acceptanceBands === undefined
@@ -1137,12 +1256,31 @@ export class ProbabilityAnalyzer {
         return this.store(result, request.outputs ?? ['json', 'sequence'], false, request.signal, request.principal);
     }
     async compare(request) {
-        const before = await this.analyzeUnstored('evaluate', { ...request, source: request.before });
-        const after = await this.analyzeUnstored('evaluate', {
-            ...request,
-            source: request.after,
-            refresh: false,
-        });
+        const manifestMode = request.beforeManifest !== undefined || request.afterManifest !== undefined;
+        if (manifestMode !== (request.before === undefined && request.after === undefined))
+            throw new ServiceError('PROBABILITY_COMPARE_INPUT_AMBIGUOUS', 'Compare either before/after sources or beforeManifest/afterManifest');
+        if (manifestMode &&
+            (request.beforeManifest === undefined || request.afterManifest === undefined))
+            throw new ServiceError('PROBABILITY_COMPARE_MANIFEST_REQUIRED', 'Custom-pool comparison requires both beforeManifest and afterManifest');
+        if (!manifestMode && (request.before === undefined || request.after === undefined))
+            throw new ServiceError('PROBABILITY_COMPARE_SOURCE_REQUIRED', 'Source comparison requires both before and after');
+        const before = manifestMode
+            ? await this.analyzeUnstored('evaluate', {
+                ...request,
+                customPoolManifest: request.beforeManifest,
+            })
+            : await this.analyzeUnstored('evaluate', { ...request, source: request.before });
+        const after = manifestMode
+            ? await this.analyzeUnstored('evaluate', {
+                ...request,
+                customPoolManifest: request.afterManifest,
+                refresh: false,
+            })
+            : await this.analyzeUnstored('evaluate', {
+                ...request,
+                source: request.after,
+                refresh: false,
+            });
         const metadata = {
             ...after.result.metadata,
             cacheKey: hashCanonical({

package/dist/hoi4_agent_tools/technology/service.js

@@ -20,7 +20,6 @@ const GRAPH_ARTIFACT_BYTES = 134_217_728;
 const GRAPH_ARTIFACT_CHUNKS = 2_048;
 const HISTORY_ENTRIES = 12;
 const FOCUSED_RENDER_LIMIT = 32;
-const FOCUSED_GRAPH_FILE_THRESHOLD = 1_000;
 class BoundedTechnologyFragmentCache {
     #values = new Map();
     #bytes = 0;
@@ -88,6 +87,45 @@ function technologyScanPatterns(workspace) {
         ...under(roots.localisation, '*.{yml,yaml}'),
     ].sort(compareCodeUnits);
 }
+function recomputeTechnologyShadowing(files) {
+    const groups = new Map();
+    for (const file of files) {
+        delete file.shadowedBy;
+        const key = file.relativePath.replaceAll('\\', '/').toLowerCase();
+        const group = groups.get(key) ?? [];
+        group.push(file);
+        groups.set(key, group);
+    }
+    for (const group of groups.values()) {
+        group.sort((left, right) => right.loadOrder - left.loadOrder || compareCodeUnits(left.displayPath, right.displayPath));
+        const active = group[0];
+        for (const shadowed of group.slice(1))
+            shadowed.shadowedBy = active.displayPath;
+    }
+}
+async function scanTechnologySources(engine, workspaceId, workspace, principal, signal) {
+    const patterns = technologyScanPatterns(workspace);
+    const scans = await Promise.all([
+        engine.scan(workspaceId, { patterns, rootKinds: ['mod', 'dependency', 'fixture'] }, principal, signal),
+        ...(workspace.roots.some(({ kind }) => kind === 'game')
+            ? [engine.scan(workspaceId, { patterns, rootKinds: ['game'] }, principal, signal)]
+            : []),
+    ]);
+    const files = scans.flatMap(({ files }) => files.map((file) => ({ ...file })));
+    recomputeTechnologyShadowing(files);
+    files.sort((left, right) => left.loadOrder - right.loadOrder || compareCodeUnits(left.displayPath, right.displayPath));
+    const index = engine.indexFiles(files);
+    return {
+        workspaceId,
+        revision: hashCanonical(files.map(({ displayPath, loadOrder, sha256 }) => ({ displayPath, loadOrder, sha256 }))),
+        files,
+        index,
+        complete: scans.every(({ complete }) => complete) && index.complete,
+        skippedSourceCount: index.skippedSourceCount,
+        skippedSources: index.skippedSources,
+        diagnostics: [...scans.flatMap(({ diagnostics }) => diagnostics), ...index.diagnostics],
+    };
+}
 function activeTechnologySprite(spriteName, spritePath, sprites) {
     return sprites.find((sprite) => sprite.name === spriteName && (spritePath === undefined || sprite.sourcePath === spritePath));
 }
@@ -130,11 +168,6 @@ async function resolveTechnologyIconDataUris(cached, requestedSprites, budget, s
     }));
     return Object.fromEntries(Object.entries(dataUris).sort(([left], [right]) => compareCodeUnits(left, right)));
 }
-function technologyAnalysisMode(workspace, snapshot) {
-    return workspace.gameRoot !== undefined || snapshot.files.length > FOCUSED_GRAPH_FILE_THRESHOLD
-        ? 'focused'
-        : 'full';
-}
 function rememberGraph(state, graph) {
     const history = state.history.get(graph.workspaceId) ?? new Map();
     history.delete(graph.revision);
@@ -400,8 +433,8 @@ export class TechnologyTreeViewer {
         const cached = this.#state.current.get(workspaceId);
         if (options.refresh !== true && cached?.generation === generation)
             return cached.graph;
-        const snapshot = await this.engine.scan(workspaceId, { patterns: technologyScanPatterns(workspace) }, options.principal, options.signal);
-        const analysisMode = technologyAnalysisMode(workspace, snapshot);
+        const snapshot = await scanTechnologySources(this.engine, workspaceId, workspace, options.principal, options.signal);
+        const analysisMode = 'full';
         const preliminary = buildTechnologyGraph(snapshot, {
             workspaceIdentity: workspace.workspaceIdentity,
             cache: this.#state.fragments,

package/dist/hoi4_agent_tools/version.js

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

package/package.json

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

package/schemas/configuration.schema.json

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

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

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

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

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

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

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

package/schemas/focus-plan.schema.json

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

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

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

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

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

package/schemas/gui-helper.schema.json

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

package/schemas/gui-scenario.schema.json

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

package/schemas/map-operation.schema.json

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

package/schemas/operation-result.schema.json

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/server.json

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