hoi4-agent-tools 3.0.9 → 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/index-segments.js

@@ -0,0 +1,137 @@
+import { canonicalJson, compareCodeUnits, hashCanonical } from './canonical.js';
+import { PACKAGE_VERSION } from '../version.js';
+export function indexSegmentAddress(file, isProvinceDefinition) {
+    return hashCanonical({
+        version: 'file-index-segment.v1',
+        toolVersion: PACKAGE_VERSION,
+        sourceHash: file.sha256,
+        path: file.displayPath,
+        relativePath: file.relativePath,
+        rootKind: file.rootKind,
+        loadOrder: file.loadOrder,
+        shadowedBy: file.shadowedBy ?? null,
+        isProvinceDefinition,
+    });
+}
+/** Encoded entries keep the aggregate index's mutable records out of the shared cache. */
+export class IndexSegmentCache {
+    maxBytes;
+    #entries = new Map();
+    #retainedBytes = 0;
+    #hits = 0;
+    #misses = 0;
+    #evictions = 0;
+    #oversized = 0;
+    constructor(maxBytes = 64 * 1024 * 1024) {
+        this.maxBytes = maxBytes;
+        if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
+            throw new RangeError('Index segment cache size must be a non-negative integer');
+    }
+    get(address) {
+        const entry = this.#entries.get(address);
+        if (entry === undefined) {
+            this.#misses += 1;
+            return undefined;
+        }
+        this.#hits += 1;
+        this.#entries.delete(address);
+        this.#entries.set(address, entry);
+        return JSON.parse(entry.encoded);
+    }
+    /** Import one authenticated canonical entry without counting it as a process-local hit. */
+    importEncoded(address, encoded) {
+        const segment = JSON.parse(encoded);
+        if (typeof segment !== 'object' ||
+            segment === null ||
+            !('symbols' in segment) ||
+            !Array.isArray(segment.symbols) ||
+            !('references' in segment) ||
+            !Array.isArray(segment.references) ||
+            !('diagnostics' in segment) ||
+            !Array.isArray(segment.diagnostics) ||
+            !('complete' in segment) ||
+            typeof segment.complete !== 'boolean')
+            throw new Error('Persistent index segment is structurally invalid');
+        this.put(address, segment);
+    }
+    exportEncoded(address) {
+        return this.#entries.get(address)?.encoded;
+    }
+    put(address, segment) {
+        const encoded = canonicalJson(segment);
+        // Account for the UTF-16 string retained by V8, including conservative key overhead.
+        const bytes = encoded.length * 2 + address.length * 2 + 128;
+        if (bytes > this.maxBytes) {
+            this.#oversized += 1;
+            return;
+        }
+        const previous = this.#entries.get(address);
+        if (previous !== undefined) {
+            if (previous.encoded !== encoded)
+                throw new Error('An immutable index segment address produced different file-local facts');
+            this.#entries.delete(address);
+            this.#entries.set(address, previous);
+            return;
+        }
+        while (this.#retainedBytes + bytes > this.maxBytes) {
+            const oldest = this.#entries.entries().next().value;
+            if (oldest === undefined)
+                break;
+            this.#entries.delete(oldest[0]);
+            this.#retainedBytes -= oldest[1].bytes;
+            this.#evictions += 1;
+        }
+        this.#entries.set(address, { encoded, bytes });
+        this.#retainedBytes += bytes;
+    }
+    clear() {
+        this.#entries.clear();
+        this.#retainedBytes = 0;
+    }
+    statistics() {
+        return {
+            hits: this.#hits,
+            misses: this.#misses,
+            evictions: this.#evictions,
+            oversized: this.#oversized,
+            retainedBytes: this.#retainedBytes,
+            retainedSegments: this.#entries.size,
+        };
+    }
+}
+/** Reverse edges are derived from typed source references, never matching arbitrary strings. */
+export class ReverseSourceDependencies {
+    #consumers = new Map();
+    #definitions = new Map();
+    constructor(symbols, references) {
+        for (const symbol of symbols) {
+            const definitions = this.#definitions.get(symbol.path) ?? new Set();
+            definitions.add(`${symbol.kind}:${symbol.id}`);
+            this.#definitions.set(symbol.path, definitions);
+        }
+        for (const reference of references) {
+            const key = `${reference.toKind}:${reference.to}`;
+            const consumers = this.#consumers.get(key) ?? new Set();
+            consumers.add(reference.path);
+            this.#consumers.set(key, consumers);
+        }
+    }
+    affectedFiles(changedFiles) {
+        const affected = new Set(changedFiles);
+        const queue = [...affected];
+        for (const source of queue) {
+            for (const definition of this.#definitions.get(source) ?? []) {
+                for (const consumer of this.#consumers.get(definition) ?? []) {
+                    if (affected.has(consumer))
+                        continue;
+                    affected.add(consumer);
+                    queue.push(consumer);
+                }
+            }
+        }
+        return [...affected].sort(compareCodeUnits);
+    }
+    consumers(kind, id) {
+        return [...(this.#consumers.get(`${kind}:${id}`) ?? [])].sort(compareCodeUnits);
+    }
+}

package/dist/hoi4_agent_tools/core/index.js

@@ -1,6 +1,7 @@
 import { compareCodeUnits } from './canonical.js';
 import path from 'node:path';
 import { sortDiagnostics } from './diagnostics.js';
+import { indexSegmentAddress } from './index-segments.js';
 import { parseClausewitz, parseLocalisation, assignments, childBlocks, firstScalar, locationFor, sourcePartialLimitDiagnostics, SOURCE_MAX_BYTES, SOURCE_MAX_NESTING, nodeLocation, } from './source/index.js';
 const spriteDefinitionKeys = new Set([
     'spritetype',
@@ -269,7 +270,8 @@ export class SymbolIndex {
     #symbolLimitReported = false;
     #referenceLimitReported = false;
     #diagnosticsTruncated = false;
-    static build(files) {
+    #indexTableBlocked = new Set();
+    static build(files, segments) {
         const index = new SymbolIndex();
         const definitionSelection = selectedDefinitionFiles(files);
         for (const displayPath of definitionSelection.selected)
@@ -279,13 +281,13 @@ export class SymbolIndex {
         }
         for (const file of [...files].sort((a, b) => a.loadOrder - b.loadOrder || compareCodeUnits(a.displayPath, b.displayPath))) {
             index.files.set(file.displayPath, file);
-            index.indexFile(file);
+            index.indexFileWithSegments(file, segments);
         }
         index.finalize();
         return index;
     }
     /** Yield between source files so protocol cancellation and progress remain responsive. */
-    static async buildAsync(files, signal) {
+    static async buildAsync(files, signal, segments) {
         signal?.throwIfAborted();
         const index = new SymbolIndex();
         const definitionSelection = selectedDefinitionFiles(files);
@@ -298,7 +300,7 @@ export class SymbolIndex {
         for (const file of [...files].sort((a, b) => a.loadOrder - b.loadOrder || compareCodeUnits(a.displayPath, b.displayPath))) {
             signal?.throwIfAborted();
             index.files.set(file.displayPath, file);
-            index.indexFile(file);
+            index.indexFileWithSegments(file, segments);
             if (performance.now() - yieldedAt >= 20) {
                 await new Promise((resolve) => setImmediate(resolve));
                 signal?.throwIfAborted();
@@ -435,6 +437,45 @@ export class SymbolIndex {
         for (const diagnostic of diagnostics)
             this.addDiagnostic(diagnostic);
     }
+    indexFileWithSegments(file, cache) {
+        if (cache === undefined) {
+            this.indexFile(file);
+            return;
+        }
+        const address = indexSegmentAddress(file, this.#definitionFiles.has(file.displayPath));
+        const cached = cache.get(address);
+        if (cached?.complete === true &&
+            this.symbols.length + cached.symbols.length <= INDEX_RECORD_LIMIT &&
+            this.references.length + cached.references.length <= INDEX_RECORD_LIMIT &&
+            this.diagnostics.length + cached.diagnostics.length <= INDEX_DIAGNOSTIC_LIMIT) {
+            this.#currentFileShadowed = file.shadowedBy !== undefined;
+            for (const symbol of cached.symbols)
+                this.addSymbol(symbol);
+            for (const reference of cached.references)
+                this.addReference(reference);
+            this.addDiagnostics(cached.diagnostics);
+            return;
+        }
+        const symbols = this.symbols.length;
+        const references = this.references.length;
+        const diagnostics = this.diagnostics.length;
+        this.indexFile(file);
+        // Incomplete files and aggregate ceilings retain the full builder's exact diagnostic
+        // ordering and coverage bookkeeping. They are never cached as complete segments.
+        if (this.#indexTableBlocked.has(file.displayPath) ||
+            this.#skippedSourcePaths.has(file.displayPath) ||
+            this.#indexNestingBlocked.has(file.displayPath) ||
+            this.#symbolLimitReported ||
+            this.#referenceLimitReported ||
+            this.#diagnosticsTruncated)
+            return;
+        cache.put(address, {
+            symbols: this.symbols.slice(symbols),
+            references: this.references.slice(references),
+            diagnostics: this.diagnostics.slice(diagnostics),
+            complete: true,
+        });
+    }
     indexFile(file) {
         this.#currentFileShadowed = file.shadowedBy !== undefined;
         const diagnosticStart = this.diagnostics.length;
@@ -1163,6 +1204,7 @@ export class SymbolIndex {
         let line = 1;
         while (start <= text.length) {
             if (line > INDEX_TABLE_RECORD_LIMIT) {
+                this.#indexTableBlocked.add(file.displayPath);
                 this.#complete = false;
                 this.addDiagnostic({
                     code: 'INDEX_TABLE_RECORD_LIMIT',
@@ -1189,6 +1231,7 @@ export class SymbolIndex {
         let match;
         while ((match = matcher.exec(value)) !== null) {
             if (fields.length >= INDEX_TABLE_FIELD_LIMIT) {
+                this.#indexTableBlocked.add(file.displayPath);
                 this.#complete = false;
                 this.addDiagnostic({
                     code: 'INDEX_TABLE_FIELD_LIMIT',

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

@@ -0,0 +1,109 @@
+import { z } from 'zod/v4';
+import { JobService } from './job-service.js';
+import { emptyServiceResult, ServiceError } from './result.js';
+import { errorResult, strictOperationResultSchema, toolResult } from './operation-result.js';
+import { requireOperationScope, resolveOperationWorkspaceId, } from './operation-context.js';
+import { workspaceIdSchema } from '../schemas/common.js';
+const jobIdSchema = z.string().regex(/^job_[a-f0-9]{64}$/u);
+export const jobReferenceSchema = z
+    .object({ workspaceId: workspaceIdSchema, jobId: jobIdSchema })
+    .strict();
+const jobStatusDataSchema = z
+    .object({
+    jobId: jobIdSchema,
+    toolName: z.string().max(256),
+    status: z.enum(['queued', 'running', 'reconciling', 'completed', 'cancelled', 'failed']),
+    revision: z.number().int().min(0),
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+    cancelRequested: z.boolean(),
+    resultReady: z.boolean(),
+    progress: z
+        .object({
+        completed: z.number().nonnegative(),
+        total: z.number().nonnegative().optional(),
+        message: z.string().max(4096),
+    })
+        .strict()
+        .optional(),
+    failure: z
+        .object({ code: z.string().max(256), message: z.string().max(4096) })
+        .strict()
+        .optional(),
+})
+    .strict();
+export const jobStatusOutputSchema = strictOperationResultSchema(jobStatusDataSchema);
+export function isJobControlTool(name) {
+    return name === 'hoi4.job_inspect' || name === 'hoi4.job_cancel';
+}
+function statusResult(record) {
+    const result = emptyServiceResult(record.scope.workspaceId, {
+        jobId: record.id,
+        toolName: record.request.toolName,
+        status: record.status,
+        revision: record.revision,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        cancelRequested: record.cancelRequested,
+        resultReady: record.result !== undefined,
+        ...(record.progress === undefined ? {} : { progress: record.progress }),
+        ...(record.failure === undefined ? {} : { failure: record.failure }),
+    });
+    result.code = record.status === 'failed' ? 'JOB_FAILED' : 'JOB_STATUS';
+    if (record.status === 'failed') {
+        result.status = 'error';
+        result.validation.passed = false;
+        result.blockers = [record.failure];
+    }
+    else if (record.status === 'cancelled') {
+        result.status = 'blocked';
+        result.code = 'JOB_CANCELLED';
+        result.validation.passed = false;
+    }
+    return result;
+}
+/** Bounded control traffic never acquires execution capacity or starts a worker. */
+export class JobControlService {
+    engine;
+    jobsPromise;
+    constructor(engine, jobsPromise) {
+        this.engine = engine;
+        this.jobsPromise = jobsPromise;
+    }
+    async call(name, input, context, signal) {
+        const parsed = jobReferenceSchema.parse(input);
+        let workspaceId = parsed.workspaceId;
+        try {
+            signal?.throwIfAborted();
+            workspaceId = await resolveOperationWorkspaceId(this.engine, context, parsed.workspaceId, signal);
+            this.jobsPromise ??= JobService.create(this.engine.resolver);
+            const jobs = await this.jobsPromise;
+            const record = await jobs.get(workspaceId, parsed.jobId, context.principal, signal);
+            if (name === 'hoi4.job_cancel') {
+                if (record.request.mutation)
+                    requireOperationScope(context, 'hoi4:write');
+                return toolResult(statusResult(await jobs.cancel(workspaceId, record.id, context.principal, signal)));
+            }
+            if (record.status !== 'completed')
+                return toolResult(statusResult(record));
+            if (record.result === undefined)
+                throw new ServiceError('JOB_RESULT_MISSING', 'Completed job has no authenticated result');
+            return {
+                ...record.result,
+                _meta: {
+                    ...z.record(z.string(), z.json()).parse(record.result._meta ?? {}),
+                    'io.github.klimPaskov/hoi4-agent-tools/job': {
+                        jobId: record.id,
+                        status: record.status,
+                        revision: record.revision,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            return errorResult(error, workspaceId);
+        }
+    }
+}