Pro browser procedure (Jev send, deterministic observation, WSL host)

Authority: docs/project/OPERATING_CONSTITUTION.md section 5. The assignment, the target
check before sending, the delivery reading (step 5) and the return facts are those of
hmasd-chatgpt-pro-transport; this skill replaces only the browser route. Use it on the WSL
host. The Windows host keeps Agentify.

Jev performs the interactive browser send: it observes the page as an indexed element table and chooses
each operation and target. The driver tools/pro_transport/jev_send.py hands Jev the committed
text verbatim (no model writes or paraphrases it), keeps the books, and guards one click: the
send click is refused unless the effort pill shows the configured label and the box equals the
committed prompt. send_attempted is persisted before that click. Settings are [jev] in
.codex/hmasd-transport.toml; Jev's credentials stay in its own ignored .env (the native
TypeSafe key is preferred; the Vercel gateway key rate-limits).

Account. This is a different ChatGPT account from the Agentify one. A conversation URL
recorded from the other account does not exist here: send with --conversation new, or with a
URL this account returned. Never paste an Agentify-account URL into this route.

Model and fallback (owner, 2026-09-27). Independent scientific review at constitution
section 5 decision points goes to ChatGPT 6 Pro on this account; 5.6 Pro on the same account is the
fallback when the 6 Pro quota is short. Both reach the repository through the same GitHub
connector, so the committed question is identical for either model and is never rewritten for the
fallback. The driver proves the configured effort_label (6 Pro) before the one click. Fall back
only on a concrete signal — a usage-limit banner, a disabled or missing 6 Pro entry, or a
PreSendFailure naming the model menu with the page otherwise healthy — by rerunning the same key
with --effort "5.6 Pro" (fallback_effort_label in [jev]); send_attempted still guards against
a second submission. The first fallback use is a --dry-run: the modern-menu proof was written
against the 6 Pro picker, and if it refuses the fallback label the proof is extended from the
observed menu (radio labels, toggle text, slider) with a test in tests/skills/test_jev_transport.py,
never from a guessed layout. Record which model answered in the NOTES answer header (model label
only; account facts stay local). A critic specification, when the question is a review, travels
inside the attached document like any other section.

Private facts stay local (owner, 2026-09-18). This account's conversation URLs, its name
and anything else identifying it live only in the driver's state directory
(~/.local/state/hmasd-pro-transport/operations/<key>.json), never in NOTES.md, RESEARCH.md,
a change note, a commit message or anything else that is pushed. Shared records name a
question by its key; the URL for a follow-up is read from the local operation file.

Steps

Interpreter: ~/test/Jev/jev-ultrafast/.venv/bin/python (written $JEV below), never an HMASD
venv, and nothing is installed into either. $D is tools/pro_transport/jev_send.py. Output
never prints the conversation address unless --show-url is given.

1. Key. $JEV $D key --repository … --branch … --subject … --source-sha … --target-path … --question-heading …
   prints the question key (hmasd: plus the SHA-256 of that JSON array, as in the old skill).

2. Compose. Save the author's complete message, unchanged, to a file and run
   $JEV $D compose --message-file <file> --slug <slug> --subject <direction>. It writes
   temp/pro_transport/hmasd-pro-question-<slug>.md (the complete message) and
   <slug>.short.txt (a brief request to read it, write the assigned Answer, or provide the
   complete reply in chat if GitHub writeback is unavailable). Digests stay in local transport
   metadata, outside the visible cover note. The complete question reaches Pro unchanged;
   the driver compares the prepared text and attachment before sending.

3. Send once, headless by default.
   $JEV $D send --key <key> --prompt-file <short> --attach <document> --conversation new|<url>
   starts the headless Chrome on the logged-in profile if none runs, sets the effort slider to
   its top position (6 Pro; a slider is outside Jev's action space, so arrow keys set it and
   the observed pill label is the fact) and empties a restored draft. Jev types; only when the
   box equals the short message does the driver give the document to the composer's own upload
   input (uploads are outside Jev's action space too, and a typing failure then leaves no stray
   copy in the account's file store), wait until the send button is enabled again (it is
   disabled while the file is processed, and a disabled control is not in Jev's element table),
   and let Jev click it. Before each decision the driver states the one fact Jev cannot see:
   whether the box already holds the prepared message. --dry-run does all of that and
   withholds the click: use it after a provider UI change, it costs no Pro request.
   --mode headed shows the window; use it only when a human must look (login, CAPTCHA) and
   stop the other mode first with chrome stop. HMASD_JEV_DEBUG=1 traces what Jev saw and
   chose at each step. Read the result:

   • {"error": ..., "pre_send": true}: nothing was submitted. Repair the named fact and run
     the same command with the same key.
   • send_attempted: true: from here on observe only. send_effect is sent when the exact
     message was seen in the conversation, otherwise uncertain with unresolved.
   • Running send again under an attempted key never sends; it returns the stored operation.

4. Wait and collect from the existing conversation without a waiting subagent. Once Send is
   accepted, Pro continues server-side; reopening Chrome does not restart the request. In Codex,
   save this JSON in task-local private scratch as /absolute/path/to/request.json, substituting
   real absolute paths, then arm the repository controller and end the turn:

   {
     "jobs": [{
       "id": "pro-<key>",
       "protocol": "pro",
       "argv": ["/absolute/path/to/jev-python", "/absolute/repository/tools/pro_transport/jev_send.py", "wait", "--key", "<key>", "--answer-file", "/absolute/path/to/answer.txt", "--timeout", "{window_seconds}"],
       "cwd": "/absolute/repository",
       "interval": 30,
       "timeout": 20
     }]
   }

   python tools/hmasd_wait.py arm --request /absolute/path/to/request.json --window 1500

   The controller is standard-library only. The passive browser observer uses CDP/WebSocket
   state and does not import Jev, use Jev credentials or ask a model to judge completion. The
   existing driver invokes Jev lazily only if an authorized connector-consent interaction is
   actually required. The generic wait controller does not depend on the probe interpreter or
   browser implementation named in a job. On Claude, run the underlying deterministic observer
   outside the model turn and return by the native runtime or a manual continuation; do not run
   the Codex-only controller or assume Codex queue can wake Claude.

   On wake, python tools/hmasd_wait.py drain returns the generation, wake id, stable event ids
   and jobs. COMPLETE means the answer was collected, not that repository delivery succeeded.
   Run step 5. If a bounded checkpoint reports the job still active, rearm the same generation
   and event ids with
   python tools/hmasd_wait.py rearm --generation <N> --wake-id <ID> --event-ids <ID>...;
   pass --resume-jobs <job-id>... only for explicitly resolved blocked jobs. Never restart the
   request or run send again. stop records observation_stop_requested and cancels only the
   waiter's owned probe; cancellation begins on the next short supervisor tick and allows a brief
   TERM grace period. The Pro request and other observed work remain unchanged. The default 1500-second window
   reserves delivery time so the queue event can arrive within the requested bound. Completion
   saves chat text even when GitHub could not write;
   a hash mentioned in a reply is not evidence of delivery. Step 5 checks actual writeback.
   Connector consent (owner, 2026-09-19). When the page shows "Allow GitHub for this
   conversation", Jev answers it with "始终允许" (Always allow); the owner authorised this for the
   GitHub connector, as needed for engineering collaboration (approval_policy,
   approval_connectors in [jev]). The driver executes that one click only on a prompt that
   names a listed connector and records it under approvals. A prompt for any other connector,
   or any other consent, returns NEEDS_HUMAN: report it to the owner and click nothing.
   If the send could not observe the settled address (a new conversation first shows a
   provisional /c/WEB: address that cannot be reopened), find the conversation and pass
   --conversation-url. Apart from that consent, nothing here clicks.

5. Read delivery, not the receipt.
   $JEV $D deliver --key <key> --branch … --source-sha … --target-path … --question-heading … --answer-out <path>
   fetches the branch and finds the commit that filled this question's ### Answer. DELIVERED
   means exactly one such commit, touching only the target file, with the question and every
   other byte unchanged and the subsection empty before; unrelated later commits do not count.
   CONFLICT lists what differs: preserve both versions and report, never choose silently.
   NOT_DELIVERED with a "chat answer" saved in step 4 means the author inserts that text,
   noted "saved from chat"; with only a receipt it is answer unavailable.

6. Return. Question key (the conversation address stays in the local operation file), send
   effect, completion state, delivery state with the answer commit or the saved text path and
   hash, target and headings, unresolved facts. Close only the operation's tab. Leave the headless
   Chrome running between questions; chrome stop ends it.

Recovery

After an accepted Send, recovery means observing the same conversation and checking whether
Pro is still thinking or has finished. Rearm the same wait job with the existing key; do not resend the
question because Chrome closed or a local wait timed out. Authentication or an error that
prevents reading is reported with its concrete cause. Leave normal recovery to the driver.

Only a genuine pre-send failure may retry the original key and text. For an uncertain Send,
reconcile --key <key> is the existing read-only check: it releases the key once only when no
settled conversation was recorded and the exact text is still the unsent new-chat draft.
This exception does not apply to an accepted conversation. A second uncertain attempt is
reported to the DM. Private conversation URLs remain in local operation files.

Verified 2026-09-19: one real direction question sent headless as short message plus document,
consent answered by Jev, the 21 000-character answer written by Pro into the repository and
confirmed by deliver; after the reordering, a dry run reached the send button in two Jev steps. Verified 2026-09-18 on the WSL host: one headed and one headless test question, each typed and
sent by Jev in two steps, completed and read back exactly; a repeated send under the same key
did not send.