agents-relay 1.0.6 → 1.0.8

package/README.md

@@ -93,7 +93,7 @@ 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 enriches the prompt with the PR URL, job/task identity, output contract, and mandatory terminal-event contract.
 
-For Codex and ChatGPT, **events are authoritative task state**. A process exit or browser submission receipt does not complete a task. The executing agent must publish exactly one correlated `task.completed`, `task.failed`, or `task.blocked` 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, **events are authoritative task state**. 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 only subscribes and reconciles. A process exit or browser submission receipt does not complete a task. The executing agent must publish exactly one correlated `task.completed`, `task.failed`, or `task.blocked` 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 the packaged `chatgpt-browser-worker` as a one-shot submitter. It opens a fresh Temporary Chat tab, uses the account defaults, submits the prompt, verifies acceptance, closes the owned tab, and returns. It 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.
 

package/dist/cli.js

@@ -211,7 +211,7 @@ async function storeFor(args) { const repo = arg(args, '--repo'); const pr = arg
 async function saveLocal(file, job) { if (file)
     await writeFile(file, JSON.stringify(job, null, 2)); }
 export function eventBus(args) { if (arg(args, '--events') !== 'nats')
-    return undefined; return new NatsEventBus(arg(args, '--nats-url', 'nats://127.0.0.1:4222'), arg(args, '--subject-prefix', 'agents-relay.events.job')); }
+    return undefined; return new NatsEventBus(arg(args, '--nats-url', 'nats://127.0.0.1:4222'), arg(args, '--subject-prefix', 'neo.events.job')); }
 async function publishWake(bus, job, taskId, message) { if (!bus)
     return; try {
     await bus.publish(eventFor(job.id, taskId, null, 'job.wake', 'queued', message, 'orchestrator', { repository: job.repository, prNumber: job.prNumber }));

package/dist/events.js

@@ -13,7 +13,7 @@ export class NatsEventBus {
     subjectPrefix;
     connection = null;
     module = null;
-    constructor(url = 'nats://127.0.0.1:4222', subjectPrefix = 'agents-relay.events.job') {
+    constructor(url = 'nats://127.0.0.1:4222', subjectPrefix = 'neo.events.job') {
         this.url = url;
         this.subjectPrefix = subjectPrefix;
         if (!/^[A-Za-z0-9_.-]+$/.test(subjectPrefix))
@@ -24,13 +24,31 @@ export class NatsEventBus {
     async publish(event) { const nats = await this.moduleLoaded(); const subject = `${this.subjectPrefix}.${subjectToken(event.job_id)}.${event.type}`; (await this.client()).publish(subject, nats.StringCodec().encode(JSON.stringify(event))); }
     async subscribe(jobId, wake) { return this.subscribeSubject(`${this.subjectPrefix}.${subjectToken(jobId)}.>`, wake); }
     async subscribeAll(wake) { return this.subscribeSubject(`${this.subjectPrefix}.>`, wake); }
-    async subscribeSubject(subject, wake) { const nats = await this.moduleLoaded(); const codec = nats.StringCodec(); const subscription = (await this.client()).subscribe(subject); let active = true; void (async () => { for await (const message of subscription) {
-        if (!active)
-            break;
-        try {
-            await wake(JSON.parse(codec.decode(message.data)));
-        }
-        catch { /* malformed events never become durable state */ }
-    } })(); return async () => { active = false; subscription.unsubscribe(); }; }
+    async subscribeSubject(subject, wake) {
+        const nats = await this.moduleLoaded();
+        const codec = nats.StringCodec();
+        const subscription = (await this.client()).subscribe(subject);
+        let active = true;
+        void (async () => {
+            for await (const message of subscription) {
+                if (!active)
+                    break;
+                let event;
+                try {
+                    event = JSON.parse(codec.decode(message.data));
+                }
+                catch {
+                    continue;
+                }
+                try {
+                    await wake(event);
+                }
+                catch (error) {
+                    process.stderr.write(`warning: event handler failed for ${subject}: ${error instanceof Error ? error.message : String(error)}\n`);
+                }
+            }
+        })();
+        return async () => { active = false; subscription.unsubscribe(); };
+    }
 }
 export function eventFor(jobId, taskId, parentTaskId, type, status, message, visibility = 'orchestrator', data) { return { version: 1, event_id: randomUUID(), job_id: jobId, task_id: taskId, parent_task_id: parentTaskId, type, status, timestamp: new Date().toISOString(), visibility, level: status === 'failed' || status === 'blocked' ? 'error' : 'info', message, data }; }

package/dist/reconciler.js

@@ -26,7 +26,11 @@ ${task.input}
 ${output}
 
 [Execution event contract]
-Use the normal events bus with exactly Job ${job.id} and Task ${task.id}.
+Use the canonical Neo events-bus with exactly Job ${job.id} and Task ${task.id}.
+Follow the events-bus skill/protocol. For sandboxed Codex or hosted ChatGPT,
+publish through the federated MCP tool events__publish; do not open NATS directly.
+For a direct non-sandbox local worker, use NEO_EVENTS_EMIT when the caller provides it.
+
 You MAY publish progress events while working.
 Before stopping, you MUST publish exactly one terminal event:
 - task.completed only after the declared output is durable;

package/dist/relayd.js

@@ -63,7 +63,7 @@ export async function runDaemon(argv) {
     const client = auth.client;
     const trusted = auth.trustedAuthors;
     const concurrency = Number(value(argv, '--concurrency', '4'));
-    const bus = value(argv, '--events') === 'nats' ? new NatsEventBus(value(argv, '--nats-url', 'nats://127.0.0.1:4222'), value(argv, '--subject-prefix', 'agents-relay.events.job')) : undefined;
+    const bus = value(argv, '--events') === 'nats' ? new NatsEventBus(value(argv, '--nats-url', 'nats://127.0.0.1:4222'), value(argv, '--subject-prefix', 'neo.events.job')) : undefined;
     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), eventBus: bus });
     const repositories = normalized.repository
         ? [normalized.repository]

package/package.json

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

package/skills/agents-relay/SKILL.md

@@ -31,11 +31,13 @@ Events are authoritative for model-backed task state.
 
 Agents Relay may launch a Codex process or submit a one-shot ChatGPT browser task, but runtime/process completion is only delivery/runtime evidence. It never means the task completed.
 
-A running agent MUST publish exactly one correlated terminal event before stopping:
+A running agent MUST use the canonical Neo `events-bus` protocol and publish exactly one correlated terminal event before stopping:
 - `task.completed` after the declared output is durable;
 - `task.failed` when the task cannot complete;
 - `task.blocked` when external or human action is required.
 
+Event publishing is not an Agents Relay CLI responsibility. Sandboxed Codex and hosted ChatGPT workers use the federated `events__publish` MCP tool from `events-bus`; direct non-sandbox local workers may use the caller-provided `NEO_EVENTS_EMIT`. Agents Relay subscribes to the canonical `neo.events.job.<job_id>.>` stream and maps terminal events into durable task state.
+
 The event must carry the exact durable `job_id` and `task_id`. Progress events are optional.
 
 Agents Relay maps those terminal events to durable state: