@cat-factory/executor-harness 1.31.6 → 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

@@ -395,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
@@ -749,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.6",
+  "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/spend": "0.10.69",
-    "@cat-factory/server": "0.66.1"
+    "@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

@@ -495,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
@@ -876,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) {
@@ -917,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)}`),