hoi4-agent-tools 1.0.0 → 1.2.0

package/dist/hoi4_agent_tools/focus/limits.js

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

package/dist/hoi4_agent_tools/focus/lint.js

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

package/dist/hoi4_agent_tools/focus/native-effects.js

@@ -5,7 +5,7 @@
  * Source: the official HOI4 1.19.2 effects documentation reviewed 2026-07-10.
  * Keep this list synchronized during compatibility reviews.
  */
-export const nativeFocusEffectKeys = new Set([
+export const nativeEffectKeys = new Set([
     'activate_advisor',
     'activate_decision',
     'activate_mission',
@@ -560,3 +560,5 @@ export const nativeFocusEffectKeys = new Set([
     'while_loop_effect',
     'white_peace',
 ]);
+/** Backward-compatible focus-domain name for the shared official effect catalog. */
+export const nativeFocusEffectKeys = nativeEffectKeys;

package/dist/hoi4_agent_tools/focus/planning.js

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

package/dist/hoi4_agent_tools/focus/render.js

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

package/dist/hoi4_agent_tools/mcp/resources/register.js

@@ -6,7 +6,7 @@ const artifactChunkMetadataKey = 'io.github.klimpaskov/hoi4-agent-tools.artifact
 const fatalUtf8Decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
 const artifactResourceMetadata = {
     title: 'HOI4 review artifact',
-    description: 'Complete plans, diagnostics, layouts, previews, and diffs. Reads accept zero-based byte offset and positive byte length query selectors; each response reports its exact byte range and continuation URI in _meta.',
+    description: 'Complete plans, diagnostics, layouts, previews, event graphs, routes, state and scope reports, comparisons, and diffs. Reads accept zero-based byte offset and positive byte length query selectors; each response reports its exact byte range and continuation URI in _meta.',
     _meta: {
         [artifactChunkMetadataKey]: {
             version: 1,

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

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

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

@@ -4,7 +4,9 @@ import { registerModsTool } from '../tools/mods.js';
 import { registerFocusTools } from '../tools/focus.js';
 import { registerGuiTools } from '../tools/gui.js';
 import { registerMapTools } from '../tools/map.js';
+import { registerEventTools } from '../tools/event.js';
 import { registerMcpResources } from '../resources/register.js';
+export const SERVER_INSTRUCTIONS = 'Use hoi4.mods to select a workspace. Use hoi4.event_inspect for scan, roots, trace, explain_path, state_flow, lint, and impact; hoi4.event_render and hoi4.event_compare return linked evidence. JSON resources are authoritative. Event tools are read-only. Only focus, GUI, and map rewrite tools edit configured mods.';
 export function createMcpServer(engine, context = {}) {
     const server = new McpServer({
         name: PACKAGE_NAME,
@@ -12,12 +14,13 @@ export function createMcpServer(engine, context = {}) {
         websiteUrl: 'https://github.com/klimPaskov/hoi4-agent-tools',
     }, {
         capabilities: { logging: {} },
-        instructions: 'Use this server when a configured HOI4 mod needs a large national or continuous focus, scripted GUI, or map created, inspected, rendered, or cleaned up. Start with hoi4.mods, then use the matching inspect, render, and rewrite tools. Each rewrite performs the complete edit in one call. Read linked hoi4-agent:// artifact resources for complete plans, diagnostics, layouts, previews, and diffs; when a resource content item has a non-null continuationUri in its namespaced _meta byte-range record, follow it until null. Generated GUI renders are offline representations, never game screenshots.',
+        instructions: SERVER_INSTRUCTIONS,
     });
     registerModsTool(server, engine, context);
     registerFocusTools(server, engine, context);
     registerGuiTools(server, engine, context);
     registerMapTools(server, engine, context);
+    registerEventTools(server, engine, context);
     registerMcpResources(server, engine, context);
     return server;
 }

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

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