hoi4-agent-tools 3.1.0 → 3.2.0

package/dist/hoi4_agent_tools/core/impact-semantic.js

@@ -0,0 +1,256 @@
+import { compareCodeUnits } from './canonical.js';
+import { assignments, firstScalar, nodeLocation, parseClausewitz, } from './source/index.js';
+const eventKeys = new Set([
+    'country_event',
+    'news_event',
+    'state_event',
+    'unit_leader_event',
+    'operative_leader_event',
+]);
+const scalarTargets = new Map([
+    ['activate_decision', 'decision'],
+    ['remove_decision', 'decision'],
+    ['complete_decision', 'decision'],
+    ['add_ideas', 'idea'],
+    ['remove_ideas', 'idea'],
+    ['has_idea', 'idea'],
+    ['has_completed_focus', 'focus'],
+    ['load_focus_tree', 'focus_tree'],
+    ['has_tech', 'technology'],
+    ['country_event', 'event'],
+    ['news_event', 'event'],
+    ['state_event', 'event'],
+]);
+const stateKeyOperations = new Map([
+    ['set_variable', { kind: 'variable', role: 'write' }],
+    ['add_to_variable', { kind: 'variable', role: 'write' }],
+    ['subtract_from_variable', { kind: 'variable', role: 'write' }],
+    ['multiply_variable', { kind: 'variable', role: 'write' }],
+    ['divide_variable', { kind: 'variable', role: 'write' }],
+    ['check_variable', { kind: 'variable', role: 'read' }],
+    ['has_variable', { kind: 'variable', role: 'read' }],
+    ['set_country_flag', { kind: 'flag', role: 'write', scope: 'country' }],
+    ['clr_country_flag', { kind: 'flag', role: 'write', scope: 'country' }],
+    ['has_country_flag', { kind: 'flag', role: 'read', scope: 'country' }],
+    ['set_state_flag', { kind: 'flag', role: 'write', scope: 'state' }],
+    ['clr_state_flag', { kind: 'flag', role: 'write', scope: 'state' }],
+    ['has_state_flag', { kind: 'flag', role: 'read', scope: 'state' }],
+    ['set_global_flag', { kind: 'flag', role: 'write', scope: 'global' }],
+    ['clr_global_flag', { kind: 'flag', role: 'write', scope: 'global' }],
+    ['has_global_flag', { kind: 'flag', role: 'read', scope: 'global' }],
+    ['save_event_target_as', { kind: 'event_target', role: 'write' }],
+    ['save_global_event_target_as', { kind: 'event_target', role: 'write' }],
+    ['clear_global_event_target', { kind: 'event_target', role: 'write' }],
+    ['has_event_target', { kind: 'event_target', role: 'read' }],
+]);
+function stateKeyTarget(assignment, kind) {
+    if (assignment.value.type === 'scalar')
+        return assignment.value.value;
+    if (kind !== 'variable')
+        return undefined;
+    const explicit = firstScalar(assignment.value, 'var');
+    if (explicit !== undefined)
+        return explicit.value;
+    return assignments(assignment.value).find(({ key }) => !['compare', 'value', 'tooltip', 'var', 'value_name'].includes(key.value))?.key.value;
+}
+function normalized(file) {
+    return file.relativePath.replaceAll('\\', '/').toLowerCase();
+}
+function ownerFor(snapshot, file, assignment, ancestors) {
+    if (assignment.value.type !== 'block')
+        return undefined;
+    const key = assignment.key.value;
+    const sourcePath = normalized(file);
+    let owner;
+    if (sourcePath.startsWith('events/') && ancestors.length === 0 && eventKeys.has(key)) {
+        const id = firstScalar(assignment.value, 'id')?.value;
+        if (id !== undefined)
+            owner = { kind: 'event', id };
+    }
+    else if (key === 'focus') {
+        const id = firstScalar(assignment.value, 'id')?.value;
+        if (id !== undefined)
+            owner = {
+                kind: ancestors.includes('continuous_focus_palette') ? 'continuous_focus' : 'focus',
+                id,
+            };
+    }
+    else if (sourcePath.startsWith('common/decisions/') &&
+        !sourcePath.startsWith('common/decisions/categories/') &&
+        ancestors.length === 1) {
+        owner = { kind: 'decision', id: key };
+    }
+    else if (sourcePath.startsWith('common/decisions/categories/') && ancestors.length === 0) {
+        owner = { kind: 'decision_category', id: key };
+    }
+    else if (sourcePath.startsWith('common/ideas/') &&
+        ancestors.length === 2 &&
+        ancestors[0] === 'ideas') {
+        owner = { kind: 'idea', id: key };
+    }
+    else if (sourcePath.startsWith('common/technologies/') &&
+        ancestors.length === 1 &&
+        ancestors[0] === 'technologies') {
+        owner = { kind: 'technology', id: key };
+    }
+    else if (sourcePath.startsWith('common/scripted_effects/') && ancestors.length === 0) {
+        owner = { kind: 'scripted_effect', id: key };
+    }
+    else if (sourcePath.startsWith('common/scripted_triggers/') && ancestors.length === 0) {
+        owner = { kind: 'scripted_trigger', id: key };
+    }
+    else if (sourcePath.startsWith('common/scripted_guis/') &&
+        ancestors.length === 1 &&
+        ancestors[0] === 'scripted_gui') {
+        owner = { kind: 'scripted_gui', id: key };
+    }
+    return owner === undefined || snapshot.index.find(owner.kind, owner.id)?.path !== file.displayPath
+        ? undefined
+        : owner;
+}
+function staticTarget(value) {
+    return (/^[A-Za-z0-9_.:-]+$/u.test(value) &&
+        !/^(?:event_target|scope|var|constant):/iu.test(value) &&
+        !/^(?:ROOT|FROM|PREV|THIS)$/iu.test(value));
+}
+/** Extracts typed script edges while preserving unknown dynamic references. */
+export function scanImpactSemanticReferences(snapshot, maxReferences = 200_000) {
+    if (!Number.isSafeInteger(maxReferences) || maxReferences < 1 || maxReferences > 1_000_000)
+        throw new RangeError('Semantic reference limit is outside the supported range');
+    const references = [];
+    const unresolved = [];
+    let scannedFiles = 0;
+    let complete = true;
+    const emit = (file, document, node, owner, toKind, target, referenceKind) => {
+        if (!staticTarget(target)) {
+            if (unresolved.length < maxReferences)
+                unresolved.push({
+                    path: file.displayPath,
+                    location: nodeLocation(document, node, owner.id),
+                    reason: `Dynamic ${referenceKind} target ${target} cannot be resolved statically`,
+                });
+            else
+                complete = false;
+            return;
+        }
+        if (references.length >= maxReferences) {
+            complete = false;
+            return;
+        }
+        references.push({
+            kind: referenceKind,
+            from: owner.id,
+            toKind,
+            to: target,
+            path: file.displayPath,
+            location: nodeLocation(document, node, owner.id),
+        });
+    };
+    const walk = (file, document, block, ancestors, owner) => {
+        for (const assignment of assignments(block)) {
+            const identified = ownerFor(snapshot, file, assignment, ancestors);
+            const current = identified ?? owner;
+            if (identified?.kind === 'decision' && ancestors.length === 1)
+                emit(file, document, assignment, identified, 'decision_category', ancestors[0], 'decision_category_membership');
+            if (current !== undefined && identified === undefined) {
+                const key = assignment.key.value;
+                if (assignment.value.type === 'scalar') {
+                    const value = assignment.value.value;
+                    const localisation = (current.kind === 'event' &&
+                        (key === 'title' ||
+                            key === 'desc' ||
+                            (key === 'name' && ancestors.includes('option')) ||
+                            (key === 'text' && ancestors.includes('desc')))) ||
+                        key === 'custom_effect_tooltip';
+                    if (localisation)
+                        emit(file, document, assignment, current, 'localisation', value, 'localisation_key');
+                    if ((key === 'picture' ||
+                        (key === 'icon' && ['decision', 'decision_category'].includes(current.kind))) &&
+                        value.startsWith('GFX_'))
+                        emit(file, document, assignment, current, 'sprite', value, 'display_sprite');
+                    if (key === 'scripted_gui' && ['decision', 'decision_category'].includes(current.kind))
+                        emit(file, document, assignment, current, 'scripted_gui', value, 'scripted_gui_binding');
+                    if (current.kind === 'scripted_gui' && key === 'parent_window_window')
+                        emit(file, document, assignment, current, 'gui_element', value, key);
+                    if (current.kind === 'scripted_gui' && key === 'parent_scripted_gui')
+                        emit(file, document, assignment, current, 'scripted_gui', value, key);
+                }
+                if (key.startsWith('event_target:'))
+                    emit(file, document, assignment, current, 'event_target', key.slice('event_target:'.length), 'event_target_read');
+                const stateOperation = stateKeyOperations.get(key);
+                if (stateOperation !== undefined) {
+                    const target = stateKeyTarget(assignment, stateOperation.kind);
+                    if (target === undefined) {
+                        if (unresolved.length < maxReferences)
+                            unresolved.push({
+                                path: file.displayPath,
+                                location: nodeLocation(document, assignment, current.id),
+                                reason: `Cannot identify ${key} state key`,
+                            });
+                        else
+                            complete = false;
+                    }
+                    else
+                        emit(file, document, assignment, current, stateOperation.kind, stateOperation.scope === undefined ? target : `${stateOperation.scope}:${target}`, `${stateOperation.kind}_${stateOperation.role}`);
+                }
+                const targetKind = scalarTargets.get(key);
+                if (key === 'set_technology' && assignment.value.type === 'block')
+                    for (const technology of assignments(assignment.value))
+                        if (technology.key.value !== 'popup')
+                            emit(file, document, technology, current, 'technology', technology.key.value, 'set_technology');
+                if (targetKind !== undefined) {
+                    if (assignment.value.type === 'scalar') {
+                        emit(file, document, assignment, current, targetKind, assignment.value.value, key);
+                    }
+                    else {
+                        const id = firstScalar(assignment.value, 'id') ?? firstScalar(assignment.value, 'decision');
+                        if (id !== undefined)
+                            emit(file, document, assignment, current, targetKind, id.value, key);
+                        else
+                            for (const entry of assignment.value.entries)
+                                if (entry.type === 'scalar')
+                                    emit(file, document, assignment, current, targetKind, entry.value, key);
+                    }
+                }
+                const helperKind = snapshot.index.find('scripted_effect', key) !== undefined
+                    ? 'scripted_effect'
+                    : snapshot.index.find('scripted_trigger', key) !== undefined
+                        ? 'scripted_trigger'
+                        : undefined;
+                if (helperKind !== undefined)
+                    emit(file, document, assignment, current, helperKind, key, 'scripted_helper_call');
+            }
+            if (assignment.value.type === 'block')
+                walk(file, document, assignment.value, [...ancestors, assignment.key.value], current);
+        }
+    };
+    for (const file of snapshot.files) {
+        if (file.shadowedBy !== undefined)
+            continue;
+        const path = normalized(file);
+        if (!path.endsWith('.txt') ||
+            !(path.startsWith('events/') ||
+                path.startsWith('common/national_focus/') ||
+                path.startsWith('common/continuous_focus/') ||
+                path.startsWith('common/decisions/') ||
+                path.startsWith('common/ideas/') ||
+                path.startsWith('common/technologies/') ||
+                path.startsWith('common/scripted_effects/') ||
+                path.startsWith('common/scripted_triggers/') ||
+                path.startsWith('common/scripted_guis/')))
+            continue;
+        if (snapshot.index.isSourceSkipped(file.displayPath)) {
+            complete = false;
+            continue;
+        }
+        scannedFiles += 1;
+        const document = parseClausewitz(file.bytes, file.displayPath);
+        walk(file, document, document.root, []);
+    }
+    references.sort((left, right) => compareCodeUnits(left.path, right.path) ||
+        compareCodeUnits(left.from, right.from) ||
+        compareCodeUnits(left.toKind, right.toKind) ||
+        compareCodeUnits(left.to, right.to) ||
+        compareCodeUnits(left.kind, right.kind));
+    return { references, unresolved, scannedFiles, complete };
+}

package/dist/hoi4_agent_tools/core/job-worker-host.js

@@ -37,6 +37,8 @@ export class JobWorkerHost {
         if (['completed', 'cancelled', 'failed'].includes(initial.status))
             return initial;
         if (![
+            'hoi4.impact_inspect',
+            'hoi4.decision_inspect',
             'hoi4.event_inspect',
             'hoi4.event_render',
             'hoi4.event_compare',

package/dist/hoi4_agent_tools/core/job-worker.js

@@ -10,6 +10,7 @@ import { registerGuiJobs } from '../gui/job-operations.js';
 import { registerMapJobs } from '../map/job-operations.js';
 import { registerProbabilityJobs } from '../probability/job-operations.js';
 import { registerTechnologyJobs } from '../technology/job-operations.js';
+import { registerAnalysisJobs } from './analysis-job-operations.js';
 // Fixed internal process entry point. It accepts only a trusted host's structured IPC
 // message, never a script path, module name, callback, command, or transport request.
 const inputSchema = z
@@ -44,6 +45,7 @@ process.once('message', (value) => {
         const jobs = await JobService.create(resolver);
         const operations = new JobOperations();
         registerEventJobs(operations, engine);
+        registerAnalysisJobs(operations, engine);
         registerTechnologyJobs(operations, engine);
         registerProbabilityJobs(operations, engine);
         registerMapJobs(operations, engine);

package/dist/hoi4_agent_tools/core/operation-tasks.js

@@ -1,4 +1,5 @@
 import { z } from 'zod/v4';
+import { decisionInspectRequestSchema, impactInspectRequestSchema } from '../schemas/analysis.js';
 import { eventCompareRequestSchema, eventInspectRequestSchema, eventRenderRequestSchema, } from '../schemas/event.js';
 import { focusInspectRequestSchema, focusRenderRequestSchema, focusRewriteRequestSchema, } from '../schemas/focus-requests.js';
 import { guiInspectRequestSchema, guiRenderRequestSchema, guiRewriteRequestSchema, } from '../schemas/gui-requests.js';
@@ -25,6 +26,8 @@ const authenticatedTaskIdSchema = z
 export const operationTaskCallSchema = z
     .object({
     name: z.enum([
+        'hoi4.impact_inspect',
+        'hoi4.decision_inspect',
         'hoi4.event_inspect',
         'hoi4.event_render',
         'hoi4.event_compare',
@@ -53,6 +56,8 @@ export const operationTaskCallSchema = z
 })
     .strict();
 const taskArgumentSchemas = {
+    'hoi4.impact_inspect': impactInspectRequestSchema,
+    'hoi4.decision_inspect': decisionInspectRequestSchema,
     'hoi4.event_inspect': eventInspectRequestSchema,
     'hoi4.event_render': eventRenderRequestSchema,
     'hoi4.event_compare': eventCompareRequestSchema,

package/dist/hoi4_agent_tools/core/source-overlay.js

@@ -0,0 +1,125 @@
+import path from 'node:path';
+import { compareCodeUnits, hashCanonical, sha256Bytes } from './canonical.js';
+import { SymbolIndex } from './index.js';
+import { isWithin } from './workspace.js';
+const MAX_EDITS = 64;
+const MAX_EDIT_BYTES = 8 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 32 * 1024 * 1024;
+const SOURCE_EXTENSION = /\.(?:txt|gui|gfx|yml|yaml)$/iu;
+function checkedRelativePath(relativePath) {
+    if (relativePath.length === 0 ||
+        relativePath.length > 4096 ||
+        relativePath.includes('\\') ||
+        relativePath.includes('\0') ||
+        path.posix.isAbsolute(relativePath) ||
+        /^[A-Za-z]:/u.test(relativePath))
+        throw new RangeError('Proposed source path is not workspace-relative');
+    const parts = relativePath.split('/');
+    if (parts.some((part) => part.length === 0 || part === '.' || part === '..'))
+        throw new RangeError('Proposed source path is not normalized');
+    if (!SOURCE_EXTENSION.test(relativePath))
+        throw new RangeError('Proposed source must be a supported text source');
+    return relativePath;
+}
+function revision(files) {
+    return hashCanonical(files.map(({ absolutePath, displayPath, relativePath, rootKind, loadOrder, shadowedBy, sha256 }) => ({
+        absolutePath,
+        displayPath,
+        relativePath,
+        rootKind,
+        loadOrder,
+        shadowedBy: shadowedBy ?? null,
+        sha256,
+    })));
+}
+/** Builds a source-only proposal in memory under the authorized mod root. */
+export function buildProposedSourceOverlay(baseline, workspace, edits) {
+    if (edits.length < 1 || edits.length > MAX_EDITS)
+        throw new RangeError(`Proposed overlay requires 1-${MAX_EDITS} edits`);
+    if (baseline.workspaceId !== workspace.id)
+        throw new Error('Proposed overlay workspace does not match its baseline snapshot');
+    const modRoot = workspace.roots.find(({ kind }) => kind === 'mod');
+    if (modRoot?.path !== workspace.modRoot)
+        throw new Error('Authorized mod root is unavailable');
+    const files = baseline.files.map((file) => {
+        const copy = { ...file };
+        delete copy.shadowedBy;
+        return copy;
+    });
+    const changes = [];
+    const seen = new Set();
+    let totalBytes = 0;
+    for (const edit of edits) {
+        const relativePath = checkedRelativePath(edit.relativePath);
+        const key = relativePath.toLowerCase();
+        if (seen.has(key))
+            throw new Error(`Duplicate proposed source path: ${relativePath}`);
+        seen.add(key);
+        const existingIndex = files.findIndex((file) => file.rootKind === 'mod' && file.relativePath.toLowerCase() === relativePath.toLowerCase());
+        const existing = existingIndex < 0 ? undefined : files[existingIndex];
+        const sourcePath = existing?.relativePath ?? relativePath;
+        const absolutePath = path.resolve(modRoot.path, ...sourcePath.split('/'));
+        if (!isWithin(modRoot.path, absolutePath) || absolutePath === modRoot.path)
+            throw new RangeError('Proposed source path escapes the authorized mod root');
+        const displayPath = existing?.displayPath ?? `mod:${sourcePath}`;
+        if (existing !== undefined)
+            files.splice(existingIndex, 1);
+        if (edit.content === null) {
+            if (existing === undefined)
+                throw new Error(`Proposed removal has no mod source: ${relativePath}`);
+            changes.push({
+                path: existing.displayPath,
+                change: 'removed',
+                beforeHash: existing.sha256,
+                afterHash: null,
+            });
+            continue;
+        }
+        const bytes = Buffer.from(edit.content, 'utf8');
+        totalBytes += bytes.length;
+        if (bytes.length > MAX_EDIT_BYTES || totalBytes > MAX_TOTAL_BYTES)
+            throw new RangeError('Proposed source content exceeds the overlay limit');
+        const sha256 = sha256Bytes(bytes);
+        files.push({
+            absolutePath,
+            displayPath,
+            relativePath: sourcePath,
+            rootKind: 'mod',
+            loadOrder: modRoot.loadOrder,
+            size: bytes.length,
+            modifiedMs: 0,
+            sha256,
+            bytes,
+        });
+        changes.push({
+            path: displayPath,
+            change: existing === undefined ? 'added' : 'replaced',
+            beforeHash: existing?.sha256 ?? null,
+            afterHash: sha256,
+        });
+    }
+    files.sort((left, right) => left.loadOrder - right.loadOrder || compareCodeUnits(left.relativePath, right.relativePath));
+    const groups = new Map();
+    for (const file of files) {
+        const group = groups.get(file.relativePath.toLowerCase()) ?? [];
+        group.push(file);
+        groups.set(file.relativePath.toLowerCase(), group);
+    }
+    for (const group of groups.values()) {
+        group.sort((left, right) => right.loadOrder - left.loadOrder || compareCodeUnits(left.displayPath, right.displayPath));
+        for (const file of group.slice(1))
+            file.shadowedBy = group[0].displayPath;
+    }
+    const index = SymbolIndex.build(files);
+    const snapshot = {
+        workspaceId: baseline.workspaceId,
+        revision: revision(files),
+        files,
+        index,
+        complete: index.complete,
+        skippedSourceCount: index.skippedSourceCount,
+        skippedSources: index.skippedSources,
+        diagnostics: index.diagnostics,
+    };
+    return { baselineRevision: baseline.revision, snapshot, changes };
+}

package/dist/hoi4_agent_tools/decision/ai.js

@@ -0,0 +1,104 @@
+import { ProbabilityAnalyzer } from '../probability/service.js';
+import { decisionSourceInventory } from './source-inventory.js';
+function selected(snapshot, id) {
+    return decisionSourceInventory(snapshot).decisions.find(({ id: candidate }) => candidate === id);
+}
+function summary(result) {
+    return {
+        analysisId: result.analysisId,
+        status: result.status,
+        adapter: result.adapter.id,
+        sourceHash: result.metadata.sourceHash,
+        scenarios: result.scenarios.map((scenario) => ({
+            id: scenario.id,
+            candidates: scenario.candidates.map((candidate) => ({
+                id: candidate.id,
+                eligibility: candidate.eligibility,
+                supportLevel: candidate.supportLevel,
+                ...(candidate.rawValue === undefined ? {} : { rawValue: candidate.rawValue }),
+                unresolved: candidate.unresolved,
+            })),
+            unresolved: scenario.unresolved,
+        })),
+        unresolved: result.unresolved,
+        ...(result.comparison === undefined ? {} : { comparison: result.comparison }),
+        resources: result.resources,
+    };
+}
+/** Uses the existing score-only probability adapters; never invents decision selection odds. */
+export async function inspectDecisionAi(engine, before, id, scenarios, overlay, principal, signal) {
+    const source = selected(before, id);
+    const proposed = overlay === undefined ? undefined : selected(overlay.snapshot, id);
+    const baselineWeighted = (source?.fields.ai_will_do.length ?? 0) > 0;
+    const proposedWeighted = (proposed?.fields.ai_will_do.length ?? 0) > 0;
+    if (!baselineWeighted && !proposedWeighted)
+        return undefined;
+    const subject = source ?? proposed;
+    const adapter = subject.kind === 'mission' ? 'mission_ai_will_do' : 'decision_ai_will_do';
+    const scenarioSet = {
+        schemaVersion: '1.0',
+        id: `decision-${id}`,
+        scenarios: scenarios.map(({ closedFlags: _closedFlags, ...scenario }) => scenario),
+    };
+    const analyzer = new ProbabilityAnalyzer(engine);
+    const workspaceId = before.workspaceId;
+    const context = {
+        workspaceId,
+        adapter,
+        scenarioSet,
+        outputs: ['json'],
+        ...(principal === undefined ? {} : { principal }),
+        ...(signal === undefined ? {} : { signal }),
+    };
+    const sourceFile = source === undefined
+        ? undefined
+        : before.files.find(({ displayPath }) => displayPath === source.path);
+    const baselineSelector = sourceFile === undefined
+        ? undefined
+        : { path: sourceFile.relativePath, identifier: id, expectedSourceHash: sourceFile.sha256 };
+    const proposedFile = proposed === undefined
+        ? undefined
+        : overlay?.snapshot.files.find(({ displayPath }) => displayPath === proposed.path);
+    const proposedSelector = proposedFile === undefined
+        ? undefined
+        : { virtualPatch: proposedFile.bytes.toString('utf8'), identifier: id };
+    const isolatedProposal = overlay?.changes.length === 1 &&
+        proposedFile !== undefined &&
+        overlay.changes[0]?.path === proposedFile.displayPath;
+    if (baselineWeighted &&
+        proposedWeighted &&
+        isolatedProposal &&
+        baselineSelector &&
+        proposedSelector) {
+        const compared = await analyzer.compare({
+            ...context,
+            before: baselineSelector,
+            after: proposedSelector,
+        });
+        return { mode: 'compare', ...summary(compared) };
+    }
+    if (baselineWeighted && baselineSelector) {
+        const evaluated = await analyzer.evaluate({ ...context, source: baselineSelector });
+        return {
+            mode: 'baseline',
+            ...summary(evaluated),
+            ...(overlay === undefined
+                ? {}
+                : {
+                    proposedUnresolved: 'The proposal changes multiple sources or adds/removes the weighted decision; use probability_compare with explicit source selectors',
+                }),
+        };
+    }
+    if (proposedWeighted && proposedSelector) {
+        const evaluated = await analyzer.evaluate({ ...context, source: proposedSelector });
+        return {
+            mode: 'proposed',
+            ...summary(evaluated),
+            baselineUnresolved: 'The baseline has no matching weighted decision',
+        };
+    }
+    return {
+        mode: 'unresolved',
+        reason: 'Weighted decision source could not be selected for probability analysis',
+    };
+}

package/dist/hoi4_agent_tools/decision/comparison.js

@@ -0,0 +1,106 @@
+import { hashCanonical } from '../core/canonical.js';
+import { inspectDecisionCost } from './cost.js';
+import { evaluateDecisionGates } from './evaluation.js';
+import { inspectDecisionLifecycle } from './lifecycle.js';
+import { decisionSourceInventory, decisionTargetCatalog, } from './source-inventory.js';
+export function inspectDecisionScenario(snapshot, id, scenario) {
+    const source = decisionSourceInventory(snapshot).decisions.find((candidate) => candidate.id === id);
+    if (source === undefined)
+        return null;
+    return {
+        targeting: decisionTargetCatalog(source),
+        gates: evaluateDecisionGates(snapshot, id, scenario),
+        cost: inspectDecisionCost(snapshot, source, scenario),
+        lifecycle: inspectDecisionLifecycle(snapshot, source, scenario),
+    };
+}
+function differences(before, after) {
+    if (before === null || after === null)
+        return before === after ? [] : ['definition'];
+    const fields = [
+        ['targeting', before.targeting, after.targeting],
+        ['category_allowed', before.gates.categoryAllowed.state, after.gates.categoryAllowed.state],
+        ['decision_allowed', before.gates.decisionAllowed.state, after.gates.decisionAllowed.state],
+        ['category_visible', before.gates.categoryVisible.state, after.gates.categoryVisible.state],
+        [
+            'decision_visible',
+            before.gates.decisionVisible?.state ?? null,
+            after.gates.decisionVisible?.state ?? null,
+        ],
+        [
+            'category_available',
+            before.gates.categoryAvailable.state,
+            after.gates.categoryAvailable.state,
+        ],
+        [
+            'decision_available',
+            before.gates.decisionAvailable.state,
+            after.gates.decisionAvailable.state,
+        ],
+        ['eligible', before.gates.eligible, after.gates.eligible],
+        ['visible', before.gates.visible, after.gates.visible],
+        ['available', before.gates.available, after.gates.available],
+        ['target_selection', before.gates.targetSelection.state, after.gates.targetSelection.state],
+        ['target_trigger', before.gates.targetTrigger.state, after.gates.targetTrigger.state],
+        ['cost_kind', before.cost.kind, after.cost.kind],
+        ['cost_amount', before.cost.amount, after.cost.amount],
+        ['affordable', before.cost.affordable, after.cost.affordable],
+        [
+            'payment_effects',
+            before.cost.paymentEffects.map(({ resource, amount, operation, scope }) => ({
+                resource,
+                amount,
+                operation,
+                scope,
+            })),
+            after.cost.paymentEffects.map(({ resource, amount, operation, scope }) => ({
+                resource,
+                amount,
+                operation,
+                scope,
+            })),
+        ],
+        ['lifecycle', before.lifecycle, after.lifecycle],
+    ];
+    return fields
+        .filter(([, left, right]) => hashCanonical(left) !== hashCanonical(right))
+        .map(([field]) => field);
+}
+/** Compare declared scenarios against two revision-pinned source snapshots. */
+export function compareDecisionScenarios(before, after, id, scenarios) {
+    if (before.workspaceId !== after.workspaceId)
+        throw new Error('Decision comparison crosses workspace boundaries');
+    if (scenarios.length < 1 || scenarios.length > 64)
+        throw new RangeError('Decision comparison requires 1-64 scenarios');
+    if (id.length === 0 || id.length > 512)
+        throw new RangeError('Decision identifier is invalid');
+    const seen = new Set();
+    const cases = scenarios.map((scenario) => {
+        if (seen.has(scenario.id))
+            throw new Error(`Duplicate decision scenario: ${scenario.id}`);
+        seen.add(scenario.id);
+        const baseline = inspectDecisionScenario(before, id, scenario);
+        const proposed = inspectDecisionScenario(after, id, scenario);
+        return {
+            scenarioId: scenario.id,
+            before: baseline,
+            after: proposed,
+            changed: differences(baseline, proposed),
+        };
+    });
+    return {
+        id,
+        beforeRevision: before.revision,
+        afterRevision: after.revision,
+        complete: before.complete &&
+            after.complete &&
+            cases.every(({ before: baseline, after: proposed }) => (baseline !== null || proposed !== null) &&
+                (baseline?.gates.complete ?? true) &&
+                (proposed?.gates.complete ?? true) &&
+                (baseline?.cost.unresolved.length ?? 0) === 0 &&
+                (proposed?.cost.unresolved.length ?? 0) === 0 &&
+                (baseline?.lifecycle.unresolved.length ?? 0) === 0 &&
+                (proposed?.lifecycle.unresolved.length ?? 0) === 0),
+        cases,
+    };
+}