agents-relay 1.0.22 → 1.0.24

package/dist/cli.js

@@ -572,8 +572,8 @@ async function main() {
         task.id = arg(args, '--task-id', randomUUID());
         await store.appendTask(task);
         job.tasks.push(task);
-        if (job.state === 'COMPLETED') {
-            job.state = 'OPEN';
+        if (job.state !== 'RUNNING') {
+            job.state = 'RUNNING';
             job.updatedAt = now;
             await store.saveJob(job);
         }
@@ -597,6 +597,11 @@ async function main() {
         task.error = command === 'retry' ? null : 'Cancelled by user';
         task.updatedAt = new Date().toISOString();
         await store.saveTask(task);
+        if (command === 'retry' && job.state !== 'RUNNING') {
+            job.state = 'RUNNING';
+            job.updatedAt = task.updatedAt;
+            await store.saveJob(job);
+        }
         await saveLocal(localFile, job);
         await publishWake(bus, job, task.id, `${task.id} ${command} requested`);
         console.log(`${id}: ${task.state}`);

package/dist/planner.js

@@ -21,6 +21,30 @@ function stringArray(value, field, fallback = []) {
         throw new Error(`Planner ${field} must be an array of non-empty strings`);
     return [...value];
 }
+function rawValue(value) {
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    if (value === undefined)
+        return 'undefined';
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function normalizePlannerPriority(value, field) {
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 3)
+        return `P${value}`;
+    if (typeof value === 'string') {
+        const normalized = value.trim();
+        if (/^P[0-3]$/i.test(normalized))
+            return normalized.toUpperCase();
+        if (/^[0-3]$/.test(normalized))
+            return `P${normalized}`;
+    }
+    throw new Error(`Planner ${field} is invalid: ${rawValue(value)}`);
+}
 function routing(value, field) {
     if (value === undefined || value === null)
         return undefined;
@@ -58,8 +82,7 @@ export function parsePlannerResult(value) {
             throw new Error(`Planner next_tasks[${index}].output is required`);
         if (output.kind === 'file' && (typeof output.path !== 'string' || output.path.length === 0))
             throw new Error(`Planner next_tasks[${index}].output.path is required for file output`);
-        if (task.priority !== undefined && !['P0', 'P1', 'P2', 'P3'].includes(String(task.priority)))
-            throw new Error(`Planner next_tasks[${index}].priority is invalid`);
+        const priority = task.priority === undefined ? undefined : normalizePlannerPriority(task.priority, `next_tasks[${index}].priority`);
         const maxAttempts = task.maxAttempts === undefined ? 3 : task.maxAttempts;
         const timeoutMs = task.timeoutMs === undefined ? 300000 : task.timeoutMs;
         if (typeof maxAttempts !== 'number' || !Number.isInteger(maxAttempts) || maxAttempts < 1)
@@ -67,7 +90,7 @@ export function parsePlannerResult(value) {
         if (typeof timeoutMs !== 'number' || !Number.isFinite(timeoutMs) || timeoutMs < 0)
             throw new Error(`Planner next_tasks[${index}].timeoutMs is invalid`);
         return {
-            id, input: task.input, priority: task.priority,
+            id, input: task.input, priority,
             projectName: optionalString(task.projectName, 'projectName'), agentName: optionalString(task.agentName, 'agentName'),
             dependencies: stringArray(task.dependencies, 'dependencies'), capabilities: stringArray(task.capabilities, 'capabilities'),
             adapter: adapter, output: output, routing: routing(task.routing, `next_tasks[${index}].routing`),

package/dist/reconciler.js

@@ -59,7 +59,9 @@ export class Reconciler {
     live = new Map();
     plannerLive = new Map();
     terminalTimers = new Map();
+    terminalExitGraceTimers = new Map();
     continuationLive = new Set();
+    launchFailureClaims = new Set();
     terminalWaiters = new Map();
     reconciling = false;
     constructor(store, options) {
@@ -67,6 +69,10 @@ export class Reconciler {
         this.options = options;
     }
     async handleEvent(event) {
+        if (event.type === 'task.started') {
+            this.markWorkerStarted(event);
+            return;
+        }
         if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type)) {
             await this.applyTerminalEvent(event);
             return;
@@ -341,7 +347,7 @@ export class Reconciler {
         void (execution.launched ?? Promise.resolve()).then(() => this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.process.launched', 'running', `Task ${task.id} process launched`, 'user', { adapter: adapter.id, model: task.routing?.model }, { agent: 'relay', component: 'agents-relay' }))).catch(error => this.failLaunch(job.id, task.id, durableExecutionId, error instanceof Error ? error.message : String(error), 'launch'));
         if (startAckSetup)
             void startAckSetup.ack.finally(() => { void startAckSetup.stop(); }).catch(() => { });
-        this.live.set(task.id, { taskId: task.id, executionId: durableExecutionId, execution, controller });
+        this.live.set(task.id, { jobId: job.id, taskId: task.id, executionId: durableExecutionId, execution, controller, launchBarrier: Date.now(), workerStarted: false });
         const terminalTimer = setTimeout(() => {
             this.detach(this.timeoutTask(job.id, task.id, durableExecutionId), job.id, task.id, 'worker terminal-event timeout');
         }, Math.max(1, task.timeoutMs));
@@ -484,8 +490,30 @@ export class Reconciler {
         if (timer)
             clearTimeout(timer);
         this.terminalTimers.delete(taskId);
+        const graceTimer = this.terminalExitGraceTimers.get(taskId);
+        if (graceTimer)
+            clearTimeout(graceTimer);
+        this.terminalExitGraceTimers.delete(taskId);
+    }
+    markWorkerStarted(event) {
+        const live = this.live.get(event.task_id);
+        if (!live || event.job_id !== live.jobId)
+            return;
+        const sourceAgent = typeof event.source?.agent === 'string' ? event.source.agent : '';
+        const sourceComponent = typeof event.source?.component === 'string' ? event.source.component : '';
+        if (sourceAgent === 'relay' || sourceComponent === 'agents-relay')
+            return;
+        if (event.timestamp && new Date(event.timestamp).getTime() < live.launchBarrier)
+            return;
+        live.workerStarted = true;
     }
     async failLaunch(jobId, taskId, executionId, message, phase = 'launch') {
+        const claim = executionId ?? `${jobId}:${taskId}`;
+        if (this.launchFailureClaims.has(claim))
+            return;
+        this.launchFailureClaims.add(claim);
+        const cleanup = setTimeout(() => this.launchFailureClaims.delete(claim), 60000);
+        cleanup.unref();
         const job = await this.store.load(jobId);
         const task = job.tasks.find(item => item.id === taskId);
         if (!task || task.executionId !== executionId || task.state !== 'RUNNING')
@@ -496,13 +524,37 @@ export class Reconciler {
     }
     async runtimeSettled(jobId, taskId, executionId, result, error) {
         const live = this.live.get(taskId);
+        const workerStarted = live?.executionId === executionId && live.workerStarted;
         if (live?.executionId === executionId)
             this.live.delete(taskId);
         const job = await this.store.load(jobId);
         const task = job.tasks.find(item => item.id === taskId);
-        if (!task || task.executionId !== executionId || 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.state === 'RUNNING' && task.adapter === 'codex')
+            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) {
+        const job = await this.store.load(jobId);
+        const task = job.tasks.find(item => item.id === taskId);
+        if (!task || task.executionId !== executionId || task.state !== 'RUNNING')
+            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 event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', message, 'user', { reason, terminalGraceMs: this.options.terminalExitGraceMs ?? 1000 }, { agent: 'relay', component: 'agents-relay', watchdog: true });
+        await this.applyTerminalEvent(event);
+        await this.emit(event);
     }
     async timeoutTask(jobId, taskId, executionId) {
         const live = this.live.get(taskId);

package/dist/scheduler.js

@@ -31,7 +31,7 @@ export function schedule(job) {
     const waiting = job.tasks.some(t => ['QUEUED', 'WAITING'].includes(t.state));
     const failed = job.tasks.some(t => t.state === 'FAILED');
     const cancelled = job.tasks.every(t => t.state === 'CANCELLED');
-    const next = failed ? 'FAILED' : active ? 'RUNNING' : blocked ? 'BLOCKED' : waiting ? 'WAITING' : cancelled ? 'CANCELLED' : completionGateSatisfied(job) ? 'COMPLETED' : 'WAITING';
+    const next = active ? 'RUNNING' : failed ? 'FAILED' : blocked ? 'BLOCKED' : waiting ? 'WAITING' : cancelled ? 'CANCELLED' : completionGateSatisfied(job) ? 'COMPLETED' : 'WAITING';
     if (job.state !== next) {
         assertJobTransition(job.state, next);
         job.state = next;

package/package.json

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

package/skills/agents-relay/SKILL.md

@@ -47,6 +47,8 @@ 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`.
+
 ## Managed GitHub jobs
 
 For repository work, create/adopt/repair the PR-backed job through the Agents Relay CLI. Do not create the managed PR through a parallel raw GitHub path.

package/skills/agents-relay/agents/planner.agent.md

@@ -17,6 +17,7 @@ Inspect the durable objective and task tree, then decide whether the objective i
   - `{"kind":"file","path":"..."}`.
 - Include routing metadata for every model-backed child task.
 - Do not call an execution agent "codex"; agent identity describes responsibility, while the adapter describes runtime.
+- If a child task includes `priority`, emit the canonical string `P0`, `P1`, `P2`, or `P3` exactly. Do not emit numeric priorities, lowercase aliases, or labels such as `high`/`medium`/`low`.
 - Return no prose outside the JSON result.
 
 ## Output

package/skills/chatgpt-browser-worker/scripts/_submit_readiness.py

@@ -0,0 +1,30 @@
+"""Bounded polling helpers for ChatGPT submit readiness."""
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Mapping
+
+
+def wait_until_stable(
+    read_state: Callable[[], Mapping[str, object]],
+    ready: Callable[[Mapping[str, object]], bool],
+    *,
+    timeout: float,
+    interval: float = 0.25,
+    stable_samples: int = 2,
+    phase: str,
+) -> Mapping[str, object]:
+    """Return only after the observable state is ready for stable_samples polls."""
+    deadline = time.monotonic() + timeout
+    stable = 0
+    last_state: Mapping[str, object] = {}
+    while time.monotonic() < deadline:
+        last_state = read_state()
+        if ready(last_state):
+            stable += 1
+            if stable >= stable_samples:
+                return last_state
+        else:
+            stable = 0
+        time.sleep(interval)
+    raise RuntimeError(f"Temporary Chat {phase} was not observed ready")

package/skills/chatgpt-browser-worker/scripts/_temporary_bh.py

@@ -58,6 +58,21 @@ def _composer_text(selector):
     }})()""") or ""
 
 
+def _wait_for_composer(timeout=30):
+    def read_selector():
+        try:
+            return _composer()
+        except RuntimeError:
+            return None
+
+    return wait_until_stable(
+        lambda: {"selector": read_selector()},
+        lambda state: bool(state["selector"]),
+        timeout=timeout,
+        phase="composer readiness",
+    )["selector"]
+
+
 def _same_text(observed, expected):
     normalize = lambda value: re.sub(r"\\s+", " ", value or "").strip()
     return normalize(expected) in normalize(observed)
@@ -73,6 +88,38 @@ def _attachment_names():
       .filter(Boolean))()""") or []
 
 
+def _attachment_state():
+    return js(r"""(() => {
+      const names = [...document.querySelectorAll('button[aria-label^="Remove file"]')]
+        .map(b => (b.getAttribute('aria-label') || '').replace(/^Remove file\s+\d+:\s*/, ''))
+        .filter(Boolean);
+      const pending = [...document.querySelectorAll(
+        '[role="progressbar"], [aria-busy="true"], [data-state="loading"]'
+      )].some(e => {
+        const r=e.getBoundingClientRect();
+        return r.width > 0 && r.height > 0;
+      });
+      return {names, pending};
+    })()""") or {"names": [], "pending": True}
+
+
+def _send_state():
+    return js(r"""(() => {
+      const b=document.querySelector('button[data-testid="send-button"],button[aria-label="Send prompt"]');
+      return {present: !!b, enabled: !!b && !b.disabled && b.getAttribute('aria-disabled') !== 'true'};
+    })()""") or {"present": False, "enabled": False}
+
+
+def _wait_for_attachments(expected, timeout=45):
+    expected = set(expected)
+    wait_until_stable(
+        _attachment_state,
+        lambda state: expected.issubset(state["names"]) and not state["pending"],
+        timeout=timeout,
+        phase="attachment upload readiness",
+    )
+
+
 def _upload_files(paths):
     if not paths:
         return []
@@ -87,13 +134,17 @@ def _upload_files(paths):
         if not os.path.isfile(path):
             raise RuntimeError(f"attachment does not exist: {path}")
         upload_file(selector, path)
-        expected = os.path.basename(path)
-        deadline = time.time() + 20
-        while time.time() < deadline and expected not in _attachment_names():
-            time.sleep(.25)
-        if expected not in _attachment_names():
-            raise RuntimeError(f"attachment was not observed ready: {expected}")
-    return [os.path.basename(path) for path in paths]
+    expected = [os.path.basename(path) for path in paths]
+    if expected:
+        # Presence is a selection signal; upload readiness is checked separately.
+        wait_until_stable(
+            _attachment_state,
+            lambda state: set(expected).issubset(state["names"]),
+            timeout=30,
+            phase="attachment presence",
+        )
+        _wait_for_attachments(expected)
+    return expected
 
 
 def _user_turns():
@@ -109,17 +160,41 @@ def _click_send():
       b.click(); return true;
     })()""")
     if not ok:
-        raise RuntimeError("Temporary Chat Send prompt button was not observed ready")
+        raise RuntimeError("Temporary Chat send readiness changed before click")
+
+
+def _wait_for_send_ready(selector, prompt, attachments):
+    expected = set(attachments)
+
+    def read_state():
+        return {
+            "text": _composer_text(selector),
+            "attachments": _attachment_state(),
+            "send": _send_state(),
+        }
+
+    wait_until_stable(
+        read_state,
+        lambda state: (
+            _normalized_text(prompt) in _normalized_text(state["text"])
+            and expected.issubset(state["attachments"]["names"])
+            and not state["attachments"]["pending"]
+            and state["send"]["enabled"]
+        ),
+        timeout=45 if expected else 15,
+        phase="send readiness",
+    )
 
 
 def _wait_user_turn(before_count, prompt, timeout=20):
     deadline = time.time() + timeout
     while time.time() < deadline:
         turns = _user_turns()
-        if len(turns) > before_count and _normalized_text(prompt) in _normalized_text(turns[-1]["text"]):
-            return turns[-1]
+        for turn in turns[before_count:]:
+            if _normalized_text(prompt) in _normalized_text(turn["text"]):
+                return turn
         time.sleep(.25)
-    raise RuntimeError("Temporary Chat prompt did not become an observed user turn")
+    raise RuntimeError("Temporary Chat submission verification did not observe a new user turn")
 
 
 def _diagnostic_thread_id():
@@ -145,30 +220,59 @@ deadline = time.time() + 20
 while time.time() < deadline:
     if "temporary-chat=true" in page_info().get("url", ""):
         try:
-            _composer()
             break
         except RuntimeError:
             pass
     time.sleep(.25)
 else:
-    raise RuntimeError("Temporary Chat mode did not become ready")
+    raise RuntimeError("Temporary Chat composer readiness was not observed")
 
 attachments = _upload_files(CFG.get("file", []))
-selector = _composer()
+selector = _wait_for_composer()
 before_count = len(_user_turns())
-fill_input(selector, CFG["prompt"], clear_first=True)
-if not _same_text(_composer_text(selector), CFG["prompt"]):
-    info = js(f"""(() => {{
+prompt = CFG["prompt"]
+is_contenteditable = bool(js(f"""(() => {{
+  const e=document.querySelector({json.dumps(selector)});
+  return !!e && e.getAttribute('contenteditable') === 'true';
+}})()"""))
+if is_contenteditable:
+    cleared = js(f"""(() => {{
       const e=document.querySelector({json.dumps(selector)});
-      const r=e.getBoundingClientRect();
-      return {{x:r.x+r.width/2,y:r.y+r.height/2}};
+      if (!e) return false;
+      e.focus();
+      const sel=window.getSelection();
+      const range=document.createRange();
+      range.selectNodeContents(e);
+      sel.removeAllRanges();
+      sel.addRange(range);
+      document.execCommand('delete', false, null);
+      return true;
     }})()""")
-    click_at_xy(info["x"], info["y"])
-    press_key("CTRL+A")
-    type_text(CFG["prompt"])
-if _normalized_text(CFG["prompt"]) not in _normalized_text(_composer_text(selector)):
-    raise RuntimeError("Temporary Chat prompt was not observed in the composer")
+    if not cleared:
+        raise RuntimeError("Temporary Chat contenteditable composer could not be cleared")
+    for offset in range(0, len(prompt), 256):
+        chunk = prompt[offset:offset + 256]
+        inserted = js(f"""(() => {{
+          const e=document.querySelector({json.dumps(selector)});
+          if (!e) return false;
+          e.focus();
+          const ok=document.execCommand('insertText', false, {json.dumps(chunk)});
+          e.dispatchEvent(new InputEvent('input', {{bubbles:true,inputType:'insertText',data:{json.dumps(chunk)}}}));
+          return ok;
+        }})()""")
+        if not inserted:
+            raise RuntimeError(f"Temporary Chat composer rejected prompt chunk at offset {offset}")
+else:
+    fill_input(selector, prompt, clear_first=True)
+
+wait_until_stable(
+    lambda: {"text": _composer_text(selector)},
+    lambda state: _normalized_text(CFG["prompt"]) in _normalized_text(state["text"]),
+    timeout=30,
+    phase="composer readiness",
+)
 
+_wait_for_send_ready(selector, CFG["prompt"], attachments)
 _click_send()
 user_turn = _wait_user_turn(before_count, CFG["prompt"])
 

package/skills/chatgpt-browser-worker/scripts/temporary_bh.py

@@ -10,6 +10,7 @@ import tempfile
 
 
 BH_SCRIPT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_temporary_bh.py")
+READINESS_HELPER = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_submit_readiness.py")
 
 
 def main() -> int:
@@ -23,7 +24,9 @@ def main() -> int:
         json.dump(vars(args), handle, ensure_ascii=False)
         config_path = handle.name
     try:
-        code = open(BH_SCRIPT, encoding="utf-8").read().replace("__CFG_PATH__", config_path)
+        helper = open(READINESS_HELPER, encoding="utf-8").read()
+        code = helper + "\n" + open(BH_SCRIPT, encoding="utf-8").read()
+        code = code.replace("__CFG_PATH__", config_path)
         return subprocess.run(["browser-harness"], input=code, text=True, timeout=180).returncode
     finally:
         os.unlink(config_path)