chatgpt-pro-browser

name	chatgpt-pro-browser
description	Use the operator's already-authenticated ChatGPT browser session through Computer Use to run or resume GPT-5.6 Pro reasoning, capture deliverables, maintain a private resumable session artifact, and hand the work back to Codex. Use when a user asks Codex to use ChatGPT Pro, GPT-5.6 Pro, a Pro browser conversation, continue a Pro run, or hand reasoning between ChatGPT Pro and Codex.

ChatGPT Pro browser

Treat the live ChatGPT conversation as truth. Treat the local session artifact as a pointer plus Codex-authored claims that must be reconciled against the browser on every resume.

Load the supported browser surface

Read and follow the current bundled computer-use skill completely before any browser action. Use its supported browser runtime for every interaction. If that skill, its runtime, the browser, or the authenticated session is unavailable, checkpoint the exact blocker and stop.

Never enter credentials, choose an account, complete MFA, change account or security settings, or bypass a browser warning. Ask the operator to take over at an authentication boundary. Apply the Computer Use confirmation policy to every prompt, upload, download, and browser action.

Create or resume the artifact first

Resolve this skill's directory from the loaded SKILL.md. Use its helper with Python 3; do not copy the helper into the target workspace.

Create an artifact before the first prompt:

python3 <skill-directory>/scripts/session_artifact.py new \
  --objective "<1-3 sentence outcome>" \
  --workspace "<absolute workspace>" \
  --task-ref "<stable task reference when one exists>"

The helper stores one mode-0600 Markdown file below ${CODEX_HOME:-~/.codex}/pro-sessions/YYYY/MM/DD/ by default. Keep it outside repositories unless the operator explicitly requests another root. It prints the exact path, status, update version, next expected transition, and next action.

Resume an explicitly supplied artifact. Otherwise locate the newest matching artifact:

python3 <skill-directory>/scripts/session_artifact.py latest \
  --workspace "<absolute workspace>"

Read the artifact directly. Never treat its status, model observation, URL, or summary as current until the live browser confirms them.

Operate the shared browser safely

1. Fresh-read the browser and remember the currently selected tab in working memory. Do not persist unrelated tab titles or URLs.
2. Always open a new tab for skill-driven work. For a resume, navigate that new tab to the sanitized conversation URL in the artifact. For a new session, navigate to https://chatgpt.com/.
3. Confirm the authenticated ChatGPT surface without persisting the account identity. A usable composer plus the authenticated profile surface is enough.
4. Immediately before every send, open the live selector and verify the exact model-family and intelligence labels. The labels can change; record the live values instead of assuming them. Select the current Pro equivalent only when the user's request authorizes it.
5. Fresh-read the conversation before sending. If generation is active, a Stop control is visible, or the last visible exchange differs from the artifact, do not send. Reconcile the artifact or checkpoint a blocker.
6. If the browser unexpectedly changes tabs or the user moves to another page, stop browser actions. Never fight for focus.

Restore the originally selected tab only when the current selection is still the exact Pro tab opened by this run. If the user has moved elsewhere, leave their selection untouched.

Send one grounded prompt

Prefer one complete prompt over quota-heavy ping-pong. Include only deliberate, task-relevant context. Never send secrets, credentials, bulk workspace content, private third-party messages, or unnecessary personal data. A prompt transmits its contents to OpenAI under the operator's account; obtain any confirmation required by the Computer Use policy before the send.

Put the artifact's session ID near the top of the first prompt. Add this standing instruction once, not on every follow-up:

At the end of each response, include a concise PRO_SESSION_STATE with completed
work, decisions, produced artifacts, blockers, the best next step, and context
Codex must retain. This state block is advisory; Codex will verify the response.

Set the full prompt into the composer in one action. For large or exact deliverables, ask Pro to produce a downloadable file plus a concise explanation. For short deliverables, plan to read the live accessibility text. Do not archive the whole transcript.

After Send, fresh-read the conversation. Move the artifact to waiting_for_pro only after the sent message is visibly present and the browser has a stable https://chatgpt.com/.../c/... conversation URL. This keeps the send-to-checkpoint gap to one browser read.

python3 <skill-directory>/scripts/session_artifact.py checkpoint <artifact> \
  --expected-updated-at "<artifact updated timestamp>" \
  --status waiting_for_pro \
  --conversation-url "<live conversation URL>" \
  --conversation-title "<live title when visible>" \
  --model-family "<live family label>" \
  --intelligence-mode "<live intelligence label>" \
  --last-exchange "Sent <compact own-words summary>; response pending." \
  --next-action "Open the recorded conversation in a new tab and inspect it without interrupting." \
  --note "Confirmed the sent message and stable conversation URL in the live browser."

The helper uses compare-and-swap through --expected-updated-at. On a mismatch, re-read the artifact and browser; never overwrite another session's checkpoint.

Inspect, extract, and hand back

After a confirmed send, leave the shared browser instead of continuously polling it. A later Codex turn or session should open the recorded URL in a new tab and fresh-read it.

Treat a response as terminal only when the live composer is available and no Stop-generation control is visible. Text that merely looks finished is not terminal proof. If it is still running, leave it alone and keep waiting_for_pro.

Read and judge the actual response. Summarize it in Codex's own words; never paste the model-authored PRO_SESSION_STATE into the artifact as truth. Extract the requested deliverable, not the surrounding transcript:

• For a short result, use the fresh accessibility text.
• For a large exact result, use the visible download or copy control only after a fresh state exposes it. Prefer a provider-created downloadable file. Save or move the inbound deliverable to a deliberate local path and record it.
• If exact extraction cannot be proved, record the limitation and do not reconstruct a supposedly exact file from partial screen text.

Checkpoint the terminal response:

python3 <skill-directory>/scripts/session_artifact.py checkpoint <artifact> \
  --expected-updated-at "<artifact updated timestamp>" \
  --status ready_for_codex \
  --last-exchange "<Codex's compact summary of the confirmed exchange>" \
  --decision "<material decision, repeat as needed>" \
  --artifact "<sanitized local path or stable URL, repeat as needed>" \
  --open-question "<remaining question, repeat as needed>" \
  --next-action "<one imperative action executable by a new Codex session>" \
  --note "Confirmed a terminal Pro response and reconciled the handoff."

Use exactly five statuses:

• draft: Codex acts; nothing is confirmed sent.
• waiting_for_pro: the provider acts; do not send another prompt.
• ready_for_codex: Codex acts; inspect, apply, follow up, or finish.
• blocked: the operator acts or a grounded external blocker must change.
• complete: nobody acts; the requested outcome is finished.

When finishing, checkpoint complete. When human action is required, checkpoint blocked with the exact ask as --next-action and a concrete --blocker. Decisions and produced artifact references accumulate. Resolve stale blockers or questions explicitly with --resolve-blocker and --resolve-question.

Every handoff back to Codex must report:

• the exact local artifact path;
• the sanitized conversation URL;
• the current status and what live UI proved it;
• produced local artifacts;
• the one exact next action.

Recover honestly

On resume, validate the browser first. If the artifact URL is dead or missing, search the authenticated account's recent conversations by the recorded title, time, and session ID before starting over. If recovery fails, create a new chat from the artifact's compact current handoff, checkpoint the continuity break, and never claim it is the same provider conversation.

If a resumed artifact is still draft, search recent conversations for its session ID before sending. A crash may have happened after the confirmed send but before the first URL checkpoint.

Never close an existing Pro conversation, interrupt an active generation, infer completion from old browser content, or use the artifact as proof of provider state. Never persist credentials, cookies, full transcripts, raw provider bodies, unrelated tabs, or sensitive third-party content.