hoi4-agent-tools 3.9.0 → 4.0.0

package/dist/hoi4_agent_tools/core/job-transactions.js

@@ -55,7 +55,7 @@ export class JobTransactions {
             return this.fail(job, ownerToken, transaction.rollbackStatus === 'applied'
                 ? 'JOB_REWRITE_RESTORED'
                 : 'JOB_REWRITE_RECOVERY_REQUIRED', transaction.rollbackStatus === 'applied'
-                ? 'The interrupted rewrite was restored; it was not replayed'
+                ? `The interrupted rewrite was restored; it was not replayed${failureCause(undefined, transaction)}`
                 : 'The transaction could not establish a completed or restored outcome', principal);
         throw new ServiceError('JOB_TRANSACTION_UNRESOLVED', 'The transaction has no stable outcome after recovery');
     }
@@ -101,7 +101,7 @@ export class JobTransactions {
                 if (outcome.state === 'applied')
                     return this.complete(current, ownerToken, { transaction: outcome, outcome: 'applied', artifacts: [] }, true, principal, current.writeRecipe ?? recipe, completion);
                 if (outcome.state === 'rolled_back')
-                    return this.fail(current, ownerToken, 'JOB_REWRITE_RESTORED', 'The rewrite failed and its original source was restored', principal);
+                    return this.fail(current, ownerToken, 'JOB_REWRITE_RESTORED', `The rewrite failed and its original source was restored${failureCause(error, outcome)}`, principal);
                 if (outcome.state === 'failed')
                     return this.fail(current, ownerToken, 'JOB_REWRITE_RECOVERY_REQUIRED', 'The transaction could not establish a completed or restored outcome', principal);
             }
@@ -124,3 +124,32 @@ export class JobTransactions {
         return this.jobs.store.updateOwned(this.jobs.scope(job.scope.workspaceId, principal), job.id, ownerToken, { status: 'failed', failure: { code, message } });
     }
 }
+/**
+ * Why the write stopped: the error code and message of a service error, else only the error
+ * kind, followed by the first check or diagnostic of the transaction that failed validation.
+ */
+function failureCause(error, transaction) {
+    const recorded = transaction.failure === undefined
+        ? ''
+        : `${transaction.failure.code}: ${transaction.failure.message}`;
+    const cause = error instanceof ServiceError
+        ? `${error.code}: ${error.message}`
+        : error instanceof Error
+            ? error.name
+            : recorded;
+    const failedCheck = transaction.validation.checks.find(({ passed }) => !passed);
+    const blocking = transaction.diagnostics.find(({ severity }) => severity === 'error' || severity === 'blocker');
+    // The blocking diagnostic comes first: it is the part the agent can act on.
+    const text = [
+        blocking === undefined
+            ? ''
+            : `${blocking.code}: ${blocking.message}${blocking.location === undefined
+                ? ''
+                : ` at ${blocking.location.path}:${blocking.location.start.line}`}`,
+        failedCheck?.message ?? '',
+        cause,
+    ]
+        .filter((part) => part !== '')
+        .join('; ');
+    return text === '' ? '' : ` (${text})`.slice(0, 700);
+}

package/dist/hoi4_agent_tools/core/job-worker-host.js

@@ -8,8 +8,12 @@ import { RequestScheduler } from './request-scheduler.js';
 import { SharedRequestCapacity } from './shared-request-capacity.js';
 import { containedGeneratedPath } from './workspace.js';
 import { ServiceError } from './result.js';
+import { isDomainToolName } from './domain-tools.js';
 const maximumCheckpointRecoveries = 2;
 const maximumPreDispatchRecoveries = 2;
+/** An exit with no outcome is most often the worker running out of memory on a large mod. */
+const WORKER_EXIT_HINT = '; if the mod is large the worker may have run out of memory, so retry the call or raise jobWorkerMaxHeapMiB';
+const WORKER_EXIT_MESSAGE = `The worker stopped without publishing a terminal job outcome${WORKER_EXIT_HINT}`;
 // Native and IPC codes are fixed vocabulary. Error messages can contain paths or source
 // text, so only an allowlisted code and the fixed coordination stage are reported.
 const nativeFailureCodes = new Set([
@@ -94,36 +98,7 @@ export class JobWorkerHost {
         const initial = await this.jobs.get(workspaceId, id, principal);
         if (['completed', 'cancelled', 'failed'].includes(initial.status))
             return initial;
-        if (![
-            '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',
-        ].includes(initial.request.toolName))
+        if (!isDomainToolName(initial.request.toolName))
             throw new ServiceError('JOB_OPERATION_UNAVAILABLE', 'This domain has not yet been registered for worker execution');
         const signal = new AbortController().signal;
         const recovered = new Set();
@@ -139,7 +114,7 @@ export class JobWorkerHost {
                     return current;
                 if (current.owner !== undefined && jobOwnerLiveness(current.owner) === 'alive')
                     return await this.followOwner(workspaceId, id, principal);
-                throw new ServiceError('JOB_WORKER_EXIT', 'The worker stopped without publishing a terminal job outcome');
+                throw new ServiceError('JOB_WORKER_EXIT', WORKER_EXIT_MESSAGE);
             }
             catch (error) {
                 const current = await this.jobs.get(workspaceId, id, principal);
@@ -178,15 +153,19 @@ export class JobWorkerHost {
             if (liveness !== 'alive')
                 throw new ServiceError(liveness === 'unknown' ? 'JOB_OWNER_UNRESOLVED' : 'JOB_WORKER_EXIT', liveness === 'unknown'
                     ? 'The replacement execution owner cannot be verified on this host'
-                    : 'The replacement worker stopped without publishing a terminal job outcome');
+                    : `The replacement worker stopped without publishing a terminal job outcome${WORKER_EXIT_HINT}`);
             await delay(100);
         }
     }
     async launch(workspaceId, id, lease, progress, principal) {
-        // Resolve the same configured workspace and grants again immediately before dispatch.
-        await this.jobs.get(workspaceId, id, principal);
-        const sourceMode = import.meta.url.endsWith('.ts');
-        const entry = fileURLToPath(new URL(sourceMode ? './job-worker.ts' : './job-worker.js', import.meta.url));
+        // Resolve the same configured workspace and grants again immediately before dispatch. A
+        // job that finished, or that a live worker already runs, needs no new worker: another
+        // launcher may have run it while this one waited for capacity.
+        const current = await this.jobs.get(workspaceId, id, principal);
+        if (['completed', 'failed', 'cancelled'].includes(current.status))
+            return;
+        if (current.owner !== undefined && jobOwnerLiveness(current.owner) === 'alive')
+            return;
         const configuration = this.engine.resolver.config();
         const registeredWorkspaceIds = new Set(configuration.workspaces.map((workspace) => workspace.id));
         const resolvedWorkspaces = this.engine.resolver.list();
@@ -199,96 +178,54 @@ export class JobWorkerHost {
                 workspaceIds: [...new Set([...grant.workspaceIds, ...discoveredWorkspaceIds])],
             }
             : grant;
+        const message = {
+            configuration: {
+                ...configuration,
+                modRoots: [],
+                workspaces: resolvedWorkspaces.map(({ registration }) => registration),
+                http: {
+                    ...configuration.http,
+                    tokens: configuration.http.tokens.map(preserveDiscoveredGrants),
+                    principals: configuration.http.principals.map(preserveDiscoveredGrants),
+                },
+            },
+            workspaceId,
+            jobId: id,
+            ...(principal === undefined ? {} : { principal }),
+        };
+        const warm = configuration.jobWorkerIdleSeconds > 0;
         progress.stage = 'startup';
-        const child = spawn(process.execPath, [
-            ...(configuration.jobWorkerMaxHeapMiB === undefined
-                ? []
-                : [`--max-old-space-size=${configuration.jobWorkerMaxHeapMiB}`]),
-            ...(sourceMode ? ['--import', import.meta.resolve('tsx')] : []),
-            entry,
-        ], {
-            detached: true,
-            cwd: process.cwd(),
-            stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
-            windowsHide: true,
-        });
-        let phase = 'waiting_for_ready';
-        let acknowledgmentTimer;
-        const initialized = new Promise((resolve, reject) => {
-            child.once('error', reject);
-            child.once('exit', (code, signal) => reject(new ServiceError('JOB_WORKER_STARTUP_EXIT', `The worker exited before completing its startup handshake (phase ${phase}, exit ${code ?? 'none'}, signal ${signal ?? 'none'})`)));
-            child.once('message', (value) => {
-                void (async () => {
-                    if (typeof value !== 'object' ||
-                        value === null ||
-                        !('type' in value) ||
-                        value.type !== 'ready' ||
-                        child.pid === undefined)
-                        throw new ServiceError('JOB_WORKER_PROTOCOL', 'The worker did not provide its readiness handshake');
-                    progress.stage = 'handoff';
-                    await lease.handoffToProcess(child.pid);
-                    progress.stage = 'dispatch';
-                    await new Promise((resolve, reject) => {
-                        phase = 'waiting_for_acceptance';
-                        acknowledgmentTimer = setTimeout(() => reject(new ServiceError('JOB_WORKER_ACCEPT_TIMEOUT', 'The worker did not acknowledge receipt within its startup window')), 30_000);
-                        child.once('message', (accepted) => {
-                            if (typeof accepted !== 'object' ||
-                                accepted === null ||
-                                !('type' in accepted) ||
-                                accepted.type !== 'accepted') {
-                                reject(new ServiceError('JOB_WORKER_PROTOCOL', 'The worker did not acknowledge the dispatched job'));
-                                return;
-                            }
-                            phase = 'accepted';
-                            // Only close IPC after the child confirms receipt. The persistent job,
-                            // rather than the launcher's lifetime, owns execution after this point.
-                            if (child.connected)
-                                child.disconnect();
-                            resolve();
-                        });
-                        child.send({
-                            configuration: {
-                                ...configuration,
-                                modRoots: [],
-                                workspaces: resolvedWorkspaces.map(({ registration }) => registration),
-                                http: {
-                                    ...configuration.http,
-                                    tokens: configuration.http.tokens.map(preserveDiscoveredGrants),
-                                    principals: configuration.http.principals.map(preserveDiscoveredGrants),
-                                },
-                            },
-                            workspaceId,
-                            jobId: id,
-                            ...(principal === undefined ? {} : { principal }),
-                        }, (error) => {
-                            if (error !== null)
-                                reject(error);
-                        });
-                    });
-                    resolve();
-                })().catch((error) => {
-                    if (child.connected)
-                        child.disconnect();
-                    reject(error instanceof Error
-                        ? error
-                        : new ServiceError('JOB_WORKER_PROTOCOL', 'Worker initialization failed'));
-                });
-            });
-        });
+        const reused = warm ? this.takeIdleWorker() : undefined;
+        const child = reused ?? (await this.startWorker(configuration.jobWorkerMaxHeapMiB));
         try {
-            await initialized;
+            progress.stage = 'handoff';
+            await lease.handoffToProcess(child.pid);
         }
-        finally {
-            clearTimeout(acknowledgmentTimer);
+        catch (error) {
+            // A reused worker that just exited cannot take the slot; no job reached it.
+            if (reused !== undefined && error instanceof ServiceError)
+                throw new ServiceError('REQUEST_LEASE_HANDOFF_LOST', 'The warm worker stopped before it received the job');
+            if (reused === undefined)
+                await stopChild(child);
+            throw error;
         }
+        progress.stage = 'dispatch';
+        await this.dispatch(child, message, reused !== undefined);
+        // Without warm reuse the persistent job, not the launcher's lifetime, owns execution once
+        // the child confirmed receipt, so close the channel.
+        if (!warm && child.connected)
+            child.disconnect();
         progress.stage = 'supervision';
         const { jobDeadlineSeconds, jobCancelGraceSeconds } = this.engine.resolver.config();
         const supervisedSince = Date.now();
         let cancellationSeenAt;
         for (;;) {
             const record = await this.jobs.get(workspaceId, id, principal);
-            if (['completed', 'failed', 'cancelled'].includes(record.status))
+            if (['completed', 'failed', 'cancelled'].includes(record.status)) {
+                if (warm)
+                    await this.keepWarm(child, lease);
                 return;
+            }
             if (record.owner !== undefined && record.owner.pid !== child.pid) {
                 if (jobOwnerLiveness(record.owner) === 'alive')
                     return;
@@ -317,10 +254,172 @@ export class JobWorkerHost {
                 }
                 catch (error) {
                     if (error.code === 'ESRCH')
-                        throw new ServiceError('JOB_WORKER_EXIT', 'The worker stopped without publishing a terminal job outcome');
+                        throw new ServiceError('JOB_WORKER_EXIT', WORKER_EXIT_MESSAGE);
                 }
             }
             await delay(100);
         }
     }
+    /** Idle warm workers of this host, most recently used last. */
+    idleWorkers = [];
+    /**
+     * Workers that reported idle since their last dispatch. The report usually arrives before the
+     * supervision loop notices the finished job, so it is recorded as it comes.
+     */
+    reportedIdle = new WeakSet();
+    watched = new WeakSet();
+    watchIdle(child) {
+        if (this.watched.has(child))
+            return;
+        this.watched.add(child);
+        child.on('message', (value) => {
+            if (typeof value === 'object' && value !== null && 'type' in value && value.type === 'idle')
+                this.reportedIdle.add(child);
+        });
+    }
+    /** Let every idle warm worker exit; a busy one finishes its job first. */
+    releaseIdleWorkers() {
+        for (const child of this.idleWorkers.splice(0))
+            if (child.connected)
+                child.disconnect();
+    }
+    takeIdleWorker() {
+        for (;;) {
+            const child = this.idleWorkers.pop();
+            if (child === undefined)
+                return undefined;
+            if (child.connected &&
+                child.exitCode === null &&
+                child.signalCode === null &&
+                child.pid !== undefined) {
+                child.ref();
+                child.channel?.ref();
+                return child;
+            }
+        }
+    }
+    /** Start a fixed-entry worker and wait for its readiness handshake. */
+    async startWorker(maxHeapMiB) {
+        const sourceMode = import.meta.url.endsWith('.ts');
+        const entry = fileURLToPath(new URL(sourceMode ? './job-worker.ts' : './job-worker.js', import.meta.url));
+        const child = spawn(process.execPath, [
+            ...(maxHeapMiB === undefined ? [] : [`--max-old-space-size=${maxHeapMiB}`]),
+            ...(sourceMode ? ['--import', import.meta.resolve('tsx')] : []),
+            entry,
+        ], {
+            detached: true,
+            cwd: process.cwd(),
+            stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+            windowsHide: true,
+        });
+        try {
+            await new Promise((resolve, reject) => {
+                const onExit = (code, signal) => reject(new ServiceError('JOB_WORKER_STARTUP_EXIT', `The worker exited before completing its startup handshake (phase waiting_for_ready, exit ${code ?? 'none'}, signal ${signal ?? 'none'})`));
+                child.once('error', reject);
+                child.once('exit', onExit);
+                child.once('message', (value) => {
+                    child.off('exit', onExit);
+                    child.off('error', reject);
+                    if (typeof value !== 'object' ||
+                        value === null ||
+                        !('type' in value) ||
+                        value.type !== 'ready' ||
+                        child.pid === undefined)
+                        reject(new ServiceError('JOB_WORKER_PROTOCOL', 'The worker did not provide its readiness handshake'));
+                    else
+                        resolve();
+                });
+            });
+        }
+        catch (error) {
+            if (child.connected)
+                child.disconnect();
+            throw error;
+        }
+        return child;
+    }
+    /** Send the job and wait until the worker acknowledges receipt. */
+    async dispatch(child, message, reused) {
+        let acknowledgmentTimer;
+        this.watchIdle(child);
+        this.reportedIdle.delete(child);
+        try {
+            await new Promise((resolve, reject) => {
+                const onExit = (code, signal) => reject(reused
+                    ? new ServiceError('REQUEST_LEASE_HANDOFF_LOST', 'The warm worker stopped before it received the job')
+                    : new ServiceError('JOB_WORKER_STARTUP_EXIT', `The worker exited before completing its startup handshake (phase waiting_for_acceptance, exit ${code ?? 'none'}, signal ${signal ?? 'none'})`));
+                child.once('exit', onExit);
+                acknowledgmentTimer = setTimeout(() => reject(new ServiceError('JOB_WORKER_ACCEPT_TIMEOUT', 'The worker did not acknowledge receipt within its startup window')), 30_000);
+                const onMessage = (accepted) => {
+                    if (typeof accepted === 'object' &&
+                        accepted !== null &&
+                        'type' in accepted &&
+                        accepted.type === 'idle')
+                        return;
+                    child.off('message', onMessage);
+                    child.off('exit', onExit);
+                    if (typeof accepted !== 'object' ||
+                        accepted === null ||
+                        !('type' in accepted) ||
+                        accepted.type !== 'accepted')
+                        reject(new ServiceError('JOB_WORKER_PROTOCOL', 'The worker did not acknowledge the dispatched job'));
+                    else
+                        resolve();
+                };
+                child.on('message', onMessage);
+                child.send(message, (error) => {
+                    if (error !== null)
+                        reject(error);
+                });
+            });
+        }
+        catch (error) {
+            if (child.connected)
+                child.disconnect();
+            throw error;
+        }
+        finally {
+            clearTimeout(acknowledgmentTimer);
+        }
+    }
+    /**
+     * After a job, wait briefly for the worker to report itself idle, release its capacity slot
+     * and keep it for the next job. A worker that does not report idle is left to exit.
+     */
+    async keepWarm(child, lease) {
+        if (!child.connected || child.exitCode !== null || child.signalCode !== null)
+            return;
+        const idle = await new Promise((resolve) => {
+            if (this.reportedIdle.has(child)) {
+                resolve(true);
+                return;
+            }
+            const timer = setTimeout(() => finish(false), 10_000);
+            const onMessage = (value) => {
+                if (typeof value === 'object' && value !== null && 'type' in value && value.type === 'idle')
+                    finish(true);
+            };
+            const onExit = () => finish(false);
+            function finish(result) {
+                clearTimeout(timer);
+                child.off('message', onMessage);
+                child.off('exit', onExit);
+                resolve(result);
+            }
+            child.on('message', onMessage);
+            child.once('exit', onExit);
+        });
+        // The channel can close while waiting; read it afresh rather than from the earlier check.
+        const connected = () => child.connected;
+        if (!idle || !connected()) {
+            if (connected())
+                child.disconnect();
+            return;
+        }
+        await lease.reclaimFromProcess();
+        // An idle worker must not keep this server's event loop alive.
+        child.unref();
+        child.channel?.unref();
+        this.idleWorkers.push(child);
+    }
 }

package/dist/hoi4_agent_tools/core/job-worker.js

@@ -1,12 +1,21 @@
+import { setFlagsFromString, getHeapStatistics } from 'node:v8';
+import { runInNewContext } from 'node:vm';
 import { z } from 'zod/v4';
+import { hashCanonical } from './canonical.js';
 import { serverConfigurationSchema } from './configuration.js';
 import { CoreEngine } from './engine.js';
 import { JobExecutor } from './job-executor.js';
 import { JobService } from './job-service.js';
 import { WorkspaceResolver } from './workspace.js';
-import { registerWorkerOperations } from './job-operation-registration.js';
+import { registerWorkerOperations, workerDomain } from './job-operation-registration.js';
 // Fixed internal process entry point. It accepts only a trusted host's structured IPC
 // message, never a script path, module name, callback, command, or transport request.
+//
+// A worker runs one job at a time. After a job it stays warm for jobWorkerIdleSeconds while
+// its host keeps the IPC channel open, so the host's next job reuses the loaded indexes
+// instead of scanning cold. It exits when the idle time ends or the host disconnects. A worker
+// whose heap stays large after a job is not kept warm: several heavy jobs in a row would
+// otherwise exhaust the heap limit in the middle of the next one.
 const inputSchema = z
     .object({
     configuration: serverConfigurationSchema,
@@ -17,54 +26,99 @@ const inputSchema = z
     .strict();
 if (process.send === undefined)
     throw new Error('Job workers require their internal IPC host');
+let warm;
+let busy = false;
 let started = false;
+let idleTimer;
+/** Share of the heap limit a worker may still hold after a job and a full collection. */
+const WARM_HEAP_SHARE = 0.4;
+/** Whether the heap, after a full collection, is small enough to serve another job. */
+function heapAllowsReuse() {
+    const limit = getHeapStatistics().heap_size_limit * WARM_HEAP_SHARE;
+    if (getHeapStatistics().used_heap_size <= limit)
+        return true;
+    try {
+        setFlagsFromString('--expose-gc');
+        runInNewContext('gc')();
+    }
+    catch {
+        // Without a collection the figure above stands: recycle rather than risk the next job.
+        return false;
+    }
+    return getHeapStatistics().used_heap_size <= limit;
+}
 const startup = setTimeout(() => {
     if (!started)
         process.exit(1);
 }, 30_000);
 startup.unref();
-process.once('disconnect', () => {
-    if (!started)
-        process.exit(0);
+function finish() {
+    if (process.connected)
+        process.disconnect();
+    process.exit(process.exitCode ?? 0);
+}
+process.on('disconnect', () => {
+    // A host that leaves while a job runs does not cancel it; the job finishes and the worker
+    // exits afterwards. An idle worker has nothing left to do.
+    if (!busy)
+        finish();
 });
-process.once('message', (value) => {
+async function warmState(configuration) {
+    const configurationHash = hashCanonical(configuration);
+    if (warm?.configurationHash === configurationHash)
+        return warm;
+    const resolver = await WorkspaceResolver.create(configuration);
+    const engine = new CoreEngine(resolver);
+    // Recovery is targeted by the job executor. Do not sweep or interfere with
+    // unrelated live rewrite journals when a worker starts.
+    const jobs = await JobService.create(resolver);
+    warm = { configurationHash, resolver, engine, jobs, operations: new Map() };
+    return warm;
+}
+async function runJob(value) {
+    const input = inputSchema.parse(value);
+    // The send callback confirms enqueueing, not receipt. Acknowledge before the host
+    // continues; losing that channel after receipt never cancels durable execution.
+    if (process.connected)
+        process.send?.({ type: 'accepted' }, () => undefined);
+    const state = await warmState(input.configuration);
+    const record = await state.jobs.get(input.workspaceId, input.jobId, input.principal);
+    // The host enforces the deadline while it lives; the executor also stops a read-only job
+    // at its deadline and records why, so an orphaned worker never runs indefinitely.
+    const deadlineMs = Date.now() + state.resolver.config().jobDeadlineSeconds * 1000;
+    const domain = workerDomain(record.request.toolName);
+    let operations = state.operations.get(domain);
+    if (operations === undefined) {
+        operations = await registerWorkerOperations(state.engine, record.request.toolName);
+        state.operations.set(domain, operations);
+    }
+    else
+        operations.get(record.request.toolName);
+    await new JobExecutor(state.engine, state.jobs, operations).run(input.workspaceId, input.jobId, input.principal, { deadlineMs });
+}
+process.on('message', (value) => {
+    if (busy)
+        return;
     started = true;
+    busy = true;
     clearTimeout(startup);
-    void (async () => {
-        const input = inputSchema.parse(value);
-        // The send callback confirms enqueueing, not receipt. Acknowledge before the host
-        // disconnects; losing that channel after receipt never cancels durable execution.
-        if (process.connected)
-            process.send?.({ type: 'accepted' }, () => undefined);
-        const resolver = await WorkspaceResolver.create(input.configuration);
-        const engine = new CoreEngine(resolver);
-        // Recovery is targeted by the job executor. Do not sweep or interfere with
-        // unrelated live rewrite journals when a worker starts.
-        const jobs = await JobService.create(resolver);
-        const record = await jobs.get(input.workspaceId, input.jobId, input.principal);
-        if (!record.request.mutation) {
-            // The host enforces the deadline while it lives; a worker whose host has gone stops
-            // itself, so an orphaned read-only analysis never holds memory indefinitely.
-            const { jobDeadlineSeconds } = resolver.config();
-            setTimeout(() => {
-                void jobs
-                    .failInterrupted(input.workspaceId, input.jobId, {
-                    code: 'JOB_DEADLINE_EXCEEDED',
-                    message: `The job ran longer than ${jobDeadlineSeconds} seconds and was stopped; narrow its selector or limits, or raise jobDeadlineSeconds`,
-                }, input.principal)
-                    .catch(() => undefined)
-                    .finally(() => process.exit(1));
-            }, jobDeadlineSeconds * 1000).unref();
-        }
-        const operations = await registerWorkerOperations(engine, record.request.toolName);
-        await new JobExecutor(engine, jobs, operations).run(input.workspaceId, input.jobId, input.principal);
-    })()
+    if (idleTimer !== undefined)
+        clearTimeout(idleTimer);
+    void runJob(value)
         .catch(() => {
         process.exitCode = 1;
     })
         .finally(() => {
-        if (process.connected)
-            process.disconnect();
+        busy = false;
+        const idleSeconds = warm?.resolver.config().jobWorkerIdleSeconds ?? 0;
+        // A failed job leaves state of unknown health; start the next job in a fresh worker.
+        if (!process.connected || idleSeconds === 0 || process.exitCode === 1 || !heapAllowsReuse()) {
+            finish();
+            return;
+        }
+        process.send?.({ type: 'idle' }, () => undefined);
+        idleTimer = setTimeout(finish, idleSeconds * 1000);
+        idleTimer.unref();
     });
 });
 process.send({ type: 'ready' });