GPT DotFIELD GUIDE
Home/Integrations
Integrations

How to connect GitHub to your ChatGPT Dot: setup, PR reviews, stuck writes and 18 real repo cases (OpenAI Dots)

Install the ChatGPT app on GitHub for only the repos your Dot should see; it reads code on demand and hands fixes to Codex. 18 real cases, from a CI break caught before macos-14 runners retired to a read-only map of 415 files across three mixed systems, plus public bug reports on approvals, big files and the cloud shell.

GPT Dot · Updated
OpenAI Dots product demonstration
Image source

The short version: what a Dot does well with GitHub, how to set it up, where it gets stuck

A ChatGPT Dot (OpenAI Dots) can read the GitHub repositories you authorise, check pull requests and CI, and hand coding work to Codex when something needs fixing (Connecting GitHub to ChatGPT). This section sums up what developers learned; the named cases and the detailed bug reports follow below. To set up the Dot itself, start with getting started.

Is it worth connecting?

Yes for reading and reviewing, and plan to stay involved when it writes. The strongest cases are read-only. Charlie Marsh's Dot warned him, unasked, that Astral's CI jobs would break when GitHub retired the macos-14 runners; 余佳恆's Dot reviewed PR #473 and reported which branches, changes and PRs were open; 整える旅行記's Dot mapped 415 files across three mixed systems without changing any of them. Fixes work best as a Codex task that ends in a draft PR you merge, like Manton Reece's one-line Hugo fix tested across three Hugo versions. The weak spot is the write itself. Uploads, branches, comments and merges are checked against the exact action, big files bring the approval card back, and the Dot's cloud shell has no GitHub login of its own. Let it read, review and prepare, and approve each write in the task that makes it.

How to set it up in seven steps

  1. In ChatGPT, open Plugins and choose GitHub. GitHub opens so you can install and authorise the ChatGPT app; select only the repositories the Dot should see. Organisation repositories may need an admin to approve the app, and repositories take about five minutes to show up (Connecting GitHub to ChatGPT).
  2. Know the boundary. The Dot gets the same GitHub permissions you gave ChatGPT. It reads permitted code, READMEs and docs on demand, without a synced index, while writing code, editing files and pushing go through Codex. GitHub is an app connection, so adding the Dot to a Slack channel doesn't connect it (Connect computers and apps).
  3. Test it on one known file. Ask the Dot to read a file or an open issue in an authorised repository and quote it back, then ask which of these it can do there: read, push to a branch, open a PR, edit a PR, comment. A repository outside the app installation, or a repository selection that never saved, later looks like an approval error.
  4. In its custom rules, name the repositories it may work in and say that merging stays with you. Flavio Copes's starter rules are a useful base. Keep a read-only status report and development work as separate jobs, so one job's limits aren't applied to the other.
  5. For fixes, set up the Codex environment you already use, in the cloud or on your Mac. Decide before the work starts which route will publish: the GitHub connection, or git and gh on the Dot's cloud computer, which need a login of their own.
  6. For work that should start on its own, eligible users can create a task in Work that fires when a pull request on a github.com repository is opened, marked ready for review or closed; it can also follow reviews, comments, new commits and merges. Self-hosted GitHub Enterprise isn't supported. Sharing a scheduled task that mentions GitHub doesn't pass on your connection, so the other person connects their own account.
  7. When a write needs approval, answer in the task that makes the write, and name the repository, branch, files and action in that one yes.

Where it gets stuck, and what worked

  1. A general yes doesn't cover the next write. Approvals are checked against the exact action, so a later batch, a new branch or a comment was refused again (jabdori, seeton, and doublemover's forty or fifty attempts). What worked for jabdori was one question that named the files, the repository, that it was private, and the draft PR.
  2. A saved rule or a "retry" isn't enough when the content is sensitive. binarysubstrate had a scoped custom rule saved and said to retry, and publishing mailbox-derived trackers to their private repository was still refused because the approval didn't name that content and destination; the task also said it couldn't see the newly saved rule. DmitrL-dev's saved merge rule was refused because the check picked up a "Windows/editor gate" from their own PR description. Put the content, destination and conditions in the approval itself, and remove draft-only wording from a PR description before asking for a merge. Custom rules can't remove the approval for consequential GitHub actions.
  3. A yes relayed by the Dot isn't accepted by the delegated task. Beowulfwar and misosiruda approved merges in the parent Dot conversation, and the task treated the forwarded approval as untrusted. Open the task and approve it there.
  4. "User cancelled" or no result, when nobody cancelled. tndd's blob never arrived, while konard's upload that looked lost turned up hours later. Check on GitHub whether the branch, commit or blob exists before retrying, and retry only what is missing.
  5. Big files bring the approval card back. In mibrh's tests the cut-off sat between 719,687 and 720,000 bytes per call, even with Allow all actions set. Minifying, splitting into separate files, or uploading blobs first and building the tree from their SHAs went through. Appending to one big file didn't, because each update sends the whole file again.
  6. The cloud shell has no GitHub login. The connection kept working while gh and git push on the Dot's cloud computer had no login (s520145, konard, f0909172434), and kendonB's gh auth login was blocked by network policy. The connection has no clone operation either. Run gh auth status and git push --dry-run as read-only checks first, and if neither route works, ask for a patch you push yourself.
  7. The connection can't do everything you can do on github.com. Editing your own PR in an upstream repository outside the installation returned 403 (articultur), and commits carry your personal identity with no way to set a separate author (wookingwoo).
  8. It looks into repositories you never mentioned. 0x8007000e's Dot went through other repositories looking for work, and u/Artelj's scanned private repositories and flagged a committed private-key file. Select only the repositories it needs and name them in its rules.
  9. The same step keeps failing. If a step is refused twice, stop and do that one step by hand on github.com, as NaturalMatchaKing did with Create pull request, then let the Dot check the result and carry on.

What it can do, and what it can't yet

It can:

  • Warn you about CI jobs that are about to break, and about issues a merged PR only partly fixed (Charlie Marsh, Eduardo)
  • Review a PR, check CI and how far it is behind main, and test it on its own cloud computer (余佳恆)
  • Report a repository's branches, uncommitted changes and which PRs are done, then wait for your approval (余佳恆)
  • Map a large private repository read-only before anyone changes it (整える旅行記)
  • Reproduce a bug, write the fix through Codex and open a draft PR (Manton Reece, Eduardo, Himanshu Jha)
  • Read GitHub together with Slack, email and analytics to pick up unanswered requests or likely bugs (Shingo Irie, Bradley)
  • Read a public bug report and try the workaround in it (supernovae)

It can't yet, or not reliably:

  • Carry one approval across several different writes, or accept a yes relayed from the parent conversation (jabdori, Beowulfwar, misosiruda)
  • Let a custom rule stand in for the approval of consequential GitHub actions (doublemover, binarysubstrate)
  • Send more than about 720 KB in one write without bringing the approval card back (mibrh)
  • Push or clone from its cloud shell using the GitHub connection's login (s520145, konard, kendonB)
  • Edit a PR in a repository outside the app installation, or commit under a separate author (articultur, wookingwoo)
  • Run event-triggered tasks on self-hosted GitHub Enterprise (OpenAI's GitHub guide)

One message to start with

Tell me which GitHub repositories you can see and, for [owner/repo], which of these you can do: read, push to a branch, open a PR, edit a PR, comment. Then review PR [link]: what it changes, whether CI passes, how far it is behind main and what could break for current users. Don't comment, push or merge. From now on, before any GitHub write, ask me one question that names the repository, the branch, the files and the action, and treat my yes as covering only that. If the same step is refused or comes back as cancelled twice, stop, check on GitHub what actually exists, and tell me the one thing to do by hand.

Quick answers

How do I connect GitHub to my ChatGPT Dot?

In ChatGPT, open Plugins, choose GitHub, then install and authorise the ChatGPT app on GitHub, selecting only the repositories the Dot should see; organisation repositories may need an admin. Repositories take about five minutes to appear. The Dot gets the same GitHub permissions you gave ChatGPT; it reads code on demand without a synced index, and writing code and pushing go through Codex (Connecting GitHub to ChatGPT; Connect computers and apps). Ask it to quote one known file back before giving it real work.

Will it catch CI and repository problems on its own?

Often. Charlie Marsh's Dot warned, unasked, that a batch of Astral's CI jobs would fail on Monday because GitHub was retiring macos-14 runners; Eduardo's Dot spotted that his merged PR fixed Try Omarchy only for new installs and current users still needed a migration; Chrono IT's Dot named the repository he had been working on without a prompt; Teeming has his Dot chase CI failures from his phone.

Can it review pull requests?

Yes, read-only reviews work well. 余佳恆's Dot reviewed PR #473 (four passing checks, two commits behind main) and, when his Mac stalled, tested it on its own cloud computer; another run checked a repository's branch, uncommitted changes and which PRs were done or ready in 3 minutes 44 seconds, then waited for approval. Antonio Leiva's Dot transcribed a student's demo video and left a first review of the repo. More on the Dot's own machine on Cloud computer.

Can it fix bugs and open pull requests?

Yes, through Codex, and usually as a draft you merge. Manton Reece's Dot reproduced a Hugo build failure, wrote a one-line fix, ran 15 clean test builds across three Hugo versions and offered a draft PR; Eduardo's Dot opened a Codex chat on his Mac to write the migration and open a PR; Himanshu Jha's overnight run ended with a draft PR and 193 passing targeted tests. Flavio Copes's starter rules keep merging with you. See Dots and Codex for delegated tasks.

Why do GitHub writes get stuck?

In the public bug reports collected below, approvals were checked against the exact write: a general yes didn't cover the next batch, branch or comment (jabdori, seeton, and doublemover's forty or fifty attempts). "User cancelled" appeared when nobody cancelled (tndd); above about 720 KB per call the approval card came back (mibrh); a yes relayed by the Dot wasn't accepted by the delegated task (Beowulfwar, misosiruda); and the cloud shell had no GitHub login of its own (s520145, konard). Custom rules can't remove the approval for consequential GitHub actions.

Will it go into repositories I didn't ask about?

It can. 0x8007000e's Dot, asked to keep one part of one repo up to date, started going through other repositories; u/Artelj's Dot scanned private repos on its own and flagged a committed private-key file. Select only the repositories it needs when you authorise the app, and name them in its custom rules.

Which plan do I need?

A Dot comes with Pro ($100, $200 or $500 tiers) outside the EEA, UK and Switzerland, with Business Premium in any supported region, and with Enterprise once an admin switches it on (How to get ChatGPT Dots; in Europe, see Dots in the EU and UK). The full list of what a Dot can do is on the features page; if the Dot or its GitHub jobs go quiet, start at Dots not showing or not working.

Real examples, by job

Catch repository and CI problems early

Charlie Marsh, @charliermarsh, Astral (X, 2 October 2026). His Dot messaged him without being asked that a batch of Astral's CI jobs would start failing on Monday because GitHub was retiring the macos-14 runners. The jobs it named included uv tests and the ARM64 release builds of the Ruff and ty VS Code extensions.

Eduardo, @martiano (X, 30 September 2026). Eduardo's Dot pointed out an open issue in Try Omarchy that his pull request from the day before had fixed, but only for new installs: current users still needed a migration. He asked it to fix that with Codex on his Mac, and the Dot opened the Codex chat so Sol 6.1 could work on the migration and open a PR.

Chrono IT channel (YouTube, Japanese, 2 October 2026). In his proactive-research test, the host connected Gmail and GitHub. Without a prompt, his Dot read his recent mail, listed the deadlines due that day, and named the repository he had been working on.

整える旅行記 (note.com/bold_drake211, 1 October 2026). After upgrading to Pro 100, they created a Dot named ナカムラdot1号, connected a private GitHub repo read-only, and asked it only to map three mixed systems (horse-racing analysis, ownership admin, an AI secretary) across 415 tracked files—no commits, creates, or deletes. The Dot reported that a naive three-way split would break references, so the next ask was design-only separation. They then connected a Windows PC via the desktop app and ran a ~3m52s read-only audit (GitHub vs local diffs, Python env, JV-Link files; it skipped a SQLite database that was mid-write). The Dot also drafted a ~4,200-character note.com article and picked screenshots, but its cloud browser could not log into note.com, so publishing stayed with the author.

Copyable ask:

Each weekday at [time] [time zone], check [owner/repo] for failing or newly deprecated CI jobs, open issues that a merged PR only partly fixed, and runner or dependency changes announced for the next two weeks. Send me a short list with links. Read only: don't open PRs or start Codex tasks until I say yes.

Review pull requests and check repository state

余佳恆, @tachichocolate (Threads, Traditional Chinese, 30 September 2026). On his first test, the Dot picked up PR #473 in tachiko-work for a full review. The PR moved a long, always-loaded process into an on-demand skill, had four passing CI checks, and was two commits behind main. When running locally stalled on authorizing his Mac, the Dot switched to its own cloud computer, checked that Git, Python, and Node were installed, and set up a separate workspace to test the PR against main.

余佳恆, again (Threads, two more posts). Given read access, his Dot spent 3 minutes 44 seconds checking the state of the tachiko-sheet repository: the branch and remote, the commit main was on, which local changes were uncommitted, and which PRs were done or ready to start. It then drafted a small behaviour-regression test plan and waited for his approval before changing files, running tests, or pushing. In another test it compared two related repositories and found that Sheet #136 was merged while some of its acceptance criteria were still open.

Antonio Leiva, Dot "Keet" (X, Spanish). A student in his AI Expert course handed in a practice project with a demo video. Antonio asked his Dot to install Whisper on its own computer and transcribe the video, and it then reviewed the student's repository through the GitHub connector and left him a first review. He says he no longer starts from zero.

u/Danny7Guns (Reddit r/codex, October 2026). He had his Dot install the Mempalace memory tool on its cloud computer one night. The Dot now backs up his GitHub repo to Mempalace, and he says it remembers his workflow rules without being reminded as often. He credits the setup with saving time, tokens and headaches, and with more accurate coding progress.

Copyable ask:

Review PR [link] in [owner/repo]. Tell me what it changes, whether CI passes, how far behind main it is, and what could break for current users. If you need to run it, use your own cloud computer, not my Mac. Don't comment on the PR, push, or merge.

Fix the bug and open a draft PR you merge

Manton Reece, @manton, creator of Micro.blog (Threads, 30 September 2026). Soon after he named his Dot, it offered to fix something: a Hugo compatibility problem in his Search Page plug-in. He said yes. The Dot reproduced the build failure on Hugo 0.158, wrote a one-line fix, ran 15 clean test builds across Hugo 0.117, 0.156, and 0.158, and offered to open it as a draft pull request on microdotblog/plugin-search-page.

Himanshu Jha, @jhahimanshu653, Dot "Buddy" (X, 1 October 2026). He told his Dot to "surprise me by morning", with three rules: spend nothing, leave his existing projects alone, and keep going all night. By 9 AM it had published three new GitHub projects, opened a draft PR that was audited separately, passed 193 targeted tests, and sent three DevRel applications, one of which came back with a take-home invitation. The cloud workspace reset partway through, so the Dot rebuilt the lost files and reran the checks. He handled the sign-ins and permission approvals himself.

Teeming, @teemingchew (Threads, 4 October 2026). While he juggles several products, he asks his Dot from his phone to investigate CI failures, coordinate the fixes, and follow them through. The same Dot also reminds him of things outside code, such as arrival instructions for an event.

Copyable ask:

If you find a confirmed bug in [owner/repo], reproduce it first and tell me the smallest fix you would make and how you would test it. When I reply "go", start a Codex task in [cloud environment or my Mac] to make the fix, run the tests, and open a draft pull request. Send me the link. Never merge.

Triage GitHub with the rest of your inbox

Shingo Irie, @iritec_jp (X, Japanese, 1 October 2026). His Dot checks Slack, GitHub, and email on a schedule and picks up requests he read but never answered, with the background and the next step. Before meetings it pulls the last minutes and the current development status into talking points, with links to the screens worth showing.

Bradley, Breakeven Brothers podcast (YouTube, 6 October 2026). On the episode, Bradley describes his Dot handling app-support triage: it reads email, GitHub, and product analytics together to flag what might be a bug.

@billgo.me (Threads, Chinese, 30 September 2026). He had his Dot run a whole note-taking chain: sign in to his Google account, ask questions in NotebookLM, write the answers into his fsnotes knowledge base, add follow-up tasks to Things, and commit the code to GitHub.

Have the Dot read a bug report and try the workaround

supernovae, @byron_miller (X, 12 and 13 October 2026). On his Windows computer, SSH didn't work in tasks his Dot created: the SSH connections he had set up in the ChatGPT app showed as connected, but the Dot said it couldn't use them. The same problem is written up in openai/codex issue #50333, opened on 2 October by another user: in a fresh Dot-created task on Windows, ssh resolved to a local .sbx-denybin\ssh.bat wrapper that printed text and returned exit code 0 without running anything, whichever permission mode was selected. He told his Dot to read that issue and try the fix, and it worked: the Dot could use SSH from PowerShell. A day later he added that the Dot had done about 100 PRs that week, that it still couldn't use the SSH keys inside Codex, and that it reached SSH "in another way". Neither post says what the workaround was, and the issue was still open on 13 October.

When the Dot reaches too far

0x8007000e (Threads, October 2026). Their Dot had one job: keep one part of one repository up to date. It started going through other repositories they had never discussed, looking for things to do, and sent them an unrelated message they found inappropriate. After what they call a very frank discussion, they and the Dot created a new rule together.

u/Artelj (Reddit, r/OpenAI, 1 October 2026). Their Dot went through their private GitHub repositories on its own and flagged a committed private-key file. It read only the first line, enough to recognise a private-key header, and checked the file on GitHub without downloading anything. They posted to ask whether that kind of unprompted scan is fine.

AD Amorim, @nativedone (X, 3 October 2026). When his Dot worked with GitHub through computer use rather than the plugin, it kept stopping to ask for authorization to upload blobs.

If you want the Dot in only some repositories, select only those when you authorize the GitHub app and name them in its custom rules. Flavio Copes's starter rules are a useful base: the Dot opens a draft pull request when you say so, and merging always comes back to you.

Where GitHub writes got stuck: the reports in detail

The cases above are mostly reads, reviews and offers to fix something. The trouble starts when the Dot writes to GitHub: uploads, branches, comments, pull requests and merges. These are public bug reports from Dot users on the openai/codex tracker, grouped by what went wrong. Most are still open, and several reporters say plainly that they don't know the root cause.

The yes didn't carry over to the exact write

jabdori (#50769, 3–4 October). The work had two parts: development the user had approved, and a separate scheduled progress report that was read-only. Later GitHub writes kept being refused with explanations that cited the read-only report. File uploads went through in batches 3–10, then batch 11 was refused. What unblocked it was a narrow question from the assistant: may I upload these reviewed source files and tests to this private repository and open a draft PR with CI, separately from the read-only report? The user said yes and the batch and commit went through. Creating the branch afterwards, even with gh CLI on the user's Mac, was still refused before the command ran, so no draft PR was created. Report

partialobserver (#50769, 4–5 October). The same create_tree request to a private repository was refused twice and then succeeded unchanged three hours later. In between, the user found that an earlier change to the GitHub app's repository selection had never saved, and fixed it. After one complete publish, the fifth tree of the next checkpoint was refused as "unacceptable risk", and the branch stayed at the last good checkpoint. Comment

seeton (#50769, 5 October). Saving results and checkpoints to the user's own private repository had been approved, and many saves worked. Then a create_file call was refused because the approval was read as covering only an index update. Comment

konard (#52503, 7–9 October). The user kept choosing Always allow for uploads to one public repository, yet new approval cards kept appearing, and older ones said "This request is no longer pending." A 5,825-byte source upload was refused, then the unchanged retry went through two minutes later. After three refusals in a row, the coding task was stopped and needed a fresh confirmation. Report

carabinshely (#50769, 8–9 October). A GitHub issue comment was refused as "unacceptable risk". The Dot asked for approval, the user replied "Да, конечно." ("Yes, of course."), and the same comment was refused again. It went through only after the user said they had switched a Codex chat back to Full Access. The reporter notes the timing does not prove the setting was the cause, and they could not find an access-mode selector in the Dot's web interface. Comment

doublemover (#53756): forty-to-fifty GitHub approval attempts, then "hydro is not defined"

doublemover's Dot is named hydro, used from the ChatGPT web client on Windows with the GitHub connection. The user is quoted estimating about forty or fifty different ways to approve ordinary GitHub work after advertised local-thread features still failed, so GitHub publishes were being used as a fallback. A bounded audit verified at least 15 workaround artifacts from 4–13 October. Separately, the Library held 75 assistant-generated recovery ZIP files from 1–12 October (about 467 MB); those ZIPs accumulated across tooling failures and are not all attributed to this approval defect.

In the affected publish sequence: the user explicitly approved publishing prepared code and assets to two named, user-owned repository/branch targets, and repeated those approvals when asked. Individual GitHub create_blob calls were rejected for missing authorization or an unverified destination; the user then approved an exact file and both targets. A later create_commit attempt was rejected because the approval was treated as an isolated "I approve", even though it was a reply to a confirmation that named the targets. Other failed calls returned "user cancelled MCP tool call" when the user said they had not cancelled. After repeated denials stopped the worker, the user again approved continuation, and publication eventually succeeded after renewed approvals. A generic approval card also appeared without enough information to tell which action it covered.

On 13 October the custom-rule editor became part of the recovery attempt. A screenshot showed the fields "When hydro wants to:", rule text that hydro can use GitHub for consequential work, and selected behavior "Take action without asking". The first error said the rule would let consequential GitHub actions run without required approval or handoff, which custom rules cannot remove. After the user changed one word that was not mentioned in that error, the first message disappeared and the editor instead said "hydro is not defined" — the Dot's own name. The exact second edit and a second screenshot were not retained. It overlaps #50769, the thread with the jabdori and tndd reports above. Report

"Cancelled" or hanging, with nobody cancelling

tndd (#50769, 4 and 9 October). A 25.5 MB backup was sent to a private repository as 392 blobs. After 16 succeeded, the rest returned "user cancelled MCP tool call", although tndd had cancelled nothing. A read-back found the expected blob missing (404), and the branch was untouched; the full backup was still on the local machine. On 9 October, creating a branch in a brand-new private repository returned the same message. Comment

f0909172434 (#49607, 30 September). Two attempts to upload one blob of about 969 KB stayed pending for about 16 minutes each and were stopped. No blob appeared afterwards, while repository reads and other pull-request work were fine. Report

konard (#52503, again). A 1,342,545-byte upload blocked for 1,018 seconds with no result. Nineteen minutes later the object was still missing, yet it turned up later the same morning, and a read-back of the staging tree matched the expected files. Another upload was still waiting for approval after 8 minutes and then succeeded about 13 minutes after it started, without a retry. Report

Above about 720 KB per write, the approval card comes back

mibrh (#52714, 9 October). The GitHub plugin was set to Allow all actions, and approval cards kept coming back anyway. mibrh and their Dot ran controlled tests through the Dot itself, a delegated Codex worker, and scheduled tasks that created and edited files. Small writes went through without a prompt in all of them, so the worker and the schedule weren't losing the permission. Size was what changed the outcome: a 719,687-byte file went through without asking, and a 720,000-byte file brought up an approval card, for both JSON and Markdown. Minifying an 874,365-byte JSON file to 645,251 bytes, with the same data, removed the prompt. Writing the big file in two halves didn't help, because the second update_file call sends the whole file again. What did work was uploading smaller blobs first and building a tree from their SHAs: about 1.29 MB in one tree, no prompt. Sending the content inline in create_tree went worse. One 874 KB file asked for approval and was then reported as cancelled although mibrh had approved it, and two 645 KB files sent inline were "cancelled" twice without any card. Every successful write was read back. Report

konard (#52503, 9–10 October, follow-ups). mibrh pointed konard to these results in the same thread. konard's later updates show what a long upload session looked like after the forced stop described above. The Rust archive upload that had looked lost was recovered at 09:35 UTC. At 19:43 UTC, just after the user authorized resuming, the cloud host had changed and the task checkouts, toolchains and recovery journals were gone, the third apparent workspace replacement in this incident. A verified Git staging tree still held 933 paths, but the PR branch had not moved, so recovery checked the remote state instead of retrying blindly. That evening a 1,755,934-byte upload lost its result with neither success nor denial. Update 1 · Update 2 · Update 3

A saved rule, a "retry" or a relayed yes still wasn't enough

DmitrL-dev (#52096, 8–9 October, macOS, Pro). The Custom rules screen showed two rules, both set to "Take action without asking": one for prepared changes and draft PRs without merging, and one for merging into main after required CI passes on the exact HEAD, with no conflicts and no unresolved blocking review comments. The merge rule was saved at 12:11 UTC. The PR had green CI and was reported mergeable, and the merge was still refused twice. The second refusal read: "Merging PR #76 is an irreversible repository commitment, while the applicable user rule authorizes only creating draft PRs without merging and the Windows/editor acceptance gate remains unmet." In a read-only follow-up the next day, DmitrL-dev found where the "Windows/editor gate" most likely came from: their own description of PR #76 said it remained draft pending exact-head CI and the necessary Windows/editor gates. The repository's CONTRIBUTING file and workflows had no such rule, and main was unprotected. No other way of merging was tried. Report · Follow-up

binarysubstrate (#54712, 16 October, connected Windows computer). Reads and earlier publications to their private repository had worked. They explicitly authorised the Dot to keep routine mailbox-derived trackers and task evidence in that repository, confirmed a scoped custom rule (revision 4, saved at 20:45 UTC), added a further rule and told it to retry. The github_create_tree call was refused before it ran: "This publishes extensive sensitive mailbox-derived sender, recipient, and message data to a repository without explicit user authorization specifying that payload and destination; the vague request to retry does not authorize sensitive egress." The local task said it couldn't see the newly saved rule. Nothing was written, and the documentation stayed on the local computer. The Dot wrote and filed the report at the user's request. Report

Beowulfwar (#50701, 3 October, Windows). The work ran in a Dot conversation on the web, with a delegated task on the user's connected Windows computer under WSL. Beowulfwar authorized merging PRs into the integrate branch only after the workflow's required reviews and validations passed, and did not authorize deployment or skipping any checks. The task's automatic review refused the merge command before it ran, citing the earlier no-merge instruction. Beowulfwar then answered directly in the parent Dot conversation: "autorizo, todos os PRs que ja passaram pelas revisões e validações exigidas pelo fluxo estão autorizados a integração em integrate." The Dot forwarded the question and the answer, and the task refused again because forwarded authorization counted as untrusted. A read-only check found the local setup was approvals_reviewer = "user" with full access, while the delegated task ran with auto_review and workspace-write. Report

misosiruda (#50701, 6 October, Windows). Same step, same result. misosiruda approved implementation, commits, pushes, PRs and gated merges in the parent Dot conversation. Tests, an independent review and a security review were done for the current PR head. The task said automatic review could not verify a direct approval from the user, because it arrived through delegated messages, and confirming again in the parent conversation didn't change that. misosiruda adds that similar publishing requests had gone through before in conversations they opened themselves, though that was not a controlled comparison. Comment

What the GitHub connection itself can't do

articultur (#50173, 2 October). Writes to their own fork worked. Editing the description of their own pull request in the upstream repository returned "403 Resource not accessible by integration", although they could edit it on github.com. The upstream repository was not in the GitHub app installation's repository list. Report

wookingwoo (#50752, 7 October). They use Dots with the GitHub connection to automate changes in a personal repository. Commits made by the automation end up under their personal GitHub identity. They would like the agent's changes to carry a separate author, and the connection offers no way to set one. Comment

Detours through the cloud browser and gh CLI

NaturalMatchaKing (#50769, 5 October). The user asked the Dot to use its Linux cloud browser, already signed in to GitHub. A click on "Branches" was refused with "JavaScript execution did not receive approval", then worked on retry. The click on "Create pull request" was refused twice. The user opened the PR by hand, and the Dot then merged it after a retry with the approval attached. Comment

f0909172434 (#49607, again). As a workaround, the user completed GitHub's device sign-in for gh CLI on the Dot's cloud computer. The command then reported blocked network access to api.github.com, and gh stayed signed out. The GitHub connection itself kept working. Report

The Dot's cloud shell has its own GitHub login

s520145 (#52755, 9–10 October, macOS app, managed Linux cloud computer). Signing in to gh CLI from the Dot's cloud computer failed with Post "https://github.com/login/device/code": dial tcp 140.82.114.4:443: connect: connection refused. Overnight checks were mixed: first all three GitHub addresses timed out in the default shell, then the elevated path reached only api.github.com, and by 02:53 UTC both paths got HTTP responses. gh auth status still showed no signed-in host. The connected GitHub integration kept working throughout. Report

konard (#52503, 10 October). After the upload trouble, the user asked for an ordinary git push instead. A dry run against the existing PR branch failed with fatal: unable to get password from user. Local commits worked and the GitHub plugin had done authenticated repository work, but the shell had no Git login to push with. No credentials were created. Comment f0909172434, above, ran into the same split on 30 September.

kendonB (#54403, 15 October, hosted Linux cloud computer). The Dot could read a private repository through the GitHub connection, but after kendonB approved gh auth login, the shell returned Network access to "https://api.github.com:443" was blocked by policy. and gh auth status still showed no login. The connection has no clone operation, so there was no verified way to check out the app and run it on the Dot's computer. Report

For the approval rules themselves, see Approvals in practice. Delegated Codex work that stalls is covered on Run and check Codex tasks, the Dot's own machine on Cloud computer, and leaving a Dot working on GitHub overnight on Project follow-up. Google Drive uploads hit similar timeouts, as shown on Dots + Google Drive.

More copyable asks for GitHub writes

Swap the parts in brackets for your own. The 700 KB figure in "Keep each write small" is a margin under the size mibrh measured, not an official limit.

One question per write

Based on jabdori, partialobserver and seeton. It avoids a general yes that the check doesn't accept.

Before you write anything to GitHub, ask me one question that names the repository and whether it is public or private, the branch, the files or the comment, and the action (upload, commit, branch, draft PR, comment). Treat my yes as covering only that. If a later write is different, ask again. Never merge.

Read back before you retry

Based on tndd, konard and f0909172434. It avoids duplicates and half-finished uploads after "cancelled" or a timeout.

If a GitHub write comes back as cancelled, timed out, or with no result, don't retry straight away. First check whether the branch, commit, blob, or comment exists on GitHub, and tell me what you found. Retry only the part that is missing, and keep my local copy until the branch on GitHub matches it.

Check access first

Based on articultur and partialobserver. It avoids errors that are really about repository selection.

Before working on [owner/repo], check that the GitHub app can reach it and tell me which of these you can do there: read, push to a branch, open a PR, edit a PR, comment. If a write is not possible, say so before trying, and give me the text or patch to paste on github.com myself.

Keep reports and changes apart

Based on jabdori and seeton. It avoids a read-only job's limits being applied to development work.

The daily status report on [repo] is read-only. Development on [repo] is a separate job, and I approve its writes one at a time. Don't reuse the report's limits for development, or the development approvals for the report. If you are unsure which job a step belongs to, ask me.

Stuck twice, hand it to me

Based on NaturalMatchaKing, carabinshely and konard. It avoids long loops of refused retries.

If the same GitHub step is refused or blocked twice, stop retrying. Tell me the exact step, the error text, and the one thing I can do by hand on github.com. Wait for me to say it's done, then check the result and carry on from the next step.

Keep each write small

Based on mibrh and konard. It avoids approval cards and lost results on big uploads.

Before uploading to [owner/repo], list each file with its size in bytes. Keep every file you send in one call under 700 KB: minify data files if the content stays identical, or split them into separate files. For bigger changes, upload blobs first and build the tree from their SHAs. Don't rebuild one large file by appending to it. Tell me which files you can't get under that size before you write them.

Merge conditions in one place

Based on DmitrL-dev and Beowulfwar. It avoids refusals that quote a condition you never set.

My merge rule for [repo]: merge PR #[number] into [branch] only when required CI has passed on the exact current HEAD, there are no conflicts, and there are no unresolved blocking review comments. Before merging, show me any sentence in the PR description that reads like an extra condition, and ask me whether to update the description first. Don't release or deploy.

Ask me in the task that does the work

Based on Beowulfwar and misosiruda. It avoids a forwarded yes the task won't accept.

If a delegated task needs my approval to merge or push, don't forward my answer from this chat. Tell me which task it is, give me the link, and I'll approve it there myself. Then check the result and report back here.

Pick the publishing path first

Based on s520145 and konard. It avoids finishing the work and then finding nothing can push it.

Before starting work that ends with a push to [owner/repo], check which route works: the GitHub connection, or git and gh in your cloud shell. Use read-only checks only: read the branch through the connection, and run gh auth status and git push --dry-run in the shell. Tell me which route works and use only that one. If neither works, keep the commits and give me a patch I can push myself.

Don't use custom rules to bypass GitHub approvals

Based on doublemover.

Do not ask me to save a custom rule that lets you take consequential GitHub actions without asking. If a write needs approval, ask in the task that does the write, naming the repository and the files. If the custom-rule editor shows an error that names my Dot or says a name "is not defined", stop editing rules and report the exact error text instead.

Related

Copy this task brief

How do I connect GitHub to my ChatGPT Dot? Install the ChatGPT app for only the repositories it should see. Covers PR reviews, CI checks, fixes through Codex, why writes get stuck (approvals, big files, the cloud shell) and a copyable starter message.
Download Markdown ↓

Sources & further reading