hoi4-agent-tools 3.0.8 → 3.1.0

package/dist/hoi4_agent_tools/focus/tool-support.js

@@ -0,0 +1,123 @@
+import { compareCodeUnits } from '../core/canonical.js';
+import { ServiceError } from '../core/result.js';
+import { parseClausewitz } from '../core/source/index.js';
+import { enrichFocusPlanFromSidecar, focusPlanningSidecarPath, importContinuousFocusPalettes, importFocusTrees, linkContinuousFocusPalettes, parseFocusPlanningSidecar, } from './index.js';
+function normalizedRoot(value) {
+    return value.replaceAll('\\', '/').replace(/^\.\//u, '').replace(/\/+$/u, '').toLowerCase();
+}
+export function underConfiguredRoot(relativePath, roots) {
+    const candidate = relativePath.replaceAll('\\', '/').toLowerCase();
+    return roots.some((root) => {
+        const normalized = normalizedRoot(root);
+        return candidate === normalized || candidate.startsWith(`${normalized}/`);
+    });
+}
+export function activeFocusFiles(snapshot, focusRoots) {
+    return snapshot.files.filter(({ relativePath, shadowedBy }) => shadowedBy === undefined &&
+        underConfiguredRoot(relativePath, focusRoots) &&
+        relativePath.toLowerCase().endsWith('.txt'));
+}
+export function activeContinuousFocusFiles(snapshot) {
+    return snapshot.files.filter(({ relativePath, shadowedBy }) => shadowedBy === undefined &&
+        relativePath.replaceAll('\\', '/').toLowerCase().startsWith('common/continuous_focus/') &&
+        relativePath.toLowerCase().endsWith('.txt'));
+}
+export function continuousPalettes(snapshot) {
+    const palettes = [];
+    const diagnostics = [];
+    for (const file of activeContinuousFocusFiles(snapshot)) {
+        const document = parseClausewitz(file.bytes, file.displayPath);
+        const imported = importContinuousFocusPalettes(document);
+        palettes.push(...imported.continuousFocusPalettes);
+        diagnostics.push(...imported.diagnostics);
+    }
+    return { palettes, diagnostics };
+}
+export function activeSidecar(snapshot, focusFile) {
+    const relativePath = focusPlanningSidecarPath(focusFile.relativePath).toLowerCase();
+    const file = snapshot.files.find((candidate) => candidate.shadowedBy === undefined && candidate.relativePath.toLowerCase() === relativePath);
+    return file === undefined ? undefined : { file, sidecar: parseFocusPlanningSidecar(file.bytes) };
+}
+export function importFocusFile(snapshot, file, palettes) {
+    const document = parseClausewitz(file.bytes, file.displayPath);
+    const imported = importFocusTrees(document, { references: referenceCatalog(snapshot) });
+    const sidecar = activeSidecar(snapshot, file);
+    imported.plans = imported.plans.map((plan) => {
+        const enriched = sidecar === undefined
+            ? { plan, diagnostics: [] }
+            : enrichFocusPlanFromSidecar(plan, sidecar.sidecar);
+        imported.diagnostics.push(...enriched.diagnostics);
+        return linkContinuousFocusPalettes(enriched.plan, palettes);
+    });
+    return imported;
+}
+export function selectedFocusFile(snapshot, focusRoots, relativePath) {
+    const file = activeFocusFiles(snapshot, focusRoots).find((candidate) => candidate.relativePath === relativePath);
+    if (file === undefined)
+        throw new ServiceError('FOCUS_SOURCE_NOT_FOUND', `Focus source was not found: ${relativePath}`);
+    return file;
+}
+export function selectedContinuousFocusFile(snapshot, relativePath) {
+    const file = activeContinuousFocusFiles(snapshot).find((candidate) => candidate.relativePath === relativePath);
+    if (file === undefined)
+        throw new ServiceError('CONTINUOUS_FOCUS_SOURCE_NOT_FOUND', `Continuous focus source was not found: ${relativePath}`);
+    return file;
+}
+export function selectPlan(result, treeId) {
+    if (result.plans.length === 0)
+        throw new ServiceError('FOCUS_TREE_NOT_FOUND', 'The source file contains no focus tree');
+    if (treeId === undefined) {
+        if (result.plans.length !== 1)
+            throw new ServiceError('FOCUS_TREE_ID_REQUIRED', 'The source file contains multiple focus trees; provide treeId', { treeIds: result.plans.map(({ id }) => id) });
+        return result.plans[0];
+    }
+    const plan = result.plans.find(({ id }) => id === treeId);
+    if (plan === undefined)
+        throw new ServiceError('FOCUS_TREE_NOT_FOUND', `Focus tree was not found: ${treeId}`);
+    return plan;
+}
+export function selectContinuousPlan(result, paletteId) {
+    if (result.continuousFocusPalettes.length === 0)
+        throw new ServiceError('CONTINUOUS_FOCUS_PALETTE_NOT_FOUND', 'The source file contains no continuous focus palette');
+    if (paletteId === undefined) {
+        if (result.continuousFocusPalettes.length !== 1)
+            throw new ServiceError('CONTINUOUS_FOCUS_PALETTE_ID_REQUIRED', 'The source file contains multiple continuous focus palettes; provide paletteId', { paletteIds: result.continuousFocusPalettes.map(({ id }) => id) });
+        return result.continuousFocusPalettes[0];
+    }
+    const plan = result.continuousFocusPalettes.find(({ id }) => id === paletteId);
+    if (plan === undefined)
+        throw new ServiceError('CONTINUOUS_FOCUS_PALETTE_NOT_FOUND', `Continuous focus palette was not found: ${paletteId}`);
+    return plan;
+}
+export function referenceCatalog(snapshot) {
+    const identifiers = (kind) => [
+        ...new Set(snapshot.index
+            .findAll(kind)
+            .filter(({ overridden }) => !overridden)
+            .map(({ id }) => id)),
+    ].sort((left, right) => compareCodeUnits(left, right));
+    return {
+        decision: identifiers('decision'),
+        decision_category: identifiers('decision_category'),
+        event: identifiers('event'),
+        idea: identifiers('idea'),
+        leader: identifiers('leader'),
+        formable: identifiers('formable'),
+        helper: identifiers('scripted_effect'),
+    };
+}
+export function validationFromDiagnostics(diagnostics) {
+    const blocking = diagnostics.filter(({ severity }) => severity === 'error' || severity === 'blocker');
+    return {
+        passed: blocking.length === 0,
+        checks: [
+            {
+                id: 'focus-diagnostics',
+                passed: blocking.length === 0,
+                message: blocking.length === 0
+                    ? 'Focus source, references, and layout have no blocking diagnostics'
+                    : `${blocking.length} blocking focus diagnostics`,
+            },
+        ],
+    };
+}

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

@@ -0,0 +1,81 @@
+import { z } from 'zod/v4';
+import { IdleCacheLifetime } from '../core/idle-cache-lifetime.js';
+import { errorResult, toolResult } from '../core/operation-result.js';
+import { ServiceError } from '../core/result.js';
+import { guiInspectRequestSchema, guiRenderRequestSchema, guiRewriteRequestSchema, } from '../schemas/gui-requests.js';
+import { ScriptedGuiStudio } from './studio.js';
+import { inspectGui, completeGuiRewrite, normalizeGuiInspectRequest, normalizeGuiRenderRequest, normalizeGuiRewriteRequest, prepareGuiRewrite, renderGui, } from './tool-operations.js';
+const wireResult = z.record(z.string(), z.json());
+/** Registers read-only GUI operations without invoking transport handlers. */
+export function registerGuiJobs(operations, engine) {
+    const studio = new ScriptedGuiStudio(engine);
+    const lifetime = new IdleCacheLifetime(() => studio.clearCaches());
+    function register(name, schema, normalize, execute) {
+        operations.registerRead(name, schema, async (input, context) => {
+            const release = lifetime.begin();
+            try {
+                if (input.workspaceId !== 'current' && input.workspaceId !== context.workspaceId)
+                    throw new ServiceError('JOB_ARGUMENT_SCOPE_MISMATCH', 'The request workspace does not match the authorized job workspace');
+                const result = await execute(studio, normalize(input), {
+                    workspaceId: context.workspaceId,
+                    ...(context.principal === undefined ? {} : { principal: context.principal }),
+                    signal: context.signal,
+                    progress: (completed, total, message) => context.progress({ completed, total, message }),
+                });
+                const wire = wireResult.parse(JSON.parse(JSON.stringify(toolResult(result))));
+                const revision = result.data !== null &&
+                    typeof result.data === 'object' &&
+                    'sourceRevision' in result.data &&
+                    typeof result.data.sourceRevision === 'string'
+                    ? result.data.sourceRevision
+                    : result.data !== null &&
+                        typeof result.data === 'object' &&
+                        'sharedRevision' in result.data &&
+                        typeof result.data.sharedRevision === 'string'
+                        ? result.data.sharedRevision
+                        : undefined;
+                if (revision !== undefined)
+                    await context.stageResult(wire, { sourceRevision: revision });
+                return wire;
+            }
+            catch (error) {
+                if (context.signal.aborted)
+                    throw error;
+                return wireResult.parse(JSON.parse(JSON.stringify(errorResult(error, context.workspaceId))));
+            }
+            finally {
+                release();
+            }
+        });
+    }
+    register('hoi4.gui_inspect', guiInspectRequestSchema, normalizeGuiInspectRequest, (studio, input, context) => inspectGui(engine, studio, input, context));
+    register('hoi4.gui_render', guiRenderRequestSchema, normalizeGuiRenderRequest, renderGui);
+    operations.registerWrite('hoi4.gui_rewrite', guiRewriteRequestSchema, async (input, context) => {
+        if (input.workspaceId !== 'current' && input.workspaceId !== context.workspaceId)
+            throw new ServiceError('JOB_ARGUMENT_SCOPE_MISMATCH', 'The request workspace does not match the authorized job workspace');
+        const release = lifetime.begin();
+        try {
+            return await prepareGuiRewrite(studio, normalizeGuiRewriteRequest(input), {
+                workspaceId: context.workspaceId,
+                ...(context.principal === undefined ? {} : { principal: context.principal }),
+                signal: context.signal,
+                progress: (completed, total, message) => context.progress({ completed, total, message }),
+            });
+        }
+        finally {
+            release();
+        }
+    }, async (_input, execution, _reconciled, recipe, context) => {
+        const result = completeGuiRewrite(context.workspaceId, execution, recipe);
+        await context.progress({
+            completed: 3,
+            total: 3,
+            message: execution.outcome === 'applied'
+                ? 'GUI rewrite complete'
+                : execution.outcome === 'unchanged'
+                    ? 'GUI content already satisfied the rewrite'
+                    : 'GUI rewrite blocked',
+        });
+        return wireResult.parse(JSON.parse(JSON.stringify(toolResult(result))));
+    });
+}

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

@@ -0,0 +1,119 @@
+import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.js';
+import { hasBlockingDiagnostics } from '../core/diagnostics.js';
+import { evaluateTriggerBlock } from '../core/condition-evaluator.js';
+import { resolveScopeContext, rootScopeContext } from '../core/scenario-state.js';
+import { assignments, firstScalar, parseClausewitz } from '../core/source/index.js';
+/** Keep declared scoped scalars out of exploratory value generation. */
+export function guiExplicitConditionValues(base) {
+    const values = { ...base.stateValues, ...base.variables, ...base.values };
+    for (const [key, value] of Object.entries(values)) {
+        if (key.includes('.'))
+            continue;
+        values[`ROOT.${key}`] ??= value;
+        values[`THIS.${key}`] ??= value;
+    }
+    for (const [scope, binding] of Object.entries(base.scopes ?? {})) {
+        for (const [key, value] of Object.entries(binding.state)) {
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+                values[`${scope}.${key}`] ??= value;
+        }
+    }
+    return values;
+}
+function parsedCondition(expression) {
+    const text = expression.trim();
+    const document = parseClausewitz(Buffer.from(`condition = ${text.startsWith('{') ? text : `{ ${text} }`}`), 'scenario:condition');
+    const assignment = assignments(document.root, 'condition')[0];
+    return {
+        ...(assignment?.value.type === 'block' ? { block: assignment.value } : {}),
+        invalid: hasBlockingDiagnostics(document.diagnostics) || assignment?.value.type !== 'block',
+    };
+}
+export function guiConditionScenario(base, values = base.values) {
+    const state = { ...base.stateValues, ...base.variables, ...values };
+    for (const [key, value] of Object.entries(base.flags))
+        state[`flag.${key}`] = value;
+    const scopes = structuredClone(base.scopes ?? {});
+    for (const [key, value] of Object.entries(state)) {
+        const match = /^(ROOT|THIS|FROM(?:\.FROM)*|PREV)\.(.+)$/u.exec(key);
+        if (match === null)
+            continue;
+        if (match[1] === 'ROOT' || match[1] === 'THIS')
+            state[match[2]] ??= value;
+        else {
+            const scope = (scopes[match[1]] ??= { id: match[1], state: {} });
+            scope.state[match[2]] ??= value;
+        }
+    }
+    const actor = base.country?.tag ?? base.country?.countryTag ?? base.country?.GetTag;
+    return {
+        id: base.id,
+        state,
+        scopes,
+        closedFlags: false,
+        ...(typeof actor === 'string' ? { actor } : {}),
+    };
+}
+export function evaluateGuiCondition(expression, scenario, subject, definitions = new ClausewitzEvaluationDefinitions(), scope = 'ROOT') {
+    const context = resolveScopeContext(scenario, scope, rootScopeContext(scenario));
+    const parsed = expression === undefined ? { invalid: false } : parsedCondition(expression);
+    if (parsed.invalid || context === undefined)
+        return {
+            state: 'unresolved',
+            unresolved: [
+                {
+                    code: 'GUI_CONDITION_UNRESOLVED',
+                    message: parsed.invalid
+                        ? 'Condition could not be parsed'
+                        : `Scenario does not declare scope ${scope}`,
+                    candidateId: subject.id,
+                },
+            ],
+        };
+    return evaluateTriggerBlock(parsed.block, scenario, subject, definitions, [], context);
+}
+/** Find operands structurally for exploratory previews, without asserting branch eligibility. */
+export function guiConditionVariables(expression, definitions) {
+    if (expression === undefined)
+        return [];
+    const parsed = parsedCondition(expression);
+    if (parsed.invalid || parsed.block === undefined)
+        return [];
+    const output = new Set();
+    const visit = (block, scope, stack) => {
+        const add = (key) => {
+            // Scoped operands need actual bindings; fabricated flat values can shadow ROOT/PREV.
+            if (scope === '' &&
+                key !== undefined &&
+                !key.includes('.') &&
+                !key.startsWith('@') &&
+                !key.startsWith('constant:') &&
+                !Number.isFinite(Number(key)))
+                output.add(key);
+        };
+        for (const assignment of assignments(block)) {
+            const key = assignment.key.value;
+            if (key === 'check_variable' && assignment.value.type === 'block') {
+                const short = assignments(assignment.value).find(({ key }) => !['var', 'value', 'compare', 'tooltip'].includes(key.value));
+                add(firstScalar(assignment.value, 'var')?.value ?? short?.key.value);
+                add(firstScalar(assignment.value, 'value')?.value ??
+                    (short?.value.type === 'scalar' ? short.value.value : undefined));
+            }
+            else if (assignment.value.type === 'block') {
+                const prefix = ['ROOT', 'THIS', 'FROM', 'PREV'].includes(key) ? `${key}.` : scope;
+                visit(assignment.value, prefix, stack);
+            }
+            else if (assignment.operator.text === '>' || assignment.operator.text === '<') {
+                add(key);
+                add(assignment.value.value);
+            }
+            else {
+                const helper = definitions.scriptedTriggers.get(key);
+                if (helper !== undefined && !stack.has(key))
+                    visit(helper.value, scope, new Set([...stack, key]));
+            }
+        }
+    };
+    visit(parsed.block, '', new Set());
+    return [...output].sort();
+}

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

@@ -1,4 +1,6 @@
 import { sha256Bytes } from '../core/canonical.js';
+import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.js';
+import { evaluateGuiCondition, guiConditionScenario, guiConditionVariables, guiExplicitConditionValues, } from './scenario-conditions.js';
 import { parsePreviewScenario } from './scenario.js';
 const countryNames = ['Germany', 'France', 'Poland', 'Italy', 'Brazil', 'India', 'Canada'];
 const countryTags = ['GER', 'FRA', 'POL', 'ITA', 'BRA', 'RAJ', 'CAN'];
@@ -257,70 +259,46 @@ function generatedNumberForKey(key, options, random, inferred = {}) {
 function setIfMissing(target, key, value) {
     target[key] ??= value;
 }
-function scriptedLocalisationValue(graph, token, language, random, kind, values) {
+function scriptedLocalisationValue(graph, token, language, kind, values, base, definitions, results) {
     const shortToken = token.slice(token.lastIndexOf('.') + 1);
-    const definitions = graph.scriptedLocalisation.filter(({ name }) => name === token || name === shortToken);
-    if (definitions.length === 0)
+    const definition = graph.scriptedLocalisation
+        .filter(({ name }) => name === token || name === shortToken)
+        .at(-1);
+    if (definition === undefined)
         return undefined;
-    const sprites = new Set(graph.sprites.map(({ name }) => name.toLocaleLowerCase('en-US')));
-    const choices = definitions.flatMap(({ choices }) => choices);
-    const eligible = choices.filter(({ localisationKey }) => kind === 'image'
-        ? sprites.has(localisationKey.toLocaleLowerCase('en-US'))
-        : localisationText(graph, language, localisationKey) !== undefined);
-    if (eligible.length === 0)
-        return undefined;
-    const evaluated = eligible.map((choice) => ({
-        choice,
-        result: evaluateSimpleTrigger(choice.triggerExpression, values),
-    }));
-    const matched = evaluated.find(({ result }) => result === true)?.choice;
-    const firstThreshold = evaluated
-        .map(({ choice }) => simpleThreshold(choice.triggerExpression))
-        .find((threshold) => threshold !== undefined && typeof values[threshold.variable] === 'number');
-    const unknownExists = evaluated.some(({ result }) => result === undefined);
-    const ranked = matched === undefined && unknownExists && firstThreshold !== undefined
-        ? eligible[Math.min(eligible.length - 1, Math.max(0, Math.round((1 - Math.max(0, Math.min(100, Number(values[firstThreshold.variable]))) / 100) *
-            (eligible.length - 1))))]
-        : undefined;
-    const fallback = evaluated.find(({ result }) => result === 'fallback')?.choice;
-    const selected = matched ?? ranked ?? fallback ?? random.pick(eligible);
-    if (kind === 'image')
-        return selected.localisationKey;
-    return localisationText(graph, language, selected.localisationKey);
-}
-function simpleThreshold(triggerExpression) {
-    if (triggerExpression === undefined)
-        return undefined;
-    const direct = /([A-Za-z_][A-Za-z0-9_.:^]*)\s*([<>])\s*(-?(?:\d+\.?\d*|\.\d+))/u.exec(triggerExpression);
-    if (direct !== null)
-        return {
-            variable: direct[1],
-            operator: direct[2],
-            threshold: Number(direct[3]),
-        };
-    const variable = /\bvar\s*=\s*([A-Za-z_][A-Za-z0-9_.:^]*)/u.exec(triggerExpression)?.[1];
-    const threshold = /\bvalue\s*=\s*(-?(?:\d+\.?\d*|\.\d+))/u.exec(triggerExpression)?.[1];
-    const compare = /\bcompare\s*=\s*(greater_than|less_than)/u.exec(triggerExpression)?.[1];
-    if (variable === undefined || threshold === undefined || compare === undefined)
-        return undefined;
-    return {
-        variable,
-        operator: compare === 'greater_than' ? '>' : '<',
-        threshold: Number(threshold),
+    const scenario = guiConditionScenario(base, values);
+    const subject = {
+        id: token,
+        provenance: [
+            {
+                path: definition.sourcePath,
+                rootKind: 'source',
+                loadOrder: 0,
+                sourceHash: graph.sourceHashes[definition.sourcePath] ?? '',
+                ...(definition.location === undefined ? {} : { location: definition.location }),
+            },
+        ],
     };
-}
-function evaluateSimpleTrigger(triggerExpression, values) {
-    if (triggerExpression === undefined || /\balways\s*=\s*yes\b/u.test(triggerExpression))
-        return 'fallback';
-    if (/\balways\s*=\s*no\b/u.test(triggerExpression))
-        return false;
-    const threshold = simpleThreshold(triggerExpression);
-    if (threshold === undefined)
-        return undefined;
-    const value = values[threshold.variable];
-    if (typeof value !== 'number')
-        return undefined;
-    return threshold.operator === '>' ? value > threshold.threshold : value < threshold.threshold;
+    const prefix = token.includes('.') ? token.slice(0, token.lastIndexOf('.')) : 'ROOT';
+    for (const choice of definition.choices) {
+        const result = evaluateGuiCondition(choice.triggerExpression, scenario, subject, definitions, prefix);
+        results.push({
+            token,
+            sourcePath: definition.sourcePath,
+            state: result.state,
+            localisationKey: choice.localisationKey,
+            unresolved: result.unresolved.map(({ message }) => message),
+        });
+        // An earlier unknown branch may be selected by the game; a later fallback cannot prove it false.
+        if (result.state === 'unresolved')
+            return undefined;
+        if (result.state === 'false')
+            continue;
+        return kind === 'image'
+            ? choice.localisationKey
+            : localisationText(graph, language, choice.localisationKey);
+    }
+    return undefined;
 }
 function materializeDynamicText(template, values) {
     const valueFor = (key) => {
@@ -481,7 +459,7 @@ function generatedRows(count, random, options) {
         };
     });
 }
-export function generateGuiPreviewScenarios(graph, windowName, base, options) {
+export function generateGuiPreviewScenarios(graph, windowName, base, options, definitions = new ClausewitzEvaluationDefinitions()) {
     if (!options.enabled)
         return [];
     const scripted = relatedScriptedGuis(graph, windowName);
@@ -519,9 +497,8 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
         if (![...relevantDynamicTokens].some((token) => token === definition.name || token.endsWith(`.${definition.name}`)))
             continue;
         for (const choice of definition.choices) {
-            const threshold = simpleThreshold(choice.triggerExpression);
-            if (threshold !== undefined)
-                tokens.numeric.add(threshold.variable);
+            for (const variable of guiConditionVariables(choice.triggerExpression, definitions))
+                tokens.numeric.add(variable);
         }
     }
     const progressRanges = new Map();
@@ -545,7 +522,10 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
     const sourceSeed = options.seed === 'auto' ? `${windowName}:${base.id}:${hashSourceGraph(graph)}` : options.seed;
     return Array.from({ length: options.count }, (_unused, scenarioIndex) => {
         const random = new ScenarioRandom(`${sourceSeed}:${scenarioIndex}`);
-        const values = { ...base.values };
+        const explicitValues = guiExplicitConditionValues(base);
+        const values = { ...explicitValues };
+        const conditionResults = [];
+        const scriptedTokens = new Set([...tokens.textual].filter((token) => graph.scriptedLocalisation.some(({ name }) => name === token || token.endsWith(`.${name}`))));
         const lists = Object.fromEntries(Object.entries(base.lists).map(([key, rows]) => [key, rows.map((row) => ({ ...row }))]));
         const visibility = generatedVisibility(graph, scripted, options, random, base.visibility);
         const elementStates = { ...base.elementStates };
@@ -571,7 +551,7 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
                 setIfMissing(values, startValueToken, value);
         }
         for (const key of tokens.numeric) {
-            if (!key.endsWith('_bar') || base.values[key] !== undefined)
+            if (!key.endsWith('_bar') || explicitValues[key] !== undefined)
                 continue;
             const sourceKey = key.slice(0, -'_bar'.length);
             const sourceValue = values[sourceKey];
@@ -579,7 +559,7 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
                 values[key] = sourceValue;
         }
         for (const { value: valueKey, limit: limitKey } of numericConstraints.relationships) {
-            if (base.values[valueKey] !== undefined)
+            if (explicitValues[valueKey] !== undefined)
                 continue;
             const value = values[valueKey];
             const limit = values[limitKey];
@@ -589,22 +569,27 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
             values[valueKey] = Math.max(minimum, Math.min(value, limit));
         }
         for (const key of tokens.textual)
-            setIfMissing(values, key, plausibleText(key, random, options.textSamples, scopedCountries));
+            if (!scriptedTokens.has(key))
+                setIfMissing(values, key, plausibleText(key, random, options.textSamples, scopedCountries));
         const scriptedTextTemplates = new Map();
         for (const key of tokens.textual) {
-            const scriptedValue = scriptedLocalisationValue(graph, key, base.language, random, 'text', values);
-            if (scriptedValue !== undefined && base.values[key] === undefined)
+            if (explicitValues[key] !== undefined)
+                continue;
+            const scriptedValue = scriptedLocalisationValue(graph, key, base.language, 'text', values, base, definitions, conditionResults);
+            if (scriptedValue !== undefined)
                 scriptedTextTemplates.set(key, scriptedValue);
         }
         for (let pass = 0; pass < 3; pass += 1)
             for (const [key, template] of scriptedTextTemplates)
                 values[key] = materializeDynamicText(template, values);
         for (const key of imageTokens) {
+            if (explicitValues[key] !== undefined)
+                continue;
             if (/(?:^|\.)GetFlag$/u.test(key)) {
                 setIfMissing(values, key, generatedCountryTag);
                 continue;
             }
-            const sprite = scriptedLocalisationValue(graph, key, base.language, random, 'image', values);
+            const sprite = scriptedLocalisationValue(graph, key, base.language, 'image', values, base, definitions, conditionResults);
             if (sprite !== undefined)
                 setIfMissing(values, key, sprite);
         }
@@ -625,7 +610,8 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
         return parsePreviewScenario({
             ...base,
             id: `${base.id}-${options.idPrefix}-${scenarioIndex + 1}`,
-            description: `Generated source-aware scenario ${scenarioIndex + 1} (seed ${sourceSeed})`,
+            description: `Generated exploratory preview ${scenarioIndex + 1} (seed ${sourceSeed}; not verified campaign state)`,
+            conditionResults,
             values,
             country: [...imageTokens].some((key) => /(?:^|\.)GetFlag$/u.test(key))
                 ? {

package/dist/hoi4_agent_tools/gui/scenario.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { ConditionScopeBindingSchema, ConditionResultSchema } from '../core/condition-schema.js';
 import { renderDimensionViolation, RENDER_MAX_DIMENSION } from '../core/render-budget.js';
 import { ServiceError } from '../core/result.js';
 import { GUI_SCENARIO_MAX_KEYS, GUI_SCENARIO_MAX_LIST_KEYS, GUI_SCENARIO_MAX_ROWS, GUI_SCENARIO_MAX_STRING_CHARACTERS, } from './limits.js';
@@ -120,6 +121,8 @@ const GuiPreviewScenarioBodySchema = z
     visibleTimeSeconds: z.number().min(0).max(86_400).optional(),
     country: objectSchema.optional(),
     stateValues: objectSchema.optional(),
+    scopes: z.record(z.string().max(256), ConditionScopeBindingSchema).optional(),
+    conditionResults: z.array(ConditionResultSchema).max(10_000).optional(),
     variables: z.record(z.string(), z.number()).default({}),
     flags: z.record(z.string(), z.boolean()).default({}),
     lists: z.record(z.string(), z.array(objectSchema).max(10_000)).default({}),

package/dist/hoi4_agent_tools/gui/studio.js

@@ -6,6 +6,7 @@ import { compareCodeUnits, canonicalJson, deterministicId, hashCanonical, sha256
 import { DiagnosticCollector } from '../core/diagnostic-collector.js';
 import { sortDiagnostics } from '../core/diagnostics.js';
 import { CoreEngine } from '../core/engine.js';
+import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.js';
 import { assertRenderDimensions, RenderBudget, RENDER_MAX_PIXELS } from '../core/render-budget.js';
 import { ServiceError } from '../core/result.js';
 import { WorkspaceScanner } from '../core/scanner.js';
@@ -25,6 +26,8 @@ import { buildGuiSourceGraph } from './source-graph.js';
 import { assertGuiSourcePatchesSafe } from './source-patch.js';
 import { validateGuiScene, validateResolutionDrift, validateStateMatrix } from './validators.js';
 const staticGuiDefinitionPatterns = [
+    'common/scripted_triggers/**/*.txt',
+    'common/script_constants/**/*.txt',
     'common/scripted_localisation/**/*.txt',
     'common/decisions/**/*.txt',
     'common/decision_categories/**/*.txt',
@@ -814,7 +817,7 @@ export class ScriptedGuiStudio {
         const scanned = await this.scanWindow(input.workspaceId, input.windowName, input.principal, input.signal, [placeholderScenario.language, ...explicitRelatedScenarios.map(({ language }) => language)], scenarioSpriteNames([placeholderScenario, ...explicitRelatedScenarios], generatedOptions?.textSamples));
         const generatedScenarios = generatedOptions === undefined
             ? []
-            : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions);
+            : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions, ClausewitzEvaluationDefinitions.build(scanned));
         const scenario = generatedScenarios[0] ?? placeholderScenario;
         const relatedScenarios = [
             ...(generatedOptions?.preservePlaceholder === true && generatedScenarios.length > 0
@@ -893,7 +896,7 @@ export class ScriptedGuiStudio {
         ], generatedOptions?.textSamples));
         const generatedScenarios = generatedOptions === undefined
             ? []
-            : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions);
+            : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions, ClausewitzEvaluationDefinitions.build(scanned));
         const scenario = generatedScenarios[0] ?? placeholderScenario;
         const relatedScenarios = [
             ...(generatedOptions?.preservePlaceholder === true && generatedScenarios.length > 0