agents-relay 1.0.18 → 1.0.20

package/README.md

@@ -99,9 +99,9 @@ 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. 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.
+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`, `task.blocked`, or `task.cancelled`. The ChatGPT worker-owned tab follows the configured close policy: `after-start` waits for the correlated start acknowledgement, `never` keeps it open for debug, and `after-terminal` waits for a new exact-task terminal event; start-ack failure closes only the owned tab 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.
+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, and applies `--chatgpt-tab-close-policy` (or `AGENTS_RELAY_CHATGPT_TAB_CLOSE_POLICY`): `after-start` by default, `never` for test/debug, or `after-terminal` after a new exact-task terminal event. It never closes a user tab and 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.
 
 ~~~sh
 npx agents-relay submit --repo OWNER/REPO --pr 5 --id job-1 \

package/dist/adapters.js

@@ -98,6 +98,12 @@ export class CodexAdapter {
         return execution;
     }
 }
+export function chatGptTabClosePolicy(value, fallback = 'after-start') {
+    const policy = value || fallback;
+    if (!['after-start', 'never', 'after-terminal'].includes(policy))
+        throw new Error(`Invalid ChatGPT tab close policy: ${policy}`);
+    return policy;
+}
 export class LaunchFailure extends Error {
 }
 export class StartAckTimeout extends LaunchFailure {
@@ -148,7 +154,7 @@ function parseDriverJson(output) {
 function directBrowserWorkerRunner(root) {
     return (_definition, request, _route, signal) => {
         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];
+        const args = [join(root, 'scripts', 'temporary_bh.py'), '--prompt', request.prompt, '--release-file', releaseFile, '--close-policy', request.tabClosePolicy ?? 'after-start'];
         for (const file of request.files ?? [])
             args.push('--file', file);
         const child = spawn('python3', args, { shell: false, stdio: ['ignore', 'pipe', 'pipe'] });
@@ -228,9 +234,11 @@ export class ChatGptAdapter {
     capabilities = ['model', 'chatgpt', 'browser-harness'];
     agentPath;
     runner;
+    tabClosePolicy;
     constructor(options = {}) {
         this.agentPath = options.agentPath ?? process.env.AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT;
         this.runner = options.agentRunner;
+        this.tabClosePolicy = chatGptTabClosePolicy(options.tabClosePolicy ?? process.env.AGENTS_RELAY_CHATGPT_TAB_CLOSE_POLICY);
     }
     launch(task, signal, context = {}) {
         if (!task.routing)
@@ -255,14 +263,21 @@ export class ChatGptAdapter {
             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);
+            const policy = chatGptTabClosePolicy(task.chatgptTabClosePolicy, this.tabClosePolicy);
+            const run = (this.runner ?? directBrowserWorkerRunner(runtime.root))(runtime.definition, { prompt: task.input, tabClosePolicy: policy }, route, controller.signal);
             try {
                 const output = await (run.submitted ?? run.promise);
                 const response = parseBrowserWorkerResponse(output);
                 launchResolve();
-                if (context.waitForWorkerStart)
+                if (policy === 'after-start' && context.waitForWorkerStart)
                     await context.waitForWorkerStart;
-                run.release?.();
+                else if (policy === 'after-terminal') {
+                    if (!context.waitForTerminal)
+                        throw new Error('ChatGPT after-terminal tab close policy requires a terminal event barrier');
+                    await context.waitForTerminal;
+                }
+                if (policy !== 'never')
+                    run.release?.();
                 if (run.submitted)
                     await run.promise;
                 return {
@@ -276,7 +291,8 @@ export class ChatGptAdapter {
             }
             catch (error) {
                 launchReject(error);
-                run.release?.();
+                if (policy !== 'never')
+                    run.release?.();
                 if (controller.signal.aborted)
                     throw error;
                 if (error instanceof StartAckTimeout)

package/dist/cli.js

@@ -90,7 +90,7 @@ Actions:
     'task update': `Update mutable durable task fields in place.
 
 Required: --task-id ID and the normal job storage options.
-Mutable while not RUNNING/SUCCEEDED/CANCELLED: --adapter, --priority, --input, --project, --agent, --parent, --deps, --capabilities, --timeout, --max-attempts, --provider, --model, --profile, --reasoning, --cwd, --chatgpt-project.
+Mutable while not RUNNING/SUCCEEDED/CANCELLED: --adapter, --priority, --input, --project, --agent, --parent, --deps, --capabilities, --timeout, --max-attempts, --provider, --model, --profile, --reasoning, --cwd, --chatgpt-project, --chatgpt-tab-close-policy.
 Use --clear-routing to remove routing metadata. A model update requires --model; provider defaults to the existing provider or openai.
 
 Example:
@@ -226,6 +226,12 @@ function priority(args, fallback = 'P2') { const value = arg(args, '--priority',
     throw new Error('--priority must be P0, P1, P2, or P3'); return value; }
 export function executionMode(args, fallback = 'fixed') { const value = arg(args, '--mode', arg(args, '--execution-mode', fallback)); if (value !== 'fixed' && value !== 'autonomous')
     throw new Error('--mode must be fixed or autonomous'); return value; }
+export function chatGptTabClosePolicy(args) {
+    const value = arg(args, '--chatgpt-tab-close-policy', process.env.AGENTS_RELAY_CHATGPT_TAB_CLOSE_POLICY || 'after-start');
+    if (!['after-start', 'never', 'after-terminal'].includes(value))
+        throw new Error('--chatgpt-tab-close-policy must be after-start, never, or after-terminal');
+    return value;
+}
 function requestedExecutionMode(args) { const value = arg(args, '--mode', arg(args, '--execution-mode')); return value ? executionMode(args) : undefined; }
 function continuation(args) { const kind = arg(args, '--continue-kind'); const target = arg(args, '--continue-target'); return kind && target ? { kind: kind, target, input: arg(args, '--continue-input') || undefined } : null; }
 export async function ensureManagedGitHubJob(client, repositoryName, trustedAuthors, options) {
@@ -276,6 +282,7 @@ function workerTaskFromArgs(job, args, now, requireInput = false) {
     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 };
+    const closePolicy = hasArg(args, '--chatgpt-tab-close-policy') ? chatGptTabClosePolicy(args) : undefined;
     return {
         jobId: job.id,
         id: arg(args, '--task-id', 'initial'),
@@ -286,6 +293,7 @@ function workerTaskFromArgs(job, args, now, requireInput = false) {
         dependencies: arg(args, '--deps').split(',').filter(Boolean),
         capabilities: arg(args, '--capabilities').split(',').filter(Boolean),
         adapter,
+        chatgptTabClosePolicy: closePolicy,
         input: input || 'true',
         output: outputKind === 'file' ? { kind: 'file', path: outputPath } : { kind: 'task_pr' },
         routing,
@@ -337,6 +345,8 @@ async function runTaskCommand(action, args) {
         task.dependencies = arg(args, '--deps').split(',').filter(Boolean);
     if (hasArg(args, '--capabilities'))
         task.capabilities = arg(args, '--capabilities').split(',').filter(Boolean);
+    if (hasArg(args, '--chatgpt-tab-close-policy'))
+        task.chatgptTabClosePolicy = chatGptTabClosePolicy(args);
     task.timeoutMs = integerArg(args, '--timeout', task.timeoutMs);
     task.maxAttempts = integerArg(args, '--max-attempts', task.maxAttempts);
     if (hasArg(args, '--max-attempts') && task.maxAttempts < task.attempt)
@@ -414,7 +424,7 @@ async function runJobCommand(action, args) {
     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 }); }
+export function runtime(store, args, bus) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); const policy = chatGptTabClosePolicy(args); 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({ tabClosePolicy: policy })], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, eventBus: bus, emit, chatgptTabClosePolicy: policy }); }
 export async function createService(args) {
     const loaded = await storeFor(args);
     const upstream = eventBus(args);

package/dist/dashboard.js

@@ -354,6 +354,12 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             throw new Error(`Managed job ${requestedJobId ?? ''} not found`);
         return { id: jobId, json: JSON.stringify(await store.load(jobId)) };
     };
+    const broadcastSnapshots = async (jobIds = []) => {
+        const snapshots = await Promise.all((jobIds.length > 0 ? jobIds : [undefined]).map(requestedJobId => snapshot(requestedJobId)));
+        for (const value of snapshots)
+            for (const client of clients)
+                client.write(`data: ${value.json}\n\n`);
+    };
     const usage = async () => {
         if (!usageRegistry)
             throw new Error('Account usage telemetry is unavailable');
@@ -394,7 +400,13 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             }
             res.writeHead(202);
             res.end('Accepted');
-            queueMicrotask(() => { void webhook.wake(event); });
+            queueMicrotask(() => {
+                void (webhook.refresh ? webhook.refresh(event) : Promise.resolve([]))
+                    .then(jobIds => broadcastSnapshots(jobIds))
+                    .catch(error => process.stderr.write(`warning: webhook dashboard snapshot unavailable: ${error instanceof Error ? error.message : String(error)}\n`))
+                    .then(() => webhook.wake(event))
+                    .catch(error => process.stderr.write(`warning: webhook wake unavailable: ${error instanceof Error ? error.message : String(error)}\n`));
+            });
             return;
         }
         if (new URL(req.url ?? '/', 'http://127.0.0.1').pathname === '/api/jobs') {

package/dist/reconciler.js

@@ -46,13 +46,14 @@ export class Reconciler {
     plannerLive = new Map();
     terminalTimers = new Map();
     continuationLive = new Set();
+    terminalWaiters = new Map();
     reconciling = false;
     constructor(store, options) {
         this.store = store;
         this.options = options;
     }
     async handleEvent(event) {
-        if (['task.completed', 'task.failed', 'task.blocked'].includes(event.type)) {
+        if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type)) {
             await this.applyTerminalEvent(event);
             return;
         }
@@ -306,12 +307,20 @@ export class Reconciler {
         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 } : {};
+        const closePolicy = task.chatgptTabClosePolicy ?? this.options.chatgptTabClosePolicy ?? adapter.tabClosePolicy ?? 'after-start';
+        const terminalWait = task.adapter === 'chatgpt' && closePolicy === 'after-terminal'
+            ? this.terminalWait(task.id, durableExecutionId, startedAt - 1)
+            : null;
+        const launchContext = {
+            ...(startAckSetup ? { waitForWorkerStart: startAckSetup.ack } : {}),
+            ...(terminalWait ? { waitForTerminal: terminalWait.promise } : {}),
+        };
         try {
             execution = adapter.launch(workerTask, controller.signal, launchContext);
         }
         catch (error) {
             await startAckSetup?.stop();
+            terminalWait?.cancel();
             await this.failLaunch(job.id, task.id, task.executionId, error instanceof Error ? error.message : String(error));
             return;
         }
@@ -502,10 +511,15 @@ export class Reconciler {
         const task = job.tasks.find(item => item.id === event.task_id);
         if (!task || !['codex', 'chatgpt'].includes(task.adapter) || task.state !== 'RUNNING')
             return;
+        const terminalWaiter = this.terminalWaiters.get(task.id);
+        if (terminalWaiter && (!event.timestamp || new Date(event.timestamp).getTime() < terminalWaiter.launchBarrier))
+            return;
         this.clearExecution(task.id, task.executionId);
         task.leaseOwner = null;
         task.leaseExpiresAt = null;
         task.updatedAt = event.timestamp || new Date().toISOString();
+        this.terminalWaiters.get(task.id)?.resolve();
+        this.terminalWaiters.delete(task.id);
         if (event.type === 'task.completed') {
             task.result = { summary: event.message || `Task ${task.id} completed`, data: event.data };
             task.error = null;
@@ -523,8 +537,26 @@ export class Reconciler {
             transitionTask(task, 'BLOCKED');
             await this.store.saveTask(task);
         }
+        else if (event.type === 'task.cancelled') {
+            task.error = event.message || `Task ${task.id} cancelled`;
+            transitionTask(task, 'CANCELLED');
+            await this.store.saveTask(task);
+        }
         this.detach(this.reconcile(job.id), job.id, task.id, 'terminal-event reconciliation');
     }
+    terminalWait(taskId, executionId, launchBarrier) {
+        let resolve;
+        const promise = new Promise(resolver => { resolve = resolver; });
+        this.terminalWaiters.set(taskId, { executionId, launchBarrier, resolve });
+        return {
+            promise,
+            cancel: () => {
+                const current = this.terminalWaiters.get(taskId);
+                if (current?.executionId === executionId)
+                    this.terminalWaiters.delete(taskId);
+            },
+        };
+    }
     async deliverContinuation(job, task) {
         const continuation = task.continuation ?? job.continuation;
         if (!continuation || task.continuationDeliveredAt || this.continuationLive.has(task.id))

package/dist/relayd.js

@@ -121,16 +121,22 @@ export async function runDaemon(argv) {
     const webhook = secret ? {
         secret,
         repositories: new Set(repositories),
+        refresh: async (event) => {
+            if (!event.repository || !event.pullRequest)
+                return [];
+            const refreshed = await refreshPullRequest(event.repository, event.pullRequest);
+            return refreshed.map(item => item.job.id);
+        },
         wake: async (event) => {
             if (!event.repository || !event.pullRequest)
                 return;
             try {
-                const refreshed = await refreshPullRequest(event.repository, event.pullRequest);
+                const refreshed = cachedOverviews.filter(item => item.job.repository === event.repository && item.job.prNumber === event.pullRequest);
                 for (const item of refreshed)
                     await pool.webhookWake(bus, item.job, event.deliveryId, event.event, event.action);
             }
             catch (error) {
-                process.stderr.write(`warning: webhook PR refresh unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
+                process.stderr.write(`warning: webhook wake unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
             }
         }
     } : undefined;

package/dist/store.js

@@ -83,7 +83,7 @@ function immutableTaskDefinition(task) {
     return {
         jobId: task.jobId, id: task.id, priority: task.priority, projectName: task.projectName, agentName: task.agentName,
         kind: task.kind ?? 'work', parentTaskId: task.parentTaskId, dependencies: task.dependencies, capabilities: task.capabilities, adapter: task.adapter,
-        input: task.input, output: task.output, routing, continuation: task.continuation ?? null, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs
+        input: task.input, output: task.output, routing, chatgptTabClosePolicy: task.chatgptTabClosePolicy ?? 'after-start', continuation: task.continuation ?? null, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs
     };
 }
 function sameTaskDefinition(left, right) {

package/package.json

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

package/skills/agents-relay/SKILL.md

@@ -78,7 +78,7 @@ The job/task descriptions remain the durable source of intent. Adapters do not i
 
 ## ChatGPT worker
 
-The ChatGPT adapter uses the packaged `chatgpt-browser-worker` one-shot path. It opens a fresh Temporary Chat tab, submits the complete task with the account defaults, verifies acceptance, closes the owned tab, and returns a submission receipt.
+The ChatGPT adapter uses the packaged `chatgpt-browser-worker` one-shot path. It opens a fresh Temporary Chat tab, submits the complete task with the account defaults, verifies acceptance, applies the configured `after-start` (default), `never`, or `after-terminal` owned-tab close policy, and returns a submission receipt.
 
 ChatGPT thread identity is diagnostic only. It is not persisted as a resumable task handle, and Relay does not poll, resume, retrieve a result from, or delete a ChatGPT conversation as part of task lifecycle.
 

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

@@ -48,12 +48,14 @@ 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, 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 complete task, verifies that ChatGPT accepted the submission, and applies
+the configured tab-close policy. `after-start` waits for the exact
+post-submission worker `task.started` acknowledgement, `never` leaves the owned
+tab open for debugging, and `after-terminal` waits for a new exact-task
+`task.completed`, `task.failed`, `task.blocked`, or `task.cancelled` event.
+ChatGPT continues the task independently and publishes the result through the
+declared output contract. If the start 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,11 +28,13 @@ 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, 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.
+- Once submission is verified, follow the configured owned-tab close policy:
+  `after-start` closes after a new worker-owned `task.started` event, `never`
+  leaves the owned tab open for test/debug use, and `after-terminal` closes only
+  after a new exact-task `task.completed`, `task.failed`, `task.blocked`, or
+  `task.cancelled` event. Never close a user tab. Do not wait for the assistant
+  response or reopen/poll the conversation. If the start acknowledgement does
+  not arrive within 60 seconds, close only the owned tab and report a 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

@@ -9,6 +9,7 @@ from browser_harness import *
 
 CFG = json.load(open("__CFG_PATH__", encoding="utf-8"))
 _OWNED_TABS = []
+_KEEP_OWNED_TAB_OPEN = CFG.get("close_policy", "after-start") == "never"
 
 
 def _new_owned_tab(url):
@@ -21,6 +22,8 @@ def _new_owned_tab(url):
 
 
 def _close_owned_tabs():
+    if _KEEP_OWNED_TAB_OPEN:
+        return
     while _OWNED_TABS:
         try:
             close_tab(_OWNED_TABS.pop())
@@ -185,8 +188,7 @@ print(json.dumps({
 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):
+if CFG.get("close_policy", "after-start") == "never":
+    raise SystemExit(0)
+while 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

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