@pmelab/gtd 29.2.3 → 29.2.4

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "29.2.3",
+  "version": "29.2.4",
   "description": "Drive the gtd loop inside Claude Code: agent turns run as subagents, gtd decides every beat",
   "author": {
     "name": "Philipp Melab"

package/README.md

@@ -341,15 +341,16 @@ wait for the next rest. When the process finishes, Claude offers to squash it
 and open its pull request(s) (or run `/gtd ship`; `GTD_SHIP_MODE` picks one
 stacked pull request per slice or one commit per slice, see the
 [driver doc](docs/driver.md)); a process started for an issue ships with
-`Closes #N` on its top pull request; re-running `/gtd ship` after a lower
-stacked pull request merged restacks the rest (it refuses, with nothing changed,
-when that pull request merged anywhere but the default branch (unless into a
-lower slice branch before that one merged into it), a slice branch is checked
-out in another worktree, an unrelated local branch sits inside the rebased
-commits, or a slice's change is already upstream; a failed rebase is rolled
-back). A process can change hands at any gate: ask Claude to hand it off (or run
-`/gtd throw @dev`) and it opens a draft pull request assigned to them, and
-`/gtd catch <pr>` picks it up exactly where it waits, so whoever wrote the
+`Closes #N` on its top pull request; a closed pull request whose branch was
+deleted from origin is left behind and a new one opens; re-running `/gtd ship`
+after a lower stacked pull request merged restacks the rest (it refuses, with
+nothing changed, when that pull request merged anywhere but the default branch
+(unless into a lower slice branch before that one merged into it), a slice
+branch is checked out in another worktree, an unrelated local branch sits inside
+the rebased commits, or a slice's change is already upstream; a failed rebase is
+rolled back). A process can change hands at any gate: ask Claude to hand it off
+(or run `/gtd throw @dev`) and it opens a draft pull request assigned to them,
+and `/gtd catch <pr>` picks it up exactly where it waits, so whoever wrote the
 requirements can hand the architecture to someone else. Ship, hand-off and throw
 answer at once and run in the background, with progress on the status line; they
 report by waking Claude, a toast, a transcript line and a push notification, and

package/claude/hooks/ship.ts

@@ -633,7 +633,13 @@ export const NO_PR_FOUND = "no pull requests found"
 
 // `gh pr view <branch>`: only NO_PR_FOUND reads as none; any
 // other failure (auth, network) must refuse, or ship would open a duplicate PR.
-async function viewPr(io: ShipIo, branch: string): Promise<View | undefined | string> {
+// A closed PR whose branch origin lost is an abandoned earlier ship and reads as
+// none; `abandoned` is recorded before the push so a retry, with origin holding
+// the branch again, still reads it as none. `gone`: a tracking ref is stale.
+async function readPr(
+  io: ShipIo,
+  branch: string,
+): Promise<{ view?: View; gone?: boolean; abandoned?: number } | string> {
   const v = await io.run([
     "gh",
     "pr",
@@ -643,14 +649,41 @@ async function viewPr(io: ShipIo, branch: string): Promise<View | undefined | st
     "number,title,body,url,state,baseRefName,mergedAt",
   ])
   if (v.code !== 0) {
-    if (v.err.includes(NO_PR_FOUND)) return undefined
+    if (v.err.includes(NO_PR_FOUND)) return {}
     return `gh pr view ${branch} failed: ${v.err.trim()}`
   }
+  let view: View
   try {
-    return JSON.parse(v.out) as View
+    view = JSON.parse(v.out) as View
   } catch {
     return `gh pr view ${branch} returned something unreadable.`
   }
+  if (view.state !== "CLOSED") return { view }
+  const key = await io.run(["git", "config", "--local", "--get", ABANDONED_KEY(branch)])
+  const recorded = key.out.trim() === String(view.number)
+  const ls = await io.run(["git", "ls-remote", "origin", `refs/heads/${branch}`])
+  const gone = ls.code === 0 && !ls.out.trim()
+  if (recorded) return { gone }
+  return gone ? { gone, abandoned: view.number } : { view }
+}
+
+const ABANDONED_KEY = (branch: string) => `branch.${branch}.gtdAbandonedPr`
+
+// Once the new PR opens, gh pr view finds it: the record has served its purpose.
+async function settled<T extends Shipped>(io: ShipIo, branch: string, done: T) {
+  if (done.ok) await io.run(["git", "config", "--local", "--unset", ABANDONED_KEY(branch)])
+  return done
+}
+
+async function abandon(io: ShipIo, branch: string, pr: number | undefined) {
+  if (pr === undefined) return undefined
+  const set = await io.run(["git", "config", "--local", ABANDONED_KEY(branch), String(pr)])
+  return set.code === 0 ? undefined : `git config failed.\n${set.err}`.trimEnd()
+}
+
+async function viewPr(io: ShipIo, branch: string): Promise<View | undefined | string> {
+  const read = await readPr(io, branch)
+  return typeof read === "string" ? read : read.view
 }
 
 // `dead` names belong to a retired record gtd built itself: not a collision.
@@ -1512,10 +1545,13 @@ async function shipLink(
   const l = links[i]!
   const lower = i ? links[i - 1]! : undefined
   const base = baseOf(links, i, baseBranch)
-  const view = await viewPr(io, l.branch)
-  if (typeof view === "string")
-    return { step: "pull request", why: `${view} ${l.branch} was not pushed; /gtd ship retries.` }
-  const pushed = await pushLink(io, git, l, i < links.length - 1)
+  const read = await readPr(io, l.branch)
+  if (typeof read === "string")
+    return { step: "pull request", why: `${read} ${l.branch} was not pushed; /gtd ship retries.` }
+  const { view, gone } = read
+  const marked = await abandon(io, l.branch, read.abandoned)
+  if (marked) return { step: "push", why: marked }
+  const pushed = await pushLink(io, git, { ...l, fresh: l.fresh || gone }, i < links.length - 1)
   if (pushed) return { step: "push", why: pushed }
   const lowerRef = lower?.branch ?? baseRef
   const ctx: Ctx = {
@@ -1528,6 +1564,7 @@ async function shipLink(
   }
   const done = await sliceStep(io, git, ok, l, view, base, lowerRef, ctx)
   if ("step" in done) return done
+  if (!view) await settled(io, l.branch, done)
   if (done.number === undefined && i < links.length - 1)
     return { step: "pull request", why: "its number could not be read from gh's reply." }
   return done
@@ -1764,17 +1801,24 @@ async function pullRequest(
   if (mergeBase === (await git("rev-parse", "HEAD")))
     return fail(`HEAD is an ancestor of ${baseRef}: nothing to describe.`)
 
-  const existing = await viewPr(io, branch)
-  if (typeof existing === "string")
+  const read = await readPr(io, branch)
+  if (typeof read === "string")
     return fail(
-      `${existing} ${branch} was not pushed; the squash and history ref stay, /gtd ship retries.`,
+      `${read} ${branch} was not pushed; the squash and history ref stay, /gtd ship retries.`,
     )
+  const { view: existing, gone } = read
   if (existing && existing.state !== "OPEN")
     return fail(`The pull request for ${branch} is ${existing.state}, not open.`)
-  const pushed = await pushBranch(io, branch)
+  const marked = await abandon(io, branch, read.abandoned)
+  if (marked) return fail(`${marked} ${branch} was not pushed; /gtd ship retries.`)
+  const pushed = await pushBranch(io, branch, "HEAD", undefined, gone)
   if (pushed) return fail(pushed)
   if (!existing)
-    return createPr(io, git, branch, baseBranch, baseRef, { from: mergeBase, to: "HEAD" })
+    return settled(
+      io,
+      branch,
+      await createPr(io, git, branch, baseBranch, baseRef, { from: mergeBase, to: "HEAD" }),
+    )
   // A branch once shipped as a stack keeps the PR aimed at a slice branch; any
   // other base is the author's own and stays.
   const onSlice = recorded.some((n) => existing.baseRefName === `${branch}-${n}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "29.2.3",
+  "version": "29.2.4",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {