agents-relay 2.0.58 → 2.0.60

package/dist/relayd.js

@@ -17,15 +17,17 @@ import { eventBusResolutionMessage, publishOrchestratorTaskStarted, publishOrche
 import { eventFor } from './events.js';
 import { applyJobActivateAction } from './job-actions.js';
 import { applyOrchestratorStartAction, applyOrchestratorCompleteAction } from './task-actions.js';
+import { managedTaskUpdateHandler } from './task-update.js';
 import { dashboardJobSetState, dashboardTaskAction, dashboardTaskSetState } from './dashboard-actions.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
 import { defaultWorkspaceRoot, discoverWorkspaceRepositories, resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
 import { deriveJobRuntimeStatus } from './runtime-status.js';
-import { decisionMode, LayaCliDecisionEngine } from './decision.js';
+import { decisionMode, executionDecisionEngine } from './decision.js';
 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. */
@@ -196,7 +198,7 @@ export async function runDaemon(argv) {
             job, githubState: snapshot.facts.state, draft: false, mergedAt: null, closedAt: null, publication: null,
         }));
     }));
-    const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), usageSnapshotProvider: () => usageRegistry.snapshot(), runtimeSummaryProvider: () => ({ chatgptRunning: summarizeRuntime(cachedOverviews.map(item => item.job)).workers.chatgpt }), decisionEngine: new LayaCliDecisionEngine(), decisionMode: decisionMode(), decisionAuditStore, eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: async (job) => resolveRepositoryProjectPath(repositoryPaths.get(job.repository) ?? await resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot), job.projectPath) });
+    const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), usageSnapshotProvider: () => usageRegistry.snapshot(), runtimeSummaryProvider: () => ({ chatgptRunning: summarizeRuntime(cachedOverviews.map(item => item.job)).workers.chatgpt }), decisionEngine: executionDecisionEngine(), decisionMode: decisionMode(), decisionAuditStore, eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: async (job) => resolveRepositoryProjectPath(repositoryPaths.get(job.repository) ?? await resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot), job.projectPath) });
     const refreshAll = async (full = false) => {
         if (client.rateLimitStatus().limited)
             return cachedOverviews;
@@ -403,6 +405,8 @@ export async function runDaemon(argv) {
         cancel: workspaceJobAction('cancel'),
         jobSetState: workspaceJobSetState,
         taskCreate: workspaceTaskCreate,
+        taskUpdate: managedTaskUpdateHandler(jobId => { const row = cachedOverviews.find(item => item.job.id === jobId); if (!row)
+            throw new Error('Job not found'); return { store: runtimeStore(row.job.repository, row.job.prNumber), repository: row.job.repository, prNumber: row.job.prNumber }; }, (repository, prNumber, jobId) => pool.reconcileTarget(repository, prNumber, jobId, 'control.task.update')),
         taskStart: workspaceTaskStart,
         taskRetry: workspaceTaskAction('retry'),
         taskCancel: workspaceTaskAction('cancel'),
@@ -423,7 +427,7 @@ export async function runDaemon(argv) {
             { name: 'chatgpt', id: 'chatgpt/browser-worker', capabilities: ['model', 'chatgpt', 'browser-workspace'] },
         ], [], usage);
         const result = await routeExecution(workers, task.workerRequirements ?? { capabilities: task.capabilities ?? [] }, {
-            decisionEngine: new LayaCliDecisionEngine(),
+            decisionEngine: executionDecisionEngine(),
             decisionMode: 'active',
             taskFacts: {
                 job: {
@@ -436,7 +440,7 @@ export async function runDaemon(argv) {
                     id: task.id, kind: task.kind ?? 'work', storySize: task.storySize ?? 'M',
                     priority: task.priority ?? null, agentName: task.agentName ?? null,
                     parentTaskId: task.parentTaskId, dependencies: task.dependencies,
-                    capabilities: task.capabilities, input: task.input,
+                    capabilities: task.capabilities, taskCapabilities: task.taskCapabilities, workerCapabilities: task.workerCapabilities, input: task.input,
                     attachments: task.attachments ?? [], output: task.output ?? null,
                     state: task.state, attempt: task.attempt, maxAttempts: task.maxAttempts,
                 },
@@ -508,7 +512,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/task-update.js

@@ -0,0 +1,52 @@
+import { applyTaskHoldAction, applyTaskQueueAction } from './task-actions.js';
+const editableFields = [
+    'priority', 'storySize', 'projectName', 'agentName', 'agentGraph',
+    'parentTaskId', 'dependencies', 'capabilities', 'workerRequirements',
+    'adapter', 'chatgptTabClosePolicy', 'input', 'attachments',
+    'routing', 'timeoutMs', 'maxAttempts',
+];
+/** All managed CLI Task updates commit through the daemon's operational store. */
+export async function applyManagedTaskUpdate(store, jobId, taskId, proposed, expectedUpdatedAt) {
+    const job = await store.load(jobId);
+    const current = job.tasks.find(item => item.id === taskId);
+    if (!current || proposed.id !== taskId || proposed.jobId !== jobId)
+        throw new Error('Task update identity mismatch');
+    if (current.updatedAt !== expectedUpdatedAt)
+        throw new Error('Task changed since update preflight; refresh and retry');
+    if (['RUNNING', 'UNBLOCKED', 'SUCCEEDED', 'CANCELLED'].includes(current.state) || current.executionId || current.leaseOwner)
+        throw new Error('Task is not mutable while active or terminal');
+    if (current.attempt > 0 && current.adapter !== proposed.adapter)
+        throw new Error('Cannot replace adapter after an execution attempt');
+    if (proposed.maxAttempts < current.attempt)
+        throw new Error('Retry budget is below execution attempts');
+    const next = structuredClone(current);
+    for (const key of editableFields) {
+        if (Object.hasOwn(proposed, key))
+            next[key] = structuredClone(proposed[key]);
+        else
+            delete next[key];
+    }
+    if (next.dependencies.includes(taskId))
+        throw new Error('Task cannot depend on itself');
+    if (proposed.state !== current.state) {
+        if (proposed.state === 'DRAFT' && current.state === 'QUEUED')
+            await applyTaskHoldAction(next);
+        else if (proposed.state === 'QUEUED')
+            await applyTaskQueueAction(job, next);
+        else
+            throw new Error('Task state change requires a dedicated lifecycle action');
+    }
+    if (next.adapter !== current.adapter || JSON.stringify(next.routing) !== JSON.stringify(current.routing))
+        next.workerSelection = undefined;
+    next.updatedAt = new Date().toISOString();
+    await store.saveTask(next);
+    return store.load(jobId);
+}
+export function managedTaskUpdateHandler(locate, wake) {
+    return async (jobId, taskId, task, expectedUpdatedAt) => {
+        const target = locate(jobId);
+        const updated = await applyManagedTaskUpdate(target.store, jobId, taskId, task, expectedUpdatedAt);
+        await wake(target.repository, target.prNumber, jobId);
+        return updated;
+    };
+}

package/dist/terminal-event-watchdog.js

@@ -0,0 +1,11 @@
+/**
+ * Replace the overall worker deadline with a shorter post-exit deadline.
+ * Execution outcomes remain owned by the authoritative task lifecycle graph.
+ * Never extend the original overall timeout.
+ */
+export function rearmTerminalEventDeadline(timers, taskId, overallRemainingMs, graceMs, expire) {
+    const existing = timers.get(taskId);
+    if (existing)
+        clearTimeout(existing);
+    timers.set(taskId, setTimeout(expire, Math.max(1, Math.min(overallRemainingMs, graceMs))));
+}

package/dist/usage.js

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

package/dist/workspace.js

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

package/package.json

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

package/workflow/task-lifecycle.mmd

@@ -120,6 +120,7 @@ queued -->|on: worker.delivery_failed| failed
 queued -->|on: worker.start_ack_failed| failed
 queued -->|on: planner.unavailable| plannerUnavailableMark
 plannerUnavailableMark --> failed
+queued -->|on: execution.orphaned| orphanRetryAvailable
 queued -->|on: lease.expired| retryAvailableQueued
 retryAvailableQueued -->|true| leaseRetryQueuedClearError
 leaseRetryQueuedClearError --> leaseRetryQueuedClearLease