hoi4-agent-tools 0.2.0 → 1.1.0

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

@@ -6,19 +6,22 @@ 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, assertCompactLayoutQuality, compactFocusTreePlanAsync, focusPlanHash, focusPresentationEvidence, focusPlanningSidecarPath, importContinuousFocusPalettes, importFocusTrees, linkContinuousFocusPalettes, parseFocusPlanningSidecar, renderContinuousFocusPalette, renderFocusTree, resolveFocusPresentation, enrichFocusPlanFromSidecar, } from '../../focus/index.js';
+import { continuousFocusPaletteSchema, focusLayoutMetricsSchema, 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';
-import { autonomousFailureContext, autonomousResultArtifacts, autonomousWrites, executePlannedTransaction, } from '../server/transaction-execution.js';
-const focusScanOutputSchema = strictOperationResultSchema(z
+import { requireServerScope } from '../server/base-tools.js';
+import { compactValidatedInputSchema } from '../server/context-schemas.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({
@@ -29,36 +32,23 @@ 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,
+        layoutMetrics: focusLayoutMetricsSchema,
         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', [
@@ -97,12 +87,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;
@@ -114,11 +98,10 @@ const focusPlanOutputSchema = strictOperationResultSchema(z.discriminatedUnion('
         treeId: z.string().max(256),
         drift: focusDriftOutputSchema,
         created: z.boolean(),
-        execution: z.enum(['planned', 'applied', 'blocked', 'unchanged']),
+        execution: z.enum(['applied', 'blocked', 'unchanged']),
         layoutHash: sha256Schema,
-        expiresAt: z.iso.datetime(),
-        transactionFileCount: nonNegativeIntegerSchema,
-        transactionArtifactCount: nonNegativeIntegerSchema,
+        fileCount: nonNegativeIntegerSchema,
+        artifactCount: nonNegativeIntegerSchema,
     })
         .strict(),
     z
@@ -127,27 +110,23 @@ const focusPlanOutputSchema = strictOperationResultSchema(z.discriminatedUnion('
         paletteId: z.string().max(256),
         drift: continuousFocusDriftOutputSchema,
         created: z.boolean(),
-        execution: z.enum(['planned', 'applied', 'blocked', 'unchanged']),
-        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 compactFocusPlanSchema = compactValidatedInputSchema(z.union([focusTreePlanSchema, continuousFocusPaletteSchema]), `Complete focus plan: https://github.com/klimPaskov/hoi4-agent-tools/blob/v${PACKAGE_VERSION}/docs/focus.md`);
+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) => {
@@ -164,6 +143,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({
@@ -216,8 +211,9 @@ const focusPlanInput = z
     mode: z.enum(['national', 'continuous']).optional(),
     workspaceId: workspaceIdSchema,
     relativePath: workspaceRelativePathSchema,
-    plan: z.union([focusTreePlanSchema, continuousFocusPaletteSchema]),
-    authority: z.enum(['plan', 'source']).optional(),
+    treeId: z.string().min(1).max(256).optional(),
+    layoutMode: z.enum(['authored', 'compact']).default('authored'),
+    plan: compactFocusPlanSchema.optional(),
     createIfMissing: z.boolean().default(false),
     horizontalSpacing: z.number().int().min(80).max(1000).optional(),
     verticalSpacing: z.number().int().min(60).max(1000).optional(),
@@ -232,13 +228,31 @@ const focusPlanInput = z
     .superRefine((value, context) => {
     const mode = value.mode ?? 'national';
     const schema = mode === 'continuous' ? continuousFocusPaletteSchema : focusTreePlanSchema;
-    if (!schema.safeParse(value.plan).success)
+    if (value.plan !== undefined && !schema.safeParse(value.plan).success)
         context.addIssue({
             code: 'custom',
             path: ['plan'],
             message: `plan must be a ${mode} focus plan`,
         });
     if (mode === 'continuous') {
+        if (value.plan === undefined)
+            context.addIssue({
+                code: 'custom',
+                path: ['plan'],
+                message: 'plan is required in continuous mode',
+            });
+        if (value.treeId !== undefined)
+            context.addIssue({
+                code: 'custom',
+                path: ['treeId'],
+                message: 'treeId is only valid in national mode',
+            });
+        if (value.layoutMode !== 'authored')
+            context.addIssue({
+                code: 'custom',
+                path: ['layoutMode'],
+                message: 'compact layout mode is only valid in national mode',
+            });
         for (const [field, fieldValue] of [
             ['horizontalSpacing', value.horizontalSpacing],
             ['verticalSpacing', value.verticalSpacing],
@@ -249,10 +263,39 @@ 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`,
                 });
         }
     }
+    else {
+        if (value.plan === undefined && value.layoutMode !== 'compact')
+            context.addIssue({
+                code: 'custom',
+                path: ['plan'],
+                message: 'plan is required unless layoutMode is compact',
+            });
+        if (value.plan === undefined && value.treeId === undefined)
+            context.addIssue({
+                code: 'custom',
+                path: ['treeId'],
+                message: 'treeId is required for plan-free compact reflow',
+            });
+        if (value.plan === undefined && value.createIfMissing)
+            context.addIssue({
+                code: 'custom',
+                path: ['createIfMissing'],
+                message: 'plan-free compact reflow requires an existing focus source',
+            });
+        if (value.plan !== undefined &&
+            value.treeId !== undefined &&
+            'id' in value.plan &&
+            value.plan.id !== value.treeId)
+            context.addIssue({
+                code: 'custom',
+                path: ['treeId'],
+                message: 'treeId must match the supplied national focus plan',
+            });
+    }
 });
 const artifactProducing = {
     readOnlyHint: false,
@@ -260,9 +303,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();
@@ -392,25 +443,102 @@ function validationFromDiagnostics(diagnostics) {
     };
 }
 export function registerFocusTools(server, engine, context) {
-    const autonomous = autonomousWrites(engine);
     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');
@@ -419,16 +547,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,
@@ -439,7 +591,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,
@@ -449,25 +601,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,
@@ -475,9 +634,14 @@ 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,
+                    layoutMetrics: layout.metrics,
+                    diagnosticCount,
                 })),
+                palettes: [],
             });
-            result.code = 'FOCUS_SCANNED';
+            result.code = 'FOCUS_INSPECTED';
             setInlineFilesScanned(result, [
                 ...new Set([
                     ...selectedFiles.map(({ displayPath }) => displayPath),
@@ -489,143 +653,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) {
@@ -634,7 +662,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,
@@ -703,6 +731,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,
@@ -716,10 +745,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,
@@ -749,25 +778,23 @@ export function registerFocusTools(server, engine, context) {
             return errorResult(error, workspaceId);
         }
     });
-    server.registerTool(autonomous ? 'hoi4.focus_rewrite' : 'hoi4.focus_plan_changes', {
-        title: autonomous ? 'Rewrite focus source' : 'Dry-run focus source changes',
-        description: `${autonomous
-            ? 'Compile, validate, journal, and immediately apply a national tree or continuous palette plan in one call. No transaction approval or follow-up apply call is required.'
-            : 'Compile a validated national tree or continuous palette plan into source and create a hash-bound reviewed transaction; it does not apply the transaction.'} 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, validate it, and apply it in one call. Supply a complete plan; set layoutMode compact for automatic arrangement. Existing national trees can omit the plan and use treeId plus layoutMode compact. Set createIfMissing for a new file.',
         inputSchema: focusPlanInput,
         outputSchema: focusPlanOutputSchema,
         annotations: {
             readOnlyHint: false,
-            destructiveHint: autonomous,
+            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') {
@@ -793,8 +820,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: [],
@@ -871,21 +896,19 @@ 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,
                 });
-                await progress.report(4, 5, autonomous
-                    ? 'Applying and post-validating continuous focus rewrite'
-                    : 'Finalizing reviewed 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, {
@@ -894,9 +917,8 @@ export function registerFocusTools(server, engine, context) {
                     drift: compactDrift(planned.drift),
                     created: planned.drift.status === 'target_missing',
                     execution: execution.outcome,
-                    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 =
@@ -904,9 +926,7 @@ export function registerFocusTools(server, engine, context) {
                         ? 'CONTINUOUS_FOCUS_CHANGES_APPLIED'
                         : execution.outcome === 'unchanged'
                             ? 'CONTINUOUS_FOCUS_CHANGES_UNCHANGED'
-                            : transaction.validation.passed
-                                ? 'CONTINUOUS_FOCUS_CHANGES_PLANNED'
-                                : 'CONTINUOUS_FOCUS_CHANGES_BLOCKED';
+                            : 'CONTINUOUS_FOCUS_CHANGES_BLOCKED';
                 setInlineFilesScanned(result, [
                     ...new Set([
                         ...(sourceFile === undefined ? [] : [sourceFile.displayPath]),
@@ -918,15 +938,7 @@ export function registerFocusTools(server, engine, context) {
                     .map(({ relativePath: file }) => file);
                 result.changedFiles = transaction.appliedFiles.slice(0, 100);
                 result.diagnostics = transaction.diagnostics.slice(0, 100);
-                if (autonomous) {
-                    result.artifacts = transaction.artifacts;
-                }
-                else {
-                    result.transactionId = transaction.transactionId;
-                    result.planHash = transaction.planHash;
-                    result.artifacts = [transactionResourceLink(transaction)];
-                    result.rollbackStatus = transaction.rollbackStatus;
-                }
+                result.artifacts = autonomousResultArtifacts(execution);
                 result.validation = transaction.validation;
                 result.blockers = transaction.diagnostics
                     .filter(({ severity }) => severity === 'error' || severity === 'blocker')
@@ -938,11 +950,11 @@ export function registerFocusTools(server, engine, context) {
                 await progress.report(5, 5, execution.outcome === 'applied'
                     ? 'Continuous focus rewrite complete'
                     : execution.outcome === 'unchanged'
-                        ? 'Continuous focus source already satisfied the plan'
-                        : 'Continuous focus transaction planned');
+                        ? 'Continuous focus content already satisfied the plan'
+                        : 'Continuous focus rewrite blocked');
                 return toolResult(result);
             }
-            const plan = input.plan;
+            const suppliedPlan = input.plan;
             if (createIfMissing &&
                 (!relativePath.toLowerCase().endsWith('.txt') ||
                     !underConfiguredRoot(relativePath, workspace.registration.roots.focus)))
@@ -960,6 +972,30 @@ export function registerFocusTools(server, engine, context) {
             const paletteImport = continuousPalettes(snapshot);
             if (imported !== undefined)
                 imported.result.plans = imported.result.plans.map((current) => linkContinuousFocusPalettes(current, paletteImport.palettes));
+            let compactPlanning;
+            let compactSourcePlan;
+            let plan;
+            if (suppliedPlan !== undefined) {
+                if (input.layoutMode === 'compact') {
+                    compactSourcePlan = suppliedPlan;
+                    compactPlanning = await compactFocusTreePlanAsync(suppliedPlan, {
+                        signal: progress.signal,
+                    });
+                    plan = compactPlanning.plan;
+                }
+                else {
+                    plan = suppliedPlan;
+                }
+            }
+            else {
+                if (imported === undefined)
+                    throw new ServiceError('FOCUS_COMPACT_SOURCE_REQUIRED', 'Plan-free compact reflow requires an existing national focus source', { relativePath });
+                compactSourcePlan = selectPlan(imported.result, input.treeId);
+                compactPlanning = await compactFocusTreePlanAsync(compactSourcePlan, {
+                    signal: progress.signal,
+                });
+                plan = compactPlanning.plan;
+            }
             const currentPlan = imported?.result.plans.find(({ id }) => id === plan.id);
             if (currentPlan === undefined && !createIfMissing) {
                 if (imported === undefined)
@@ -969,20 +1005,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],
@@ -996,7 +1031,9 @@ export function registerFocusTools(server, engine, context) {
             });
             const currentLayout = currentPlan === undefined
                 ? undefined
-                : await workbench.layoutAsync(currentPlan, { signal: progress.signal });
+                : currentPlan === compactSourcePlan && compactPlanning !== undefined
+                    ? compactPlanning.currentLayout
+                    : await workbench.layoutAsync(currentPlan, { signal: progress.signal });
             const currentDiagnostics = currentPlan === undefined || currentLayout === undefined
                 ? []
                 : workbench.lint(currentPlan, {
@@ -1022,6 +1059,11 @@ export function registerFocusTools(server, engine, context) {
                     importedPlanHash: proposedPlanHash,
                 },
             };
+            const proposedLayout = compactPlanning?.proposedLayout ??
+                (await workbench.layoutAsync(reviewPlan, { signal: progress.signal }));
+            if (input.layoutMode === 'compact') {
+                assertCompactLayoutQuality(currentLayout, proposedLayout);
+            }
             const proposed = await workbench.renderAndStore(workspaceId, reviewPlan, {
                 ...(context.principal === undefined ? {} : { principal: context.principal }),
                 index: snapshot.index,
@@ -1036,6 +1078,7 @@ export function registerFocusTools(server, engine, context) {
                 },
                 budget: renderBudget,
                 signal: progress.signal,
+                layout: proposedLayout,
             });
             const beforePng = currentRender?.png ??
                 (await createTransparentPng(proposed.bundle.width, proposed.bundle.height, 'new national focus baseline', renderBudget));
@@ -1078,13 +1121,14 @@ 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',
+                layout: proposed.layout,
                 ...(context.principal === undefined ? {} : { principal: context.principal }),
                 index: snapshot.index,
                 references: catalog,
@@ -1092,9 +1136,7 @@ export function registerFocusTools(server, engine, context) {
                 readDependencies: readDependenciesFromScannedFiles(snapshot.files),
                 signal: progress.signal,
             });
-            await progress.report(4, 5, autonomous
-                ? 'Applying and post-validating focus rewrite'
-                : 'Finalizing reviewed 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, {
@@ -1104,9 +1146,8 @@ export function registerFocusTools(server, engine, context) {
                 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 =
@@ -1114,9 +1155,7 @@ export function registerFocusTools(server, engine, context) {
                     ? 'FOCUS_CHANGES_APPLIED'
                     : execution.outcome === 'unchanged'
                         ? 'FOCUS_CHANGES_UNCHANGED'
-                        : transaction.validation.passed
-                            ? 'FOCUS_CHANGES_PLANNED'
-                            : 'FOCUS_CHANGES_BLOCKED';
+                        : 'FOCUS_CHANGES_BLOCKED';
             setInlineFilesScanned(result, [
                 ...new Set([
                     ...(focusFile === undefined ? [] : [focusFile.displayPath]),
@@ -1128,15 +1167,7 @@ export function registerFocusTools(server, engine, context) {
                 .map(({ relativePath: file }) => file);
             result.changedFiles = transaction.appliedFiles.slice(0, 100);
             result.diagnostics = transaction.diagnostics.slice(0, 100);
-            if (autonomous) {
-                result.artifacts = autonomousResultArtifacts(execution);
-            }
-            else {
-                result.transactionId = transaction.transactionId;
-                result.planHash = transaction.planHash;
-                result.artifacts = [transactionResourceLink(transaction)];
-                result.rollbackStatus = transaction.rollbackStatus;
-            }
+            result.artifacts = autonomousResultArtifacts(execution);
             result.validation = transaction.validation;
             result.blockers = transaction.diagnostics
                 .filter(({ severity }) => severity === 'error' || severity === 'blocker')
@@ -1148,8 +1179,8 @@ export function registerFocusTools(server, engine, context) {
             await progress.report(5, 5, execution.outcome === 'applied'
                 ? 'Focus rewrite complete'
                 : execution.outcome === 'unchanged'
-                    ? 'Focus source already satisfied the plan'
-                    : 'Focus transaction planned');
+                    ? 'Focus content already satisfied the plan'
+                    : 'Focus rewrite blocked');
             return toolResult(result);
         }
         catch (error) {
@@ -1157,4 +1188,3 @@ export function registerFocusTools(server, engine, context) {
         }
     });
 }
-//# sourceMappingURL=focus.js.map