hoi4-agent-tools 1.0.0 → 1.1.0

package/dist/hoi4_agent_tools/focus/limits.js

@@ -2,7 +2,7 @@ export const FOCUS_GRAPH_MAX_DEPTH = 256;
 export const FOCUS_GRAPH_MAX_NODES = 10_000;
 export const FOCUS_GRAPH_MAX_EDGES = 50_000;
 export const FOCUS_PAIR_COMPARISON_MAX = 2_000_000;
-export const FOCUS_LAYOUT_WORK_MAX = 500_000;
+export const FOCUS_LAYOUT_WORK_MAX = 8_000_000;
 export const FOCUS_LINT_WORK_MAX = 2_000_000;
 export const FOCUS_DIAGNOSTIC_MAX = 2_000;
 export const FOCUS_CYCLE_SAMPLE_MAX = 128;

package/dist/hoi4_agent_tools/focus/lint.js

@@ -2,7 +2,7 @@ import { compareCodeUnits } from '../core/canonical.js';
 import { sortDiagnostics } from '../core/diagnostics.js';
 import { DiagnosticCollector } from '../core/diagnostic-collector.js';
 import { ServiceError } from '../core/result.js';
-import { focusConnectorSegmentsProperlyCross, focusNodesVisiblyOverlap } from './geometry.js';
+import { flattenFocusConnectorCurve, focusConnectorCurve, focusConnectorPolylinesIntersect, focusNodesVisiblyOverlap, } from './geometry.js';
 import { layoutFocusTree } from './layout.js';
 import { FOCUS_CYCLE_SAMPLE_MAX, FOCUS_DIAGNOSTIC_MAX, FOCUS_GRAPH_MAX_DEPTH, FOCUS_GRAPH_MAX_EDGES, FOCUS_GRAPH_MAX_NODES, FOCUS_LINT_WORK_MAX, FOCUS_PAIR_COMPARISON_MAX, } from './limits.js';
 import { layoutNodeMap, } from './model.js';
@@ -641,7 +641,15 @@ export function lintFocusTree(plan, options = {}) {
         const child = positions.get(focus.id);
         return parent === undefined || child === undefined
             ? []
-            : [{ parentId, childId: focus.id, parent, child }];
+            : [
+                {
+                    parentId,
+                    childId: focus.id,
+                    parent,
+                    child,
+                    points: flattenFocusConnectorCurve(focusConnectorCurve(parent, child)),
+                },
+            ];
     }));
     const connectorPairCount = (connectors.length * (connectors.length - 1)) / 2;
     if (connectorPairCount > FOCUS_PAIR_COMPARISON_MAX) {
@@ -668,7 +676,7 @@ export function lintFocusTree(plan, options = {}) {
                     first.childId === second.childId) {
                     continue;
                 }
-                if (!focusConnectorSegmentsProperlyCross(first.parent, first.child, second.parent, second.child))
+                if (!focusConnectorPolylinesIntersect(first.points, second.points))
                     continue;
                 const focus = focuses.get(second.childId);
                 if (focus === undefined)

package/dist/hoi4_agent_tools/focus/planning.js

@@ -27,6 +27,7 @@ function planningNode(focus) {
         aiStrategyIds: [...focus.ai.strategyIds],
         ...(focus.payoff === undefined ? {} : { payoff: focus.payoff }),
         ...(focus.terminalKind === undefined ? {} : { terminalKind: focus.terminalKind }),
+        ...(focus.position.mode === 'auto' ? { autoPosition: structuredClone(focus.position) } : {}),
     };
 }
 export function createFocusPlanningSidecar(plan, sourceHash = plan.provenance.sourceHash) {
@@ -139,8 +140,12 @@ export function enrichFocusPlanFromSidecar(plan, sidecar) {
             delete focus.laneId;
         else
             focus.laneId = saved.laneId;
-        if (focus.position.mode !== 'auto')
+        if (saved.autoPosition !== undefined) {
+            focus.position = structuredClone(saved.autoPosition);
+        }
+        else if (focus.position.mode !== 'auto') {
             focus.position.pinned = saved.pinned;
+        }
         focus.visibility = saved.visibility;
         if (saved.reveal === undefined)
             delete focus.reveal;

package/dist/hoi4_agent_tools/focus/render.js

@@ -6,7 +6,7 @@ import { ServiceError } from '../core/result.js';
 import { DeterministicSvgTextRenderer } from '../core/svg-text.js';
 import { PACKAGE_VERSION } from '../version.js';
 import { compileFocusTreeWithSourceMap } from './compiler.js';
-import { FOCUS_HORIZONTAL_GRID_PIXELS, FOCUS_NODE_HEIGHT_PIXELS, FOCUS_NODE_WIDTH_PIXELS, FOCUS_VERTICAL_GRID_PIXELS, focusNodeOrigin, } from './geometry.js';
+import { FOCUS_HORIZONTAL_GRID_PIXELS, FOCUS_NODE_HEIGHT_PIXELS, FOCUS_NODE_WIDTH_PIXELS, FOCUS_VERTICAL_GRID_PIXELS, focusConnectorCurve, focusConnectorSvgPath, focusNodeOrigin, } from './geometry.js';
 import { createFocusPlanningSidecar, serializeFocusPlanningSidecar } from './planning.js';
 import { FOCUS_GRAPH_MAX_EDGES, FOCUS_GRAPH_MAX_NODES } from './lint.js';
 import { layoutNodeMap, } from './model.js';
@@ -173,6 +173,7 @@ function svgDocument(plan, layout, diagnostics, options) {
         node.id,
         focusNodeOrigin(node, minimumX, minimumY, padding, horizontal, vertical),
     ]));
+    const layoutNodes = new Map(nodes.map((node) => [node.id, node]));
     const focusMap = new Map(plan.focuses.map((focus) => [focus.id, focus]));
     const diagnosticMap = new Map();
     const toolText = new DeterministicSvgTextRenderer();
@@ -214,16 +215,19 @@ function svgDocument(plan, layout, diagnostics, options) {
         '<g id="prerequisites">',
     ];
     for (const edge of prerequisiteEdges) {
-        const parent = pixel.get(edge.parentId);
-        const child = pixel.get(edge.childId);
+        const parent = layoutNodes.get(edge.parentId);
+        const child = layoutNodes.get(edge.childId);
         if (parent === undefined || child === undefined)
             continue;
-        const startX = parent.x + nodeWidth / 2;
-        const startY = parent.y + nodeHeight;
-        const endX = child.x + nodeWidth / 2;
-        const endY = child.y;
-        const middleY = (startY + endY) / 2;
-        parts.push(`<path d="M ${startX} ${startY} C ${startX} ${middleY}, ${endX} ${middleY}, ${endX} ${endY}" fill="none" stroke="#8da2bc" stroke-width="2" marker-end="url(#arrow)" data-parent="${escapeXml(edge.parentId)}" data-child="${escapeXml(edge.childId)}" data-prerequisite-group="${edge.groupIndex}"/>`);
+        const curve = focusConnectorCurve(parent, child, {
+            horizontalSpacing: horizontal,
+            verticalSpacing: vertical,
+            nodeWidth,
+            nodeHeight,
+            originX: padding - minimumX * horizontal,
+            originY: padding - minimumY * vertical,
+        });
+        parts.push(`<path d="${focusConnectorSvgPath(curve)}" fill="none" stroke="#8da2bc" stroke-width="2" marker-end="url(#arrow)" data-parent="${escapeXml(edge.parentId)}" data-child="${escapeXml(edge.childId)}" data-prerequisite-group="${edge.groupIndex}"/>`);
     }
     parts.push('</g>', '<g id="mutual-exclusions">');
     for (const [leftId, rightId] of exclusionEdges) {
@@ -309,6 +313,7 @@ function svgDocument(plan, layout, diagnostics, options) {
             hash: layout.layoutHash,
             nodes,
             decisions: layout.decisions,
+            metrics: layout.metrics ?? null,
         },
         focuses: [...plan.focuses]
             .sort((left, right) => compareCodeUnits(left.id, right.id))

package/dist/hoi4_agent_tools/mcp/server/context-schemas.js

@@ -0,0 +1,8 @@
+import { z } from 'zod/v4';
+/**
+ * Keep a large nested payload schema out of tools/list while retaining its complete runtime parser.
+ * The MCP SDK publishes the input side of a pipe and executes both sides when a tool is called.
+ */
+export function compactValidatedInputSchema(schema, description) {
+    return z.unknown().describe(description).pipe(schema);
+}

package/dist/hoi4_agent_tools/mcp/server/create.js

@@ -12,7 +12,6 @@ export function createMcpServer(engine, context = {}) {
         websiteUrl: 'https://github.com/klimPaskov/hoi4-agent-tools',
     }, {
         capabilities: { logging: {} },
-        instructions: 'Use this server when a configured HOI4 mod needs a large national or continuous focus, scripted GUI, or map created, inspected, rendered, or cleaned up. Start with hoi4.mods, then use the matching inspect, render, and rewrite tools. Each rewrite performs the complete edit in one call. Read linked hoi4-agent:// artifact resources for complete plans, diagnostics, layouts, previews, and diffs; when a resource content item has a non-null continuationUri in its namespaced _meta byte-range record, follow it until null. Generated GUI renders are offline representations, never game screenshots.',
     });
     registerModsTool(server, engine, context);
     registerFocusTools(server, engine, context);

package/dist/hoi4_agent_tools/mcp/server/result.js

@@ -3,15 +3,15 @@ import { canonicalJson } from '../../core/canonical.js';
 import { ServiceError } from '../../core/result.js';
 import { diagnosticSchema } from '../../schemas/common.js';
 import { artifactLinkSchema, validationSummarySchema } from '../../schemas/transaction.js';
-export const MAX_INLINE_FILES_SCANNED = 1_000;
-export const MAX_INLINE_PROPOSED_FILES = 1_000;
-export const MAX_INLINE_CHANGED_FILES = 1_000;
-export const MAX_INLINE_DIAGNOSTICS = 100;
-export const MAX_INLINE_ARTIFACT_LINKS = 512;
-export const MAX_INLINE_BLOCKERS = 100;
+export const MAX_INLINE_FILES_SCANNED = 64;
+export const MAX_INLINE_PROPOSED_FILES = 64;
+export const MAX_INLINE_CHANGED_FILES = 64;
+export const MAX_INLINE_DIAGNOSTICS = 20;
+export const MAX_INLINE_ARTIFACT_LINKS = 32;
+export const MAX_INLINE_BLOCKERS = 20;
 export const MAX_INLINE_VALIDATION_CHECKS = 5;
 // Leave headroom for the enclosing JSON-RPC response and transport metadata.
-export const MAX_TOOL_RESULT_BYTES = 500_000;
+export const MAX_TOOL_RESULT_BYTES = 32_768;
 const deferredFilesDiagnostic = Symbol('deferredFilesDiagnostic');
 const operationResultBaseSchema = z
     .object({
@@ -39,15 +39,43 @@ export const operationResultSchema = operationResultBaseSchema
     .extend({ data: z.record(z.string().max(256), z.unknown()) })
     .strict();
 const emptyToolDataSchema = z.object({}).strict();
+const compactPublicOperationResultSchema = z
+    .object({
+    status: z.enum(['ok', 'blocked', 'error']),
+    code: z.string().max(256),
+    workspaceId: z.string().max(64),
+    filesScanned: z.array(z.string().max(4096)).max(MAX_INLINE_FILES_SCANNED),
+    proposedFiles: z.array(z.string().max(1024)).max(MAX_INLINE_PROPOSED_FILES),
+    changedFiles: z.array(z.string().max(1024)).max(MAX_INLINE_CHANGED_FILES),
+    diagnostics: z.array(z.unknown()).max(MAX_INLINE_DIAGNOSTICS),
+    artifacts: z.array(z.unknown()).max(MAX_INLINE_ARTIFACT_LINKS),
+    validation: z
+        .object({
+        passed: z.boolean(),
+        checks: z.array(z.unknown()).max(MAX_INLINE_VALIDATION_CHECKS),
+    })
+        .strict(),
+    blockers: z.array(z.unknown()).max(MAX_INLINE_BLOCKERS),
+    data: z.record(z.string().max(256), z.unknown()),
+})
+    .strict()
+    .describe('Stable operation envelope; data is tool-specific and artifacts link bulk evidence.');
 /**
- * Advertise an exact success payload for one tool while retaining the shared empty error payload.
- * The generic operation-result schema remains available for stored envelopes, but is never used as
- * a public tool output contract.
+ * Advertise one compact operation envelope while retaining exact per-tool runtime validation.
+ * The generic operation-result schema remains available for stored envelopes.
  */
 export function strictOperationResultSchema(successDataSchema) {
-    return operationResultBaseSchema
+    const exactSchema = operationResultBaseSchema
         .extend({ data: z.union([emptyToolDataSchema, successDataSchema]) })
         .strict();
+    return compactPublicOperationResultSchema.superRefine((value, context) => {
+        const parsed = exactSchema.safeParse(value);
+        if (parsed.success)
+            return;
+        for (const issue of parsed.error.issues) {
+            context.addIssue({ code: 'custom', path: issue.path, message: issue.message });
+        }
+    });
 }
 /** Keep source inventories compact; complete inventories belong in linked resources. */
 export function setInlineFilesScanned(result, files) {
@@ -82,11 +110,14 @@ function preserveDeferredFilesDiagnostic(result) {
     };
 }
 function boundedResult(result, actualBytes) {
+    const hasLinkedEvidence = result.artifacts.length > 0;
     const truncationDiagnostic = {
         code: 'MCP_RESPONSE_TRUNCATED',
         severity: 'warning',
         category: 'configuration',
-        message: 'Tool output exceeded the wire budget; complete details remain available through linked resources',
+        message: hasLinkedEvidence
+            ? 'Tool output exceeded the wire budget; inspect the linked evidence for complete details'
+            : 'Tool output exceeded the wire budget; nonessential inline details were omitted',
         details: { actualBytes, maxBytes: MAX_TOOL_RESULT_BYTES },
     };
     return {
@@ -106,7 +137,9 @@ function boundedResult(result, actualBytes) {
             : [
                 {
                     code: 'MCP_RESPONSE_TRUNCATED',
-                    message: 'Tool output exceeded the wire budget; inspect the linked resource for complete details',
+                    message: hasLinkedEvidence
+                        ? 'Tool output exceeded the wire budget; inspect the linked evidence for complete details'
+                        : 'Tool output exceeded the wire budget; nonessential inline details were omitted',
                     details: {
                         actualBytes,
                         maxBytes: MAX_TOOL_RESULT_BYTES,
@@ -196,32 +229,60 @@ function jsonBytesWithin(value, budget) {
     return visit(value);
 }
 function compactDetails(details) {
-    return jsonBytesWithin(details, 4_096) ? details : { truncated: true };
+    return jsonBytesWithin(details, 2_048) ? details : { truncated: true };
 }
 function compactDescriptions(result) {
     const compactLocation = (location) => location === undefined
         ? undefined
         : {
             ...location,
-            path: location.path.slice(0, 4_096),
-            ...(location.symbol === undefined ? {} : { symbol: location.symbol.slice(0, 1_024) }),
+            path: location.path.slice(0, 1_024),
+            ...(location.symbol === undefined ? {} : { symbol: location.symbol.slice(0, 256) }),
         };
-    const validationTruncation = result.validation.checks.length > MAX_INLINE_VALIDATION_CHECKS
-        ? {
-            code: 'MCP_INLINE_VALIDATION_TRUNCATED',
-            severity: 'info',
-            category: 'configuration',
-            message: `Inline validation is limited to ${MAX_INLINE_VALIDATION_CHECKS} checks; use the linked artifact for the complete validation record`,
-            details: {
-                total: result.validation.checks.length,
-                returned: MAX_INLINE_VALIDATION_CHECKS,
-            },
-        }
-        : undefined;
-    const compactDiagnostics = result.diagnostics.map((diagnostic) => ({
+    const collectionTotals = {
+        filesScanned: result.filesScanned.length,
+        proposedFiles: result.proposedFiles.length,
+        changedFiles: result.changedFiles.length,
+        diagnostics: result.diagnostics.length,
+        artifacts: result.artifacts.length,
+        validationChecks: result.validation.checks.length,
+        blockers: result.blockers.length,
+    };
+    const collectionLimits = {
+        filesScanned: MAX_INLINE_FILES_SCANNED,
+        proposedFiles: MAX_INLINE_PROPOSED_FILES,
+        changedFiles: MAX_INLINE_CHANGED_FILES,
+        diagnostics: MAX_INLINE_DIAGNOSTICS,
+        artifacts: MAX_INLINE_ARTIFACT_LINKS,
+        validationChecks: MAX_INLINE_VALIDATION_CHECKS,
+        blockers: MAX_INLINE_BLOCKERS,
+    };
+    const truncatedCollections = Object.fromEntries(Object.entries(collectionTotals).flatMap(([name, total]) => {
+        const limit = collectionLimits[name];
+        return total > limit ? [[name, { total, limit }]] : [];
+    }));
+    if (Object.keys(truncatedCollections).length > 0 &&
+        result.diagnostics.length > MAX_INLINE_DIAGNOSTICS - 1) {
+        truncatedCollections.diagnostics = {
+            total: result.diagnostics.length,
+            limit: MAX_INLINE_DIAGNOSTICS - 1,
+        };
+    }
+    const needsTruncationDiagnostic = Object.keys(truncatedCollections).length > 0;
+    const diagnosticSlots = Math.max(0, MAX_INLINE_DIAGNOSTICS - (needsTruncationDiagnostic ? 1 : 0));
+    const hardDiagnostics = result.diagnostics.filter(({ severity }) => severity === 'error' || severity === 'blocker');
+    const priorityDiagnostics = result.diagnostics.filter(({ code, severity }) => severity === 'error' || severity === 'blocker' || code === 'MCP_INLINE_FILES_TRUNCATED');
+    const otherDiagnostics = result.diagnostics.filter((diagnostic) => !priorityDiagnostics.includes(diagnostic));
+    const retainedPriorityDiagnostics = priorityDiagnostics.slice(0, diagnosticSlots);
+    const retainedDiagnostics = [
+        ...retainedPriorityDiagnostics,
+        ...otherDiagnostics.slice(0, diagnosticSlots - retainedPriorityDiagnostics.length),
+    ];
+    const omittedHardDiagnostics = hardDiagnostics.filter((diagnostic) => !retainedDiagnostics.includes(diagnostic)).length;
+    const compactDiagnostics = retainedDiagnostics.map((diagnostic) => ({
         ...diagnostic,
         code: diagnostic.code.slice(0, 256),
-        message: diagnostic.message.slice(0, 4_096),
+        message: diagnostic.message.slice(0, 1_024),
         ...(diagnostic.operationId === undefined
             ? {}
             : { operationId: diagnostic.operationId.slice(0, 256) }),
@@ -231,35 +292,53 @@ function compactDescriptions(result) {
         ...(diagnostic.related === undefined
             ? {}
             : {
-                related: diagnostic.related.slice(0, 5).map((location) => compactLocation(location)),
+                related: diagnostic.related.slice(0, 3).map((location) => compactLocation(location)),
             }),
         ...(diagnostic.details === undefined ? {} : { details: compactDetails(diagnostic.details) }),
     }));
+    const truncationDiagnostic = needsTruncationDiagnostic
+        ? {
+            code: 'MCP_INLINE_COLLECTIONS_TRUNCATED',
+            severity: omittedHardDiagnostics > 0 ? 'blocker' : 'info',
+            category: 'configuration',
+            message: result.artifacts.length > 0
+                ? 'Large collections were bounded inline; linked resources retain bulk evidence'
+                : 'Large collections were bounded inline',
+            details: {
+                collections: truncatedCollections,
+                diagnosticsReturned: retainedDiagnostics.length,
+                omittedHardDiagnostics,
+            },
+        }
+        : undefined;
     return {
         ...result,
-        diagnostics: validationTruncation === undefined
+        filesScanned: result.filesScanned.slice(0, MAX_INLINE_FILES_SCANNED),
+        proposedFiles: result.proposedFiles.slice(0, MAX_INLINE_PROPOSED_FILES),
+        changedFiles: result.changedFiles.slice(0, MAX_INLINE_CHANGED_FILES),
+        diagnostics: truncationDiagnostic === undefined
             ? compactDiagnostics
-            : [validationTruncation, ...compactDiagnostics].slice(0, MAX_INLINE_DIAGNOSTICS),
+            : [truncationDiagnostic, ...compactDiagnostics],
+        artifacts: result.artifacts.slice(0, MAX_INLINE_ARTIFACT_LINKS).map((artifact) => ({
+            ...artifact,
+            ...(artifact.description === undefined
+                ? {}
+                : { description: artifact.description.slice(0, 256) }),
+        })),
         validation: {
             ...result.validation,
             checks: result.validation.checks.slice(0, MAX_INLINE_VALIDATION_CHECKS).map((check) => ({
                 ...check,
                 id: check.id.slice(0, 256),
-                message: check.message.slice(0, 4_096),
+                message: check.message.slice(0, 1_024),
             })),
         },
-        blockers: result.blockers.map((blocker) => ({
+        blockers: result.blockers.slice(0, MAX_INLINE_BLOCKERS).map((blocker) => ({
             ...blocker,
             code: blocker.code.slice(0, 256),
-            message: blocker.message.slice(0, 4_096),
+            message: blocker.message.slice(0, 1_024),
             ...(blocker.details === undefined ? {} : { details: compactDetails(blocker.details) }),
         })),
-        artifacts: result.artifacts.map((artifact) => ({
-            ...artifact,
-            ...(artifact.description === undefined
-                ? {}
-                : { description: artifact.description.slice(0, 1_024) }),
-        })),
     };
 }
 function buildToolResult(selected) {
@@ -286,23 +365,15 @@ function buildToolResult(selected) {
 }
 export function toolResult(result) {
     const completeResult = preserveDeferredFilesDiagnostic(result);
-    const exceedsArrayBudget = completeResult.filesScanned.length > MAX_INLINE_FILES_SCANNED ||
-        completeResult.proposedFiles.length > MAX_INLINE_PROPOSED_FILES ||
-        completeResult.changedFiles.length > MAX_INLINE_CHANGED_FILES ||
-        completeResult.diagnostics.length > MAX_INLINE_DIAGNOSTICS ||
-        completeResult.artifacts.length > MAX_INLINE_ARTIFACT_LINKS ||
-        completeResult.blockers.length > MAX_INLINE_BLOCKERS;
     const compact = compactDescriptions(completeResult);
     const estimatedBytes = jsonBytesWithin(compact, MAX_TOOL_RESULT_BYTES)
         ? Buffer.byteLength(canonicalJson(compact), 'utf8')
         : MAX_TOOL_RESULT_BYTES + 1;
-    const selected = estimatedBytes > MAX_TOOL_RESULT_BYTES || exceedsArrayBudget
-        ? boundedResult(completeResult, estimatedBytes)
-        : compact;
+    const selected = estimatedBytes > MAX_TOOL_RESULT_BYTES ? boundedResult(compact, estimatedBytes) : compact;
     let output = buildToolResult(selected);
     const wireBytes = Buffer.byteLength(canonicalJson(output), 'utf8');
     if (wireBytes > MAX_TOOL_RESULT_BYTES) {
-        output = buildToolResult(boundedResult(completeResult, wireBytes));
+        output = buildToolResult(boundedResult(compact, wireBytes));
     }
     const finalBytes = Buffer.byteLength(canonicalJson(output), 'utf8');
     if (finalBytes > MAX_TOOL_RESULT_BYTES) {

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

@@ -6,14 +6,15 @@ 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, focusPlanHash, focusPresentationEvidence, focusPlanningSidecarPath, importContinuousFocusPalettes, importFocusTrees, linkContinuousFocusPalettes, parseFocusPlanningSidecar, renderContinuousFocusPalette, renderFocusTree, resolveFocusPresentation, enrichFocusPlanFromSidecar, } from '../../focus/index.js';
-import { continuousFocusPaletteSchema, 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 } 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({
@@ -33,6 +34,7 @@ const focusInspectOutputSchema = strictOperationResultSchema(z
         resolvedTitleCount: nonNegativeIntegerSchema,
         layoutHash: sha256Schema,
         layoutDecisionCount: nonNegativeIntegerSchema,
+        layoutMetrics: focusLayoutMetricsSchema,
         diagnosticCount: nonNegativeIntegerSchema,
     })
         .strict())
@@ -114,6 +116,7 @@ const focusPlanOutputSchema = strictOperationResultSchema(z.discriminatedUnion('
     })
         .strict(),
 ]));
+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(),
@@ -208,7 +211,9 @@ const focusPlanInput = z
     mode: z.enum(['national', 'continuous']).optional(),
     workspaceId: workspaceIdSchema,
     relativePath: workspaceRelativePathSchema,
-    plan: z.union([focusTreePlanSchema, continuousFocusPaletteSchema]),
+    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(),
@@ -223,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],
@@ -244,6 +267,35 @@ const focusPlanInput = z
                 });
         }
     }
+    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,
@@ -584,6 +636,7 @@ export function registerFocusTools(server, engine, context) {
                     resolvedTitleCount: plan.focuses.filter(({ id }) => presentation.entries[id]?.titleSourceLocation !== undefined).length,
                     layoutHash: layout.layoutHash,
                     layoutDecisionCount: layout.decisions.length,
+                    layoutMetrics: layout.metrics,
                     diagnosticCount,
                 })),
                 palettes: [],
@@ -727,7 +780,7 @@ export function registerFocusTools(server, engine, context) {
     });
     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.',
+        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: {
@@ -901,7 +954,7 @@ export function registerFocusTools(server, engine, context) {
                         : '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)))
@@ -919,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)
@@ -954,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, {
@@ -980,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,
@@ -994,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));
@@ -1043,6 +1128,7 @@ export function registerFocusTools(server, engine, context) {
                 plan,
                 createIfMissing,
                 authority: 'plan',
+                layout: proposed.layout,
                 ...(context.principal === undefined ? {} : { principal: context.principal }),
                 index: snapshot.index,
                 references: catalog,