agents-relay 1.0.124 → 1.0.126

package/dist/cli-help.js

@@ -1,4 +1,4 @@
-export const usage = 'agents-relay <job|task|blocker|context|init|record|agent-register|agent-discover|reconcile|tick|serve> [options]';
+export const usage = 'agents-relay <job|task|blocker|context|init|record|agent-register|agent-discover|status|reconcile|tick|serve> [options]';
 const help = {
     root: `Agents Relay coordinates durable asynchronous agent jobs through GitHub pull requests.
 
@@ -14,6 +14,7 @@ Commands:
   record                   Backfill a completed task into durable history
   agent-register           Register an agent role and its capabilities
   agent-discover           Find registered agents matching hard filters
+  status                   Show live aggregate runtime status from agents-relayd
   reconcile                Run reconciliation once
   tick                     Run the indexed autonomous scheduler heartbeat
   serve                    Run the dashboard and reconciliation service
@@ -75,6 +76,12 @@ Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID. The current PR head S
     'job cancel': `Cancel the durable Job and close its backing pull request.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID. Nonterminal Tasks are cancelled before the PR is closed.`,
+    status: `Show live aggregate runtime status from the running Agents Relay service.
+
+Usage:
+  npx agents-relay status [--host HOST] [--port PORT]
+
+Returns the same summary used by the dashboard header plus a running array with concrete RUNNING task and execution identities. Defaults to 127.0.0.1:8787.`,
     task: `Manage durable tasks.
 
 Usage:

package/dist/cli.js

@@ -601,6 +601,23 @@ async function main() {
         return;
     }
     const bus = eventBus(args);
+    if (command === 'status') {
+        const host = arg(args, '--host', '127.0.0.1');
+        const port = Number(arg(args, '--port', String(SERVICE_DEFAULTS.port)));
+        if (!Number.isInteger(port) || port <= 0 || port > 65535)
+            throw new Error('--port must be an integer between 1 and 65535');
+        let response;
+        try {
+            response = await fetch(`http://${host}:${port}/api/runtime-summary`);
+        }
+        catch (error) {
+            throw new Error(`Agents Relay service unavailable at ${host}:${port}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!response.ok)
+            throw new Error(`Agents Relay status request failed: HTTP ${response.status}`);
+        console.log(JSON.stringify(await response.json(), null, 2));
+        return;
+    }
     if (command === 'tick') {
         const repo = repository(args);
         const auth = await githubAuthContext(args);
@@ -649,10 +666,6 @@ async function main() {
         console.log(`Recorded ${id}`);
         return;
     }
-    if (command === 'status') {
-        console.log(JSON.stringify(await store.load(job.id), null, 2));
-        return;
-    }
     if (command === 'reconcile' && !localFile) {
         try {
             await requestManagedReconciliation(bus, job);

package/dist/dashboard.js

@@ -352,8 +352,15 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             return;
         }
         if (req.url === '/api/runtime-summary') {
-            res.writeHead(200, { 'content-type': 'application/json' });
-            res.end(JSON.stringify(summarizeRuntime(lastKnownJobs ?? [])));
+            try {
+                const jobs = await discoveredJobs();
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify(summarizeRuntime(jobs)));
+            }
+            catch (error) {
+                res.writeHead(502);
+                res.end(error instanceof Error ? error.message : String(error));
+            }
             return;
         }
         if (req.url === '/api/status') {

package/dist/reconciler-review.js

@@ -1,6 +1,6 @@
 import { storySizeTimeoutMs, taskOverallTimeoutMs } from './types.js';
 import { schedule, transitionTaskEvent, transitionJobEvent } from './scheduler.js';
-import { implementationComplete } from './runtime-status.js';
+import { implementationComplete, implementationTasks } from './runtime-status.js';
 import { eventFor } from './events.js';
 import { selectReviewer } from './reviewer-routing.js';
 import { routeWorker, workerCandidates } from './worker-routing.js';
@@ -26,8 +26,6 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
     async ensureFinalReview(job, prState, headSha) {
         if (job.schedule || job.reviewEnabled === false || prState !== 'OPEN' || job.state !== 'ACTIVE' || !implementationComplete(job) || !headSha)
             return;
-        if (!this.preReviewGatesPass(job))
-            return;
         const review = job.review;
         if (review?.headSha === headSha && ['started', 'approved', 'changes_required', 'blocked'].includes(review.outcome))
             return;
@@ -38,9 +36,9 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             return;
         const id = `final-review-${headSha.slice(0, 12)}`;
         const now = new Date().toISOString();
-        const implementationTasks = job.tasks.filter(item => item.agentName !== 'reviewer' && !this.isSupersededTask(item));
-        const reviewerRouting = await this.selectReviewer(implementationTasks);
-        const task = { jobId: job.id, id, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'reviewer', parentTaskId: null, dependencies: implementationTasks.map(item => item.id), capabilities: ['review'], workerSelection: reviewerRouting.selection, adapter: reviewerRouting.candidate.adapter, input: `Review existing PR #${job.prNumber} at exactly head SHA ${headSha}. Job objective: ${job.objective ?? job.description ?? job.title}. Use the selected reviewer agent contract as the authoritative review protocol.`, output: { kind: 'task_pr' }, routing: reviewerRouting.candidate.routing, continuation: null, continuationDeliveredAt: null, reviewHeadSha: headSha, state: 'QUEUED', attempt: 0, maxAttempts: this.options.reviewer?.maxAttempts ?? 2, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: this.options.reviewer?.timeoutMs ?? storySizeTimeoutMs('M'), createdAt: now, updatedAt: now };
+        const reviewGateTasks = implementationTasks(job);
+        const reviewerRouting = await this.selectReviewer(reviewGateTasks);
+        const task = { jobId: job.id, id, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'reviewer', parentTaskId: null, dependencies: reviewGateTasks.map(item => item.id), capabilities: ['review'], workerSelection: reviewerRouting.selection, adapter: reviewerRouting.candidate.adapter, input: `Review existing PR #${job.prNumber} at exactly head SHA ${headSha}. Job objective: ${job.objective ?? job.description ?? job.title}. Use the selected reviewer agent contract as the authoritative review protocol.`, output: { kind: 'task_pr' }, routing: reviewerRouting.candidate.routing, continuation: null, continuationDeliveredAt: null, reviewHeadSha: headSha, state: 'QUEUED', attempt: 0, maxAttempts: this.options.reviewer?.maxAttempts ?? 2, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: this.options.reviewer?.timeoutMs ?? storySizeTimeoutMs('M'), createdAt: now, updatedAt: now };
         await this.store.appendTask(task);
         job.review = { outcome: 'pending', headSha, taskId: id, evidence: null, updatedAt: now };
         job.updatedAt = now;
@@ -145,12 +143,6 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'model.selected', 'queued', `Selected ${task.routing.model} · thinking ${task.routing.reasoning ?? 'unknown'}`, 'user', { routing: task.routing }, { agent: 'relay', component: 'agents-relay' }));
         }
     }
-    isSupersededTask(task) {
-        return task.state === 'CANCELLED' && typeof task.error === 'string' && task.error.startsWith('Superseded ');
-    }
-    preReviewGatesPass(job) {
-        return job.tasks.filter(task => task.agentName !== 'reviewer' && !this.isSupersededTask(task)).every(task => task.state === 'SUCCEEDED');
-    }
     async applyReviewEvent(event) {
         const job = await this.store.load(event.job_id);
         const task = job.tasks.find(item => item.id === event.task_id && item.agentName === 'reviewer');

package/dist/reconciler-runtime.js

@@ -22,7 +22,6 @@ export class ReconcilerRuntimeBase {
     live = new Map();
     plannerLive = new Map();
     terminalTimers = new Map();
-    terminalExitGraceTimers = new Map();
     continuationLive = new Set();
     launchFailureClaims = new Set();
     terminalWaiters = new Map();
@@ -108,9 +107,6 @@ export class ReconcilerRuntimeBase {
         for (const timer of this.terminalTimers.values())
             clearTimeout(timer);
         this.terminalTimers.clear();
-        for (const timer of this.terminalExitGraceTimers.values())
-            clearTimeout(timer);
-        this.terminalExitGraceTimers.clear();
         for (const planner of this.plannerLive.values()) {
             clearTimeout(planner.timer);
             planner.controller.abort();
@@ -171,10 +167,6 @@ export class ReconcilerRuntimeBase {
         if (timer)
             clearTimeout(timer);
         this.terminalTimers.delete(taskId);
-        const graceTimer = this.terminalExitGraceTimers.get(taskId);
-        if (graceTimer)
-            clearTimeout(graceTimer);
-        this.terminalExitGraceTimers.delete(taskId);
     }
     async markWorkerStarted(event) {
         const live = this.live.get(event.task_id);
@@ -245,53 +237,13 @@ export class ReconcilerRuntimeBase {
     }
     async runtimeSettled(jobId, taskId, executionId, result, error) {
         const live = this.live.get(taskId);
-        const liveWorkerStarted = live?.executionId === executionId && live.workerStarted;
         if (live?.executionId === executionId)
             live.processSettled = true;
         const job = await this.store.load(jobId);
         const task = job.tasks.find(item => item.id === taskId);
-        const workerStarted = liveWorkerStarted || task?.state === 'RUNNING';
         if (!task || task.executionId !== executionId)
             return;
         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' }));
-        if (task.adapter === 'codex' && !terminalExecutionClaimed(jobId, taskId, executionId))
-            this.scheduleUnexpectedExit(jobId, taskId, executionId, workerStarted === true);
-    }
-    scheduleUnexpectedExit(jobId, taskId, executionId, workerStarted) {
-        const graceMs = Math.max(1, this.options.terminalExitGraceMs ?? 1000);
-        const timer = setTimeout(() => {
-            this.terminalExitGraceTimers.delete(taskId);
-            this.detach(this.failUnexpectedExit(jobId, taskId, executionId, workerStarted), jobId, taskId, 'unexpected worker process exit');
-        }, graceMs);
-        this.terminalExitGraceTimers.set(taskId, timer);
-    }
-    async failUnexpectedExit(jobId, taskId, executionId, workerStarted) {
-        if (terminalExecutionClaimed(jobId, taskId, executionId))
-            return;
-        const current = await this.store.load(jobId);
-        const currentTask = current.tasks.find(item => item.id === taskId);
-        if (!currentTask || currentTask.executionId !== executionId || ['SUCCEEDED', 'FAILED', 'BLOCKED', 'CANCELLED'].includes(currentTask.state)) {
-            this.clearExecution(taskId, executionId);
-            return;
-        }
-        const reason = workerStarted ? 'worker_exit_without_terminal_event' : 'worker_exit_before_start';
-        const message = workerStarted
-            ? `Worker ${taskId} exited after task.started without publishing a terminal task event`
-            : `Worker ${taskId} exited before publishing task.started`;
-        const transition = await this.taskTransitions.apply(jobId, taskId, 'watchdog.failed', {
-            eligible: (_job, task) => task.executionId === executionId && !terminalExecutionClaimed(jobId, taskId, executionId),
-            mutate: (_job, task) => {
-                this.clearExecution(task.id, executionId);
-                task.error = message;
-                task.failureReason = reason;
-                task.leaseOwner = null;
-                task.leaseExpiresAt = null;
-            },
-        });
-        if (!transition?.decision.accepted)
-            return;
-        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', message, 'user', { reason, terminalGraceMs: this.options.terminalExitGraceMs ?? 1000, workflowEvent: 'watchdog.failed' }, { agent: 'relay', component: 'agents-relay', watchdog: true });
-        this.detach(this.emit(event), jobId, taskId, 'watchdog failure event');
     }
     async timeoutTask(jobId, taskId, executionId) {
         const live = this.live.get(taskId);

package/dist/runtime-status.js

@@ -2,7 +2,7 @@ function isSuperseded(task) {
     return task.state === 'CANCELLED' && typeof task.error === 'string' && task.error.startsWith('Superseded ');
 }
 export function implementationTasks(job) {
-    return job.tasks.filter(task => task.agentName !== 'reviewer' && !isSuperseded(task));
+    return job.tasks.filter(task => task.agentName !== 'reviewer' && task.agentName !== 'troubleshooter' && !isSuperseded(task));
 }
 export function implementationComplete(job) {
     const tasks = implementationTasks(job);

package/dist/runtime-summary.js

@@ -10,6 +10,7 @@ export function summarizeRuntime(jobs) {
     let chatgpt = 0;
     let codex = 0;
     const models = new Map();
+    const running = [];
     for (const job of jobs) {
         if (job.state === 'ACTIVE')
             activeJobs += 1;
@@ -25,6 +26,19 @@ export function summarizeRuntime(jobs) {
             const model = task.routing?.model;
             if (model)
                 models.set(model, (models.get(model) ?? 0) + 1);
+            running.push({
+                repository: job.repository,
+                prNumber: job.prNumber,
+                jobId: job.id,
+                jobTitle: job.title,
+                taskId: task.id,
+                agentName: task.agentName ?? null,
+                worker: task.workerSelection?.adapter ?? task.adapter,
+                provider: task.routing?.provider ?? null,
+                model: model ?? null,
+                executionId: task.executionId,
+                leaseExpiresAt: task.leaseExpiresAt,
+            });
         }
     }
     return {
@@ -34,5 +48,6 @@ export function summarizeRuntime(jobs) {
         models: [...models.entries()]
             .map(([model, count]) => ({ model, count }))
             .sort((left, right) => right.count - left.count || left.model.localeCompare(right.model)),
+        running,
     };
 }

package/package.json

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

package/skills/agents-relay/SKILL.md

@@ -51,7 +51,7 @@ Agents Relay maps those terminal events to durable state:
 
 A model-backed task must not launch without an event bus. If no terminal event arrives before the task timeout, Relay records an explicit timeout failure. A Codex process exit or ChatGPT submission receipt alone never changes the task to a terminal state.
 
-For Codex, an unexpected process exit after the worker's `task.started` is given only a short bounded terminal grace window. If no exact correlated worker terminal event arrives in that window, Relay records `task.failed` with `worker_exit_without_terminal_event` as an explicit lifecycle-contract failure. This watchdog failure is still distinct from `task.process.exited`; it never treats process exit as task success and never duplicates an already-applied terminal event. An exit before `task.started` is likewise recorded as `worker_exit_before_start`.
+Worker process exit is observational only. Relay does not perform an exit-time terminal check or synthesize task failure from process exit; semantic terminal state comes from the worker event contract or the normal task timeout.
 
 ## Managed GitHub jobs