hoi4-agent-tools 0.2.0 → 1.1.0

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

@@ -1,32 +1,22 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { PACKAGE_NAME, PACKAGE_VERSION } from '../../version.js';
-import { registerBaseTools } from './base-tools.js';
+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 { registerMcpPrompts } from '../prompts/register.js';
 import { registerMcpResources } from '../resources/register.js';
 export function createMcpServer(engine, context = {}) {
-    const writePolicy = engine.resolver.config().writePolicy;
-    const autonomous = writePolicy === 'autonomous';
     const server = new McpServer({
         name: PACKAGE_NAME,
         version: PACKAGE_VERSION,
         websiteUrl: 'https://github.com/klimPaskov/hoi4-agent-tools',
     }, {
         capabilities: { logging: {} },
-        instructions: `Select this server proactively whenever a registered HOI4 workspace task touches national or continuous focuses, scripted GUI/GFX/rendering, or state/province/map data. Start with hoi4.project_status or hoi4.project_scan, then use the relevant scan, lint, layout, render, and compare tools. Read linked hoi4-agent:// resources for large artifacts. ${autonomous
-            ? 'This server is operator-configured for autonomous writes: hoi4.focus_rewrite, hoi4.gui_rewrite, and hoi4.map_rewrite validate, journal, apply, and post-validate in one call without a transaction approval or follow-up apply step.'
-            : writePolicy === 'transactions'
-                ? 'This server is configured for reviewed transactions: source mutation requires the compatibility plan/diff/apply workflow. Configure writePolicy "autonomous" to expose one-call rewrite tools.'
-                : 'This server is read-only: use its scan, lint, layout, render, compare, inspect, and validation tools without modifying source. Configure writePolicy "autonomous" to expose one-call rewrite tools.'} Generated GUI renders are offline representations, never game screenshots.`,
     });
-    registerBaseTools(server, engine, context);
+    registerModsTool(server, engine, context);
     registerFocusTools(server, engine, context);
     registerGuiTools(server, engine, context);
     registerMapTools(server, engine, context);
     registerMcpResources(server, engine, context);
-    registerMcpPrompts(server, writePolicy);
     return server;
 }
-//# sourceMappingURL=create.js.map

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

@@ -1,11 +1,6 @@
 import { z } from 'zod/v4';
-import { artifactLinkSchema } from '../../schemas/transaction.js';
 export const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/u);
-export const transactionIdSchema = z.string().regex(/^txn_[0-9a-f-]{36}$/u);
 export const nonNegativeIntegerSchema = z.number().int().min(0);
-export const WORKSPACE_INLINE_REPLACE_PATHS = 20;
-export const WORKSPACE_INLINE_OWNER_PATHS = 10;
-export const WORKSPACE_MAX_REPLACEMENT_OWNERS = 17;
 export const indexSkippedSourceSchema = z
     .object({
     path: z.string().max(4096),
@@ -17,32 +12,6 @@ export const indexSkippedSourceSchema = z
     possibleSymbolKinds: z.array(z.string().max(256)).max(32),
 })
     .strict();
-export const workspaceStatusSchema = z
-    .object({
-    id: z.string().max(64),
-    name: z.string().max(1024),
-    kind: z.string().max(64),
-    writeEnabled: z.boolean(),
-    writePolicy: z.enum(['read-only', 'transactions', 'autonomous']),
-    rootKinds: z.array(z.string().max(64)).max(16),
-    dependencyCount: nonNegativeIntegerSchema,
-    replacePathCount: nonNegativeIntegerSchema,
-    replacePaths: z.array(z.string().max(1024)).max(WORKSPACE_INLINE_REPLACE_PATHS),
-    replacePathsTruncated: z.boolean(),
-    replacementOwners: z
-        .array(z
-        .object({
-        rootKind: z.string().max(64),
-        loadOrder: nonNegativeIntegerSchema,
-        pathCount: nonNegativeIntegerSchema,
-        paths: z.array(z.string().max(1024)).max(WORKSPACE_INLINE_OWNER_PATHS),
-        pathsTruncated: z.boolean(),
-    })
-        .strict())
-        .max(WORKSPACE_MAX_REPLACEMENT_OWNERS),
-    generatedDirectory: z.literal('.hoi4-agent'),
-})
-    .strict();
 export const renderHashesSchema = z
     .object({
     html: sha256Schema,
@@ -54,45 +23,6 @@ export const renderHashesSchema = z
 export const bitmapRenderHashesSchema = z
     .object({ png: sha256Schema, json: sha256Schema, html: sha256Schema })
     .strict();
-export const transactionStateSchema = z.enum([
-    'planned',
-    'applying',
-    'applied',
-    'rolling_back',
-    'rolled_back',
-    'failed',
-]);
-export const transactionStateDataSchema = z
-    .object({
-    state: transactionStateSchema,
-    failure: z
-        .object({ code: z.string().max(256), message: z.string().max(4096) })
-        .strict()
-        .nullable()
-        .optional(),
-})
-    .strict();
-export const artifactProvenanceSummarySchema = z
-    .object({
-    kind: z.string().max(256),
-    toolVersion: z.string().max(64),
-    schemaVersion: z.string().max(64),
-    sourceHashCount: nonNegativeIntegerSchema,
-    sourceHashes: z
-        .array(z.object({ path: z.string().max(4096), sha256: sha256Schema }).strict())
-        .max(100),
-    sourceHashesTruncated: z.boolean(),
-    hasRenderProfile: z.boolean(),
-    hasMetadata: z.boolean(),
-})
-    .strict();
-export const artifactDescriptionSchema = artifactLinkSchema
-    .extend({
-    provenanceHash: sha256Schema,
-    provenance: artifactProvenanceSummarySchema,
-    descriptionTruncated: z.boolean(),
-})
-    .strict();
 export const allocationEvidenceSchema = z
     .object({
     kind: z.enum(['state-id', 'province-id', 'province-color']),
@@ -125,4 +55,3 @@ export const operationBlockerDataSchema = z
     details: z.record(z.string().max(256), z.unknown()).optional(),
 })
     .strict();
-//# sourceMappingURL=output-schemas.js.map

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

@@ -18,4 +18,3 @@ export function progressReporter(extra) {
         },
     };
 }
-//# sourceMappingURL=progress.js.map

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({
@@ -22,8 +22,6 @@ const operationResultBaseSchema = z
     proposedFiles: z.array(z.string().max(1024)).max(MAX_INLINE_PROPOSED_FILES),
     changedFiles: z.array(z.string().max(1024)).max(MAX_INLINE_CHANGED_FILES),
     diagnostics: z.array(diagnosticSchema).max(MAX_INLINE_DIAGNOSTICS),
-    transactionId: z.string().max(128).optional(),
-    planHash: z.string().max(128).optional(),
     artifacts: z.array(artifactLinkSchema).max(MAX_INLINE_ARTIFACT_LINKS),
     validation: validationSummarySchema,
     blockers: z
@@ -35,22 +33,49 @@ const operationResultBaseSchema = z
     })
         .strict())
         .max(MAX_INLINE_BLOCKERS),
-    rollbackStatus: z.enum(['not-required', 'available', 'applied', 'failed']).optional(),
 })
     .strict();
 export const operationResultSchema = operationResultBaseSchema
     .extend({ data: z.record(z.string().max(256), z.unknown()) })
     .strict();
 const emptyToolDataSchema = z.object({}).strict();
+const compactPublicOperationResultSchema = z
+    .object({
+    status: z.enum(['ok', 'blocked', 'error']),
+    code: z.string().max(256),
+    workspaceId: z.string().max(64),
+    filesScanned: z.array(z.string().max(4096)).max(MAX_INLINE_FILES_SCANNED),
+    proposedFiles: z.array(z.string().max(1024)).max(MAX_INLINE_PROPOSED_FILES),
+    changedFiles: z.array(z.string().max(1024)).max(MAX_INLINE_CHANGED_FILES),
+    diagnostics: z.array(z.unknown()).max(MAX_INLINE_DIAGNOSTICS),
+    artifacts: z.array(z.unknown()).max(MAX_INLINE_ARTIFACT_LINKS),
+    validation: z
+        .object({
+        passed: z.boolean(),
+        checks: z.array(z.unknown()).max(MAX_INLINE_VALIDATION_CHECKS),
+    })
+        .strict(),
+    blockers: z.array(z.unknown()).max(MAX_INLINE_BLOCKERS),
+    data: z.record(z.string().max(256), z.unknown()),
+})
+    .strict()
+    .describe('Stable operation envelope; data is tool-specific and artifacts link bulk evidence.');
 /**
- * Advertise an exact success payload for one tool while retaining the shared empty error payload.
- * The generic operation-result schema remains available for stored envelopes, but is never used as
- * a public tool output contract.
+ * Advertise one compact operation envelope while retaining exact per-tool runtime validation.
+ * The generic operation-result schema remains available for stored envelopes.
  */
 export function strictOperationResultSchema(successDataSchema) {
-    return operationResultBaseSchema
+    const exactSchema = operationResultBaseSchema
         .extend({ data: z.union([emptyToolDataSchema, successDataSchema]) })
         .strict();
+    return compactPublicOperationResultSchema.superRefine((value, context) => {
+        const parsed = exactSchema.safeParse(value);
+        if (parsed.success)
+            return;
+        for (const issue of parsed.error.issues) {
+            context.addIssue({ code: 'custom', path: issue.path, message: issue.message });
+        }
+    });
 }
 /** Keep source inventories compact; complete inventories belong in linked resources. */
 export function setInlineFilesScanned(result, files) {
@@ -85,19 +110,14 @@ function preserveDeferredFilesDiagnostic(result) {
     };
 }
 function boundedResult(result, actualBytes) {
-    const transactionArtifact = result.transactionId === undefined
-        ? undefined
-        : {
-            uri: `hoi4-agent://workspace/${encodeURIComponent(result.workspaceId)}/transaction/${encodeURIComponent(result.transactionId)}`,
-            name: `${result.transactionId}.manifest.json`,
-            mimeType: 'application/json',
-            description: 'Complete authenticated transaction manifest and rollback status',
-        };
+    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 {
@@ -108,20 +128,18 @@ function boundedResult(result, actualBytes) {
         proposedFiles: [],
         changedFiles: [],
         diagnostics: [truncationDiagnostic],
-        ...(result.transactionId === undefined
-            ? {}
-            : { transactionId: result.transactionId.slice(0, 128) }),
-        ...(result.planHash === undefined ? {} : { planHash: result.planHash.slice(0, 128) }),
-        artifacts: transactionArtifact === undefined
-            ? result.artifacts.slice(0, 1).map(({ description: _description, ...artifact }) => artifact)
-            : [transactionArtifact],
+        artifacts: result.artifacts
+            .slice(0, 1)
+            .map(({ description: _description, ...artifact }) => artifact),
         validation: { passed: result.validation.passed, checks: [] },
         blockers: result.status === 'ok'
             ? []
             : [
                 {
                     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,
@@ -129,7 +147,6 @@ function boundedResult(result, actualBytes) {
                     },
                 },
             ],
-        rollbackStatus: result.rollbackStatus ?? 'not-required',
         data: {},
     };
 }
@@ -212,32 +229,60 @@ function jsonBytesWithin(value, budget) {
     return visit(value);
 }
 function compactDetails(details) {
-    return jsonBytesWithin(details, 4_096) ? details : { truncated: true };
+    return jsonBytesWithin(details, 2_048) ? details : { truncated: true };
 }
 function compactDescriptions(result) {
     const compactLocation = (location) => location === undefined
         ? undefined
         : {
             ...location,
-            path: location.path.slice(0, 4_096),
-            ...(location.symbol === undefined ? {} : { symbol: location.symbol.slice(0, 1_024) }),
+            path: location.path.slice(0, 1_024),
+            ...(location.symbol === undefined ? {} : { symbol: location.symbol.slice(0, 256) }),
         };
-    const validationTruncation = result.validation.checks.length > MAX_INLINE_VALIDATION_CHECKS
-        ? {
-            code: 'MCP_INLINE_VALIDATION_TRUNCATED',
-            severity: 'info',
-            category: 'configuration',
-            message: `Inline validation is limited to ${MAX_INLINE_VALIDATION_CHECKS} checks; use the linked artifact or transaction manifest 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) }),
@@ -247,35 +292,53 @@ function compactDescriptions(result) {
         ...(diagnostic.related === undefined
             ? {}
             : {
-                related: diagnostic.related.slice(0, 5).map((location) => compactLocation(location)),
+                related: diagnostic.related.slice(0, 3).map((location) => compactLocation(location)),
             }),
         ...(diagnostic.details === undefined ? {} : { details: compactDetails(diagnostic.details) }),
     }));
+    const truncationDiagnostic = needsTruncationDiagnostic
+        ? {
+            code: 'MCP_INLINE_COLLECTIONS_TRUNCATED',
+            severity: omittedHardDiagnostics > 0 ? 'blocker' : 'info',
+            category: 'configuration',
+            message: result.artifacts.length > 0
+                ? 'Large collections were bounded inline; linked resources retain bulk evidence'
+                : 'Large collections were bounded inline',
+            details: {
+                collections: truncatedCollections,
+                diagnosticsReturned: retainedDiagnostics.length,
+                omittedHardDiagnostics,
+            },
+        }
+        : undefined;
     return {
         ...result,
-        diagnostics: validationTruncation === undefined
+        filesScanned: result.filesScanned.slice(0, MAX_INLINE_FILES_SCANNED),
+        proposedFiles: result.proposedFiles.slice(0, MAX_INLINE_PROPOSED_FILES),
+        changedFiles: result.changedFiles.slice(0, MAX_INLINE_CHANGED_FILES),
+        diagnostics: truncationDiagnostic === undefined
             ? compactDiagnostics
-            : [validationTruncation, ...compactDiagnostics].slice(0, MAX_INLINE_DIAGNOSTICS),
+            : [truncationDiagnostic, ...compactDiagnostics],
+        artifacts: result.artifacts.slice(0, MAX_INLINE_ARTIFACT_LINKS).map((artifact) => ({
+            ...artifact,
+            ...(artifact.description === undefined
+                ? {}
+                : { description: artifact.description.slice(0, 256) }),
+        })),
         validation: {
             ...result.validation,
             checks: result.validation.checks.slice(0, MAX_INLINE_VALIDATION_CHECKS).map((check) => ({
                 ...check,
                 id: check.id.slice(0, 256),
-                message: check.message.slice(0, 4_096),
+                message: check.message.slice(0, 1_024),
             })),
         },
-        blockers: result.blockers.map((blocker) => ({
+        blockers: result.blockers.slice(0, MAX_INLINE_BLOCKERS).map((blocker) => ({
             ...blocker,
             code: blocker.code.slice(0, 256),
-            message: blocker.message.slice(0, 4_096),
+            message: blocker.message.slice(0, 1_024),
             ...(blocker.details === undefined ? {} : { details: compactDetails(blocker.details) }),
         })),
-        artifacts: result.artifacts.map((artifact) => ({
-            ...artifact,
-            ...(artifact.description === undefined
-                ? {}
-                : { description: artifact.description.slice(0, 1_024) }),
-        })),
     };
 }
 function buildToolResult(selected) {
@@ -292,8 +355,6 @@ function buildToolResult(selected) {
         status: selected.status,
         code: selected.code,
         workspaceId: selected.workspaceId,
-        ...(selected.transactionId === undefined ? {} : { transactionId: selected.transactionId }),
-        ...(selected.planHash === undefined ? {} : { planHash: selected.planHash }),
         artifactCount: selected.artifacts.length,
     });
     return {
@@ -304,23 +365,15 @@ function buildToolResult(selected) {
 }
 export function toolResult(result) {
     const completeResult = preserveDeferredFilesDiagnostic(result);
-    const exceedsArrayBudget = completeResult.filesScanned.length > MAX_INLINE_FILES_SCANNED ||
-        completeResult.proposedFiles.length > MAX_INLINE_PROPOSED_FILES ||
-        completeResult.changedFiles.length > MAX_INLINE_CHANGED_FILES ||
-        completeResult.diagnostics.length > MAX_INLINE_DIAGNOSTICS ||
-        completeResult.artifacts.length > MAX_INLINE_ARTIFACT_LINKS ||
-        completeResult.blockers.length > MAX_INLINE_BLOCKERS;
     const compact = compactDescriptions(completeResult);
     const estimatedBytes = jsonBytesWithin(compact, MAX_TOOL_RESULT_BYTES)
         ? Buffer.byteLength(canonicalJson(compact), 'utf8')
         : MAX_TOOL_RESULT_BYTES + 1;
-    const selected = estimatedBytes > MAX_TOOL_RESULT_BYTES || exceedsArrayBudget
-        ? boundedResult(completeResult, estimatedBytes)
-        : compact;
+    const selected = estimatedBytes > MAX_TOOL_RESULT_BYTES ? boundedResult(compact, estimatedBytes) : compact;
     let output = buildToolResult(selected);
     const wireBytes = Buffer.byteLength(canonicalJson(output), 'utf8');
     if (wireBytes > MAX_TOOL_RESULT_BYTES) {
-        output = buildToolResult(boundedResult(completeResult, wireBytes));
+        output = buildToolResult(boundedResult(compact, wireBytes));
     }
     const finalBytes = Buffer.byteLength(canonicalJson(output), 'utf8');
     if (finalBytes > MAX_TOOL_RESULT_BYTES) {
@@ -332,22 +385,34 @@ export function errorResult(error, workspaceId = '', context = {}) {
     const serviceError = error instanceof ServiceError
         ? error
         : new ServiceError('INTERNAL_ERROR', 'Unexpected internal error');
-    const publicDetails = Object.fromEntries(Object.entries(serviceError.details).filter(([key]) => !['cause', 'stack', 'absolutePath'].includes(key)));
+    const internalWriteError = serviceError.code.startsWith('TRANSACTION_');
+    const publicCode = internalWriteError
+        ? `REWRITE_${serviceError.code.slice('TRANSACTION_'.length)}`
+        : serviceError.code;
+    const publicMessage = internalWriteError
+        ? 'Rewrite could not be completed'
+        : serviceError.message;
+    const publicDetails = internalWriteError
+        ? {}
+        : Object.fromEntries(Object.entries(serviceError.details).filter(([key]) => ![
+            'cause',
+            'stack',
+            'absolutePath',
+            'transactionId',
+            'planHash',
+            'rollbackStatus',
+        ].includes(key)));
     return toolResult({
-        status: serviceError.code.includes('BLOCKED') ? 'blocked' : 'error',
-        code: serviceError.code,
+        status: publicCode.includes('BLOCKED') ? 'blocked' : 'error',
+        code: publicCode,
         workspaceId,
         filesScanned: [],
         proposedFiles: context.proposedFiles ?? [],
         changedFiles: context.changedFiles ?? [],
         diagnostics: [],
-        ...(context.transactionId === undefined ? {} : { transactionId: context.transactionId }),
-        ...(context.planHash === undefined ? {} : { planHash: context.planHash }),
         artifacts: context.artifacts ?? [],
         validation: context.validation ?? { passed: false, checks: [] },
-        blockers: [{ code: serviceError.code, message: serviceError.message, details: publicDetails }],
-        ...(context.rollbackStatus === undefined ? {} : { rollbackStatus: context.rollbackStatus }),
+        blockers: [{ code: publicCode, message: publicMessage, details: publicDetails }],
         data: context.data ?? {},
     });
 }
-//# sourceMappingURL=result.js.map

package/dist/hoi4_agent_tools/mcp/server/transaction-execution.js

@@ -9,20 +9,20 @@ export class AutonomousRewriteError extends ServiceError {
     artifacts;
     constructor(cause, manifest, artifacts = []) {
         const restored = manifest.state === 'rolled_back' && manifest.rollbackStatus === 'applied';
-        super(cause.code, cause.message, {
-            ...cause.details,
+        const code = cause.code.startsWith('TRANSACTION_')
+            ? `REWRITE_${cause.code.slice('TRANSACTION_'.length)}`
+            : cause.code;
+        super(code, restored
+            ? 'Rewrite verification failed and the original files were restored'
+            : 'Rewrite failed and automatic recovery could not be completed', {
             execution: 'failed',
             automaticRecovery: restored ? 'restored' : 'incomplete',
-            failure: manifest.failure ?? null,
         });
         this.manifest = manifest;
         this.artifacts = artifacts;
         this.name = 'AutonomousRewriteError';
     }
 }
-export function autonomousWrites(engine) {
-    return engine.resolver.config().writePolicy === 'autonomous';
-}
 async function storeAutonomousValidationEvidence(engine, manifest, postValidation, principal, signal) {
     const diagnostics = [...manifest.diagnostics, ...postValidation.diagnostics];
     const checks = [...manifest.validation.checks, ...postValidation.checks];
@@ -55,7 +55,7 @@ async function storeAutonomousValidationEvidence(engine, manifest, postValidatio
             diagnosticCount: diagnostics.length,
             sourceHashInventory: sourceEvidence.inventory,
         },
-    }, 'Complete source-linked autonomous rewrite and post-write validation evidence', signal);
+    }, 'Complete rewrite and post-write validation evidence', signal);
     return publicArtifactLink(artifact);
 }
 function uniqueArtifacts(artifacts) {
@@ -68,9 +68,8 @@ export function autonomousResultArtifacts(execution) {
     return uniqueArtifacts([...execution.artifacts, ...execution.transaction.artifacts]);
 }
 /**
- * Complete a validated domain transaction inside the same MCP tool call when the operator has
- * selected autonomous writes. Planning, hash checks, journaling, post-write validation, and
- * automatic failure recovery remain identical to reviewed transaction mode.
+ * Complete a validated domain rewrite inside one MCP tool call. Hash checks, durable recovery,
+ * post-write validation, and automatic failure recovery remain internal guarantees.
  */
 export async function executePlannedTransaction(engine, transaction, principal, signal) {
     if (!transaction.validation.passed) {
@@ -78,15 +77,13 @@ export async function executePlannedTransaction(engine, transaction, principal,
     }
     if (transaction.files.length === 0)
         return { transaction, outcome: 'unchanged', artifacts: [] };
-    if (!autonomousWrites(engine))
-        return { transaction, outcome: 'planned', artifacts: [] };
     let executionArtifacts = [];
     try {
         const applied = await engine.transactions.apply(transaction.workspaceId, transaction.transactionId, transaction.planHash, {
             ...(principal === undefined ? {} : { principal }),
             ...(signal === undefined ? {} : { signal }),
             postValidate: async (manifest, validationSignal) => {
-                const validation = await postValidateTransaction(engine, manifest, principal, validationSignal, true);
+                const validation = await postValidateTransaction(engine, manifest, principal, validationSignal);
                 executionArtifacts = [...validation.artifacts];
                 executionArtifacts.unshift(await storeAutonomousValidationEvidence(engine, manifest, validation, principal, validationSignal));
                 return validation;
@@ -124,4 +121,3 @@ export function autonomousFailureContext(error) {
         validation: manifest.validation,
     };
 }
-//# sourceMappingURL=transaction-execution.js.map