hoi4-agent-tools 3.0.9 → 3.2.0

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

@@ -1,18 +1,8 @@
+import { registerLegacyTaskTools } from '../server/legacy-task-tools.js';
 import { z } from 'zod/v4';
-import { boundedSourceHashEvidence, publicArtifactLink, } from '../../core/artifacts.js';
-import { canonicalJson, hashCanonical } from '../../core/canonical.js';
-import { IdleCacheLifetime } from '../../core/idle-cache-lifetime.js';
-import { emptyServiceResult } from '../../core/result.js';
-import { AgentNudger, allocateMapIdentifiersAsync, buildMapCatalog, exportProvinceGeometryRowRuns, lookupMapCoordinate, MAP_PROVINCE_GEOMETRY_SELECTOR_LIMIT, renderMap, searchMapCatalog, } from '../../map/index.js';
-import { workspaceIdSchema } from '../../schemas/common.js';
-import { mapAllocationRequestSchema, mapOperationSchema } from '../../schemas/map.js';
-import { PACKAGE_VERSION } from '../../version.js';
-import { requireServerScope, resolveServerWorkspaceId, } from '../server/base-tools.js';
-import { compactValidatedInputSchema } from '../server/context-schemas.js';
-import { autonomousFailureContext, autonomousResultArtifacts, executePlannedTransaction, } from '../server/transaction-execution.js';
+import { mapInspectRequestSchema, mapRenderRequestSchema, mapRewriteRequestSchema, } from '../../schemas/map-requests.js';
 import { allocationEvidenceSchema, bitmapRenderHashesSchema, nonNegativeIntegerSchema, operationBlockerDataSchema, sha256Schema, } from '../server/output-schemas.js';
-import { progressReporter } from '../server/progress.js';
-import { errorResult, setInlineFilesScanned, strictOperationResultSchema, toolResult, } from '../server/result.js';
+import { strictOperationResultSchema } from '../server/result.js';
 const changedBoundsSchema = z
     .object({
     minX: nonNegativeIntegerSchema,
@@ -85,12 +75,8 @@ const mapWorkspaceInspectOutputSchema = strictOperationResultSchema(z
     provinceGeometryCount: nonNegativeIntegerSchema,
     provinceGeometryPixelCount: nonNegativeIntegerSchema,
     provinceGeometryRowRunCount: nonNegativeIntegerSchema,
-    unknownProvinceIds: z
-        .array(nonNegativeIntegerSchema)
-        .max(MAP_PROVINCE_GEOMETRY_SELECTOR_LIMIT),
-    missingGeometryProvinceIds: z
-        .array(nonNegativeIntegerSchema)
-        .max(MAP_PROVINCE_GEOMETRY_SELECTOR_LIMIT),
+    unknownProvinceIds: z.array(nonNegativeIntegerSchema).max(512),
+    missingGeometryProvinceIds: z.array(nonNegativeIntegerSchema).max(512),
 })
     .strict());
 const mapRenderOutputSchema = strictOperationResultSchema(z
@@ -123,519 +109,28 @@ const artifactProducing = {
     idempotentHint: true,
     openWorldHint: false,
 };
-const mapInlineDiffLimit = 20;
-const mapInlineMembershipIdLimit = 32;
-const mapInlineTextLimit = 512;
-function compactAllocationEvidence(evidence) {
-    return {
-        ...evidence,
-        rootCount: evidence.roots.length,
-        roots: evidence.roots.slice(0, 16),
-        rootsTruncated: evidence.roots.length > 16,
-    };
-}
-function compactNullableText(value) {
-    return value === null ? null : value.slice(0, mapInlineTextLimit);
-}
-function compactRecordDiffs(entries) {
-    return entries.slice(0, mapInlineDiffLimit).map(({ key, before, after }) => ({
-        key: key.slice(0, 256),
-        before: compactNullableText(before),
-        after: compactNullableText(after),
-    }));
-}
-function compactMapSemanticDiff(semantic) {
-    const counts = {
-        definitions: semantic.definitions.length,
-        stateMembership: semantic.stateMembership.length,
-        regionMembership: semantic.regionMembership.length,
-        states: semantic.states.length,
-        ports: semantic.ports.length,
-        buildingPositions: semantic.buildingPositions.length,
-        unitPositions: semantic.unitPositions.length,
-        weatherPositions: semantic.weatherPositions.length,
-        entityLocators: semantic.entityLocators.length,
-        supplyNodes: semantic.supplyNodes.length,
-        railways: semantic.railways.length,
-        adjacencies: semantic.adjacencies.length,
-        normalAdjacencies: semantic.normalAdjacencies.length,
-    };
-    return {
-        semantic: {
-            definitions: semantic.definitions
-                .slice(0, mapInlineDiffLimit)
-                .map(({ id, before, after }) => ({
-                id,
-                before: compactNullableText(before),
-                after: compactNullableText(after),
-            })),
-            stateMembership: semantic.stateMembership.slice(0, mapInlineDiffLimit).map((entry) => ({
-                ...entry,
-                before: entry.before.slice(0, mapInlineMembershipIdLimit),
-                after: entry.after.slice(0, mapInlineMembershipIdLimit),
-            })),
-            regionMembership: semantic.regionMembership.slice(0, mapInlineDiffLimit).map((entry) => ({
-                ...entry,
-                before: entry.before.slice(0, mapInlineMembershipIdLimit),
-                after: entry.after.slice(0, mapInlineMembershipIdLimit),
-            })),
-            states: compactRecordDiffs(semantic.states),
-            ports: compactRecordDiffs(semantic.ports),
-            buildingPositions: compactRecordDiffs(semantic.buildingPositions),
-            unitPositions: compactRecordDiffs(semantic.unitPositions),
-            weatherPositions: compactRecordDiffs(semantic.weatherPositions),
-            entityLocators: compactRecordDiffs(semantic.entityLocators),
-            supplyNodes: compactRecordDiffs(semantic.supplyNodes),
-            railways: compactRecordDiffs(semantic.railways),
-            adjacencies: compactRecordDiffs(semantic.adjacencies),
-            normalAdjacencies: compactRecordDiffs(semantic.normalAdjacencies),
-            supplyNodesChanged: semantic.supplyNodesChanged,
-            railwaysChanged: semantic.railwaysChanged,
-            adjacenciesChanged: semantic.adjacenciesChanged,
-            normalAdjacenciesChanged: semantic.normalAdjacenciesChanged,
-        },
-        counts,
-        truncated: Object.values(counts).some((count) => count > mapInlineDiffLimit) ||
-            [...semantic.stateMembership, ...semantic.regionMembership].some(({ before, after }) => before.length > mapInlineMembershipIdLimit || after.length > mapInlineMembershipIdLimit) ||
-            semantic.definitions.some(({ before, after }) => (before?.length ?? 0) > mapInlineTextLimit || (after?.length ?? 0) > mapInlineTextLimit) ||
-            [
-                ...semantic.states,
-                ...semantic.ports,
-                ...semantic.buildingPositions,
-                ...semantic.unitPositions,
-                ...semantic.weatherPositions,
-                ...semantic.entityLocators,
-                ...semantic.supplyNodes,
-                ...semantic.railways,
-                ...semantic.adjacencies,
-                ...semantic.normalAdjacencies,
-            ].some(({ key, before, after }) => key.length > 256 ||
-                (before?.length ?? 0) > mapInlineTextLimit ||
-                (after?.length ?? 0) > mapInlineTextLimit),
-    };
-}
-const mapLayerSchema = z.enum([
-    'province',
-    'state',
-    'strategic-region',
-    'terrain',
-    'continent',
-    'owner',
-    'controller',
-    'cores',
-    'claims',
-    'coast',
-]);
-const mapOverlaySchema = z.enum([
-    'coastlines',
-    'ports',
-    'victory-points',
-    'resources',
-    'state-buildings',
-    'province-buildings',
-    'supply-nodes',
-    'railways',
-    'adjacencies',
-    'building-positions',
-    'unit-positions',
-    'weather-positions',
-]);
-const compactMapOperationSchema = compactValidatedInputSchema(mapOperationSchema, `Complete map operation: https://github.com/klimPaskov/hoi4-agent-tools/blob/v${PACKAGE_VERSION}/docs/map.md`);
-function validationSummary(validation) {
-    return { passed: validation.passed, checks: validation.checks };
-}
-function mapArtifactSourceEvidence(files) {
-    const complete = Object.fromEntries(files.map(({ displayPath, sha256 }) => [displayPath, sha256]));
-    return { complete, bounded: boundedSourceHashEvidence(complete) };
-}
-function selectedMapEntities(snapshot, provinceIds, stateIds, regionIds) {
-    const provinces = [...new Set(provinceIds)]
-        .sort((a, b) => a - b)
-        .map((id) => {
-        const definition = snapshot.index.definitionsById.get(id);
-        const geometry = snapshot.index.raster?.geometry.get(id);
-        return {
-            id,
-            definition: definition === undefined
-                ? null
-                : {
-                    color: definition.color,
-                    type: definition.type,
-                    coastal: definition.coastal,
-                    terrain: definition.terrain,
-                    continent: definition.continent,
-                },
-            geometry: geometry ?? null,
-            stateIds: snapshot.index.stateForProvince(id).map(({ id: state }) => state),
-            regionIds: snapshot.index.regionForProvince(id).map(({ id: region }) => region),
-            victoryPoints: snapshot.index.victoryPointsByProvince
-                .get(id)
-                ?.map(({ stateId: state, value }) => ({ stateId: state, value })) ?? [],
-            provinceBuildings: snapshot.index.provinceBuildingsByProvince
-                .get(id)
-                ?.map(({ stateId: state, buildings }) => ({
-                stateId: state,
-                buildings: Object.fromEntries(buildings),
-            })) ?? [],
-            port: (() => {
-                const port = snapshot.index.ports.find(({ provinceId }) => provinceId === id);
-                return port === undefined
-                    ? null
-                    : {
-                        stateId: port.stateId,
-                        provinceId: port.provinceId,
-                        level: port.level,
-                        coastal: port.coastal,
-                        adjacentSeaProvinceIds: port.adjacentSeaProvinceIds,
-                        positions: port.positions.map(({ stateId, building, x, y, z, rotation, adjacentSeaProvince }) => ({
-                            stateId,
-                            building,
-                            x,
-                            y,
-                            z,
-                            rotation,
-                            adjacentSeaProvince,
-                        })),
-                    };
-            })(),
-        };
-    });
-    const states = [...new Set(stateIds)]
-        .sort((a, b) => a - b)
-        .map((id) => {
-        const state = snapshot.index.statesById.get(id);
-        return state === undefined
-            ? { id, value: null }
-            : {
-                id,
-                value: {
-                    name: state.name,
-                    capital: state.capital ?? null,
-                    manpower: state.manpower,
-                    category: state.category,
-                    provinces: state.provinces,
-                    resources: Object.fromEntries(state.resources),
-                    owner: state.owner ?? null,
-                    controller: state.controller ?? null,
-                    cores: state.cores,
-                    claims: state.claims,
-                    victoryPoints: state.victoryPoints.map(({ provinceId, value }) => ({
-                        provinceId,
-                        value,
-                    })),
-                    stateBuildings: Object.fromEntries(state.stateBuildings),
-                    provinceBuildings: Object.fromEntries([...state.provinceBuildings].map(([provinceId, buildings]) => [
-                        String(provinceId),
-                        Object.fromEntries(buildings),
-                    ])),
-                },
-            };
-    });
-    const regions = [...new Set(regionIds)]
-        .sort((a, b) => a - b)
-        .map((id) => {
-        const region = snapshot.index.regionsById.get(id);
-        return region === undefined
-            ? { id, value: null }
-            : {
-                id,
-                value: {
-                    name: region.name,
-                    provinces: region.provinces,
-                    navalTerrain: region.navalTerrain ?? null,
-                },
-            };
-    });
-    return { provinces, states, regions };
-}
-export function registerMapTools(server, engine, context) {
-    const nudger = new AgentNudger(engine);
-    const cacheLifetime = new IdleCacheLifetime(() => engine.releaseScanCaches());
-    server.registerTool('hoi4.map_inspect', {
+export const mapTaskTools = [
+    {
+        name: 'hoi4.map_inspect',
         title: 'Inspect HOI4 map',
         description: 'Render, validate, search, and click the complete map.',
-        inputSchema: 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(),
+        inputSchema: mapInspectRequestSchema,
         outputSchema: mapWorkspaceInspectOutputSchema,
         annotations: artifactProducing,
-    }, async ({ workspaceId: requestedWorkspaceId, provinceIds, stateIds, regionIds, query, queryLimit, coordinates, includeOverview, allocationRequests, }, extra) => {
-        const workspaceId = await resolveServerWorkspaceId(engine, context, requestedWorkspaceId, extra.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            const progress = progressReporter(extra);
-            await progress.report(0, 3, 'Inspecting and validating the map');
-            const { snapshot, validation } = await nudger.validate(workspaceId, context.principal, progress.signal);
-            const sharedRevision = snapshot.revision;
-            const catalog = buildMapCatalog(snapshot.index);
-            const queryMatches = query === undefined ? [] : searchMapCatalog(catalog, query, queryLimit);
-            const coordinateMatches = coordinates.map((coordinate) => lookupMapCoordinate(snapshot.index, coordinate));
-            const overviewRendered = includeOverview && snapshot.index.raster !== undefined;
-            const selected = selectedMapEntities(snapshot, provinceIds, stateIds, regionIds);
-            const provinceGeometry = provinceIds.length === 0
-                ? undefined
-                : await exportProvinceGeometryRowRuns(snapshot.index, provinceIds, progress.signal);
-            const allocationPreviews = [];
-            for (const request of allocationRequests) {
-                allocationPreviews.push({
-                    request,
-                    allocation: await allocateMapIdentifiersAsync(snapshot.index, request, progress.signal),
-                });
-            }
-            const workspace = engine.resolver.get(workspaceId, context.principal);
-            const sourceEvidence = mapArtifactSourceEvidence(snapshot.files);
-            const inspectionProvenance = {
-                kind: 'map-inspect',
-                toolVersion: PACKAGE_VERSION,
-                schemaVersion: 'map-inspect.v2',
-                sourceHashes: sourceEvidence.bounded.sourceHashes,
-                metadata: {
-                    sharedRevision,
-                    sourceHashInventory: sourceEvidence.bounded.inventory,
-                },
-            };
-            const artifactWrites = [
-                {
-                    name: `map-inspect.${snapshot.revision.slice(0, 16)}.json`,
-                    mimeType: 'application/json',
-                    content: `${canonicalJson({
-                        schemaVersion: 2,
-                        revision: snapshot.revision,
-                        sharedRevision,
-                        dimensions: snapshot.index.raster === undefined
-                            ? null
-                            : {
-                                width: snapshot.index.raster.width,
-                                height: snapshot.index.raster.height,
-                                bitsPerPixel: snapshot.index.provinceBitmap?.bitsPerPixel,
-                                dibSize: snapshot.index.provinceBitmap?.dibSize,
-                            },
-                        counts: {
-                            definitions: snapshot.index.definitions.length,
-                            states: snapshot.index.states.length,
-                            regions: snapshot.index.regions.length,
-                            adjacencies: snapshot.index.adjacencies.length,
-                            supplyNodes: snapshot.index.supplyNodes.length,
-                            railways: snapshot.index.railways.length,
-                            ports: snapshot.index.ports.length,
-                            locators: snapshot.index.entityLocators.length,
-                        },
-                        catalog,
-                        query: query ?? null,
-                        queryMatches,
-                        coordinateMatches,
-                        selected,
-                        allocationPreviews,
-                        validation,
-                        sourceHashes: sourceEvidence.complete,
-                    })}\n`,
-                    provenance: inspectionProvenance,
-                    description: 'Complete searchable map catalog, inspection, validation, selected records, and allocation previews',
-                },
-            ];
-            if (overviewRendered) {
-                const overviewLayer = 'state';
-                const overviewOverlays = [
-                    'coastlines',
-                    'ports',
-                    'victory-points',
-                    'supply-nodes',
-                    'railways',
-                ];
-                const overview = await renderMap(snapshot.index, {
-                    layer: overviewLayer,
-                    overlays: overviewOverlays,
-                    signal: progress.signal,
-                });
-                const overviewProvenance = {
-                    kind: 'map-inspect-overview',
-                    toolVersion: PACKAGE_VERSION,
-                    schemaVersion: 'map-inspect-overview.v1',
-                    sourceHashes: sourceEvidence.bounded.sourceHashes,
-                    renderProfile: {
-                        layer: overviewLayer,
-                        overlays: [...new Set(overviewOverlays)].sort(),
-                        scale: 1,
-                    },
-                    metadata: { sourceHashInventory: sourceEvidence.bounded.inventory },
-                };
-                artifactWrites.push({
-                    name: `map-overview.${snapshot.revision.slice(0, 16)}.png`,
-                    mimeType: 'image/png',
-                    content: overview.png,
-                    provenance: overviewProvenance,
-                    description: 'Complete rendered map overview',
-                }, {
-                    name: `map-overview.${snapshot.revision.slice(0, 16)}.html`,
-                    mimeType: 'text/html',
-                    content: overview.html,
-                    provenance: overviewProvenance,
-                    description: 'Searchable and clickable full-map navigator with exact IDs, names, coordinates, and linked records',
-                });
-            }
-            if (provinceGeometry !== undefined) {
-                const { width, height, requestedProvinceIds, unknownProvinceIds, missingGeometryProvinceIds, pixelCount, rowRunCount, provinces, } = provinceGeometry;
-                const selectorHash = hashCanonical(requestedProvinceIds).slice(0, 16);
-                artifactWrites.push({
-                    name: `map-province-geometry.${snapshot.revision.slice(0, 16)}.${selectorHash}.json`,
-                    mimeType: 'application/json',
-                    content: `${canonicalJson({
-                        schemaVersion: 1,
-                        revision: snapshot.revision,
-                        dimensions: { width, height },
-                        coordinateSystem: {
-                            origin: 'top-left',
-                            xDirection: 'right',
-                            yDirection: 'down',
-                        },
-                        rowRunFormat: ['y', 'startX', 'endXExclusive'],
-                        requestedProvinceIds,
-                        unknownProvinceIds,
-                        missingGeometryProvinceIds,
-                        pixelCount,
-                        rowRunCount,
-                        provinces,
-                        sourceHashes: sourceEvidence.complete,
-                    })}\n`,
-                    provenance: {
-                        kind: 'map-province-geometry',
-                        toolVersion: PACKAGE_VERSION,
-                        schemaVersion: 'map-province-geometry.v1',
-                        sourceHashes: sourceEvidence.bounded.sourceHashes,
-                        metadata: {
-                            requestedProvinceIds,
-                            sourceHashInventory: sourceEvidence.bounded.inventory,
-                        },
-                    },
-                    description: 'Exact canonical province row runs for deriving bounded split or create geometry',
-                });
-            }
-            const artifacts = await engine.artifacts.withAtomicChunkedWrites(workspace, artifactWrites, (stored) => Promise.resolve([...stored]), progress.signal);
-            const result = emptyServiceResult(workspaceId, {
-                revision: snapshot.revision,
-                sharedRevision,
-                width: snapshot.index.raster?.width ?? null,
-                height: snapshot.index.raster?.height ?? null,
-                definitions: snapshot.index.definitions.length,
-                states: snapshot.index.states.length,
-                regions: snapshot.index.regions.length,
-                ports: snapshot.index.ports.length,
-                inspectedProvinceCount: selected.provinces.length,
-                inspectedStateCount: selected.states.length,
-                inspectedRegionCount: selected.regions.length,
-                allocationCount: allocationPreviews.length,
-                queryMatchCount: queryMatches.length,
-                coordinateMatchCount: coordinateMatches.length,
-                overviewRendered,
-                provinceGeometryCount: provinceGeometry?.provinces.length ?? 0,
-                provinceGeometryPixelCount: provinceGeometry?.pixelCount ?? 0,
-                provinceGeometryRowRunCount: provinceGeometry?.rowRunCount ?? 0,
-                unknownProvinceIds: provinceGeometry?.unknownProvinceIds ?? [],
-                missingGeometryProvinceIds: provinceGeometry?.missingGeometryProvinceIds ?? [],
-            });
-            result.code = 'MAP_INSPECTED';
-            setInlineFilesScanned(result, snapshot.files.map(({ displayPath }) => displayPath));
-            result.diagnostics = validation.diagnostics.slice(0, 100);
-            result.artifacts = artifacts.map(publicArtifactLink);
-            result.validation = validationSummary(validation);
-            await progress.report(3, 3, 'Map inspection complete');
-            return toolResult(result);
-        }
-        catch (error) {
-            return errorResult(error, workspaceId);
-        }
-        finally {
-            releaseCaches();
-        }
-    });
-    server.registerTool('hoi4.map_render', {
+    },
+    {
+        name: 'hoi4.map_render',
         title: 'Render map inspection artifacts',
         description: 'Render searchable full-map PNG, JSON, and HTML.',
-        inputSchema: z
-            .object({
-            workspaceId: workspaceIdSchema,
-            layer: mapLayerSchema.optional(),
-            overlays: z.array(mapOverlaySchema).max(12).optional(),
-            scale: z.number().int().min(1).max(16).optional(),
-        })
-            .strict(),
+        inputSchema: mapRenderRequestSchema,
         outputSchema: mapRenderOutputSchema,
         annotations: artifactProducing,
-    }, async ({ workspaceId: requestedWorkspaceId, layer, overlays, scale }, extra) => {
-        const workspaceId = await resolveServerWorkspaceId(engine, context, requestedWorkspaceId, extra.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            const progress = progressReporter(extra);
-            await progress.report(0, 3, 'Rendering offline map layer');
-            const rendered = await nudger.renderAndStore(workspaceId, {
-                ...(layer === undefined ? {} : { layer }),
-                ...(overlays === undefined ? {} : { overlays }),
-                ...(scale === undefined ? {} : { scale }),
-                ...(context.principal === undefined ? {} : { principal: context.principal }),
-                signal: progress.signal,
-            });
-            const result = emptyServiceResult(workspaceId, {
-                revision: rendered.revision,
-                width: rendered.bundle.width,
-                height: rendered.bundle.height,
-                hashes: rendered.bundle.hashes,
-                offlineRepresentation: true,
-            });
-            result.code = 'MAP_RENDERED';
-            setInlineFilesScanned(result, rendered.filesScanned);
-            result.artifacts = rendered.artifacts.map(publicArtifactLink);
-            await progress.report(3, 3, 'Map render complete');
-            return toolResult(result);
-        }
-        catch (error) {
-            return errorResult(error, workspaceId);
-        }
-        finally {
-            releaseCaches();
-        }
-    });
-    server.registerTool('hoi4.map_rewrite', {
+    },
+    {
+        name: 'hoi4.map_rewrite',
         title: 'Create or clean up map content',
         description: 'Apply map creation, edits, and ID swaps with visual and semantic evidence.',
-        inputSchema: z
-            .object({
-            workspaceId: workspaceIdSchema,
-            operations: z.array(compactMapOperationSchema).min(1).max(100),
-            diffScale: z.number().int().min(1).max(16).optional(),
-        })
-            .strict(),
+        inputSchema: mapRewriteRequestSchema,
         outputSchema: mapPlanOutputSchema,
         annotations: {
             readOnlyHint: false,
@@ -643,82 +138,8 @@ export function registerMapTools(server, engine, context) {
             idempotentHint: false,
             openWorldHint: false,
         },
-    }, async ({ workspaceId: requestedWorkspaceId, operations, diffScale }, extra) => {
-        const workspaceId = await resolveServerWorkspaceId(engine, context, requestedWorkspaceId, extra.signal);
-        const releaseCaches = cacheLifetime.begin();
-        try {
-            requireServerScope(context, 'hoi4:write');
-            const progress = progressReporter(extra);
-            await progress.report(0, 5, 'Planning map operations and visual diff');
-            const typedOperations = operations;
-            const planned = await nudger.planRewriteWithDiff({
-                workspaceId,
-                operations: typedOperations,
-                ...(diffScale === undefined ? {} : { diffScale }),
-                ...(context.principal === undefined ? {} : { principal: context.principal }),
-                signal: progress.signal,
-            });
-            const diff = planned;
-            await progress.report(3, 5, 'Preparing the map rewrite');
-            await progress.report(4, 5, 'Applying and validating the map rewrite');
-            const execution = await executePlannedTransaction(engine, planned.transaction, context.principal, progress.signal);
-            const transaction = execution.transaction;
-            const compactSemantic = compactMapSemanticDiff(diff.bundle.semantic);
-            const result = emptyServiceResult(workspaceId, {
-                execution: execution.outcome,
-                allocations: planned.plan.allocations.slice(0, 100).map(compactAllocationEvidence),
-                operationBlockers: planned.plan.blockers
-                    .slice(0, 100)
-                    .map(({ code, message, operationId }) => ({ code, message, operationId })),
-                expectedChangedBounds: planned.plan.expectedChangedBounds ?? null,
-                changedProvinceIds: diff.bundle.changedProvinceIds.slice(0, 256),
-                changedProvinceCount: diff.bundle.changedProvinceIds.length,
-                semanticDiff: compactSemantic.semantic,
-                semanticDiffCounts: compactSemantic.counts,
-                semanticDiffTruncated: compactSemantic.truncated,
-                fileCount: transaction.files.length,
-                artifactCount: transaction.artifacts.length,
-            });
-            result.status = transaction.validation.passed ? 'ok' : 'blocked';
-            result.code =
-                execution.outcome === 'applied'
-                    ? 'MAP_CHANGES_APPLIED'
-                    : execution.outcome === 'unchanged'
-                        ? 'MAP_CHANGES_UNCHANGED'
-                        : 'MAP_CHANGES_BLOCKED';
-            setInlineFilesScanned(result, diff.filesScanned);
-            result.proposedFiles = transaction.files
-                .slice(0, 100)
-                .map(({ relativePath }) => relativePath);
-            result.changedFiles = transaction.appliedFiles.slice(0, 100);
-            result.diagnostics = transaction.diagnostics.slice(0, 100);
-            result.artifacts = autonomousResultArtifacts(execution);
-            result.validation = transaction.validation;
-            result.blockers = [
-                ...planned.plan.blockers.map(({ code, message }) => ({
-                    code,
-                    message,
-                })),
-                ...transaction.diagnostics
-                    .filter(({ severity }) => severity === 'error' || severity === 'blocker')
-                    .map(({ code, message, details }) => ({
-                    code,
-                    message,
-                    ...(details === undefined ? {} : { details }),
-                })),
-            ].slice(0, 100);
-            await progress.report(5, 5, execution.outcome === 'applied'
-                ? 'Map rewrite complete'
-                : execution.outcome === 'unchanged'
-                    ? 'Map content already satisfied the operations'
-                    : 'Map rewrite blocked');
-            return toolResult(result);
-        }
-        catch (error) {
-            return errorResult(error, workspaceId, autonomousFailureContext(error));
-        }
-        finally {
-            releaseCaches();
-        }
-    });
+    },
+];
+export function registerMapTools(server, _engine, _context) {
+    registerLegacyTaskTools(server, mapTaskTools);
 }