hoi4-agent-tools 3.0.8 → 3.1.0

package/dist/hoi4_agent_tools/schemas/gui-requests.js

@@ -0,0 +1,193 @@
+import { z } from 'zod/v4';
+import { renderDimensionViolation, RenderBudget, RENDER_MAX_DIMENSION, } from '../core/render-budget.js';
+import { ServiceError } from '../core/result.js';
+import { SOURCE_MAX_BYTES } from '../core/source/index.js';
+import { GUI_TEXT_PACKAGE_MAX_FILES, GuiHelperDocumentSchema } from '../gui/index.js';
+import { GuiGeneratedScenarioOptionsSchema, GuiPreviewScenarioSchema } from '../gui/scenario.js';
+import { backgroundRequestKeySchema, workspaceIdSchema, workspaceRelativePathSchema, } from './common.js';
+function compact(schema, description) {
+    return z.unknown().describe(description).pipe(schema);
+}
+const compactGuiScenarioSchema = compact(GuiPreviewScenarioSchema, 'GUI preview scenario.');
+const compactGeneratedScenarioOptionsSchema = compact(GuiGeneratedScenarioOptionsSchema, 'GUI generated-scenario options.');
+const compactGuiHelperSchema = compact(GuiHelperDocumentSchema, 'GUI helper document.');
+export const guiPreviewStateSchema = z.enum([
+    'normal',
+    'hover',
+    'selected',
+    'locked',
+    'disabled',
+    'warning',
+    'active',
+    'completed',
+    'empty-list',
+    'full-list',
+    'minimum-value',
+    'maximum-value',
+    'long-text',
+    'missing-localisation',
+]);
+export const guiInspectRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    windowName: z.string().min(1).max(256).optional(),
+    scenario: compactGuiScenarioSchema.optional(),
+    relatedScenarios: z.array(compactGuiScenarioSchema).max(32).optional(),
+    generatedScenarios: compactGeneratedScenarioOptionsSchema.optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if ((value.windowName === undefined) !== (value.scenario === undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'windowName and scenario must be provided together',
+        });
+    if (value.relatedScenarios !== undefined && value.scenario === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['relatedScenarios'],
+            message: 'relatedScenarios requires a window scenario',
+        });
+    if (value.generatedScenarios !== undefined && value.scenario === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['generatedScenarios'],
+            message: 'generatedScenarios requires a window scenario',
+        });
+});
+export const guiResolutionSchema = z
+    .object({
+    width: z.number().int().min(320).max(RENDER_MAX_DIMENSION),
+    height: z.number().int().min(200).max(RENDER_MAX_DIMENSION),
+    uiScale: z
+        .number()
+        .min(0.25)
+        .max(4)
+        .optional()
+        .describe('In-game UI scale for this resolution. Use 1 at 1920x1080; do not use it to enlarge an artifact.'),
+})
+    .strict()
+    .superRefine(({ width, height }, context) => {
+    const violation = renderDimensionViolation(width, height, 'GUI matrix resolution');
+    if (violation !== undefined)
+        context.addIssue({ code: 'custom', message: `${violation.code}: ${violation.message}` });
+});
+export const guiRenderRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    windowName: z.string().min(1).max(256),
+    scenario: compactGuiScenarioSchema,
+    states: z.array(guiPreviewStateSchema).max(14).optional(),
+    resolutions: z.array(guiResolutionSchema).min(1).max(16).optional(),
+    relatedScenarios: z.array(compactGuiScenarioSchema).max(32).optional(),
+    generatedScenarios: compactGeneratedScenarioOptionsSchema.optional(),
+    comparisonScenario: compactGuiScenarioSchema.optional(),
+})
+    .strict()
+    .superRefine(({ scenario, states, resolutions, relatedScenarios, generatedScenarios }, context) => {
+    const budget = new RenderBudget();
+    try {
+        const stateCount = states?.length ?? 14;
+        for (let index = 0; index < 9 + stateCount; index += 1)
+            budget.reserve(scenario.resolution.width, scenario.resolution.height, 'GUI request variant');
+        for (const resolution of resolutions ?? [
+            { width: 1280, height: 720 },
+            { width: 1920, height: 1080 },
+            { width: 2560, height: 1440 },
+            { width: 1920, height: 1080 },
+        ])
+            budget.reserve(resolution.width, resolution.height, 'GUI resolution variant');
+        const generatedCount = generatedScenarios?.enabled === false ? 0 : (generatedScenarios?.count ?? 1);
+        const scenarioCount = generatedCount === 0
+            ? 1 + (relatedScenarios?.length ?? 0)
+            : generatedCount +
+                (generatedScenarios?.preservePlaceholder === false ? 0 : 1) +
+                (relatedScenarios?.length ?? 0);
+        const stateColumns = Math.min(3, Math.max(1, stateCount));
+        const stateRows = Math.max(1, Math.ceil(stateCount / stateColumns));
+        budget.reserve(stateColumns * 420, 46 + stateRows * 280, 'GUI state gallery');
+        const resolutionCount = resolutions?.length ?? 4;
+        const resolutionColumns = Math.min(3, Math.max(1, resolutionCount));
+        const resolutionRows = Math.max(1, Math.ceil(resolutionCount / resolutionColumns));
+        budget.reserve(resolutionColumns * 420, 46 + resolutionRows * 280, 'GUI resolution gallery');
+        const scenarioBudget = new RenderBudget();
+        const scenarioColumns = Math.min(3, Math.max(1, scenarioCount));
+        const scenarioRows = Math.max(1, Math.ceil(scenarioCount / scenarioColumns));
+        scenarioBudget.reserve(scenarioColumns * 420, 46 + scenarioRows * 280, 'GUI scripted scenario gallery');
+    }
+    catch (error) {
+        if (error instanceof ServiceError) {
+            context.addIssue({ code: 'custom', message: `${error.code}: ${error.message}` });
+            return;
+        }
+        throw error;
+    }
+});
+export const guiRewriteRequestSchema = z
+    .object({
+    mode: z.enum(['source', 'helpers', 'patches']),
+    workspaceId: workspaceIdSchema,
+    relativePath: workspaceRelativePathSchema,
+    windowName: z.string().min(1).max(256),
+    scenario: compactGuiScenarioSchema,
+    requestKey: backgroundRequestKeySchema.optional(),
+    source: z.string().max(SOURCE_MAX_BYTES).optional(),
+    helper: compactGuiHelperSchema.optional(),
+    additionalFiles: z
+        .array(z
+        .object({
+        relativePath: workspaceRelativePathSchema,
+        source: z.string().max(SOURCE_MAX_BYTES),
+    })
+        .strict())
+        .max(GUI_TEXT_PACKAGE_MAX_FILES - 1)
+        .optional(),
+    expectedSourceHash: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional(),
+    patches: z
+        .array(z
+        .object({
+        start: z.number().int().min(0),
+        end: z.number().int().min(0),
+        expectedText: z.string().max(5_000_000),
+        text: z.string().max(5_000_000),
+        description: z.string().min(1).max(1000),
+    })
+        .strict())
+        .min(1)
+        .max(1000)
+        .optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.mode === 'source' && value.source === undefined)
+        context.addIssue({ code: 'custom', message: 'source is required in source mode' });
+    if (value.mode === 'helpers' && value.helper === undefined)
+        context.addIssue({ code: 'custom', message: 'helper is required in helpers mode' });
+    if (value.mode === 'patches' &&
+        (value.patches === undefined || value.expectedSourceHash === undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'patches and expectedSourceHash are required in patches mode',
+        });
+    if (value.mode === 'source' && value.helper !== undefined)
+        context.addIssue({ code: 'custom', message: 'helper is forbidden in source mode' });
+    if (value.mode === 'helpers' && value.source !== undefined)
+        context.addIssue({ code: 'custom', message: 'source is forbidden in helpers mode' });
+    if (value.mode !== 'patches' &&
+        (value.patches !== undefined || value.expectedSourceHash !== undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'patch fields are accepted only in patches mode',
+        });
+    if (value.mode === 'patches' &&
+        (value.source !== undefined ||
+            value.helper !== undefined ||
+            value.additionalFiles !== undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'source, helper, and additionalFiles are forbidden in patches mode',
+        });
+});

package/dist/hoi4_agent_tools/schemas/helper-expansion.js

@@ -0,0 +1,58 @@
+import { z } from 'zod/v4';
+export const helperExpansionRequestSchema = z
+    .object({
+    rootIds: z.array(z.string().min(1).max(1_024)).min(1).max(2_000).optional(),
+    maxDepth: z.number().int().min(1).max(256).optional(),
+    maxRecords: z.number().int().min(1).max(5_000).optional(),
+    maxWork: z.number().int().min(1).max(100_000).optional(),
+    continuationUri: z
+        .string()
+        .min(1)
+        .max(8_192)
+        .regex(/^hoi4-agent:\/\//u)
+        .optional(),
+})
+    .strict();
+const count = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+export const helperExpansionSummarySchema = z
+    .object({
+    complete: z.boolean(),
+    finished: z.boolean(),
+    sourceComplete: z.boolean(),
+    maxDepth: count,
+    records: count,
+    totalRecords: count,
+    work: count,
+    totalWork: count,
+    completedRoots: count,
+    totalRoots: count,
+    cycles: count,
+    depthStops: count,
+    continuationUri: z
+        .string()
+        .max(8_192)
+        .regex(/^hoi4-agent:\/\//u)
+        .optional(),
+})
+    .strict();
+/** A dedicated mode must not silently ignore filters belonging to other inspection modes. */
+export function validateHelperExpansionMode(value, context) {
+    const fields = value;
+    if (fields.mode !== 'helper_expansion') {
+        if (fields.helperExpansion !== undefined)
+            context.addIssue({
+                code: 'custom',
+                path: ['helperExpansion'],
+                message: 'helperExpansion requires helper_expansion mode',
+            });
+        return;
+    }
+    const allowed = new Set(['workspaceId', 'mode', 'helperExpansion', 'refresh']);
+    for (const [field, content] of Object.entries(fields))
+        if (content !== undefined && !allowed.has(field))
+            context.addIssue({
+                code: 'custom',
+                path: [field],
+                message: 'Use helperExpansion rootIds and bounds in helper_expansion mode',
+            });
+}

package/dist/hoi4_agent_tools/schemas/map-requests.js

@@ -0,0 +1,85 @@
+import { z } from 'zod/v4';
+import { MAP_PROVINCE_GEOMETRY_SELECTOR_LIMIT } from '../map/limits.js';
+import { backgroundRequestKeySchema, workspaceIdSchema } from './common.js';
+import { mapAllocationRequestSchema, mapOperationSchema } from './map.js';
+function compact(schema, description) {
+    return z.unknown().describe(description).pipe(schema);
+}
+const compactMapOperationSchema = compact(mapOperationSchema, 'Complete map operation.');
+export const mapLayerSchema = z.enum([
+    'province',
+    'state',
+    'strategic-region',
+    'terrain',
+    'continent',
+    'owner',
+    'controller',
+    'cores',
+    'claims',
+    'coast',
+]);
+export const mapOverlaySchema = z.enum([
+    'coastlines',
+    'ports',
+    'victory-points',
+    'resources',
+    'state-buildings',
+    'province-buildings',
+    'supply-nodes',
+    'railways',
+    'adjacencies',
+    'building-positions',
+    'unit-positions',
+    'weather-positions',
+]);
+export const mapInspectRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    provinceIds: z
+        .array(z.number().int().min(0))
+        .max(MAP_PROVINCE_GEOMETRY_SELECTOR_LIMIT)
+        .default([])
+        .describe(`Export row runs for up to ${MAP_PROVINCE_GEOMETRY_SELECTOR_LIMIT} province IDs`),
+    stateIds: z.array(z.number().int().positive()).max(1_000).default([]),
+    regionIds: z.array(z.number().int().positive()).max(1_000).default([]),
+    query: z.string().max(256).optional(),
+    queryLimit: z.number().int().min(1).max(1_000).default(100),
+    coordinates: z
+        .array(z.discriminatedUnion('kind', [
+        z
+            .object({
+            kind: z.literal('pixel'),
+            x: z.number().int().min(0),
+            y: z.number().int().min(0),
+        })
+            .strict(),
+        z
+            .object({
+            kind: z.literal('map'),
+            x: z.number(),
+            z: z.number(),
+        })
+            .strict(),
+    ]))
+        .max(100)
+        .default([]),
+    includeOverview: z.boolean().default(true),
+    allocationRequests: z.array(mapAllocationRequestSchema).max(100).default([]),
+})
+    .strict();
+export const mapRenderRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    layer: mapLayerSchema.optional(),
+    overlays: z.array(mapOverlaySchema).max(12).optional(),
+    scale: z.number().int().min(1).max(16).optional(),
+})
+    .strict();
+export const mapRewriteRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    operations: z.array(compactMapOperationSchema).min(1).max(100),
+    diffScale: z.number().int().min(1).max(16).optional(),
+    requestKey: backgroundRequestKeySchema.optional(),
+})
+    .strict();

package/dist/hoi4_agent_tools/schemas/probability-requests.js

@@ -0,0 +1,168 @@
+import { z } from 'zod/v4';
+import { customWeightedPoolManifestSchema, probabilityAcceptanceBandSchema, probabilityAdapterIdSchema, probabilityDiagnosticThresholdsSchema, probabilityMetricSchema, probabilityOutputSchema, probabilityRenderFilterSchema, probabilityScenarioSetSchema, probabilitySamplingMethodSchema, probabilitySourceSchema, } from './probability.js';
+import { workspaceIdSchema } from './common.js';
+function compact(schema, description) {
+    return z.unknown().describe(description).pipe(schema);
+}
+const nestedSource = compact(probabilitySourceSchema, 'Source selector or proposed source.');
+const nestedScenarios = compact(probabilityScenarioSetSchema, 'Explicit world-state scenarios.');
+const nestedManifest = compact(customWeightedPoolManifestSchema, 'Declared custom weighted pool and state transitions.');
+const nestedRenderFilter = compact(probabilityRenderFilterSchema, 'Optional scenario, candidate, metric, diagnostic, source, and page filter.');
+const nestedAcceptanceBands = compact(z.array(probabilityAcceptanceBandSchema).max(100_000), 'Optional named metric acceptance bands.');
+const nestedDiagnosticThresholds = compact(probabilityDiagnosticThresholdsSchema, 'Optional diagnostic thresholds.');
+const candidatePool = z.array(z.string().min(1).max(512)).max(100_000).optional();
+const outputs = z.array(probabilityOutputSchema).max(10).optional();
+const commonShape = {
+    workspaceId: workspaceIdSchema,
+    adapter: probabilityAdapterIdSchema.optional(),
+    scenarioSet: nestedScenarios,
+    candidatePool,
+    horizonDays: z.number().positive().max(1_000_000).optional(),
+    metrics: z.array(probabilityMetricSchema).min(1).max(4).optional(),
+    acceptanceBands: nestedAcceptanceBands.optional(),
+    diagnosticThresholds: nestedDiagnosticThresholds.optional(),
+    outputs,
+    refresh: z.boolean().optional(),
+};
+export const probabilityInspectRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    adapter: probabilityAdapterIdSchema.optional(),
+    source: nestedSource.optional(),
+    customPoolManifest: nestedManifest.optional(),
+    candidatePool,
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.source !== undefined && value.customPoolManifest !== undefined)
+        context.addIssue({ code: 'custom', message: 'Provide either source or customPoolManifest' });
+    if (value.adapter !== undefined &&
+        value.source === undefined &&
+        value.customPoolManifest === undefined)
+        context.addIssue({
+            code: 'custom',
+            message: 'An adapter requires a source; provide a source alone to discover compatible adapters',
+        });
+    if (value.customPoolManifest !== undefined &&
+        value.adapter !== undefined &&
+        value.adapter !== 'custom_weighted_pool')
+        context.addIssue({
+            code: 'custom',
+            path: ['adapter'],
+            message: 'customPoolManifest requires adapter custom_weighted_pool',
+        });
+});
+export const probabilityEvaluateRequestSchema = z
+    .object({
+    ...commonShape,
+    source: nestedSource.optional(),
+    customPoolManifest: nestedManifest.optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if ((value.source === undefined) === (value.customPoolManifest === undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'Provide exactly one source or customPoolManifest',
+        });
+    if (value.customPoolManifest !== undefined &&
+        value.adapter !== undefined &&
+        value.adapter !== 'custom_weighted_pool')
+        context.addIssue({
+            code: 'custom',
+            path: ['adapter'],
+            message: 'customPoolManifest requires adapter custom_weighted_pool',
+        });
+});
+export const probabilitySweepRequestSchema = z
+    .object({
+    ...commonShape,
+    source: nestedSource,
+    sweep: z
+        .object({
+        paths: z.array(z.string().min(1).max(1024)).min(1).max(32),
+        steps: z.number().int().min(2).max(10_000).default(25),
+        pairwise: z.boolean().default(false),
+        findRankReversals: z.boolean().default(true),
+    })
+        .strict(),
+})
+    .strict();
+export const probabilitySimulateRequestSchema = z
+    .object({
+    ...commonShape,
+    source: nestedSource,
+    samples: z.number().int().min(100).max(10_000_000).default(100_000),
+    seed: z.number().int().min(-2_147_483_648).max(2_147_483_647).default(1),
+    confidenceLevel: z.number().min(0.5).max(0.9999).default(0.95),
+    samplingMethod: probabilitySamplingMethodSchema.default('latin_hypercube'),
+})
+    .strict();
+export const probabilitySequenceRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    scenarioSet: nestedScenarios,
+    customPoolManifest: nestedManifest,
+    horizonDays: z.number().positive().max(1_000_000),
+    maxSteps: z.number().int().min(1).max(100_000).default(1_000),
+    samples: z.number().int().min(100).max(10_000_000).default(100_000),
+    seed: z.number().int().min(-2_147_483_648).max(2_147_483_647).default(1),
+    confidenceLevel: z.number().min(0.5).max(0.9999).default(0.95),
+    acceptanceBands: nestedAcceptanceBands.optional(),
+    diagnosticThresholds: nestedDiagnosticThresholds.optional(),
+    outputs,
+})
+    .strict();
+export const probabilityCompareRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    adapter: probabilityAdapterIdSchema.optional(),
+    before: nestedSource.optional(),
+    after: nestedSource.optional(),
+    beforeManifest: nestedManifest.optional(),
+    afterManifest: nestedManifest.optional(),
+    scenarioSet: nestedScenarios,
+    candidatePool,
+    horizonDays: z.number().positive().max(1_000_000).optional(),
+    acceptanceBands: nestedAcceptanceBands.optional(),
+    diagnosticThresholds: nestedDiagnosticThresholds.optional(),
+    outputs,
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    const sourceMode = value.before !== undefined || value.after !== undefined;
+    const manifestMode = value.beforeManifest !== undefined || value.afterManifest !== undefined;
+    if (sourceMode === manifestMode)
+        context.addIssue({
+            code: 'custom',
+            message: 'Compare either before/after sources or beforeManifest/afterManifest',
+        });
+    if (sourceMode && (value.before === undefined || value.after === undefined))
+        context.addIssue({ code: 'custom', message: 'Source comparison requires before and after' });
+    if (manifestMode && (value.beforeManifest === undefined || value.afterManifest === undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'Custom-pool comparison requires beforeManifest and afterManifest',
+        });
+    if (manifestMode && value.adapter !== undefined && value.adapter !== 'custom_weighted_pool')
+        context.addIssue({
+            code: 'custom',
+            path: ['adapter'],
+            message: 'Manifest comparison requires adapter custom_weighted_pool',
+        });
+});
+export const probabilityRenderRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    analysisId: z.string().min(1).max(256),
+    expectedScenarioHash: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional(),
+    outputs: z.array(probabilityOutputSchema).min(1).max(10),
+    includeHtml: z.boolean().default(false),
+    filter: nestedRenderFilter.optional(),
+})
+    .strict();

package/dist/hoi4_agent_tools/schemas/technology.js

@@ -1,6 +1,7 @@
 import { z } from 'zod/v4';
 import { SOURCE_MAX_BYTES } from '../core/source/index.js';
-import { workspaceRelativePathSchema } from './common.js';
+import { workspaceIdSchema, workspaceRelativePathSchema } from './common.js';
+import { helperExpansionRequestSchema, validateHelperExpansionMode } from './helper-expansion.js';
 export const technologyIdSchema = z.string().min(1).max(512);
 export const technologyDirectionSchema = z.enum(['prerequisites', 'descendants', 'both']);
 export const technologyUnlockKindSchema = z.enum([
@@ -75,3 +76,91 @@ export const technologyProposedSourceSchema = z
         .optional(),
 })
     .strict();
+export const technologyAnalysisModeSchema = z.enum([
+    'scan',
+    'folders',
+    'trace',
+    'explain',
+    'unlocks',
+    'bonus_coverage',
+    'lint',
+    'impact',
+    'helper_expansion',
+]);
+export function validateTechnologyInspectRequest(value, context) {
+    validateHelperExpansionMode(value, context);
+    if ((value.mode === 'trace' || value.mode === 'explain') && value.technologyId === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['technologyId'],
+            message: `${value.mode} requires technologyId`,
+        });
+    if (value.mode === 'impact' && value.impact === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['impact'],
+            message: 'Impact mode requires impact',
+        });
+}
+export const technologyInspectRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    mode: technologyAnalysisModeSchema,
+    folderId: technologyIdSchema.optional(),
+    technologyId: technologyIdSchema.optional(),
+    categoryId: technologyIdSchema.optional(),
+    targetKind: technologyUnlockKindSchema.optional(),
+    targetId: technologyIdSchema.optional(),
+    direction: technologyDirectionSchema.optional(),
+    maxDepth: z.number().int().min(1).max(256).optional(),
+    maxNodes: z.number().int().min(1).max(25_000).optional(),
+    includeSubTechnologies: z.boolean().optional(),
+    classifications: z.array(technologyDefectClassSchema).max(4).optional(),
+    codes: z.array(z.string().min(1).max(256)).max(100).optional(),
+    impact: technologyImpactSchema.optional(),
+    helperExpansion: helperExpansionRequestSchema.optional(),
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine(validateTechnologyInspectRequest);
+export const technologyRenderRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    view: technologyRenderViewSchema.exclude(['comparison']),
+    folderId: technologyIdSchema.optional(),
+    technologyId: technologyIdSchema.optional(),
+    categoryId: technologyIdSchema.optional(),
+    targetId: technologyIdSchema.optional(),
+    maxNodes: z.number().int().min(1).max(2_000).optional(),
+    includeHtml: z.boolean().optional(),
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.view === 'folder' && value.folderId === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['folderId'],
+            message: 'Folder view requires folderId',
+        });
+});
+export function validateTechnologyCompareRequest(value, context) {
+    if (value.after !== undefined && value.proposedSources !== undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['after'],
+            message: 'after conflicts with proposedSources',
+        });
+}
+export const technologyCompareRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    before: technologyGraphReferenceSchema.optional(),
+    after: technologyGraphReferenceSchema.optional(),
+    proposedSources: z.array(technologyProposedSourceSchema).min(1).max(128).optional(),
+    render: z.boolean().optional(),
+    maxRenderNodes: z.number().int().min(1).max(2_000).optional(),
+    refresh: z.boolean().optional(),
+})
+    .strict()
+    .superRefine(validateTechnologyCompareRequest);

package/dist/hoi4_agent_tools/schemas/transaction.js

@@ -96,6 +96,7 @@ export const transactionManifestSchema = z
     diagnostics: z.array(diagnosticSchema).max(TRANSACTION_MAX_DIAGNOSTICS),
     validation: validationSummarySchema,
     artifacts: z.array(artifactLinkSchema).max(TRANSACTION_MAX_ARTIFACTS),
+    executionArtifacts: z.array(artifactLinkSchema).max(TRANSACTION_MAX_ARTIFACTS).optional(),
     appliedFiles: z.array(workspaceRelativePathSchema).max(TRANSACTION_MAX_APPLIED_FILES),
     rollbackStatus: z.enum(['available', 'applied', 'failed']),
     failure: z.object({ code: identifierSchema, message: summarySchema }).strict().optional(),