hoi4-agent-tools 3.0.9 → 3.1.0

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(),

package/dist/hoi4_agent_tools/technology/graph.js

@@ -1,6 +1,8 @@
 import { canonicalJson, compareCodeUnits, deterministicId, hashCanonical, } from '../core/canonical.js';
 import { sortDiagnostics } from '../core/diagnostics.js';
 import { ServiceError } from '../core/result.js';
+import { beginSemanticAnalysis, semanticFragment, SemanticCatalog, } from '../core/semantic-dependencies.js';
+import { runDependencyAnalysis, runDependencyAnalysisAsync, } from '../core/dependency-walk.js';
 import { analyzeTechnologySource, technologyAnalysisDiagnostics, technologySourceFiles, technologySourceFragmentCacheKey, } from './source-analysis.js';
 import { TECHNOLOGY_GRAPH_SCHEMA_VERSION, TECHNOLOGY_PARSER_VERSION, } from './model.js';
 const MAX_TECHNOLOGIES = 100_000;
@@ -374,7 +376,24 @@ function stronglyConnectedComponents(nodeIds, edges, signal) {
     }
     return components.sort((left, right) => compareCodeUnits(left[0] ?? '', right[0] ?? ''));
 }
-function expandHelperReferences(references, calls, unresolved, analysisMode, signal) {
+function technologyHelperWalk(calls, sourceRevision) {
+    return {
+        domain: 'technology-helper-references',
+        sourceRevision,
+        edges: calls.map(({ id, sourceKind, sourceId, helperId }) => ({
+            id,
+            from: `${sourceKind}:${sourceId}`,
+            to: `scripted_effect:${helperId}`,
+        })),
+        roots: calls.filter(({ sourceKind }) => sourceKind !== 'scripted_effect').map(({ id }) => id),
+        branches: [...new Set(calls.map(({ helperId }) => `scripted_effect:${helperId}`))].sort(compareCodeUnits),
+        maximumDepth: MAX_HELPER_DEPTH,
+        maximumSteps: 10_000_000,
+        visitPolicy: 'path',
+        reverseEdges: false,
+    };
+}
+function expandHelperReferences(references, calls, unresolved, analysisMode, walk, signal) {
     const direct = references.filter(({ sourceKind }) => sourceKind === 'scripted_effect');
     const publicReferences = references.filter(({ sourceKind }) => sourceKind !== 'scripted_effect');
     if (analysisMode === 'focused') {
@@ -404,82 +423,59 @@ function expandHelperReferences(references, calls, unresolved, analysisMode, sig
         group.push(reference);
         refsByHelper.set(reference.sourceId, group);
     }
-    const callsBySource = new Map();
-    for (const call of calls) {
-        const key = `${call.sourceKind}:${call.sourceId}`;
-        const group = callsBySource.get(key) ?? [];
-        group.push(call);
-        callsBySource.set(key, group);
-    }
     const projected = [...publicReferences, ...direct];
     let projectionCount = 0;
-    for (const rootCall of calls.filter(({ sourceKind }) => sourceKind !== 'scripted_effect')) {
-        const stack = [
-            {
-                helperId: rootCall.helperId,
-                helperStack: [rootCall.helperId],
-                confidence: rootCall.confidence,
-            },
-        ];
-        const visited = new Set();
-        while (stack.length > 0) {
-            signal?.throwIfAborted();
-            const current = stack.pop();
-            const visitKey = current.helperStack.join('\0');
-            if (visited.has(visitKey))
-                continue;
-            visited.add(visitKey);
-            if (current.helperStack.length > MAX_HELPER_DEPTH) {
-                unresolved.push({
-                    id: deterministicId('tech-unresolved', { rootCall, helperStack: current.helperStack }),
-                    kind: 'unsupported_construct',
-                    expression: current.helperStack.join(' -> '),
-                    ownerId: rootCall.sourceId,
-                    location: rootCall.location,
-                    confidence: 'unresolved',
-                    blockers: [
-                        {
-                            code: 'TECH_HELPER_DEPTH_BLOCKED',
-                            message: `Scripted-effect expansion exceeds depth ${MAX_HELPER_DEPTH}`,
-                            location: rootCall.location,
-                        },
-                    ],
-                });
-                continue;
-            }
-            for (const reference of refsByHelper.get(current.helperId) ?? []) {
-                projectionCount += 1;
-                if (projectionCount > MAX_HELPER_PROJECTIONS)
-                    break;
-                projected.push({
-                    ...reference,
-                    id: deterministicId('tech-external-projection', {
-                        root: rootCall.id,
-                        reference: reference.id,
-                        helperStack: current.helperStack,
-                    }),
-                    sourceKind: rootCall.sourceKind,
-                    sourceId: rootCall.sourceId,
-                    helperStack: [...current.helperStack],
-                    confidence: worseConfidence(current.confidence, reference.confidence),
-                    metadata: {
-                        ...reference.metadata,
-                        projectedFromScriptedEffect: reference.sourceId,
-                        callLocation: canonicalJson(rootCall.location),
+    if (walk === undefined)
+        throw new Error('Full technology helper analysis requires a dependency traversal');
+    const roots = calls.filter(({ sourceKind }) => sourceKind !== 'scripted_effect');
+    const callById = new Map(calls.map((call) => [call.id, call]));
+    for (const record of walk.state.records) {
+        signal?.throwIfAborted();
+        if (record.kind !== 'visit' && record.kind !== 'depth')
+            continue;
+        const rootCall = roots[record.root];
+        const path = walk.path(record.path).map(({ id }) => callById.get(id));
+        const helperStack = path.map(({ helperId }) => helperId);
+        if (record.kind === 'depth') {
+            unresolved.push({
+                id: deterministicId('tech-unresolved', { rootCall, helperStack }),
+                kind: 'unsupported_construct',
+                expression: helperStack.join(' -> '),
+                ownerId: rootCall.sourceId,
+                location: rootCall.location,
+                confidence: 'unresolved',
+                blockers: [
+                    {
+                        code: 'TECH_HELPER_DEPTH_BLOCKED',
+                        message: `Scripted-effect expansion exceeds depth ${MAX_HELPER_DEPTH}`,
+                        location: rootCall.location,
                     },
-                });
-            }
+                ],
+            });
+            continue;
+        }
+        const confidence = path.reduce((value, call) => worseConfidence(value, call.confidence), rootCall.confidence);
+        for (const reference of refsByHelper.get(path.at(-1).helperId) ?? []) {
+            projectionCount++;
             if (projectionCount > MAX_HELPER_PROJECTIONS)
                 break;
-            for (const call of callsBySource.get(`scripted_effect:${current.helperId}`) ?? []) {
-                if (current.helperStack.includes(call.helperId))
-                    continue;
-                stack.push({
-                    helperId: call.helperId,
-                    helperStack: [...current.helperStack, call.helperId],
-                    confidence: worseConfidence(current.confidence, call.confidence),
-                });
-            }
+            projected.push({
+                ...reference,
+                id: deterministicId('tech-external-projection', {
+                    root: rootCall.id,
+                    reference: reference.id,
+                    helperStack,
+                }),
+                sourceKind: rootCall.sourceKind,
+                sourceId: rootCall.sourceId,
+                helperStack,
+                confidence: worseConfidence(confidence, reference.confidence),
+                metadata: {
+                    ...reference.metadata,
+                    projectedFromScriptedEffect: reference.sourceId,
+                    callLocation: canonicalJson(rootCall.location),
+                },
+            });
         }
         if (projectionCount > MAX_HELPER_PROJECTIONS)
             break;
@@ -1123,14 +1119,13 @@ function fragmentsFor(snapshot, options) {
     };
     const fingerprint = helperCatalogFingerprint(snapshot);
     const fragments = [];
+    const dependencies = beginSemanticAnalysis(options.cache, snapshot, 'technology', options.workspaceIdentity);
+    const reads = new SemanticCatalog();
+    context.helperIds = reads.bind('helpers', 'scripted_effect', helperIds);
     for (const file of technologySourceFiles(snapshot.files)) {
         options.signal?.throwIfAborted();
         const key = technologySourceFragmentCacheKey(file, fingerprint);
-        let fragment = options.cache?.get(key);
-        if (fragment === undefined) {
-            fragment = analyzeTechnologySource(file, context);
-            options.cache?.set(key, fragment, file.bytes.length);
-        }
+        const fragment = semanticFragment(dependencies, options.cache, file, key, reads, () => analyzeTechnologySource(file, context));
         fragments.push(fragment);
     }
     return fragments;
@@ -1143,6 +1138,12 @@ function resolveUnlocks(unlocks, targets, complete) {
     }));
 }
 export function buildTechnologyGraph(snapshot, options) {
+    return runDependencyAnalysis(technologyGraphAnalysis(snapshot, options), options.signal);
+}
+export function buildTechnologyGraphAsync(snapshot, options) {
+    return runDependencyAnalysisAsync(technologyGraphAnalysis(snapshot, options), options.signal);
+}
+function* technologyGraphAnalysis(snapshot, options) {
     options.signal?.throwIfAborted();
     const fragments = fragmentsFor(snapshot, options);
     const assets = assetMap(options.assetFiles ?? []);
@@ -1167,7 +1168,10 @@ export function buildTechnologyGraph(snapshot, options) {
     const placements = enrichPlacements(basePlacements, edges, gridboxes, technologies, unlocks, itemLayouts, options.signal);
     const unresolved = fragments.flatMap(({ unresolved }) => unresolved);
     const helperCalls = fragments.flatMap(({ helperCalls }) => helperCalls);
-    const externalReferences = expandHelperReferences(fragments.flatMap(({ externalReferences }) => externalReferences), helperCalls, unresolved, options.analysisMode ?? 'full', options.signal);
+    const walk = options.analysisMode === 'focused'
+        ? undefined
+        : yield technologyHelperWalk(helperCalls, snapshot.revision);
+    const externalReferences = expandHelperReferences(fragments.flatMap(({ externalReferences }) => externalReferences), helperCalls, unresolved, options.analysisMode ?? 'full', walk, options.signal);
     const issues = diagnose(technologies, folders, placements, gridboxes, edges, categories, doctrineDefinitions, unlocks, externalReferences, selectedTechnologies.duplicates.map((group) => group.map(({ iconSprite, effectSignatureFields, ...technology }) => ({
         ...technology,
         icon: iconStatus(iconSprite, snapshot.index, assets),
@@ -1199,6 +1203,7 @@ export function buildTechnologyGraph(snapshot, options) {
         revision,
         complete: snapshot.complete &&
             unresolved.every(({ kind }) => kind !== 'partial_source') &&
+            !unresolved.some(({ blockers }) => blockers.some(({ code }) => code === 'TECH_HELPER_DEPTH_BLOCKED' || code === 'TECH_HELPER_PROJECTION_LIMIT')) &&
             !(options.analysisMode === 'focused' && helperCalls.length > 0),
         analysisBoundary: {
             staticAnalysis: true,

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

@@ -0,0 +1,33 @@
+import { compareCodeUnits } from '../core/canonical.js';
+export function technologyHelperInventory(graph, sourceComplete) {
+    return {
+        domain: 'technology',
+        sourceRevision: graph.revision,
+        sourceComplete,
+        sourceHashes: graph.sourceHashes,
+        unresolved: graph.unresolved.filter(({ id }) => id !== 'tech-unresolved-helper-expansion-deferred'),
+        edges: [
+            ...graph.helperCalls.map((call) => ({
+                id: call.id,
+                from: `${call.sourceKind}:${call.sourceId}`,
+                to: `scripted_effect:${call.helperId}`,
+                evidence: { kind: 'helper_call', call },
+            })),
+            ...graph.externalReferences
+                .filter(({ sourceKind }) => sourceKind === 'scripted_effect')
+                .map((reference) => ({
+                id: `reference:${reference.id}`,
+                from: `scripted_effect:${reference.sourceId}`,
+                to: `reference:${reference.id}`,
+                evidence: { kind: 'technology_reference', reference },
+            })),
+        ].sort((left, right) => compareCodeUnits(left.id, right.id)),
+        roots: graph.helperCalls
+            .filter(({ sourceKind }) => sourceKind !== 'scripted_effect')
+            .map(({ id }) => id)
+            .sort(compareCodeUnits),
+        branches: [
+            ...new Set(graph.helperCalls.map(({ helperId }) => `scripted_effect:${helperId}`)),
+        ].sort(compareCodeUnits),
+    };
+}

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

@@ -0,0 +1,60 @@
+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 { technologyCompareRequestSchema, technologyInspectRequestSchema, technologyRenderRequestSchema, } from '../schemas/technology.js';
+import { compareTechnologies, inspectTechnologies, normalizeTechnologyCompareRequest, normalizeTechnologyInspectionRequest, normalizeTechnologyRenderRequest, renderTechnologies, } from './operations.js';
+import { TechnologyTreeViewer } from './service.js';
+const wireResult = z.record(z.string(), z.json());
+/** Registers typed technology operations without invoking transport handlers. */
+export function registerTechnologyJobs(operations, engine) {
+    const viewer = new TechnologyTreeViewer(engine);
+    const lifetime = new IdleCacheLifetime(() => viewer.clearCaches());
+    function register(name, schema, normalize, execute, message) {
+        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');
+                await context.progress({ completed: 0, total: 3, message });
+                const result = await execute(viewer, {
+                    ...normalize(input),
+                    workspaceId: context.workspaceId,
+                    ...(context.principal === undefined ? {} : { principal: context.principal }),
+                    signal: context.signal,
+                });
+                await context.progress({
+                    completed: 3,
+                    total: 3,
+                    message: 'Technology operation complete',
+                });
+                const wire = wireResult.parse(JSON.parse(JSON.stringify(toolResult(result))));
+                const revision = result.data !== null &&
+                    typeof result.data === 'object' &&
+                    'revision' in result.data &&
+                    typeof result.data.revision === 'string'
+                    ? result.data.revision
+                    : result.data !== null &&
+                        typeof result.data === 'object' &&
+                        'afterRevision' in result.data &&
+                        typeof result.data.afterRevision === 'string'
+                        ? result.data.afterRevision
+                        : 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.tech_inspect', technologyInspectRequestSchema, normalizeTechnologyInspectionRequest, inspectTechnologies, 'Analyzing technology trees');
+    register('hoi4.tech_render', technologyRenderRequestSchema, normalizeTechnologyRenderRequest, renderTechnologies, 'Rendering technology-tree view');
+    register('hoi4.tech_compare', technologyCompareRequestSchema, normalizeTechnologyCompareRequest, compareTechnologies, 'Comparing technology-tree graphs');
+}