agents-relay 1.0.5 → 1.0.7

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

@@ -1,102 +1,62 @@
 ---
 name: chatgpt-browser-worker
-description: Manage ChatGPT work threads through the authenticated browser-harness session, including Project selection, thinking-level requests, durable thread identity, resume/status/result retrieval, and cleanup.
+description: Submit an isolated one-shot ChatGPT browser worker task through browser-harness with a required durable output destination.
 ---
 
 # ChatGPT browser worker
 
-This skill is the browser-backed ChatGPT worker contract for Neo. It uses the
-existing `browser-harness` command as its only browser interaction layer. It
-does not use the MacBridge ChatGPT runtime, ChatGPT APIs, copied cookies, or a
-second browser automation stack.
-
-## Capability contract
-
-The worker boundary exposes these lifecycle operations:
-
-```text
-create(project, prompt, thinking_level) -> ThreadState
-resume(thread_id, project)             -> ThreadState
-status(thread_id)                      -> StatusObservation
-result(thread_id)                      -> ThreadResult
-delete(thread_id)                      -> DeletedThreadState
-```
-
-`project.name` is required when creating or resuming a thread. `project.id` is
-optional because the UI may not expose it at every boundary. The adapter must
-select and verify that Project before sending the first prompt. A resumed
-thread keeps its recorded Project identity; callers cannot silently move it to
-another Project.
-
-Thinking levels are split into `requested_thinking_level` and
-`effective_thinking_level`. Requested values are `default`, `low`, `medium`,
-and `high`; effective values may additionally be `unknown`. `default` leaves
-the account's current/default setting unchanged. The adapter must preserve
-`unknown` rather than guessing from a label or silently downgrading a request.
-
-## Durable identity and state
-
-Persist the returned state after every successful lifecycle transition. The
-durable key is the ChatGPT `thread_id`; a URL, title, or browser tab index is
-not an identity. Records retain a deleted thread as a tombstone so a stale
-caller cannot recreate or accidentally reuse it. The complete JSON schema and
-valid transition table are in [references/contract.md](references/contract.md).
-
-Pure validation and transition helpers live in `scripts/contract.py`, with
-focused tests in `tests/test_contract.py`. The browser-harness driver is
-intentionally injected through the semantic port described in the reference;
-the contract layer does not import or launch `browser-harness`.
-Run `python3 -m pytest skills/chatgpt-browser-worker/tests` from the repository
-root.
-
-For the Neo/Leo and Agents Relay handoff—task IDs, run-local state, event
-ownership, and the create/resume/result/delete invocation sequence—see
-[references/orchestration.md](references/orchestration.md). The outer
-orchestrator may use MacBridge as a transport, but this worker never treats
-MacBridge as the ChatGPT runtime.
-
-The runtime entry point is the
-[browser-worker agent](agents/browser-worker.agent.md). Callers launch that
-agent with a typed lifecycle intent; they must not directly call
-`create_bh.py` or `operate_bh.py`. Those scripts are helper implementations
-that the agent may use, repair, or bypass while preserving this skill's
-browser-harness and verification contract.
-
-The browser-worker agent's `create` intent starts a new ChatGPT chat when the
-attached tab is already a conversation and emits JSON with the observed
-`thread_id`, conversation URL, selected Project, and thinking observation.
-`scripts/create_bh.py` is only a helper for that agent, not a caller-facing
-runtime contract.
-
-For implementation/debugging, the agent may use the helper equivalent for an
-existing thread with the durable identity from persisted state:
-
-```text
-python3 scripts/operate_bh.py resume --thread-id ID --project NAME
-python3 scripts/operate_bh.py continue --thread-id ID --project NAME --prompt TEXT
-python3 scripts/operate_bh.py status --thread-id ID --project NAME
-python3 scripts/operate_bh.py result --thread-id ID --project NAME
-python3 scripts/operate_bh.py delete --thread-id ID --project NAME
-```
-
-Each command performs one serial browser-harness operation. The injected
-semantic adapter in `scripts/operations.py` is the testable boundary; it does
-not import MacBridge or a ChatGPT runtime API.
-
-## Verification boundary
-
-The worker may report `completed` only from an observed assistant message and
-normalized result. A process exit, click, URL change, or tab title alone is not
-proof that a thread was created, resumed, completed, or deleted. Authentication
-walls, MFA, consent, ambiguous account/project selection, and unverified
-thinking levels are `blocked` or `failed` conditions and must not be
-self-healed.
-
-Delete targets the exact durable conversation URL, requires an observed action
-and confirmation, and verifies that the requested thread is no longer visible.
-Repeated cleanup is idempotent (`not_found` is accepted); archive/undo UI
-controls are evidence only and never revive a deleted tombstone.
-
-Keep credentials, prompts containing private data, and browser runtime state
-out of durable state and events. Runtime artifacts belong under the caller's
-ignored `runs/` directory.
+Use this skill to hand one self-contained task to ChatGPT through the authenticated
+browser session. The caller does not manage ChatGPT threads, model selection,
+thinking level, polling, or result retrieval.
+
+## Output contract
+
+Every task handed to this worker MUST declare exactly one durable output mode
+before the worker is launched.
+
+### 1. Task / PR output
+
+Use this for repository or managed-task work.
+
+The task prompt must identify the exact managed task/PR that owns the result.
+The worker performs the requested work directly against that task/PR and records
+its final outcome there.
+
+Output:
+task/PR
+<exact managed task/PR identity and required final action>
+
+### 2. File output
+
+Use this for research, analysis, reports, or other artifact-producing work.
+
+The task prompt must name the exact file path. That file is the authoritative
+result.
+
+Output:
+file
+<exact file path>
+
+A Browser ChatGPT worker task without one of these output declarations is
+invalid and must not be launched. The orchestrator chooses and writes the output
+contract when it creates the worker task; the worker must not invent or change
+the destination.
+
+Progress and terminal success/failure are always reported through the normal
+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 worker must never interact through a pre-existing user ChatGPT tab.
+Browser details, transient conversation identity, submission verification,
+model/default-thinking behavior, and tab cleanup are implementation concerns of
+the worker and are not part of the caller-facing contract.
+
+The runtime entry point is the browser-worker agent. Callers launch that agent
+with the complete task prompt and declared output; they do not call helper
+scripts directly.

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

@@ -1,113 +1,42 @@
 ---
 name: browser-worker
-description: Execute the ChatGPT browser-worker lifecycle through browser-harness while preserving verified thread and Project identity.
+description: Submit one isolated ChatGPT browser task and return after the task is accepted.
 type: worker
 ---
 
 # Browser Worker Agent
 
-You are the runtime owner for the `chatgpt-browser-worker` skill. Before doing
-any work, load and follow both this skill and the `browser-harness` skill. The
-outer adapter launches you with one typed lifecycle request; Agents Relay
-owns task correlation, retries, events, and run-local persistence, but does
-not own browser execution.
+You are the runtime owner for the `chatgpt-browser-worker` skill. Load and follow
+that skill and the `browser-harness` skill before execution.
 
-## Runtime rules
-
-- Use `browser-harness` for every browser interaction. Do not use another
-  browser stack, ChatGPT API, MacBridge ChatGPT runtime, copied cookies, or
-  direct HTTP calls to ChatGPT.
-- Preserve the exact observed ChatGPT `thread_id` and Project identity. A URL,
-  title, tab index, or inferred conversation is not an identity. A resumed
-  thread must remain in its recorded Project; reject a mismatch.
-- Treat the scripts in `scripts/` as helpers only. You may use, repair, or
-  bypass `create_bh.py` and `operate_bh.py` when they are brittle, but preserve
-  the skill contract and its evidence requirements.
-- When a selector, layout, label, or ordinary UI flow changes, re-observe the
-  current page through `browser-harness`, identify the semantic control, and
-  adapt the operation. Do not guess from stale selectors or coordinates.
-- Stop with `blocked` for authentication, MFA, consent, ambiguous account or
-  Project selection, or any human decision. Do not bypass these gates.
-- Stop with `blocked` or `failed` when the result cannot be verified. A process
-  exit, URL change, tab title, prior assistant bubble, or synthetic message ID
-  is not completion evidence.
-- Return only observations from the current browser state and persist the last
-  known `thread_id` when an operation fails after creation.
-
-## Typed adapter contract
-
-The input is one JSON object. `operation` must be one of `create`, `resume`,
-`continue`, `status`, `result`, or `delete`.
-
-```json
-{
-  "operation": "create",
-  "thread_id": null,
-  "project": {"name": "neo", "id": "project-optional"},
-  "prompt": "Run the assigned task.",
-  "thinking_level": "high",
-  "state": null
-}
-```
+The outer orchestrator gives you one complete task. That task MUST already
+contain exactly one output declaration defined by the skill:
 
-Input requirements:
+- `task/PR` with the exact managed task/PR identity and required final action; or
+- `file` with the exact authoritative output path.
 
-- `create`: requires `project.name`, `prompt`, and `thinking_level`.
-- `resume`: requires `thread_id` and `project.name`; verify the recorded
-  Project before any other thread action.
-- `continue`: requires `thread_id`, `project.name`, and `prompt`; open and
-  verify the exact thread before sending the follow-up.
-- `status`, `result`, and `delete`: require the durable `thread_id`; use the
-  persisted `state` when supplied and never recreate a missing identity.
-- `thinking_level` is `default`, `low`, `medium`, or `high`; preserve an
-  observed effective value of `unknown` instead of guessing.
+If the output declaration is missing or ambiguous, do not invent one.
 
-The output is one JSON object suitable for an outer adapter:
-
-```json
-{
-  "operation": "result",
-  "status": "completed",
-  "thread_id": "chatgpt-conversation-id",
-  "project": {"name": "neo", "id": "project-id"},
-  "result": {
-    "message_id": "observed-assistant-message-id",
-    "text": "The normalized assistant answer.",
-    "verified": true,
-    "observed_at": "2026-09-19T12:02:00Z"
-  },
-  "state": {
-    "schema_version": 1,
-    "thread_id": "chatgpt-conversation-id",
-    "status": "completed",
-    "project": {"name": "neo", "id": "project-id"}
-  },
-  "error": null
-}
-```
-
-Every response must include `operation`, `status`, and the exact
-`thread_id` when one is known. A successful `result` response must include an
-observed assistant `message_id`, non-empty normalized `text`, and
-`result.verified: true`. `status` is not a result and must not claim
-completion. For `delete`, return a verified `deleted` or idempotent verified
-`not_found` observation and retain a terminal `deleted` tombstone.
-
-For blocked or failed operations, return the last known identity and a typed
-error without credentials or private prompts:
-
-```json
-{
-  "operation": "resume",
-  "status": "blocked",
-  "thread_id": "chatgpt-conversation-id",
-  "error": {
-    "code": "authentication_required",
-    "message": "Sign-in or MFA requires user action.",
-    "retryable": false
-  }
-}
-```
+## Runtime rules
 
-Do not report success until the relevant browser observation has been
-validated against [../references/contract.md](../references/contract.md).
+- Use `browser-harness` for every ChatGPT browser interaction.
+- Execute only a one-shot submission. Do not expose or operate a
+  create/resume/status/result/continue lifecycle for callers.
+- Always create a fresh worker-owned tab. Never type, upload, click New chat,
+  select a Project, or submit through a pre-existing user ChatGPT tab.
+- Use Temporary Chat and the account's existing default model/thinking
+  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.
+- 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
+  reported through the normal Neo event contract by the executing task. The
+  final durable result goes to the declared task/PR or file output.
+- Stop on authentication, MFA, consent, or ambiguous browser state rather than
+  bypassing it.
+
+Helper scripts under `scripts/` are implementation details. Callers must not
+invoke them directly.

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

@@ -0,0 +1,171 @@
+import atexit
+import json
+import os
+import re
+import time
+
+from browser_harness import *
+
+
+CFG = json.load(open("__CFG_PATH__", encoding="utf-8"))
+_OWNED_TABS = []
+
+
+def _new_owned_tab(url):
+    target_id = cdp("Target.createTarget", url="about:blank", background=True)["targetId"]
+    switch_tab(target_id)
+    _OWNED_TABS.append(target_id)
+    if url != "about:blank":
+        goto_url(url)
+    return target_id
+
+
+def _close_owned_tabs():
+    while _OWNED_TABS:
+        try:
+            close_tab(_OWNED_TABS.pop())
+        except Exception:
+            pass
+
+
+atexit.register(_close_owned_tabs)
+
+
+def _composer():
+    selector = js("""(() => {
+      const preferred = document.querySelector('#prompt-textarea');
+      if (preferred) {
+        const r=preferred.getBoundingClientRect();
+        if (r.width>0 && r.height>0) return '#prompt-textarea';
+      }
+      const fallback = [...document.querySelectorAll('textarea,[contenteditable="true"]')]
+        .find(e => { const r=e.getBoundingClientRect(); return r.width>0 && r.height>0 && !e.disabled; });
+      if (!fallback) return null;
+      return fallback.tagName === 'TEXTAREA' ? 'textarea' : '[contenteditable="true"]';
+    })()""")
+    if not selector:
+        raise RuntimeError("Temporary Chat composer was not observed")
+    return selector
+
+
+def _composer_text(selector):
+    return js(f"""(() => {{
+      const e=document.querySelector({json.dumps(selector)});
+      return e ? ((e.innerText ?? e.value) || '') : '';
+    }})()""") or ""
+
+
+def _attachment_names():
+    return js(r"""(() => [...document.querySelectorAll('button[aria-label^="Remove file"]')]
+      .map(b => (b.getAttribute('aria-label') || '').replace(/^Remove file\s+\d+:\s*/, ''))
+      .filter(Boolean))()""") or []
+
+
+def _upload_files(paths):
+    if not paths:
+        return []
+    selector = js("""(() => {
+      for (const s of ['#upload-files','#upload-media','input[name="upload-media"]','input[type="file"]'])
+        if (document.querySelector(s)) return s;
+      return null;
+    })()""")
+    if not selector:
+        raise RuntimeError("ChatGPT file input was not observed")
+    for path in paths:
+        if not os.path.isfile(path):
+            raise RuntimeError(f"attachment does not exist: {path}")
+        upload_file(selector, path)
+        expected = os.path.basename(path)
+        deadline = time.time() + 20
+        while time.time() < deadline and expected not in _attachment_names():
+            time.sleep(.25)
+        if expected not in _attachment_names():
+            raise RuntimeError(f"attachment was not observed ready: {expected}")
+    return [os.path.basename(path) for path in paths]
+
+
+def _user_turns():
+    return js("""(() => [...document.querySelectorAll('[data-message-author-role="user"]')]
+      .map(e => ({text:e.innerText.trim(), id:e.getAttribute('data-message-id') || ''}))
+      .filter(e => e.text))()""") or []
+
+
+def _click_send():
+    ok = js("""(() => {
+      const b=document.querySelector('button[data-testid="send-button"],button[aria-label="Send prompt"]');
+      if (!b || b.disabled || b.getAttribute('aria-disabled') === 'true') return false;
+      b.click(); return true;
+    })()""")
+    if not ok:
+        raise RuntimeError("Temporary Chat Send prompt button was not observed ready")
+
+
+def _wait_user_turn(before_count, prompt, timeout=20):
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        turns = _user_turns()
+        if len(turns) > before_count and prompt.strip() in turns[-1]["text"]:
+            return turns[-1]
+        time.sleep(.25)
+    raise RuntimeError("Temporary Chat prompt did not become an observed user turn")
+
+
+def _diagnostic_thread_id():
+    match = re.search(r"/c/([^/?#]+)", page_info().get("url", ""))
+    return match.group(1) if match else None
+
+
+_new_owned_tab("https://chatgpt.com/")
+wait_for_load()
+
+enabled = js("""(() => {
+  const matches=[...document.querySelectorAll('button')].filter(
+    b => (b.getAttribute('aria-label') || '').trim() === 'Temporary chat'
+  );
+  if (matches.length !== 1) return false;
+  matches[0].click();
+  return true;
+})()""")
+if not enabled:
+    raise RuntimeError("Temporary Chat toggle was not uniquely observed")
+
+deadline = time.time() + 20
+while time.time() < deadline:
+    if "temporary-chat=true" in page_info().get("url", ""):
+        try:
+            _composer()
+            break
+        except RuntimeError:
+            pass
+    time.sleep(.25)
+else:
+    raise RuntimeError("Temporary Chat mode did not become ready")
+
+attachments = _upload_files(CFG.get("file", []))
+selector = _composer()
+before_count = len(_user_turns())
+fill_input(selector, CFG["prompt"], clear_first=True)
+if CFG["prompt"].strip() not in _composer_text(selector):
+    info = js(f"""(() => {{
+      const e=document.querySelector({json.dumps(selector)});
+      const r=e.getBoundingClientRect();
+      return {{x:r.x+r.width/2,y:r.y+r.height/2}};
+    }})()""")
+    click_at_xy(info["x"], info["y"])
+    press_key("CTRL+A")
+    type_text(CFG["prompt"])
+if CFG["prompt"].strip() not in _composer_text(selector):
+    raise RuntimeError("Temporary Chat prompt was not observed in the composer")
+
+_click_send()
+user_turn = _wait_user_turn(before_count, CFG["prompt"])
+
+print(json.dumps({
+    "operation": "submit",
+    "status": "submitted",
+    "temporary": True,
+    "attachments": attachments,
+    "diagnostic_thread_id": _diagnostic_thread_id(),
+    "user_message_id": user_turn.get("id") or None,
+    "verified": True,
+}, ensure_ascii=False))

package/skills/chatgpt-browser-worker/scripts/{create_bh.py → temporary_bh.py}

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Create one ChatGPT thread using the authenticated browser-harness session."""
+"""Submit one isolated Temporary Chat task through browser-harness."""
 from __future__ import annotations
 
 import argparse
@@ -9,23 +9,20 @@ import subprocess
 import tempfile
 
 
-BH_SCRIPT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_create_bh.py")
+BH_SCRIPT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_temporary_bh.py")
 
 
 def main() -> int:
     parser = argparse.ArgumentParser()
-    parser.add_argument("--project", required=True)
     parser.add_argument("--prompt", required=True)
-    parser.add_argument("--thinking-level", choices=("default", "low", "medium", "high"), default="default")
+    parser.add_argument("--file", action="append", default=[])
     args = parser.parse_args()
-    config = {"project": {"name": args.project}, "prompt": args.prompt, "thinking_level": args.thinking_level}
     with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as handle:
-        json.dump(config, handle, ensure_ascii=False)
+        json.dump(vars(args), handle, ensure_ascii=False)
         config_path = handle.name
     try:
         code = open(BH_SCRIPT, encoding="utf-8").read().replace("__CFG_PATH__", config_path)
-        result = subprocess.run(["browser-harness"], input=code, text=True, timeout=180)
-        return result.returncode
+        return subprocess.run(["browser-harness"], input=code, text=True, timeout=180).returncode
     finally:
         os.unlink(config_path)
 

package/skills/chatgpt-browser-worker/references/contract.md

@@ -1,132 +0,0 @@
-# ChatGPT browser-worker contract
-
-This document is the stable boundary between Neo orchestration and a
-`browser-harness` adapter. It is intentionally independent of ChatGPT's DOM,
-URL layout, or internal network calls.
-
-## Requests
-
-All requests contain an operation and no credentials:
-
-```json
-{
-  "operation": "create",
-  "project": {"name": "neo", "id": "project-optional"},
-  "prompt": "Run the assigned task.",
-  "thinking_level": "high"
-}
-```
-
-`create` requires `project.name`, `prompt`, and `thinking_level`.
-`resume` requires `thread_id` and `project`; its thinking level is optional and
-defaults to the persisted request. `status`, `result`, and `delete` require
-only `thread_id`.
-
-Allowed requested thinking levels are `default`, `low`, `medium`, and `high`.
-The adapter may expose a current UI label in an observation, but it must map it
-to one of these values or `unknown` rather than guessing.
-
-## Durable thread state
-
-The state file is the only persisted worker identity. It may look like:
-
-```json
-{
-  "schema_version": 1,
-  "thread_id": "chatgpt-conversation-id",
-  "conversation_url": "https://chatgpt.com/c/chatgpt-conversation-id",
-  "project": {"id": "project-id", "name": "neo"},
-  "status": "awaiting_result",
-  "requested_thinking_level": "high",
-  "effective_thinking_level": "high",
-  "created_at": "2026-09-19T12:00:00Z",
-  "updated_at": "2026-09-19T12:01:00Z",
-  "last_error": null
-}
-```
-
-Required fields are `schema_version`, `thread_id`, `project.name`, `status`,
-`requested_thinking_level`, and `effective_thinking_level`. `project.id` and
-`conversation_url` are optional because the UI may not expose them at every
-boundary, but the adapter must preserve them when observed.
-
-The only valid statuses are:
-
-| Status | Meaning |
-| --- | --- |
-| `created` | identity exists; no prompt has been sent yet |
-| `running` | a prompt was sent and work is in progress |
-| `awaiting_result` | the UI indicates a response may be read |
-| `completed` | an assistant result was observed and normalized |
-| `failed` | the operation failed; recovery may resume this identity |
-| `blocked` | human/authentication/ambiguity decision is required |
-| `deleted` | cleanup was verified; identity must not be reused |
-
-Valid transitions are:
-
-```text
-create -> created -> running -> awaiting_result -> completed
-                                      |              |
-                                      +-> failed     +-> running (follow-up)
-any live state -> blocked
-any live state -> deleted  (only after verified cleanup)
-failed/blocked -> running  (only after an explicit recovery operation)
-```
-
-`deleted` is terminal. A new conversation gets a new `thread_id`.
-
-## Results
-
-```json
-{
-  "thread_id": "chatgpt-conversation-id",
-  "status": "completed",
-  "text": "The assistant's normalized final answer.",
-  "message_id": "observed-message-id",
-  "observed_at": "2026-09-19T12:02:00Z"
-}
-```
-
-`text` is required only for `completed`. Partial or streaming text is not a
-completed result. A result with no observed assistant message is an error, not
-success.
-
-## Browser adapter port
-
-The adapter is tested through a fake port with these semantic calls:
-
-```text
-select_project(project) -> observed_project
-open_thread(thread_id) -> observed_thread
-set_thinking_level(level) -> observation
-send_prompt(prompt) -> observation
-read_status() -> status_observation
-read_result() -> result_observation
-delete_thread() -> cleanup_observation
-```
-
-`cleanup_observation` must contain the requested `thread_id` (or omit it only
-when the browser has verified the thread is absent), `outcome` equal to
-`deleted` or `not_found`, and `verified: true`. `not_found` is a successful
-idempotent retry. Archive/undo controls may be reported as observational
-metadata, but they do not turn a delete into a recoverable state: a deleted
-tombstone remains terminal and must never be reused.
-
-These names describe the boundary, not a required Python class or browser
-selector implementation. Each call must return observed values or a typed
-failure. The contract layer must remain usable with a fake port and must not
-import or launch `browser-harness` itself.
-
-## Testable safety boundaries
-
-- no request can omit the Project on `create` or `resume`;
-- Project IDs are compared when both browser boundaries expose them; a
-  name-only observation remains valid because the UI may hide opaque IDs;
-- no state can omit a non-empty `thread_id` or valid status;
-- `resume` rejects an observed Project mismatch;
-- requested and effective thinking levels are distinct fields;
-- unknown effective level stays `unknown`;
-- only an observed assistant message yields `completed`;
-- delete is terminal and cannot be followed by resume;
-- browser, login, and ambiguity failures preserve the thread identity and are
-  classified as `failed` or `blocked`.