@pmelab/gtd 29.0.0 → 29.1.1

package/.claude-plugin/plugin.json

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

package/README.md

@@ -338,16 +338,21 @@ the process on only when you say so; a review you leave untouched signs off.
 While a step runs you can keep asking; requests for changes 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 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
-a failed push or `gh` call reports as a failure. While a ship or hand-off runs
-or is queued, `/gtd catch`, the doors, `/gtd <requirements>` and bare `/gtd`
-wait for its report. See
+per slice or one commit per slice, see the [driver doc](docs/driver.md));
+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 a failed push or `gh` call reports as a
+failure. While a ship or hand-off runs or is queued, `/gtd catch`, the doors,
+`/gtd <requirements>` and bare `/gtd` wait for its report. See
 [Inside Claude Code](https://github.com/pmelab/gtd/blob/main/docs/driver.md#inside-claude-code-the-gtd-mod).
 
 ### Then let an agent build your own
@@ -415,15 +420,20 @@ noted in steps 3 and 4 below.
 
 3. **You wait.** The work is split into vertical slices and built one at a time,
    each one starting from the unit and e2e tests it declares (a build turn
-   missing one is refused), checked against the full suite (`testCommand`) and
-   fixed until it passes before moving on — so keep that suite fast; gtd has no
-   lighter one. Scenario wording is not frozen: you sign the scenarios off once,
-   in the review's `## Scenarios` chunk, where any assertion an existing
-   scenario lost is marked `Weakened:`. After the last package the quality lap
-   runs. Two points along the process are judged rather than always asking you
-   outright — each stops and hands you a verdict to make (`gtd judge answer`, or
-   land with a clean tree to accept the conservative default, which never skips
-   work; `gtd judge run --provider fixed --answers <path>` — or the
+   missing one is refused; a test the package only relies on is marked
+   `(unchanged)`; it must exist before the turn, and the build turn must not
+   create, edit or delete it — a wrong marker is fixed upstream, in the plan,
+   and a process stuck on one is ended with `gtd abandon`; and a package whose
+   work lies outside the repository, such as filing issues, closes on recorded
+   evidence), checked against the full suite (`testCommand`) and fixed until it
+   passes before moving on — so keep that suite fast; gtd has no lighter one.
+   Scenario wording is not frozen: you sign the scenarios off once, in the
+   review's `## Scenarios` chunk, where any assertion an existing scenario lost
+   is marked `Weakened:`. After the last package the quality lap runs. Two
+   points along the process are judged rather than always asking you outright —
+   each stops and hands you a verdict to make (`gtd judge answer`, or land with
+   a clean tree to accept the conservative default, which never skips work;
+   `gtd judge run --provider fixed --answers <path>` — or the
    `GTD_JUDGE_ANSWERS` env var, inline JSON — answers one from a file, piped
    between `gtd judge --json` and `gtd judge answer`;
    `gtd judge run --provider jev` asks TypeSafe's Jev instead, with the key in

package/claude/hooks/handoff.ts

@@ -2,7 +2,7 @@
 // pushing the branch and telling them. `throw` opens (or refreshes) a draft
 // pull request for the hand-off; `catch` checks it out wherever it was thrown.
 
-import { pushBranch, THROWN } from "./ship"
+import { defaultBranch, pushBranch, THROWN } from "./ship"
 import type { ShipIo, Shipped } from "./ship"
 
 export type Rest = { state?: string; label?: string; content?: string; isIdle: boolean }
@@ -73,8 +73,7 @@ async function throwBranch(io: ShipIo, now: string) {
   const git = async (...args: string[]) => (await io.run(["git", ...args])).out.trim()
   const branch = await git("rev-parse", "--abbrev-ref", "HEAD")
   if (!branch || branch === "HEAD") return "Detached HEAD: there is no branch to throw."
-  const head = await git("symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD")
-  const base = head.replace(/^origin\//, "") || "main"
+  const base = await defaultBranch(git)
   if (branch !== base) return { branch, base }
   const fresh = `gtd/${now.replace(/[-:]/g, "").replace("T", "-").slice(0, 13)}`
   const switched = await io.run(["git", "switch", "-c", fresh])