fix(open-pr): anchor PR branches to patch base

Author: vincentkoc

CHANGELOG.md

@@ -8,6 +8,8 @@
 - Hardened review ingestion so provider findings must cite included files with valid line ranges and matching evidence quotes.
 - Fixed `clawpatch open-pr` so repositories without default-branch metadata use a dedicated patch branch and let GitHub choose the PR base.
 - Fixed `clawpatch open-pr` retries to push the recorded patch commit instead of any later local branch tip.
+- Fixed first-time `clawpatch open-pr` branch creation to start from the recorded patch base.
+- Fixed command execution so providers that exit before reading stdin do not surface benign `EPIPE` errors.
 - Fixed `clawpatch ci --since` empty-review output so it reports `reviewed: 0`.
 - Fixed Express route mapping for aliased Router imports that follow block comment banners, thanks @rohitjavvadi.
 - Fixed Bun package-manager detection to recognize the text `bun.lock` lockfile, thanks @austinm911.

src/app.ts

@@ -1119,12 +1119,18 @@ export async function openPrCommand(
   let commitSha = patch.git.commitSha;
   const hadRecordedCommit = commitSha !== null;
   if (commitSha === null) {
+    const patchBaseSha = assertDefined(patch.git.baseSha, "missing patch base");
+    const targetBranchExists = await localBranchExists(git.root, branch);
+    if (targetBranchExists) {
+      await assertRefAtPatchBase(git.root, branch, patch);
+    }
     if (git.currentBranch !== branch) {
-      const switchArgs = (await localBranchExists(git.root, branch))
+      const switchArgs = targetBranchExists
         ? ["switch", branch]
-        : ["switch", "-c", branch];
+        : ["switch", "-c", branch, patchBaseSha];
       await checkedRun("git switch", runCommandArgs("git", switchArgs, git.root));
     }
+    await assertRefAtPatchBase(git.root, "HEAD", patch);
     const stagePlan = await patchStagePlan(git.root, patchWorktree);
     if (stagePlan.addFiles.length > 0) {
       await checkedRun(
@@ -1528,11 +1534,14 @@ function plannedPrCommands(
 ): string[] {
   const commands: string[] = [];
   if (patch.git.commitSha === null) {
+    const patchBaseSha = assertDefined(patch.git.baseSha, "missing patch base");
     const commitFiles = stagePlan?.commitFiles ?? gitFiles;
     const addFiles = stagePlan?.addFiles ?? gitFiles;
     const updateFiles = stagePlan?.updateFiles ?? [];
     commands.push(
-      branchExists ? `git switch ${shellArg(branch)}` : `git switch -c ${shellArg(branch)}`,
+      branchExists
+        ? `git switch ${shellArg(branch)}`
+        : `git switch -c ${shellArg(branch)} ${shellArg(patchBaseSha)}`,
     );
     if (addFiles.length > 0) {
       commands.push(`git add -- ${shellPathspecArgs(addFiles)}`);
@@ -1735,6 +1744,25 @@ async function localBranchExists(gitRoot: string, branch: string): Promise<boole
   return result.exitCode === 0;
 }
 
+async function assertRefAtPatchBase(
+  gitRoot: string,
+  ref: string,
+  patch: PatchAttempt,
+): Promise<void> {
+  const head = await checkedRun(
+    "git rev-parse",
+    runCommandArgs("git", ["rev-parse", ref], gitRoot),
+  );
+  const sha = head.stdout.trim();
+  if (sha !== patch.git.baseSha) {
+    const message = [
+      `patch attempt ${patch.patchAttemptId} was recorded from ${patch.git.baseSha},`,
+      `but ${ref} is ${sha}`,
+    ].join(" ");
+    throw new ClawpatchError(message, 2, "invalid-input");
+  }
+}
+
 function firstUrl(output: string): string | null {
   return /https?:\/\/\S+/u.exec(output)?.[0] ?? null;
 }

src/exec.test.ts

@@ -31,6 +31,14 @@ describe("runCommandArgs", () => {
     expect(result.stderr).toContain("clawpatch-missing-executable-for-test");
   });
 
+  it("does not surface EPIPE when a child exits before reading stdin", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "clawpatch-exec-stdin-"));
+    const input = "x".repeat(1_000_000);
+    const result = await runCommandArgs(process.execPath, ["-e", "process.exit(0)"], dir, input);
+
+    expect(result.exitCode).toBe(0);
+  });
+
   it("terminates commands that exceed a timeout", async () => {
     const dir = await mkdtemp(join(tmpdir(), "clawpatch-exec-timeout-"));
     const script = join(dir, "hang.mjs");

src/exec.ts

@@ -46,11 +46,7 @@ export async function runCommandRaw(
     });
     child.on("close", resolve);
   });
-  if (input !== undefined) {
-    child.stdin.end(input);
-  } else {
-    child.stdin.end();
-  }
+  endChildStdin(child, input);
   const exitCode = await exitCodePromise;
   if (spawnErrorMessage !== null) {
     stderr += stderr.length === 0 ? spawnErrorMessage : `\n${spawnErrorMessage}`;
@@ -137,11 +133,7 @@ export async function runCommandArgs(
       });
     }, options.timeoutMs);
   }
-  if (input !== undefined) {
-    child.stdin.end(input);
-  } else {
-    child.stdin.end();
-  }
+  endChildStdin(child, input);
   const exitCode = await exitCodePromise;
   if (spawnErrorMessage !== null) {
     stderr += stderr.length === 0 ? spawnErrorMessage : `\n${spawnErrorMessage}`;
@@ -229,6 +221,19 @@ function signalExitCode(signal: NodeJS.Signals): number {
 
 function noop(): void {}
 
+function endChildStdin(child: ReturnType<typeof spawn>, input: string | undefined): void {
+  const stdin = child.stdin;
+  if (stdin === null) {
+    return;
+  }
+  stdin.on("error", noop);
+  if (input !== undefined) {
+    stdin.end(input);
+  } else {
+    stdin.end();
+  }
+}
+
 function commandSpawnSpec(
   program: string,
   args: string[],

src/workflow.test.ts

@@ -3757,6 +3757,93 @@ describe("workflow", () => {
     }
   });
 
+  it("creates first PR branches from the recorded patch base", async () => {
+    const root = await fixtureRoot("clawpatch-open-pr-recorded-base-");
+    await writeFixture(
+      root,
+      "package.json",
+      JSON.stringify({ name: "open-pr-recorded-base", bin: { open: "src/index.ts" } }),
+    );
+    await writeFixture(root, "src/index.ts", "export const value = 'TODO_BUG';\n");
+    await initGit(root);
+    await checkCommand(root, "git add package.json src/index.ts");
+    await checkCommand(root, 'git -c commit.gpgsign=false commit -q -m "base"');
+    const baseSha = (await runCommand("git rev-parse HEAD", root)).stdout.trim();
+    const origin = await fixtureRoot("clawpatch-open-pr-recorded-base-origin-");
+    await checkCommand(root, `git init --bare -q ${origin}`);
+    await checkCommand(root, `git remote add origin ${origin}`);
+    const context = await makeContext(testOptions(root));
+    const paths = statePaths(join(root, ".clawpatch"));
+    await initCommand(context, {});
+    await writeFixture(root, "src/index.ts", "export const value = 'fixed';\n");
+    await writeFixture(root, "src/unrelated.ts", "export const unrelated = true;\n");
+    await checkCommand(root, "git add src/unrelated.ts");
+    await checkCommand(root, 'git -c commit.gpgsign=false commit -q -m "unrelated"');
+    const advancedHead = (await runCommand("git rev-parse HEAD", root)).stdout.trim();
+    expect(advancedHead).not.toBe(baseSha);
+    const now = new Date().toISOString();
+    await writePatchAttempt(paths, {
+      schemaVersion: 1,
+      patchAttemptId: "pat_open_pr_recorded_base",
+      findingIds: [],
+      featureIds: [],
+      status: "applied",
+      plan: "Replace the marker value.",
+      filesChanged: ["src/index.ts"],
+      commandsRun: [],
+      testResults: [
+        {
+          command: "pnpm test",
+          cwd: root,
+          exitCode: 0,
+          durationMs: 1,
+          stdout: "",
+          stderr: "",
+        },
+      ],
+      provider: null,
+      git: {
+        baseSha,
+        commitSha: null,
+        branchName: null,
+        prUrl: null,
+      },
+      createdAt: now,
+      updatedAt: now,
+    });
+    const ghScripts = await fixtureRoot("clawpatch-open-pr-recorded-base-gh-");
+    const successGh = join(ghScripts, "success-gh.sh");
+    await writeFixture(
+      ghScripts,
+      "success-gh.sh",
+      "#!/bin/sh\necho https://github.com/openclaw/clawpatch/pull/1005\n",
+    );
+    await chmod(successGh, 0o755);
+    const previousGh = process.env["CLAWPATCH_GH"];
+    try {
+      process.env["CLAWPATCH_GH"] = successGh;
+      const opened = (await openPrCommand(context, {
+        patch: "pat_open_pr_recorded_base",
+        base: "main",
+        branch: "clawpatch/pat_open_pr_recorded_base",
+      })) as { commit: string; pr: string };
+      const parent = (
+        await runCommand(`git show -s --format=%P ${opened.commit}`, root)
+      ).stdout.trim();
+      const committed = await runCommand(`git show --name-only --format= ${opened.commit}`, root);
+
+      expect(opened.pr).toBe("https://github.com/openclaw/clawpatch/pull/1005");
+      expect(parent).toBe(baseSha);
+      expect(committed.stdout.trim().split("\n")).toEqual(["src/index.ts"]);
+    } finally {
+      if (previousGh === undefined) {
+        delete process.env["CLAWPATCH_GH"];
+      } else {
+        process.env["CLAWPATCH_GH"] = previousGh;
+      }
+    }
+  });
+
   it("switches to an existing patch branch when opening a PR", async () => {
     const root = await fixtureRoot("clawpatch-open-pr-existing-branch-");
     await writeFixture(