hoi4-agent-tools 0.1.7 → 1.0.0

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

@@ -6,18 +6,21 @@ import { RenderBudget } from '../../core/render-budget.js';
 import { emptyServiceResult, ServiceError } from '../../core/result.js';
 import { parseClausewitz } from '../../core/source/index.js';
 import { readDependenciesFromScannedFiles } from '../../core/transactions.js';
-import { FocusWorkbench, FOCUS_RENDER_MAX_OUTPUT_SCALE, FOCUS_RENDER_MIN_OUTPUT_SCALE, assertFocusPlanAuthority, detectContinuousFocusDrift, detectFocusDrift, focusPlanHash, focusPresentationEvidence, focusPlanningSidecarPath, importContinuousFocusPalettes, importFocusTrees, linkContinuousFocusPalettes, parseFocusPlanningSidecar, renderContinuousFocusPalette, renderFocusTree, resolveFocusPresentation, enrichFocusPlanFromSidecar, } from '../../focus/index.js';
-import { continuousFocusPaletteSchema, focusLayoutDecisionSchema, focusLayoutSchema, focusTreePlanSchema, } from '../../schemas/focus.js';
+import { FocusWorkbench, FOCUS_RENDER_MAX_OUTPUT_SCALE, FOCUS_RENDER_MIN_OUTPUT_SCALE, focusPlanHash, focusPresentationEvidence, focusPlanningSidecarPath, importContinuousFocusPalettes, importFocusTrees, linkContinuousFocusPalettes, parseFocusPlanningSidecar, renderContinuousFocusPalette, renderFocusTree, resolveFocusPresentation, enrichFocusPlanFromSidecar, } from '../../focus/index.js';
+import { continuousFocusPaletteSchema, focusLayoutSchema, focusTreePlanSchema, } from '../../schemas/focus.js';
 import { workspaceIdSchema, workspaceRelativePathSchema } from '../../schemas/common.js';
 import { PACKAGE_VERSION } from '../../version.js';
 import { nonNegativeIntegerSchema, renderHashesSchema, sha256Schema, } from '../server/output-schemas.js';
 import { progressReporter } from '../server/progress.js';
 import { errorResult, setInlineFilesScanned, strictOperationResultSchema, toolResult, } from '../server/result.js';
-import { requireServerScope, transactionResourceLink, } from '../server/base-tools.js';
-const focusScanOutputSchema = strictOperationResultSchema(z
+import { requireServerScope } from '../server/base-tools.js';
+import { autonomousFailureContext, autonomousResultArtifacts, executePlannedTransaction, } from '../server/transaction-execution.js';
+const focusInspectOutputSchema = strictOperationResultSchema(z
     .object({
+    mode: z.enum(['national', 'continuous']),
     revision: sha256Schema,
     treeCount: nonNegativeIntegerSchema,
+    paletteCount: nonNegativeIntegerSchema,
     trees: z
         .array(z
         .object({
@@ -28,36 +31,22 @@ const focusScanOutputSchema = strictOperationResultSchema(z
         continuousPaletteCount: nonNegativeIntegerSchema,
         continuousFocusCount: nonNegativeIntegerSchema,
         resolvedTitleCount: nonNegativeIntegerSchema,
-    })
-        .strict())
-        .max(100),
-})
-    .strict());
-const focusLintOutputSchema = strictOperationResultSchema(z.discriminatedUnion('mode', [
-    z
-        .object({
-        mode: z.literal('national'),
-        treeId: z.string().max(256),
-        focusCount: nonNegativeIntegerSchema,
         layoutHash: sha256Schema,
+        layoutDecisionCount: nonNegativeIntegerSchema,
         diagnosticCount: nonNegativeIntegerSchema,
     })
-        .strict(),
-    z
+        .strict())
+        .max(100),
+    palettes: z
+        .array(z
         .object({
-        mode: z.literal('continuous'),
-        paletteId: z.string().max(256),
+        id: z.string().max(256),
+        sourcePath: z.string().max(4096),
         focusCount: nonNegativeIntegerSchema,
         diagnosticCount: nonNegativeIntegerSchema,
     })
-        .strict(),
-]));
-const focusLayoutOutputSchema = strictOperationResultSchema(z
-    .object({
-    treeId: z.string().max(256),
-    layoutHash: sha256Schema,
-    nodeCount: nonNegativeIntegerSchema,
-    decisions: z.array(focusLayoutDecisionSchema).max(100),
+        .strict())
+        .max(100),
 })
     .strict());
 const focusRenderOutputSchema = strictOperationResultSchema(z.discriminatedUnion('mode', [
@@ -96,12 +85,6 @@ const focusDriftBaseOutputSchema = z
     ]),
     sourceChanged: z.boolean(),
     planChanged: z.boolean(),
-    requiresAuthority: z.boolean(),
-    savedPlanHash: sha256Schema,
-    currentPlanHash: z.string().max(256),
-    importedPlanHash: sha256Schema,
-    savedSourceHash: sha256Schema,
-    currentSourceHash: sha256Schema,
 })
     .strict();
 const focusDriftOutputSchema = focusDriftBaseOutputSchema;
@@ -113,10 +96,10 @@ const focusPlanOutputSchema = strictOperationResultSchema(z.discriminatedUnion('
         treeId: z.string().max(256),
         drift: focusDriftOutputSchema,
         created: z.boolean(),
+        execution: z.enum(['applied', 'blocked', 'unchanged']),
         layoutHash: sha256Schema,
-        expiresAt: z.iso.datetime(),
-        transactionFileCount: nonNegativeIntegerSchema,
-        transactionArtifactCount: nonNegativeIntegerSchema,
+        fileCount: nonNegativeIntegerSchema,
+        artifactCount: nonNegativeIntegerSchema,
     })
         .strict(),
     z
@@ -125,26 +108,22 @@ const focusPlanOutputSchema = strictOperationResultSchema(z.discriminatedUnion('
         paletteId: z.string().max(256),
         drift: continuousFocusDriftOutputSchema,
         created: z.boolean(),
-        expiresAt: z.iso.datetime(),
-        transactionFileCount: nonNegativeIntegerSchema,
-        transactionArtifactCount: nonNegativeIntegerSchema,
+        execution: z.enum(['applied', 'blocked', 'unchanged']),
+        fileCount: nonNegativeIntegerSchema,
+        artifactCount: nonNegativeIntegerSchema,
     })
         .strict(),
 ]));
-const focusPathInput = z
-    .object({
-    workspaceId: workspaceIdSchema,
-    relativePath: workspaceRelativePathSchema,
-    treeId: z.string().min(1).max(256).optional(),
-})
-    .strict();
-const focusLintInput = z
+const focusInspectInput = z
     .object({
     mode: z.enum(['national', 'continuous']).optional(),
     workspaceId: workspaceIdSchema,
-    relativePath: workspaceRelativePathSchema,
+    relativePath: workspaceRelativePathSchema.optional(),
     treeId: z.string().min(1).max(256).optional(),
     paletteId: z.string().min(1).max(256).optional(),
+    previous: focusLayoutSchema.optional(),
+    laneSpacing: z.number().int().min(1).max(100).optional(),
+    nodeSpacing: z.number().int().min(1).max(100).optional(),
 })
     .strict()
     .superRefine((value, context) => {
@@ -161,6 +140,22 @@ const focusLintInput = z
             path: ['treeId'],
             message: 'treeId is only valid in national mode',
         });
+    if (mode === 'continuous') {
+        for (const field of ['previous', 'laneSpacing', 'nodeSpacing']) {
+            if (value[field] !== undefined)
+                context.addIssue({
+                    code: 'custom',
+                    path: [field],
+                    message: `${field} is only valid in national mode`,
+                });
+        }
+    }
+    if (value.previous !== undefined && value.treeId === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['previous'],
+            message: 'previous requires treeId so it applies to exactly one tree',
+        });
 });
 const focusRenderInput = z
     .object({
@@ -214,7 +209,6 @@ const focusPlanInput = z
     workspaceId: workspaceIdSchema,
     relativePath: workspaceRelativePathSchema,
     plan: z.union([focusTreePlanSchema, continuousFocusPaletteSchema]),
-    authority: z.enum(['plan', 'source']).optional(),
     createIfMissing: z.boolean().default(false),
     horizontalSpacing: z.number().int().min(80).max(1000).optional(),
     verticalSpacing: z.number().int().min(60).max(1000).optional(),
@@ -246,7 +240,7 @@ const focusPlanInput = z
                 context.addIssue({
                     code: 'custom',
                     path: [field],
-                    message: `${field} is only valid for national focus transaction review renders`,
+                    message: `${field} is only valid for national focus review renders`,
                 });
         }
     }
@@ -257,9 +251,17 @@ const artifactProducing = {
     idempotentHint: true,
     openWorldHint: false,
 };
+const LARGE_FOCUS_RENDER_NODE_THRESHOLD = 200;
+const LARGE_FOCUS_RENDER_SCALE = 0.5;
+function automaticFocusRenderScale(focusCount) {
+    return focusCount >= LARGE_FOCUS_RENDER_NODE_THRESHOLD ? LARGE_FOCUS_RENDER_SCALE : 1;
+}
 function compactDrift(drift) {
-    const { currentSourcePlan: _currentSourcePlan, ...summary } = drift;
-    return summary;
+    return {
+        status: drift.status,
+        sourceChanged: drift.sourceChanged,
+        planChanged: drift.planChanged,
+    };
 }
 function normalizedRoot(value) {
     return value.replaceAll('\\', '/').replace(/^\.\//u, '').replace(/\/+$/u, '').toLowerCase();
@@ -390,23 +392,101 @@ function validationFromDiagnostics(diagnostics) {
 }
 export function registerFocusTools(server, engine, context) {
     const workbench = new FocusWorkbench(engine.resolver, engine.transactions, engine.artifacts);
-    server.registerTool('hoi4.focus_scan', {
-        title: 'Scan focus trees',
-        description: 'Import active focus-tree source through the shared lossless parser and return compact summaries plus a full resource artifact.',
-        inputSchema: z
-            .object({
-            workspaceId: workspaceIdSchema,
-            relativePath: workspaceRelativePathSchema.optional(),
-        })
-            .strict(),
-        outputSchema: focusScanOutputSchema,
+    server.registerTool('hoi4.focus_inspect', {
+        title: 'Inspect focus trees',
+        description: 'Inspect national trees or continuous palettes for creation and cleanup, including complete plans, references, diagnostics, and stable layout decisions.',
+        inputSchema: focusInspectInput,
+        outputSchema: focusInspectOutputSchema,
         annotations: artifactProducing,
-    }, async ({ workspaceId, relativePath }, extra) => {
+    }, async (input, extra) => {
+        const { workspaceId, relativePath } = input;
         try {
             const progress = progressReporter(extra);
             await progress.report(0, 3, 'Building shared workspace index');
             const snapshot = await engine.scan(workspaceId, {}, context.principal, progress.signal);
             const workspace = engine.resolver.get(workspaceId, context.principal);
+            if (input.mode === 'continuous') {
+                const selectedFiles = activeContinuousFocusFiles(snapshot).filter((file) => relativePath === undefined || file.relativePath === relativePath);
+                if (selectedFiles.length === 0) {
+                    throw new ServiceError('CONTINUOUS_FOCUS_SOURCE_NOT_FOUND', 'No active continuous focus source matched the request');
+                }
+                const diagnostics = [];
+                const importedPalettes = [];
+                for (const file of selectedFiles) {
+                    progress.signal.throwIfAborted();
+                    const imported = importContinuousFocusPalettes(parseClausewitz(file.bytes, file.displayPath));
+                    importedPalettes.push(...imported.continuousFocusPalettes);
+                    diagnostics.push(...imported.diagnostics);
+                }
+                const palettes = importedPalettes.filter(({ id }) => input.paletteId === undefined || id === input.paletteId);
+                if (palettes.length === 0) {
+                    throw new ServiceError('CONTINUOUS_FOCUS_PALETTE_NOT_FOUND', input.paletteId === undefined
+                        ? 'The selected source contains no continuous focus palette'
+                        : `Continuous focus palette was not found: ${input.paletteId}`);
+                }
+                const paletteDiagnosticCounts = new Map();
+                for (const palette of palettes) {
+                    const lintDiagnostics = workbench.lintContinuous(palette);
+                    paletteDiagnosticCounts.set(palette.id, lintDiagnostics.length);
+                    diagnostics.push(...lintDiagnostics);
+                }
+                const presentation = await resolveFocusPresentation({
+                    plans: [],
+                    palettes,
+                    files: snapshot.files,
+                    index: snapshot.index,
+                    scanner: engine.scanner,
+                    workspace,
+                    signal: progress.signal,
+                });
+                diagnostics.push(...presentation.diagnostics);
+                await progress.report(2, 3, 'Writing continuous focus inspection');
+                const completeSourceHashes = Object.fromEntries(Object.entries({
+                    ...Object.fromEntries(selectedFiles.map(({ displayPath, sha256 }) => [displayPath, sha256])),
+                    ...presentation.sourceHashes,
+                }).sort(([left], [right]) => compareCodeUnits(left, right)));
+                const sourceEvidence = boundedSourceHashEvidence(completeSourceHashes);
+                const artifact = await engine.artifacts.putChunked(workspace, `focus-inspect.${snapshot.revision.slice(0, 16)}.json`, 'application/json', `${canonicalJson({
+                    schemaVersion: 1,
+                    mode: 'continuous',
+                    revision: snapshot.revision,
+                    continuousFocusPalettes: palettes,
+                    presentation: focusPresentationEvidence(presentation),
+                    sourceHashes: completeSourceHashes,
+                    diagnostics,
+                })}\n`, {
+                    kind: 'focus-inspect',
+                    toolVersion: PACKAGE_VERSION,
+                    schemaVersion: 'focus-inspect.v1',
+                    sourceHashes: sourceEvidence.sourceHashes,
+                    metadata: { sourceHashInventory: sourceEvidence.inventory },
+                }, 'Continuous focus plans and diagnostics', progress.signal);
+                const result = emptyServiceResult(workspaceId, {
+                    mode: 'continuous',
+                    revision: snapshot.revision,
+                    treeCount: 0,
+                    paletteCount: palettes.length,
+                    trees: [],
+                    palettes: palettes.slice(0, 100).map((palette) => ({
+                        id: palette.id,
+                        sourcePath: palette.provenance.sourcePath,
+                        focusCount: palette.focuses.length,
+                        diagnosticCount: paletteDiagnosticCounts.get(palette.id) ?? 0,
+                    })),
+                });
+                result.code = 'FOCUS_INSPECTED';
+                setInlineFilesScanned(result, [
+                    ...new Set([
+                        ...selectedFiles.map(({ displayPath }) => displayPath),
+                        ...presentation.filesScanned,
+                    ]),
+                ].sort((left, right) => compareCodeUnits(left, right)));
+                result.diagnostics = diagnostics.slice(0, 100);
+                result.artifacts = [publicArtifactLink(artifact)];
+                result.validation = validationFromDiagnostics(diagnostics);
+                await progress.report(3, 3, 'Continuous focus inspection complete');
+                return toolResult(result);
+            }
             const selectedFiles = activeFocusFiles(snapshot, workspace.registration.roots.focus).filter((file) => relativePath === undefined || file.relativePath === relativePath);
             if (selectedFiles.length === 0) {
                 throw new ServiceError('FOCUS_SOURCE_NOT_FOUND', 'No active focus source matched the request');
@@ -415,16 +495,40 @@ export function registerFocusTools(server, engine, context) {
                 const resolved = activeSidecar(snapshot, file);
                 return resolved === undefined ? [] : [resolved.file];
             });
-            const plans = [];
+            const importedPlans = [];
             const diagnostics = [];
             const paletteImport = continuousPalettes(snapshot);
             diagnostics.push(...paletteImport.diagnostics);
             for (const file of selectedFiles) {
                 progress.signal.throwIfAborted();
                 const imported = importFocusFile(snapshot, file, paletteImport.palettes);
-                plans.push(...imported.plans);
+                importedPlans.push(...imported.plans);
                 diagnostics.push(...imported.diagnostics);
             }
+            const plans = importedPlans.filter(({ id }) => input.treeId === undefined || id === input.treeId);
+            if (plans.length === 0) {
+                throw new ServiceError('FOCUS_TREE_NOT_FOUND', input.treeId === undefined
+                    ? 'The selected source contains no national focus tree'
+                    : `Focus tree was not found: ${input.treeId}`);
+            }
+            const inspectedPlans = [];
+            for (const plan of plans) {
+                const layout = await workbench.layoutAsync(plan, {
+                    ...(input.previous === undefined
+                        ? {}
+                        : { previous: input.previous }),
+                    ...(input.laneSpacing === undefined ? {} : { laneSpacing: input.laneSpacing }),
+                    ...(input.nodeSpacing === undefined ? {} : { nodeSpacing: input.nodeSpacing }),
+                    signal: progress.signal,
+                });
+                const lintDiagnostics = workbench.lint(plan, {
+                    index: snapshot.index,
+                    references: referenceCatalog(snapshot),
+                    layout,
+                });
+                diagnostics.push(...lintDiagnostics);
+                inspectedPlans.push({ plan, layout, diagnosticCount: lintDiagnostics.length });
+            }
             const presentation = await resolveFocusPresentation({
                 plans,
                 palettes: paletteImport.palettes,
@@ -435,7 +539,7 @@ export function registerFocusTools(server, engine, context) {
                 signal: progress.signal,
             });
             diagnostics.push(...presentation.diagnostics);
-            await progress.report(2, 3, 'Writing imported planning models');
+            await progress.report(2, 3, 'Writing focus plans, diagnostics, and layouts');
             const completeSourceHashes = Object.fromEntries(Object.entries({
                 ...Object.fromEntries([
                     ...selectedFiles,
@@ -445,25 +549,32 @@ export function registerFocusTools(server, engine, context) {
                 ...presentation.sourceHashes,
             }).sort(([left], [right]) => compareCodeUnits(left, right)));
             const sourceEvidence = boundedSourceHashEvidence(completeSourceHashes);
-            const artifact = await engine.artifacts.putChunked(workspace, `focus-scan.${snapshot.revision.slice(0, 16)}.json`, 'application/json', `${canonicalJson({
+            const artifact = await engine.artifacts.putChunked(workspace, `focus-inspect.${snapshot.revision.slice(0, 16)}.json`, 'application/json', `${canonicalJson({
                 schemaVersion: 1,
                 revision: snapshot.revision,
                 plans,
+                layouts: inspectedPlans.map(({ plan, layout, diagnosticCount }) => ({
+                    treeId: plan.id,
+                    layout,
+                    diagnosticCount,
+                })),
                 continuousFocusPalettes: paletteImport.palettes,
                 presentation: focusPresentationEvidence(presentation),
                 sourceHashes: completeSourceHashes,
                 diagnostics,
             })}\n`, {
-                kind: 'focus-scan',
+                kind: 'focus-inspect',
                 toolVersion: PACKAGE_VERSION,
-                schemaVersion: 'focus-scan.v1',
+                schemaVersion: 'focus-inspect.v1',
                 sourceHashes: sourceEvidence.sourceHashes,
                 metadata: { sourceHashInventory: sourceEvidence.inventory },
-            }, 'Imported focus planning models and source-linked diagnostics', progress.signal);
+            }, 'Focus plans, diagnostics, and stable layout decisions', progress.signal);
             const result = emptyServiceResult(workspaceId, {
+                mode: 'national',
                 revision: snapshot.revision,
                 treeCount: plans.length,
-                trees: plans.slice(0, 100).map((plan) => ({
+                paletteCount: paletteImport.palettes.length,
+                trees: inspectedPlans.slice(0, 100).map(({ plan, layout, diagnosticCount }) => ({
                     id: plan.id,
                     sourcePath: plan.provenance.sourcePath,
                     focusCount: plan.focuses.length,
@@ -471,9 +582,13 @@ export function registerFocusTools(server, engine, context) {
                     continuousPaletteCount: plan.continuousFocusPaletteIds.length,
                     continuousFocusCount: plan.continuousFocusIds.length,
                     resolvedTitleCount: plan.focuses.filter(({ id }) => presentation.entries[id]?.titleSourceLocation !== undefined).length,
+                    layoutHash: layout.layoutHash,
+                    layoutDecisionCount: layout.decisions.length,
+                    diagnosticCount,
                 })),
+                palettes: [],
             });
-            result.code = 'FOCUS_SCANNED';
+            result.code = 'FOCUS_INSPECTED';
             setInlineFilesScanned(result, [
                 ...new Set([
                     ...selectedFiles.map(({ displayPath }) => displayPath),
@@ -485,143 +600,7 @@ export function registerFocusTools(server, engine, context) {
             result.diagnostics = diagnostics.slice(0, 100);
             result.artifacts = [publicArtifactLink(artifact)];
             result.validation = validationFromDiagnostics(diagnostics);
-            await progress.report(3, 3, 'Focus scan complete');
-            return toolResult(result);
-        }
-        catch (error) {
-            return errorResult(error, workspaceId);
-        }
-    });
-    server.registerTool('hoi4.focus_lint', {
-        title: 'Lint focus source',
-        description: 'Lint one national focus tree or continuous focus palette. Omit mode for backward-compatible national behavior.',
-        inputSchema: focusLintInput,
-        outputSchema: focusLintOutputSchema,
-        annotations: artifactProducing,
-    }, async (input, extra) => {
-        const { workspaceId, relativePath } = input;
-        try {
-            const progress = progressReporter(extra);
-            await progress.report(0, 3, 'Importing and indexing focus source');
-            const snapshot = await engine.scan(workspaceId, {}, context.principal, progress.signal);
-            const workspace = engine.resolver.get(workspaceId, context.principal);
-            if (input.mode === 'continuous') {
-                selectedContinuousFocusFile(snapshot, relativePath);
-                const imported = await workbench.importContinuousPath(workspaceId, relativePath, context.principal);
-                const plan = selectContinuousPlan(imported.result, input.paletteId);
-                const diagnostics = [...imported.result.diagnostics, ...workbench.lintContinuous(plan)];
-                await progress.report(2, 3, 'Writing continuous focus lint evidence');
-                const artifact = await engine.artifacts.put(workspace, `${plan.id.replace(/[^A-Za-z0-9._-]/gu, '_')}.continuous-focus-lint.json`, 'application/json', `${canonicalJson({ schemaVersion: 1, mode: 'continuous', paletteId: plan.id, diagnostics })}\n`, {
-                    kind: 'continuous-focus-lint',
-                    toolVersion: PACKAGE_VERSION,
-                    schemaVersion: 'continuous-focus-lint.v1',
-                    sourceHashes: { [plan.provenance.sourcePath]: plan.provenance.sourceHash },
-                }, 'Complete continuous focus lint report', progress.signal);
-                const result = emptyServiceResult(workspaceId, {
-                    mode: 'continuous',
-                    paletteId: plan.id,
-                    focusCount: plan.focuses.length,
-                    diagnosticCount: diagnostics.length,
-                });
-                result.code = 'CONTINUOUS_FOCUS_LINTED';
-                setInlineFilesScanned(result, [plan.provenance.sourcePath]);
-                result.diagnostics = diagnostics.slice(0, 100);
-                result.artifacts = [publicArtifactLink(artifact)];
-                result.validation = validationFromDiagnostics(diagnostics);
-                await progress.report(3, 3, 'Continuous focus lint complete');
-                return toolResult(result);
-            }
-            const paletteImport = continuousPalettes(snapshot);
-            const imported = importFocusFile(snapshot, selectedFocusFile(snapshot, workspace.registration.roots.focus, relativePath), paletteImport.palettes);
-            const plan = selectPlan(imported, input.treeId);
-            const layout = await workbench.layoutAsync(plan, { signal: progress.signal });
-            const diagnostics = [
-                ...paletteImport.diagnostics,
-                ...imported.diagnostics,
-                ...workbench.lint(plan, {
-                    index: snapshot.index,
-                    references: referenceCatalog(snapshot),
-                    layout,
-                }),
-            ];
-            await progress.report(2, 3, 'Writing focus lint evidence');
-            const artifact = await engine.artifacts.put(workspace, `${plan.id.replace(/[^A-Za-z0-9._-]/gu, '_')}.focus-lint.json`, 'application/json', `${canonicalJson({ schemaVersion: 1, treeId: plan.id, layoutHash: layout.layoutHash, diagnostics })}\n`, {
-                kind: 'focus-lint',
-                toolVersion: PACKAGE_VERSION,
-                schemaVersion: 'focus-lint.v1',
-                sourceHashes: { [plan.provenance.sourcePath]: plan.provenance.sourceHash },
-            }, 'Complete focus lint report', progress.signal);
-            const result = emptyServiceResult(workspaceId, {
-                mode: 'national',
-                treeId: plan.id,
-                focusCount: plan.focuses.length,
-                layoutHash: layout.layoutHash,
-                diagnosticCount: diagnostics.length,
-            });
-            result.code = 'FOCUS_LINTED';
-            setInlineFilesScanned(result, [plan.provenance.sourcePath]);
-            result.diagnostics = diagnostics.slice(0, 100);
-            result.artifacts = [publicArtifactLink(artifact)];
-            result.validation = validationFromDiagnostics(diagnostics);
-            await progress.report(3, 3, 'Focus lint complete');
-            return toolResult(result);
-        }
-        catch (error) {
-            return errorResult(error, workspaceId);
-        }
-    });
-    server.registerTool('hoi4.focus_layout', {
-        title: 'Plan stable focus layout',
-        description: 'Create a deterministic constraint layout while preserving pinned, relative, and previous automatic positions. Imported authored coordinates remain fixed; a full existing-tree repair must submit a complete plan whose movable nodes use position.mode "auto".',
-        inputSchema: focusPathInput
-            .extend({
-            previous: focusLayoutSchema.optional(),
-            laneSpacing: z.number().int().min(1).max(100).optional(),
-            nodeSpacing: z.number().int().min(1).max(100).optional(),
-        })
-            .strict(),
-        outputSchema: focusLayoutOutputSchema,
-        annotations: artifactProducing,
-    }, async ({ workspaceId, relativePath, treeId, previous, laneSpacing, nodeSpacing }, extra) => {
-        try {
-            const progress = progressReporter(extra);
-            await progress.report(0, 3, 'Importing and indexing focus source');
-            const snapshot = await engine.scan(workspaceId, {}, context.principal, progress.signal);
-            const workspace = engine.resolver.get(workspaceId, context.principal);
-            const paletteImport = continuousPalettes(snapshot);
-            const imported = importFocusFile(snapshot, selectedFocusFile(snapshot, workspace.registration.roots.focus, relativePath), paletteImport.palettes);
-            const plan = selectPlan(imported, treeId);
-            const layout = await workbench.layoutAsync(plan, {
-                ...(previous === undefined ? {} : { previous: previous }),
-                ...(laneSpacing === undefined ? {} : { laneSpacing }),
-                ...(nodeSpacing === undefined ? {} : { nodeSpacing }),
-                signal: progress.signal,
-            });
-            progress.signal.throwIfAborted();
-            await progress.report(2, 3, 'Writing stable focus layout evidence');
-            const artifact = await engine.artifacts.put(workspace, `${plan.id.replace(/[^A-Za-z0-9._-]/gu, '_')}.focus-layout.json`, 'application/json', `${canonicalJson(layout)}\n`, {
-                kind: 'focus-layout',
-                toolVersion: PACKAGE_VERSION,
-                schemaVersion: 'focus-layout.v1',
-                sourceHashes: { [plan.provenance.sourcePath]: plan.provenance.sourceHash },
-            }, 'Stable focus layout decisions and diagnostics', progress.signal);
-            const diagnostics = [
-                ...paletteImport.diagnostics,
-                ...imported.diagnostics,
-                ...layout.diagnostics,
-            ];
-            const result = emptyServiceResult(workspaceId, {
-                treeId: plan.id,
-                layoutHash: layout.layoutHash,
-                nodeCount: layout.nodes.length,
-                decisions: layout.decisions.slice(0, 100),
-            });
-            result.code = 'FOCUS_LAYOUT_PLANNED';
-            setInlineFilesScanned(result, [plan.provenance.sourcePath]);
-            result.diagnostics = diagnostics.slice(0, 100);
-            result.artifacts = [publicArtifactLink(artifact)];
-            result.validation = validationFromDiagnostics(diagnostics);
-            await progress.report(3, 3, 'Focus layout complete');
+            await progress.report(3, 3, 'Focus inspection complete');
             return toolResult(result);
         }
         catch (error) {
@@ -630,7 +609,7 @@ export function registerFocusTools(server, engine, context) {
     });
     server.registerTool('hoi4.focus_render', {
         title: 'Render focus review artifacts',
-        description: 'Generate deterministic HTML, SVG, genuine PNG, JSON, and source-map artifacts for a national tree or continuous palette. Omit mode for national behavior. National renders accept a uniform reviewScale from 0.25 through 1.0 so very large trees can fit bounded artifacts without changing logical node geometry or source coordinates.',
+        description: 'Render a national tree or continuous palette for creation and cleanup review as deterministic HTML, SVG, PNG, JSON, and source-map artifacts. Omit mode for national behavior. National trees with at least 200 focuses use reviewScale 0.5 by default; set 0.25 through 1.0 explicitly when needed.',
         inputSchema: focusRenderInput,
         outputSchema: focusRenderOutputSchema,
         annotations: artifactProducing,
@@ -699,6 +678,7 @@ export function registerFocusTools(server, engine, context) {
                 signal: progress.signal,
             });
             await progress.report(1, 3, 'Rendering focus artifacts');
+            const effectiveReviewScale = input.reviewScale ?? automaticFocusRenderScale(plan.focuses.length);
             const rendered = await workbench.renderAndStore(workspaceId, plan, {
                 ...(context.principal === undefined ? {} : { principal: context.principal }),
                 index: snapshot.index,
@@ -712,10 +692,10 @@ export function registerFocusTools(server, engine, context) {
                     ? {}
                     : { verticalSpacing: input.verticalSpacing }),
                 ...(input.padding === undefined ? {} : { padding: input.padding }),
-                ...(input.reviewScale === undefined ? {} : { outputScale: input.reviewScale }),
+                outputScale: effectiveReviewScale,
                 renderProfile: {
                     sourceRevision: snapshot.revision,
-                    ...(input.reviewScale === undefined ? {} : { reviewScale: input.reviewScale }),
+                    reviewScale: effectiveReviewScale,
                 },
                 budget: renderBudget,
                 signal: progress.signal,
@@ -745,23 +725,23 @@ export function registerFocusTools(server, engine, context) {
             return errorResult(error, workspaceId);
         }
     });
-    server.registerTool('hoi4.focus_plan_changes', {
-        title: 'Dry-run focus source changes',
-        description: 'Compile a validated national tree or continuous palette plan into source and create a hash-bound dry-run transaction; never applies it. Omit mode for national behavior. National plans accept the same bounded horizontalSpacing, verticalSpacing, and padding controls as focus_render plus a uniform reviewScale that preserves logical SVG geometry while reducing both before/proposed raster outputs. For an unoccupied new source, pass createIfMissing: true with plan:<id> and zero-hash creation provenance.',
+    server.registerTool('hoi4.focus_rewrite', {
+        title: 'Create or clean up focus content',
+        description: 'Create or clean up a national tree or continuous palette from a complete plan, validate the result, apply it in one call, and return before-and-after review artifacts. Omit mode for national behavior. National plans accept bounded horizontalSpacing, verticalSpacing, padding, and reviewScale controls. Set createIfMissing for a new file.',
         inputSchema: focusPlanInput,
         outputSchema: focusPlanOutputSchema,
         annotations: {
             readOnlyHint: false,
-            destructiveHint: false,
+            destructiveHint: true,
             idempotentHint: false,
             openWorldHint: false,
         },
     }, async (input, extra) => {
-        const { workspaceId, relativePath, authority, createIfMissing, horizontalSpacing, verticalSpacing, padding, reviewScale, } = input;
+        const { workspaceId, relativePath, createIfMissing, horizontalSpacing, verticalSpacing, padding, reviewScale, } = input;
         try {
             requireServerScope(context, 'hoi4:write');
             const progress = progressReporter(extra);
-            await progress.report(0, 5, 'Validating shared index and source authority');
+            await progress.report(0, 5, 'Validating shared index and current source');
             const snapshot = await engine.scan(workspaceId, {}, context.principal, progress.signal);
             const workspace = engine.resolver.get(workspaceId, context.principal);
             if (input.mode === 'continuous') {
@@ -787,8 +767,6 @@ export function registerFocusTools(server, engine, context) {
                 }
                 if (currentPlan === undefined && createIfMissing && sourceFile !== undefined)
                     throw new ServiceError('CONTINUOUS_FOCUS_CREATE_REQUIRES_NEW_SOURCE', 'Creating a continuous-focus palette requires a new mod source file so unrelated existing source is never repurposed', { relativePath, paletteId: plan.id });
-                if (currentPlan !== undefined && imported !== undefined)
-                    assertFocusPlanAuthority(detectContinuousFocusDrift(plan, imported.document), authority);
                 const renderBudget = new RenderBudget();
                 const presentation = await resolveFocusPresentation({
                     plans: [],
@@ -865,32 +843,37 @@ export function registerFocusTools(server, engine, context) {
                     ...proposed.artifacts.map(publicArtifactLink),
                     ...comparisonArtifacts.map(publicArtifactLink),
                 ];
-                await progress.report(3, 5, 'Creating hash-bound continuous focus transaction');
+                await progress.report(3, 5, 'Preparing the continuous focus rewrite');
                 const planned = await workbench.planContinuousChanges({
                     workspaceId,
                     relativePath,
                     plan,
                     createIfMissing,
-                    ...(authority === undefined ? {} : { authority }),
+                    authority: 'plan',
                     ...(context.principal === undefined ? {} : { principal: context.principal }),
                     artifacts: reviewArtifacts,
                     readDependencies: readDependenciesFromScannedFiles(snapshot.files),
                     signal: progress.signal,
                 });
-                const transaction = planned.transaction;
+                await progress.report(4, 5, 'Applying and validating the continuous focus rewrite');
+                const execution = await executePlannedTransaction(engine, planned.transaction, context.principal, progress.signal);
+                const transaction = execution.transaction;
                 const result = emptyServiceResult(workspaceId, {
                     mode: 'continuous',
                     paletteId: plan.id,
                     drift: compactDrift(planned.drift),
                     created: planned.drift.status === 'target_missing',
-                    expiresAt: transaction.expiresAt,
-                    transactionFileCount: transaction.files.length,
-                    transactionArtifactCount: transaction.artifacts.length,
+                    execution: execution.outcome,
+                    fileCount: transaction.files.length,
+                    artifactCount: transaction.artifacts.length,
                 });
                 result.status = transaction.validation.passed ? 'ok' : 'blocked';
-                result.code = transaction.validation.passed
-                    ? 'CONTINUOUS_FOCUS_CHANGES_PLANNED'
-                    : 'CONTINUOUS_FOCUS_CHANGES_BLOCKED';
+                result.code =
+                    execution.outcome === 'applied'
+                        ? 'CONTINUOUS_FOCUS_CHANGES_APPLIED'
+                        : execution.outcome === 'unchanged'
+                            ? 'CONTINUOUS_FOCUS_CHANGES_UNCHANGED'
+                            : 'CONTINUOUS_FOCUS_CHANGES_BLOCKED';
                 setInlineFilesScanned(result, [
                     ...new Set([
                         ...(sourceFile === undefined ? [] : [sourceFile.displayPath]),
@@ -900,12 +883,10 @@ export function registerFocusTools(server, engine, context) {
                 result.proposedFiles = transaction.files
                     .slice(0, 100)
                     .map(({ relativePath: file }) => file);
+                result.changedFiles = transaction.appliedFiles.slice(0, 100);
                 result.diagnostics = transaction.diagnostics.slice(0, 100);
-                result.transactionId = transaction.transactionId;
-                result.planHash = transaction.planHash;
-                result.artifacts = [transactionResourceLink(transaction)];
+                result.artifacts = autonomousResultArtifacts(execution);
                 result.validation = transaction.validation;
-                result.rollbackStatus = transaction.rollbackStatus;
                 result.blockers = transaction.diagnostics
                     .filter(({ severity }) => severity === 'error' || severity === 'blocker')
                     .map(({ code, message, details }) => ({
@@ -913,7 +894,11 @@ export function registerFocusTools(server, engine, context) {
                     message,
                     ...(details === undefined ? {} : { details }),
                 }));
-                await progress.report(5, 5, 'Continuous focus dry run complete');
+                await progress.report(5, 5, execution.outcome === 'applied'
+                    ? 'Continuous focus rewrite complete'
+                    : execution.outcome === 'unchanged'
+                        ? 'Continuous focus content already satisfied the plan'
+                        : 'Continuous focus rewrite blocked');
                 return toolResult(result);
             }
             const plan = input.plan;
@@ -943,20 +928,19 @@ export function registerFocusTools(server, engine, context) {
             }
             if (currentPlan === undefined && createIfMissing && focusFile !== undefined)
                 throw new ServiceError('FOCUS_CREATE_REQUIRES_NEW_SOURCE', 'Creating a national focus tree requires a new mod source file so an existing source and its planning sidecar cannot be repurposed', { relativePath, treeId: plan.id });
-            if (currentPlan !== undefined && imported !== undefined)
-                assertFocusPlanAuthority(detectFocusDrift(plan, imported.document, catalog), authority);
             const renderBudget = new RenderBudget();
+            const effectiveReviewScale = reviewScale ?? automaticFocusRenderScale(plan.focuses.length);
             const reviewRenderOptions = {
                 ...(horizontalSpacing === undefined ? {} : { horizontalSpacing }),
                 ...(verticalSpacing === undefined ? {} : { verticalSpacing }),
                 ...(padding === undefined ? {} : { padding }),
-                ...(reviewScale === undefined ? {} : { outputScale: reviewScale }),
+                outputScale: effectiveReviewScale,
             };
             const reviewRenderProfile = {
                 ...(horizontalSpacing === undefined ? {} : { horizontalSpacing }),
                 ...(verticalSpacing === undefined ? {} : { verticalSpacing }),
                 ...(padding === undefined ? {} : { padding }),
-                ...(reviewScale === undefined ? {} : { reviewScale }),
+                reviewScale: effectiveReviewScale,
             };
             const presentation = await resolveFocusPresentation({
                 plans: [...(currentPlan === undefined ? [] : [currentPlan]), plan],
@@ -1052,13 +1036,13 @@ export function registerFocusTools(server, engine, context) {
                 ...proposed.artifacts.map(publicArtifactLink),
                 ...comparisonArtifacts.map(publicArtifactLink),
             ];
-            await progress.report(3, 5, 'Creating hash-bound focus transaction');
+            await progress.report(3, 5, 'Preparing the focus-tree rewrite');
             const planned = await workbench.planChanges({
                 workspaceId,
                 relativePath,
                 plan,
                 createIfMissing,
-                ...(authority === undefined ? {} : { authority }),
+                authority: 'plan',
                 ...(context.principal === undefined ? {} : { principal: context.principal }),
                 index: snapshot.index,
                 references: catalog,
@@ -1066,21 +1050,26 @@ export function registerFocusTools(server, engine, context) {
                 readDependencies: readDependenciesFromScannedFiles(snapshot.files),
                 signal: progress.signal,
             });
-            const transaction = planned.transaction;
+            await progress.report(4, 5, 'Applying and validating the focus-tree rewrite');
+            const execution = await executePlannedTransaction(engine, planned.transaction, context.principal, progress.signal);
+            const transaction = execution.transaction;
             const result = emptyServiceResult(workspaceId, {
                 mode: 'national',
                 treeId: plan.id,
                 drift: compactDrift(planned.drift),
                 created: planned.drift.status === 'target_missing',
+                execution: execution.outcome,
                 layoutHash: planned.layout.layoutHash,
-                expiresAt: transaction.expiresAt,
-                transactionFileCount: transaction.files.length,
-                transactionArtifactCount: transaction.artifacts.length,
+                fileCount: transaction.files.length,
+                artifactCount: transaction.artifacts.length,
             });
             result.status = transaction.validation.passed ? 'ok' : 'blocked';
-            result.code = transaction.validation.passed
-                ? 'FOCUS_CHANGES_PLANNED'
-                : 'FOCUS_CHANGES_BLOCKED';
+            result.code =
+                execution.outcome === 'applied'
+                    ? 'FOCUS_CHANGES_APPLIED'
+                    : execution.outcome === 'unchanged'
+                        ? 'FOCUS_CHANGES_UNCHANGED'
+                        : 'FOCUS_CHANGES_BLOCKED';
             setInlineFilesScanned(result, [
                 ...new Set([
                     ...(focusFile === undefined ? [] : [focusFile.displayPath]),
@@ -1090,12 +1079,10 @@ export function registerFocusTools(server, engine, context) {
             result.proposedFiles = transaction.files
                 .slice(0, 100)
                 .map(({ relativePath: file }) => file);
+            result.changedFiles = transaction.appliedFiles.slice(0, 100);
             result.diagnostics = transaction.diagnostics.slice(0, 100);
-            result.transactionId = transaction.transactionId;
-            result.planHash = transaction.planHash;
-            result.artifacts = [transactionResourceLink(transaction)];
+            result.artifacts = autonomousResultArtifacts(execution);
             result.validation = transaction.validation;
-            result.rollbackStatus = transaction.rollbackStatus;
             result.blockers = transaction.diagnostics
                 .filter(({ severity }) => severity === 'error' || severity === 'blocker')
                 .map(({ code, message, details }) => ({
@@ -1103,12 +1090,15 @@ export function registerFocusTools(server, engine, context) {
                 message,
                 ...(details === undefined ? {} : { details }),
             }));
-            await progress.report(5, 5, 'Focus dry run complete');
+            await progress.report(5, 5, execution.outcome === 'applied'
+                ? 'Focus rewrite complete'
+                : execution.outcome === 'unchanged'
+                    ? 'Focus content already satisfied the plan'
+                    : 'Focus rewrite blocked');
             return toolResult(result);
         }
         catch (error) {
-            return errorResult(error, workspaceId);
+            return errorResult(error, workspaceId, autonomousFailureContext(error));
         }
     });
 }
-//# sourceMappingURL=focus.js.map