agents-relay 1.0.16 → 1.0.17

package/README.md

@@ -10,6 +10,11 @@ For GitHub-backed work, create or adopt the PR through Agents Relay itself. This
 npx agents-relay job create --repo OWNER/REPO --head feat/example --base main \
   --id job-1 --title "Objective" --body "PR description" --mode fixed
 
+# Create/reuse the managed job and submit its initial task atomically
+npx agents-relay job create --repo OWNER/REPO --head feat/example --base main \
+  --id job-1 --start --task-id initial --adapter codex --provider openai \
+  --model MODEL --output task-pr --input "Implement the objective and publish a terminal event."
+
 npx agents-relay submit --repo OWNER/REPO --pr 12 --id job-1 \
   --task-id child --adapter codex --provider openai --model MODEL --output task-pr \
   --input "Implement the described child task and publish a terminal event."
@@ -35,6 +40,7 @@ Planner-created tasks use stable IDs and the existing parent/subtask tree, so
 retries and daemon restarts do not create duplicate work.
 
 job create first resolves an existing open PR with the same head/base, then creates it only when needed. Re-running it is idempotent: it reuses the PR and maintains exactly one trusted agents-relay:job:v1 marker.
+Use `--start` to create/reuse the job and submit its initial task in one invocation. Start mode requires explicit `--adapter`, `--model`, `--output`, and non-empty `--input`; the task ID defaults to `initial`. Re-running with the same task definition reuses that task and never duplicates it. Omitting `--start` preserves create-only behavior, leaving an `OPEN` job with zero tasks until a caller submits work.
 
 To adopt an existing unmanaged PR, including a PR with no comments:
 
@@ -93,7 +99,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**. 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.
+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. Relay publishes `task.process.launched` only after successful adapter launch; `task.started` is worker-owned and must be a new, correlated start acknowledgement. Codex publishes `task.process.exited` when its synchronous runtime exits, while ChatGPT publishes `task.process.async_exited` after its submission runtime exits; neither substitutes for `task.completed`, `task.failed`, or `task.blocked`. The ChatGPT worker-owned tab remains open until the correlated worker start acknowledgement arrives, or is closed and failed with `worker_start_timeout` after 60 seconds. The executing agent must publish exactly one correlated terminal 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/adapters.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { access, readFile } from 'node:fs/promises';
+import { access, readFile, writeFile, unlink } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -42,7 +42,7 @@ export class CodexAdapter {
     constructor(command = 'codex') {
         this.command = command;
     }
-    launch(task, signal) {
+    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), {
@@ -53,6 +53,10 @@ export class CodexAdapter {
         let stdoutBuffer = '';
         let stderrTail = '';
         let bufferedThreadId;
+        let launchedResolve;
+        let launchedReject;
+        const launched = new Promise((resolve, reject) => { launchedResolve = resolve; launchedReject = reject; });
+        launched.catch(() => { });
         let execution;
         const consumeLine = (line) => {
             const threadId = parseThreadStarted(line);
@@ -75,7 +79,8 @@ export class CodexAdapter {
             stderrTail = appendTail(stderrTail, chunk.toString());
         });
         const promise = new Promise((resolve, reject) => {
-            child.on('error', reject);
+            child.on('error', error => { launchedReject(error); reject(error); });
+            child.once('spawn', launchedResolve);
             child.on('close', code => {
                 if (stdoutBuffer)
                     consumeLine(stdoutBuffer);
@@ -88,13 +93,15 @@ export class CodexAdapter {
             });
             signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
         });
-        execution = { id: randomUUID(), promise, cancel: () => child.kill('SIGTERM') };
+        execution = { id: randomUUID(), promise, launched, cancel: () => child.kill('SIGTERM') };
         execution.threadId = bufferedThreadId;
         return execution;
     }
 }
 export class LaunchFailure extends Error {
 }
+export class StartAckTimeout extends LaunchFailure {
+}
 function browserWorkerCandidates(explicit) {
     const roots = (process.env.AGENTS_RELAY_SKILL_ROOTS ?? '').split(':').filter(Boolean);
     const packageSkills = join(dirname(fileURLToPath(import.meta.url)), '..', 'skills');
@@ -140,14 +147,27 @@ function parseDriverJson(output) {
 }
 function directBrowserWorkerRunner(root) {
     return (_definition, request, _route, signal) => {
-        const args = [join(root, 'scripts', 'temporary_bh.py'), '--prompt', request.prompt];
+        const releaseFile = join(process.env.TMPDIR ?? '/tmp', `agents-relay-chatgpt-release-${randomUUID()}`);
+        const args = [join(root, 'scripts', 'temporary_bh.py'), '--prompt', request.prompt, '--release-file', releaseFile];
         for (const file of request.files ?? [])
             args.push('--file', file);
         const child = spawn('python3', args, { shell: false, stdio: ['ignore', 'pipe', 'pipe'] });
         let stdout = '';
         let stderr = '';
+        let submitted = false;
+        let submittedResolve;
+        let submittedReject;
+        const submittedPromise = new Promise((resolve, reject) => { submittedResolve = resolve; submittedReject = reject; });
         child.stdout?.on('data', (chunk) => {
             stdout += chunk.toString();
+            if (!submitted) {
+                try {
+                    const response = parseDriverJson(stdout);
+                    submitted = true;
+                    submittedResolve?.(JSON.stringify(response));
+                }
+                catch { /* receipt may be split across chunks */ }
+            }
         });
         child.stderr?.on('data', (chunk) => {
             stderr = appendTail(stderr, chunk.toString());
@@ -156,11 +176,18 @@ function directBrowserWorkerRunner(root) {
             child.on('error', reject);
             child.on('close', code => {
                 if (code !== 0) {
-                    reject(new Error(stderr.trim() || stdout.trim() || `browser-worker driver exited ${code}`));
+                    const error = new Error(stderr.trim() || stdout.trim() || `browser-worker driver exited ${code}`);
+                    submittedReject?.(error);
+                    reject(error);
                     return;
                 }
                 try {
-                    resolve(JSON.stringify(parseDriverJson(stdout)));
+                    const result = JSON.stringify(parseDriverJson(stdout));
+                    if (!submitted) {
+                        submitted = true;
+                        submittedResolve?.(result);
+                    }
+                    resolve(result);
                 }
                 catch (error) {
                     reject(error);
@@ -171,7 +198,9 @@ function directBrowserWorkerRunner(root) {
             else
                 signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
         });
-        return { promise, cancel: () => child.kill('SIGTERM') };
+        const release = () => { void writeFile(releaseFile, 'release').catch(() => { }); };
+        promise.finally(() => { void unlink(releaseFile).catch(() => { }); }).catch(() => { });
+        return { promise, submitted: submittedPromise, release, cancel: () => { release(); child.kill('SIGTERM'); } };
     };
 }
 function parseBrowserWorkerResponse(output) {
@@ -203,7 +232,7 @@ export class ChatGptAdapter {
         this.agentPath = options.agentPath ?? process.env.AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT;
         this.runner = options.agentRunner;
     }
-    launch(task, signal) {
+    launch(task, signal, context = {}) {
         if (!task.routing)
             throw new Error(`Task ${task.id} requires routing metadata before ChatGPT launch`);
         const route = task.routing;
@@ -218,14 +247,24 @@ export class ChatGptAdapter {
             promise: Promise.resolve({ summary: '' }),
             cancel: abort,
         };
+        let launchResolve;
+        let launchReject;
+        execution.launched = new Promise((resolve, reject) => { launchResolve = resolve; launchReject = reject; });
+        execution.launched.catch(() => { });
         execution.promise = (async () => {
             const runtime = await loadBrowserWorkerRuntime(this.agentPath);
             if (controller.signal.aborted)
                 throw new Error('browser-worker execution aborted');
             const run = (this.runner ?? directBrowserWorkerRunner(runtime.root))(runtime.definition, { prompt: task.input }, route, controller.signal);
             try {
-                const output = await run.promise;
+                const output = await (run.submitted ?? run.promise);
                 const response = parseBrowserWorkerResponse(output);
+                launchResolve();
+                if (context.waitForWorkerStart)
+                    await context.waitForWorkerStart;
+                run.release?.();
+                if (run.submitted)
+                    await run.promise;
                 return {
                     summary: 'ChatGPT task submitted; terminal task state is event-owned',
                     data: {
@@ -236,8 +275,12 @@ export class ChatGptAdapter {
                 };
             }
             catch (error) {
+                launchReject(error);
+                run.release?.();
                 if (controller.signal.aborted)
                     throw error;
+                if (error instanceof StartAckTimeout)
+                    throw error;
                 throw new LaunchFailure(error instanceof Error ? error.message : String(error));
             }
         })();

package/dist/cli.js

@@ -43,7 +43,7 @@ Usage:
   npx agents-relay job <create|adopt|repair> [options]
 
 Actions:
-  create  Find or create an open PR, then persist its job marker
+  create  Find or create an open PR, then persist its job marker; use --start to submit the initial task
   adopt   Attach a job marker to an existing PR
   repair  Repair duplicate markers for the same job
 
@@ -54,6 +54,7 @@ Common options:
   --title TEXT             Job title
   --objective TEXT         Objective for autonomous mode
   --mode fixed|autonomous  Execution mode (default: fixed)
+  --start                   Create/reuse the job and submit its initial task
 
 Example:
   npx agents-relay job create --repo OWNER/REPO --head feat/example --base main --id job-1`,
@@ -61,6 +62,8 @@ Example:
 
 Required: --repo OWNER/REPO, --id JOB_ID, and --head BRANCH.
 Common: --base BRANCH (default: main), --title TEXT, --body TEXT, --mode fixed|autonomous.
+With --start, also require --adapter codex|chatgpt, --model MODEL, --output task-pr|file,
+and --input TEXT. The initial task ID defaults to 'initial'; use --task-id to override it.
 
 Example:
   npx agents-relay job create --repo OWNER/REPO --head feat/example --base main --id job-1 --title "Objective"`,
@@ -255,6 +258,53 @@ export async function ensureManagedGitHubJob(client, repositoryName, trustedAuth
     await store.saveJob(job);
     return { job: await store.load(options.id), pr };
 }
+function workerTaskFromArgs(job, args, now, requireInput = false) {
+    const model = arg(args, '--model');
+    const adapterValue = arg(args, '--adapter');
+    const adapter = (adapterValue || 'codex');
+    const outputKind = arg(args, '--output');
+    const outputPath = arg(args, '--output-path');
+    const input = arg(args, '--input');
+    if (!['codex', 'chatgpt'].includes(adapter))
+        throw new Error('submit adapter must be codex or chatgpt');
+    if (!model)
+        throw new Error('submit requires --model for codex/chatgpt tasks');
+    if (requireInput && !input)
+        throw new Error('job create --start requires --input');
+    if (outputKind !== 'task-pr' && outputKind !== 'file')
+        throw new Error('submit requires --output task-pr|file');
+    if (outputKind === 'file' && !outputPath)
+        throw new Error('--output file requires --output-path');
+    const routing = { provider: arg(args, '--provider', 'openai'), model, profile: arg(args, '--profile') || undefined, reasoning: arg(args, '--reasoning') || undefined, cwd: arg(args, '--cwd') || undefined, projectId: arg(args, '--chatgpt-project') || undefined, decidedBy: 'cli', decidedAt: now };
+    return {
+        jobId: job.id,
+        id: arg(args, '--task-id', 'initial'),
+        priority: priority(args, job.priority ?? 'P2'),
+        projectName: arg(args, '--project') || undefined,
+        agentName: arg(args, '--agent') || undefined,
+        parentTaskId: arg(args, '--parent') || null,
+        dependencies: arg(args, '--deps').split(',').filter(Boolean),
+        capabilities: arg(args, '--capabilities').split(',').filter(Boolean),
+        adapter,
+        input: input || 'true',
+        output: outputKind === 'file' ? { kind: 'file', path: outputPath } : { kind: 'task_pr' },
+        routing,
+        continuation: continuation(args),
+        continuationDeliveredAt: null,
+        state: 'QUEUED',
+        attempt: 0,
+        maxAttempts: Number(arg(args, '--max-attempts', '3')),
+        leaseOwner: null,
+        leaseExpiresAt: null,
+        executionId: null,
+        threadId: null,
+        result: null,
+        error: null,
+        timeoutMs: Number(arg(args, '--timeout', '300000')),
+        createdAt: now,
+        updatedAt: now
+    };
+}
 async function runTaskCommand(action, args) {
     if (action !== 'update')
         throw new Error(usage);
@@ -322,6 +372,14 @@ async function runJobCommand(action, args) {
     const id = arg(args, '--id');
     if (!id)
         throw new Error('--id is required for managed GitHub jobs');
+    const start = hasArg(args, '--start');
+    if (start && action !== 'create')
+        throw new Error('--start is only supported by job create');
+    if (start) {
+        if (!hasArg(args, '--adapter'))
+            throw new Error('job create --start requires --adapter codex|chatgpt');
+        workerTaskFromArgs({ id, title: '', executionMode: 'fixed', prNumber: 0, repository: repo, state: 'OPEN', continuation: null, createdAt: '', updatedAt: '', tasks: [] }, args, new Date().toISOString(), true);
+    }
     const auth = await githubAuthContext(args);
     const client = auth.client;
     const trustedAuthors = auth.trustedAuthors;
@@ -343,7 +401,17 @@ async function runJobCommand(action, args) {
         base: arg(args, '--base', 'main'),
         body: arg(args, '--body') || undefined
     });
-    console.log(JSON.stringify({ repository: repo, pr: result.pr.number, job: result.job.id, executionMode: result.job.executionMode, state: result.job.state }, null, 2));
+    if (start) {
+        const task = workerTaskFromArgs(result.job, args, new Date().toISOString(), true);
+        const existing = result.job.tasks.find(item => item.id === task.id);
+        const store = new GitHubStore(client, repo, result.pr.number, trustedAuthors);
+        await store.appendTask(task);
+        if (!existing) {
+            await publishWake(eventBus(args), result.job, task.id, `Task ${task.id} submitted`);
+            result.job.tasks.push(task);
+        }
+    }
+    console.log(JSON.stringify({ repository: repo, pr: result.pr.number, job: result.job.id, executionMode: result.job.executionMode, state: result.job.state, task: start ? arg(args, '--task-id', 'initial') : undefined }, null, 2));
 }
 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 runtime(store, args, bus) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); 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()], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, eventBus: bus, emit }); }
@@ -489,20 +557,8 @@ async function main() {
     }
     if (command === 'submit') {
         const now = new Date().toISOString();
-        const model = arg(args, '--model');
-        const adapter = arg(args, '--adapter', 'codex');
-        const outputKind = arg(args, '--output');
-        const outputPath = arg(args, '--output-path');
-        if (!['codex', 'chatgpt'].includes(adapter))
-            throw new Error('submit adapter must be codex or chatgpt');
-        if (!model)
-            throw new Error('submit requires --model for codex/chatgpt tasks');
-        if (outputKind !== 'task-pr' && outputKind !== 'file')
-            throw new Error('submit requires --output task-pr|file');
-        if (outputKind === 'file' && !outputPath)
-            throw new Error('--output file requires --output-path');
-        const routing = model ? { provider: arg(args, '--provider', 'openai'), model, profile: arg(args, '--profile') || undefined, reasoning: arg(args, '--reasoning') || undefined, cwd: arg(args, '--cwd') || undefined, projectId: arg(args, '--chatgpt-project') || undefined, decidedBy: 'cli', decidedAt: now } : undefined;
-        const task = { jobId: job.id, id: arg(args, '--task-id', randomUUID()), priority: priority(args, job.priority ?? 'P2'), projectName: arg(args, '--project') || undefined, agentName: arg(args, '--agent') || undefined, parentTaskId: arg(args, '--parent') || null, dependencies: arg(args, '--deps').split(',').filter(Boolean), capabilities: arg(args, '--capabilities').split(',').filter(Boolean), adapter, input: arg(args, '--input', 'true'), output: outputKind === 'file' ? { kind: 'file', path: outputPath } : { kind: 'task_pr' }, routing, continuation: continuation(args), continuationDeliveredAt: null, state: 'QUEUED', attempt: 0, maxAttempts: Number(arg(args, '--max-attempts', '3')), leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, error: null, timeoutMs: Number(arg(args, '--timeout', '300000')), createdAt: now, updatedAt: now };
+        const task = workerTaskFromArgs(job, args, now);
+        task.id = arg(args, '--task-id', randomUUID());
         await store.appendTask(task);
         job.tasks.push(task);
         if (job.state === 'COMPLETED') {

package/dist/dashboard.js

@@ -220,6 +220,7 @@ function rememberSelection(){if(selectedJob)sessionStorage.setItem('agents-relay
 function selected(){return jobs.find(job=>job.id===selectedJob)||jobs[0]||null;}
 function counts(tasks){const out={};for(const task of Array.isArray(tasks)?tasks:[])out[task.state]=(out[task.state]||0)+1;return out;}
 function compactCounts(input){const order=['RUNNING','BLOCKED','FAILED','QUEUED','READY','WAITING','SUCCEEDED','CANCELLED'];return order.filter(state=>input[state]).map(state=>input[state]+' '+state).join(', ')||'No tasks';}
+function awaitingInitialTask(job){return job?.state==='OPEN'&&Array.isArray(job?.tasks)&&job.tasks.length===0;}
 function relativeTime(timestamp){if(!timestamp)return '—';const parsed=Date.parse(timestamp);if(!Number.isFinite(parsed))return value(timestamp);const seconds=Math.max(0,Math.round((Date.now()-parsed)/1000));if(seconds<60)return 'just now';if(seconds<3600)return Math.floor(seconds/60)+'m ago';if(seconds<86400)return Math.floor(seconds/3600)+'h ago';return Math.floor(seconds/86400)+'d ago';}
 function safePrUrl(repository,prNumber){if(typeof repository!=='string'||!Number.isInteger(prNumber)||prNumber<=0)return null;const parts=repository.split('/');if(parts.length!==2)return null;const [owner,repo]=parts;if(!owner||!repo||owner==='.'||owner==='..'||repo==='.'||repo==='..')return null;if(!/^[A-Za-z0-9-]+$/.test(owner)||!/^[A-Za-z0-9._-]+$/.test(repo))return null;return 'https://github.com/'+owner+'/'+repo+'/pull/'+prNumber;}
 function prField(job){const box=element('div','detail-group');box.append(element('p','detail-label',text('GitHub PR')));const line=element('p','detail-value');const url=safePrUrl(job.repository,job.prNumber);if(url){const link=document.createElement('a');link.href=url;link.target='_blank';link.rel='noopener noreferrer';link.textContent='PR #'+job.prNumber;line.append(link);}else line.append(text('unavailable'));box.append(line);return box;}
@@ -235,12 +236,12 @@ function syncFilters(){
   selectedRepo=repos.includes(previousRepo)?previousRepo:'';
   repoFilter.value=selectedRepo;
 }
-function renderJobList(){jobList.replaceChildren();const visible=filteredJobs();if(!jobs.length){jobList.append(element('li','empty',text('No durable jobs discovered.')));return;}if(!visible.length){jobList.append(element('li','empty',text('No jobs match the selected repo.')));return;}for(const job of visible){const button=document.createElement('button');button.type='button';button.className='job-button'+(isCompleteUnmerged(job)?' complete-unmerged':'');button.setAttribute('aria-current',String(job.id===selectedJob));button.title=job.title||job.id;button.addEventListener('click',()=>selectJob(job.id));const meta=element('span','job-meta');meta.append(element('span','badge '+value(job.state),text(job.state)),element('span','badge mode-'+value(job.executionMode||'fixed'),text(value(job.executionMode||'fixed').toUpperCase())),element('span',job.draft?'badge DRAFT':'',text(job.draft?'DRAFT':value(job.githubState||'UNKNOWN'))));if(isCompleteUnmerged(job))meta.append(element('span','badge MERGE_PENDING',text('MERGE PENDING')));meta.append(element('span','',text(job.repository||'unknown repo')),element('span','',text(relativeTime(job.updatedAt))));button.append(element('span','job-title',text('PR#'+value(job.prNumber)+': '+value(job.title||job.id))),meta,element('span','subtle',text(compactCounts(counts(job.tasks)))));jobList.append(element('li','',button));}}
+function renderJobList(){jobList.replaceChildren();const visible=filteredJobs();if(!jobs.length){jobList.append(element('li','empty',text('No durable jobs discovered.')));return;}if(!visible.length){jobList.append(element('li','empty',text('No jobs match the selected repo.')));return;}for(const job of visible){const button=document.createElement('button');button.type='button';button.className='job-button'+(isCompleteUnmerged(job)?' complete-unmerged':'');button.setAttribute('aria-current',String(job.id===selectedJob));button.title=job.title||job.id;button.addEventListener('click',()=>selectJob(job.id));const meta=element('span','job-meta');meta.append(element('span','badge '+value(job.state),text(job.state)),element('span','badge mode-'+value(job.executionMode||'fixed'),text(value(job.executionMode||'fixed').toUpperCase())),element('span',job.draft?'badge DRAFT':'',text(job.draft?'DRAFT':value(job.githubState||'UNKNOWN'))));if(isCompleteUnmerged(job))meta.append(element('span','badge MERGE_PENDING',text('MERGE PENDING')));if(awaitingInitialTask(job))meta.append(element('span','badge WAITING',text('AWAITING INITIAL TASK')));meta.append(element('span','',text(job.repository||'unknown repo')),element('span','',text(relativeTime(job.updatedAt))));button.append(element('span','job-title',text('PR#'+value(job.prNumber)+': '+value(job.title||job.id))),meta,element('span','subtle',text(compactCounts(counts(job.tasks)))));jobList.append(element('li','',button));}}
 function taskNode(task,children,depth){const li=element('li');const row=document.createElement('button');row.type='button';row.className='task-row';row.setAttribute('aria-current',String(task.id===selectedTaskId));row.title=task.id;row.addEventListener('click',()=>{selectedTaskId=task.id;eventTaskId=task.id;rememberSelection();clearEvents();renderAll();void loadEventHistory();});const id=element('span','task-id',text(task.id));id.style.paddingLeft=Math.min(depth,4)*6+'px';row.append(id,element('span','badge '+value(task.state),text(task.state)));li.append(row);const nested=children.get(task.id)||[];if(nested.length){const ul=element('ul','tree');for(const child of nested)ul.append(taskNode(child,children,depth+1));li.append(ul);}return li;}
 function buildTree(tasks){taskTree.replaceChildren();if(!Array.isArray(tasks)||!tasks.length){taskTree.append(element('li','empty',text('No tasks in durable state.')));return;}const known=new Set(tasks.map(task=>task.id));const children=new Map();const roots=[];for(const task of tasks){if(!task.parentTaskId||!known.has(task.parentTaskId))roots.push(task);else{const siblings=children.get(task.parentTaskId)||[];siblings.push(task);children.set(task.parentTaskId,siblings);}}for(const task of roots)taskTree.append(taskNode(task,children,0));}
 function attemptBudget(task){const attempt=Number(task?.attempt)||0;const max=Number(task?.maxAttempts)||0;if(max>=3&&max%3===0){const effectiveMax=Math.max(max,Math.ceil(attempt/3)*3);return attempt+' / 3×'+(effectiveMax/3);}return attempt+' / '+max;}
 function renderTaskDetail(task){taskDetailRoot.replaceChildren();if(!task){taskDetailRoot.append(element('p','empty',text('Select a task to inspect execution details.')));return;}const routing=task.routing||{};const groups=element('div','detail-groups');groups.append(field('Task',task.id),field('Kind',task.kind||'work'),field('State',task.state),field('Project / agent',value(task.projectName)+' / '+value(task.agentName)),field('Parent task',task.parentTaskId||'root'),field('Adapter',task.adapter),field('Provider / model',value(routing.provider)+' / '+value(routing.model)),field('Reasoning / profile',value(routing.reasoning||routing.profile)),field('Attempt',attemptBudget(task)),field('Dependencies',Array.isArray(task.dependencies)&&task.dependencies.length?task.dependencies.join(', '):'none'),chatField(task));if(task.plannerResult)groups.append(field('Objective status',task.plannerResult.objective_status),markdownField('Assessment',task.plannerResult.assessment));if(task.error)groups.append(field('Error',task.error));taskDetailRoot.append(groups);}
-function renderSelectedJob(){jobDetail.replaceChildren();const job=selected();if(!job){selectedJobTitle.textContent='';jobDetail.append(element('div','empty',text('No durable jobs discovered.')));buildTree([]);renderTaskDetail(null);return;}selectedJobTitle.textContent='— '+value(job.title||job.id);if(job.id!==selectedJob){selectedJob=job.id;selectedTaskId=null;eventTaskId=null;clearEvents();rememberSelection();}const summary=element('div','job-summary');summary.append(field('GitHub state',job.githubState||'UNKNOWN'),field('Durable state',job.state),field('Execution mode',job.executionMode||'fixed'),field('Objective',job.objective||job.description||job.title),prField(job),field('Repository',job.repository||'—'),field('Last activity',relativeTime(job.updatedAt)),field('Task states',compactCounts(counts(job.tasks))));jobDetail.append(summary);const selectedTask=(job.tasks||[]).find(task=>task.id===selectedTaskId)||null;if(selectedTaskId&&!selectedTask){selectedTaskId=null;eventTaskId=null;clearEvents();rememberSelection();}buildTree(job.tasks||[]);renderTaskDetail(selectedTask);renderEventScope();}
+function renderSelectedJob(){jobDetail.replaceChildren();const job=selected();if(!job){selectedJobTitle.textContent='';jobDetail.append(element('div','empty',text('No durable jobs discovered.')));buildTree([]);renderTaskDetail(null);return;}selectedJobTitle.textContent='— '+value(job.title||job.id);if(job.id!==selectedJob){selectedJob=job.id;selectedTaskId=null;eventTaskId=null;clearEvents();rememberSelection();}const summary=element('div','job-summary');summary.append(field('GitHub state',job.githubState||'UNKNOWN'),field('Durable state',job.state),field('Execution mode',job.executionMode||'fixed'),field('Status',awaitingInitialTask(job)?'Awaiting initial task':job.state),field('Objective',job.objective||job.description||job.title),prField(job),field('Repository',job.repository||'—'),field('Last activity',relativeTime(job.updatedAt)),field('Task states',compactCounts(counts(job.tasks))));jobDetail.append(summary);const selectedTask=(job.tasks||[]).find(task=>task.id===selectedTaskId)||null;if(selectedTaskId&&!selectedTask){selectedTaskId=null;eventTaskId=null;clearEvents();rememberSelection();}buildTree(job.tasks||[]);renderTaskDetail(selectedTask);renderEventScope();}
 function renderAll(){jobs.sort(compareJobs);syncFilters();renderJobList();renderSelectedJob();}
 function isCompleteUnmerged(job){return job.state==='COMPLETED'&&job.githubState==='OPEN';}
 function isTerminalJob(job){return ['COMPLETED','CANCELLED'].includes(job.state)||['MERGED','CLOSED'].includes(job.githubState);}
@@ -256,7 +257,8 @@ function renderRateLimitStatus(status){
 async function refreshStatus(){try{renderRateLimitStatus(await loadJSON('/api/status'));}catch{renderRateLimitStatus(null);}}
 async function refresh(force=false){jobsRefresh.disabled=true;jobsRefresh.textContent='Refreshing…';try{const discovered=await loadJSON('/api/jobs'+(force?'?refresh=1':''));jobs=Array.isArray(discovered)?discovered:[];jobs.sort(compareJobs);if(selectedJob&&!jobs.some(job=>job.id===selectedJob)){selectedJob=null;selectedTaskId=null;}if(!selectedJob){const match=location.hash.match(/^#\\/jobs\\/(.+)$/);const fromHash=match?decodeURIComponent(match[1]):null;selectedJob=jobs.some(job=>job.id===fromHash)?fromHash:(jobs[0]?.id||null);}rememberSelection();renderAll();void loadEventHistory();connection.textContent='Live · durable state connected';connection.className='status-pill ok';}catch(error){connection.textContent='Error · durable state unavailable';connection.className='status-pill bad';jobList.replaceChildren(element('li','error-state',text('Could not load jobs: '+error.message)));}finally{jobsRefresh.disabled=false;jobsRefresh.textContent='Refresh';}}
 function renderEventScope(){const task=eventTaskId&&selected()?.tasks?.find(candidate=>candidate.id===eventTaskId);eventsAllTasks.disabled=!task;eventsAllTasks.setAttribute('aria-pressed',String(!task));eventsScope.textContent=task?'Task '+task.id+' · newest first · 60 max':'Job-wide · newest first · 60 max';}
-function addEvent(event,level){if(!event||selectedJob&&event.job_id&&event.job_id!==selectedJob||eventTaskId&&event.task_id!==eventTaskId)return;if(event.event_id&&displayedEventIds.has(event.event_id))return;if(event.event_id)displayedEventIds.add(event.event_id);const item=element('li','event-item');const meta=element('div','event-meta');meta.append(element('span','event-kind',text(event.type||'event')),element('span','',text(relativeTime(event.timestamp))),element('span','',text('task: '+value(event.task_id))));item.append(meta);const message=element('p','event-message',text(event.message||'Event received'));if(level==='error'||event.level==='error')message.classList.add('error-text');item.append(message);eventFeed.querySelector('.empty')?.remove();eventFeed.prepend(item);while(eventFeed.children.length>MAX_EVENTS)eventFeed.lastElementChild?.remove();}
+function eventLabel(type){return ({'task.process.launched':'Process launched','task.started':'Worker started','task.process.exited':'Sync process exited','task.process.async_exited':'Async process exited','task.completed':'Worker completed','task.failed':'Worker failed','task.blocked':'Worker blocked'})[type]||type||'Event';}
+function addEvent(event,level){if(!event||selectedJob&&event.job_id&&event.job_id!==selectedJob||eventTaskId&&event.task_id!==eventTaskId)return;if(event.event_id&&displayedEventIds.has(event.event_id))return;if(event.event_id)displayedEventIds.add(event.event_id);const item=element('li','event-item');const meta=element('div','event-meta');meta.append(element('span','event-kind',text(eventLabel(event.type))),element('span','event-type',text(event.type||'event')),element('span','',text(relativeTime(event.timestamp))),element('span','',text('task: '+value(event.task_id))));item.append(meta);const message=element('p','event-message',text(event.message||'Event received'));if(level==='error'||event.level==='error')message.classList.add('error-text');item.append(message);eventFeed.querySelector('.empty')?.remove();eventFeed.prepend(item);while(eventFeed.children.length>MAX_EVENTS)eventFeed.lastElementChild?.remove();}
 function usageBar(label,windowData){const percent=Math.max(0,Math.min(100,100-windowData.usedPercent));const row=element('div','usage-row');const heading=element('div','usage-label');heading.append(element('span','',text(label)),element('span','',text(Math.round(percent)+'%')));const track=element('div','usage-track');track.setAttribute('role','progressbar');track.setAttribute('aria-label',label+' available');track.setAttribute('aria-valuemin','0');track.setAttribute('aria-valuemax','100');track.setAttribute('aria-valuenow',String(percent));const fill=element('div','usage-fill');fill.style.width=percent+'%';track.append(fill);row.append(heading,track);return row;}
 function usageProvider(provider){const card=element('section','usage-provider');card.append(element('h3','',text(provider.label)));const usage=provider.usage||{};if(!usage.available||!usage.fiveHour||!usage.weekly){card.append(element('p','empty',text(usage.reason||'Account usage telemetry is unavailable.')));return card;}const bars=element('div','usage-bars');bars.append(usageBar('5-hour remaining',usage.fiveHour),usageBar('Weekly remaining',usage.weekly));card.append(bars);return card;}
 function formatCredit(value,currency){if(value===null||value===undefined||!Number.isFinite(Number(value)))return '—';const number=Number(value);if(currency==='USD')return '$'+number.toFixed(2);if(currency==='CNY')return '¥'+number.toFixed(2);return number.toFixed(2)+' '+currency;}

package/dist/events.js

@@ -51,4 +51,4 @@ export class NatsEventBus {
         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 }; }
+export function eventFor(jobId, taskId, parentTaskId, type, status, message, visibility = 'orchestrator', data, source) { 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, source }; }

package/dist/pool.js

@@ -4,6 +4,9 @@ const RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
 export function compareJobPriority(a, b) { return RANK[a.priority ?? 'P2'] - RANK[b.priority ?? 'P2'] || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id); }
 export function runnableManagedJobs(items) { return items.filter(item => item.githubState === 'OPEN' && !item.draft && !['COMPLETED', 'CANCELLED'].includes(item.job.state)).map(item => item.job).sort(compareJobPriority); }
 export function needsLifecycleReconciliation(job, now = Date.now()) {
+    // Create-only jobs stay OPEN until a caller explicitly submits work.
+    if (job.tasks.length === 0)
+        return false;
     if (job.tasks.some(task => ['READY', 'QUEUED', 'WAITING'].includes(task.state)))
         return true;
     return job.tasks.some(task => task.state === 'RUNNING' && task.leaseExpiresAt !== null && new Date(task.leaseExpiresAt).getTime() <= now);
@@ -47,7 +50,7 @@ export class RepositoryWorkerPool {
             const store = new GitHubStore(this.client, job.repository, job.prNumber, this.trustedAuthors);
             const ready = job.tasks.filter(task => ['READY', 'QUEUED', 'WAITING'].includes(task.state)).length;
             const expiredRunning = job.tasks.some(task => task.state === 'RUNNING' && task.leaseExpiresAt !== null && new Date(task.leaseExpiresAt).getTime() <= Date.now());
-            if (!needsLifecycleReconciliation(job) && job.tasks.length > 0)
+            if (!needsLifecycleReconciliation(job))
                 continue;
             const allowance = Math.max(1, Math.min(capacity, ready || (expiredRunning ? 1 : 0) || 1));
             await this.makeReconciler(store, allowance).reconcile(job.id);

package/dist/reconciler.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { schedule, transitionTask } from './scheduler.js';
-import { LaunchFailure } from './adapters.js';
+import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
 import { parsePlannerResult, plannerInput } from './planner.js';
 const PRIORITY_RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
@@ -230,25 +230,68 @@ export class Reconciler {
         task.executionId = randomUUID();
         const durableExecutionId = task.executionId;
         await this.store.saveTask(task);
-        await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.started', 'running', `Task ${task.id} started`, 'user', { adapter: adapter.id, model: task.routing?.model }));
         const controller = new AbortController();
         let execution;
         const workerTask = { ...task, input: workerInput };
+        const startAckSetup = task.adapter === 'chatgpt' ? await this.startAck(job.id, task.id, Date.now()) : null;
+        const launchContext = startAckSetup ? { waitForWorkerStart: startAckSetup.ack } : {};
         try {
-            execution = adapter.launch(workerTask, controller.signal);
+            execution = adapter.launch(workerTask, controller.signal, launchContext);
         }
         catch (error) {
+            await startAckSetup?.stop();
             await this.failLaunch(job.id, task.id, task.executionId, error instanceof Error ? error.message : String(error));
             return;
         }
+        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 });
         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));
         this.terminalTimers.set(task.id, terminalTimer);
-        this.detach(execution.promise.then(result => this.runtimeSettled(job.id, task.id, durableExecutionId, result, null), error => error instanceof LaunchFailure
-            ? this.failLaunch(job.id, task.id, durableExecutionId, error.message, 'delivery')
-            : this.runtimeSettled(job.id, task.id, durableExecutionId, null, error instanceof Error ? error.message : String(error))), job.id, task.id, 'worker runtime completion');
+        this.detach(execution.promise.then(result => this.runtimeSettled(job.id, task.id, durableExecutionId, result, null), error => error instanceof StartAckTimeout
+            ? this.failLaunch(job.id, task.id, durableExecutionId, error.message, 'start-ack')
+            : error instanceof LaunchFailure
+                ? this.failLaunch(job.id, task.id, durableExecutionId, error.message, 'delivery')
+                : this.runtimeSettled(job.id, task.id, durableExecutionId, null, error instanceof Error ? error.message : String(error))), job.id, task.id, 'worker runtime completion');
+    }
+    async startAck(jobId, taskId, launchBarrier) {
+        if (!this.options.eventBus)
+            throw new Error('Worker start acknowledgement requires an event bus');
+        let resolveAck;
+        let rejectAck;
+        let settled = false;
+        let timer;
+        const ack = new Promise((resolve, reject) => { resolveAck = resolve; rejectAck = reject; });
+        const unsubscribe = await this.options.eventBus.subscribe(jobId, async (event) => {
+            if (settled || event.type !== 'task.started' || event.job_id !== jobId || event.task_id !== taskId)
+                return;
+            const sourceAgent = typeof event.source?.agent === 'string' ? event.source.agent : '';
+            const sourceComponent = typeof event.source?.component === 'string' ? event.source.component : '';
+            const workerOwned = event.data?.worker_owned === true || ['codex', 'chatgpt'].includes(sourceAgent);
+            if (!workerOwned || sourceAgent === 'relay' || sourceComponent === 'agents-relay')
+                return;
+            if (!event.timestamp || new Date(event.timestamp).getTime() < launchBarrier)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            resolveAck();
+        });
+        timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            void unsubscribe();
+            rejectAck(new StartAckTimeout(`Task ${taskId} worker_start_timeout: no worker task.started start-ack`));
+        }, this.options.startAckTimeoutMs ?? 60000);
+        let stopped = false;
+        const stop = async () => { if (stopped)
+            return; stopped = true; if (timer)
+            clearTimeout(timer); await unsubscribe(); };
+        return { ack, stop };
     }
     async launchPlanner(job, task) {
         const planner = this.options.planner;
@@ -352,7 +395,7 @@ export class Reconciler {
         const task = job.tasks.find(item => item.id === taskId);
         if (!task || task.executionId !== executionId || task.state !== 'RUNNING')
             return;
-        const event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', `Worker ${phase} failed: ${message}`, 'user', { phase });
+        const event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', `Worker ${phase} failed: ${message}`, 'user', { phase, reason: phase === 'start-ack' ? 'worker_start_timeout' : undefined }, { agent: 'relay', component: 'agents-relay', watchdog: true });
         await this.applyTerminalEvent(event);
         await this.emit(event);
     }
@@ -364,7 +407,7 @@ export class Reconciler {
         const task = job.tasks.find(item => item.id === taskId);
         if (!task || task.executionId !== executionId || task.state !== 'RUNNING')
             return;
-        await this.emit(eventFor(jobId, taskId, task.parentTaskId, error ? 'worker.runtime.failed' : 'worker.runtime.exited', error ? 'failed' : 'succeeded', error ?? result?.summary ?? 'Worker runtime exited', 'orchestrator', { authoritative: false, waitingForTerminalEvent: true }));
+        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' }));
     }
     async timeoutTask(jobId, taskId, executionId) {
         const live = this.live.get(taskId);

package/package.json

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

package/skills/chatgpt-browser-worker/SKILL.md

@@ -48,9 +48,12 @@ Neo event contract. Events are execution observability, not a third output mode.
 ## Runtime behavior
 
 The worker is one-shot. It opens an isolated worker-owned ChatGPT tab, submits
-the complete task, verifies that ChatGPT accepted the submission, closes its
-owned tab, and returns. ChatGPT continues the task independently and publishes
-the result through the declared output contract.
+the complete task, verifies that ChatGPT accepted the submission, waits for the
+exact post-submission worker `task.started` acknowledgement, then closes its
+owned tab and returns. ChatGPT continues the task independently and publishes
+the result through the declared output contract. If the acknowledgement does
+not arrive within 60 seconds, close only the owned tab and fail with
+`worker_start_timeout`.
 
 The worker must never interact through a pre-existing user ChatGPT tab.
 Browser details, transient conversation identity, submission verification,

package/skills/chatgpt-browser-worker/agents/browser-worker.agent.md

@@ -28,8 +28,11 @@ If the output declaration is missing or ambiguous, do not invent one.
   settings. Do not change model or thinking settings.
 - Upload requested files, submit the complete task prompt, and verify that the
   submission became a new user turn.
-- Once submission is verified, close the worker-owned tab and return. Do not
-  wait for the assistant response and do not reopen or poll the conversation.
+- Once submission is verified, keep the worker-owned tab open until Relay has
+  observed a new worker-owned `task.started` event for the exact job/task, then
+  close the tab and return. Do not wait for the assistant response and do not
+  reopen or poll the conversation. If the start acknowledgement does not arrive
+  within 60 seconds, close only the owned tab and report a start-ack timeout.
 - Treat any observed conversation/thread identity only as diagnostic evidence,
   never as a resumable handle.
 - Progress and terminal success/failure for the actual delegated task are

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

@@ -177,4 +177,16 @@ print(json.dumps({
     "diagnostic_thread_id": _diagnostic_thread_id(),
     "user_message_id": user_turn.get("id") or None,
     "verified": True,
-}, ensure_ascii=False))
+}, ensure_ascii=False), flush=True)
+
+# Keep the owned Temporary Chat tab alive until Relay observes the worker's
+# post-launch task.started acknowledgement.  The parent releases this file;
+# atexit then closes only this worker-owned tab.
+release_file = CFG.get("release_file")
+if not release_file:
+    raise RuntimeError("worker release file was not configured")
+deadline = time.time() + 90
+while time.time() < deadline and not os.path.exists(release_file):
+    time.sleep(.1)
+if not os.path.exists(release_file):
+    raise RuntimeError("worker start acknowledgement release was not observed")

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

@@ -16,6 +16,7 @@ def main() -> int:
     parser = argparse.ArgumentParser()
     parser.add_argument("--prompt", required=True)
     parser.add_argument("--file", action="append", default=[])
+    parser.add_argument("--release-file", required=True)
     args = parser.parse_args()
     with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as handle:
         json.dump(vars(args), handle, ensure_ascii=False)