hoi4-agent-tools 3.10.0 → 4.0.0

package/dist/hoi4_agent_tools/core/operation-result.js

@@ -4,7 +4,20 @@ import { ServiceError, MAX_INLINE_ARTIFACT_LINKS } from './result.js';
 export { MAX_INLINE_ARTIFACT_LINKS } from './result.js';
 import { diagnosticSchema } from '../schemas/common.js';
 import { artifactLinkSchema, validationSummarySchema } from '../schemas/transaction.js';
-export const MAX_INLINE_FILES_SCANNED = 64;
+// Agents act on the mod's own files; a long inventory of scanned game files is linked evidence.
+export const MAX_INLINE_FILES_SCANNED = 12;
+/**
+ * Resource links shown beside the summary. Every artifact stays in `structuredContent.artifacts`,
+ * which clients show as well, so a long gallery is not listed twice; images and reports come first.
+ */
+export const MAX_CONTENT_RESOURCE_LINKS = 8;
+const linkPriority = (mimeType) => mimeType === 'image/png'
+    ? 0
+    : mimeType === 'text/html'
+        ? 2
+        : mimeType === 'image/svg+xml'
+            ? 3
+            : 1;
 export const MAX_INLINE_PROPOSED_FILES = 64;
 export const MAX_INLINE_CHANGED_FILES = 64;
 export const MAX_INLINE_DIAGNOSTICS = 20;
@@ -73,7 +86,12 @@ export function strictOperationResultSchema(successDataSchema) {
 }
 /** Keep source inventories compact; complete inventories belong in linked resources. */
 export function setInlineFilesScanned(result, files) {
-    result.filesScanned = files.slice(0, MAX_INLINE_FILES_SCANNED);
+    // Mod files first: they are the ones an agent can change.
+    const ordered = [
+        ...files.filter((file) => file.startsWith('mod:')),
+        ...files.filter((file) => !file.startsWith('mod:')),
+    ];
+    result.filesScanned = ordered.slice(0, MAX_INLINE_FILES_SCANNED);
     if (files.length <= MAX_INLINE_FILES_SCANNED)
         return;
     const truncation = {
@@ -103,6 +121,40 @@ function preserveDeferredFilesDiagnostic(result) {
         diagnostics: [deferred, ...result.diagnostics].slice(0, MAX_INLINE_DIAGNOSTICS),
     };
 }
+/**
+ * When a result is too large, keep the first few diagnostics with their code, message and
+ * location only; the linked evidence holds the rest.
+ */
+function essentialDiagnostics(diagnostics) {
+    const kept = [];
+    let bytes = 0;
+    for (const diagnostic of diagnostics) {
+        if (diagnostic.code === 'MCP_RESPONSE_TRUNCATED' || kept.length >= 5)
+            continue;
+        const essential = {
+            code: diagnostic.code.slice(0, 256),
+            severity: diagnostic.severity,
+            category: diagnostic.category,
+            message: diagnostic.message.slice(0, 300),
+            ...(diagnostic.location === undefined
+                ? {}
+                : {
+                    location: {
+                        ...diagnostic.location,
+                        path: diagnostic.location.path.slice(0, 512),
+                        ...(diagnostic.location.symbol === undefined
+                            ? {}
+                            : { symbol: diagnostic.location.symbol.slice(0, 128) }),
+                    },
+                }),
+        };
+        bytes += Buffer.byteLength(JSON.stringify(essential), 'utf8');
+        if (bytes > 6_000)
+            break;
+        kept.push(essential);
+    }
+    return kept;
+}
 function boundedResult(result, actualBytes) {
     const hasLinkedEvidence = result.artifacts.length > 0;
     const truncationDiagnostic = {
@@ -124,7 +176,7 @@ function boundedResult(result, actualBytes) {
         filesScanned: [],
         proposedFiles: [],
         changedFiles: [],
-        diagnostics: [truncationDiagnostic],
+        diagnostics: [truncationDiagnostic, ...essentialDiagnostics(result.diagnostics)],
         artifacts: result.artifacts
             .slice(0, 1)
             .map(({ description: _description, ...artifact }) => artifact),
@@ -225,10 +277,28 @@ function jsonBytesWithin(value, budget) {
     };
     return visit(value);
 }
+/** The most frequent diagnostic codes, so an omitted flood is still visible by kind. */
+function diagnosticCodeCounts(diagnostics) {
+    const counts = new Map();
+    for (const { code } of diagnostics)
+        counts.set(code, (counts.get(code) ?? 0) + 1);
+    return Object.fromEntries([...counts]
+        .sort(([leftCode, left], [rightCode, right]) => right - left || (leftCode < rightCode ? -1 : leftCode > rightCode ? 1 : 0))
+        .slice(0, 12)
+        .map(([code, count]) => [code.slice(0, 256), count]));
+}
 function compactDetails(details) {
     return jsonBytesWithin(details, 2_048) ? details : { truncated: true };
 }
-function compactDescriptions(result) {
+/** A passed check that only says its problem was not found carries nothing to act on. */
+function withoutCleanChecks(result) {
+    const checks = result.validation.checks.filter((check) => !(check.passed && check.message.endsWith('not detected.')));
+    return checks.length === result.validation.checks.length
+        ? result
+        : { ...result, validation: { ...result.validation, checks } };
+}
+function compactDescriptions(unfiltered) {
+    const result = withoutCleanChecks(unfiltered);
     const compactLocation = (location) => location === undefined
         ? undefined
         : {
@@ -268,8 +338,13 @@ function compactDescriptions(result) {
     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));
+    // Within each class, diagnostics in the mod's own files come before game or dependency ones.
+    const modFirst = (diagnostics) => [
+        ...diagnostics.filter(({ location }) => location?.path.startsWith('mod:') === true),
+        ...diagnostics.filter(({ location }) => location?.path.startsWith('mod:') !== true),
+    ];
+    const priorityDiagnostics = modFirst(result.diagnostics.filter(({ code, severity }) => severity === 'error' || severity === 'blocker' || code === 'MCP_INLINE_FILES_TRUNCATED'));
+    const otherDiagnostics = modFirst(result.diagnostics.filter((diagnostic) => !priorityDiagnostics.includes(diagnostic)));
     const retainedPriorityDiagnostics = priorityDiagnostics.slice(0, diagnosticSlots);
     const retainedDiagnostics = [
         ...retainedPriorityDiagnostics,
@@ -305,6 +380,9 @@ function compactDescriptions(result) {
                 collections: truncatedCollections,
                 diagnosticsReturned: retainedDiagnostics.length,
                 omittedHardDiagnostics,
+                ...(result.diagnostics.length > retainedDiagnostics.length
+                    ? { codeCounts: diagnosticCodeCounts(result.diagnostics) }
+                    : {}),
             },
         }
         : undefined;
@@ -340,7 +418,13 @@ function compactDescriptions(result) {
 }
 function buildToolResult(selected) {
     const structuredContent = operationResultSchema.parse(selected);
-    const links = selected.artifacts.map((artifact) => ({
+    const shown = selected.artifacts
+        .map((artifact, order) => ({ artifact, order }))
+        .sort((left, right) => linkPriority(left.artifact.mimeType) - linkPriority(right.artifact.mimeType) ||
+        left.order - right.order)
+        .slice(0, MAX_CONTENT_RESOURCE_LINKS)
+        .map(({ artifact }) => artifact);
+    const links = shown.map((artifact) => ({
         type: 'resource_link',
         uri: artifact.uri,
         name: artifact.name,
@@ -348,11 +432,27 @@ function buildToolResult(selected) {
         ...(artifact.description === undefined ? {} : { description: artifact.description }),
         ...(artifact.size === undefined ? {} : { size: artifact.size }),
     }));
+    // Clients show an error's text, not its structured content, so an error or a blocked
+    // result carries what went wrong and how to proceed in the text as well.
     const summary = canonicalJson({
         status: selected.status,
         code: selected.code,
         workspaceId: selected.workspaceId,
         artifactCount: selected.artifacts.length,
+        ...(selected.artifacts.length > shown.length
+            ? { artifactsListedInStructuredContent: selected.artifacts.length }
+            : {}),
+        ...(selected.status === 'ok' || selected.blockers.length === 0
+            ? {}
+            : {
+                blockers: selected.blockers.slice(0, 3).map(({ code, message, details }) => ({
+                    code,
+                    message,
+                    ...(details === undefined || Object.keys(details).length === 0
+                        ? {}
+                        : { details: compactDetails(details) }),
+                })),
+            }),
     });
     return {
         content: [{ type: 'text', text: summary }, ...links],
@@ -378,10 +478,23 @@ export function toolResult(result) {
     }
     return output;
 }
+/** Paths in a message can name private folders; the file name is enough to act on. */
+function withoutDirectories(message) {
+    return message
+        .replace(/(?:[A-Za-z]:)?[\\/](?:[^\s'"`:\\/]+[\\/])+([^\s'"`:\\/]+)/gu, '$1')
+        .slice(0, 300);
+}
+/**
+ * An unexpected failure is a server defect. Name the error kind and its path-free message so
+ * the caller can tell a malformed source from a bug, and say what to do next.
+ */
+export function internalServiceError(error) {
+    const kind = error instanceof Error ? error.name : typeof error;
+    const message = error instanceof Error ? withoutDirectories(error.message) : '';
+    return new ServiceError('INTERNAL_ERROR', `Unexpected ${kind}${message.length > 0 ? `: ${message}` : ''}. Retry once with a narrower selector; if it repeats, report this message with the tool name and arguments.`);
+}
 export function errorResult(error, workspaceId = '', context = {}) {
-    const serviceError = error instanceof ServiceError
-        ? error
-        : new ServiceError('INTERNAL_ERROR', 'Unexpected internal error');
+    const serviceError = error instanceof ServiceError ? error : internalServiceError(error);
     const internalWriteError = serviceError.code.startsWith('TRANSACTION_');
     const publicCode = internalWriteError
         ? `REWRITE_${serviceError.code.slice('TRANSACTION_'.length)}`

package/dist/hoi4_agent_tools/core/operation-tasks.js

@@ -1,12 +1,6 @@
 import { z } from 'zod/v4';
-import { decisionInspectRequestSchema, impactInspectRequestSchema } from '../schemas/analysis.js';
-import { mechanicTestRequestSchema, packageCheckRequestSchema, scenarioTestRequestSchema, } from '../schemas/scenarios.js';
-import { eventCompareRequestSchema, eventInspectRequestSchema, eventRenderRequestSchema, } from '../schemas/event.js';
-import { focusInspectRequestSchema, focusRenderRequestSchema, focusRewriteRequestSchema, } from '../schemas/focus-requests.js';
-import { guiInspectRequestSchema, guiRenderRequestSchema, guiRewriteRequestSchema, } from '../schemas/gui-requests.js';
-import { mapInspectRequestSchema, mapRenderRequestSchema, mapRewriteRequestSchema, } from '../schemas/map-requests.js';
-import { probabilityCompareRequestSchema, probabilityEvaluateRequestSchema, probabilityInspectRequestSchema, probabilityRenderRequestSchema, probabilitySequenceRequestSchema, probabilitySimulateRequestSchema, probabilitySweepRequestSchema, } from '../schemas/probability-requests.js';
-import { technologyCompareRequestSchema, technologyInspectRequestSchema, technologyRenderRequestSchema, } from '../schemas/technology.js';
+import { DOMAIN_TOOL_ARGUMENT_SCHEMAS, DOMAIN_TOOL_NAMES, MUTATION_TOOL_NAMES, } from './domain-tools.js';
+import { normalizeToolArguments } from '../schemas/lenient-arguments.js';
 import { currentJobOwner, jobOwnerLiveness, jobRetentionExpired, } from './job-store.js';
 import { JobService } from './job-service.js';
 import { JobWorkerHost, workerFailure } from './job-worker-host.js';
@@ -26,78 +20,18 @@ const authenticatedTaskIdSchema = z
     .regex(/^[a-z][a-z0-9_-]{0,63}:job_[a-f0-9]{64}\.[a-f0-9]{64}$/u);
 export const operationTaskCallSchema = z
     .object({
-    name: z.enum([
-        'hoi4.impact_inspect',
-        'hoi4.decision_inspect',
-        'hoi4.mechanic_test',
-        'hoi4.package_check',
-        'hoi4.scenario_test',
-        'hoi4.event_inspect',
-        'hoi4.event_render',
-        'hoi4.event_compare',
-        'hoi4.tech_inspect',
-        'hoi4.tech_render',
-        'hoi4.tech_compare',
-        'hoi4.probability_inspect',
-        'hoi4.probability_evaluate',
-        'hoi4.probability_sweep',
-        'hoi4.probability_simulate',
-        'hoi4.probability_sequence',
-        'hoi4.probability_compare',
-        'hoi4.probability_render',
-        'hoi4.map_inspect',
-        'hoi4.map_render',
-        'hoi4.map_rewrite',
-        'hoi4.gui_inspect',
-        'hoi4.gui_render',
-        'hoi4.gui_rewrite',
-        'hoi4.focus_inspect',
-        'hoi4.focus_render',
-        'hoi4.focus_raster',
-        'hoi4.focus_rewrite',
-    ]),
+    name: z.enum(DOMAIN_TOOL_NAMES),
     arguments: z.record(z.string(), z.json()),
 })
     .strict();
-const taskArgumentSchemas = {
-    'hoi4.impact_inspect': impactInspectRequestSchema,
-    'hoi4.decision_inspect': decisionInspectRequestSchema,
-    'hoi4.mechanic_test': mechanicTestRequestSchema,
-    'hoi4.package_check': packageCheckRequestSchema,
-    'hoi4.scenario_test': scenarioTestRequestSchema,
-    'hoi4.event_inspect': eventInspectRequestSchema,
-    'hoi4.event_render': eventRenderRequestSchema,
-    'hoi4.event_compare': eventCompareRequestSchema,
-    'hoi4.tech_inspect': technologyInspectRequestSchema,
-    'hoi4.tech_render': technologyRenderRequestSchema,
-    'hoi4.tech_compare': technologyCompareRequestSchema,
-    'hoi4.probability_inspect': probabilityInspectRequestSchema,
-    'hoi4.probability_evaluate': probabilityEvaluateRequestSchema,
-    'hoi4.probability_sweep': probabilitySweepRequestSchema,
-    'hoi4.probability_simulate': probabilitySimulateRequestSchema,
-    'hoi4.probability_sequence': probabilitySequenceRequestSchema,
-    'hoi4.probability_compare': probabilityCompareRequestSchema,
-    'hoi4.probability_render': probabilityRenderRequestSchema,
-    'hoi4.map_inspect': mapInspectRequestSchema,
-    'hoi4.map_render': mapRenderRequestSchema,
-    'hoi4.map_rewrite': mapRewriteRequestSchema,
-    'hoi4.gui_inspect': guiInspectRequestSchema,
-    'hoi4.gui_render': guiRenderRequestSchema,
-    'hoi4.gui_rewrite': guiRewriteRequestSchema,
-    'hoi4.focus_inspect': focusInspectRequestSchema,
-    'hoi4.focus_render': focusRenderRequestSchema,
-    'hoi4.focus_raster': focusRenderRequestSchema,
-    'hoi4.focus_rewrite': focusRewriteRequestSchema,
-};
+const taskArgumentSchemas = DOMAIN_TOOL_ARGUMENT_SCHEMAS;
 const sourceResolvingTools = new Set([
     'hoi4.focus_inspect',
     'hoi4.focus_render',
-    'hoi4.focus_raster',
     'hoi4.focus_rewrite',
 ]);
-const mutationTools = new Set(['hoi4.gui_rewrite', 'hoi4.map_rewrite', 'hoi4.focus_rewrite']);
 export function isMutationTask(name) {
-    return mutationTools.has(name);
+    return MUTATION_TOOL_NAMES.has(name);
 }
 function taskRetention(ttl) {
     if (ttl === undefined || ttl === null)
@@ -133,26 +67,43 @@ export function operationTaskMessage(record) {
         return 'Cancellation requested';
     return undefined;
 }
-/** Protocol-independent task execution, ownership, retention, and recovery over durable jobs. */
+const engineTaskStates = new WeakMap();
+const REJECTED_TASK_RETENTION_MS = 300_000;
+/** Let an engine's idle warm workers exit, for example when its last client disconnects. */
+export async function releaseIdleWorkers(engine) {
+    const worker = engineTaskStates.get(engine)?.worker;
+    if (worker === undefined)
+        return;
+    (await worker.catch(() => undefined))?.releaseIdleWorkers();
+}
 export class OperationTaskService {
     engine;
-    jobsPromise;
-    workerPromise;
-    launches = new Map();
+    state;
     constructor(engine) {
         this.engine = engine;
+        const state = engineTaskStates.get(engine) ?? { launches: new Map() };
+        engineTaskStates.set(engine, state);
+        this.state = state;
+    }
+    get launches() {
+        return this.state.launches;
     }
     jobs() {
-        this.jobsPromise ??= JobService.create(this.engine.resolver);
-        return this.jobsPromise;
+        // The first use per engine also sweeps results nobody will read again.
+        this.state.jobs ??= JobService.create(this.engine.resolver).then(async (jobs) => {
+            await jobs.store.sweepExpired().catch(() => 0);
+            return jobs;
+        });
+        return this.state.jobs;
     }
     worker() {
-        this.workerPromise ??= this.jobs().then((jobs) => JobWorkerHost.create(this.engine, jobs));
-        return this.workerPromise;
+        this.state.worker ??= this.jobs().then((jobs) => JobWorkerHost.create(this.engine, jobs));
+        return this.state.worker;
     }
     async submit(input, context, options) {
         const parsed = operationTaskCallSchema.parse(input);
-        const validatedArguments = taskArgumentSchemas[parsed.name].parse(parsed.arguments);
+        // The same shorthand normalization as the transport, for callers that submit directly.
+        const validatedArguments = taskArgumentSchemas[parsed.name].parse(normalizeToolArguments(parsed.name, parsed.arguments));
         const requestSignal = options.signal;
         const mutation = isMutationTask(parsed.name);
         const explicitTask = options.background;
@@ -201,16 +152,24 @@ export class OperationTaskService {
                 pollInterval: TASK_POLL_INTERVAL,
             },
         }, context.principal, requestSignal);
+        let cancel;
         if (!explicitTask && requestSignal !== undefined) {
             if (requestSignal.aborted) {
                 return jobs.cancel(workspaceId, record.id, context.principal);
             }
-            const cancel = () => {
+            cancel = () => {
                 void jobs.cancel(workspaceId, record.id, context.principal).catch(() => undefined);
             };
             requestSignal.addEventListener('abort', cancel, { once: true });
         }
-        await this.ensureExecution(record, context.principal);
+        this.ensureExecution(record, context.principal);
+        // A finished job needs no cancellation; release the listener with its execution.
+        if (cancel !== undefined && requestSignal !== undefined) {
+            const listener = cancel;
+            const release = () => requestSignal.removeEventListener('abort', listener);
+            // Release on rejection too; the launch handles its own failure where it is created.
+            void this.launches.get(operationTaskId(record))?.then(release, release);
+        }
         return record;
     }
     async get(value, context, options = {}) {
@@ -237,7 +196,7 @@ export class OperationTaskService {
         // Verify before resuming: a malformed or guessed reference must not admit execution.
         return this.resume(record, context, options);
     }
-    async resume(record, context, options) {
+    resume(record, context, options) {
         if (record?.request.protocolTask === undefined)
             return null;
         if (options.resume === false)
@@ -247,7 +206,7 @@ export class OperationTaskService {
             context.scopes !== undefined &&
             !context.scopes.includes('hoi4:write'))
             return record;
-        await this.ensureExecution(record, context.principal);
+        this.ensureExecution(record, context.principal);
         return record;
     }
     async assertPublishedResult(value, status, result, context) {
@@ -351,7 +310,8 @@ export class OperationTaskService {
             mutation: false,
             requestKey: `rejected:${secureId('request')}`,
             protocolTask: {
-                ttl: taskRetention(options.ttlMs),
+                // A refusal is read once; it need not outlive a short retry window.
+                ttl: Math.min(taskRetention(options.ttlMs), REJECTED_TASK_RETENTION_MS),
                 pollInterval: TASK_POLL_INTERVAL,
             },
         }, context.principal);
@@ -363,7 +323,7 @@ export class OperationTaskService {
         });
         return completed;
     }
-    async ensureExecution(record, principal) {
+    ensureExecution(record, principal) {
         if (['completed', 'failed', 'cancelled'].includes(record.status))
             return;
         if (record.status !== 'queued' &&
@@ -372,9 +332,9 @@ export class OperationTaskService {
         const key = operationTaskId(record);
         if (this.launches.has(key))
             return;
-        const worker = await this.worker();
-        const launched = worker
-            .run(record.scope.workspaceId, record.id, principal)
+        // Registered before any await, so a concurrent poll cannot start a second launcher.
+        const launched = this.worker()
+            .then((worker) => worker.run(record.scope.workspaceId, record.id, principal))
             .then(() => undefined)
             .catch(async (error) => {
             const jobs = await this.jobs();

package/dist/hoi4_agent_tools/core/persistent-analysis-cache.js

@@ -11,7 +11,7 @@ const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const entryKindSchema = z.enum(['source-document', 'index-segment']);
 const unsignedEntrySchema = z
     .object({
-    version: z.literal(1),
+    version: z.literal(2),
     kind: entryKindSchema,
     scopeHash: digestSchema,
     address: digestSchema,
@@ -23,6 +23,15 @@ const unsignedEntrySchema = z
     .strict();
 const entrySchema = unsignedEntrySchema.extend({ authenticationTag: digestSchema }).strict();
 const entryFilePattern = /^(?<address>[a-f0-9]{64})\.json$/u;
+/**
+ * What the authentication tag covers: every field but the payload bytes, which the tag binds
+ * through their SHA-256. A reader hashes the payload once and compares it, so the megabytes of
+ * a parsed document do not pass through canonical JSON and the HMAC as well.
+ */
+function entryIdentity(entry) {
+    const { payload: _payload, ...identity } = entry;
+    return { kind: 'analysis-cache-entry.v2', entry: identity };
+}
 function sourceAddress(key) {
     return hashCanonical({
         version: 'persistent-source-document.v1',
@@ -114,10 +123,7 @@ export class PersistentAnalysisCache {
                 const payload = await this.read(scopeHash, 'source-document', documentAddress, signal);
                 if (payload !== undefined) {
                     try {
-                        documents.importEncoded(key, payload, {
-                            bytes: file.bytes,
-                            sourcePath: file.displayPath,
-                        });
+                        documents.importEncoded(key, payload);
                     }
                     catch {
                         this.#invalidEntries += 1;
@@ -172,22 +178,23 @@ export class PersistentAnalysisCache {
                 }
                 const key = sourceDocumentCacheKey(file.bytes, file.displayPath);
                 const documentAddress = sourceAddress(key);
-                const document = documents.exportEncoded(key);
-                if (document !== undefined &&
-                    (!sourceEntries.has(documentAddress) ||
-                        this.#invalidAddresses.has(`${scopeHash}\0source-document\0${documentAddress}`))) {
-                    if (await retain('source-document', documentAddress, document)) {
+                // Stored entries are skipped before their payload is exported, which copies it.
+                if (!sourceEntries.has(documentAddress) ||
+                    this.#invalidAddresses.has(`${scopeHash}\0source-document\0${documentAddress}`)) {
+                    const document = documents.exportEncoded(key);
+                    if (document !== undefined &&
+                        (await retain('source-document', documentAddress, document))) {
                         sourceEntries.add(documentAddress);
                     }
                 }
                 for (const provinceDefinition of [false, true]) {
                     const address = indexSegmentAddress(file, provinceDefinition);
-                    const segment = segments.exportEncoded(address);
-                    if (segment === undefined ||
-                        (indexEntries.has(address) &&
-                            !this.#invalidAddresses.has(`${scopeHash}\0index-segment\0${address}`)))
+                    if (indexEntries.has(address) &&
+                        !this.#invalidAddresses.has(`${scopeHash}\0index-segment\0${address}`))
                         continue;
-                    if (await retain('index-segment', address, Buffer.from(segment))) {
+                    const segment = segments.exportEncoded(address);
+                    if (segment !== undefined &&
+                        (await retain('index-segment', address, Buffer.from(segment)))) {
                         indexEntries.add(address);
                     }
                 }
@@ -254,7 +261,7 @@ export class PersistentAnalysisCache {
             if (entry.scopeHash !== scopeHash ||
                 entry.kind !== kind ||
                 entry.address !== address ||
-                !this.state.verifyJournal({ kind: 'analysis-cache-entry.v1', entry }, authenticationTag))
+                !this.state.verifyJournal(entryIdentity(entry), authenticationTag))
                 throw new Error('Persistent analysis cache authentication or identity is invalid');
             const payload = Buffer.from(entry.payload, 'base64');
             if (payload.length > this.maxSingleBytes || sha256Bytes(payload) !== entry.payloadHash)
@@ -289,7 +296,7 @@ export class PersistentAnalysisCache {
         const target = await containedGeneratedPath(directory, `${digestSchema.parse(address)}.json`);
         const invalidAddress = `${scopeHash}\0${kind}\0${address}`;
         const unsigned = {
-            version: 1,
+            version: 2,
             kind,
             scopeHash,
             address,
@@ -300,10 +307,7 @@ export class PersistentAnalysisCache {
         };
         const bytes = Buffer.from(canonicalJson({
             ...unsigned,
-            authenticationTag: this.state.authenticateJournal({
-                kind: 'analysis-cache-entry.v1',
-                entry: unsigned,
-            }),
+            authenticationTag: this.state.authenticateJournal(entryIdentity(unsigned)),
         }));
         if (bytes.length > Math.ceil((this.maxSingleBytes * 4) / 3) + 4096) {
             this.#oversized += 1;

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

@@ -11,6 +11,7 @@ const HEARTBEAT_MS = 60_000;
 /** A record this old without an update belongs to a process that is blocked or gone. */
 const STALE_MS = 5 * HEARTBEAT_MS;
 const MAX_RECORDS = 512;
+const ABANDONED_MS = 24 * STALE_MS;
 const recordSchema = z
     .object({
     pid: z.number().int().positive(),
@@ -78,8 +79,13 @@ export class ServerRegistry {
         const beat = () => void mkdir(root, { recursive: true })
             .then(async () => {
             const temporary = `${file}.${Date.now()}.tmp`;
-            await writeFile(temporary, `${JSON.stringify(this.current())}\n`);
-            await rename(temporary, file);
+            try {
+                await writeFile(temporary, `${JSON.stringify(this.current())}\n`);
+                await rename(temporary, file);
+            }
+            catch {
+                await unlink(temporary).catch(() => undefined);
+            }
         })
             .catch(() => undefined);
         beat();
@@ -109,9 +115,14 @@ export class ServerRegistry {
         const servers = [];
         let removed = 0;
         if (root !== undefined) {
-            const names = (await readdir(root).catch(() => []))
-                .filter((name) => /^\d+\.json$/u.test(name))
-                .slice(0, MAX_RECORDS);
+            const entries = await readdir(root).catch(() => []);
+            // Temporary heartbeat files left by a failed rename.
+            for (const name of entries) {
+                const temporary = /^\d+\.json\.(\d+)\.tmp$/u.exec(name);
+                if (temporary !== null && Date.now() - Number(temporary[1]) > STALE_MS)
+                    await unlink(path.join(root, name)).catch(() => undefined);
+            }
+            const names = entries.filter((name) => /^\d+\.json$/u.test(name)).slice(0, MAX_RECORDS);
             for (const name of names) {
                 const file = path.join(root, name);
                 const parsed = recordSchema.safeParse(await readFile(file, 'utf8')
@@ -128,6 +139,12 @@ export class ServerRegistry {
                     continue;
                 }
                 const age = Date.now() - Date.parse(record.updatedAt);
+                // A record silent for this long belongs to an exited process whose pid was reused.
+                if (age > ABANDONED_MS) {
+                    removed += 1;
+                    await unlink(file).catch(() => undefined);
+                    continue;
+                }
                 servers.push({ ...record, state: age > STALE_MS ? 'stale' : 'live' });
             }
         }

package/dist/hoi4_agent_tools/core/shared-request-capacity.js

@@ -20,11 +20,13 @@ export class SharedRequestCapacity {
     stateRoot;
     capacity;
     deletePendingLimitMs;
+    leaseMaxAgeMs;
     now;
     constructor(stateRoot, capacity = 4, options = {}) {
         this.stateRoot = stateRoot;
         this.capacity = capacity;
         this.deletePendingLimitMs = options.deletePendingLimitMs ?? 60_000;
+        this.leaseMaxAgeMs = options.leaseMaxAgeMs;
         this.now = options.now ?? Date.now;
     }
     async run(signal, action) {
@@ -34,6 +36,7 @@ export class SharedRequestCapacity {
                 handoffToProcess: () => {
                     return Promise.reject(new ServiceError('REQUEST_LEASE_STORAGE_REQUIRED', 'Worker ownership transfer requires persistent capacity storage'));
                 },
+                reclaimFromProcess: () => Promise.resolve(),
             });
         const root = await containedGeneratedPath(await canonicalPath(this.stateRoot, signal), 'request-capacity', sha256Bytes(hostname().toLowerCase()).slice(0, 16));
         await mkdir(root, { recursive: true });
@@ -112,6 +115,14 @@ export class SharedRequestCapacity {
                             owner = next;
                             transferredPid = pid;
                         },
+                        reclaimFromProcess: async () => {
+                            if (transferredPid === undefined)
+                                return;
+                            const next = path.join(slot, `${process.pid}-${randomUUID()}.lease`);
+                            await retryWindowsSharing(() => rename(owner, next));
+                            owner = next;
+                            transferredPid = undefined;
+                        },
                     });
                 }
                 finally {
@@ -137,6 +148,18 @@ export class SharedRequestCapacity {
             await delay(sharingRetryDelay(waits) * (0.75 + Math.random() / 2), undefined, { signal });
         }
     }
+    async leaseExpired(lease) {
+        if (this.leaseMaxAgeMs === undefined)
+            return false;
+        try {
+            return this.now() - (await lstat(lease)).mtimeMs > this.leaseMaxAgeMs;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return false;
+            throw error;
+        }
+    }
     async reap(slot) {
         try {
             const metadata = await lstat(slot);
@@ -150,7 +173,9 @@ export class SharedRequestCapacity {
             else {
                 for (const name of owners) {
                     const match = /^([1-9][0-9]*)-[0-9a-f-]{36}\.lease$/u.exec(name);
-                    if (match === null || processAlive(Number(match[1])))
+                    if (match === null)
+                        return;
+                    if (processAlive(Number(match[1])) && !(await this.leaseExpired(path.join(slot, name))))
                         return;
                     // Unique owner names prevent a concurrent reaper from deleting a new lease.
                     await unlink(path.join(slot, name)).catch((error) => {