hoi4-agent-tools 0.2.0 → 1.0.0

package/dist/bin/setup.js

@@ -9,35 +9,75 @@ import { compareCodeUnits, canonicalJson } from '../hoi4_agent_tools/core/canoni
 import { loadConfiguration } from '../hoi4_agent_tools/core/configuration.js';
 import { CoreEngine } from '../hoi4_agent_tools/core/engine.js';
 import { WorkspaceResolver } from '../hoi4_agent_tools/core/workspace.js';
-import { configurationPath } from '../hoi4_agent_tools/runtime.js';
+import { configurationPath, defaultConfigurationPath } from '../hoi4_agent_tools/runtime.js';
 import { PACKAGE_VERSION } from '../hoi4_agent_tools/version.js';
 function argument(name) {
     const index = process.argv.indexOf(name);
     return index < 0 ? undefined : process.argv[index + 1];
 }
-function usage() {
-    return `HOI4 Agent Tools setup utility
-
-Usage:
-  hoi4-agent-tools-setup --init-config PATH [--workspace ROOT] [--workspace-id ID] [--workspace-name NAME] [--game ROOT] [--autonomous-writes --server-state ROOT]
-  hoi4-agent-tools-setup --init-config PATH [--workspace ROOT] [--reviewed-writes --server-state ROOT]
-  hoi4-agent-tools-setup --discover
-  hoi4-agent-tools-setup --diagnose [--config PATH]
-  hoi4-agent-tools-setup --print-client-config [--config PATH]
-
-The legacy --enable-writes flag is an alias for --reviewed-writes.
-This utility writes only the explicitly requested server config. It never edits an MCP client's settings.`;
+function argumentsFor(name) {
+    const values = [];
+    for (let index = 2; index < process.argv.length; index += 1) {
+        if (process.argv[index] !== name)
+            continue;
+        const value = process.argv[index + 1];
+        if (value === undefined || value.startsWith('--'))
+            throw new Error(`${name} requires a path`);
+        values.push(value);
+        index += 1;
+    }
+    return values;
 }
-async function discover() {
+function assertKnownArguments(flags, valueFlags) {
+    const known = new Set([...flags, ...valueFlags]);
+    for (let index = 2; index < process.argv.length; index += 1) {
+        const value = process.argv[index];
+        if (!known.has(value))
+            throw new Error(`Unknown setup option: ${value}`);
+        if (valueFlags.includes(value)) {
+            const argumentValue = process.argv[index + 1];
+            if (argumentValue === undefined || argumentValue.startsWith('--')) {
+                throw new Error(`${value} requires a path`);
+            }
+            index += 1;
+        }
+    }
+}
+function persistentRoots() {
     const home = homedir();
-    const candidates = new Set([
-        ...(process.env.HOI4_GAME_ROOT === undefined ? [] : [process.env.HOI4_GAME_ROOT]),
+    const dataRoot = process.env.XDG_DATA_HOME ?? process.env.LOCALAPPDATA ?? path.join(home, '.local', 'share');
+    const stateRoot = process.env.XDG_STATE_HOME ?? process.env.LOCALAPPDATA ?? path.join(home, '.local', 'state');
+    return {
+        serverStateRoot: path.join(stateRoot, 'hoi4-agent-tools', 'state'),
+        workspaceStorageRoot: path.join(dataRoot, 'hoi4-agent-tools', 'workspaces'),
+    };
+}
+function standardModRootCandidates() {
+    const home = homedir();
+    const oneDriveRoots = [
+        process.env.OneDrive,
+        process.env.OneDriveConsumer,
+        process.env.OneDriveCommercial,
+        path.join(home, 'OneDrive'),
+    ].filter((value) => value !== undefined);
+    return [
         ...(process.env.HOI4_MOD_ROOTS ?? '').split(path.delimiter).filter(Boolean),
+        ...oneDriveRoots.map((root) => path.join(root, 'Documents', 'Paradox Interactive', 'Hearts of Iron IV', 'mod')),
+        path.join(home, 'Documents', 'Paradox Interactive', 'Hearts of Iron IV', 'mod'),
+        path.join(home, '.local', 'share', 'Paradox Interactive', 'Hearts of Iron IV', 'mod'),
+    ];
+}
+function standardGameRootCandidates() {
+    const home = homedir();
+    return [
+        ...(process.env.HOI4_GAME_ROOT === undefined ? [] : [process.env.HOI4_GAME_ROOT]),
         path.join(process.env['ProgramFiles(x86)'] ?? 'C:\\Program Files (x86)', 'Steam', 'steamapps', 'common', 'Hearts of Iron IV'),
         path.join(home, '.local', 'share', 'Steam', 'steamapps', 'common', 'Hearts of Iron IV'),
         path.join(home, '.steam', 'steam', 'steamapps', 'common', 'Hearts of Iron IV'),
         path.join(home, 'Library', 'Application Support', 'Steam', 'steamapps', 'common', 'Hearts of Iron IV'),
-    ]);
+    ];
+}
+async function existingDirectories(candidates) {
     const existing = new Set();
     for (const candidate of candidates) {
         try {
@@ -46,84 +86,87 @@ async function discover() {
             existing.add(await realpath(candidate));
         }
         catch {
-            // Discovery reports only verified paths and never creates or edits them.
+            // Setup discovery is read-only and reports only verified directories.
+        }
+    }
+    return [...existing].sort((left, right) => compareCodeUnits(left, right));
+}
+async function firstExistingDirectory(candidates) {
+    for (const candidate of candidates) {
+        try {
+            if (!(await stat(candidate)).isDirectory())
+                continue;
+            return await realpath(candidate);
+        }
+        catch {
+            // Continue through the ordered setup candidates.
         }
     }
+    return undefined;
+}
+function usage() {
+    return `HOI4 Agent Tools setup utility
+
+Usage:
+  hoi4-agent-tools-setup --init [--config PATH] [--mod-root PATH ...] [--game-root PATH] [--workspace-storage-root PATH]
+  hoi4-agent-tools-setup --discover
+  hoi4-agent-tools-setup --diagnose [--config PATH]
+  hoi4-agent-tools-setup --print-client-config [--config PATH]
+
+This utility writes only the explicitly requested server config. It never edits an MCP client's settings.`;
+}
+async function discover() {
+    const [modRoots, gameRoots] = await Promise.all([
+        existingDirectories(standardModRootCandidates()),
+        existingDirectories(standardGameRootCandidates()),
+    ]);
     process.stdout.write(`${JSON.stringify({
         status: 'ok',
-        candidates: [...existing].sort((left, right) => compareCodeUnits(left, right)),
-        note: 'Review a candidate and pass it explicitly to --game or --workspace; discovery changes nothing.',
+        modRoots,
+        gameRoots,
     }, null, 2)}\n`);
 }
 async function initializeConfig(target) {
-    const workspaceRoot = argument('--workspace');
-    const gameRoot = argument('--game');
-    const requestedWorkspaceId = argument('--workspace-id');
-    const requestedWorkspaceName = argument('--workspace-name');
-    const autonomousWrites = process.argv.includes('--autonomous-writes');
-    const reviewedWrites = process.argv.includes('--reviewed-writes') || process.argv.includes('--enable-writes');
-    if (autonomousWrites && reviewedWrites) {
-        throw new Error('--autonomous-writes and --reviewed-writes/--enable-writes are mutually exclusive');
-    }
-    const writeEnabled = autonomousWrites || reviewedWrites;
-    const requestedServerStateRoot = argument('--server-state');
-    if (process.argv.includes('--server-state') &&
-        (requestedServerStateRoot === undefined || requestedServerStateRoot.startsWith('--'))) {
-        throw new Error('--server-state requires a directory path');
-    }
-    if (writeEnabled && requestedServerStateRoot === undefined) {
-        throw new Error('Write-enabled setup requires an explicit --server-state ROOT');
-    }
-    for (const [flag, value] of [
-        ['--workspace-id', requestedWorkspaceId],
-        ['--workspace-name', requestedWorkspaceName],
-    ]) {
-        if (process.argv.includes(flag) && (value === undefined || value.startsWith('--'))) {
-            throw new Error(`${flag} requires a value`);
-        }
+    const absolute = path.resolve(target);
+    try {
+        await stat(absolute);
+        throw new Error(`Configuration already exists: ${absolute}`);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
     }
-    if (workspaceRoot === undefined &&
-        (requestedWorkspaceId !== undefined || requestedWorkspaceName !== undefined)) {
-        throw new Error('--workspace-id and --workspace-name require --workspace ROOT');
-    }
-    const workspaceId = requestedWorkspaceId ?? 'mod';
-    if (!/^[a-z][a-z0-9_-]{0,63}$/u.test(workspaceId)) {
-        throw new Error('--workspace-id must match [a-z][a-z0-9_-]{0,63}');
-    }
-    const workspaceName = requestedWorkspaceName ?? (workspaceRoot === undefined ? '' : path.basename(workspaceRoot));
-    if (workspaceRoot !== undefined && (workspaceName.length < 1 || workspaceName.length > 200)) {
-        throw new Error('--workspace-name must contain 1 through 200 characters');
-    }
-    const registrationRoots = workspaceRoot === undefined ? [] : [path.dirname(path.resolve(workspaceRoot))];
-    const workspaces = workspaceRoot === undefined
-        ? []
-        : [
-            {
-                id: workspaceId,
-                name: workspaceName,
-                root: path.resolve(workspaceRoot),
-                ...(gameRoot === undefined ? {} : { gameRoot: path.resolve(gameRoot) }),
-                writeEnabled,
-            },
-        ];
+    const explicitModRoots = argumentsFor('--mod-root');
+    const modRoots = explicitModRoots.length === 0
+        ? await existingDirectories(standardModRootCandidates())
+        : await existingDirectories(explicitModRoots.map((root) => path.resolve(root)));
+    if (modRoots.length === 0 ||
+        (modRoots.length !== explicitModRoots.length && explicitModRoots.length > 0)) {
+        throw new Error('Setup requires at least one existing mod-root directory');
+    }
+    const requestedGameRoot = argument('--game-root');
+    if (process.argv.includes('--game-root') &&
+        (requestedGameRoot === undefined || requestedGameRoot.startsWith('--'))) {
+        throw new Error('--game-root requires a path');
+    }
+    const gameRoot = await firstExistingDirectory(requestedGameRoot === undefined
+        ? standardGameRootCandidates()
+        : [path.resolve(requestedGameRoot)]);
+    if (requestedGameRoot !== undefined && gameRoot === undefined) {
+        throw new Error('--game-root must be an existing directory');
+    }
+    const persistent = persistentRoots();
+    const requestedStorageRoot = argument('--workspace-storage-root');
+    const storageRoot = path.resolve(requestedStorageRoot ?? persistent.workspaceStorageRoot);
+    await mkdir(storageRoot, { recursive: true });
+    const workspaceStorageRoot = await realpath(storageRoot);
     const config = {
         version: 1,
-        writePolicy: autonomousWrites ? 'autonomous' : reviewedWrites ? 'transactions' : 'read-only',
-        ...(requestedServerStateRoot === undefined
-            ? {}
-            : { serverStateRoot: path.resolve(requestedServerStateRoot) }),
-        registrationRoots,
-        writableRegistrationRoots: [],
-        workspaces,
-        http: {
-            host: '127.0.0.1',
-            port: 3210,
-            allowedOrigins: [],
-            tokens: [],
-            principals: [],
-        },
+        serverStateRoot: persistent.serverStateRoot,
+        modRoots,
+        ...(gameRoot === undefined ? {} : { gameRoot }),
+        workspaceStorageRoot,
     };
-    const absolute = path.resolve(target);
     await mkdir(path.dirname(absolute), { recursive: true });
     await writeFile(absolute, `${JSON.stringify(config, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
     process.stdout.write(`${absolute}\n`);
@@ -168,25 +211,28 @@ async function diagnose(configPath) {
 }
 function printClientConfig(configPath) {
     const absolute = path.resolve(configPath);
+    const useDefaultConfiguration = absolute === path.resolve(defaultConfigurationPath());
     const windows = process.platform === 'win32';
     const command = windows ? 'npx.cmd' : 'npx';
     const common = {
         command,
         args: ['-y', `hoi4-agent-tools@${PACKAGE_VERSION}`],
-        env: { HOI4_AGENT_CONFIG: absolute },
+        ...(useDefaultConfiguration ? {} : { env: { HOI4_AGENT_CONFIG: absolute } }),
     };
     const installedCommand = windows ? 'hoi4-agent-tools.cmd' : 'hoi4-agent-tools';
     const installed = {
         command: installedCommand,
         args: [],
-        env: { HOI4_AGENT_CONFIG: absolute },
+        ...(useDefaultConfiguration ? {} : { env: { HOI4_AGENT_CONFIG: absolute } }),
     };
+    const npxToml = `[mcp_servers.hoi4_agent_tools]\ncommand = "${command}"\nargs = ["-y", "hoi4-agent-tools@${PACKAGE_VERSION}"]${useDefaultConfiguration ? '' : `\nenv = { HOI4_AGENT_CONFIG = ${JSON.stringify(absolute)} }`}`;
+    const globalToml = `[mcp_servers.hoi4_agent_tools]\ncommand = "${installedCommand}"${useDefaultConfiguration ? '' : `\nenv = { HOI4_AGENT_CONFIG = ${JSON.stringify(absolute)} }`}`;
     process.stdout.write(`${JSON.stringify({
         note: 'Review and paste one example into your MCP client; this utility does not edit client settings.',
         generic: { mcpServers: { hoi4_agent_tools: common } },
         globalInstall: { mcpServers: { hoi4_agent_tools: installed } },
-        codexToml: `[mcp_servers.hoi4_agent_tools]\ncommand = "${command}"\nargs = ["-y", "hoi4-agent-tools@${PACKAGE_VERSION}"]\nenv = { HOI4_AGENT_CONFIG = ${JSON.stringify(absolute)} }`,
-        codexTomlGlobal: `[mcp_servers.hoi4_agent_tools]\ncommand = "${installedCommand}"\nenv = { HOI4_AGENT_CONFIG = ${JSON.stringify(absolute)} }`,
+        codexToml: npxToml,
+        codexTomlGlobal: globalToml,
     }, null, 2)}\n`);
 }
 async function main() {
@@ -194,21 +240,25 @@ async function main() {
         process.stdout.write(`${usage()}\n`);
         return;
     }
-    const init = argument('--init-config');
-    if (init !== undefined) {
-        await initializeConfig(init);
+    if (process.argv.includes('--init')) {
+        assertKnownArguments(['--init'], ['--config', '--mod-root', '--game-root', '--workspace-storage-root']);
+        const target = argument('--config') ?? defaultConfigurationPath();
+        await initializeConfig(target);
         return;
     }
     if (process.argv.includes('--discover')) {
+        assertKnownArguments(['--discover'], []);
         await discover();
         return;
     }
     const config = configurationPath(process.argv.slice(2));
     if (process.argv.includes('--diagnose')) {
+        assertKnownArguments(['--diagnose'], ['--config']);
         await diagnose(config);
         return;
     }
     if (process.argv.includes('--print-client-config')) {
+        assertKnownArguments(['--print-client-config'], ['--config']);
         printClientConfig(config);
         return;
     }
@@ -222,4 +272,3 @@ main().catch((error) => {
     })}\n`);
     process.exitCode = 1;
 });
-//# sourceMappingURL=setup.js.map

package/dist/bin/stdio.js

@@ -33,4 +33,3 @@ main().catch((error) => {
     })}\n`);
     process.exitCode = 1;
 });
-//# sourceMappingURL=stdio.js.map

package/dist/hoi4_agent_tools/core/artifacts.js

@@ -1044,4 +1044,3 @@ export class ArtifactStore {
         return { sha256: sha256, provenanceHash: provenanceHash, name: name };
     }
 }
-//# sourceMappingURL=artifacts.js.map

package/dist/hoi4_agent_tools/core/canonical.js

@@ -38,4 +38,3 @@ export function deterministicId(prefix, value) {
 export function secureId(prefix) {
     return `${prefix}_${randomUUID()}`;
 }
-//# sourceMappingURL=canonical.js.map

package/dist/hoi4_agent_tools/core/configuration.js

@@ -4,7 +4,9 @@ import { z } from 'zod/v4';
 import { CONFIG_VERSION } from '../version.js';
 import { ServiceError } from './result.js';
 export const HTTP_MAX_SAFE_CONCURRENT_REQUESTS = 2;
-export const HTTP_MAX_AGGREGATE_BODY_BYTES = 16_777_216;
+export const HTTP_MAX_BODY_BYTES = 67_108_864;
+export const HTTP_MAX_AGGREGATE_BODY_BYTES = 134_217_728;
+export const HTTP_DEFAULT_SESSION_EVENT_BYTES = 2_097_152;
 export const WORKSPACE_MAX_REGISTRATIONS = 1_000;
 const WORKSPACE_MAX_SOURCE_ROOTS = 16;
 const WORKSPACE_MAX_PATHS = 1_000;
@@ -90,7 +92,6 @@ export const workspaceRegistrationSchema = z
     artifactRoot: z.string().min(1).optional(),
     cacheRoot: z.string().min(1).optional(),
     fixtureRoot: z.string().min(1).optional(),
-    writeEnabled: z.boolean().default(false),
 })
     .strict()
     .superRefine((value, context) => {
@@ -106,36 +107,27 @@ const tokenSchema = z
     .object({
     principal: z.string().regex(/^[A-Za-z0-9._@-]{1,128}$/),
     tokenEnv: z.string().regex(/^[A-Z][A-Z0-9_]{1,127}$/),
-    workspaceIds: z.array(z.string()).min(1).max(WORKSPACE_MAX_REGISTRATIONS),
-    allowRegistration: z.boolean().default(false),
+    workspaceIds: z.array(z.string()).max(WORKSPACE_MAX_REGISTRATIONS).default([]),
+    allowDiscoveredMods: z.boolean().default(false),
 })
     .strict();
 const principalSchema = z
     .object({
     principal: z.string().regex(/^[A-Za-z0-9._@:-]{1,256}$/),
     workspaceIds: z.array(z.string()).max(WORKSPACE_MAX_REGISTRATIONS).default([]),
-    allowRegistration: z.boolean().default(false),
+    allowDiscoveredMods: z.boolean().default(false),
 })
     .strict();
 export const serverConfigurationSchema = z
     .object({
     version: z.literal(CONFIG_VERSION),
-    writePolicy: z.enum(['read-only', 'transactions', 'autonomous']).default('read-only'),
     serverStateRoot: z
         .string()
         .min(1)
         .refine((value) => path.isAbsolute(value), {
-        message: 'Server state root must be an absolute operator-controlled path',
+        message: 'Server state root must be an absolute private path',
     })
         .optional(),
-    transactionTtlSeconds: z.number().int().min(60).max(86_400).default(3600),
-    transactionMaxJournalBytes: z
-        .number()
-        .int()
-        .min(1_048_576)
-        .max(Number.MAX_SAFE_INTEGER)
-        .default(536_870_912),
-    transactionMaxJournals: z.number().int().min(1).max(10_000).default(128),
     scanMaxFiles: z.number().int().min(1).max(1_000_000).default(20_000),
     scanMaxBytes: z.number().int().min(1_048_576).max(Number.MAX_SAFE_INTEGER).default(134_217_728),
     scanMaxFileBytes: z.number().int().min(65_536).max(Number.MAX_SAFE_INTEGER).default(67_108_864),
@@ -152,11 +144,9 @@ export const serverConfigurationSchema = z
         .min(1_048_576)
         .max(Number.MAX_SAFE_INTEGER)
         .default(134_217_728),
-    registrationRoots: z.array(z.string().min(1)).max(WORKSPACE_MAX_SOURCE_ROOTS).default([]),
-    writableRegistrationRoots: z
-        .array(z.string().min(1))
-        .max(WORKSPACE_MAX_SOURCE_ROOTS)
-        .default([]),
+    modRoots: z.array(z.string().min(1)).max(WORKSPACE_MAX_SOURCE_ROOTS).default([]),
+    gameRoot: z.string().min(1).optional(),
+    workspaceStorageRoot: z.string().min(1).optional(),
     storageRoots: z.array(z.string().min(1)).max(WORKSPACE_MAX_SOURCE_ROOTS).default([]),
     workspaces: z.array(workspaceRegistrationSchema).max(WORKSPACE_MAX_REGISTRATIONS).default([]),
     http: z
@@ -181,7 +171,12 @@ export const serverConfigurationSchema = z
         })
             .strict()
             .optional(),
-        maxBodyBytes: z.number().int().min(1024).max(16_777_216).default(1_048_576),
+        maxBodyBytes: z
+            .number()
+            .int()
+            .min(1024)
+            .max(HTTP_MAX_BODY_BYTES)
+            .default(HTTP_MAX_BODY_BYTES),
         headersTimeoutMs: z.number().int().min(1_000).max(120_000).default(10_000),
         requestTimeoutMs: z.number().int().min(1_000).max(300_000).default(30_000),
         keepAliveTimeoutMs: z.number().int().min(1_000).max(120_000).default(5_000),
@@ -197,7 +192,12 @@ export const serverConfigurationSchema = z
         maxSessionsPerPrincipal: z.number().int().min(1).max(10_000).default(32),
         maxEventStreams: z.number().int().min(1).max(10_000).default(32),
         maxEventStreamsPerPrincipal: z.number().int().min(1).max(10_000).default(4),
-        maxSessionEventBytes: z.number().int().min(65_536).max(67_108_864).default(1_048_576),
+        maxSessionEventBytes: z
+            .number()
+            .int()
+            .min(65_536)
+            .max(67_108_864)
+            .default(HTTP_DEFAULT_SESSION_EVENT_BYTES),
         maxEventStoreBytes: z.number().int().min(65_536).max(268_435_456).default(16_777_216),
         requestsPerMinute: z.number().int().min(1).max(100_000).default(120),
         sessionTtlSeconds: z.number().int().min(60).max(86_400).default(3600),
@@ -257,7 +257,7 @@ export const serverConfigurationSchema = z
         trustedProxyAddresses: [],
         tokens: [],
         principals: [],
-        maxBodyBytes: 1_048_576,
+        maxBodyBytes: HTTP_MAX_BODY_BYTES,
         headersTimeoutMs: 10_000,
         requestTimeoutMs: 30_000,
         keepAliveTimeoutMs: 5_000,
@@ -268,7 +268,7 @@ export const serverConfigurationSchema = z
         maxSessionsPerPrincipal: 32,
         maxEventStreams: 32,
         maxEventStreamsPerPrincipal: 4,
-        maxSessionEventBytes: 1_048_576,
+        maxSessionEventBytes: HTTP_DEFAULT_SESSION_EVENT_BYTES,
         maxEventStoreBytes: 16_777_216,
         requestsPerMinute: 120,
         sessionTtlSeconds: 3600,
@@ -276,11 +276,12 @@ export const serverConfigurationSchema = z
 })
     .strict()
     .superRefine((value, context) => {
-    if (value.writePolicy !== 'read-only' && value.serverStateRoot === undefined) {
+    const hasModWorkspace = value.workspaces.some(({ kind }) => kind === 'mod');
+    if ((value.modRoots.length > 0 || hasModWorkspace) && value.serverStateRoot === undefined) {
         context.addIssue({
             code: 'custom',
             path: ['serverStateRoot'],
-            message: 'Write policies require an operator-controlled server state root',
+            message: 'Writable mod workspaces require a separate private server state root',
         });
     }
     if (value.scanMaxFileBytes > value.scanMaxBytes) {
@@ -332,7 +333,7 @@ export const serverConfigurationSchema = z
         context.addIssue({
             code: 'custom',
             path: ['http', 'maxBodyBytes'],
-            message: 'HTTP body-byte ceiling multiplied by concurrency must not exceed 16 MiB',
+            message: 'HTTP body-byte ceiling multiplied by concurrency must not exceed 128 MiB',
         });
     }
 });
@@ -380,4 +381,3 @@ export async function loadConfiguration(filePath) {
     }
     return result.data;
 }
-//# sourceMappingURL=configuration.js.map

package/dist/hoi4_agent_tools/core/diagnostic-collector.js

@@ -42,4 +42,3 @@ export class DiagnosticCollector {
         ];
     }
 }
-//# sourceMappingURL=diagnostic-collector.js.map

package/dist/hoi4_agent_tools/core/diagnostics.js

@@ -22,4 +22,3 @@ export function sortDiagnostics(diagnostics) {
 export function hasBlockingDiagnostics(diagnostics) {
     return diagnostics.some(({ severity }) => severity === 'error' || severity === 'blocker');
 }
-//# sourceMappingURL=diagnostics.js.map

package/dist/hoi4_agent_tools/core/diff.js

@@ -90,4 +90,3 @@ export function binaryDiff(oldBytes, newBytes) {
     };
 }
 import { ServiceError } from './result.js';
-//# sourceMappingURL=diff.js.map

package/dist/hoi4_agent_tools/core/engine.js

@@ -3,6 +3,9 @@ import { SymbolIndex } from './index.js';
 import { WorkspaceScanner } from './scanner.js';
 import { ArtifactStore } from './artifacts.js';
 import { TransactionManager } from './transactions.js';
+const RECOVERY_TTL_SECONDS = 3_600;
+const RECOVERY_MAX_BYTES = 536_870_912;
+const RECOVERY_MAX_RECORDS = 128;
 function abortReason(signal) {
     return signal.reason instanceof Error
         ? signal.reason
@@ -67,38 +70,21 @@ export class CoreEngine {
                 new ArtifactStore(resolver.config().artifactMaxBytes, resolver.config().artifactMaxEntries, resolver.config().artifactMaxSingleBytes);
         this.transactions =
             services.transactions ??
-                new TransactionManager(resolver, this.artifacts, resolver.config().transactionTtlSeconds, resolver.config().transactionMaxJournalBytes, resolver.config().transactionMaxJournals, resolver.serverState());
+                new TransactionManager(resolver, this.artifacts, RECOVERY_TTL_SECONDS, RECOVERY_MAX_BYTES, RECOVERY_MAX_RECORDS, resolver.serverState());
     }
     async initialize() {
         for (const workspace of this.resolver.list()) {
-            // Recovery is a safety repair, not a newly authorized write. An interrupted
-            // transaction must be restored even if the operator restarts read-only.
+            // Recovery repairs an interrupted internal rewrite before the workspace is exposed.
             await this.transactions.recover(workspace.id);
         }
     }
-    async register(registration, principal, signal) {
-        signal?.throwIfAborted();
-        const workspace = await this.resolver.register(registration, principal, signal);
-        // Runtime registrations are intentionally not persisted, so startup could not
-        // discover an interrupted journal for this root. Recover it before exposing the
-        // workspace or allowing another write transaction.
-        try {
-            await this.transactions.recover(workspace.id, principal, signal);
-        }
-        catch (error) {
-            this.resolver.unregisterRuntime(workspace.id, principal);
-            throw error;
-        }
-        return this.status(workspace.id, principal);
-    }
     status(workspaceId, principal) {
         const workspace = this.resolver.get(workspaceId, principal);
         return {
             id: workspace.id,
             name: workspace.name,
             kind: workspace.registration.kind,
-            writeEnabled: workspace.writeEnabled,
-            writePolicy: this.resolver.config().writePolicy,
+            writable: workspace.writeEnabled,
             rootKinds: [...new Set(workspace.roots.map(({ kind }) => kind))].sort((a, b) => compareCodeUnits(a, b)),
             dependencyCount: workspace.dependencyRoots.length,
             replacePaths: [...workspace.registration.replacePaths].sort((a, b) => compareCodeUnits(a, b)),
@@ -317,4 +303,3 @@ export class CoreEngine {
         return SymbolIndex.build(files);
     }
 }
-//# sourceMappingURL=engine.js.map

package/dist/hoi4_agent_tools/core/image-diff.js

@@ -118,4 +118,3 @@ export async function comparePngImages(leftPng, rightPng, threshold = 8, signal,
         })}\n`,
     };
 }
-//# sourceMappingURL=image-diff.js.map

package/dist/hoi4_agent_tools/core/index.js

@@ -968,4 +968,3 @@ export class SymbolIndex {
         this.diagnostics.splice(0, this.diagnostics.length, ...sorted);
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/hoi4_agent_tools/core/render-budget.js

@@ -106,4 +106,3 @@ export class RenderBudget {
         return dimensions;
     }
 }
-//# sourceMappingURL=render-budget.js.map

package/dist/hoi4_agent_tools/core/result.js

@@ -23,4 +23,3 @@ export class ServiceError extends Error {
         this.name = 'ServiceError';
     }
 }
-//# sourceMappingURL=result.js.map

package/dist/hoi4_agent_tools/core/scanner.js

@@ -133,4 +133,3 @@ async function readBoundedFile(handle, remainingBytes, signal) {
     }
     return Buffer.concat(chunks, total);
 }
-//# sourceMappingURL=scanner.js.map

package/dist/hoi4_agent_tools/core/server-state.js

@@ -410,4 +410,3 @@ export class ServerState {
         return head;
     }
 }
-//# sourceMappingURL=server-state.js.map

package/dist/hoi4_agent_tools/core/source/encoding.js

@@ -51,4 +51,3 @@ export function encodeSource(text, encoding) {
     }
     return encoded;
 }
-//# sourceMappingURL=encoding.js.map

package/dist/hoi4_agent_tools/core/source/index.js

@@ -4,4 +4,3 @@ export * from './limits.js';
 export * from './localisation.js';
 export * from './parser.js';
 export * from './rewrite.js';
-//# sourceMappingURL=index.js.map

package/dist/hoi4_agent_tools/core/source/lexer.js

@@ -263,4 +263,3 @@ export function lexClausewitz(text, sourcePath, options = {}) {
     }
     return { tokens, diagnostics: diagnostics.diagnostics };
 }
-//# sourceMappingURL=lexer.js.map

package/dist/hoi4_agent_tools/core/source/limits.js

@@ -46,4 +46,3 @@ export class SourceDiagnosticCollector {
         this.#truncated = true;
     }
 }
-//# sourceMappingURL=limits.js.map

package/dist/hoi4_agent_tools/core/source/localisation.js

@@ -160,4 +160,3 @@ export function parseLocalisation(bytes, sourcePath) {
     }
     return { ...decoded, path: sourcePath, lineIndex, entries, diagnostics };
 }
-//# sourceMappingURL=localisation.js.map

package/dist/hoi4_agent_tools/core/source/parser.js

@@ -331,4 +331,3 @@ export function nodeLocation(document, node, symbol) {
     const location = locationFor(document.path, document.lineIndex, node.start, node.end);
     return symbol === undefined ? location : { ...location, symbol };
 }
-//# sourceMappingURL=parser.js.map

package/dist/hoi4_agent_tools/core/source/rewrite.js

@@ -25,4 +25,3 @@ export function applyReplacements(document, replacements) {
     pieces.push(document.text.slice(cursor));
     return encodeDocumentText(document, pieces.join(''));
 }
-//# sourceMappingURL=rewrite.js.map

package/dist/hoi4_agent_tools/core/svg-text.js

@@ -124,4 +124,3 @@ export class DeterministicSvgTextRenderer {
             .join('');
     }
 }
-//# sourceMappingURL=svg-text.js.map