agents-relay 2.0.58 → 2.0.59

package/dist/adapters.js

@@ -1,8 +1,8 @@
-import { spawn } from 'node:child_process';
 import { readFile, writeFile, unlink } from 'node:fs/promises';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { randomUUID } from 'node:crypto';
+import { spawnOwnedProcess, terminateOwnedProcess } from './owned-process.js';
 export function buildCodexArgs(route, input) {
     const args = ['exec', '--json'];
     if (route.profile)
@@ -27,29 +27,6 @@ function parseThreadStarted(line) {
         return undefined;
     }
 }
-function signalChildTree(child, signal) {
-    if (child.pid && process.platform !== 'win32') {
-        try {
-            process.kill(-child.pid, signal);
-            return;
-        }
-        catch (error) {
-            if (error.code !== 'ESRCH')
-                throw error;
-        }
-    }
-    child.kill(signal);
-}
-function terminateChild(child, graceMs = 750) {
-    if (child.exitCode !== null || child.signalCode !== null)
-        return;
-    signalChildTree(child, 'SIGTERM');
-    const force = setTimeout(() => {
-        if (child.exitCode === null && child.signalCode === null)
-            signalChildTree(child, 'SIGKILL');
-    }, graceMs);
-    force.unref();
-}
 function appendTail(current, chunk, maxBytes = 16384) {
     const combined = current + chunk;
     return Buffer.byteLength(combined) <= maxBytes
@@ -67,11 +44,11 @@ export class CodexAdapter {
     launch(task, signal, context = {}) {
         if (!task.routing)
             throw new Error(`Task ${task.id} requires routing metadata before Codex launch`);
-        const child = spawn(this.command, buildCodexArgs(task.routing, task.input), {
-            shell: false,
-            cwd: task.routing.cwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            detached: process.platform !== 'win32',
+        const child = spawnOwnedProcess(this.command, buildCodexArgs(task.routing, task.input), {
+            invocation: `worker.codex:${task.id}`,
+            signal,
+            correlation: { jobId: task.jobId, taskId: task.id, executionId: task.executionId ?? undefined },
+            spawn: { shell: false, cwd: task.routing.cwd, stdio: ['ignore', 'pipe', 'pipe'] },
         });
         let stdoutBuffer = '';
         let stderrTail = '';
@@ -104,7 +81,8 @@ export class CodexAdapter {
         const promise = new Promise((resolve, reject) => {
             child.on('error', error => { launchedReject(error); reject(error); });
             child.once('spawn', launchedResolve);
-            child.on('close', code => {
+            child.on('close', (code, signal) => {
+                execution.processExit = { exitCode: code, signal, stderr: stderrTail };
                 if (stdoutBuffer)
                     consumeLine(stdoutBuffer);
                 if (code === 0) {
@@ -114,9 +92,8 @@ export class CodexAdapter {
                     reject(new Error(stderrTail.trim() || `Codex exited ${code}`));
                 }
             });
-            signal.addEventListener('abort', () => terminateChild(child), { once: true });
         });
-        execution = { id: randomUUID(), promise, launched, cancel: () => terminateChild(child) };
+        execution = { id: randomUUID(), promise, launched, cancel: () => { void terminateOwnedProcess(child, 'cancel'); } };
         execution.threadId = bufferedThreadId;
         return execution;
     }
@@ -153,10 +130,14 @@ function browserWorkspaceCli(override = process.env.AGENTS_RELAY_BROWSER_WORKSPA
 }
 function browserWorkspaceCommand(cli, args, stdin, signal) {
     return new Promise((resolve, reject) => {
-        const child = spawn(cli.command, [...cli.prefix, ...args], { shell: false, stdio: [stdin === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'] });
+        const child = spawnOwnedProcess(cli.command, [...cli.prefix, ...args], {
+            invocation: 'browser-workspace.command',
+            signal,
+            spawn: { shell: false, stdio: [stdin === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'] },
+        });
         let stdout = '';
         let stderr = '';
-        const abort = () => terminateChild(child);
+        const abort = () => { void terminateOwnedProcess(child, 'abort'); };
         child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
         child.stderr?.on('data', (chunk) => { stderr = appendTail(stderr, chunk.toString()); });
         child.on('error', reject);

package/dist/cli-escalation.js

@@ -1,9 +1,9 @@
-import { spawn } from 'node:child_process';
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { textOption, arg } from './cli-support.js';
 import { runEscalationGraph } from './workflow/escalation.js';
+import { spawnOwnedProcess } from './owned-process.js';
 export function neoEscalationArgs(handoffPath, policyPath, cwd) {
     return [
         'escalation', '--handoff-file', handoffPath,
@@ -31,11 +31,11 @@ export async function runNeoEscalation(request) {
         }
         const args = neoEscalationArgs(handoffPath, policyPath, request.cwd);
         return await new Promise((resolve, reject) => {
-            const child = spawn('neo', args, { cwd: request.cwd ?? process.cwd(), stdio: ['ignore', 'pipe', 'pipe'] });
+            const child = spawnOwnedProcess('neo', args, { invocation: 'escalation.neo', spawn: { cwd: request.cwd ?? process.cwd(), stdio: ['ignore', 'pipe', 'pipe'] } });
             let stdout = '';
             let stderr = '';
-            child.stdout.setEncoding('utf8').on('data', chunk => { stdout += chunk; });
-            child.stderr.setEncoding('utf8').on('data', chunk => { stderr += chunk; });
+            child.stdout?.setEncoding('utf8').on('data', chunk => { stdout += chunk; });
+            child.stderr?.setEncoding('utf8').on('data', chunk => { stderr += chunk; });
             child.on('error', reject);
             child.on('close', code => {
                 let parsed;

package/dist/cli.js

@@ -29,6 +29,7 @@ import { helpText, usage } from './cli-help.js';
 import { parseAgentGraph } from './agent-graph.js';
 import { runJobUnblockCommand, runTaskUnblockCommand } from './cli-unblock.js';
 import { createJobEntity, createTaskEntity } from './workflow/entity-creation.js';
+import { shutdownOwnedProcesses } from './owned-process.js';
 export { helpText } from './cli-help.js';
 import { SERVICE_DEFAULTS, ServiceEventBus, arg, hasArg, textOption, integerArg, repository, storeFor, saveLocal, githubStore, eventBus, publishWake, publishDependentUnblocked, priority, storySize, executionMode, chatGptTabClosePolicy, requestedExecutionMode, continuation, scheduleFromArgs, jobTagFromArgs, requestManagedReconciliation, relayControlJob, relayTaskCommand, withEventBus } from './cli-support.js';
 export { SERVICE_DEFAULTS, eventBus, executionMode, chatGptTabClosePolicy } from './cli-support.js';
@@ -520,7 +521,7 @@ export async function createService(args) {
             const serverClosed = new Promise((resolve, reject) => { dashboardServer.close(error => error ? reject(error) : resolve()); });
             dashboardServer.closeAllConnections();
             const watcherClosed = bus ? bus.close() : stopWatcher();
-            stopping = Promise.all([watcherClosed, serverClosed]).then(() => undefined, error => { throw error; });
+            stopping = Promise.all([reconciler.close(), watcherClosed, serverClosed, shutdownOwnedProcesses('parent-shutdown')]).then(() => undefined, error => { throw error; });
             return stopping;
         }
     };
@@ -631,10 +632,17 @@ async function main() {
     if (command === 'plan') {
         const guidance = hasArg(args, '--prompt') || hasArg(args, '--prompt-file') ? await textOption(args, '--prompt', '--prompt-file') : undefined;
         await withEventBus(args, async (bus) => {
-            const result = await runtime(store, args, bus).planJob(job.id, guidance?.trim() || undefined);
-            await saveLocal(localFile, result.job);
-            await publishWake(bus, result.job, result.round.id, `Planning round ${result.round.id} completed`);
-            console.log(JSON.stringify(result.round, null, 2));
+            const reconciler = runtime(store, args, bus);
+            try {
+                const result = await reconciler.planJob(job.id, guidance?.trim() || undefined);
+                await saveLocal(localFile, result.job);
+                await publishWake(bus, result.job, result.round.id, `Planning round ${result.round.id} completed`);
+                console.log(JSON.stringify(result.round, null, 2));
+            }
+            finally {
+                await reconciler.close();
+                await shutdownOwnedProcesses('parent-shutdown');
+            }
         });
         return;
     }
@@ -679,11 +687,17 @@ async function main() {
                 return;
             }
             const reconciler = runtime(store, args, bus);
-            await reconciler.reconcile(job.id);
-            await reconciler.idle();
-            const finalState = await store.load(job.id);
-            await saveLocal(localFile, finalState);
-            console.log(JSON.stringify(finalState, null, 2));
+            try {
+                await reconciler.reconcile(job.id);
+                await reconciler.idle();
+                const finalState = await store.load(job.id);
+                await saveLocal(localFile, finalState);
+                console.log(JSON.stringify(finalState, null, 2));
+            }
+            finally {
+                await reconciler.close();
+                await shutdownOwnedProcesses('parent-shutdown');
+            }
         });
         return;
     }

package/dist/continuation.js

@@ -1,4 +1,4 @@
-import { spawn } from 'node:child_process';
+import { spawnOwnedProcess } from './owned-process.js';
 export class CodexThreadContinuation {
     command;
     kind = 'codex-thread';
@@ -6,12 +6,12 @@ export class CodexThreadContinuation {
         this.command = command;
     }
     async continue(input, continuation) { if (continuation.kind !== this.kind)
-        throw new Error('Continuation is not a Codex thread'); await new Promise((resolve, reject) => { const child = spawn(this.command, ['exec', 'resume', continuation.target, input]); child.on('error', reject); child.on('close', code => code === 0 ? resolve() : reject(new Error(`Codex continuation exited ${code}`))); }); }
+        throw new Error('Continuation is not a Codex thread'); await new Promise((resolve, reject) => { const child = spawnOwnedProcess(this.command, ['exec', 'resume', continuation.target, input], { invocation: 'continuation.codex' }); child.on('error', reject); child.on('close', code => code === 0 ? resolve() : reject(new Error(`Codex continuation exited ${code}`))); }); }
 }
 export class CommandContinuation {
     kind = 'command';
     async continue(input, continuation) { if (continuation.kind !== this.kind)
-        throw new Error('Continuation is not a command'); await new Promise((resolve, reject) => { const child = spawn(continuation.target, [input]); child.on('error', reject); child.on('close', code => code === 0 ? resolve() : reject(new Error(`Continuation exited ${code}`))); }); }
+        throw new Error('Continuation is not a command'); await new Promise((resolve, reject) => { const child = spawnOwnedProcess(continuation.target, [input], { invocation: 'continuation.command' }); child.on('error', reject); child.on('close', code => code === 0 ? resolve() : reject(new Error(`Continuation exited ${code}`))); }); }
 }
 export class WebhookContinuation {
     kind = 'webhook';

package/dist/decision.js

@@ -1,7 +1,7 @@
-import { spawn } from 'node:child_process';
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { spawnOwnedProcess, terminateOwnedProcess } from './owned-process.js';
 function validateContract(contract) {
     if (contract.type !== 'choice')
         throw new Error(`Unsupported decision contract ${contract.type}`);
@@ -122,7 +122,7 @@ export class LayaCliDecisionEngine {
     }
     async run(extraArgs) {
         return await new Promise((resolve, reject) => {
-            const child = spawn(this.command, [...this.args, ...extraArgs], { stdio: ['ignore', 'pipe', 'pipe'], env: this.env ?? process.env });
+            const child = spawnOwnedProcess(this.command, [...this.args, ...extraArgs], { invocation: 'decision.laya', spawn: { stdio: ['ignore', 'pipe', 'pipe'], env: this.env ?? process.env } });
             const stdout = [];
             const stderr = [];
             let settled = false;
@@ -137,11 +137,11 @@ export class LayaCliDecisionEngine {
                     resolve(output ?? '');
             };
             const timer = setTimeout(() => {
-                child.kill('SIGKILL');
+                void terminateOwnedProcess(child, 'timeout', 0);
                 finish(new Error(`Laya CLI timed out after ${this.timeoutMs}ms`));
             }, this.timeoutMs);
-            child.stdout.on('data', chunk => stdout.push(Buffer.from(chunk)));
-            child.stderr.on('data', chunk => stderr.push(Buffer.from(chunk)));
+            child.stdout?.on('data', chunk => stdout.push(Buffer.from(chunk)));
+            child.stderr?.on('data', chunk => stderr.push(Buffer.from(chunk)));
             child.once('error', error => finish(error));
             child.once('close', code => {
                 if (code !== 0) {

package/dist/github-client.js

@@ -1,7 +1,7 @@
-import { spawn } from 'node:child_process';
 import { createSign } from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { emptyGitHubRuntimeRateUsage, observeRuntimeRateLimit, parseGitHubCliHeaders, runtimeRejection } from './github-runtime-usage.js';
+import { spawnOwnedProcess } from './owned-process.js';
 function base64Url(value) {
     return Buffer.from(value).toString('base64url');
 }
@@ -143,15 +143,15 @@ export class GhApiClient {
             this.assertAvailable();
         const commandArgs = includeHeaders ? [args[0] ?? '', '--include', ...args.slice(1)] : args;
         return await new Promise((resolve) => {
-            const child = spawn('gh', commandArgs, { env });
+            const child = spawnOwnedProcess('gh', commandArgs, { invocation: 'github.api', spawn: { env } });
             let stdout = '';
             let stderr = '';
-            child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
-            child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+            child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
+            child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
             child.on('error', error => resolve({ status: null, headers: {}, body: '', stderr: error.message }));
             if (input !== undefined)
-                child.stdin.write(input);
-            child.stdin.end();
+                child.stdin?.write(input);
+            child.stdin?.end();
             child.on('close', code => {
                 const response = parseGitHubCliHeaders(stdout, includeHeaders);
                 const failed = code !== 0;
@@ -231,9 +231,9 @@ export class GhApiClient {
     }
     async localLogin() {
         return new Promise((resolve) => {
-            const child = spawn('gh', ['auth', 'status', '--active', '--json', 'hosts']);
+            const child = spawnOwnedProcess('gh', ['auth', 'status', '--active', '--json', 'hosts'], { invocation: 'github.auth-status' });
             let stdout = '';
-            child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+            child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
             child.on('error', () => resolve(null));
             child.on('close', () => {
                 try {

package/dist/owned-process.js

@@ -0,0 +1,170 @@
+import { spawn, spawnSync, } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { basename } from 'node:path';
+import { observability } from './observability.js';
+const owned = new Map();
+const byChild = new WeakMap();
+let exitHookInstalled = false;
+function audit(record, event, outcome, data) {
+    observability().record({
+        stage: 'daemon',
+        event,
+        outcome,
+        level: outcome === 'failed' ? 'warn' : 'info',
+        message: `${record.invocation} process ${event.replace('process.', '')}`,
+        correlation: record.correlation,
+        data: {
+            invocationId: record.invocationId,
+            invocation: record.invocation,
+            executable: basename(record.command),
+            pid: record.pid,
+            processGroup: record.processGroup,
+            elapsedMs: Date.now() - record.startedAt,
+            ...data,
+        },
+    });
+}
+function signalOwned(record, signal) {
+    try {
+        if (record.processGroup !== null)
+            process.kill(-record.processGroup, signal);
+        else
+            record.child.kill(signal);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ESRCH')
+            return false;
+        audit(record, 'process.signal_failed', 'failed', { signal, error: error instanceof Error ? error.message : String(error) });
+        return false;
+    }
+}
+function forceOwned(record, reason) {
+    if (!owned.has(record.pid))
+        return;
+    if (process.platform === 'win32') {
+        const result = spawnSync('taskkill', ['/pid', String(record.pid), '/t', '/f'], { stdio: 'ignore', windowsHide: true });
+        audit(record, 'process.signal', result.status === 0 ? 'succeeded' : 'failed', { reason, signal: 'taskkill-/t-/f', exitStatus: result.status });
+        return;
+    }
+    const sent = signalOwned(record, 'SIGKILL');
+    audit(record, 'process.signal', sent ? 'succeeded' : 'failed', { reason, signal: 'SIGKILL' });
+}
+function installExitHook() {
+    if (exitHookInstalled)
+        return;
+    exitHookInstalled = true;
+    process.once('exit', () => {
+        for (const record of owned.values())
+            forceOwned(record, 'parent-shutdown');
+    });
+}
+function launchParentDeathSupervisor(pid, processGroup, graceMs) {
+    const posix = process.platform !== 'win32';
+    const script = posix ? [
+        "const pgid=Number(process.argv[1]),grace=Number(process.argv[2]);",
+        "const alive=()=>{try{process.kill(-pgid,0);return true}catch(e){return e&&e.code==='EPERM'}};",
+        "const stop=()=>{try{process.kill(-pgid,'SIGTERM')}catch{}setTimeout(()=>{try{process.kill(-pgid,'SIGKILL')}catch{}process.exit(0)},grace).unref()};",
+        "const timer=setInterval(()=>{if(!alive()){clearInterval(timer);process.exit(0);return}if(process.ppid===1){clearInterval(timer);stop()}},250);",
+    ].join('') : [
+        "const {spawnSync}=require('node:child_process'),owner=Number(process.argv[1]),pid=Number(process.argv[2]);",
+        "const alive=p=>{try{process.kill(p,0);return true}catch{return false}};",
+        "const timer=setInterval(()=>{if(!alive(pid)){clearInterval(timer);process.exit(0);return}if(!alive(owner)){clearInterval(timer);spawnSync('taskkill',['/pid',String(pid),'/t','/f'],{stdio:'ignore'});process.exit(0)}},250);",
+    ].join('');
+    const supervisorArgs = posix ? [String(processGroup), String(graceMs)] : [String(process.pid), String(pid)];
+    const supervisor = spawn(process.execPath, ['-e', script, ...supervisorArgs], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    supervisor.unref();
+    return supervisor;
+}
+/** Spawn one disposable Relay-owned process group. Arguments are intentionally excluded from audit logs. */
+export function spawnOwnedProcess(command, args, options) {
+    installExitHook();
+    if (options.signal?.aborted)
+        throw new Error(`${options.invocation} aborted before launch`);
+    const detached = process.platform !== 'win32';
+    const child = spawn(command, [...args], { ...options.spawn, detached });
+    if (!child.pid)
+        return child;
+    const record = {
+        child,
+        invocationId: randomUUID(),
+        invocation: options.invocation,
+        command,
+        pid: child.pid,
+        processGroup: detached ? child.pid : null,
+        startedAt: Date.now(),
+        graceMs: options.graceMs ?? 750,
+        correlation: options.correlation,
+        terminating: false,
+    };
+    owned.set(record.pid, record);
+    byChild.set(child, record);
+    record.supervisor = launchParentDeathSupervisor(record.pid, record.processGroup, record.graceMs);
+    audit(record, 'process.launched', 'started', {});
+    const abort = () => { void terminateOwnedProcess(child, 'abort'); };
+    record.abort = abort;
+    options.signal?.addEventListener('abort', abort, { once: true });
+    if (options.timeoutMs !== undefined) {
+        record.timeoutTimer = setTimeout(() => { void terminateOwnedProcess(child, 'timeout'); }, options.timeoutMs);
+        record.timeoutTimer.unref();
+    }
+    child.once('exit', (code, signal) => {
+        audit(record, 'process.exited', code === 0 ? 'succeeded' : 'failed', { exitStatus: code, signal });
+        // `close` waits for inherited stdio. End any descendants left behind by a
+        // wrapper before they can keep the caller alive indefinitely.
+        if (!record.terminating)
+            void terminateOwnedProcess(child, 'leader-exit');
+    });
+    child.once('close', () => {
+        if (record.timeoutTimer)
+            clearTimeout(record.timeoutTimer);
+        options.signal?.removeEventListener('abort', abort);
+        // The leader closing is not proof that its process group is gone.
+        // In particular, unref'd grandchildren need not inherit stdio.
+        // Preserve ownership and the force-kill timer through the grace window.
+        if (!record.terminating)
+            void terminateOwnedProcess(child, 'leader-exit');
+        setTimeout(() => {
+            if (record.forceTimer)
+                clearTimeout(record.forceTimer);
+            record.supervisor?.kill('SIGTERM');
+            owned.delete(record.pid);
+        }, record.graceMs + 100).unref();
+    });
+    return child;
+}
+export async function terminateOwnedProcess(child, reason, graceMs) {
+    const record = byChild.get(child);
+    if (!record || !owned.has(record.pid))
+        return;
+    if (!record.terminating) {
+        record.terminating = true;
+        const sent = signalOwned(record, 'SIGTERM');
+        audit(record, 'process.signal', sent ? 'succeeded' : 'failed', { reason, signal: 'SIGTERM' });
+        record.forceTimer = setTimeout(() => forceOwned(record, reason), graceMs ?? record.graceMs);
+        record.forceTimer.unref();
+    }
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    await new Promise(resolve => {
+        const fallback = setTimeout(resolve, (graceMs ?? record.graceMs) + 1000);
+        fallback.unref();
+        child.once('close', () => { clearTimeout(fallback); resolve(); });
+    });
+}
+export async function shutdownOwnedProcesses(reason = 'parent-shutdown') {
+    await Promise.allSettled([...owned.values()].map(record => terminateOwnedProcess(record.child, reason)));
+}
+export function ownedProcessSnapshot() {
+    return [...owned.values()].map(record => ({
+        invocationId: record.invocationId,
+        invocation: record.invocation,
+        pid: record.pid,
+        processGroup: record.processGroup,
+        elapsedMs: Date.now() - record.startedAt,
+    }));
+}

package/dist/planner.js

@@ -1,4 +1,3 @@
-import { spawn } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
@@ -7,6 +6,7 @@ import { executionContextPrompt } from './execution-context.js';
 import { parseAgentGraph, validateAgentSelection } from './agent-graph.js';
 import { dispatchPlannerTrigger } from './workflow/planner-trigger-v2.js';
 import { createTaskEntity } from './workflow/entity-creation.js';
+import { spawnOwnedProcess } from './owned-process.js';
 export function semanticTaskTree(tasks) {
     const work = tasks.filter(task => task.kind !== 'planner');
     const ids = new Set(work.map(task => task.id));
@@ -384,11 +384,11 @@ export class CommandObjectivePlanner {
     }
     async plan(context, signal) {
         return await new Promise((resolve, reject) => {
-            const child = spawn(this.command, [], { stdio: ['pipe', 'pipe', 'pipe'] });
+            const child = spawnOwnedProcess(this.command, [], { invocation: 'planner.command', signal, correlation: { jobId: context.job.id }, spawn: { stdio: ['pipe', 'pipe', 'pipe'] } });
             let stdout = '';
             let stderr = '';
-            child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
-            child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+            child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
+            child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
             child.on('error', reject);
             child.on('close', code => code === 0 ? (() => { try {
                 resolve(parsePlannerOutput(stdout));
@@ -396,8 +396,7 @@ export class CommandObjectivePlanner {
             catch (error) {
                 reject(error);
             } })() : reject(new Error(stderr.trim() || `Planner exited ${code}`)));
-            signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
-            child.stdin.end(plannerInput(context));
+            child.stdin?.end(plannerInput(context));
         });
     }
 }
@@ -430,7 +429,7 @@ export class AgentObjectivePlanner {
         const resolvedContext = context.executionContext ? executionContextPrompt(context.executionContext) + '\n\n' : '';
         const prompt = instructions.trim() + '\n\n## Shared Task / Job Contract\n\n' + contract.trim() + '\n\n' + resolvedContext + '## Durable planner input\n\n' + plannerInput(context);
         return await new Promise((resolve, reject) => {
-            const child = spawn(this.command, ['exec', '--json', '--', prompt], { cwd: context.executionContext?.project.path, stdio: ['ignore', 'pipe', 'pipe'] });
+            const child = spawnOwnedProcess(this.command, ['exec', '--json', '--', prompt], { invocation: 'planner.agent', signal, correlation: { jobId: context.job.id }, spawn: { cwd: context.executionContext?.project.path, stdio: ['ignore', 'pipe', 'pipe'] } });
             let stdoutBuffer = '';
             let finalMessage = '';
             let stderrTail = '';
@@ -439,14 +438,14 @@ export class AgentObjectivePlanner {
                 if (message)
                     finalMessage = message;
             };
-            child.stdout.on('data', (chunk) => {
+            child.stdout?.on('data', (chunk) => {
                 stdoutBuffer += chunk.toString();
                 const lines = stdoutBuffer.split(/\r?\n/);
                 stdoutBuffer = lines.pop() ?? '';
                 for (const line of lines)
                     consume(line);
             });
-            child.stderr.on('data', (chunk) => { stderrTail = (stderrTail + chunk.toString()).slice(-16384); });
+            child.stderr?.on('data', (chunk) => { stderrTail = (stderrTail + chunk.toString()).slice(-16384); });
             child.on('error', reject);
             child.on('close', code => {
                 if (stdoutBuffer)
@@ -466,7 +465,6 @@ export class AgentObjectivePlanner {
                     reject(error);
                 }
             });
-            signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
         });
     }
 }

package/dist/reconciler-runtime.js

@@ -54,6 +54,7 @@ export class ReconcilerRuntimeBase {
     continuationLive = new Set();
     launchFailureClaims = new Set();
     terminalWaiters = new Map();
+    startAckCleanups = new Set();
     taskTransitions;
     eventCoordinator;
     detachedReconciles = new Set();
@@ -155,6 +156,7 @@ export class ReconcilerRuntimeBase {
         await this.eventCoordinator.settle();
         if (this.detachedReconciles.size > 0)
             await Promise.allSettled([...this.detachedReconciles]);
+        await Promise.allSettled([...this.startAckCleanups].map(stop => stop()));
         for (const live of this.live.values()) {
             const sourceId = executionEventSource(live.jobId, live.taskId, live.executionId);
             if (activeExecutionOwners.get(sourceId) === this)
@@ -204,9 +206,20 @@ export class ReconcilerRuntimeBase {
             rejectAck(new StartAckTimeout(`Task ${taskId} worker_start_timeout: no worker task.started start-ack`));
         }, timeoutMs);
         let stopped = false;
-        const stop = async () => { if (stopped)
-            return; stopped = true; if (timer)
-            clearTimeout(timer); await unsubscribe(); };
+        const stop = async () => {
+            if (stopped)
+                return;
+            stopped = true;
+            if (timer)
+                clearTimeout(timer);
+            if (!settled) {
+                settled = true;
+                rejectAck(new StartAckTimeout(`Task ${taskId} worker_start_cancelled: start-ack owner closed`));
+            }
+            this.startAckCleanups.delete(stop);
+            await unsubscribe();
+        };
+        this.startAckCleanups.add(stop);
         return { ack, stop };
     }
     registerExecutionOwner(jobId, taskId, executionId) {
@@ -325,7 +338,8 @@ export class ReconcilerRuntimeBase {
             return;
         if (task.adapter !== 'chatgpt')
             this.clearTerminalTimer(taskId, executionId);
-        await this.emit(eventFor(jobId, taskId, task.parentTaskId, task.adapter === 'chatgpt' ? 'task.process.async_exited' : 'task.process.exited', error ? 'failed' : 'succeeded', error ?? result?.summary ?? 'Worker runtime exited', 'orchestrator', { authoritative: false, waitingForTerminalEvent: true, processError: error }, { agent: 'relay', component: 'agents-relay' }));
+        await this.emit(eventFor(jobId, taskId, task.parentTaskId, task.adapter === 'chatgpt' ? 'task.process.async_exited' : 'task.process.exited', live?.execution.processExit ? (live.execution.processExit.exitCode === 0 ? 'succeeded' : 'failed') : (error ? 'failed' : 'succeeded'), result?.summary ?? (error ? 'Worker runtime exited with error' : 'Worker runtime exited'), 'orchestrator', { authoritative: false, waitingForTerminalEvent: true, exitCode: live?.execution.processExit?.exitCode ?? null,
+            signal: live?.execution.processExit?.signal ?? null, stderr: live?.execution.processExit?.stderr ?? '', processError: error }, { agent: 'relay', component: 'agents-relay' }));
     }
     async timeoutTask(jobId, taskId, executionId) {
         const live = this.live.get(taskId);

package/dist/relayd.js

@@ -26,6 +26,7 @@ import { JsonlDecisionAuditStore } from './decision-audit.js';
 import { summarizeRuntime } from './runtime-summary.js';
 import { executionRouterRulesPath } from './routing-policy.js';
 import { workerCandidates } from './worker-routing.js';
+import { shutdownOwnedProcesses } from './owned-process.js';
 import { routeExecution } from './execution-routing.js';
 import { RelayObservability, classifyFailure, errorMessage, observability, setObservability } from './observability.js';
 /** Initialize the process-wide structured observability sink once, from environment. */
@@ -508,7 +509,7 @@ export async function runDaemon(argv) {
     const stop = () => { if (interval)
         clearInterval(interval); if (scheduleInterval)
         clearInterval(scheduleInterval); if (projectionInterval)
-        clearInterval(projectionInterval); void stopWatch().finally(() => { for (const store of relayStores.values())
+        clearInterval(projectionInterval); void Promise.allSettled([stopWatch(), shutdownOwnedProcesses('parent-shutdown')]).finally(() => { for (const store of relayStores.values())
         store.close(); server.close(() => process.exit(0)); }); };
     process.once('SIGINT', stop);
     process.once('SIGTERM', stop);

package/dist/usage.js

@@ -3,7 +3,7 @@ import { readdir, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
-import { spawn } from 'node:child_process';
+import { spawnOwnedProcess, terminateOwnedProcess } from './owned-process.js';
 export class BrowserWorkspaceUsageReader {
     command;
     timeoutMs;
@@ -18,7 +18,7 @@ export class BrowserWorkspaceUsageReader {
     async read() {
         const observedAt = this.now().toISOString();
         return await new Promise(resolve => {
-            const child = spawn(this.command, [], { stdio: ['pipe', 'pipe', 'ignore'] });
+            const child = spawnOwnedProcess(this.command, [], { invocation: 'usage.browser-workspace', timeoutMs: this.timeoutMs, spawn: { stdio: ['pipe', 'pipe', 'ignore'] } });
             let output = '';
             let settled = false;
             const finish = (capacity) => {
@@ -26,13 +26,13 @@ export class BrowserWorkspaceUsageReader {
                     return;
                 settled = true;
                 clearTimeout(timer);
-                child.kill();
+                void terminateOwnedProcess(child, 'cancel');
                 resolve(capacity);
             };
             const unavailable = (reason) => ({ name: 'Harness', poolSize: null, idle: null, leased: null, available: null, observedAt, reason });
             const timer = setTimeout(() => finish(unavailable('Browser Workspace capacity probe timed out.')), this.timeoutMs);
-            child.stdout.setEncoding('utf8');
-            child.stdout.on('data', chunk => { output += chunk; });
+            child.stdout?.setEncoding('utf8');
+            child.stdout?.on('data', chunk => { output += chunk; });
             child.once('error', () => finish(unavailable('Browser Workspace capacity probe could not be started.')));
             child.once('close', code => {
                 if (settled)
@@ -65,7 +65,7 @@ export class BrowserWorkspaceUsageReader {
                 }
                 finish(unavailable(code === 0 ? 'Browser Workspace capacity probe returned no usable capacity.' : `Browser Workspace capacity probe exited with code ${code ?? 'unknown'}.`));
             });
-            child.stdin.end('import json\nprint(json.dumps(workspace_capacity()))\n');
+            child.stdin?.end('import json\nprint(json.dumps(workspace_capacity()))\n');
         });
     }
 }
@@ -133,9 +133,15 @@ export class CodexApiUsageReader {
     async read() {
         const generatedAt = this.now().toISOString();
         return await new Promise(resolve => {
-            const child = spawn('codex', ['app-server', '--stdio'], { stdio: ['pipe', 'pipe', 'ignore'] });
+            const child = spawnOwnedProcess('codex', ['app-server', '--stdio'], { invocation: 'usage.codex-app-server', timeoutMs: 10_000, spawn: { stdio: ['pipe', 'pipe', 'ignore'] } });
+            if (!child.stdout) {
+                resolve({ available: false, generatedAt, fiveHour: null, weekly: null, reason: 'Codex app-server stdout unavailable.' });
+                return;
+            }
             const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
-            const finish = (snapshot) => { lines.close(); child.kill(); resolve(snapshot); };
+            let queryTimer;
+            const finish = (snapshot) => { lines.close(); if (queryTimer)
+                clearTimeout(queryTimer); void terminateOwnedProcess(child, 'cancel'); resolve(snapshot); };
             const timer = setTimeout(() => finish({ available: false, generatedAt, fiveHour: null, weekly: null, reason: 'Codex app-server rate-limit request timed out.' }), 10_000);
             lines.on('line', line => {
                 try {
@@ -164,8 +170,8 @@ export class CodexApiUsageReader {
                 }
             });
             child.once('error', () => { clearTimeout(timer); finish({ available: false, generatedAt, fiveHour: null, weekly: null, reason: 'Codex app-server could not be started.' }); });
-            child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { clientInfo: { name: 'agents-relay', version: '1' }, capabilities: {} } }) + '\n');
-            setTimeout(() => child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'account/rateLimits/read', params: {} }) + '\n'), 100);
+            child.stdin?.write(JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { clientInfo: { name: 'agents-relay', version: '1' }, capabilities: {} } }) + '\n');
+            queryTimer = setTimeout(() => child.stdin?.write(JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'account/rateLimits/read', params: {} }) + '\n'), 100);
         });
     }
 }

package/dist/workspace.js

@@ -1,9 +1,18 @@
 import { mkdir, readdir, stat } from 'node:fs/promises';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { homedir } from 'node:os';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
+import { spawnOwnedProcess } from './owned-process.js';
+async function gitOutput(args) {
+    return await new Promise((resolve, reject) => {
+        const child = spawnOwnedProcess('git', args, { invocation: 'workspace.git', spawn: { stdio: ['ignore', 'pipe', 'pipe'] } });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', chunk => { stdout += chunk.toString(); });
+        child.stderr?.on('data', chunk => { stderr += chunk.toString(); });
+        child.once('error', reject);
+        child.once('close', code => code === 0 ? resolve(stdout) : reject(new Error(stderr.trim() || `git exited ${code}`)));
+    });
+}
 export function defaultWorkspaceRoot() {
     return join(homedir(), 'Workspace');
 }
@@ -42,7 +51,7 @@ export async function discoverGitRepositories(root) {
 }
 async function origin(path) {
     try {
-        return (await execFileAsync('git', ['-C', path, 'remote', 'get-url', 'origin'])).stdout.trim() || null;
+        return (await gitOutput(['-C', path, 'remote', 'get-url', 'origin'])).trim() || null;
     }
     catch {
         return null;
@@ -111,7 +120,7 @@ export function taskUsesCanonicalProjectRun(task, tasks) {
     return false;
 }
 async function git(path, args) {
-    return (await execFileAsync('git', ['-C', path, ...args])).stdout.trim();
+    return (await gitOutput(['-C', path, ...args])).trim();
 }
 export async function prepareManagedExecutionWorktree(projectPath, repository, prNumber, head, executionId) {
     const primary = await git(projectPath, ['rev-parse', '--show-toplevel']);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.58",
+  "version": "2.0.59",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {