hoi4-agent-tools 2.3.11 → 2.3.12

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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.

package/dist/hoi4_agent_tools/focus/compact.js

@@ -12,26 +12,21 @@ const COMPACT_HARD_DIAGNOSTICS = new Set([
     'FOCUS_LAYOUT_CONNECTOR_CROSSING_UNSATISFIED',
     'FOCUS_LAYOUT_CONNECTOR_THROUGH_NODE',
     'FOCUS_LAYOUT_COORDINATE_CONFLICT',
-    'FOCUS_LAYOUT_LINEAR_DETOUR',
     '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_STAIRCASE_CHAIN',
     'FOCUS_LAYOUT_VISIBLE_OVERLAP',
+]);
+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 compactLimits(focusCount) {
-    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,
-    };
-}
 function requiredMetrics(layout) {
     if (layout.metrics !== undefined)
         return layout.metrics;
@@ -39,7 +34,6 @@ function requiredMetrics(layout) {
 }
 function absoluteCompactRegressions(layout) {
     const metrics = requiredMetrics(layout);
-    const limits = compactLimits(layout.nodes.length);
     return [
         ...(layout.diagnostics.some(({ code }) => COMPACT_HARD_DIAGNOSTICS.has(code))
             ? ['hardLayoutDiagnostics']
@@ -47,61 +41,9 @@ function absoluteCompactRegressions(layout) {
         ...(metrics.connectors.crossingCount > 0 ? ['connectorCrossingCount'] : []),
         ...(metrics.connectors.nodeIntersectionCount > 0 ? ['connectorNodeIntersections'] : []),
         ...(metrics.spacing.tooCloseSameRowPairCount > 0 ? ['sameRowSpacing'] : []),
-        ...(metrics.symmetry.asymmetricSiblingCohortCount > 0 ? ['siblingMirrorDeviation'] : []),
-        ...(metrics.symmetry.totalSiblingDeviation > 0 ? ['totalSiblingMirrorDeviation'] : []),
-        ...(metrics.symmetry.offAnchorSiblingCohortCount > 0 ? ['siblingAnchorDeviation'] : []),
-        ...(metrics.symmetry.totalSiblingAnchorDeviation > 0 ? ['totalSiblingAnchorDeviation'] : []),
         ...(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 > 0 ? ['longConnectors'] : []),
-    ];
-}
-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
@@ -225,7 +167,8 @@ function straightenLinearChains(plan, preferredX, preferredY) {
         preferredY.set(focus.id, parentY + 1);
     }
 }
-function compactCandidate(plan, layout, scale, compressRows) {
+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));
@@ -256,8 +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);
-    straightenLinearChains(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,
@@ -277,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,
     ];
@@ -310,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 [false, true]) {
-            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;
@@ -365,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 [false, true]) {
-            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 };
@@ -413,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),
-        ...(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,
@@ -1955,6 +2144,7 @@ function* layoutFocusTreeSteps(plan, options = {}) {
         siblingCohorts: siblingLayout.cohorts,
         nodeSpacing,
         minimumMutualExclusionSpacing: nodeSpacing,
+        aggressiveAestheticRepair: options.aggressiveAestheticRepair ?? false,
         decisions: [],
         diagnostics,
         work: options.workBudget ?? new FocusLayoutWorkBudget(),

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.11';
+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, overall centering, and topology-aware fake-complexity patterns. Compact mode straightens mechanically linear chains and refuses a result with overlapping or cramped focuses, rendered crossings, connectors through unrelated focuses, long connectors, asymmetric or off-anchor sibling groups, offset linear detours, staircase or zigzag chains, an off-center canvas, or 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.11",
+  "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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11/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.11",
+  "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.11",
+      "version": "2.3.12",
       "transport": {
         "type": "stdio"
       }