@@ -52,7 +52,7 @@ Only one publish runs per task at a time; a second one is refused. A publish who
 
 1. **Recover.** If an opening is still `opening`, look for the open PR from the task branch, with the markers of all the task's openings for that branch. If it has this opening's marker, record it as opened; if this was a draft opening, this publish is a draft publish too, and the PR has since been made ready, turn it back into a draft first (a failure keeps the opening owned). The recovered opening ends this publish only when it is this publish's own work: same task state version and same draft mode. Otherwise the PR is recorded and publishing continues, so the main path pushes the current head and brings the PR into the current mode. If it has another opening's marker, this opening created nothing (one open PR per branch): mark it `abandoned` and continue. If none exists, the request may still be in flight or not yet visible. So publish stops with `OpeningUnsettled` until the opening is 10 minutes old (`settleMs`). After that, it marks the opening `abandoned` and continues.
 2. **Status and no changes.** Refuse unless the task is running (or in needs human, for a draft). If the task head is its base, open nothing. A running task moves to needs human.
-3. **Find the branch PR.** Ask GitHub for the branch's open PR every time, with the markers of the task's opened and abandoned openings for that branch (none if the task has no PR yet). An open PR that carries none of them was not opened by codeboost: publish refuses before anything is pushed. A PR with an opened record's marker but another number is refused too. When the PR's draft state on GitHub differs from the record, the record is corrected here (for example after a draft change whose record was lost), under the task's state-version guard. This comes before the check: an abandoned opening's PR links the issue and has no recorded number, so only its marker shows it is the task's own, and its number is added to the own PRs for the check.
+3. **Find the branch PR.** Ask GitHub for the branch's open PR every time, with the markers of the task's opened and abandoned openings for that branch (none if the task has no PR yet). An open PR that carries none of them was not opened by codeboost: publish refuses before anything is pushed. A PR with an opened record's marker but another number is refused too. An abandoned opening whose PR is now visible is adopted here (number, URL and draft state recorded, task status unchanged), whatever the check then says, so the record names every PR the task has on GitHub. When the PR's draft state on GitHub differs from the record, the record is corrected here (for example after a draft change whose record was lost), under the task's state-version guard. This comes before the check: an abandoned opening's PR links the issue and has no recorded number, so only its marker shows it is the task's own, and its number is added to the own PRs for the check.
 4. **Check.** Run the check. Record the result, and any status change, in one transaction. That transaction refuses if the task changed during the check.
 5. **Push.** When the task already has an open PR, the refresh is recorded first (the push moves that PR's head), then the push runs; otherwise the push runs straight after the check's transaction with no await in between. Push the task head to `codeboost/issue-<issue>-<task slug>-<hash>`. The slug is readable but can collide. The hash is 16 hex characters of SHA-256 over the exact task identity, so two tasks never share a branch.
 6. **Re-read.** Right before the GitHub call, the Store confirms that the latest check is clear and that nothing changed since that check: same task state version, same review version (approvals, choices and notes), same snapshot, same head.
@@ -73,6 +73,8 @@ When the check matches (or is unknown) and the task's earlier PR is open and rea
 
 The adapter refuses any answer for a PR that is not open. A PR closed between the lookup and the update is never recorded as the task's review PR.
 
+**Deadlines.** Each PR operation (open, lookup, refresh, draft change) has one deadline for all of its commands and poll waits together: 60 seconds by default (`operationMs`), combined with the caller's signal.
+
 **Transport.** The PR title and description go to `gh api --input -` as a JSON body on stdin (`github/run-with-input.ts`), never as arguments: Linux limits one argument to 128 KiB, and a 60,000-character description of multibyte text is larger. The runner settles only after `gh` has exited, including on a timeout or abort: it sends SIGTERM, then SIGKILL after 5 seconds if `gh` is still running, and if a process `gh` started keeps the output pipes open after `gh` exits, it closes them after 1 second. The already-fixed check uses the same runner, so its 12-second deadline always holds. The already-fixed check also waits for both of its reads to settle before it returns.
 
 **Environment.** Each `gh` process gets only an allowlist of variables: the path, home and locale; GitHub tokens, host and configuration directories; the D-Bus session bus that Linux keyring sign-in uses; and proxy and CA settings (`github/gh-env.ts`). Prompts, the pager and update checks are turned off.
 
@@ -47,6 +47,8 @@ async function draftCall<T>(call: () => Promise<T>): Promise<T> {
  * agent-controlled, so a marker-shaped string there never identifies a PR.
  */
 export const markerOf = (body: string): string => body.split('\n', 1)[0]!.trim();
+/** The longest one open, lookup, refresh or draft change may take in total, whatever the caller's signal. */
+export const PR_OPERATION_DEADLINE_MS = 60_000;
 /** GitHub updates a PR's head a moment after a push; the read-back waits up to this many polls for the pushed head. */
 export const HEAD_POLLS = 5, HEAD_POLL_MS = 500;
 
@@ -58,12 +60,22 @@ export const HEAD_POLLS = 5, HEAD_POLL_MS = 500;
 export class GhPullRequestGateway implements PullRequestGateway {
   readonly repository: string;
   readonly run: RunGhWithInput;
-  constructor(config: { repository: string }, run?: RunGhWithInput) {
+  /** One deadline for a whole operation (every command and poll wait in it), not a fresh allowance per command. */
+  readonly operationMs: number;
+  constructor(config: { repository: string; operationMs?: number }, run?: RunGhWithInput) {
     if (!REPOSITORY.test(config.repository)) throw new Error('A GitHub repository is required to open pull requests.');
+    if (config.operationMs !== undefined && (!Number.isSafeInteger(config.operationMs) || config.operationMs < 1)) throw new Error('Invalid operation deadline.');
     this.repository = config.repository;
+    this.operationMs = config.operationMs ?? PR_OPERATION_DEADLINE_MS;
     this.run = run ?? ((args, options) => runWithInput('gh', args, { input: options?.input, timeout: 30_000, maxBuffer: 8 * 1024 * 1024, signal: options?.signal, env: ghEnvironment() }));
   }
 
+  /** The caller's signal combined with this operation's single deadline; every command and wait in it uses the result. */
+  #bounded(signal?: AbortSignal): AbortSignal {
+    const deadline = AbortSignal.timeout(this.operationMs);
+    return signal ? AbortSignal.any([signal, deadline]) : deadline;
+  }
+
   async #json(args: readonly string[], signal?: AbortSignal, body?: Record<string, unknown>): Promise<unknown> {
     const output = await this.run(body ? [...args, '--input', '-'] : args, { signal, ...(body ? { input: JSON.stringify(body) } : {}) });
     try { return JSON.parse(output); }
@@ -91,6 +103,7 @@ export class GhPullRequestGateway implements PullRequestGateway {
   }
 
   async open(input: OpenPullRequestInput, signal?: AbortSignal): Promise<OpenedPullRequest> {
+    signal = this.#bounded(signal);
     this.#validate(input);
     if (markerOf(input.body) !== input.marker) throw new Error('The pull request description must start with its marker.');
     const post = () => this.#json(['api', '-X', 'POST', '-H', 'Accept: application/vnd.github+json', `repos/${this.repository}/pulls`], signal,
@@ -104,6 +117,7 @@ export class GhPullRequestGateway implements PullRequestGateway {
   }
 
   async findOpened(input: { base: string; headBranch: string; markers: readonly string[] }, signal?: AbortSignal): Promise<(OpenedPullRequest & { marker: string }) | null> {
+    signal = this.#bounded(signal);
     this.#validate(input);
     const owner = this.repository.split('/')[0]!;
     const query = new URLSearchParams({ state: 'open', head: `${owner}:${input.headBranch}`, base: input.base, per_page: '100' });
@@ -118,6 +132,7 @@ export class GhPullRequestGateway implements PullRequestGateway {
   }
 
   async refresh(number: number, input: OpenPullRequestInput & { ready: boolean; headSha?: string }, signal?: AbortSignal): Promise<OpenedPullRequest> {
+    signal = this.#bounded(signal);
     this.#validate(input);
     if (!Number.isSafeInteger(number) || number < 1) throw new Error('Invalid pull request number.');
     if (markerOf(input.body) !== input.marker) throw new Error('The pull request description must start with its marker.');
@@ -136,6 +151,7 @@ export class GhPullRequestGateway implements PullRequestGateway {
 
   /** The caller has just read the PR as ready, so this changes it straight away and reads the result back once. */
   async markDraft(number: number, input: { base: string; headBranch: string; marker: string }, signal?: AbortSignal): Promise<OpenedPullRequest> {
+    signal = this.#bounded(signal);
     this.#validate(input);
     if (!Number.isSafeInteger(number) || number < 1) throw new Error('Invalid pull request number.');
     let refused: unknown = null;
 
@@ -95,9 +95,15 @@ export class PullRequestPublisher {
     // before the push could move it.
     const live = await this.#pulls.findOpened({ base: this.#config.baseBranch, headBranch: branch, markers: candidates.map(pr => marker(pr.openingId)) }, signal);
     signal?.throwIfAborted();
-    const earlier = live ? candidates.find(pr => marker(pr.openingId) === live.marker)! : undefined;
+    let earlier = live ? candidates.find(pr => marker(pr.openingId) === live.marker)! : undefined;
     // What GitHub shows is the truth for the draft flag: a draft change whose record was lost is repaired here.
     let stateVersion = task.stateVersion;
+    // An abandoned opening's PR that is now visible is adopted at once, whatever the check says next, so the record
+    // always names every PR the task has on GitHub (for reuse, cancel or cleanup). It does not change the task status.
+    if (earlier && live && earlier.state === 'abandoned') {
+      stateVersion = this.#store.adoptOpening(identity, earlier.openingId, live, stateVersion);
+      earlier = { ...earlier, state: 'opened', number: live.number, url: live.url, draft: live.draft };
+    }
     if (earlier && live && earlier.state === 'opened' && earlier.number === live.number && earlier.draft !== live.draft)
       stateVersion = this.#store.recordPullRequestDraft(identity, earlier.openingId, live.number, live.draft, stateVersion);
     const own = new Set(prs.filter(pr => pr.number !== null && pr.repository.toLowerCase() === this.#config.repository.toLowerCase()).map(pr => pr.number!));
@@ -117,7 +123,7 @@ export class PullRequestPublisher {
     const needsDraft = result.outcome !== 'clear' && earlier && live && !live.draft;
     if (needsDraft) this.#store.assertUnchangedSince(identity, { stateVersion, reviewVersion, snapshotId: snapshot.id, draft });
     let drafted = null, leftReady: number | undefined;
-    if (needsDraft) {
+    if (needsDraft && earlier && live) {
       try { drafted = await this.#pulls.markDraft(live.number, { base: this.#config.baseBranch, headBranch: branch, marker: marker(earlier.openingId) }, signal); }
       catch (error) { if (!(error instanceof DraftsUnsupported)) throw error; leftReady = live.number; }
     }
@@ -136,8 +142,7 @@ export class PullRequestPublisher {
       }
       // The push is a refresh's first content write (it moves the open PR's head), so the refresh is recorded before it;
       // beginRefresh re-reads the task after the draft change's await. A task change during the push cannot strand it.
-      const stateVersion = this.#store.beginRefresh(identity, { checkId: check.id, openingId: earlier.openingId, headSha: snapshot.head, draft,
-        ...(earlier.state === 'abandoned' ? { adopt: { number: live.number, url: live.url } } : {}) });
+      const stateVersion = this.#store.beginRefresh(identity, { checkId: check.id, openingId: earlier.openingId, headSha: snapshot.head, draft });
       await this.#pusher.push(identity, { head: snapshot.head, branch }, signal);
       signal?.throwIfAborted();
       // Any failure here, including a draft refusal after the PR was made ready again meanwhile, leaves the update
 
@@ -1064,6 +1064,22 @@ export class Store {
       return this.#task(key).status as TaskStatus;
     });
   }
+  /**
+   * An abandoned opening whose PR became visible is the task's PR after all: record its number, URL and draft state so
+   * it can be reused, closed or cleaned up. The task status does not change. Guarded by the state version the caller
+   * read; returns the new state version.
+   */
+  adoptOpening(identity: PlanIdentity, openingId: string, pr: { number: number; url: string; draft: boolean }, expectedStateVersion: number): number {
+    if (!Number.isSafeInteger(pr.number) || pr.number < 1 || typeof pr.url !== 'string') throw new Error('Invalid pull request.');
+    const key = identityKey(identity);
+    return this.#transaction(() => {
+      if (this.#task(key).state_version !== expectedStateVersion) throw new GuardRefusal('Stale task state. Reload before writing.');
+      if (this.#run("UPDATE task_pull_requests SET state='opened', number=?, url=?, draft=?, updated_at=? WHERE plan_key=? AND opening_id=? AND state='abandoned'",
+        pr.number, pr.url, pr.draft ? 1 : 0, new Date().toISOString(), key, openingId).changes !== 1) throw new GuardRefusal('No abandoned opening with this ID.');
+      this.#touch(key);
+      return this.#task(key).state_version as number;
+    });
+  }
   /** The task, its review and its head are exactly as a publish read them before its last await. */
   assertUnchangedSince(identity: PlanIdentity, input: { stateVersion: number; reviewVersion: number; snapshotId: string; draft: boolean }): void {
     const key = identityKey(identity);
 
@@ -557,6 +557,32 @@ describe('recovering from an abandoned opening whose PR appears later', () => {
     expect(store.taskPullRequests(identity)).toMatchObject([{ openingId: first!.openingId, state: 'opened', number: 100 }, { state: 'abandoned' }]);
     expect(third.log.filter(line => line.startsWith('open'))).toEqual([]);
   });
+  it('adopts an abandoned opening\'s PR as soon as it is seen, even when the check then matches', async () => {
+    const store = runningTask(), live = new Map<string, OpenedPullRequest>(), next = { value: 100 }, hidden = new Set<string>();
+    const later = { now: () => Date.now() + 10 * 60_000 };
+    await expect(harness(store, { live, next, openTimesOut: true }).publisher.publish(identity)).rejects.toThrow('timeout');
+    for (const m of live.keys()) hidden.add(m);
+    // The opening is abandoned after its settle time; a new POST is refused (the first PR exists), leaving one opening.
+    await expect(harness(store, { live, next, hidden, config: later }).publisher.publish(identity)).rejects.toThrow(/already exists/);
+    hidden.clear();
+    const found: AlreadyFixedResult = { outcome: 'found', baseHead: oid(9), matches: [{ kind: 'closed', by: 'owner/repo#5' }] };
+    expect(await harness(store, { live, next, results: [found], config: later }).publisher.publish(identity)).toMatchObject({ kind: 'possibly already fixed' });
+    // The first opening's PR is now recorded with its number and URL, so it can be found and closed later.
+    expect(store.taskPullRequests(identity)).toMatchObject([{ state: 'opened', number: 100, url: expect.stringContaining('github.com') }, { state: 'abandoned' }]);
+  });
+  it('does not adopt when the task changed during the lookup', async () => {
+    const store = runningTask(), live = new Map<string, OpenedPullRequest>(), next = { value: 100 }, hidden = new Set<string>();
+    const later = { now: () => Date.now() + 10 * 60_000 };
+    await expect(harness(store, { live, next, openTimesOut: true }).publisher.publish(identity)).rejects.toThrow('timeout');
+    for (const m of live.keys()) hidden.add(m);
+    await expect(harness(store, { live, next, hidden, config: later }).publisher.publish(identity)).rejects.toThrow(/already exists/);
+    hidden.clear();
+    // Recovery drops the second opening; then the task changes while the branch lookup runs.
+    let finds = 0;
+    const again = harness(store, { live, next, config: later, onFind: () => { if (++finds === 2) store.setAssignment(identity, store.getTask(identity).stateVersion, 'someone-else', 'code'); } });
+    await expect(again.publisher.publish(identity)).rejects.toThrow(/Stale task state/);
+    expect(store.taskPullRequests(identity).map(pr => pr.state)).toEqual(['abandoned', 'abandoned']);
+  });
   it('refuses before pushing when the branch PR has the earlier marker but another number', async () => {
     const store = runningTask(), live = new Map<string, OpenedPullRequest>(), next = { value: 100 };
     store.transitionTask(identity, store.getTask(identity).stateVersion, 'needs human');
@@ -789,6 +815,20 @@ describe('GitHub PR adapter', () => {
     await expect(gh.open({ ...input, draft: true })).rejects.toThrow(/as ready, not as a draft/);
     expect(await gh.open({ ...input, draft: false })).toMatchObject({ draft: false });
   });
+  it('bounds a whole refresh by one deadline, not a fresh allowance per command or poll', async () => {
+    let calls = 0, lastSignal: AbortSignal | undefined;
+    const gh = new GhPullRequestGateway({ repository: 'owner/repo', operationMs: 300 }, async (args, options) => {
+      calls++; lastSignal = options?.signal;
+      await new Promise(resolve => setTimeout(resolve, 40));
+      // GitHub never shows the pushed head, so the refresh would poll 5 times at 500 ms without the deadline.
+      return args[0] === 'pr' ? '' : JSON.stringify(response({ draft: false, head: { sha: oid(2), ref: 'codeboost/issue-12-task', repo: { full_name: 'owner/repo' } } }));
+    });
+    const started = Date.now();
+    await expect(gh.refresh(7, { ...input, draft: false, ready: true, headSha: oid(3) })).rejects.toThrow();
+    expect(Date.now() - started).toBeLessThan(1_500);
+    expect(lastSignal?.aborted).toBe(true);
+    expect(calls).toBeLessThan(5);
+  });
   it('finds a lost PR only by its marker, and refuses a PR on the branch that codeboost did not open', async () => {
     const calls: string[][] = [];
     const found = new GhPullRequestGateway({ repository: 'owner/repo' }, async args => { calls.push([...args]); return JSON.stringify([response()]); });