agents-relay 2.0.58 → 2.0.60

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, pid: child.pid, 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-shutdown.js

@@ -0,0 +1,16 @@
+/** One-shot CLI commands may have leaked transport handles after durable work ends. */
+export async function runCliEntrypoint(main, options = {}) {
+    let exitCode = 0;
+    try {
+        await main();
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        exitCode = 1;
+    }
+    process.exitCode = exitCode;
+    if (options.serve)
+        return;
+    const timer = setTimeout(() => (options.forceExit ?? process.exit)(exitCode), options.graceMs ?? 2_000);
+    timer.unref();
+}

package/dist/cli-support.js

@@ -145,7 +145,20 @@ export async function withEventBus(args, work, resolve = eventBus) {
         return await work(bus);
     }
     finally {
-        await bus?.close?.();
+        if (bus?.close) {
+            let timer;
+            const deadline = new Promise(resolve => { timer = setTimeout(resolve, 1_500); });
+            try {
+                await Promise.race([bus.close(), deadline]);
+            }
+            catch (error) {
+                process.stderr.write('warning: event bus close failed: ' + (error instanceof Error ? error.message : String(error)) + '\n');
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        }
     }
 }
 export async function publishWake(bus, job, taskId, message) { if (!bus)

package/dist/cli.js

@@ -14,11 +14,11 @@ import { CodexThreadContinuation, CommandContinuation, WebhookContinuation } fro
 import { eventFor } from './events.js';
 import { serveDashboard } from './dashboard.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
-import { decisionMode, LayaCliDecisionEngine } from './decision.js';
+import { decisionMode, executionDecisionEngine } from './decision.js';
 import { discoverAgents } from './registry.js';
 import { AgentObjectivePlanner, CommandObjectivePlanner } from './planner.js';
 import { transitionJobEvent } from './scheduler.js';
-import { applyOrchestratorStartAction, applyOrchestratorCompleteAction, applyTaskHoldAction, dispatchTaskAction } from './task-actions.js';
+import { applyOrchestratorStartAction, applyOrchestratorCompleteAction, applyTaskHoldAction, applyTaskQueueAction, dispatchTaskAction } from './task-actions.js';
 import { applyJobActivateAction, applyJobCancelAction } from './job-actions.js';
 import { resolveExecutionContext } from './execution-context.js';
 import { defaultWorkspaceRoot, resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
@@ -29,6 +29,8 @@ 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 { runCliEntrypoint } from './cli-shutdown.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';
@@ -164,7 +166,9 @@ async function runTaskCommand(action, args) {
         await runManagedTaskCommand(action, args);
         return;
     }
-    const { store, job, localFile } = await storeFor(args);
+    const loaded = await storeFor(args);
+    const { store, localFile } = loaded;
+    const job = managed && action === 'update' ? await relayControlJob(args, loaded.job.id) : loaded.job;
     if (action === 'list') {
         console.log(JSON.stringify(job.tasks, null, 2));
         return;
@@ -240,6 +244,7 @@ async function runTaskCommand(action, args) {
         console.log(JSON.stringify(outputTask, null, 2));
         return;
     }
+    const expectedUpdatedAt = task.updatedAt;
     if (['RUNNING', 'UNBLOCKED', 'SUCCEEDED', 'CANCELLED'].includes(task.state))
         throw new Error(`Task ${id} is ${task.state}; durable execution fields are immutable in this state`);
     if (hasArg(args, '--adapter')) {
@@ -282,9 +287,13 @@ async function runTaskCommand(action, args) {
     if (hasArg(args, '--draft') && task.state === 'QUEUED')
         await applyTaskHoldAction(task);
     if (hasArg(args, '--queue')) {
-        await store.saveTask(task);
-        const result = await dispatchTaskAction(store, { id: 'task.queue', jobId: job.id, taskId: id });
-        Object.assign(task, result.task);
+        if (managed)
+            await applyTaskQueueAction(job, task);
+        else {
+            await store.saveTask(task);
+            const result = await dispatchTaskAction(store, { id: 'task.queue', jobId: job.id, taskId: id });
+            Object.assign(task, result.task);
+        }
     }
     if (hasArg(args, '--max-attempts') && task.maxAttempts < task.attempt)
         throw new Error('--max-attempts cannot be less than the current attempt count');
@@ -308,6 +317,11 @@ async function runTaskCommand(action, args) {
         if (hasArg(args, '--reasoning') && !hasArg(args, '--timeout'))
             task.timeoutMs = taskOverallTimeoutMs(task.storySize ?? 'M', task.routing.reasoning);
     }
+    if (managed) {
+        const updated = await relayTaskCommand(args, { jobId: job.id, taskId: id, action: 'update', task, expectedUpdatedAt });
+        console.log(JSON.stringify(updated.tasks.find(item => item.id === id), null, 2));
+        return;
+    }
     task.updatedAt = new Date().toISOString();
     await store.saveTask(task);
     await saveLocal(localFile, job);
@@ -457,7 +471,7 @@ async function runJobCommand(action, args) {
 }
 export function runtimePlanner(args) { const plannerCommand = arg([...args], '--planner-command'); const modelRuntime = arg([...args], '--codex', 'codex'); return plannerCommand ? new CommandObjectivePlanner(plannerCommand) : new AgentObjectivePlanner(modelRuntime); }
 export function runtimeReviewer() { return { requirements: { capabilities: ['model'] } }; }
-export function runtime(store, args, bus, usageRegistry = codexAndZaiUsageRegistry()) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); const policy = chatGptTabClosePolicy(args); const planner = runtimePlanner(args); return new Reconciler(store, { owner: arg(args, '--owner', `cli-${process.pid}`), maxConcurrent: Number(arg(args, '--concurrency', '4')), leaseMs: Number(arg(args, '--lease-ms', '300000')), adapters: [new CodexAdapter(modelRuntime), new ChatGptAdapter({ tabClosePolicy: policy })], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, usageSnapshotProvider: () => usageRegistry.snapshot(), decisionEngine: new LayaCliDecisionEngine(), decisionMode: decisionMode(), reviewer: runtimeReviewer(), eventBus: bus, emit, chatgptTabClosePolicy: policy, projectPathForJob: async (job) => resolveRepositoryProjectPath(await resolveManagedProjectPath(job.repository, arg(args, '--project-path'), arg(args, '--workspace-root') || defaultWorkspaceRoot()), job.projectPath) }); }
+export function runtime(store, args, bus, usageRegistry = codexAndZaiUsageRegistry()) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); const policy = chatGptTabClosePolicy(args); const planner = runtimePlanner(args); return new Reconciler(store, { owner: arg(args, '--owner', `cli-${process.pid}`), maxConcurrent: Number(arg(args, '--concurrency', '4')), leaseMs: Number(arg(args, '--lease-ms', '300000')), adapters: [new CodexAdapter(modelRuntime), new ChatGptAdapter({ tabClosePolicy: policy })], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, usageSnapshotProvider: () => usageRegistry.snapshot(), decisionEngine: executionDecisionEngine(), decisionMode: decisionMode(), reviewer: runtimeReviewer(), eventBus: bus, emit, chatgptTabClosePolicy: policy, projectPathForJob: async (job) => resolveRepositoryProjectPath(await resolveManagedProjectPath(job.repository, arg(args, '--project-path'), arg(args, '--workspace-root') || defaultWorkspaceRoot()), job.projectPath) }); }
 export function dashboardJobAction(store, reconciler, action) {
     return async (jobId) => {
         const job = await store.load(jobId);
@@ -520,7 +534,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 +645,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,15 +700,21 @@ 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;
     }
     throw new Error(usage);
 }
 if (isEntrypoint(import.meta.url))
-    main().catch(error => { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1; });
+    void runCliEntrypoint(main, { serve: process.argv[2] === 'serve' });

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/dashboard.js

@@ -280,6 +280,8 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
                 let result;
                 if (body.action === 'create' && body.task && resolvedActions?.taskCreate)
                     result = await resolvedActions.taskCreate(requestedJobId, body.task);
+                else if (body.action === 'update' && isTaskId(requestedTaskId) && body.task && body.expectedUpdatedAt && resolvedActions?.taskUpdate)
+                    result = await resolvedActions.taskUpdate(requestedJobId, requestedTaskId, body.task, body.expectedUpdatedAt);
                 else if (body.action === 'start' && isTaskId(requestedTaskId) && resolvedActions?.taskStart)
                     result = await resolvedActions.taskStart(requestedJobId, requestedTaskId);
                 else if (body.action === 'retry' && isTaskId(requestedTaskId) && resolvedActions?.taskRetry)

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}`);
@@ -71,6 +71,54 @@ export function parseChoiceDecision(raw, contract) {
         result.probabilities = parsedProbabilities;
     return result;
 }
+/** OpenRouter Decisions API adapter; the choice contract remains engine-independent. */
+export class JevDecisionEngine {
+    options;
+    name = 'openrouter-jev';
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async decide(request, contract) {
+        validateDecisionRequest(request, contract);
+        const apiKey = this.options.apiKey ?? process.env.OPENROUTER_API_KEY;
+        if (!apiKey)
+            throw new Error('OPENROUTER_API_KEY is required for Jev');
+        const choices = Object.fromEntries(contract.choices.map((choice, index) => [`route_${index + 1}`, choice]));
+        const started = Date.now();
+        const response = await (this.options.fetcher ?? fetch)(this.options.endpoint ?? 'https://openrouter.ai/api/alpha/decisions', {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: this.options.model ?? 'typesafe/jev-1.13',
+                state: request.facts,
+                questions: { decision: { type: 'choice', instructions: contract.question, criteria: choices } },
+            }),
+            signal: AbortSignal.timeout(this.options.timeoutMs ?? 12_000),
+        });
+        if (!response.ok)
+            throw new Error(`Jev Decisions API returned HTTP ${response.status}`);
+        const raw = await response.json();
+        const envelope = raw;
+        const answer = envelope?.answers?.decision;
+        if (!answer || typeof answer.choice !== 'string' || !Object.hasOwn(choices, answer.choice)) {
+            throw new Error('Jev returned a choice outside the decision contract');
+        }
+        const mappedProbabilities = answer.probabilities && typeof answer.probabilities === 'object'
+            ? Object.fromEntries(Object.entries(answer.probabilities)
+                .filter(([id]) => Object.hasOwn(choices, id)).map(([id, p]) => [choices[id], p]))
+            : undefined;
+        return {
+            ...parseChoiceDecision({ choice: choices[answer.choice], probabilities: mappedProbabilities }, contract),
+            usage: raw.usage,
+            latencyMs: Date.now() - started,
+            model: raw.model,
+        };
+    }
+}
+/** Select router engine without changing caller-owned hard gates. */
+export function executionDecisionEngine() {
+    return new JevDecisionEngine();
+}
 /**
  * Stateless Laya invocation. The adapter materializes the caller's JSON state
  * and question contract as temporary files for `uvx laya-mlx predict`. It is
@@ -122,7 +170,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 +185,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/execution-process-tracker.js

@@ -0,0 +1,35 @@
+import { activeRelayLeaseOwner, captureProcessRecord, probeProcessRecord, stopOrphanedProcessGroup } from './process-identity.js';
+/** Correlate Relay execution IDs with OS process identity in SQLite, never GitHub. */
+export async function monitorExecutionProcess(store, jobId, taskId, executionId, owner, execution) {
+    if (!execution.pid || !store.recordExecutionProcess)
+        return;
+    const registration = (async () => {
+        const record = await captureProcessRecord(jobId, taskId, executionId, owner, execution.pid);
+        if (record)
+            await store.recordExecutionProcess?.(record);
+    })();
+    const closeRecord = async () => {
+        await registration;
+        await store.finishExecutionProcess?.(jobId, taskId, executionId);
+    };
+    void execution.promise.then(closeRecord, closeRecord).catch(() => {
+        // Recording failures are surfaced by the registration promise to the caller.
+    });
+    await registration;
+}
+/** Reuse only if the previous exact process has gone or safely been reaped. */
+export async function reclaimStaleExecutionProcess(store, task, currentOwner) {
+    if (!task.executionId || !task.jobId || !store.loadExecutionProcess)
+        return true;
+    const record = await store.loadExecutionProcess(task.jobId, task.id, task.executionId);
+    if (task.leaseOwner && task.leaseOwner !== currentOwner && await activeRelayLeaseOwner(task.leaseOwner))
+        return false;
+    if (!record || record.endedAt)
+        return true;
+    const state = await probeProcessRecord(record);
+    if (state === 'gone' || state === 'reused')
+        return true;
+    if (state !== 'alive' || (task.leaseOwner && task.leaseOwner !== currentOwner && await activeRelayLeaseOwner(task.leaseOwner)))
+        return false;
+    return await stopOrphanedProcessGroup(record);
+}

package/dist/execution-recovery.js

@@ -1,4 +1,5 @@
 import { transitionTaskEvent } from './scheduler.js';
+import { reclaimStaleExecutionProcess } from './execution-process-tracker.js';
 async function currentGeneration(store, job, stale) {
     const task = (await store.load(job.id)).tasks.find(item => item.id === stale.id);
     if (!task)
@@ -23,14 +24,18 @@ export async function recoverExpiredExecutions(job, now, ports) {
         const recoverable = task && (task.state === 'RUNNING' || (task.state === 'QUEUED' && task.executionId !== null));
         if (!recoverable || task.leaseExpiresAt === null || new Date(task.leaseExpiresAt).getTime() > now)
             continue;
+        if (!await reclaimStaleExecutionProcess(ports.store, task, ports.owner))
+            continue;
         await recoverTask(task, 'lease.expired', 'lease_expired', ports);
     }
 }
 export async function recoverStartupOrphans(job, ports) {
-    const candidates = job.tasks.filter(task => task.kind !== 'planner' && task.state === 'RUNNING' && task.executionId && task.leaseOwner && task.leaseOwner !== ports.owner && task.adapter !== 'chatgpt');
+    const candidates = job.tasks.filter(task => task.kind !== 'planner' && (task.state === 'RUNNING' || task.state === 'QUEUED') && task.executionId && task.leaseOwner && task.leaseOwner !== ports.owner && task.adapter !== 'chatgpt');
     for (const stale of candidates) {
         const task = await currentGeneration(ports.store, job, stale);
-        if (!task || task.state !== 'RUNNING' || task.adapter === 'chatgpt' || !task.executionId || !task.leaseOwner || task.leaseOwner === ports.owner)
+        if (!task || !['RUNNING', 'QUEUED'].includes(task.state) || task.adapter === 'chatgpt' || !task.executionId || !task.leaseOwner || task.leaseOwner === ports.owner)
+            continue;
+        if (!await reclaimStaleExecutionProcess(ports.store, task, ports.owner))
             continue;
         await recoverTask(task, 'execution.orphaned', 'startup_orphaned', ports);
     }

package/dist/execution-routing.js

@@ -17,11 +17,35 @@ export function executionTaskShape(taskFacts = {}) {
             : 'Small/medium tasks favor ChatGPT when Browser Workspace capacity is available.',
     };
 }
+/** Explicit task capability tags override heuristic inference; legacy capabilities are additive. */
+export function taskCapabilityFacts(taskFacts) {
+    const task = taskFacts.task && typeof taskFacts.task === 'object' ? taskFacts.task : taskFacts;
+    const explicit = task.taskCapabilities ?? task.task_capabilities;
+    const legacy = task.capabilities;
+    const tags = [...(Array.isArray(explicit) ? explicit : []), ...(Array.isArray(legacy) ? legacy : [])]
+        .filter((item) => typeof item === 'string' && item.trim().length > 0);
+    if (Array.isArray(explicit) && explicit.length > 0)
+        return [...new Set(tags)];
+    const description = [task.input, task.title, task.description, task.role].filter(item => typeof item === 'string').join(' ').toLowerCase();
+    if (/image generation|generate (an? )?image|生成图片|图片生成|生图/.test(description))
+        tags.push('image_generation');
+    if (/final review|final approval review|最终审核|最终审查|终审/.test(description))
+        tags.push('final_review');
+    if (/visual review|image review|视觉审核|图片审核|画面审核/.test(description))
+        tags.push('visual_review');
+    if (/vision|image understanding|图像理解|图片理解|看图/.test(description))
+        tags.push('vision');
+    return [...new Set(tags)];
+}
+function workerCapabilityFacts(worker) {
+    const specializations = worker.adapter === 'chatgpt' ? ['vision', 'image_generation', 'visual_review', 'final_review'] : ['coding', 'cli', 'filesystem'];
+    return [...new Set([...worker.capabilities, ...specializations])];
+}
 export const EXECUTION_ROUTING_PRINCIPLES = [
     'Choose one complete executable route: worker plus provider/model/profile/reasoning.',
     'ChatGPT with MacBridge and Codex have broadly overlapping execution capabilities.',
     "Browser Workspace exhaustion is ChatGPT's primary hard execution constraint.",
-    'Codex is only the deterministic fallback when the decision engine fails.',
+    'Codex is the deterministic fallback when Jev fails; no second decision model is invoked.',
 ];
 function sameModelRoute(candidate, route) {
     return (!route.provider || candidate.provider === route.provider)
@@ -110,7 +134,7 @@ async function decideStage(engine, name, facts, question, choices) {
     const decision = await engine.decide({ facts }, contract);
     if (decision.type !== 'choice')
         throw new Error('Execution router expected a choice result for ' + name);
-    return { name, facts, contract, result: { choice: decision.choice, probabilities: decision.probabilities } };
+    return { name, facts, contract, result: { choice: decision.choice, probabilities: decision.probabilities, usage: decision.usage, latencyMs: decision.latencyMs, model: decision.model } };
 }
 function routeId(worker, model) {
     return worker.workerId + '::' + model.id + (model.reasoning ? '@' + model.reasoning : '');
@@ -265,10 +289,13 @@ export async function routeExecution(workers, requirements, options = {}) {
         source: isDefaultCandidate(route.model, discoveredDefaults.get(route.worker.workerId) ?? []) ? 'profile-default' : 'explicit-choice',
     }));
     const choiceLabels = routes.map((route, index) => executionChoiceLabel(route, effectiveChoices[index].default));
+    // Usage is keyed by worker/provider, not repeated for every route choice.
+    const usageByProvider = Object.fromEntries([...new Map(routes.map(route => [
+            route.worker.workerId + '::' + route.model.provider,
+            { worker: route.worker.workerId, provider: route.model.provider, ...codePlan(route.model) },
+        ])).entries()]);
     const facts = JSON.parse(JSON.stringify({
         context: {
-            job: taskFacts.job ?? null,
-            task: taskFacts.task ?? taskFacts,
             task_shape: {
                 story_size: taskShape.storySize,
                 sustained_work: taskShape.sustainedWork,
@@ -280,14 +307,19 @@ export async function routeExecution(workers, requirements, options = {}) {
                 reviewer_diversity: taskFacts.reviewer_diversity,
             } : null,
         },
+        task_capabilities: taskCapabilityFacts(taskFacts),
+        task_worker_capabilities: (() => {
+            const task = taskFacts.task && typeof taskFacts.task === 'object' ? taskFacts.task : taskFacts;
+            return Array.isArray(task.workerCapabilities) ? task.workerCapabilities : [];
+        })(),
+        worker_capabilities: Object.fromEntries(workers.map(worker => [worker.workerId, workerCapabilityFacts(worker)])),
+        usage_by_provider: usageByProvider,
         runtime: {
             chatgpt_running: chatgptRunning,
             preferred_chatgpt_concurrency: preferredChatgptConcurrency,
         },
-        worker_candidates: workerProviderFacts(routes),
-        effective_choices: effectiveChoices,
     }));
-    const question = appendRoutingInstruction('Choose one complete route from the merged choice list. Relay has already merged profile defaults with the user\'s explicit [choices] and applied every authoritative hard gate, so only these routes are legal. Do not invent, add, or substitute routes that are not listed.', routingInstruction);
+    const question = appendRoutingInstruction('User routing instructions have highest priority over default preferences, task size, runtime and resource signals. Candidate order is arbitrary and conveys no priority, ranking or preference. Do not favor earlier choices. Select an offered route that obeys the user instructions.\nUser routing instructions:\n' + routingInstruction, 'For vision, image generation, visual review, and final review tasks, prefer ChatGPT Worker when available and within capacity; for coding, CLI and filesystem tasks, prefer Codex. These are soft preferences subordinate to user rules. Choose exactly one listed route; do not invent routes.');
     let selected = fallback;
     let evidence = { mode: options.decisionMode ?? 'off', fallback: true };
     const decisionStages = [];
@@ -297,7 +329,7 @@ export async function routeExecution(workers, requirements, options = {}) {
             decisionStages.push(stage);
             const index = stage.result.choice ? choiceLabels.indexOf(stage.result.choice) : -1;
             if (index < 0)
-                throw new Error('Laya selected a route outside the merged choice list');
+                throw new Error('Decision engine selected a route outside the merged choice list');
             selected = routes[index];
             evidence = {
                 mode: options.decisionMode ?? 'active',

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/model-redecision.js

@@ -31,7 +31,7 @@ export async function redecideFailedTask(options) {
         rulesPath: options.rulesPath,
         auditStore: options.auditStore,
         auditTask: options.task,
-        taskFacts: { kind: options.task.kind ?? 'work', capabilities: options.task.capabilities, prior_routing: options.task.routing ?? null, fresh_usage_generated_at: usage.generatedAt },
+        taskFacts: { kind: options.task.kind ?? 'work', capabilities: options.task.capabilities, taskCapabilities: options.task.taskCapabilities, workerCapabilities: options.task.workerCapabilities, input: options.task.input, prior_routing: options.task.routing ?? null, fresh_usage_generated_at: usage.generatedAt },
         priorDecisionId: options.task.routing?.decisionId,
         priorFailure: options.evidence,
         excludedRoutes: options.task.routing ? [{ provider: options.task.routing.provider, model: options.task.routing.model, profile: options.task.routing.profile }] : [],