agents-relay 2.0.57 → 2.0.59

package/README.md

@@ -230,9 +230,9 @@ Managed tasks are descriptive work for agents, not shell commands. Use `codex` o
 
 Every model-backed task declares a durable output with `--output task-pr` or `--output file --output-path PATH`. Agents Relay bootstraps workers with the managed PR URL, durable task-comment URL, job/task identity, project, output contract, and mandatory terminal-event contract; workers retrieve the task intent from GitHub rather than receiving a duplicate copy of the stored task prompt.
 
-For Codex and ChatGPT, **correlated worker events are authoritative lifecycle inputs**, not a separate durable store. Event publication uses the canonical Neo `events-bus` surface (`events__publish` for sandboxed/hosted workers, or `NEO_EVENTS_EMIT` for direct local workers); Agents Relay subscribes, validates correlation, applies graph transitions, persists results in RelayStore, and projects them to GitHub. Relay publishes `task.process.launched` only after successful adapter launch; `task.started` is worker-owned and must be a new, correlated start acknowledgement. Codex publishes `task.process.exited` when its synchronous runtime exits, while ChatGPT publishes `task.process.async_exited` after its submission runtime exits; neither substitutes for `task.completed`, `task.failed`, `task.blocked`, or `task.cancelled`. The ChatGPT worker-owned tab follows the configured close policy: `after-start` waits for the correlated start acknowledgement, `never` keeps it open for debug, and `after-terminal` waits for a new exact-task terminal event; start-ack failure closes only the owned tab after 60 seconds. The executing agent must publish exactly one correlated terminal event. Relay persists the matching durable state only from that terminal event. Model-backed tasks require an event bus and time out explicitly if no terminal event arrives.
+For Codex and ChatGPT, **correlated worker events are authoritative lifecycle inputs**, not a separate durable store. Event publication uses the canonical Neo `events-bus` surface (`events__publish` for sandboxed/hosted workers, or `NEO_EVENTS_EMIT` for direct local workers); Agents Relay subscribes, validates correlation, applies graph transitions, persists results in RelayStore, and projects them to GitHub. Relay publishes `task.process.launched` only after successful adapter launch; `task.started` is worker-owned and must be a new, correlated start acknowledgement. Codex publishes `task.process.exited` when its synchronous runtime exits, while ChatGPT publishes `task.process.async_exited` after its one-shot submission runtime exits; neither substitutes for `task.completed`, `task.failed`, `task.blocked`, or `task.cancelled`. The executing agent must publish exactly one correlated terminal event. Relay persists the matching durable state only from that terminal event. Model-backed tasks require an event bus and time out explicitly if no terminal event arrives.
 
-The ChatGPT adapter uses Relay's `agents/chatgpt-worker.agent.md` lifecycle contract and Browser Workspace `platforms/chatgpt` for all ChatGPT browser mechanics. It opens a fresh Temporary Chat tab, uses the account defaults, submits the prompt, verifies acceptance, and applies `--chatgpt-tab-close-policy` (or `AGENTS_RELAY_CHATGPT_TAB_CLOSE_POLICY`): `after-start` by default, `never` for test/debug, or `after-terminal` after a new exact-task terminal event. It never closes a user tab and does not poll for the assistant response, resume/reopen a thread, or use conversation text as the result channel. Any observed ChatGPT thread ID is diagnostic only.
+The ChatGPT adapter uses Relay's `agents/chatgpt-worker.agent.md` lifecycle contract and invokes Browser Workspace exactly as a one-shot platform action: `browser-workspace platform run chatgpt temporary-submit --auto-session --config <file>`. Browser Workspace owns creation/release of the fresh Temporary Chat session, selectors, attachments, and submit verification; Relay does not self-heal browser failures and instead lets delivery failures enter its normal retry/recovery lifecycle. Legacy `--chatgpt-tab-close-policy` values remain accepted for compatibility around Relay's event barriers, but they do not control the Browser Workspace auto-session lifetime. The adapter never uses a pre-existing user tab, polls for the assistant response, resumes/reopens a thread, or treats conversation text as the result channel. Any observed ChatGPT thread ID is diagnostic only.
 
 ~~~sh
 npx agents-relay task create --repo OWNER/REPO --pr 5 --id job-1 \
@@ -283,4 +283,4 @@ For autonomous Jobs, `UNBLOCKED` is historical: Relay does not retry that old Ta
 
 ### Browser Workspace product boundary
 
-Agents Relay owns the persistent `Relay` browser workspace as product infrastructure. At daemon startup it runs `browser-workspace status`, dynamically imports the returned absolute `admin_helper`, and calls `ensureWorkspace("Relay", 6)`. This bootstrap is best-effort: Browser Workspace discovery/helper failures are logged and skipped so they do not prevent `agents-relayd` from starting; ChatGPT browser work may remain unavailable until Browser Workspace recovers. Ordinary worker/session activity remains on the public Browser Workspace CLI (`session start/exec/stop` and platform commands). Relay does not create or delete workspaces through CLI lifecycle commands.
+Agents Relay owns the persistent `Relay` browser workspace as product infrastructure. At daemon startup it runs `browser-workspace status`, dynamically imports the returned absolute `admin_helper`, and calls `ensureWorkspace("Relay", 6)`. This bootstrap is best-effort: Browser Workspace discovery/helper failures are logged and skipped so they do not prevent `agents-relayd` from starting; ChatGPT browser work may remain unavailable until Browser Workspace recovers. Ordinary ChatGPT worker activity uses the public Browser Workspace one-shot `platform run ... --auto-session` command; orchestrator-owned self-healing flows may still use explicit session commands. Relay does not create or delete workspaces through CLI lifecycle commands.

package/agents/chatgpt-worker.agent.md

@@ -11,14 +11,12 @@ You execute one complete Relay task by submitting it to a fresh worker-owned Cha
 ## Contract
 
 - Browser Workspace `platforms/chatgpt` is the sole owner of ChatGPT selectors, readiness checks, attachments, Temporary Chat mechanics, and submit verification.
-- Relay owns worker lifecycle, task/event barriers, routing, cancellation, and tab/session close policy.
-- Execute only a one-shot submission. Do not expose a create/resume/status/result conversation lifecycle.
-- Always use a fresh worker-owned Browser Workspace session/tab. Never submit through a pre-existing user tab.
+- Relay owns worker lifecycle, task/event barriers, routing, and cancellation; Browser Workspace owns the one-shot auto-session lifecycle.
+- Execute only a one-shot submission with `platform run chatgpt temporary-submit --auto-session`. Do not expose a create/resume/status/result conversation lifecycle.
+- Let Browser Workspace create and release the fresh Temporary Chat session/tab for the action. Never submit through a pre-existing user tab.
 - Preserve the account's current default model/thinking settings.
 - A submission is accepted only after Browser Workspace returns a verified submit receipt.
 - Treat observed conversation/thread identity as diagnostic only, never as a resumable handle.
-- `after-start` releases the Browser Workspace session after the exact worker `task.started` barrier.
-- `after-terminal` releases it after the exact task terminal barrier.
-- `never` leaves the owned session open for test/debug.
+- Legacy ChatGPT tab-close policy values remain accepted by Relay for compatibility, but they do not control Browser Workspace's auto-session lifetime or add self-heal.
 - Do not wait for the assistant response. Durable task success/failure is event-owned by Relay and the executing task.
 - Stop on authentication, MFA, consent, or ambiguous browser state rather than bypassing it.

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;
     }
@@ -151,20 +128,32 @@ function parseDriverJson(output) {
 function browserWorkspaceCli(override = process.env.AGENTS_RELAY_BROWSER_WORKSPACE_COMMAND) {
     return override ? { command: override, prefix: [] } : { command: 'npx', prefix: ['browser-workspace'] };
 }
-function browserWorkspaceCommand(cli, args, stdin) {
+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 = () => { 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);
         child.on('close', code => {
+            signal?.removeEventListener('abort', abort);
             if (code === 0)
                 resolve(stdout.trim());
+            else if (signal?.aborted)
+                reject(new Error('browser-worker execution aborted'));
             else
                 reject(new Error(stderr.trim() || stdout.trim() || `browser-workspace exited ${code}`));
         });
+        if (signal?.aborted)
+            abort();
+        else
+            signal?.addEventListener('abort', abort, { once: true });
         if (stdin !== undefined) {
             child.stdin?.end(stdin);
         }
@@ -191,86 +180,26 @@ export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS
     }
     await admin.ensureWorkspace(CHATGPT_BROWSER_WORKSPACE, CHATGPT_BROWSER_WORKSPACE_POOL_SIZE);
 }
-function sessionBrowserWorkerRunner() {
+function autoSessionBrowserWorkerRunner() {
     const cli = browserWorkspaceCli();
     return (_definition, request, _route, signal) => {
-        const policy = request.tabClosePolicy ?? 'after-start';
-        let activeSessionId;
-        let released = false;
-        let releaseResolve;
-        const releaseBarrier = new Promise(resolve => { releaseResolve = resolve; });
-        const release = () => {
-            if (released)
-                return;
-            released = true;
-            releaseResolve();
-        };
-        let submittedResolve;
-        let submittedReject;
-        const submitted = new Promise((resolve, reject) => {
-            submittedResolve = resolve;
-            submittedReject = reject;
-        });
         const promise = (async () => {
             const configFile = join(process.env.TMPDIR ?? '/tmp', `agents-relay-chatgpt-${randomUUID()}.json`);
             try {
                 await writeFile(configFile, JSON.stringify({
                     prompt: request.prompt,
                     file: request.files ?? [],
-                    close_policy: 'never',
                 }));
-                const startOutput = await browserWorkspaceCommand(cli, ['session', 'start', '--workspace', CHATGPT_BROWSER_WORKSPACE]);
-                const started = parseWorkspaceJson(startOutput);
-                if (typeof started.session_id !== 'string') {
-                    throw new Error('browser-workspace session start returned no session_id');
-                }
-                activeSessionId = started.session_id;
                 if (signal.aborted)
                     throw new Error('browser-worker execution aborted');
-                const source = await browserWorkspaceCommand(cli, ['platform', 'source', 'chatgpt', 'temporary-submit', '--config', configFile]);
-                const execOutput = await browserWorkspaceCommand(cli, ['session', 'exec', activeSessionId], source);
-                const wrapper = parseWorkspaceJson(execOutput);
-                if (wrapper.ok !== true) {
-                    throw new Error(typeof wrapper.error === 'string' ? wrapper.error : 'browser-workspace session exec failed');
-                }
-                const receipt = parseDriverJson(typeof wrapper.stdout === 'string' ? wrapper.stdout : '');
-                const result = JSON.stringify(receipt);
-                submittedResolve(result);
-                if (policy === 'never') {
-                    await unlink(configFile).catch(() => { });
-                    activeSessionId = undefined;
-                    return result;
-                }
-                await releaseBarrier;
-                if (activeSessionId) {
-                    await browserWorkspaceCommand(cli, ['session', 'stop', activeSessionId]);
-                    activeSessionId = undefined;
-                }
-                return result;
+                const output = await browserWorkspaceCommand(cli, ['platform', 'run', 'chatgpt', 'temporary-submit', '--auto-session', '--config', configFile], undefined, signal);
+                return JSON.stringify(parseDriverJson(output));
             }
-            catch (failure) {
-                if (activeSessionId) {
-                    await browserWorkspaceCommand(cli, ['session', 'stop', activeSessionId]).catch(() => { });
-                    activeSessionId = undefined;
-                }
+            finally {
                 await unlink(configFile).catch(() => { });
-                const error = failure instanceof Error ? failure : new Error(String(failure));
-                submittedReject(error);
-                throw error;
             }
         })();
-        const cancel = () => {
-            release();
-            if (activeSessionId) {
-                void browserWorkspaceCommand(cli, ['session', 'stop', activeSessionId]);
-                activeSessionId = undefined;
-            }
-        };
-        if (signal.aborted)
-            cancel();
-        else
-            signal.addEventListener('abort', cancel, { once: true });
-        return { promise, submitted, release, cancel };
+        return { promise, submitted: promise, cancel: () => { } };
     };
 }
 function parseBrowserWorkerResponse(output) {
@@ -326,7 +255,7 @@ export class ChatGptAdapter {
             if (controller.signal.aborted)
                 throw new Error('browser-worker execution aborted');
             const policy = chatGptTabClosePolicy(task.chatgptTabClosePolicy, this.tabClosePolicy);
-            const run = (this.runner ?? sessionBrowserWorkerRunner())(definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
+            const run = (this.runner ?? autoSessionBrowserWorkerRunner())(definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
             try {
                 const output = await (run.submitted ?? run.promise);
                 const response = parseBrowserWorkerResponse(output);
@@ -335,7 +264,7 @@ export class ChatGptAdapter {
                     await context.waitForWorkerStart;
                 else if (policy === 'after-terminal') {
                     if (!context.waitForTerminal)
-                        throw new Error('ChatGPT after-terminal tab close policy requires a terminal event barrier');
+                        throw new Error('ChatGPT after-terminal compatibility policy requires a terminal event barrier');
                     await context.waitForTerminal;
                 }
                 if (policy !== 'never')

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.57",
+  "version": "2.0.59",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {