agents-relay 2.0.154 → 2.0.156

package/README.md

@@ -168,7 +168,7 @@ Review destinations are durable Job facts. `job create` and `job update` accept
 `--reviewer-thread-id` and `--creator-thread-id`; a reviewer ID takes precedence
 over the creator/origin ID. A local runtime invocation may pass
 `--thread-id` as an explicit one-run review override. When a destination exists,
-final-review routing requires a ChatGPT/browser-workspace worker and submits the
+final-review routing requires a ChatGPT/webhelm worker and submits the
 review request as a verified `new-turn` to that existing thread with the Job ID,
 PR number, and immutable review head SHA. Failure still follows the ordinary
 review task retry/recovery path; a transport failure is never treated as
@@ -255,7 +255,7 @@ Every model-backed task declares a durable output with `--output task-pr` or `--
 
 For Codex and ChatGPT, **correlated worker events are authoritative lifecycle inputs**, not a separate durable store. 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 subscribes, validates correlation, applies graph transitions, persists results in RelayStore, and projects them to GitHub. 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 one-shot submission runtime exits; neither substitutes for `task.completed`, `task.failed`, `task.blocked`, or `task.cancelled`. 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 Relay's `agents/chatgpt-worker.agent.md` lifecycle contract and invokes Browser Workspace exactly as a one-shot platform action: `browser-workspace platform run chatgpt temporary-submit --auto-session --config <file>`. Browser Workspace owns creation/release of the fresh Temporary Chat session, selectors, attachments, and submit verification; Relay does not self-heal browser failures and instead lets delivery failures enter its normal retry/recovery lifecycle. Legacy `--chatgpt-tab-close-policy` values remain accepted for compatibility around Relay's event barriers, but they do not control the Browser Workspace auto-session lifetime. The adapter never uses a pre-existing user tab, polls for the assistant response, resumes/reopens a thread, or treats conversation text as the result channel. Any observed ChatGPT thread ID is diagnostic only.
+The ChatGPT adapter uses Relay's `agents/chatgpt-worker.agent.md` lifecycle contract and invokes Browser Workspace exactly as a one-shot platform action: `webhelm platform run chatgpt temporary-submit --auto-session --config <file>`. Browser Workspace owns creation/release of the fresh Temporary Chat session, selectors, attachments, and submit verification; Relay does not self-heal browser failures and instead lets delivery failures enter its normal retry/recovery lifecycle. Legacy `--chatgpt-tab-close-policy` values remain accepted for compatibility around Relay's event barriers, but they do not control the Browser Workspace auto-session lifetime. The adapter never uses a pre-existing user tab, polls for the assistant response, resumes/reopens a thread, or treats conversation text as the result channel. Any observed ChatGPT thread ID is diagnostic only.
 
 ~~~sh
 npx agents-relay task create --repo OWNER/REPO --pr 5 --id job-1 \
@@ -306,7 +306,7 @@ For autonomous Jobs, `UNBLOCKED` is historical: Relay does not retry that old Ta
 
 ### Browser Workspace product boundary
 
-Agents Relay owns the persistent `Relay` browser workspace as product infrastructure. At daemon startup it runs `browser-workspace status`, dynamically imports the returned absolute `admin_helper`, and calls `ensureWorkspace("Relay", 6)`. This bootstrap is best-effort: Browser Workspace discovery/helper failures are logged and skipped so they do not prevent `agents-relayd` from starting; ChatGPT browser work may remain unavailable until Browser Workspace recovers. Ordinary ChatGPT worker activity uses the public Browser Workspace one-shot `platform run ... --auto-session` command; orchestrator-owned self-healing flows may still use explicit session commands. Relay does not create or delete workspaces through CLI lifecycle commands.
+Agents Relay owns the persistent `Relay` browser workspace as product infrastructure. At daemon startup it runs `webhelm status`, dynamically imports the returned absolute `admin_helper`, and calls `ensureWorkspace("Relay", 6)`. This bootstrap is best-effort: Browser Workspace discovery/helper failures are logged and skipped so they do not prevent `agents-relayd` from starting; ChatGPT browser work may remain unavailable until Browser Workspace recovers. Ordinary ChatGPT worker activity uses the public Browser Workspace one-shot `platform run ... --auto-session` command; orchestrator-owned self-healing flows may still use explicit session commands. Relay does not create or delete workspaces through CLI lifecycle commands.
 
 ## Shared publication reporting
 

package/dist/adapters.js

@@ -171,8 +171,8 @@ export function parseDriverJson(output) {
     }
     throw new Error('browser-worker driver returned no submitted receipt');
 }
-function browserWorkspaceCli(override = process.env.AGENTS_RELAY_BROWSER_WORKSPACE_COMMAND) {
-    return override ? { command: override, prefix: [] } : { command: 'uvx', prefix: ['browser-workspace'] };
+function browserWorkspaceCli(override = process.env.AGENTS_RELAY_WEBHELM_COMMAND) {
+    return override ? { command: override, prefix: [] } : { command: 'uvx', prefix: ['--from', 'browser-workspace', 'webhelm'] };
 }
 const browserWorkspaceInjection = new AsyncLocalStorage();
 function browserWorkspaceCommand(cli, args, stdin, signal) {
@@ -181,7 +181,7 @@ function browserWorkspaceCommand(cli, args, stdin, signal) {
 function rawBrowserWorkspaceCommand(cli, args, stdin, signal) {
     return new Promise((resolve, reject) => {
         const child = spawnOwnedProcess(cli.command, [...cli.prefix, ...args], {
-            invocation: 'browser-workspace.command',
+            invocation: 'webhelm.command',
             signal,
             spawn: { shell: false, stdio: [stdin === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'] },
         });
@@ -200,7 +200,7 @@ function rawBrowserWorkspaceCommand(cli, args, stdin, signal) {
             else {
                 // Browser Workspace reports a compact code/message JSON on nonzero exit.
                 // Preserve existing Relay failure behavior; only simplify the error text.
-                let reason = stderr.trim() || stdout.trim() || `browser-workspace exited ${code}`;
+                let reason = stderr.trim() || stdout.trim() || `webhelm exited ${code}`;
                 try {
                     const envelope = parseWorkspaceJson(stdout);
                     const result = envelope.result;
@@ -234,7 +234,7 @@ function parseWorkspaceJson(output) {
         }
         catch { /* diagnostics may precede JSON */ }
     }
-    throw new Error('browser-workspace returned no JSON result');
+    throw new Error('webhelm returned no JSON result');
 }
 /** Parse only the trusted manifest emitted before the explicit task-data boundary. */
 function declaredPromptReferences(prompt) {
@@ -274,14 +274,14 @@ async function accessiblePromptReferences(prompt) {
     }
     return readable;
 }
-export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS_RELAY_BROWSER_WORKSPACE_COMMAND) {
+export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS_RELAY_WEBHELM_COMMAND) {
     const status = parseWorkspaceJson(await browserWorkspaceCommand(browserWorkspaceCli(command), ['status']));
     if (typeof status.admin_helper !== 'string' || !status.admin_helper.startsWith('/')) {
-        throw new Error('browser-workspace status returned no absolute admin_helper path');
+        throw new Error('webhelm status returned no absolute admin_helper path');
     }
     const admin = await import(pathToFileURL(status.admin_helper).href);
     if (typeof admin.ensureWorkspace !== 'function') {
-        throw new Error('browser-workspace admin helper does not export ensureWorkspace');
+        throw new Error('webhelm admin helper does not export ensureWorkspace');
     }
     await admin.ensureWorkspace(CHATGPT_BROWSER_WORKSPACE, CHATGPT_BROWSER_WORKSPACE_POOL_SIZE);
 }
@@ -289,7 +289,7 @@ async function runBrowserWorker(cli, configFile, signal, action = 'temporary-sub
     const session = parseWorkspaceJson(await browserWorkspaceCommand(cli, ['session', 'start', '--workspace', CHATGPT_BROWSER_WORKSPACE], undefined, signal));
     const sessionId = session.session_id;
     if (typeof sessionId !== 'string' || !sessionId)
-        throw new Error('browser-workspace session start returned no session_id');
+        throw new Error('webhelm session start returned no session_id');
     try {
         return await browserWorkspaceCommand(cli, ['platform', 'run', 'chatgpt', action, '--session-id', sessionId, '--config', configFile], undefined, signal);
     }
@@ -347,7 +347,7 @@ function parseBrowserWorkerResponse(output) {
 export class ChatGptAdapter {
     name = 'chatgpt';
     id = 'chatgpt/browser-worker';
-    capabilities = ['model', 'chatgpt', 'browser-workspace'];
+    capabilities = ['model', 'chatgpt', 'webhelm'];
     runner;
     tabClosePolicy;
     constructor(options = {}) {

package/dist/reconciler-runtime.js

@@ -259,7 +259,7 @@ export class ReconcilerRuntimeBase {
         const currentTask = currentJob.tasks.find(task => task.id === taskId);
         const platformFailure = currentTask?.adapter === 'chatgpt' ? classifyChatGptPlatformFailure(failure, phase) : undefined;
         const failureReason = phase === 'start-ack' ? 'worker_start_timeout'
-            : /BROWSER_WORKSPACE_UNAVAILABLE|browser-workspace runtime dependency unavailable|browser-workspace session start returned no session_id|no close frame received or sent/i.test(message)
+            : /WEBHELM_UNAVAILABLE|webhelm runtime dependency unavailable|webhelm session start returned no session_id|no close frame received or sent/i.test(message)
                 ? 'browser_workspace_unavailable'
                 : undefined;
         const claim = executionId ?? `${jobId}:${taskId}`;
@@ -305,7 +305,7 @@ export class ReconcilerRuntimeBase {
         this.detach(this.emit(event), jobId, taskId, 'worker failure event');
         if (runtimeRetry) {
             this.detach(this.emit(eventFor(jobId, taskId, runtimeRetry.parentTaskId, 'task.rerouting', 'queued', 'ChatGPT platform rejection recorded; routing the same Task through Execution Router', 'orchestrator', { previousFailure: transition.task.platformFailure?.classification, executionId, attempt: runtimeRetry.attempt, maxAttempts: runtimeRetry.maxAttempts })), jobId, taskId, 'runtime retry event');
-            this.detach(this.eventCoordinator.accept({ jobId, reason: 'browser-workspace-runtime-retry' }), jobId, taskId, 'runtime retry reconcile wake');
+            this.detach(this.eventCoordinator.accept({ jobId, reason: 'webhelm-runtime-retry' }), jobId, taskId, 'runtime retry reconcile wake');
             return;
         }
         this.detach(this.eventCoordinator.accept({ jobId, reason: `worker-${phase}-failure` }), jobId, taskId, 'worker failure reconcile wake');

package/dist/relayd.js

@@ -465,7 +465,7 @@ export async function runDaemon(argv) {
         const runtime = summarizeRuntime(cachedOverviews.map(item => item.job));
         const workers = workerCandidates([
             { name: 'codex', id: 'codex', capabilities: ['model', 'codex'] },
-            { name: 'chatgpt', id: 'chatgpt/browser-worker', capabilities: ['model', 'chatgpt', 'browser-workspace'] },
+            { name: 'chatgpt', id: 'chatgpt/browser-worker', capabilities: ['model', 'chatgpt', 'webhelm'] },
         ], [], usage);
         const result = await routeExecution(workers, task.workerRequirements ?? { capabilities: task.capabilities ?? [] }, {
             decisionEngine: executionDecisionEngine(),

package/dist/reviewer-thread.js

@@ -50,7 +50,7 @@ export function prepareReviewerThreadDelivery(job, task, override) {
 }
 export function chatgptThreadRequirements(configured) {
     const base = configured ?? { capabilities: ['model'] };
-    const capabilities = new Set([...base.capabilities, 'model', 'chatgpt', 'browser-workspace']);
+    const capabilities = new Set([...base.capabilities, 'model', 'chatgpt', 'webhelm']);
     return { ...base, capabilities: [...capabilities], runtime: 'chatgpt' };
 }
 export function runtimeReviewer(args = []) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.154",
+  "version": "2.0.156",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "repository": {
     "type": "git",

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

@@ -27,7 +27,7 @@ Read `skills/agents-relay/troubleshooter-qa.md` for user-editable best practices
    - shared worker/runtime/tool/Agents Relay defect;
    - genuine external/human blocker.
 4. Diagnose the smallest root cause from the combined durable Task + event sequence + logs. The final `task.error` is only one piece of evidence. Never retry first and investigate later.
-5. For ChatGPT browser failures, run `browser-workspace platform run chatgpt validate --session-id SESSION_ID` in a caller-owned `Relay` session and close the session afterward. Parse the action JSON from the platform-run `result.stdout` (the outer `result.ok` only reports command execution). The action returns exactly JSON `true` on validation success or one failure ID: `PAGE_NOT_READY`, `COMPOSER_NOT_READY`, or `DELIVERY_ERROR`. Treat any unexpected output or runner error as validation unavailable. These are UI-readiness results, NOT authentication results. None permits a human login escalation. Never independently interpret DOM snapshots, sign-in buttons, or disabled Send; only confirmed authentication failure from the actual Worker authentication protocol can justify login escalation. Inspect original task delivery/start-ack evidence separately.
+5. For ChatGPT browser failures, run `webhelm platform run chatgpt validate --session-id SESSION_ID` in a caller-owned `Relay` session and close the session afterward. Parse the action JSON from the platform-run `result.stdout` (the outer `result.ok` only reports command execution). The action returns exactly JSON `true` on validation success or one failure ID: `PAGE_NOT_READY`, `COMPOSER_NOT_READY`, or `DELIVERY_ERROR`. Treat any unexpected output or runner error as validation unavailable. These are UI-readiness results, NOT authentication results. None permits a human login escalation. Never independently interpret DOM snapshots, sign-in buttons, or disabled Send; only confirmed authentication failure from the actual Worker authentication protocol can justify login escalation. Inspect original task delivery/start-ack evidence separately.
 
 6. Repair:
    - For a transient failure, verify the transient condition is gone.