hoi4-agent-tools 3.2.0 → 3.3.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+## 3.3.0 - 2026-09-20
+
+- Add `hoi4.mechanic_test` with copied versioned scenario state, bounded source effects, explicit time advancement, traces, and typed gameplay assertions.
+- Add `hoi4.package_check` for declarative package definitions, calls, registrations, localisation, assets, and required suite-case references.
+- Add `hoi4.scenario_test` for named inline or workspace-owned suites through fixed read-only operations, case artifacts, and authenticated revision-bound continuation.
+- Share declared condition state across GUI and probability adapters while preserving their public inputs and specialized evaluation semantics.
+
 ## 3.2.0 - 2026-09-20
 
 - Add read-only `hoi4.impact_inspect` with active and overridden definitions, direct and transitive source consumers, state-key access roles, cycle and coverage evidence, and in-memory source comparisons.

package/README.md

@@ -74,6 +74,9 @@ On non-Windows systems, use `hoi4-agent-tools` as the command. Agentic HOI4 repo
 | `hoi4.event_compare`        | Compare event-chain topology and diagnostics between revisions.                           |
 | `hoi4.impact_inspect`       | Trace symbol and changed-file consumers across source systems and compare proposals.      |
 | `hoi4.decision_inspect`     | Inventory and evaluate decisions or missions under declared scenarios and source changes. |
+| `hoi4.mechanic_test`        | Execute bounded source effects on a copied declared scenario and check assertions.        |
+| `hoi4.package_check`        | Check declarative package definitions, calls, registrations, assets, and case links.      |
+| `hoi4.scenario_test`        | Run named source and domain cases in resumable, revision-bound batches.                   |
 | `hoi4.job_inspect`          | Inspect durable background work or retrieve its completed tool result.                    |
 | `hoi4.job_cancel`           | Durably request cancellation of authorized background work.                               |
 | `hoi4.tech_inspect`         | Scan, trace, explain, lint, and assess technology and doctrine systems.                   |
@@ -108,6 +111,7 @@ Ask your agent in normal task language. A typical workflow is inspect, render, r
 - Maps: "Render the whole map and find this state by name," "Create a state from these provinces," "Create a province inside this exact rectangle," or "Swap these state IDs and update connected references." See [Maps](docs/map.md).
 - Event chains: "Trace every route from this event and explain where its flags and variables change," or "Compare the workspace event graph with its previous revision and render the affected routes." See [Event chains](docs/events.md).
 - Cross-system impact and decisions: "Find every direct and transitive consumer of this idea," or "Compare who can take this decision, what they pay, and its mission end paths for these actor and target scenarios." See [Cross-system impact and decisions](docs/analysis.md).
+- Mechanics and packages: "Test this transfer's conservation and payment," or "Check every declared package link and resume its named scenario suite." See [Mechanic tests and scenario suites](docs/mechanics.md).
 - Technology trees: "Explain everything this technology requires and unlocks," or "Compare this technology patch and render every affected folder and doctrine branch." See [Technology trees](docs/technology.md).
 - AI and MTTH: "Compare these focus weights across peace, defensive-war, and low-stability scenarios," or "Show when this MTTH event becomes likely and which unknown inputs control the result." See [AI and MTTH analysis](docs/probability.md).
 

package/dist/hoi4_agent_tools/core/analysis-job-operations.js

@@ -1,14 +1,21 @@
 import { z } from 'zod/v4';
 import { DecisionAnalyzer } from '../decision/service.js';
 import { ImpactAnalyzer } from '../impact/service.js';
+import { MechanicAnalyzer } from '../mechanic/service.js';
+import { PackageAnalyzer } from '../package-check/service.js';
+import { ScenarioAnalyzer } from '../scenario-suite/service.js';
 import { decisionInspectRequestSchema, impactInspectRequestSchema } from '../schemas/analysis.js';
+import { mechanicTestRequestSchema, packageCheckRequestSchema, scenarioTestRequestSchema, } from '../schemas/scenarios.js';
 import { errorResult, toolResult } from './operation-result.js';
 import { ServiceError } from './result.js';
 const wireResult = z.record(z.string(), z.json());
-/** Registers the two read-only analysis services for durable ordinary and native tasks. */
+/** Registers read-only analysis services for durable ordinary and native tasks. */
 export function registerAnalysisJobs(operations, engine) {
     const impact = new ImpactAnalyzer(engine);
     const decision = new DecisionAnalyzer(engine);
+    const mechanic = new MechanicAnalyzer(engine);
+    const packages = new PackageAnalyzer(engine);
+    const scenarios = new ScenarioAnalyzer(engine);
     const register = (name, schema, execute, progressMessage) => {
         operations.registerRead(name, schema, async (input, context) => {
             try {
@@ -35,4 +42,7 @@ export function registerAnalysisJobs(operations, engine) {
     };
     register('hoi4.impact_inspect', impactInspectRequestSchema, (input) => impact.inspect(input), 'Tracing cross-system impact');
     register('hoi4.decision_inspect', decisionInspectRequestSchema, (input) => decision.inspect(input), 'Analyzing decisions and missions');
+    register('hoi4.mechanic_test', mechanicTestRequestSchema, (input) => mechanic.test(input), 'Testing declared mechanic steps');
+    register('hoi4.package_check', packageCheckRequestSchema, (input) => packages.check(input), 'Checking package connections');
+    register('hoi4.scenario_test', scenarioTestRequestSchema, (input) => scenarios.test(input), 'Running a bounded scenario suite');
 }

package/dist/hoi4_agent_tools/core/condition-evaluator.js

@@ -257,7 +257,11 @@ function evaluateAssignmentCore(assignment, scenario, candidate, definitions, he
         const explicit = bool(scopeStateValue(scenario, `flag.${right}`, scopeContext));
         if (explicit !== undefined)
             return { state: explicit ? 'true' : 'false', unresolved: [] };
-        const flags = scopeContext.expression === 'ROOT' ? scenario.flags : scopeContext.binding.flags;
+        const flags = key === 'has_global_flag' && scenario.globalFlags !== undefined
+            ? scenario.globalFlags
+            : scopeContext.expression === 'ROOT'
+                ? scenario.flags
+                : scopeContext.binding.flags;
         if (scenario.closedFlags === false && flags?.includes(right) !== true)
             return unresolved(assignment, candidate, `Scenario does not declare flag ${right}`);
         return { state: flags?.includes(right) === true ? 'true' : 'false', unresolved: [] };

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

@@ -39,6 +39,9 @@ export class JobWorkerHost {
         if (![
             'hoi4.impact_inspect',
             'hoi4.decision_inspect',
+            'hoi4.mechanic_test',
+            'hoi4.package_check',
+            'hoi4.scenario_test',
             'hoi4.event_inspect',
             'hoi4.event_render',
             'hoi4.event_compare',

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

@@ -1,5 +1,6 @@
 import { z } from 'zod/v4';
 import { decisionInspectRequestSchema, impactInspectRequestSchema } from '../schemas/analysis.js';
+import { mechanicTestRequestSchema, packageCheckRequestSchema, scenarioTestRequestSchema, } from '../schemas/scenarios.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';
@@ -28,6 +29,9 @@ export const operationTaskCallSchema = z
     name: z.enum([
         'hoi4.impact_inspect',
         'hoi4.decision_inspect',
+        'hoi4.mechanic_test',
+        'hoi4.package_check',
+        'hoi4.scenario_test',
         'hoi4.event_inspect',
         'hoi4.event_render',
         'hoi4.event_compare',
@@ -58,6 +62,9 @@ export const operationTaskCallSchema = z
 const taskArgumentSchemas = {
     'hoi4.impact_inspect': impactInspectRequestSchema,
     'hoi4.decision_inspect': decisionInspectRequestSchema,
+    'hoi4.mechanic_test': mechanicTestRequestSchema,
+    'hoi4.package_check': packageCheckRequestSchema,
+    'hoi4.scenario_test': scenarioTestRequestSchema,
     'hoi4.event_inspect': eventInspectRequestSchema,
     'hoi4.event_render': eventRenderRequestSchema,
     'hoi4.event_compare': eventCompareRequestSchema,

package/dist/hoi4_agent_tools/core/scenario-model.js

@@ -0,0 +1,85 @@
+export function copyScenario(scenario) {
+    return {
+        scenario: structuredClone(scenario),
+        unknown: new Set(),
+        day: 0,
+    };
+}
+export function scenarioValue(state, key, scope = 'ROOT') {
+    if (state.unknown.has('*') || state.unknown.has(`${scope}.${key}`))
+        return undefined;
+    if (scope === 'ROOT' || scope === 'THIS')
+        return state.scenario.state[key];
+    return state.scenario.scopes?.[scope]?.state[key];
+}
+export function setScenarioValue(state, key, value, scope = 'ROOT') {
+    const identity = `${scope}.${key}`;
+    if (value === undefined)
+        state.unknown.add(identity);
+    else {
+        state.unknown.delete(identity);
+        if (scope === 'ROOT' || scope === 'THIS')
+            state.scenario.state[key] = value;
+        else if (state.scenario.scopes?.[scope] !== undefined)
+            state.scenario.scopes[scope].state[key] = value;
+    }
+}
+/** Preserve the GUI's existing input precedence and exploratory flag semantics. */
+export function scenarioFromGui(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 {
+        schemaVersion: '1.0',
+        id: base.id,
+        state,
+        scopes,
+        closedFlags: false,
+        ...(typeof actor === 'string' ? { actor } : {}),
+    };
+}
+/** Probability retains pools, uncertainty, correlations and schedule in its own adapter. */
+export function scenarioFromProbability(base) {
+    return {
+        schemaVersion: '1.0',
+        id: base.id,
+        ...(base.actor === undefined ? {} : { actor: base.actor }),
+        ...(base.date === undefined ? {} : { date: base.date }),
+        state: structuredClone(base.state),
+        ...(base.flags === undefined ? {} : { flags: [...base.flags] }),
+        ...(base.eventTargets === undefined ? {} : { eventTargets: { ...base.eventTargets } }),
+        ...(base.scopes === undefined ? {} : { scopes: structuredClone(base.scopes) }),
+        ...(base.candidateOverrides === undefined
+            ? {}
+            : { candidateOverrides: { ...base.candidateOverrides } }),
+        closedFlags: true,
+        ...(base.scopePools === undefined
+            ? {}
+            : {
+                scopeCatalogs: Object.fromEntries(base.scopePools.map((pool) => [
+                    pool.id,
+                    {
+                        complete: pool.complete,
+                        members: pool.candidates.map((candidate) => candidate.id),
+                    },
+                ])),
+            }),
+    };
+}

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

@@ -1,6 +1,7 @@
 import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.js';
 import { hasBlockingDiagnostics } from '../core/diagnostics.js';
 import { evaluateTriggerBlock } from '../core/condition-evaluator.js';
+import { scenarioFromGui } from '../core/scenario-model.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. */
@@ -30,29 +31,7 @@ function parsedCondition(expression) {
     };
 }
 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 } : {}),
-    };
+    return scenarioFromGui(base, values);
 }
 export function evaluateGuiCondition(expression, scenario, subject, definitions = new ClausewitzEvaluationDefinitions(), scope = 'ROOT') {
     const context = resolveScopeContext(scenario, scope, rootScopeContext(scenario));

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

@@ -1,2 +1,2 @@
 /** Shared agent-facing guidance for both MCP protocol generations. */
-export const SERVER_INSTRUCTIONS = 'Use focus tools for focus trees, GUI tools for interfaces, and map tools for map data. Start unfamiliar event chains with hoi4.event_inspect. Event tools are read-only. Start cross-system source review with hoi4.impact_inspect and decision or mission scenarios with hoi4.decision_inspect. Impact and decision tools are read-only. Start technology and doctrine work with hoi4.tech_inspect. Technology tools are read-only. Start weighted AI, MTTH, random, and declared-pool analysis with hoi4.probability_inspect. Probability tools are read-only. Concurrent calls queue automatically and emit periodic progress when the client requests it. Long operations support negotiated MCP tasks; native background rewrites require a stable requestKey. Large evidence is linked as resources.';
+export const SERVER_INSTRUCTIONS = 'Use focus tools for focus trees, GUI tools for interfaces, and map tools for map data. Start unfamiliar event chains with hoi4.event_inspect. Event tools are read-only. Start cross-system source review with hoi4.impact_inspect and decision or mission scenarios with hoi4.decision_inspect. Test declared mechanic steps with hoi4.mechanic_test, package connections with hoi4.package_check, and named suites with hoi4.scenario_test. These analysis tools are read-only. Start technology and doctrine work with hoi4.tech_inspect. Technology tools are read-only. Start weighted AI, MTTH, random, and declared-pool analysis with hoi4.probability_inspect. Probability tools are read-only. Concurrent calls queue automatically and emit periodic progress when the client requests it. Long operations support negotiated MCP tasks; native background rewrites require a stable requestKey. Large evidence is linked as resources.';

package/dist/hoi4_agent_tools/mcp/server/request-lifecycle.js

@@ -7,6 +7,9 @@ const controlTools = new Set(['hoi4.job_inspect', 'hoi4.job_cancel']);
 const backgroundTools = new Set([
     'hoi4.impact_inspect',
     'hoi4.decision_inspect',
+    'hoi4.mechanic_test',
+    'hoi4.package_check',
+    'hoi4.scenario_test',
     'hoi4.event_inspect',
     'hoi4.event_render',
     'hoi4.event_compare',

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

@@ -1,5 +1,7 @@
 import { z } from 'zod/v4';
 import { decisionInspectRequestSchema, impactInspectRequestSchema, } from '../../schemas/analysis.js';
+import { mechanicCaseSchema, mechanicTestRequestSchema, packageManifestSchema, packageCheckRequestSchema, scenarioSuiteSchema, scenarioTestRequestSchema, } from '../../schemas/scenarios.js';
+import { compactValidatedInputSchema } from '../server/context-schemas.js';
 import { nonNegativeIntegerSchema, sha256Schema } from '../server/output-schemas.js';
 import { strictOperationResultSchema } from '../server/result.js';
 import { registerLegacyTaskTools } from '../server/legacy-task-tools.js';
@@ -36,6 +38,70 @@ const decisionOutputSchema = strictOperationResultSchema(z
     unresolvedDefinitions: nonNegativeIntegerSchema,
 })
     .strict());
+const mechanicOutputSchema = strictOperationResultSchema(z
+    .object({
+    sourceRevision: sha256Schema,
+    reportHash: sha256Schema,
+    status: z.enum(['passed', 'failed', 'unresolved']),
+    assertions: nonNegativeIntegerSchema,
+    passed: nonNegativeIntegerSchema,
+    failed: nonNegativeIntegerSchema,
+    unresolved: nonNegativeIntegerSchema,
+    steps: nonNegativeIntegerSchema,
+})
+    .strict());
+const packageOutputSchema = strictOperationResultSchema(z
+    .object({
+    sourceRevision: sha256Schema,
+    reportHash: sha256Schema,
+    complete: z.boolean(),
+    items: nonNegativeIntegerSchema,
+    present: nonNegativeIntegerSchema,
+    absent: nonNegativeIntegerSchema,
+    shadowed: nonNegativeIntegerSchema,
+    unresolved: nonNegativeIntegerSchema,
+})
+    .strict());
+const scenarioOutputSchema = strictOperationResultSchema(z
+    .object({
+    sourceRevision: sha256Schema,
+    suiteHash: sha256Schema,
+    reportHash: sha256Schema,
+    start: nonNegativeIntegerSchema,
+    end: nonNegativeIntegerSchema,
+    total: nonNegativeIntegerSchema,
+    completed: nonNegativeIntegerSchema,
+    failed: nonNegativeIntegerSchema,
+    unresolved: nonNegativeIntegerSchema,
+    pending: nonNegativeIntegerSchema,
+    continuation: z.string().optional(),
+})
+    .strict());
+const mechanicInputSchema = z
+    .object({
+    ...mechanicTestRequestSchema.shape,
+    test: compactValidatedInputSchema(mechanicCaseSchema, 'Versioned declared scenario, explicit effect steps, and typed assertions. See docs/mechanics.md.'),
+})
+    .strict();
+const packageInputSchema = z
+    .object({
+    ...packageCheckRequestSchema.shape,
+    manifest: compactValidatedInputSchema(packageManifestSchema, 'Declarative definitions, calls, registrations, localisation, assets, and required cases. See docs/mechanics.md.'),
+})
+    .strict();
+const scenarioInputSchema = z
+    .object({
+    ...scenarioTestRequestSchema.shape,
+    suite: compactValidatedInputSchema(scenarioSuiteSchema, 'Named mechanic, package, or fixed read-only tool cases. See docs/mechanics.md.').optional(),
+})
+    .strict()
+    .superRefine((input, context) => {
+    if ((input.suite === undefined) === (input.suitePath === undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'Specify exactly one inline suite or suitePath',
+        });
+});
 const readOnlyAnalysisTool = {
     readOnlyHint: true,
     destructiveHint: false,
@@ -59,6 +125,30 @@ export const analysisTaskTools = [
         outputSchema: decisionOutputSchema,
         annotations: readOnlyAnalysisTool,
     },
+    {
+        name: 'hoi4.mechanic_test',
+        title: 'Test declared mechanic steps',
+        description: 'Interpret bounded, source-backed effect steps on isolated declared state and check typed invariants. Unsupported effects remain unresolved; no game or mod source is changed.',
+        inputSchema: mechanicInputSchema,
+        outputSchema: mechanicOutputSchema,
+        annotations: readOnlyAnalysisTool,
+    },
+    {
+        name: 'hoi4.package_check',
+        title: 'Check package connections',
+        description: 'Check a declarative package manifest against active definitions, references, registrations, localisation, assets, and required suite cases.',
+        inputSchema: packageInputSchema,
+        outputSchema: packageOutputSchema,
+        annotations: readOnlyAnalysisTool,
+    },
+    {
+        name: 'hoi4.scenario_test',
+        title: 'Run scenario suite',
+        description: 'Run named inline or workspace-relative cases through bounded typed read-only domain services. Large suites return an authenticated continuation.',
+        inputSchema: scenarioInputSchema,
+        outputSchema: scenarioOutputSchema,
+        annotations: readOnlyAnalysisTool,
+    },
 ];
 export function registerAnalysisTools(server) {
     registerLegacyTaskTools(server, analysisTaskTools);

package/dist/hoi4_agent_tools/mechanic/assertions.js

@@ -0,0 +1,112 @@
+import { canonicalJson } from '../core/canonical.js';
+import { scenarioValue } from '../core/scenario-model.js';
+function value(state, path) {
+    return scenarioValue(state, path.key, path.scope);
+}
+function number(state, path) {
+    const found = value(state, path);
+    return typeof found === 'number' && Number.isFinite(found) ? found : undefined;
+}
+function result(assertion, status, observed, reason) {
+    return {
+        id: assertion.id,
+        kind: assertion.kind,
+        status,
+        ...(observed === undefined ? {} : { observed }),
+        ...(reason === undefined ? {} : { reason }),
+    };
+}
+export function evaluateMechanicAssertions(assertions, before, after, checkpoints, trace) {
+    return assertions.map((assertion) => {
+        if (before.unknown.has('*') || after.unknown.has('*'))
+            return result(assertion, 'unresolved', undefined, 'An unsupported effect may write this state');
+        if (assertion.kind === 'equals' || assertion.kind === 'end_state') {
+            const found = value(after, assertion.path);
+            if (found === undefined)
+                return result(assertion, 'unresolved', undefined, 'End-state value is unknown');
+            return result(assertion, found === assertion.expected ? 'passed' : 'failed', found);
+        }
+        if (assertion.kind === 'conservation') {
+            const starting = assertion.paths.map((path) => number(before, path));
+            const ending = assertion.paths.map((path) => number(after, path));
+            if ([...starting, ...ending].some((item) => item === undefined))
+                return result(assertion, 'unresolved', undefined, 'Conserved values must be declared numbers');
+            const initial = starting.reduce((sum, item) => sum + item, 0);
+            const final = ending.reduce((sum, item) => sum + item, 0);
+            return result(assertion, Math.abs(initial - final) <= assertion.tolerance ? 'passed' : 'failed', { initial, final, difference: final - initial });
+        }
+        if (assertion.kind === 'array_alignment') {
+            const arrays = assertion.paths.map((path) => value(after, path));
+            if (arrays.some((item) => !Array.isArray(item)))
+                return result(assertion, 'unresolved', undefined, 'All aligned values must be declared arrays');
+            const lengths = arrays.map((array) => array.length);
+            return result(assertion, lengths.every((length) => length === lengths[0]) ? 'passed' : 'failed', lengths);
+        }
+        if (assertion.kind === 'affordability') {
+            const available = number(before, assertion.balance);
+            return available === undefined
+                ? result(assertion, 'unresolved', undefined, 'Starting balance is unknown')
+                : result(assertion, available >= assertion.cost ? 'passed' : 'failed', {
+                    available,
+                    cost: assertion.cost,
+                });
+        }
+        if (assertion.kind === 'single_payment') {
+            const starting = number(before, assertion.balance);
+            const ending = number(after, assertion.balance);
+            const reductions = trace.flatMap((step) => step.status === 'applied' &&
+                step.scope === assertion.balance.scope &&
+                step.target === assertion.balance.key &&
+                typeof step.before === 'number' &&
+                typeof step.after === 'number' &&
+                step.before > step.after
+                ? [step.before - step.after]
+                : []);
+            return starting === undefined || ending === undefined
+                ? result(assertion, 'unresolved', undefined, 'Payment balance is unknown')
+                : result(assertion, reductions.length === 1 &&
+                    reductions[0] === assertion.cost &&
+                    starting - ending === assertion.cost
+                    ? 'passed'
+                    : 'failed', {
+                    paid: starting - ending,
+                    expected: assertion.cost,
+                    deductions: reductions,
+                });
+        }
+        if (assertion.kind === 'repeated_setup') {
+            const first = checkpoints[assertion.firstStep];
+            const second = checkpoints[assertion.secondStep];
+            if (first === undefined ||
+                second === undefined ||
+                first.unknown.size > 0 ||
+                second.unknown.size > 0)
+                return result(assertion, 'unresolved', undefined, 'Repeated setup checkpoints are unavailable');
+            return result(assertion, canonicalJson(first.scenario) === canonicalJson(second.scenario) ? 'passed' : 'failed', { firstStep: assertion.firstStep, secondStep: assertion.secondStep });
+        }
+        if (assertion.kind === 'exclusive_flags') {
+            const flags = assertion.scope === 'GLOBAL'
+                ? after.scenario.globalFlags
+                : assertion.scope === 'ROOT'
+                    ? after.scenario.flags
+                    : after.scenario.scopes?.[assertion.scope]?.flags;
+            if (flags === undefined)
+                return result(assertion, 'unresolved', undefined, 'Flag scope is undeclared');
+            const active = assertion.flags.filter((flag) => flags.includes(flag));
+            return result(assertion, active.length <= 1 ? 'passed' : 'failed', active);
+        }
+        const flags = assertion.scope === 'GLOBAL'
+            ? after.scenario.globalFlags
+            : assertion.scope === 'ROOT'
+                ? after.scenario.flags
+                : after.scenario.scopes?.[assertion.scope]?.flags;
+        const targets = assertion.scope === 'ROOT'
+            ? after.scenario.eventTargets
+            : after.scenario.scopes?.[assertion.scope]?.eventTargets;
+        if (flags === undefined && assertion.flags.length > 0)
+            return result(assertion, 'unresolved', undefined, 'Cleanup flag scope is undeclared');
+        const lingeringFlags = assertion.flags.filter((flag) => flags?.includes(flag));
+        const lingeringTargets = assertion.targets.filter((target) => targets?.[target] !== undefined);
+        return result(assertion, lingeringFlags.length === 0 && lingeringTargets.length === 0 ? 'passed' : 'failed', { lingeringFlags, lingeringTargets });
+    });
+}