hoi4-agent-tools 2.8.6 → 2.8.8

package/CHANGELOG.md

@@ -4,6 +4,17 @@
 
 No unreleased changes.
 
+## 2.8.8 - 2026-08-29
+
+- Correct GUI font selection so mod definitions override lower-load-order game definitions, language-specific overrides only apply to their language, and extensionless WOFF assets resolve.
+- Accept numeric-block and six-digit Paradox colors, normalize fractional text-color channels, and place color runs from kerning-aware measurements without clipping glyph overhangs.
+- Make generated GUI scenarios favour ordinary values, respect literal numeric limits and progress ranges, and keep current/limit pairs coherent.
+
+## 2.8.7 - 2026-08-28
+
+- Isolate stale, foreign, oversized, malformed, and address-mismatched artifact manifests so one bad generated record cannot block unrelated probability, event, GUI, or other MCP evidence routes.
+- Repair corrupted deterministic manifests from recomputed expected bytes, validate cached probability resources before reuse, and keep direct foreign-artifact access unavailable without exposing cross-workspace content.
+
 ## 2.8.6 - 2026-08-28
 
 - Generate source-aware scripted-GUI scenarios from complete parent/child surfaces, real scripted-localisation candidates, simple threshold conditions, coherent tab states, scoped values, meter ranges, and dynamic-list rows while keeping explicit scenario values authoritative.

package/dist/hoi4_agent_tools/core/artifacts.js

@@ -132,11 +132,14 @@ export function boundedSourceHashEvidence(sourceHashes) {
 }
 function assertManifestIntegrity(manifest, expected, workspace) {
     assertManifestAddressIntegrity(manifest, expected);
-    if (manifest.workspaceIdentity !== workspace.workspaceIdentity ||
-        manifest.ownerIdentity !== workspace.ownerIdentity) {
-        throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest does not match its immutable address');
+    if (!manifestBelongsToWorkspace(manifest, workspace)) {
+        throw new ServiceError('ARTIFACT_NOT_FOUND', 'Artifact provenance manifest is unavailable');
     }
 }
+function manifestBelongsToWorkspace(manifest, workspace) {
+    return (manifest.workspaceIdentity === workspace.workspaceIdentity &&
+        manifest.ownerIdentity === workspace.ownerIdentity);
+}
 function assertManifestAddressIntegrity(manifest, expected) {
     if (manifest.sha256 !== expected.sha256 ||
         manifest.provenanceHash !== expected.provenanceHash ||
@@ -145,6 +148,33 @@ function assertManifestAddressIntegrity(manifest, expected) {
         throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest does not match its immutable address');
     }
 }
+function recoverableManifestError(error) {
+    return (error instanceof ServiceError &&
+        [
+            'ARTIFACT_NOT_FOUND',
+            'ARTIFACT_MANIFEST_INVALID',
+            'ARTIFACT_MANIFEST_LIMIT',
+            'ARTIFACT_MANIFEST_INTEGRITY_FAILED',
+        ].includes(error.code));
+}
+async function enumerableArtifactManifest(workspace, directory, entryName, signal) {
+    try {
+        const manifest = await readArtifactManifest(path.join(directory, entryName), signal);
+        if (entryName !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`)
+            return undefined;
+        assertManifestAddressIntegrity(manifest, {
+            sha256: path.basename(directory),
+            provenanceHash: manifest.provenanceHash,
+            name: manifest.name,
+        });
+        return manifestBelongsToWorkspace(manifest, workspace) ? manifest : undefined;
+    }
+    catch (error) {
+        if (recoverableManifestError(error))
+            return undefined;
+        throw error;
+    }
+}
 /** Return the only artifact fields that may cross the MCP trust boundary. */
 export function publicArtifactLink(artifact) {
     return {
@@ -501,6 +531,23 @@ async function existingManifestMatches(filePath, expectedBytes, signal) {
     try {
         const manifest = await readArtifactManifest(filePath, signal);
         if (`${canonicalJson(manifest)}\n` !== expectedBytes) {
+            const expected = artifactManifestSchema.parse(JSON.parse(expectedBytes));
+            try {
+                assertManifestAddressIntegrity(manifest, {
+                    sha256: expected.sha256,
+                    provenanceHash: expected.provenanceHash,
+                    name: expected.name,
+                });
+            }
+            catch (error) {
+                if (!recoverableManifestError(error))
+                    throw error;
+                await unlink(filePath).catch((unlinkError) => {
+                    if (unlinkError.code !== 'ENOENT')
+                        throw unlinkError;
+                });
+                return false;
+            }
             throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Immutable artifact provenance manifest contains different bytes');
         }
         return true;
@@ -508,11 +555,17 @@ async function existingManifestMatches(filePath, expectedBytes, signal) {
     catch (error) {
         if (error instanceof ServiceError && error.code === 'ARTIFACT_NOT_FOUND')
             return false;
-        if (!(error instanceof ServiceError) || error.code !== 'ARTIFACT_MANIFEST_INVALID')
+        if (!(error instanceof ServiceError) ||
+            !['ARTIFACT_MANIFEST_INVALID', 'ARTIFACT_MANIFEST_LIMIT'].includes(error.code))
             throw error;
         const state = await interruptedManifestState(filePath, expectedBytes, signal);
-        if (!state.interrupted)
-            throw error;
+        if (!state.interrupted) {
+            await unlink(filePath).catch((unlinkError) => {
+                if (unlinkError.code !== 'ENOENT')
+                    throw unlinkError;
+            });
+            return false;
+        }
         try {
             await unlink(filePath);
         }
@@ -689,19 +742,31 @@ export class ArtifactStore {
                 catch (error) {
                     if (error instanceof ServiceError && error.code === 'ARTIFACT_NOT_FOUND')
                         continue;
-                    if (!(error instanceof ServiceError) || error.code !== 'ARTIFACT_MANIFEST_INVALID')
+                    if (!recoverableManifestError(error))
                         throw error;
-                    let interrupted;
                     try {
-                        interrupted = await interruptedManifestState(candidate, undefined, signal);
+                        await unlink(candidate);
                     }
-                    catch (interruptedError) {
-                        if (interruptedError instanceof ServiceError &&
-                            interruptedError.code === 'ARTIFACT_NOT_FOUND')
-                            continue;
-                        throw interruptedError;
+                    catch (unlinkError) {
+                        if (unlinkError.code !== 'ENOENT')
+                            throw unlinkError;
                     }
-                    if (!interrupted.interrupted)
+                    usage.entries = Math.max(0, usage.entries - 1);
+                    usage.bytes = Math.max(0, usage.bytes - metadata.size);
+                    continue;
+                }
+                try {
+                    if (child.name !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`) {
+                        throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest filename does not match its contents');
+                    }
+                    assertManifestAddressIntegrity(manifest, {
+                        sha256: path.basename(directory),
+                        provenanceHash: manifest.provenanceHash,
+                        name: manifest.name,
+                    });
+                }
+                catch (error) {
+                    if (!recoverableManifestError(error))
                         throw error;
                     try {
                         await unlink(candidate);
@@ -711,17 +776,9 @@ export class ArtifactStore {
                             throw unlinkError;
                     }
                     usage.entries = Math.max(0, usage.entries - 1);
-                    usage.bytes = Math.max(0, usage.bytes - interrupted.size);
+                    usage.bytes = Math.max(0, usage.bytes - metadata.size);
                     continue;
                 }
-                if (child.name !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`) {
-                    throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest filename does not match its contents');
-                }
-                assertManifestAddressIntegrity(manifest, {
-                    sha256: path.basename(directory),
-                    provenanceHash: manifest.provenanceHash,
-                    name: manifest.name,
-                });
                 const targetPath = await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, path.join(directory, manifest.name)));
                 let targetBytes = 0;
                 try {
@@ -867,15 +924,10 @@ export class ArtifactStore {
                     await walk(await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, candidate)));
                 }
                 else if (entry.isFile() && entry.name.endsWith('.manifest.json')) {
-                    const manifest = await readArtifactManifest(await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, candidate)), signal);
-                    if (entry.name !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`) {
-                        throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest filename does not match its contents');
-                    }
-                    assertManifestIntegrity(manifest, {
-                        sha256: path.basename(directory),
-                        provenanceHash: manifest.provenanceHash,
-                        name: manifest.name,
-                    }, workspace);
+                    await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, candidate));
+                    const manifest = await enumerableArtifactManifest(workspace, directory, entry.name, signal);
+                    if (manifest === undefined)
+                        continue;
                     results.push({
                         uri: this.uri(workspace.id, manifest.sha256, manifest.provenanceHash, manifest.name),
                         name: manifest.name,
@@ -908,15 +960,10 @@ export class ArtifactStore {
         let hasMore = false;
         const visitManifest = async (directory, entryName) => {
             signal?.throwIfAborted();
-            const manifest = await readArtifactManifest(await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, path.join(directory, entryName))), signal);
-            if (entryName !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`) {
-                throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest filename does not match its contents');
-            }
-            assertManifestIntegrity(manifest, {
-                sha256: path.basename(directory),
-                provenanceHash: manifest.provenanceHash,
-                name: manifest.name,
-            }, workspace);
+            await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, path.join(directory, entryName)));
+            const manifest = await enumerableArtifactManifest(workspace, directory, entryName, signal);
+            if (manifest === undefined)
+                return;
             const uri = this.uri(workspace.id, manifest.sha256, manifest.provenanceHash, manifest.name);
             revision.update(`${Buffer.byteLength(uri, 'utf8')}:${uri}`);
             total += 1;
@@ -989,6 +1036,20 @@ export class ArtifactStore {
             path: await containedGeneratedPath(workspace.artifactRoot, parsed.sha256.slice(0, 2), parsed.sha256, parsed.name),
         };
     }
+    async available(workspace, artifacts, signal) {
+        for (const artifact of artifacts) {
+            signal?.throwIfAborted();
+            try {
+                await this.describe(workspace, artifact.uri, signal);
+            }
+            catch (error) {
+                if (recoverableManifestError(error))
+                    return false;
+                throw error;
+            }
+        }
+        return true;
+    }
     async put(workspace, name, mimeType, content, provenance, description, signal) {
         return this.withAtomicWrites(workspace, [
             {

package/dist/hoi4_agent_tools/gui/assets.js

@@ -156,6 +156,7 @@ export class GuiAssetCatalog {
     constructor(graph, scannedFiles, budget = new RenderBudget(), language = 'l_english') {
         this.graph = graph;
         this.budget = budget;
+        const sourceLoadOrder = new Map(scannedFiles.map((file) => [file.displayPath, file.loadOrder]));
         for (const file of scannedFiles
             .filter((candidate) => candidate.shadowedBy === undefined)
             .sort((left, right) => compareCodeUnits(left.relativePath, right.relativePath))) {
@@ -167,25 +168,38 @@ export class GuiAssetCatalog {
             this.basenames.set(basename, candidates);
         }
         const normalizedLanguage = language.toLocaleLowerCase('en-US');
-        for (const definition of graph.fonts) {
+        const eligibleFonts = graph.fonts.filter((definition) => definition.languages.length === 0 ||
+            definition.languages.some((candidate) => candidate.toLocaleLowerCase('en-US') === normalizedLanguage));
+        const definitionPriority = (definition) => {
+            const languageMatch = definition.languages.some((candidate) => candidate.toLocaleLowerCase('en-US') === normalizedLanguage);
+            return [
+                languageMatch ? 1 : 0,
+                sourceLoadOrder.get(definition.sourcePath) ?? 0,
+                languageMatch === definition.override ? 1 : 0,
+            ];
+        };
+        const higherPriority = (left, right) => {
+            const leftPriority = definitionPriority(left);
+            const rightPriority = definitionPriority(right);
+            for (let index = 0; index < leftPriority.length; index += 1) {
+                if (leftPriority[index] !== rightPriority[index])
+                    return leftPriority[index] > rightPriority[index];
+            }
+            return false;
+        };
+        for (const definition of eligibleFonts) {
             const key = definition.name.toLocaleLowerCase('en-US');
             const existing = this.fontDefinitions.get(key);
-            const definitionMatches = definition.languages.some((candidate) => candidate.toLocaleLowerCase('en-US') === normalizedLanguage);
-            const existingMatches = existing?.languages.some((candidate) => candidate.toLocaleLowerCase('en-US') === normalizedLanguage) ?? false;
-            if (existing === undefined ||
-                (definitionMatches && !existingMatches) ||
-                (definitionMatches === existingMatches && existing.override && !definition.override) ||
-                (definitionMatches === existingMatches &&
-                    existing.languages.length > 0 &&
-                    definition.languages.length === 0))
+            if (existing === undefined || higherPriority(definition, existing))
                 this.fontDefinitions.set(key, definition);
         }
         const baseDefinitions = new Map();
-        for (const definition of graph.fonts) {
+        for (const definition of eligibleFonts) {
             if (definition.override || definition.languages.length > 0)
                 continue;
             const key = definition.name.toLocaleLowerCase('en-US');
-            if (!baseDefinitions.has(key))
+            const existing = baseDefinitions.get(key);
+            if (existing === undefined || higherPriority(definition, existing))
                 baseDefinitions.set(key, definition);
         }
         for (const [key, definition] of this.fontDefinitions) {
@@ -211,7 +225,14 @@ export class GuiAssetCatalog {
         const extension = path.posix.extname(normalized);
         const rasterExtensions = ['.png', '.bmp', '.tga', '.dds', '.svg'];
         const normalizedCandidates = extension.length === 0
-            ? [normalized, `${normalized}.fnt`, `${normalized}.ttf`, `${normalized}.otf`]
+            ? [
+                normalized,
+                `${normalized}.fnt`,
+                `${normalized}.ttf`,
+                `${normalized}.otf`,
+                `${normalized}.woff`,
+                `${normalized}.woff2`,
+            ]
             : rasterExtensions.includes(extension)
                 ? [
                     normalized,

package/dist/hoi4_agent_tools/gui/layout.js

@@ -460,11 +460,9 @@ function colourRunsForLine(catalog, fontName, line, colours, fontSize, work, inl
         return [];
     const runs = [];
     let start = 0;
-    let offsetX = 0;
     while (start < line.length) {
         const inlineIcon = inlineIcons.get(line[start] ?? '');
         if (inlineIcon !== undefined) {
-            offsetX += inlineIcon.width;
             start += 1;
             continue;
         }
@@ -475,10 +473,12 @@ function colourRunsForLine(catalog, fontName, line, colours, fontSize, work, inl
             (colours[end] ?? defaultColour) === colour)
             end += 1;
         const text = line.slice(start, end);
-        work.spendTextLayout('localisation colour-run measurement');
-        const width = measureTextWithInlineIcons(catalog, fontName, text, fontSize, inlineIcons).width;
+        work.spendTextLayout('localisation colour-run prefix measurement');
+        const offsetX = measureTextWithInlineIcons(catalog, fontName, line.slice(0, start), fontSize, inlineIcons).width;
+        work.spendTextLayout('localisation colour-run end measurement');
+        const endX = measureTextWithInlineIcons(catalog, fontName, line.slice(0, end), fontSize, inlineIcons).width;
+        const width = Math.max(0, endX - offsetX);
         runs.push({ text, colour, offsetX, width });
-        offsetX += width;
         start = end;
     }
     return runs;

package/dist/hoi4_agent_tools/gui/renderer.js

@@ -137,15 +137,15 @@ function renderText(element, toolText) {
                 const key = `${element.id}:${index}:${runIndex}:${run.colour}`;
                 const clipId = `gui-font-run-clip-${sha256Bytes(key).slice(0, 20)}`;
                 const runX = originX + run.offsetX * horizontalScale;
-                definitions.push(`<clipPath id="${clipId}"><rect x="${finite(runX - 0.25)}" y="${finite(lineTop)}" width="${finite(run.width * horizontalScale + 0.5)}" height="${finite(text.lineHeight)}"/></clipPath>`);
+                definitions.push(`<clipPath id="${clipId}"><rect x="${finite(runX - 0.25)}" y="${finite(lineTop - text.lineHeight)}" width="${finite(run.width * horizontalScale + 0.5)}" height="${finite(text.lineHeight * 3)}"/></clipPath>`);
                 const glyphs = actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale);
                 if (glyphLine.source === 'bmfont-atlas') {
                     const maskId = `gui-font-mask-${sha256Bytes(key).slice(0, 20)}`;
                     const runRect = {
                         x: runX - 0.25,
-                        y: lineTop,
+                        y: lineTop - text.lineHeight,
                         width: run.width * horizontalScale + 0.5,
-                        height: text.lineHeight,
+                        height: text.lineHeight * 3,
                     };
                     return `<g clip-path="url(#${clipId})" data-font-colour="${run.colour}">${bitmapTintMarkup(maskId, run.colour, glyphs, runRect)}</g>`;
                 }

package/dist/hoi4_agent_tools/gui/scenario-generator.js

@@ -52,6 +52,9 @@ class ScenarioRandom {
     integer(minimum, maximum) {
         return Math.floor(this.next() * (maximum - minimum + 1)) + minimum;
     }
+    ordinary() {
+        return (this.next() + this.next() + this.next()) / 3;
+    }
     pick(values) {
         return values[Math.min(values.length - 1, Math.floor(this.next() * values.length))];
     }
@@ -182,18 +185,64 @@ function plausibleText(key, random, samples, scopedCountries) {
 function generatedNumber(options, random, minimum = options.numericMinimum, maximum = options.numericMaximum) {
     const boundedMinimum = Math.max(options.numericMinimum, minimum);
     const boundedMaximum = Math.min(options.numericMaximum, maximum);
-    const low = Math.min(boundedMinimum, boundedMaximum);
-    const high = Math.max(boundedMinimum, boundedMaximum);
-    const value = low + random.next() * (high - low);
+    const [low, high] = boundedMinimum <= boundedMaximum
+        ? [boundedMinimum, boundedMaximum]
+        : maximum < options.numericMinimum
+            ? [maximum, maximum]
+            : [minimum, minimum];
+    const value = low + random.ordinary() * (high - low);
     return options.integerValues ? Math.round(value) : Math.round(value * 100) / 100;
 }
-function generatedNumberForKey(key, options, random) {
+function sourceNumericConstraints(texts) {
+    const ranges = new Map();
+    const relationships = [];
+    const update = (key, range) => {
+        const current = ranges.get(key) ?? {};
+        const minimum = range.minimum === undefined
+            ? current.minimum
+            : current.minimum === undefined
+                ? range.minimum
+                : Math.max(current.minimum, range.minimum);
+        const maximum = range.maximum === undefined
+            ? current.maximum
+            : current.maximum === undefined
+                ? range.maximum
+                : Math.min(current.maximum, range.maximum);
+        ranges.set(key, {
+            ...(minimum === undefined ? {} : { minimum }),
+            ...(maximum === undefined ? {} : { maximum }),
+        });
+    };
+    const token = String.raw `\[\?([^\]|]+)(?:\|[^\]]+)?\]`;
+    for (const text of texts) {
+        for (const match of text.matchAll(new RegExp(`${token}\\s*(?:/|of)\\s*(-?(?:\\d+\\.?\\d*|\\.\\d+))`, 'giu'))) {
+            const key = match[1];
+            const maximum = Number(match[2]);
+            if (key !== undefined && Number.isFinite(maximum))
+                update(key, { maximum });
+        }
+        for (const match of text.matchAll(new RegExp(`(-?(?:\\d+\\.?\\d*|\\.\\d+))\\s*(?:-|to)\\s*${token}`, 'giu'))) {
+            const minimum = Number(match[1]);
+            const key = match[2];
+            if (key !== undefined && Number.isFinite(minimum))
+                update(key, { minimum });
+        }
+        for (const match of text.matchAll(new RegExp(`${token}\\s*(?:/|of)\\s*${token}`, 'giu'))) {
+            const value = match[1];
+            const limit = match[2];
+            if (value !== undefined && limit !== undefined)
+                relationships.push({ value, limit });
+        }
+    }
+    return { ranges, relationships };
+}
+function generatedNumberForKey(key, options, random, inferred = {}) {
     const lower = key.toLocaleLowerCase('en-US');
     if (/(?:ratio|fraction|progress)$/u.test(lower))
-        return generatedNumber(options, random, 0, 1);
+        return generatedNumber(options, random, inferred.minimum ?? 0, inferred.maximum ?? 1);
     if (/(?:percent|percentage|support|stability|war_support|legitimacy|threat|charge)/u.test(lower))
-        return generatedNumber(options, random, 0, 100);
-    return generatedNumber(options, random);
+        return generatedNumber(options, random, inferred.minimum ?? 0, inferred.maximum ?? 100);
+    return generatedNumber(options, random, inferred.minimum ?? options.numericMinimum, inferred.maximum ?? options.numericMaximum);
 }
 function setIfMissing(target, key, value) {
     target[key] ??= value;
@@ -419,7 +468,9 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
         return [];
     const scripted = relatedScriptedGuis(graph, windowName);
     const elements = relevantElements(graph, windowName, scripted);
-    const tokens = tokensIn(sourceTexts(graph, elements, base.language, scripted));
+    const relevantSourceTexts = sourceTexts(graph, elements, base.language, scripted);
+    const tokens = tokensIn(relevantSourceTexts);
+    const numericConstraints = sourceNumericConstraints(relevantSourceTexts);
     const imageTokens = new Set();
     const booleanTokens = new Set();
     const frameTokens = new Set();
@@ -482,7 +533,7 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
         const elementStates = { ...base.elementStates };
         const scopedCountries = new Map();
         for (const key of tokens.numeric)
-            setIfMissing(values, key, generatedNumberForKey(key, options, random));
+            setIfMissing(values, key, generatedNumberForKey(key, options, random, numericConstraints.ranges.get(key)));
         for (const [elementName, { minimum, maximum }] of progressRanges) {
             const element = elements.find(({ name }) => name === elementName);
             const startValueToken = typeof element?.attributes.startValue === 'string'
@@ -507,6 +558,16 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
             if (typeof sourceValue === 'number')
                 values[key] = sourceValue;
         }
+        for (const { value: valueKey, limit: limitKey } of numericConstraints.relationships) {
+            if (base.values[valueKey] !== undefined)
+                continue;
+            const value = values[valueKey];
+            const limit = values[limitKey];
+            if (typeof value !== 'number' || typeof limit !== 'number')
+                continue;
+            const minimum = Math.min(numericConstraints.ranges.get(valueKey)?.minimum ?? options.numericMinimum, limit);
+            values[valueKey] = Math.max(minimum, Math.min(value, limit));
+        }
         for (const key of tokens.textual)
             setIfMissing(values, key, plausibleText(key, random, options.textSamples, scopedCountries));
         const scriptedTextTemplates = new Map();

package/dist/hoi4_agent_tools/gui/source-graph.js

@@ -208,15 +208,44 @@ function boolScalar(block, ...keys) {
         return false;
     return undefined;
 }
+function colourChannels(value) {
+    if (value === undefined)
+        return undefined;
+    const channels = value.entries
+        .filter((entry) => entry.type === 'scalar')
+        .map((entry) => Number(entry.value));
+    if (channels.length < 3 || channels.slice(0, 4).some((channel) => !Number.isFinite(channel)))
+        return undefined;
+    const normalized = channels.slice(0, 4).every((channel) => channel >= 0 && channel <= 1);
+    const bytes = channels
+        .slice(0, 4)
+        .map((channel) => Math.max(0, Math.min(255, Math.round(channel * (normalized ? 255 : 1)))));
+    while (bytes.length < 4)
+        bytes.push(255);
+    return `#${bytes.map((channel) => channel.toString(16).padStart(2, '0')).join('')}`;
+}
 function paradoxColour(value) {
     if (value === undefined)
         return undefined;
-    const match = /^0x([0-9a-f]{8})$/iu.exec(value.trim());
+    const match = /^0x([0-9a-f]{6}|[0-9a-f]{8})$/iu.exec(value.trim());
     if (match === null)
         return undefined;
+    if (match[1].length === 6)
+        return `#${match[1].toLowerCase()}ff`;
     const argb = match[1];
     return `#${argb.slice(2)}${argb.slice(0, 2)}`.toLowerCase();
 }
+function colourFrom(block, ...keys) {
+    const normalized = new Set(keys.map((key) => key.toLowerCase()));
+    for (const assignment of assignments(block)) {
+        if (!normalized.has(assignment.key.value.toLowerCase()))
+            continue;
+        if (assignment.value.type === 'scalar')
+            return paradoxColour(assignment.value.value);
+        return colourChannels(assignment.value);
+    }
+    return undefined;
+}
 function textColoursFrom(block) {
     const textColours = childBlocks(block, 'textcolors')[0];
     if (textColours === undefined)
@@ -225,15 +254,9 @@ function textColoursFrom(block) {
     for (const entry of assignments(textColours)) {
         if (entry.value.type !== 'block')
             continue;
-        const channels = entry.value.entries
-            .filter((channel) => channel.type === 'scalar')
-            .map((channel) => Number(channel.value));
-        if (channels.length < 3 || channels.slice(0, 3).some((channel) => !Number.isFinite(channel)))
-            continue;
-        const [red, green, blue] = channels.map((channel) => Math.max(0, Math.min(255, Math.round(channel))));
-        result[entry.key.value] = `#${red.toString(16).padStart(2, '0')}${green
-            .toString(16)
-            .padStart(2, '0')}${blue.toString(16).padStart(2, '0')}`;
+        const colour = colourChannels(entry.value);
+        if (colour !== undefined)
+            result[entry.key.value] = colour.slice(0, 7);
     }
     return result;
 }
@@ -462,8 +485,8 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                     addEdge(edges, 'contains', fileNodeId, id, true, {}, definition.location);
                 }
             }
-            else if (assignment.key.value === 'bitmapfont' ||
-                assignment.key.value === 'bitmapfont_override') {
+            else if (assignment.key.value.toLowerCase() === 'bitmapfont' ||
+                assignment.key.value.toLowerCase() === 'bitmapfont_override') {
                 const name = firstScalarInsensitive(child, 'name');
                 if (name !== undefined) {
                     const assetPaths = [firstScalarInsensitive(child, 'path')]
@@ -474,10 +497,10 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                     const languages = childBlocks(child, 'languages').flatMap((languageBlock) => languageBlock.entries
                         .filter((entry) => entry.type === 'scalar')
                         .map((entry) => entry.value));
-                    const colour = paradoxColour(firstScalarInsensitive(child, 'color', 'colour'));
-                    const borderColour = paradoxColour(firstScalarInsensitive(child, 'border_color', 'borderColor', 'border_colour'));
+                    const colour = colourFrom(child, 'color', 'colour');
+                    const borderColour = colourFrom(child, 'border_color', 'borderColor', 'border_colour');
                     const textColours = textColoursFrom(child);
-                    const override = assignment.key.value === 'bitmapfont_override';
+                    const override = assignment.key.value.toLowerCase() === 'bitmapfont_override';
                     const id = deterministicId('gui_font', {
                         path: file.displayPath,
                         name,
@@ -519,7 +542,7 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                     addEdge(edges, 'contains', fileNodeId, id, true, {}, font.location);
                 }
             }
-            if (assignment.key.value === 'bitmapfonts') {
+            if (assignment.key.value.toLowerCase() === 'bitmapfonts') {
                 Object.assign(globalTextColours, textColoursFrom(child));
             }
             walk(child);

package/dist/hoi4_agent_tools/probability/service.js

@@ -735,11 +735,12 @@ export class ProbabilityAnalyzer {
     }
     async store(result, outputs, includeHtml = false, signal, principal) {
         const cached = this.state.byCacheKey.get(result.metadata.cacheKey);
+        const workspace = this.engine.resolver.get(result.metadata.workspaceId, principal);
         if (cached?.operation === result.operation &&
             cached.status === result.status &&
-            visualOutputs(outputs).length === 0)
+            visualOutputs(outputs).length === 0 &&
+            (await this.engine.artifacts.available(workspace, cached.resources, signal)))
             return cached;
-        const workspace = this.engine.resolver.get(result.metadata.workspaceId, principal);
         const provenance = {
             kind: 'probability-analysis',
             toolVersion: PACKAGE_VERSION,

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

package/docs/gui.md

@@ -41,7 +41,7 @@ Scripted-GUI composition follows `parent_scripted_gui` chains even when the link
 
 `hoi4.gui_inspect` and `hoi4.gui_render` generate a plausible seeded runtime scenario by default. The generator follows the complete `parent_scripted_gui` surface, discovers numeric and text tokens in GUI localisation and scripted-GUI properties, chooses real scripted-localisation text and sprite candidates, applies simple source thresholds, fills meters within their declared ranges, populates dynamic lists with coherent rows, selects one overlapping tab pane, keeps active and idle controls mutually exclusive, and leaves values explicitly supplied by the caller unchanged. Normal controls and animation frames remain stable unless variation is explicitly requested. Every explicit `relatedScenarios` entry is rendered beside the generated view.
 
-Generation is reproducible. Set `generatedScenarios.seed` to any stable string for an exact rerun, use `count` for several plausible versions, or configure numeric bounds, integer or decimal values, list row bounds, text samples, visibility probability, and state variation. The generated view is the default. Set `enabled` to `false` when only the supplied placeholder scenario should render, or set `preservePlaceholder` to `true` to include the placeholder beside generated scenarios.
+Generation is reproducible. Set `generatedScenarios.seed` to any stable string for an exact rerun, use `count` for several plausible versions, or configure numeric bounds, integer or decimal values, list row bounds, text samples, visibility probability, and state variation. Generated numeric values favour ordinary mid-range states, obey literal limits such as `[?capacity]/10`, keep displayed current/limit pairs coherent, and remain inside progress-bar ranges. The generated view is the default. Set `enabled` to `false` when only the supplied placeholder scenario should render, or set `preservePlaceholder` to `true` to include the placeholder beside generated scenarios.
 
 ```json
 {
@@ -95,4 +95,4 @@ The renderer does not run the game engine. Each render includes a fidelity repor
 
 The generated primary view replaces discovered numeric and text runtime tokens with plausible values. Set `generatedScenarios.preservePlaceholder` to `true`, or disable generation, when the same run should also show unresolved numeric values such as `[?variable|format]` as `[X]` and unresolved text-returning scripted or scoped localisation such as `[GetStatusText]`, `[FROM.GetName]`, and `[?leader_scope.GetName]` as `[dynamic_loc]`. Put `variable` or `GetStatusText` in the supplied scenario's `values` object when an exact value matters; explicit values always take precedence over generated ones and can drive the related meter or state-dependent controls. Supported HOI4 `§` localisation colour controls use the active font's palette and `§!` restores the face colour.
 
-A rewrite stops if malformed or unsupported GUI script makes the requested change ambiguous. Frame-sheet animation, nine-slice tiling, progress composition, masking, and the primary and secondary textures referenced by vanilla GFX definitions render offline. Engine shader programs, hardcoded controls, and dynamic values that are not supplied by a scenario remain fidelity-report entries; an unexecuted shader never hides its resolved base texture.
+A rewrite stops if malformed or unsupported GUI script makes the requested change ambiguous. Frame-sheet animation, nine-slice tiling, progress composition, masking, and the primary and secondary textures referenced by vanilla GFX definitions render offline. Font selection follows mod/game load order and preview language, accepts Paradox hex and numeric color declarations, and uses the supplied HOI4 bitmap or outline font assets without requiring host font installation. Engine shader programs, hardcoded controls, and dynamic values that are not supplied by a scenario remain fidelity-report entries; an unexecuted shader never hides its resolved base texture.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hoi4-agent-tools",
   "mcpName": "io.github.klimPaskov/hoi4-agent-tools",
-  "version": "2.8.6",
+  "version": "2.8.8",
   "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.6/schemas/configuration.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/continuous-focus-palette.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/custom-weighted-pool.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/event-feature-manifest.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/focus-plan.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/focus-planning-sidecar.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/gui-animation-source.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/gui-helper.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/gui-scenario.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/map-operation.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/operation-result.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/probability-analysis-result.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/probability-compare-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/probability-evaluate-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/probability-inspect-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/probability-render-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/probability-scenario-set.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/probability-sequence-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/probability-simulate-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6/schemas/probability-sweep-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.8/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.6",
+  "version": "2.8.8",
   "repository": {
     "url": "https://github.com/klimPaskov/hoi4-agent-tools",
     "source": "github"
@@ -13,7 +13,7 @@
     {
       "registryType": "npm",
       "identifier": "hoi4-agent-tools",
-      "version": "2.8.6",
+      "version": "2.8.8",
       "transport": {
         "type": "stdio"
       }