@cat-factory/executor-harness 1.31.4 → 1.31.8

package/dist/agent.js

@@ -533,6 +533,24 @@ async function runCodingMode(job, opts) {
             ...(job.repo.provider ? { provider: job.repo.provider } : {}),
             signal: opts.signal,
         });
+        // `null` ⇒ the branch has nothing ahead of base, so there was no PR to open (a resumed
+        // branch whose earlier PR already merged). Record it as a clean no-op rather than a push,
+        // mirroring the no-changes outcome — the `runCodingAgent` guard normally catches this, so
+        // this is the belt-and-suspenders path when the ahead-of-base check couldn't determine it.
+        if (prUrl === null) {
+            if (job.noChangesIsError === false) {
+                return { pushed: false, branch: pushBranch, summary, stats, ...(usage ? { usage } : {}) };
+            }
+            return {
+                pushed: false,
+                branch: pushBranch,
+                summary,
+                stats,
+                error: noChangesReason('the work branch has no commits ahead of its base (nothing to open a PR for)', stats, stderrTail),
+                failureCause: 'no-changes',
+                ...(usage ? { usage } : {}),
+            };
+        }
         return { pushed: true, prUrl, branch: pushBranch, summary, stats, ...(usage ? { usage } : {}) };
     }
     return { pushed: true, branch: pushBranch, summary, stats, ...(usage ? { usage } : {}) };

package/dist/coding-agent.js

@@ -1,6 +1,6 @@
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { branchHasCommitsSince, cloneExistingBranch, cloneRepo, commitTrackedEdits, createBranch, excludeFromGit, headCommit, listUntrackedFiles, prepareExistingCheckout, pushBranch, refreshFromBaseIfClean, remoteBranchExists, } from './git.js';
+import { branchAheadOfBase, branchHasCommitsSince, cloneExistingBranch, cloneRepo, commitTrackedEdits, createBranch, excludeFromGit, headCommit, listUntrackedFiles, prepareExistingCheckout, pushBranch, refreshFromBaseIfClean, remoteBranchExists, } from './git.js';
 import { FOLLOW_UPS_FILENAME, FollowUpTailer } from './follow-ups.js';
 import { acquireRepoCheckout, agentNeverActed, agentOutputTail, runAgentInWorkspace, } from './pi-workspace.js';
 import { log } from './logger.js';
@@ -238,7 +238,24 @@ export async function runCodingAgent(spec, opts = {}) {
                     files: leftover.slice(0, 20),
                 });
             }
-            const hasWork = resumed || (await branchHasCommitsSince(dir, baseSha, signal));
+            // A fresh run produced work iff the branch advanced past its pre-run tip. A RESUMED
+            // run already carries prior work — UNLESS that branch turns out to have nothing ahead
+            // of the PR base (e.g. its earlier PR was merged with a merge commit, leaving the
+            // branch reachable from base and its best-effort delete skipped). Opening a PR for such
+            // a branch fails with GitHub's opaque 422 "No commits between ...", so a CONFIRMED-empty
+            // resumed branch is a no-op, not work. `undefined` (couldn't determine) keeps the prior
+            // resume-is-work behaviour; the PR-open path then no-ops on the 422 as a backstop.
+            const advancedThisPass = await branchHasCommitsSince(dir, baseSha, signal);
+            let hasWork = advancedThisPass || resumed;
+            if (resumed && !advancedThisPass) {
+                const ahead = await branchAheadOfBase(dir, spec.repo.baseBranch, spec.ghToken, signal);
+                if (ahead === false) {
+                    logger.info('coding-agent: resumed branch has no commits ahead of base — no-op', {
+                        base: spec.repo.baseBranch,
+                    });
+                    hasWork = false;
+                }
+            }
             if (!hasWork) {
                 logger.info('coding-agent: no changes produced', { ...stats });
                 outcome = {

package/dist/git.js

@@ -38,15 +38,82 @@ const GIT_EMAIL = 'cat-factory[bot]@users.noreply.github.com';
 const GIT_TIMEOUT_MARGIN_MS = 3 * 60_000;
 const GIT_TIMEOUT_FLOOR_MS = 60_000;
 const GIT_TIMEOUT_MS = Math.max(GIT_TIMEOUT_FLOOR_MS, loadRunnerLimits().inactivityMs - GIT_TIMEOUT_MARGIN_MS);
-/** Wrap an error so its message/stack carry no credentials. */
-function redactError(err) {
-    if (err instanceof Error) {
-        const redacted = new Error(redactSecrets(err.message));
-        if (err.stack)
-            redacted.stack = redactSecrets(err.stack);
-        return redacted;
+// Config prefixed to EVERY git invocation to force fully non-interactive authentication.
+//
+// WHY: in native local mode the harness runs as a plain host process, so `git` inherits the
+// developer's host git config. On Windows that config has `credential.helper=manager` (Git
+// Credential Manager), and git consults its credential helpers BEFORE ever reaching
+// `GIT_ASKPASS`. GCM then pops up an interactive OS auth dialog on clone/fetch/push — which in
+// an autonomous, non-interactive run either steals focus with a stray window or, when the
+// dialog is modal, blocks the git process until it hits GIT_TIMEOUT_MS and is killed (the
+// classic "git push hung for ~7 minutes then failed" symptom).
+//
+// Emptying the helper list (`credential.helper=` with no value RESETS the multi-valued config,
+// dropping the system/global/local helpers) removes GCM from the chain, so git falls back to
+// the harness's own askpass helper — which returns the per-job PAT we already hold (see
+// `authEnv`). `credential.interactive=false` is belt-and-suspenders for any backend that still
+// runs. The token is never in argv; only this non-secret config is.
+const NON_INTERACTIVE_CREDENTIAL_ARGS = [
+    '-c',
+    'credential.helper=',
+    '-c',
+    'credential.interactive=false',
+];
+/**
+ * Env applied to git commands that DON'T carry {@link authEnv} (local ops like config/checkout/
+ * rev-parse). Keeps them from ever going interactive too — `GIT_TERMINAL_PROMPT=0` blocks the
+ * terminal prompt and `GCM_INTERACTIVE=never` blocks a Git Credential Manager popup even if a
+ * helper somehow survives. `authEnv` sets the same pair for the network ops.
+ */
+function nonInteractiveGitEnv() {
+    return { ...process.env, GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never' };
+}
+/**
+ * Whether `err` is a per-command TIMEOUT kill (the child exceeded `execFile`'s `timeout`, so
+ * Node killed it with `killSignal` and set `killed=true`) — as opposed to a normal non-zero
+ * exit or a watchdog/caller abort. `aborted` is the caller signal's state: an abort ALSO
+ * kills the child, but it's the outer watchdog's story (recorded via `killReason` upstream),
+ * so it must NOT be reported here as a git timeout. Pure, so the classification is unit-tested.
+ */
+export function isGitTimeoutKill(err, aborted) {
+    if (aborted)
+        return false;
+    const e = err;
+    if (e?.name === 'AbortError')
+        return false;
+    return e?.killed === true && e?.signal != null;
+}
+/** The first non-flag token of a git argv (the subcommand — `push`/`clone`/…), for messages. */
+function gitSubcommand(args) {
+    return args.find((a) => a !== '' && !a.startsWith('-')) ?? 'command';
+}
+/**
+ * Wrap a git failure into a credential-scrubbed {@link HarnessFailure}('git') with an ACCURATE
+ * message. Three cases the old bare "Command failed: git …" collapsed together:
+ *  - a per-command timeout kill → say it STALLED (and name the usual causes) instead of a blank
+ *    "Command failed", so a hung push/clone reads as a timeout rather than a mystery rejection;
+ *  - a real non-zero exit → fold in git's `stderr` (execFile puts the actual reason THERE, not
+ *    on `.message`, which is only "Command failed: <cmd>"), so the surfaced error has content;
+ *  - anything else → the scrubbed message.
+ */
+function gitFailure(err, args, aborted) {
+    const e = err;
+    if (isGitTimeoutKill(err, aborted)) {
+        const failure = new HarnessFailure('git', redactSecrets(`git ${gitSubcommand(args)} timed out after ${Math.round(GIT_TIMEOUT_MS / 1000)}s with no ` +
+            'progress — the operation stalled. Likely a very large clone/push, a slow or blocked ' +
+            'network, or an interactive credential prompt (e.g. a Git Credential Manager popup) that ' +
+            'a non-interactive run cannot answer.'));
+        if (e?.stack)
+            failure.stack = redactSecrets(e.stack);
+        return failure;
     }
-    return new Error(redactSecrets(String(err)));
+    const stderr = typeof e?.stderr === 'string' ? e.stderr : (e?.stderr?.toString() ?? '');
+    const base = e instanceof Error ? e.message : String(err);
+    const combined = stderr.trim() ? `${base}\n${stderr.trim()}` : base;
+    const failure = new HarnessFailure('git', redactSecrets(combined));
+    if (e?.stack)
+        failure.stack = redactSecrets(e.stack);
+    return failure;
 }
 /**
  * Build the remote URL git uses. Only the username (`x-access-token`) is embedded
@@ -89,8 +156,11 @@ async function authEnv(ghToken) {
         ...process.env,
         GIT_ASKPASS: await ensureAskpass(),
         GIT_ASKPASS_TOKEN: ghToken,
-        // Never fall back to an interactive prompt (which would hang the job).
+        // Never fall back to an interactive prompt / GUI credential dialog (which would hang the
+        // job or steal focus). Paired with the emptied credential helper in the git argv, this is
+        // what keeps a native-mode run from ever surfacing a Git Credential Manager popup.
         GIT_TERMINAL_PROMPT: '0',
+        GCM_INTERACTIVE: 'never',
     };
 }
 /**
@@ -100,12 +170,16 @@ async function authEnv(ghToken) {
  * and stack scrubbed of credentials.
  */
 async function git(args, opts = {}) {
+    // Force non-interactive auth on EVERY git op: empty the credential-helper list (drops the
+    // host's Git Credential Manager, whose popup otherwise steals focus or hangs the command)
+    // and, for ops without the auth env, still block a terminal/GCM prompt. See the notes on
+    // NON_INTERACTIVE_CREDENTIAL_ARGS / authEnv above.
     try {
-        const { stdout } = await exec('git', args, {
+        const { stdout } = await exec('git', [...NON_INTERACTIVE_CREDENTIAL_ARGS, ...args], {
             ...(opts.cwd ? { cwd: opts.cwd } : {}),
             maxBuffer: 16 * 1024 * 1024,
             timeout: GIT_TIMEOUT_MS,
-            ...(opts.env ? { env: opts.env } : {}),
+            env: opts.env ?? nonInteractiveGitEnv(),
             ...(opts.signal ? { signal: opts.signal } : {}),
         });
         return stdout;
@@ -114,11 +188,7 @@ async function git(args, opts = {}) {
         // Tag the failure as `git` so the registry's catch records the real cause instead of
         // the generic `agent`. A watchdog abort still wins: `describeFailure` keys off
         // `killReason` first, so an abort during a git op keeps the timeout message/cause.
-        const redacted = redactError(err);
-        const failure = new HarnessFailure('git', redacted.message);
-        if (redacted.stack)
-            failure.stack = redacted.stack;
-        throw failure;
+        throw gitFailure(err, args, opts.signal?.aborted === true);
     }
 }
 /** Clone `repo`'s base branch (shallow by default) into `dir` and set commit identity. */
@@ -325,6 +395,36 @@ export async function excludeFromGit(dir, pattern, signal) {
 export async function branchHasCommitsSince(dir, baseSha, signal) {
     return (await headCommit(dir, signal)) !== baseSha;
 }
+/**
+ * Whether the checked-out branch carries at least one commit the PR base does NOT — i.e.
+ * `git rev-list --count <base>..HEAD > 0`. A resume clone is single-branch, so it has no
+ * `origin/<base>` tracking ref; this fetches the base into a dedicated local ref first and
+ * diffs HEAD against it.
+ *
+ * Tri-state on purpose:
+ *  - `true`  — confirmed ≥1 commit ahead (there is something to open a PR for).
+ *  - `false` — confirmed 0 commits ahead (the branch is reachable from base, e.g. its earlier
+ *              PR was merged with a merge commit and the best-effort branch delete was skipped).
+ *  - `undefined` — could not determine (fetch / rev-list error); the caller keeps its prior
+ *              behaviour rather than wrongly dropping a resumed branch that has real work.
+ *
+ * Used by the resume path to avoid declaring a merged/empty branch as work and then failing
+ * the run with GitHub's opaque 422 "No commits between <base> and <branch>".
+ */
+export async function branchAheadOfBase(dir, baseBranch, ghToken, signal) {
+    try {
+        await git(['fetch', 'origin', `+refs/heads/${baseBranch}:refs/cat-factory/base`], {
+            cwd: dir,
+            signal,
+            env: await authEnv(ghToken),
+        });
+        const count = (await git(['rev-list', '--count', 'refs/cat-factory/base..HEAD'], { cwd: dir, signal })).trim();
+        return Number(count) > 0;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Whether the checked-out branch has a real, examinable diff against
  * `origin/<baseBranch>` — i.e. the base branch's remote-tracking ref exists (so the
@@ -679,6 +779,13 @@ export async function openPullRequest(opts) {
             if (existing)
                 return existing;
         }
+        // The head branch has nothing ahead of base ("No commits between <base> and <head>").
+        // That is not an API failure — there is simply nothing to open a PR for (e.g. a resumed
+        // branch whose earlier PR was merged with a merge commit, leaving the branch reachable
+        // from base). Signal it with null so the caller records a clean no-op instead of failing
+        // the run with GitHub's opaque 422.
+        if (res.status === 422 && /no commits between/i.test(detail))
+            return null;
         throw new HarnessFailure('api', redactSecrets(`Failed to open PR (HTTP ${res.status}): ${detail.slice(0, 300)}`));
     }
     const body = (await res.json());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/executor-harness",
-  "version": "1.31.4",
+  "version": "1.31.8",
   "description": "Container payload: a thin TypeScript wrapper that runs the Pi coding agent against a cloned repo and opens a PR. Runs in the Cloudflare Container (and, in local native mode, as a host process); carries no secrets.",
   "repository": {
     "type": "git",
@@ -26,8 +26,8 @@
     "hono": "^4.12.27",
     "typescript": "^6.0.3",
     "vitest": "^4.1.9",
-    "@cat-factory/server": "0.66.1",
-    "@cat-factory/spend": "0.10.69"
+    "@cat-factory/server": "0.66.4",
+    "@cat-factory/spend": "0.10.70"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",

package/src/agent.ts

@@ -626,6 +626,28 @@ async function runCodingMode(job: AgentJob, opts: RunOptions): Promise<AgentResu
       ...(job.repo.provider ? { provider: job.repo.provider } : {}),
       signal: opts.signal,
     })
+    // `null` ⇒ the branch has nothing ahead of base, so there was no PR to open (a resumed
+    // branch whose earlier PR already merged). Record it as a clean no-op rather than a push,
+    // mirroring the no-changes outcome — the `runCodingAgent` guard normally catches this, so
+    // this is the belt-and-suspenders path when the ahead-of-base check couldn't determine it.
+    if (prUrl === null) {
+      if (job.noChangesIsError === false) {
+        return { pushed: false, branch: pushBranch, summary, stats, ...(usage ? { usage } : {}) }
+      }
+      return {
+        pushed: false,
+        branch: pushBranch,
+        summary,
+        stats,
+        error: noChangesReason(
+          'the work branch has no commits ahead of its base (nothing to open a PR for)',
+          stats,
+          stderrTail,
+        ),
+        failureCause: 'no-changes',
+        ...(usage ? { usage } : {}),
+      }
+    }
     return { pushed: true, prUrl, branch: pushBranch, summary, stats, ...(usage ? { usage } : {}) }
   }
   return { pushed: true, branch: pushBranch, summary, stats, ...(usage ? { usage } : {}) }

package/src/coding-agent.ts

@@ -2,6 +2,7 @@ import { mkdir } from 'node:fs/promises'
 import { join } from 'node:path'
 import type { HarnessAuthFields, RepoSpec } from './job.js'
 import {
+  branchAheadOfBase,
   branchHasCommitsSince,
   cloneExistingBranch,
   cloneRepo,
@@ -343,7 +344,24 @@ export async function runCodingAgent(
           })
         }
 
-        const hasWork = resumed || (await branchHasCommitsSince(dir, baseSha, signal))
+        // A fresh run produced work iff the branch advanced past its pre-run tip. A RESUMED
+        // run already carries prior work — UNLESS that branch turns out to have nothing ahead
+        // of the PR base (e.g. its earlier PR was merged with a merge commit, leaving the
+        // branch reachable from base and its best-effort delete skipped). Opening a PR for such
+        // a branch fails with GitHub's opaque 422 "No commits between ...", so a CONFIRMED-empty
+        // resumed branch is a no-op, not work. `undefined` (couldn't determine) keeps the prior
+        // resume-is-work behaviour; the PR-open path then no-ops on the 422 as a backstop.
+        const advancedThisPass = await branchHasCommitsSince(dir, baseSha, signal)
+        let hasWork = advancedThisPass || resumed
+        if (resumed && !advancedThisPass) {
+          const ahead = await branchAheadOfBase(dir, spec.repo.baseBranch, spec.ghToken, signal)
+          if (ahead === false) {
+            logger.info('coding-agent: resumed branch has no commits ahead of base — no-op', {
+              base: spec.repo.baseBranch,
+            })
+            hasWork = false
+          }
+        }
         if (!hasWork) {
           logger.info('coding-agent: no changes produced', { ...stats })
           outcome = {

package/src/git.ts

@@ -48,14 +48,96 @@ const GIT_TIMEOUT_MS = Math.max(
   loadRunnerLimits().inactivityMs - GIT_TIMEOUT_MARGIN_MS,
 )
 
-/** Wrap an error so its message/stack carry no credentials. */
-function redactError(err: unknown): Error {
-  if (err instanceof Error) {
-    const redacted = new Error(redactSecrets(err.message))
-    if (err.stack) redacted.stack = redactSecrets(err.stack)
-    return redacted
+// Config prefixed to EVERY git invocation to force fully non-interactive authentication.
+//
+// WHY: in native local mode the harness runs as a plain host process, so `git` inherits the
+// developer's host git config. On Windows that config has `credential.helper=manager` (Git
+// Credential Manager), and git consults its credential helpers BEFORE ever reaching
+// `GIT_ASKPASS`. GCM then pops up an interactive OS auth dialog on clone/fetch/push — which in
+// an autonomous, non-interactive run either steals focus with a stray window or, when the
+// dialog is modal, blocks the git process until it hits GIT_TIMEOUT_MS and is killed (the
+// classic "git push hung for ~7 minutes then failed" symptom).
+//
+// Emptying the helper list (`credential.helper=` with no value RESETS the multi-valued config,
+// dropping the system/global/local helpers) removes GCM from the chain, so git falls back to
+// the harness's own askpass helper — which returns the per-job PAT we already hold (see
+// `authEnv`). `credential.interactive=false` is belt-and-suspenders for any backend that still
+// runs. The token is never in argv; only this non-secret config is.
+const NON_INTERACTIVE_CREDENTIAL_ARGS = [
+  '-c',
+  'credential.helper=',
+  '-c',
+  'credential.interactive=false',
+]
+
+/**
+ * Env applied to git commands that DON'T carry {@link authEnv} (local ops like config/checkout/
+ * rev-parse). Keeps them from ever going interactive too — `GIT_TERMINAL_PROMPT=0` blocks the
+ * terminal prompt and `GCM_INTERACTIVE=never` blocks a Git Credential Manager popup even if a
+ * helper somehow survives. `authEnv` sets the same pair for the network ops.
+ */
+function nonInteractiveGitEnv(): NodeJS.ProcessEnv {
+  return { ...process.env, GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never' }
+}
+
+/** The shape `execFile` decorates its rejection with — the bits we read to classify a failure. */
+type ExecError = Error & {
+  killed?: boolean
+  signal?: NodeJS.Signals | null
+  code?: number | string | null
+  stderr?: string | Buffer
+  stdout?: string | Buffer
+}
+
+/**
+ * Whether `err` is a per-command TIMEOUT kill (the child exceeded `execFile`'s `timeout`, so
+ * Node killed it with `killSignal` and set `killed=true`) — as opposed to a normal non-zero
+ * exit or a watchdog/caller abort. `aborted` is the caller signal's state: an abort ALSO
+ * kills the child, but it's the outer watchdog's story (recorded via `killReason` upstream),
+ * so it must NOT be reported here as a git timeout. Pure, so the classification is unit-tested.
+ */
+export function isGitTimeoutKill(err: unknown, aborted: boolean): boolean {
+  if (aborted) return false
+  const e = err as ExecError
+  if (e?.name === 'AbortError') return false
+  return e?.killed === true && e?.signal != null
+}
+
+/** The first non-flag token of a git argv (the subcommand — `push`/`clone`/…), for messages. */
+function gitSubcommand(args: string[]): string {
+  return args.find((a) => a !== '' && !a.startsWith('-')) ?? 'command'
+}
+
+/**
+ * Wrap a git failure into a credential-scrubbed {@link HarnessFailure}('git') with an ACCURATE
+ * message. Three cases the old bare "Command failed: git …" collapsed together:
+ *  - a per-command timeout kill → say it STALLED (and name the usual causes) instead of a blank
+ *    "Command failed", so a hung push/clone reads as a timeout rather than a mystery rejection;
+ *  - a real non-zero exit → fold in git's `stderr` (execFile puts the actual reason THERE, not
+ *    on `.message`, which is only "Command failed: <cmd>"), so the surfaced error has content;
+ *  - anything else → the scrubbed message.
+ */
+function gitFailure(err: unknown, args: string[], aborted: boolean): HarnessFailure {
+  const e = err as ExecError
+  if (isGitTimeoutKill(err, aborted)) {
+    const failure = new HarnessFailure(
+      'git',
+      redactSecrets(
+        `git ${gitSubcommand(args)} timed out after ${Math.round(GIT_TIMEOUT_MS / 1000)}s with no ` +
+          'progress — the operation stalled. Likely a very large clone/push, a slow or blocked ' +
+          'network, or an interactive credential prompt (e.g. a Git Credential Manager popup) that ' +
+          'a non-interactive run cannot answer.',
+      ),
+    )
+    if (e?.stack) failure.stack = redactSecrets(e.stack)
+    return failure
   }
-  return new Error(redactSecrets(String(err)))
+  const stderr = typeof e?.stderr === 'string' ? e.stderr : (e?.stderr?.toString() ?? '')
+  const base = e instanceof Error ? e.message : String(err)
+  const combined = stderr.trim() ? `${base}\n${stderr.trim()}` : base
+  const failure = new HarnessFailure('git', redactSecrets(combined))
+  if (e?.stack) failure.stack = redactSecrets(e.stack)
+  return failure
 }
 
 /**
@@ -102,8 +184,11 @@ async function authEnv(ghToken: string): Promise<NodeJS.ProcessEnv> {
     ...process.env,
     GIT_ASKPASS: await ensureAskpass(),
     GIT_ASKPASS_TOKEN: ghToken,
-    // Never fall back to an interactive prompt (which would hang the job).
+    // Never fall back to an interactive prompt / GUI credential dialog (which would hang the
+    // job or steal focus). Paired with the emptied credential helper in the git argv, this is
+    // what keeps a native-mode run from ever surfacing a Git Credential Manager popup.
     GIT_TERMINAL_PROMPT: '0',
+    GCM_INTERACTIVE: 'never',
   }
 }
 
@@ -117,12 +202,16 @@ async function git(
   args: string[],
   opts: { cwd?: string; signal?: AbortSignal; env?: NodeJS.ProcessEnv } = {},
 ): Promise<string> {
+  // Force non-interactive auth on EVERY git op: empty the credential-helper list (drops the
+  // host's Git Credential Manager, whose popup otherwise steals focus or hangs the command)
+  // and, for ops without the auth env, still block a terminal/GCM prompt. See the notes on
+  // NON_INTERACTIVE_CREDENTIAL_ARGS / authEnv above.
   try {
-    const { stdout } = await exec('git', args, {
+    const { stdout } = await exec('git', [...NON_INTERACTIVE_CREDENTIAL_ARGS, ...args], {
       ...(opts.cwd ? { cwd: opts.cwd } : {}),
       maxBuffer: 16 * 1024 * 1024,
       timeout: GIT_TIMEOUT_MS,
-      ...(opts.env ? { env: opts.env } : {}),
+      env: opts.env ?? nonInteractiveGitEnv(),
       ...(opts.signal ? { signal: opts.signal } : {}),
     })
     return stdout
@@ -130,10 +219,7 @@ async function git(
     // Tag the failure as `git` so the registry's catch records the real cause instead of
     // the generic `agent`. A watchdog abort still wins: `describeFailure` keys off
     // `killReason` first, so an abort during a git op keeps the timeout message/cause.
-    const redacted = redactError(err)
-    const failure = new HarnessFailure('git', redacted.message)
-    if (redacted.stack) failure.stack = redacted.stack
-    throw failure
+    throw gitFailure(err, args, opts.signal?.aborted === true)
   }
 }
 
@@ -409,6 +495,43 @@ export async function branchHasCommitsSince(
   return (await headCommit(dir, signal)) !== baseSha
 }
 
+/**
+ * Whether the checked-out branch carries at least one commit the PR base does NOT — i.e.
+ * `git rev-list --count <base>..HEAD > 0`. A resume clone is single-branch, so it has no
+ * `origin/<base>` tracking ref; this fetches the base into a dedicated local ref first and
+ * diffs HEAD against it.
+ *
+ * Tri-state on purpose:
+ *  - `true`  — confirmed ≥1 commit ahead (there is something to open a PR for).
+ *  - `false` — confirmed 0 commits ahead (the branch is reachable from base, e.g. its earlier
+ *              PR was merged with a merge commit and the best-effort branch delete was skipped).
+ *  - `undefined` — could not determine (fetch / rev-list error); the caller keeps its prior
+ *              behaviour rather than wrongly dropping a resumed branch that has real work.
+ *
+ * Used by the resume path to avoid declaring a merged/empty branch as work and then failing
+ * the run with GitHub's opaque 422 "No commits between <base> and <branch>".
+ */
+export async function branchAheadOfBase(
+  dir: string,
+  baseBranch: string,
+  ghToken: string,
+  signal?: AbortSignal,
+): Promise<boolean | undefined> {
+  try {
+    await git(['fetch', 'origin', `+refs/heads/${baseBranch}:refs/cat-factory/base`], {
+      cwd: dir,
+      signal,
+      env: await authEnv(ghToken),
+    })
+    const count = (
+      await git(['rev-list', '--count', 'refs/cat-factory/base..HEAD'], { cwd: dir, signal })
+    ).trim()
+    return Number(count) > 0
+  } catch {
+    return undefined
+  }
+}
+
 /**
  * Whether the checked-out branch has a real, examinable diff against
  * `origin/<baseBranch>` — i.e. the base branch's remote-tracking ref exists (so the
@@ -790,7 +913,7 @@ function backoffMs(attempt: number): number {
  * GitLab whose host isn't named `gitlab.*` still opens an MR instead of being misrouted to
  * GitHub's API. The GitHub path is unchanged.
  */
-export async function openPullRequest(opts: OpenPullRequestOptions): Promise<string> {
+export async function openPullRequest(opts: OpenPullRequestOptions): Promise<string | null> {
   const provider = opts.provider ?? (opts.cloneUrl ? inferVcsProvider(opts.cloneUrl) : 'github')
   if (provider === 'gitlab') {
     if (!opts.cloneUrl) {
@@ -831,6 +954,12 @@ export async function openPullRequest(opts: OpenPullRequestOptions): Promise<str
       const existing = await findOpenPullRequestUrl(opts)
       if (existing) return existing
     }
+    // The head branch has nothing ahead of base ("No commits between <base> and <head>").
+    // That is not an API failure — there is simply nothing to open a PR for (e.g. a resumed
+    // branch whose earlier PR was merged with a merge commit, leaving the branch reachable
+    // from base). Signal it with null so the caller records a clean no-op instead of failing
+    // the run with GitHub's opaque 422.
+    if (res.status === 422 && /no commits between/i.test(detail)) return null
     throw new HarnessFailure(
       'api',
       redactSecrets(`Failed to open PR (HTTP ${res.status}): ${detail.slice(0, 300)}`),