hoi4-agent-tools 3.0.9 → 3.2.0

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

@@ -0,0 +1,51 @@
+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 { eventInspectRequestSchema, eventRenderRequestSchema, eventCompareRequestSchema, } from '../schemas/event.js';
+import { inspectEvents, renderEvents, compareEvents, normalizeEventInspectionRequest, normalizeEventRenderRequest, normalizeEventCompareRequest, } from './operations.js';
+import { EventChainViewer } from './service.js';
+const wireResult = z.record(z.string(), z.json());
+/** Registers typed event operations without invoking transport handlers. */
+export function registerEventJobs(operations, engine) {
+    const viewer = new EventChainViewer(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: 'Event 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
+                    : 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.event_inspect', eventInspectRequestSchema, normalizeEventInspectionRequest, inspectEvents, 'Analyzing event chain');
+    register('hoi4.event_render', eventRenderRequestSchema, normalizeEventRenderRequest, renderEvents, 'Rendering event-chain view');
+    register('hoi4.event_compare', eventCompareRequestSchema, normalizeEventCompareRequest, compareEvents, 'Comparing event-chain graphs');
+}

package/dist/hoi4_agent_tools/event/operations.js

@@ -0,0 +1,179 @@
+import { compareCodeUnits } from '../core/canonical.js';
+import { helperExpansionValidation } from '../core/helper-expansion.js';
+import { publicArtifactLink } from '../core/artifacts.js';
+import { setInlineFilesScanned } from '../core/operation-result.js';
+import { emptyServiceResult } from '../core/result.js';
+import { eventInspectRequestSchema, eventRenderRequestSchema, eventCompareRequestSchema, } from '../schemas/event.js';
+import { eventDiagnostics, } from './service.js';
+export function normalizeEventInspectionRequest(input) {
+    // Validated request fields are JSON-only. Match wire semantics by removing optional
+    // undefined fields, including nested source-selector columns, before service dispatch.
+    return JSON.parse(JSON.stringify(eventInspectRequestSchema.parse(input)));
+}
+export function normalizeEventRenderRequest(input) {
+    return JSON.parse(JSON.stringify(eventRenderRequestSchema.parse(input)));
+}
+export function normalizeEventCompareRequest(input) {
+    return JSON.parse(JSON.stringify(eventCompareRequestSchema.parse(input)));
+}
+export function eventGraphCounts(graph, artifacts) {
+    const diagnostics = eventDiagnostics(graph);
+    return {
+        events: graph.statistics.eventCount,
+        options: graph.statistics.optionCount,
+        entries: graph.statistics.entryCount,
+        helpers: graph.statistics.helperCount,
+        unresolvedNodes: graph.statistics.unresolvedNodeCount,
+        terminals: graph.statistics.terminalCount,
+        edges: graph.statistics.edgeCount,
+        derivedEdges: graph.statistics.derivedEdgeCount,
+        stateAccesses: graph.statistics.stateAccessCount,
+        issues: graph.statistics.issueCount,
+        diagnostics: diagnostics.length,
+        blockingDiagnostics: diagnostics.filter(({ severity }) => severity === 'error' || severity === 'blocker').length,
+        skippedSources: graph.skippedSourceCount,
+        artifacts,
+    };
+}
+export function eventGraphValidation(graph) {
+    const counts = eventGraphCounts(graph, 0);
+    return {
+        passed: graph.complete && counts.blockingDiagnostics === 0,
+        checks: [
+            {
+                id: 'event-analysis',
+                passed: graph.complete && counts.blockingDiagnostics === 0,
+                message: graph.analysisMode === 'focused'
+                    ? 'Large workspace analysis deferred workspace-wide helper projections and lifecycle passes; direct evidence is linked'
+                    : graph.complete
+                        ? `${counts.blockingDiagnostics} blocking event-chain diagnostics; full evidence is linked`
+                        : graph.issues.some(({ code }) => code === 'EVENT_HELPER_DEPTH_LIMIT' ||
+                            code === 'EVENT_HELPER_PROJECTION_LIMIT' ||
+                            code === 'EVENT_HELPER_STATE_PROJECTION_LIMIT')
+                            ? 'Helper expansion reached a depth or materialization boundary; helper_expansion mode provides bounded source-linked continuation'
+                            : `${graph.skippedSourceCount} event-analysis source(s) were skipped; full evidence is linked`,
+            },
+        ],
+    };
+}
+/** Transport-independent event inspection and its complete bounded result contract. */
+export async function inspectEvents(viewer, input) {
+    const inspected = await viewer.inspect(input);
+    const result = emptyServiceResult(input.workspaceId, {
+        mode: inspected.mode,
+        analysisMode: inspected.graph.analysisMode ?? 'full',
+        revision: inspected.graph.revision,
+        graphHash: inspected.graphHash,
+        counts: eventGraphCounts(inspected.graph, inspected.artifacts.length),
+        ...(inspected.helperExpansion === undefined
+            ? {}
+            : { helperExpansion: inspected.helperExpansion }),
+        boundary: {
+            direction: input.direction ?? 'both',
+            maxDepth: inspected.helperExpansion?.maxDepth ?? input.maxDepth ?? 8,
+            maxNodes: inspected.helperExpansion === undefined ? (input.maxNodes ?? 500) : 0,
+            maxEdges: inspected.helperExpansion === undefined ? (input.maxEdges ?? 2_000) : 0,
+            expandHelpers: inspected.helperExpansion !== undefined ||
+                (input.expandHelpers ?? input.mode === 'explain_path'),
+            refresh: input.refresh ?? input.mode === 'scan',
+        },
+    });
+    result.code =
+        (inspected.helperExpansion?.complete ?? inspected.graph.complete)
+            ? 'EVENT_INSPECTED'
+            : 'EVENT_INSPECTED_PARTIAL';
+    setInlineFilesScanned(result, inspected.graph.filesScanned);
+    result.artifacts = inspected.artifacts.map(publicArtifactLink);
+    result.validation = eventGraphValidation(inspected.graph);
+    if (inspected.helperExpansion !== undefined)
+        result.validation = helperExpansionValidation(inspected.helperExpansion);
+    return result;
+}
+export async function renderEvents(viewer, input) {
+    const rendered = await viewer.renderAndStore(input);
+    const result = emptyServiceResult(input.workspaceId, {
+        view: rendered.render.view,
+        analysisMode: rendered.graph.analysisMode ?? 'full',
+        revision: rendered.graph.revision,
+        graphHash: rendered.graphHash,
+        layoutHash: rendered.render.layout.layoutHash,
+        hashes: rendered.render.hashes,
+        counts: {
+            ...eventGraphCounts(rendered.graph, rendered.artifacts.length),
+            selectedNodes: rendered.render.selectedNodeIds.length,
+            omittedNodes: rendered.render.omittedNodeCount,
+            branchRenders: rendered.branches.length,
+        },
+        boundary: {
+            direction: input.direction ?? 'both',
+            maxDepth: input.maxDepth ?? 4,
+            maxNodes: input.maxNodes ?? 120,
+            expandHelpers: input.expandHelpers ?? false,
+            includeHtml: input.includeHtml ?? false,
+            refresh: input.refresh ?? false,
+        },
+    });
+    result.code = rendered.graph.complete ? 'EVENT_RENDERED' : 'EVENT_RENDERED_PARTIAL';
+    setInlineFilesScanned(result, rendered.graph.filesScanned);
+    result.artifacts = rendered.artifacts.map(publicArtifactLink);
+    result.validation = eventGraphValidation(rendered.graph);
+    return result;
+}
+export async function compareEvents(viewer, input) {
+    const compared = await viewer.compareAndStore(input);
+    const { comparison } = compared;
+    const result = emptyServiceResult(input.workspaceId, {
+        beforeRevision: comparison.beforeRevision,
+        afterRevision: comparison.afterRevision,
+        beforeGraphHash: comparison.beforeGraphHash,
+        afterGraphHash: comparison.afterGraphHash,
+        ...(compared.render === undefined ? {} : { renderHashes: compared.render.hashes }),
+        counts: {
+            changes: comparison.changes.length,
+            addedNodes: comparison.addedNodeIds.length,
+            removedNodes: comparison.removedNodeIds.length,
+            changedNodes: comparison.changedNodeIds.length,
+            addedEdges: comparison.addedEdgeIds.length,
+            removedEdges: comparison.removedEdgeIds.length,
+            changedEdges: comparison.changedEdgeIds.length,
+            addedStateAccesses: comparison.addedStateAccessIds.length,
+            removedStateAccesses: comparison.removedStateAccessIds.length,
+            changedStateAccesses: comparison.changedStateAccessIds.length,
+            addedStateLinks: comparison.addedStateLinkIds.length,
+            removedStateLinks: comparison.removedStateLinkIds.length,
+            changedStateLinks: comparison.changedStateLinkIds.length,
+            addedDiagnostics: comparison.addedIssueIds.length,
+            resolvedDiagnostics: comparison.resolvedIssueIds.length,
+            addedUnresolved: comparison.addedUnresolvedIds.length,
+            resolvedUnresolved: comparison.resolvedUnresolvedIds.length,
+            disconnectedRoots: comparison.newlyDisconnectedRootIds.length,
+            disconnectedBranches: comparison.newlyDisconnectedBranchIds.length,
+            disconnectedTerminals: comparison.newlyDisconnectedTerminalIds.length,
+            beforeSkippedSources: compared.before.skippedSourceCount,
+            afterSkippedSources: compared.after.skippedSourceCount,
+            artifacts: compared.artifacts.length,
+        },
+        boundary: {
+            proposedSources: input.proposedSources?.length ?? 0,
+            render: input.render ?? true,
+            maxRenderNodes: input.maxRenderNodes ?? 120,
+            refresh: compared.refresh,
+        },
+    });
+    result.code =
+        compared.before.complete && compared.after.complete
+            ? 'EVENT_COMPARED'
+            : 'EVENT_COMPARED_PARTIAL';
+    setInlineFilesScanned(result, [...new Set([...compared.before.filesScanned, ...compared.after.filesScanned])].sort(compareCodeUnits));
+    result.artifacts = compared.artifacts.map(publicArtifactLink);
+    const beforeValidation = eventGraphValidation(compared.before);
+    const afterValidation = eventGraphValidation(compared.after);
+    result.validation = {
+        passed: beforeValidation.passed && afterValidation.passed,
+        checks: [...beforeValidation.checks, ...afterValidation.checks].map((check, index) => ({
+            ...check,
+            id: `${index === 0 ? 'before' : 'after'}-${check.id}`,
+        })),
+    };
+    return result;
+}

package/dist/hoi4_agent_tools/event/service.js

@@ -1,4 +1,7 @@
 import path from 'node:path';
+import { inspectHelperExpansion } from '../core/helper-expansion.js';
+import { eventHelperInventory } from './helper-expansion.js';
+import { clearSemanticDependencies } from '../core/semantic-dependencies.js';
 import { canonicalJson, compareCodeUnits, hashCanonical, sha256Bytes } from '../core/canonical.js';
 import { boundedSourceHashEvidence, publicArtifactLink, } from '../core/artifacts.js';
 import { ServiceError } from '../core/result.js';
@@ -6,7 +9,7 @@ import { RenderBudget } from '../core/render-budget.js';
 import { SOURCE_MAX_BYTES } from '../core/source/index.js';
 import { isPortablePathSegment } from '../core/workspace.js';
 import { PACKAGE_VERSION } from '../version.js';
-import { buildEventGraph } from './graph.js';
+import { buildEventGraph, buildEventGraphAsync } from './graph.js';
 import { EVENT_FRAGMENT_CACHE_MAX_ENTRIES, EVENT_FRAGMENT_CACHE_MAX_SOURCE_BYTES, EVENT_PROPOSED_SOURCE_MAX_BYTES, EVENT_PROPOSED_SOURCE_MAX_FILES, } from './limits.js';
 import { analyzeEventImpact, discoverEventRoots, explainEventPath, inspectEventStateFlow, lintEventGraph, traceSelectedEvents, } from './queries.js';
 import { compareEventGraphs, eventGraphHash } from './compare.js';
@@ -42,6 +45,7 @@ class BoundedEventFragmentCache {
         }
     }
     clear() {
+        clearSemanticDependencies(this);
         this.#entries.clear();
         this.#sourceBytes = 0;
     }
@@ -717,14 +721,18 @@ export class EventChainViewer {
         const cacheProjectHelpers = cacheAnalysisMode === 'focused' ? false : requestedProjectHelpers;
         const cacheKey = eventGraphCacheKey(workspaceId, cacheProjectHelpers, cacheAnalysisMode);
         const cached = this.#state.current.get(cacheKey);
-        if (options.refresh !== true && cached?.generation === generation) {
-            return cached.graph;
-        }
+        // An engine generation observes server-owned edits, not changes made by
+        // another agent or process. Verify source identity before reusing a graph.
         if (options.refresh !== true && requestedAnalysisMode === 'focused') {
-            const fullSibling = this.#state.current.get(eventGraphCacheKey(workspaceId, cacheProjectHelpers, 'full')) ??
-                this.#state.current.get(eventGraphCacheKey(workspaceId, !cacheProjectHelpers, 'full'));
-            if (fullSibling?.generation === generation)
-                return fullSibling.graph;
+            for (const expanded of [cacheProjectHelpers, !cacheProjectHelpers]) {
+                const sibling = this.#state.current.get(eventGraphCacheKey(workspaceId, expanded, 'full'));
+                if (sibling?.generation === generation)
+                    return this.scan(workspaceId, {
+                        ...options,
+                        analysisMode: 'full',
+                        projectHelpers: expanded,
+                    });
+            }
         }
         const scanFocused = requestedAnalysisMode === 'focused';
         const snapshot = await scanEventSources(this.engine, workspaceId, workspace, scanFocused, options.signal);
@@ -733,7 +741,7 @@ export class EventChainViewer {
             return cached.graph;
         const buildAnalysisMode = requestedAnalysisMode;
         const projectHelpers = buildAnalysisMode === 'focused' ? false : requestedProjectHelpers;
-        const graph = buildEventGraph(snapshot, {
+        const graph = await buildEventGraphAsync(snapshot, {
             ...(options.signal === undefined ? {} : { signal: options.signal }),
             cache: this.#state.fragments,
             workspaceIdentity: workspace.workspaceIdentity,
@@ -747,6 +755,24 @@ export class EventChainViewer {
     }
     async inspect(input) {
         input.signal?.throwIfAborted();
+        if (input.mode === 'helper_expansion') {
+            const graph = await this.scan(input.workspaceId, {
+                projectHelpers: false,
+                analysisMode: 'full',
+                ...(input.principal === undefined ? {} : { principal: input.principal }),
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
+            });
+            const expansion = await inspectHelperExpansion(this.engine, input.workspaceId, eventHelperInventory(graph), input.helperExpansion, input.principal, input.signal);
+            return {
+                graph,
+                graphHash: cachedEventGraphHash(graph, input.signal),
+                mode: input.mode,
+                report: expansion.report,
+                reportJson: expansion.reportJson,
+                artifacts: expansion.artifacts,
+                helperExpansion: expansion.summary,
+            };
+        }
         const focused = input.mode === 'trace' ||
             input.mode === 'explain_path' ||
             (input.selector !== undefined &&
@@ -884,6 +910,7 @@ export class EventChainViewer {
         }
         const graphHash = cachedEventGraphHash(graph, input.signal);
         const name = `${safeSlug(`event-${input.mode}`)}-${graph.revision.slice(0, 12)}.json`;
+        const graphSnapshotName = `event-graph-${graph.revision}.json`;
         const projectedScan = input.mode === 'scan' &&
             typeof report === 'object' &&
             report !== null &&
@@ -919,7 +946,12 @@ export class EventChainViewer {
                     },
                 }
                 : {}),
-            resources: [{ name, mimeType: 'application/json' }],
+            resources: [
+                { name, mimeType: 'application/json' },
+                ...(input.mode === 'scan'
+                    ? [{ name: graphSnapshotName, mimeType: 'application/json' }]
+                    : []),
+            ],
             report,
         })}\n`;
         const workspace = this.engine.resolver.get(input.workspaceId, input.principal);
@@ -927,13 +959,16 @@ export class EventChainViewer {
             mode: input.mode,
             ...(input.selector === undefined ? {} : { selector: input.selector }),
         }, input.signal), `Authoritative Event Chain Viewer ${input.mode.replaceAll('_', ' ')} report`, input.signal);
+        const graphArtifact = input.mode === 'scan'
+            ? await this.engine.artifacts.putChunked(workspace, graphSnapshotName, 'application/json', `${canonicalJson({ schemaVersion: 'event-graph-snapshot.v1', graph })}\n`, eventProvenance(graph, 'event-graph-snapshot', { revision: graph.revision, graphHash }, input.signal), 'Revision-addressed Event Chain Viewer graph snapshot', input.signal)
+            : undefined;
         return {
             graph,
             graphHash,
             mode: input.mode,
             report,
             reportJson,
-            artifacts: [artifact],
+            artifacts: [artifact, ...(graphArtifact === undefined ? [] : [graphArtifact])],
         };
     }
     async renderAndStore(input) {
@@ -1243,10 +1278,27 @@ export class EventChainViewer {
             return selected;
         }
         if (reference?.revision !== undefined) {
-            const selected = this.#state.history.get(workspaceId)?.get(reference.revision);
-            if (selected === undefined)
-                throw new ServiceError('EVENT_REVISION_NOT_CACHED', 'Requested event graph revision is not cached');
-            return selected;
+            const cached = this.#state.history.get(workspaceId)?.get(reference.revision);
+            if (cached !== undefined)
+                return cached;
+            const workspace = this.engine.resolver.get(workspaceId, principal);
+            const names = new Set([
+                `event-graph-${reference.revision}.json`,
+                `event-scan-${reference.revision.slice(0, 12)}.json`,
+            ]);
+            const candidates = (await this.engine.artifacts.list(workspace, signal)).filter(({ name }) => names.has(name));
+            for (const artifact of candidates) {
+                const selected = parseGraphArtifact(await readLogicalArtifact(this.engine, workspaceId, artifact.uri, principal, signal), signal);
+                if (selected.revision === reference.revision &&
+                    selected.workspaceId === workspaceId &&
+                    selected.workspaceIdentity === current.workspaceIdentity) {
+                    rememberGraph(this.#state, workspaceId, selected);
+                    return selected;
+                }
+            }
+            if (candidates.length === 0)
+                throw new ServiceError('EVENT_REVISION_NOT_CACHED', 'Requested event graph revision is not cached or retained as a graph artifact');
+            throw new ServiceError('EVENT_GRAPH_WORKSPACE_MISMATCH', 'Retained event graph evidence does not match the requested revision and workspace topology');
         }
         return current;
     }

package/dist/hoi4_agent_tools/event/source-analysis.js

@@ -1,4 +1,5 @@
 import { compareCodeUnits, deterministicId } from '../core/canonical.js';
+import { semanticSourceIdentity } from '../core/semantic-dependencies.js';
 import { assignments, childBlocks, firstScalar, nodeLocation, parseClausewitz, parseLocalisation, sourcePartialLimitDiagnostics, } from '../core/source/index.js';
 import { nativeEffectKeys } from '../focus/native-effects.js';
 import { EVENT_FRAGMENT_CACHE_MAX_ENTRIES, EVENT_FRAGMENT_CACHE_MAX_SOURCE_BYTES, EVENT_GRAPH_MAX_CONDITION_TEXT, EventAnalysisBudget, } from './limits.js';
@@ -303,8 +304,7 @@ function issueFromDiagnostic(diagnostic) {
 export function eventSemanticFragmentCacheKey(file, catalogFingerprint = '') {
     return deterministicId('event_fragment', {
         parser: 'clausewitz-cst.v1',
-        sourcePath: file.displayPath,
-        sourceHash: file.sha256,
+        source: semanticSourceIdentity(file),
         catalogFingerprint,
     });
 }
@@ -634,7 +634,8 @@ class FragmentAnalyzer {
         for (const assignment of assignments(this.document.root)) {
             if (assignment.value.type !== 'block')
                 continue;
-            if (this.#knownHelpers.size > 0 && !this.#knownHelpers.has(assignment.key.value))
+            if (this.context.knownHelperIds !== undefined &&
+                !this.#knownHelpers.has(assignment.key.value))
                 continue;
             const name = assignment.key.value;
             if (this.context.activeHelperPaths !== undefined &&
@@ -1050,7 +1051,7 @@ class FragmentAnalyzer {
             this.recordDynamicEvent(id, node, context.ownerId, context.semanticPath);
             return;
         }
-        const known = this.#knownEvents.size === 0 || this.#knownEvents.has(id);
+        const known = this.context.knownEventIds === undefined || this.#knownEvents.has(id);
         const target = known
             ? this.eventNodeId(id)
             : this.unresolvedNode(this.context.inventoryComplete === false ? 'partial_source' : 'missing_event', id, node, context.ownerId, context.semanticPath);

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

@@ -0,0 +1,77 @@
+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 { focusInspectRequestSchema, focusRenderRequestSchema, focusRewriteRequestSchema, } from '../schemas/focus-requests.js';
+import { FocusWorkbench } from './index.js';
+import { inspectFocus, completeFocusRewrite, normalizeFocusInspectRequest, normalizeFocusRenderRequest, normalizeFocusRewriteRequest, prepareFocusRewrite, renderFocus, } from './tool-operations.js';
+const wireResult = z.record(z.string(), z.json());
+/** Registers read-only focus operations without invoking transport handlers. */
+export function registerFocusJobs(operations, engine) {
+    const workbench = new FocusWorkbench(engine.resolver, engine.transactions, engine.artifacts);
+    const lifetime = new IdleCacheLifetime(() => engine.releaseScanCaches());
+    function register(name, schema, normalize, execute) {
+        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');
+                const execution = await execute(normalize(input), {
+                    workspaceId: context.workspaceId,
+                    ...(context.principal === undefined ? {} : { principal: context.principal }),
+                    signal: context.signal,
+                    progress: (completed, total, message) => context.progress({ completed, total, message }),
+                });
+                const wire = wireResult.parse(JSON.parse(JSON.stringify(toolResult(execution.result))));
+                await context.stageResult(wire, { sourceRevision: execution.sourceRevision });
+                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.focus_inspect', focusInspectRequestSchema, normalizeFocusInspectRequest, (input, context) => inspectFocus(engine, workbench, input, context));
+    register('hoi4.focus_render', focusRenderRequestSchema, normalizeFocusRenderRequest, (input, context) => renderFocus(engine, workbench, input, context, false));
+    register('hoi4.focus_raster', focusRenderRequestSchema, normalizeFocusRenderRequest, (input, context) => renderFocus(engine, workbench, input, context, true));
+    operations.registerWrite('hoi4.focus_rewrite', focusRewriteRequestSchema, async (input, context) => {
+        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');
+        const release = lifetime.begin();
+        try {
+            return await prepareFocusRewrite(engine, workbench, normalizeFocusRewriteRequest(input), {
+                workspaceId: context.workspaceId,
+                ...(context.principal === undefined ? {} : { principal: context.principal }),
+                signal: context.signal,
+                progress: (completed, total, message) => context.progress({ completed, total, message }),
+            });
+        }
+        finally {
+            release();
+        }
+    }, async (input, execution, _reconciled, recipe, context) => {
+        const result = completeFocusRewrite(context.workspaceId, execution, recipe);
+        const continuous = input.mode === 'continuous';
+        await context.progress({
+            completed: 5,
+            total: 5,
+            message: execution.outcome === 'applied'
+                ? continuous
+                    ? 'Continuous focus rewrite complete'
+                    : 'Focus rewrite complete'
+                : execution.outcome === 'unchanged'
+                    ? continuous
+                        ? 'Continuous focus content already satisfied the plan'
+                        : 'Focus content already satisfied the plan'
+                    : continuous
+                        ? 'Continuous focus rewrite blocked'
+                        : 'Focus rewrite blocked',
+        });
+        return wireResult.parse(JSON.parse(JSON.stringify(toolResult(result))));
+    });
+}