hoi4-agent-tools 2.3.10 → 2.3.12

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 2.3.12 - 2026-08-05
+
+- Made compact focus rewrites choose among preservation, row compression, linear-chain repair, sibling balancing, and combined strategies instead of forcing one aggressive transformation.
+- Limited rewrite rejection to invalid geometry while retaining long paths, fake complexity, branch balance, and compactness as prioritized cleanup objectives.
+- Added whole-cohort sibling refinement, collision-aware incremental placement, stable repeat rewrites, and regression coverage through the public Ireland and 1,024-focus MCP workflows.
+
+## 2.3.11 - 2026-08-05
+
+- Made compact focus rewrites straighten offset linear chains and reject artificial staircase or zigzag geometry.
+- Tightened compact layout acceptance so long connectors, connector paths through focuses, crossings, asymmetric sibling groups, and off-anchor branches cannot survive a successful cleanup.
+- Kept the stricter rewrite deterministic and verified it through the public 1,024-focus MCP workflow.
+
 ## 2.3.10 - 2026-08-04
 
 - Routed focus operations to the unique discovered mod containing a requested source when a stale client root points at another mod.

package/dist/hoi4_agent_tools/focus/compact.js

@@ -10,28 +10,23 @@ const LARGE_COMPACT_SCALES = [0.55, 0.6, 0.7, 0.8];
 const COMPACT_LAYOUT_WORK_MAX = FOCUS_LAYOUT_WORK_MAX * 10;
 const COMPACT_HARD_DIAGNOSTICS = new Set([
     'FOCUS_LAYOUT_CONNECTOR_CROSSING_UNSATISFIED',
+    'FOCUS_LAYOUT_CONNECTOR_THROUGH_NODE',
     'FOCUS_LAYOUT_COORDINATE_CONFLICT',
     'FOCUS_LAYOUT_LANE_BOUNDS_UNSATISFIED',
     'FOCUS_LAYOUT_MUTUAL_EXCLUSION_SPACING_UNSATISFIED',
+    'FOCUS_LAYOUT_PARENT_NOT_ABOVE',
     'FOCUS_LAYOUT_PARENT_ORDER_UNSATISFIED',
     'FOCUS_LAYOUT_SAME_ROW_SPACING_UNSATISFIED',
     'FOCUS_LAYOUT_VISIBLE_OVERLAP',
 ]);
-function compactLimits(focusCount, connectorCount) {
-    const graphScale = Math.sqrt(Math.max(1, focusCount));
-    const maximumHorizontalSpan = Math.max(14, Math.ceil(graphScale * 3));
-    const maximumVerticalSpan = Math.max(4, Math.ceil(Math.log2(Math.max(2, focusCount))));
-    return {
-        maximumColumns: Math.max(16, Math.ceil(graphScale * 5)),
-        maximumHorizontalSpan,
-        maximumVerticalSpan,
-        maximumManhattanSpan: maximumHorizontalSpan + maximumVerticalSpan,
-        maximumLongConnectors: Math.ceil(connectorCount * 0.05),
-        maximumNodeIntersections: Math.ceil(connectorCount * 0.12),
-        maximumSiblingDeviation: Math.max(2, Math.ceil(graphScale * 2)),
-        maximumTotalSiblingDeviation: Math.max(4, Math.ceil(focusCount * 0.5)),
-    };
-}
+const COMPACT_AESTHETIC_DIAGNOSTICS = new Set([
+    'FOCUS_LAYOUT_LINEAR_DETOUR',
+    'FOCUS_LAYOUT_LONG_CONNECTOR',
+    'FOCUS_LAYOUT_SIBLING_ANCHOR_DEVIATION',
+    'FOCUS_LAYOUT_SIBLING_ASYMMETRY',
+    'FOCUS_LAYOUT_STAIRCASE_CHAIN',
+    'FOCUS_LAYOUT_ZIGZAG_CHAIN',
+]);
 function requiredMetrics(layout) {
     if (layout.metrics !== undefined)
         return layout.metrics;
@@ -39,79 +34,16 @@ function requiredMetrics(layout) {
 }
 function absoluteCompactRegressions(layout) {
     const metrics = requiredMetrics(layout);
-    const limits = compactLimits(layout.nodes.length, metrics.connectors.count);
     return [
         ...(layout.diagnostics.some(({ code }) => COMPACT_HARD_DIAGNOSTICS.has(code))
             ? ['hardLayoutDiagnostics']
             : []),
         ...(metrics.connectors.crossingCount > 0 ? ['connectorCrossingCount'] : []),
-        ...(metrics.connectors.nodeIntersectionCount > limits.maximumNodeIntersections
-            ? ['connectorNodeIntersectionBudget']
-            : []),
+        ...(metrics.connectors.nodeIntersectionCount > 0 ? ['connectorNodeIntersections'] : []),
         ...(metrics.spacing.tooCloseSameRowPairCount > 0 ? ['sameRowSpacing'] : []),
-        ...(metrics.symmetry.maximumSiblingDeviation > 1 ? ['siblingMirrorDeviation'] : []),
-        ...(metrics.symmetry.totalSiblingDeviation > metrics.symmetry.siblingCohortCount
-            ? ['totalSiblingMirrorDeviation']
-            : []),
-        ...(metrics.symmetry.maximumSiblingAnchorDeviation > limits.maximumSiblingDeviation
-            ? ['maximumSiblingDeviationBudget']
-            : []),
-        ...(metrics.symmetry.totalSiblingAnchorDeviation > limits.maximumTotalSiblingDeviation
-            ? ['totalSiblingDeviationBudget']
-            : []),
         ...(metrics.symmetry.boundingCenterOffsetTwice > 1 ? ['boundingCenter'] : []),
-        ...(metrics.bounds.columnCount > limits.maximumColumns ? ['columnBudget'] : []),
-        ...(metrics.connectors.maximumHorizontalSpan > limits.maximumHorizontalSpan
-            ? ['maximumHorizontalConnectorBudget']
-            : []),
-        ...(metrics.connectors.maximumVerticalSpan > limits.maximumVerticalSpan
-            ? ['maximumVerticalConnectorBudget']
-            : []),
-        ...(metrics.connectors.maximumManhattanSpan > limits.maximumManhattanSpan
-            ? ['maximumManhattanConnectorBudget']
-            : []),
-        ...(metrics.connectors.longConnectorCount > limits.maximumLongConnectors
-            ? ['longConnectorBudget']
-            : []),
-    ];
-}
-function relativeCompactRegressions(current, proposed) {
-    const before = requiredMetrics(current);
-    const after = requiredMetrics(proposed);
-    return [
-        ...(after.connectors.crossingCount > before.connectors.crossingCount
-            ? ['connectorCrossingCount']
-            : []),
-        ...(after.connectors.nodeIntersectionCount > before.connectors.nodeIntersectionCount
-            ? ['connectorNodeIntersectionCount']
-            : []),
-        ...(after.connectors.maximumHorizontalSpan > before.connectors.maximumHorizontalSpan
-            ? ['maximumHorizontalConnectorSpan']
-            : []),
-        ...(after.connectors.maximumVerticalSpan > before.connectors.maximumVerticalSpan
-            ? ['maximumVerticalConnectorSpan']
-            : []),
-        ...(after.connectors.maximumManhattanSpan > before.connectors.maximumManhattanSpan
-            ? ['maximumManhattanConnectorSpan']
-            : []),
-        ...(after.connectors.longConnectorCount > before.connectors.longConnectorCount
-            ? ['longConnectorCount']
-            : []),
-        ...(after.connectors.totalHorizontalSpan > before.connectors.totalHorizontalSpan
-            ? ['totalHorizontalConnectorSpan']
-            : []),
-        ...(after.connectors.totalManhattanSpan > before.connectors.totalManhattanSpan
-            ? ['totalManhattanConnectorSpan']
-            : []),
-        ...(after.bounds.columnCount > before.bounds.columnCount ? ['columnCount'] : []),
-        ...(after.bounds.rowCount > before.bounds.rowCount ? ['rowCount'] : []),
     ];
 }
-function compactShape(plan, layout) {
-    return (plan.focuses.every(({ position }) => position.mode === 'auto') &&
-        plan.laneGroups.every(({ minimumX, maximumX }) => minimumX === undefined && maximumX === undefined) &&
-        absoluteCompactRegressions(layout).length === 0);
-}
 function prerequisiteIds(plan, focusId) {
     const focus = plan.focuses.find(({ id }) => id === focusId);
     return (focus?.prerequisites.groups
@@ -161,11 +93,8 @@ function compactStructuralAnchorX(plan, focus, parents, preferredX, laneBases) {
 function mirrorSiblingCohorts(plan, preferredX, preferredY) {
     const cohorts = new Map();
     const laneBases = compactLaneBases(plan);
-    const childCounts = new Map();
     for (const focus of plan.focuses) {
         const parents = prerequisiteIds(plan, focus.id);
-        for (const parentId of parents)
-            childCounts.set(parentId, (childCounts.get(parentId) ?? 0) + 1);
         const key = JSON.stringify([
             parents.length === 0 ? focusLaneId(plan, focus) : null,
             parents,
@@ -184,11 +113,6 @@ function mirrorSiblingCohorts(plan, preferredX, preferredY) {
         const focus = plan.focuses.find(({ id }) => id === cohort[0]);
         if (focus === undefined)
             continue;
-        // A leaf fan can be mirrored directly around its structural parent. For
-        // rooted subtrees, moving only the entry focuses would push the long
-        // connectors into their descendants; keep the subtree envelope's center
-        // until the bounded gateway refinement can move the common parent.
-        const leafFan = cohort.every((focusId) => (childCounts.get(focusId) ?? 0) === 0);
         const mirroredAt = (centerTwice) => {
             const mirrored = [...coordinates];
             for (let index = 0; index < pairCount; index += 1) {
@@ -209,25 +133,42 @@ function mirrorSiblingCohorts(plan, preferredX, preferredY) {
             }
             return mirrored;
         };
-        const selfCenterTwice = (coordinates[0] ?? 0) + (coordinates.at(-1) ?? 0);
         const anchorCenterTwice = 2 *
             compactStructuralAnchorX(plan, focus, prerequisiteIds(plan, focus.id), preferredX, laneBases);
-        let mirrored = mirroredAt(leafFan ? anchorCenterTwice : selfCenterTwice);
-        if (leafFan) {
-            const cohortIds = new Set(cohort);
-            const y = preferredY.get(cohort[0] ?? '');
-            const otherCoordinates = plan.focuses.flatMap((candidate) => !cohortIds.has(candidate.id) && preferredY.get(candidate.id) === y
-                ? [preferredX.get(candidate.id) ?? 0]
-                : []);
-            if (mirrored.some((coordinate) => otherCoordinates.some((otherCoordinate) => Math.abs(coordinate - otherCoordinate) < COMPACT_SAME_ROW_SPACING))) {
-                mirrored = mirroredAt(selfCenterTwice);
-            }
-        }
+        const mirrored = mirroredAt(anchorCenterTwice);
         for (const [index, focusId] of cohort.entries())
             preferredX.set(focusId, mirrored[index] ?? 0);
     }
 }
-function compactCandidate(plan, layout, scale, compressRows) {
+function straightenLinearChains(plan, preferredX, preferredY) {
+    const parentIds = new Map(plan.focuses.map((focus) => [focus.id, prerequisiteIds(plan, focus.id)]));
+    const childIds = new Map();
+    for (const [focusId, parents] of parentIds) {
+        for (const parentId of parents) {
+            const children = childIds.get(parentId) ?? [];
+            children.push(focusId);
+            childIds.set(parentId, children);
+        }
+    }
+    const ordered = [...plan.focuses].sort((left, right) => (preferredY.get(left.id) ?? 0) - (preferredY.get(right.id) ?? 0) ||
+        compareCodeUnits(left.id, right.id));
+    for (const focus of ordered) {
+        const parents = parentIds.get(focus.id) ?? [];
+        if (parents.length !== 1)
+            continue;
+        const parentId = parents[0];
+        if (parentId === undefined || (childIds.get(parentId)?.length ?? 0) !== 1)
+            continue;
+        const parentX = preferredX.get(parentId);
+        const parentY = preferredY.get(parentId);
+        if (parentX === undefined || parentY === undefined)
+            continue;
+        preferredX.set(focus.id, parentX);
+        preferredY.set(focus.id, parentY + 1);
+    }
+}
+function compactCandidate(plan, layout, strategy) {
+    const { scale, compressRows, mirrorSiblings, straightenChains } = strategy;
     const minimumX = Math.min(...layout.nodes.map(({ x }) => x));
     const maximumX = Math.max(...layout.nodes.map(({ x }) => x));
     const minimumY = Math.min(...layout.nodes.map(({ y }) => y));
@@ -258,7 +199,10 @@ function compactCandidate(plan, layout, scale, compressRows) {
         for (const [index, node] of row.entries())
             preferredX.set(node.id, (placed[index] ?? 0) + drift);
     }
-    mirrorSiblingCohorts(plan, preferredX, preferredY);
+    if (mirrorSiblings)
+        mirrorSiblingCohorts(plan, preferredX, preferredY);
+    if (straightenChains)
+        straightenLinearChains(plan, preferredX, preferredY);
     const compacted = structuredClone(plan);
     compacted.laneGroups = compacted.laneGroups.map(({ id, label, order }) => ({
         id,
@@ -278,14 +222,24 @@ function compactCandidate(plan, layout, scale, compressRows) {
 }
 function compactScore(layout) {
     const metrics = requiredMetrics(layout);
+    const hardDiagnosticCount = layout.diagnostics.filter(({ code }) => COMPACT_HARD_DIAGNOSTICS.has(code)).length;
+    const aestheticDiagnosticCount = layout.diagnostics.filter(({ code }) => COMPACT_AESTHETIC_DIAGNOSTICS.has(code)).length;
     return [
+        hardDiagnosticCount,
+        metrics.connectors.crossingCount,
+        metrics.connectors.nodeIntersectionCount,
+        metrics.spacing.tooCloseSameRowPairCount,
+        aestheticDiagnosticCount,
         metrics.connectors.longConnectorCount,
-        metrics.connectors.maximumHorizontalSpan,
+        metrics.symmetry.asymmetricSiblingCohortCount,
+        metrics.symmetry.offAnchorSiblingCohortCount,
+        metrics.symmetry.totalSiblingDeviation,
+        metrics.symmetry.totalSiblingAnchorDeviation,
+        metrics.bounds.rowCount,
         metrics.bounds.columnCount,
-        metrics.connectors.nodeIntersectionCount,
+        metrics.connectors.maximumHorizontalSpan,
         metrics.connectors.totalHorizontalSpan,
         metrics.connectors.maximumManhattanSpan,
-        metrics.bounds.rowCount,
         metrics.connectors.totalVerticalSpan,
         layout.layoutHash,
     ];
@@ -311,44 +265,60 @@ function compactScales(focusCount) {
                 ? [0.55, 0.65, 0.75]
                 : [0.65];
 }
+function compactStrategies(focusCount) {
+    const preservationStrategies = [
+        { scale: 1, compressRows: false, mirrorSiblings: false, straightenChains: false },
+        { scale: 1, compressRows: true, mirrorSiblings: false, straightenChains: false },
+        { scale: 1, compressRows: false, mirrorSiblings: false, straightenChains: true },
+        { scale: 1, compressRows: false, mirrorSiblings: true, straightenChains: false },
+    ];
+    const compactStrategies = compactScales(focusCount).flatMap((scale) => [
+        { scale, compressRows: false, mirrorSiblings: true, straightenChains: true },
+        { scale, compressRows: true, mirrorSiblings: true, straightenChains: true },
+    ]);
+    return [...preservationStrategies, ...compactStrategies];
+}
+function needsPresentationNormalization(plan) {
+    return (plan.focuses.some(({ position }) => position.mode !== 'auto') ||
+        plan.laneGroups.some(({ minimumX, maximumX }) => minimumX !== undefined || maximumX !== undefined));
+}
 /**
  * Produces a gameplay-neutral compact-reflow plan. Several deterministic
- * compression candidates are measured with the same layout engine; only a
- * centered, crossing-free, evenly spaced, branch-balanced candidate that
- * stays within absolute and source-relative connector budgets can win.
+ * repair and compression candidates are measured with the same layout engine.
+ * Invalid geometry cannot win; aesthetic tradeoffs are resolved by the score.
  */
 export function compactFocusTreePlan(plan) {
-    const currentLayout = layoutFocusTree(plan);
-    if (compactShape(plan, currentLayout)) {
-        const stable = structuredClone(plan);
-        stable.provenance.importedPlanHash = focusPlanHash(stable);
-        return stable;
-    }
-    const scales = compactScales(plan.focuses.length);
+    const currentLayout = layoutFocusTree(plan, { aggressiveAestheticRepair: true });
+    const normalizedPlan = needsPresentationNormalization(plan)
+        ? compactCandidate(plan, currentLayout, {
+            scale: 1,
+            compressRows: false,
+            mirrorSiblings: false,
+            straightenChains: false,
+        })
+        : plan;
+    const normalizedLayout = normalizedPlan === plan
+        ? currentLayout
+        : layoutFocusTree(normalizedPlan, { aggressiveAestheticRepair: true });
     let selected;
     let fallback;
-    for (const scale of scales) {
-        for (const compressRows of plan.focuses.length <= 500 ? [false, true] : [false]) {
-            const candidate = compactCandidate(plan, currentLayout, scale, compressRows);
-            let layout;
-            try {
-                layout = layoutFocusTree(candidate);
-            }
-            catch (error) {
-                if (error instanceof ServiceError && error.code === 'FOCUS_LAYOUT_WORK_BUDGET_BLOCKED')
-                    continue;
-                throw error;
-            }
-            if (fallback === undefined ||
-                betterScore(compactScore(layout), compactScore(fallback.layout)))
-                fallback = { plan: candidate, layout };
-            if (absoluteCompactRegressions(layout).length > 0 ||
-                relativeCompactRegressions(currentLayout, layout).length > 0)
+    for (const strategy of compactStrategies(plan.focuses.length)) {
+        const candidate = compactCandidate(normalizedPlan, normalizedLayout, strategy);
+        let layout;
+        try {
+            layout = layoutFocusTree(candidate, { aggressiveAestheticRepair: true });
+        }
+        catch (error) {
+            if (error instanceof ServiceError && error.code === 'FOCUS_LAYOUT_WORK_BUDGET_BLOCKED')
                 continue;
-            if (selected === undefined ||
-                betterScore(compactScore(layout), compactScore(selected.layout)))
-                selected = { plan: candidate, layout };
+            throw error;
         }
+        if (fallback === undefined || betterScore(compactScore(layout), compactScore(fallback.layout)))
+            fallback = { plan: candidate, layout };
+        if (absoluteCompactRegressions(layout).length > 0)
+            continue;
+        if (selected === undefined || betterScore(compactScore(layout), compactScore(selected.layout)))
+            selected = { plan: candidate, layout };
     }
     if (selected !== undefined)
         return selected.plan;
@@ -366,42 +336,44 @@ export async function compactFocusTreePlanAsync(plan, options = {}) {
     const workBudget = new FocusLayoutWorkBudget(options.maximumWork ?? COMPACT_LAYOUT_WORK_MAX);
     const layoutOptions = {
         workBudget,
+        aggressiveAestheticRepair: true,
         ...(options.signal === undefined ? {} : { signal: options.signal }),
     };
     const currentLayout = await layoutFocusTreeAsync(plan, layoutOptions);
-    if (compactShape(plan, currentLayout)) {
-        const stable = structuredClone(plan);
-        stable.provenance.importedPlanHash = focusPlanHash(stable);
-        return { plan: stable, currentLayout, proposedLayout: currentLayout };
-    }
+    const normalizedPlan = needsPresentationNormalization(plan)
+        ? compactCandidate(plan, currentLayout, {
+            scale: 1,
+            compressRows: false,
+            mirrorSiblings: false,
+            straightenChains: false,
+        })
+        : plan;
+    const normalizedLayout = normalizedPlan === plan
+        ? currentLayout
+        : await layoutFocusTreeAsync(normalizedPlan, layoutOptions);
     let selected;
     let fallback;
     let exhausted;
-    candidateSearch: for (const scale of compactScales(plan.focuses.length)) {
-        for (const compressRows of plan.focuses.length <= 500 ? [false, true] : [false]) {
-            options.signal?.throwIfAborted();
-            const candidate = compactCandidate(plan, currentLayout, scale, compressRows);
-            let layout;
-            try {
-                layout = await layoutFocusTreeAsync(candidate, layoutOptions);
-            }
-            catch (error) {
-                if (error instanceof ServiceError && error.code === 'FOCUS_LAYOUT_WORK_BUDGET_BLOCKED') {
-                    exhausted = error;
-                    break candidateSearch;
-                }
-                throw error;
+    candidateSearch: for (const strategy of compactStrategies(plan.focuses.length)) {
+        options.signal?.throwIfAborted();
+        const candidate = compactCandidate(normalizedPlan, normalizedLayout, strategy);
+        let layout;
+        try {
+            layout = await layoutFocusTreeAsync(candidate, layoutOptions);
+        }
+        catch (error) {
+            if (error instanceof ServiceError && error.code === 'FOCUS_LAYOUT_WORK_BUDGET_BLOCKED') {
+                exhausted = error;
+                break candidateSearch;
             }
-            if (fallback === undefined ||
-                betterScore(compactScore(layout), compactScore(fallback.layout)))
-                fallback = { plan: candidate, layout };
-            if (absoluteCompactRegressions(layout).length > 0 ||
-                relativeCompactRegressions(currentLayout, layout).length > 0)
-                continue;
-            if (selected === undefined ||
-                betterScore(compactScore(layout), compactScore(selected.layout)))
-                selected = { plan: candidate, layout };
+            throw error;
         }
+        if (fallback === undefined || betterScore(compactScore(layout), compactScore(fallback.layout)))
+            fallback = { plan: candidate, layout };
+        if (absoluteCompactRegressions(layout).length > 0)
+            continue;
+        if (selected === undefined || betterScore(compactScore(layout), compactScore(selected.layout)))
+            selected = { plan: candidate, layout };
     }
     if (selected !== undefined) {
         return { plan: selected.plan, currentLayout, proposedLayout: selected.layout };
@@ -414,19 +386,15 @@ export async function compactFocusTreePlanAsync(plan, options = {}) {
     }
     throw new ServiceError('FOCUS_COMPACT_LAYOUT_REQUIRED', 'Compact focus planning did not produce a measurable layout candidate', { treeId: plan.id });
 }
-/** Refuses compact rewrites that are not clean or trade readability for a smaller canvas. */
-export function assertCompactLayoutQuality(current, proposed) {
-    const regressions = [
-        ...absoluteCompactRegressions(proposed),
-        ...(current === undefined ? [] : relativeCompactRegressions(current, proposed)),
-    ].filter((value, index, all) => all.indexOf(value) === index);
+/** Refuses compact rewrites that still contain invalid or unreadable geometry. */
+export function assertCompactLayoutQuality(_current, proposed) {
+    const regressions = [...absoluteCompactRegressions(proposed)].filter((value, index, all) => all.indexOf(value) === index);
     if (regressions.length === 0)
         return;
-    throw new ServiceError('FOCUS_COMPACT_QUALITY_BLOCKED', 'Compact focus reflow failed the absolute or relative layout-quality gate', {
+    throw new ServiceError('FOCUS_COMPACT_QUALITY_BLOCKED', 'Compact focus reflow failed the layout-correctness gate', {
         treeId: proposed.treeId,
         regressions,
-        limits: compactLimits(proposed.nodes.length, requiredMetrics(proposed).connectors.count),
-        ...(current === undefined ? {} : { before: requiredMetrics(current) }),
+        ...(_current === undefined ? {} : { before: requiredMetrics(_current) }),
         proposed: requiredMetrics(proposed),
     });
 }

package/dist/hoi4_agent_tools/focus/layout.js

@@ -1258,26 +1258,60 @@ function longConnectorSpans(spans) {
 function longConnector(edge) {
     return longConnectorSpans(connectorSpans(edge));
 }
-function betterConnectorQualityScore(candidate, current) {
+function linearDetourCount(edges) {
+    const incomingCount = new Map();
+    const outgoingCount = new Map();
+    for (const edge of edges) {
+        incomingCount.set(edge.childId, (incomingCount.get(edge.childId) ?? 0) + 1);
+        outgoingCount.set(edge.parentId, (outgoingCount.get(edge.parentId) ?? 0) + 1);
+    }
+    return edges.filter((edge) => {
+        if ((outgoingCount.get(edge.parentId) ?? 0) !== 1 ||
+            (incomingCount.get(edge.childId) ?? 0) !== 1)
+            return false;
+        const spans = connectorSpans(edge);
+        return spans.horizontal !== 0 || spans.vertical !== 1;
+    }).length;
+}
+function betterConnectorQualityScore(candidate, current, aggressiveAestheticRepair = false) {
     if (candidate.longConnectorCount > current.longConnectorCount)
         return false;
-    const fields = [
-        'crossingCount',
-        'nodeIntersectionCount',
-        'maximumManhattanSpan',
-        'maximumHorizontalSpan',
-        'longConnectorCount',
-        'totalManhattanSpan',
-        'totalHorizontalSpan',
-        'asymmetricSiblingCohortCount',
-        'maximumSiblingDeviation',
-        'totalSiblingDeviation',
-        'offAnchorSiblingCohortCount',
-        'maximumSiblingAnchorDeviation',
-        'totalSiblingAnchorDeviation',
-        'columnCount',
-        'boundingCenterOffsetTwice',
-    ];
+    const fields = aggressiveAestheticRepair
+        ? [
+            'crossingCount',
+            'nodeIntersectionCount',
+            'longConnectorCount',
+            'linearDetourCount',
+            'asymmetricSiblingCohortCount',
+            'maximumSiblingDeviation',
+            'totalSiblingDeviation',
+            'offAnchorSiblingCohortCount',
+            'maximumSiblingAnchorDeviation',
+            'totalSiblingAnchorDeviation',
+            'maximumManhattanSpan',
+            'maximumHorizontalSpan',
+            'totalManhattanSpan',
+            'totalHorizontalSpan',
+            'columnCount',
+            'boundingCenterOffsetTwice',
+        ]
+        : [
+            'crossingCount',
+            'nodeIntersectionCount',
+            'maximumManhattanSpan',
+            'maximumHorizontalSpan',
+            'longConnectorCount',
+            'totalManhattanSpan',
+            'totalHorizontalSpan',
+            'asymmetricSiblingCohortCount',
+            'maximumSiblingDeviation',
+            'totalSiblingDeviation',
+            'offAnchorSiblingCohortCount',
+            'maximumSiblingAnchorDeviation',
+            'totalSiblingAnchorDeviation',
+            'columnCount',
+            'boundingCenterOffsetTwice',
+        ];
     for (const field of fields) {
         if (candidate[field] === current[field])
             continue;
@@ -1324,8 +1358,10 @@ function* affectedNodeIntersectionCount(context, edges, focusId, x) {
     }
     return count;
 }
-function* connectorNodeIntersectionSummary(context, edges) {
-    const nodes = [...context.placed.values()].sort((left, right) => compareCodeUnits(left.id, right.id));
+function* connectorNodeIntersectionSummary(context, edges, override) {
+    const nodes = [...context.placed.values()]
+        .map((node) => ({ ...node, x: override?.get(node.id) ?? node.x }))
+        .sort((left, right) => compareCodeUnits(left.id, right.id));
     const involvedFocusIds = new Set();
     let count = 0;
     let comparisonIndex = 0;
@@ -1422,14 +1458,18 @@ function siblingQuality(context, override) {
         parentFocusIds,
     };
 }
-function connectorQualityScore(context, edges, crossingCount, nodeIntersectionCount, symmetry) {
+function connectorQualityScore(context, edges, crossingCount, nodeIntersectionCount, symmetry, override) {
     const spans = edges.map(connectorSpans);
-    const nodes = [...context.placed.values()];
+    const nodes = [...context.placed.values()].map((node) => ({
+        ...node,
+        x: override?.get(node.id) ?? node.x,
+    }));
     const minimumX = Math.min(...nodes.map(({ x }) => x));
     const maximumX = Math.max(...nodes.map(({ x }) => x));
     return {
         crossingCount,
         nodeIntersectionCount,
+        linearDetourCount: linearDetourCount(edges),
         asymmetricSiblingCohortCount: symmetry.asymmetricSiblingCohortCount,
         maximumSiblingDeviation: symmetry.maximumSiblingDeviation,
         totalSiblingDeviation: symmetry.totalSiblingDeviation,
@@ -1445,6 +1485,115 @@ function connectorQualityScore(context, edges, crossingCount, nodeIntersectionCo
         boundingCenterOffsetTwice: Math.abs(minimumX + maximumX),
     };
 }
+function edgesWithXOverride(edges, override) {
+    return edges.map((edge) => ({
+        ...edge,
+        parent: { ...edge.parent, x: override.get(edge.parentId) ?? edge.parent.x },
+        child: { ...edge.child, x: override.get(edge.childId) ?? edge.child.x },
+    }));
+}
+function siblingBatchConflicts(context, cohort, override) {
+    const moved = [...override].flatMap(([focusId, x]) => {
+        const node = context.placed.get(focusId);
+        return node === undefined ? [] : [{ ...node, x }];
+    });
+    for (const node of moved) {
+        if (!coordinateWithinLane(context, node.id, node.x))
+            return true;
+        for (const other of context.placed.values()) {
+            if (cohort.has(other.id) || other.y !== node.y)
+                continue;
+            if (Math.abs(other.x - node.x) < context.nodeSpacing)
+                return true;
+        }
+        for (const excludedId of context.mutualExclusions.get(node.id) ?? []) {
+            const other = context.placed.get(excludedId);
+            if (other === undefined)
+                continue;
+            const otherX = override.get(excludedId) ?? other.x;
+            if (Math.abs(otherX - node.x) < context.minimumMutualExclusionSpacing)
+                return true;
+        }
+    }
+    const ordered = [...moved].sort((left, right) => left.y - right.y || left.x - right.x || compareCodeUnits(left.id, right.id));
+    for (let index = 1; index < ordered.length; index += 1) {
+        const left = ordered[index - 1];
+        const right = ordered[index];
+        if (left?.y === right?.y &&
+            left !== undefined &&
+            right !== undefined &&
+            Math.abs(right.x - left.x) < context.nodeSpacing)
+            return true;
+    }
+    return false;
+}
+function* refineSiblingCohorts(context, edges, initial) {
+    let current = initial;
+    for (let pass = 0; pass < 2; pass += 1) {
+        let accepted = false;
+        for (const [cohortIndex, cohort] of context.siblingCohorts.entries()) {
+            yield* cancellationCheckpoint(context.signal, cohortIndex, 8);
+            if (cohort.some((focusId) => !canMoveForSoftConstraint(context, focusId)))
+                continue;
+            const nodes = cohort
+                .flatMap((focusId) => {
+                const node = context.placed.get(focusId);
+                return node === undefined ? [] : [node];
+            })
+                .sort((left, right) => left.x - right.x || compareCodeUnits(left.id, right.id));
+            if (nodes.length < 2)
+                continue;
+            const { anchorX } = siblingCohortAnchor(context, cohort);
+            const currentSpan = (nodes.at(-1)?.x ?? 0) - (nodes[0]?.x ?? 0);
+            const spacing = Math.max(context.nodeSpacing, Math.ceil(currentSpan / Math.max(1, nodes.length - 1)));
+            const cohortIds = new Set(cohort);
+            const internalCenter = ((nodes[0]?.x ?? 0) + (nodes.at(-1)?.x ?? 0)) / 2;
+            let best;
+            for (const center of [...new Set([internalCenter, anchorX])]) {
+                const override = new Map();
+                for (const [index, node] of nodes.entries()) {
+                    override.set(node.id, Math.round(center + (index - (nodes.length - 1) / 2) * spacing));
+                }
+                if (nodes.every((node) => override.get(node.id) === node.x))
+                    continue;
+                if (siblingBatchConflicts(context, cohortIds, override))
+                    continue;
+                const candidateEdges = edgesWithXOverride(edges, override);
+                const crossingSummary = yield* connectorCrossings(candidateEdges, context);
+                if (crossingSummary.count > current.crossingCount)
+                    continue;
+                const intersectionSummary = yield* connectorNodeIntersectionSummary(context, candidateEdges, override);
+                if (intersectionSummary.count > current.nodeIntersectionCount)
+                    continue;
+                const symmetry = siblingQuality(context, override);
+                const score = connectorQualityScore(context, candidateEdges, crossingSummary.count, intersectionSummary.count, symmetry, override);
+                if (!betterConnectorQualityScore(score, current, true))
+                    continue;
+                if (best !== undefined && !betterConnectorQualityScore(score, best.score, true))
+                    continue;
+                best = { override, score };
+            }
+            if (best === undefined)
+                continue;
+            for (const node of nodes) {
+                const x = best.override.get(node.id);
+                if (x === undefined || x === node.x)
+                    continue;
+                context.decisions.push({
+                    focusId: node.id,
+                    kind: 'moved_to_improve_connector_quality',
+                    message: `Sibling-balance refinement moved (${node.x}, ${node.y}) to (${x}, ${node.y})`,
+                });
+                movePlacedFocusX(context, node, x);
+            }
+            current = best.score;
+            accepted = true;
+        }
+        if (!accepted)
+            break;
+    }
+    return current;
+}
 function candidateQualityScore(context, edges, current, focusId, x, currentAffectedCrossings, candidateAffectedCrossings, currentAffectedNodeIntersections, candidateAffectedNodeIntersections) {
     const incidentEdges = edges.filter((edge) => edge.parentId === focusId || edge.childId === focusId);
     const nonIncidentEdges = edges.filter((edge) => edge.parentId !== focusId && edge.childId !== focusId);
@@ -1471,6 +1620,7 @@ function candidateQualityScore(context, edges, current, focusId, x, currentAffec
         nodeIntersectionCount: current.nodeIntersectionCount -
             currentAffectedNodeIntersections +
             candidateAffectedNodeIntersections,
+        linearDetourCount: linearDetourCount([...nonIncidentEdges, ...candidateIncidentEdges]),
         asymmetricSiblingCohortCount: symmetry.asymmetricSiblingCohortCount,
         maximumSiblingDeviation: symmetry.maximumSiblingDeviation,
         totalSiblingDeviation: symmetry.totalSiblingDeviation,
@@ -1492,29 +1642,67 @@ function candidateQualityScore(context, edges, current, focusId, x, currentAffec
 }
 const CONNECTOR_REFINEMENT_WORK_MAX = 7_000_000;
 function* refineConnectorQualityWithinBudget(context) {
-    const maximumAcceptedMoves = 24;
-    const maximumCandidateNodes = 32;
+    const maximumAcceptedMoves = context.aggressiveAestheticRepair ? 32 : 24;
+    const maximumCandidateNodes = context.aggressiveAestheticRepair ? 48 : 32;
     const edges = yield* connectorEdges(context);
     const crossingSummary = yield* connectorCrossings(edges, context);
     const intersectionSummary = yield* connectorNodeIntersectionSummary(context, edges);
     const symmetry = siblingQuality(context);
     let current = connectorQualityScore(context, edges, crossingSummary.count, intersectionSummary.count, symmetry);
-    const siblingMembers = new Set(context.siblingCohorts.flat());
+    if (context.aggressiveAestheticRepair)
+        current = yield* refineSiblingCohorts(context, edges, current);
     const candidateIds = new Set(intersectionSummary.involvedFocusIds);
+    const longFocusIds = new Set();
     for (const edge of edges.filter(longConnector)) {
         candidateIds.add(edge.parentId);
         candidateIds.add(edge.childId);
+        longFocusIds.add(edge.parentId);
+        longFocusIds.add(edge.childId);
+    }
+    const siblingFocusIds = new Set(context.siblingCohorts.flat());
+    if (context.aggressiveAestheticRepair) {
+        for (const cohort of context.siblingCohorts) {
+            for (const focusId of cohort) {
+                candidateIds.add(focusId);
+            }
+        }
     }
     for (const parentId of symmetry.parentFocusIds)
         candidateIds.add(parentId);
+    const incomingCount = new Map();
+    const outgoingCount = new Map();
+    const linearFocusIds = new Set();
+    for (const edge of context.aggressiveAestheticRepair ? edges : []) {
+        incomingCount.set(edge.childId, (incomingCount.get(edge.childId) ?? 0) + 1);
+        outgoingCount.set(edge.parentId, (outgoingCount.get(edge.parentId) ?? 0) + 1);
+    }
+    for (const edge of edges) {
+        if ((outgoingCount.get(edge.parentId) ?? 0) !== 1 ||
+            (incomingCount.get(edge.childId) ?? 0) !== 1)
+            continue;
+        const spans = connectorSpans(edge);
+        if (spans.horizontal === 0 && spans.vertical === 1)
+            continue;
+        candidateIds.add(edge.parentId);
+        candidateIds.add(edge.childId);
+        linearFocusIds.add(edge.parentId);
+        linearFocusIds.add(edge.childId);
+    }
     const orderedCandidateIds = [...candidateIds]
         .filter((focusId) => {
         const degree = context.connectorDefinitionsByFocus.get(focusId)?.length ?? 0;
-        return (canMoveForSoftConstraint(context, focusId) && !siblingMembers.has(focusId) && degree !== 1);
+        return (canMoveForSoftConstraint(context, focusId) &&
+            (context.aggressiveAestheticRepair || (!siblingFocusIds.has(focusId) && degree !== 1)));
     })
         .sort((left, right) => {
         const degree = (focusId) => context.connectorDefinitionsByFocus.get(focusId)?.length ?? 0;
-        return degree(right) - degree(left) || compareCodeUnits(left, right);
+        const priority = (focusId) => (intersectionSummary.involvedFocusIds.has(focusId) ? 8 : 0) +
+            (longFocusIds.has(focusId) ? 4 : 0) +
+            (linearFocusIds.has(focusId) ? 2 : 0) +
+            (siblingFocusIds.has(focusId) ? 1 : 0);
+        return (priority(right) - priority(left) ||
+            degree(right) - degree(left) ||
+            compareCodeUnits(left, right));
     })
         .slice(0, maximumCandidateNodes);
     for (let acceptedMoves = 0; acceptedMoves < maximumAcceptedMoves; acceptedMoves += 1) {
@@ -1551,9 +1739,10 @@ function* refineConnectorQualityWithinBudget(context) {
                     continue;
                 const candidateAffectedNodeIntersections = yield* affectedNodeIntersectionCount(context, edges, focusId, x);
                 const score = candidateQualityScore(context, edges, current, focusId, x, currentAffectedCrossings, candidateAffectedCrossings, currentAffectedNodeIntersections, candidateAffectedNodeIntersections);
-                if (!betterConnectorQualityScore(score, current))
+                if (!betterConnectorQualityScore(score, current, context.aggressiveAestheticRepair))
                     continue;
-                if (best !== undefined && !betterConnectorQualityScore(score, best.score))
+                if (best !== undefined &&
+                    !betterConnectorQualityScore(score, best.score, context.aggressiveAestheticRepair))
                     continue;
                 best = {
                     focusId,
@@ -1620,6 +1809,76 @@ function* connectorLengthDiagnostics(context, edges) {
         });
     }
 }
+function* fakeComplexityDiagnostics(context, edges) {
+    const incomingCount = new Map();
+    const outgoingCount = new Map();
+    for (const edge of edges) {
+        incomingCount.set(edge.childId, (incomingCount.get(edge.childId) ?? 0) + 1);
+        outgoingCount.set(edge.parentId, (outgoingCount.get(edge.parentId) ?? 0) + 1);
+    }
+    const linearEdges = edges.filter(({ parentId, childId }) => (outgoingCount.get(parentId) ?? 0) === 1 && (incomingCount.get(childId) ?? 0) === 1);
+    const next = new Map(linearEdges.map((edge) => [edge.parentId, edge]));
+    const linearChildren = new Set(linearEdges.map(({ childId }) => childId));
+    for (const [edgeIndex, edge] of linearEdges.entries()) {
+        yield* cancellationCheckpoint(context.signal, edgeIndex, 32);
+        const spans = connectorSpans(edge);
+        if (spans.horizontal === 0 && spans.vertical === 1)
+            continue;
+        const focus = context.focuses.get(edge.childId);
+        context.diagnostics.push({
+            code: 'FOCUS_LAYOUT_LINEAR_DETOUR',
+            severity: 'warning',
+            category: 'layout',
+            message: `Mechanically linear connector ${edge.parentId} -> ${edge.childId} uses an unnecessary visual detour`,
+            ...(focus?.sourceLocation === undefined ? {} : { location: focus.sourceLocation }),
+            details: {
+                parentId: edge.parentId,
+                childId: edge.childId,
+                horizontalSpan: spans.horizontal,
+                verticalSpan: spans.vertical,
+                expectedHorizontalSpan: 0,
+                expectedVerticalSpan: 1,
+            },
+        });
+    }
+    const starts = linearEdges
+        .filter(({ parentId }) => !linearChildren.has(parentId))
+        .sort((left, right) => compareCodeUnits(left.parentId, right.parentId));
+    for (const start of starts) {
+        const chain = [];
+        const visited = new Set();
+        let current = start;
+        while (current !== undefined && !visited.has(current.parentId)) {
+            visited.add(current.parentId);
+            chain.push(current);
+            current = next.get(current.childId);
+        }
+        const horizontalDirections = chain
+            .map(({ parent, child }) => Math.sign(child.x - parent.x))
+            .filter((direction) => direction !== 0);
+        if (horizontalDirections.length < 2)
+            continue;
+        const sameDirection = horizontalDirections.every((direction) => direction === horizontalDirections[0]);
+        const alternating = horizontalDirections.every((direction, index) => index === 0 || direction === -horizontalDirections[index - 1]);
+        const code = sameDirection
+            ? 'FOCUS_LAYOUT_STAIRCASE_CHAIN'
+            : alternating
+                ? 'FOCUS_LAYOUT_ZIGZAG_CHAIN'
+                : undefined;
+        if (code === undefined)
+            continue;
+        const focusIds = [chain[0].parentId, ...chain.map(({ childId }) => childId)];
+        const focus = context.focuses.get(focusIds.at(-1) ?? '');
+        context.diagnostics.push({
+            code,
+            severity: 'warning',
+            category: 'layout',
+            message: `${sameDirection ? 'Staircase' : 'Zigzag'} geometry makes the linear chain ${focusIds.join(' -> ')} look artificially complex`,
+            ...(focus?.sourceLocation === undefined ? {} : { location: focus.sourceLocation }),
+            details: { focusIds, horizontalDirections },
+        });
+    }
+}
 function siblingCohortAnchor(context, cohort) {
     const focus = context.focuses.get(cohort[0] ?? '');
     const coordinates = cohort
@@ -1885,6 +2144,7 @@ function* layoutFocusTreeSteps(plan, options = {}) {
         siblingCohorts: siblingLayout.cohorts,
         nodeSpacing,
         minimumMutualExclusionSpacing: nodeSpacing,
+        aggressiveAestheticRepair: options.aggressiveAestheticRepair ?? false,
         decisions: [],
         diagnostics,
         work: options.workBudget ?? new FocusLayoutWorkBudget(),
@@ -1917,6 +2177,7 @@ function* layoutFocusTreeSteps(plan, options = {}) {
     const nodeIntersectionCount = yield* connectorNodeIntersectionDiagnostics(context, edges);
     yield* connectorCrossingDiagnostics(context, crossingSummary.samples);
     yield* connectorLengthDiagnostics(context, edges);
+    yield* fakeComplexityDiagnostics(context, edges);
     const symmetry = yield* siblingSymmetryDiagnostics(context);
     const nodes = [...context.placed.values()].sort((left, right) => compareCodeUnits(left.id, right.id));
     const decisions = [...context.decisions].sort((left, right) => compareCodeUnits(left.focusId, right.focusId));

package/dist/hoi4_agent_tools/version.js

@@ -1,6 +1,6 @@
 import { LATEST_PROTOCOL_VERSION } from '@modelcontextprotocol/sdk/types.js';
 export const PACKAGE_NAME = 'hoi4-agent-tools';
-export const PACKAGE_VERSION = '2.3.10';
+export const PACKAGE_VERSION = '2.3.12';
 export const MCP_PROTOCOL_VERSION = LATEST_PROTOCOL_VERSION;
 export const CONFIG_VERSION = 1;
 export const TRANSACTION_VERSION = 1;

package/docs/focus.md

@@ -30,7 +30,7 @@ For a layout-only cleanup of an existing national tree, call `hoi4.focus_rewrite
 
 Compact mode imports the tree, resets authored presentation coordinates and lane bounds, and performs a deterministic reflow in the same rewrite call. It keeps prerequisites, mutual exclusions, availability, bypasses, rewards, icons, localisation, AI behavior, and route/lane membership unchanged.
 
-The rewrite measures canvas bounds, same-row spacing, the same curved connector paths used by the renderer, connector lengths, connector-node intersections, branch balance, and overall centering. A bounded refinement pass moves automatic gateways and blockers only when the measured connector result improves. The rewrite refuses changes with close focuses, rendered crossings, excessive branch imbalance, an off-center canvas, or connector and size metrics outside absolute and source-relative limits.
+The rewrite measures canvas bounds, same-row spacing, the same curved connector paths used by the renderer, connector lengths, connector-node intersections, branch balance, overall centering, and topology-aware fake-complexity patterns. Compact mode evaluates preservation, row repair, linear-chain repair, sibling balancing, and combined compression strategies, then chooses the cleanest valid result. It refuses invalid geometry such as overlapping or cramped focuses, bad parent order, rendered crossings, connectors through unrelated focuses, or an off-center canvas. Long connectors, fake detours, staircase or zigzag chains, and avoidable sibling imbalance are optimization priorities instead of independent rejection budgets.
 
 Use the default `layoutMode: "authored"` with a complete plan when deliberately designing coordinates or changing gameplay. Set `layoutMode: "compact"` with a complete plan when creating a large automatically arranged tree. Inspect and render calls remain useful before or after either rewrite mode, but a separate plan is not required for compact cleanup.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hoi4-agent-tools",
   "mcpName": "io.github.klimPaskov/hoi4-agent-tools",
-  "version": "2.3.10",
+  "version": "2.3.12",
   "description": "Analyze HOI4 events, tech trees, AI weights, and MTTH; build focus trees, GUIs, and maps.",
   "type": "module",
   "license": "Apache-2.0",

package/schemas/configuration.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/configuration.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/configuration.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/continuous-focus-palette.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/continuous-focus-palette.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/continuous-focus-palette.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/custom-weighted-pool.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/custom-weighted-pool.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/custom-weighted-pool.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/event-feature-manifest.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/event-feature-manifest.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/event-feature-manifest.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/focus-plan.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/focus-plan.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/focus-plan.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/focus-planning-sidecar.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/focus-planning-sidecar.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/focus-planning-sidecar.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/gui-animation-source.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/gui-animation-source.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/gui-animation-source.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/gui-helper.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/gui-helper.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/gui-helper.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/gui-scenario.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/gui-scenario.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/gui-scenario.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/map-operation.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/map-operation.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/map-operation.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "oneOf": [
     {

package/schemas/operation-result.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/operation-result.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/operation-result.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-analysis-result.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/probability-analysis-result.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/probability-analysis-result.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-compare-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/probability-compare-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/probability-compare-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-evaluate-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/probability-evaluate-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/probability-evaluate-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-inspect-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/probability-inspect-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/probability-inspect-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-render-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/probability-render-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/probability-render-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-scenario-set.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/probability-scenario-set.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/probability-scenario-set.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-sequence-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/probability-sequence-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/probability-sequence-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-simulate-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/probability-simulate-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/probability-simulate-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-sweep-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.10/schemas/probability-sweep-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.3.12/schemas/probability-sweep-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.klimPaskov/hoi4-agent-tools",
   "title": "HOI4 Agent Tools",
   "description": "Analyze HOI4 events, tech trees, AI weights, and MTTH; build focus trees, GUIs, and maps.",
-  "version": "2.3.10",
+  "version": "2.3.12",
   "repository": {
     "url": "https://github.com/klimPaskov/hoi4-agent-tools",
     "source": "github"
@@ -13,7 +13,7 @@
     {
       "registryType": "npm",
       "identifier": "hoi4-agent-tools",
-      "version": "2.3.10",
+      "version": "2.3.12",
       "transport": {
         "type": "stdio"
       }