@pmelab/gtd 28.2.0 → 29.1.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "28.2.0",
+  "version": "29.1.0",
   "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
@@ -570,8 +575,16 @@ home directory — fails every command until you delete it. See
 architecture and package files, the agent first implements the requirements
 directly. A judge checks whether it changed anything outside the expected set
 (tests, steering files; see `seamAllow`). Incidental changes land; a needed seam
-change goes to you for approval and is refactored first; a wrong approach is
-retried twice, then rests for you to steer or overrule it. Details in
+change is refactored first, in its own slice with its own quality lap
+(`refactorQualityReviews`) and review, before the feature is implemented and
+reviewed; a wrong approach is retried twice, then rests for you to steer or
+overrule it. `gtd slices` lists the `refactor` and `feature` slices. Feedback at
+the feature review re-runs design and the implementation, never the naive pass;
+feedback at the refactor review re-runs the refactor, never design; a
+refactor-review change the refactor cannot build is refused, and the only way
+out is `gtd abandon`. A process from 27.5.0 or later whose judge ruled
+`refactor-first` must `gtd abandon` too. Each slice's quality lap reviews only
+that slice. Details in
 [the naive-pass path](docs/configuration.md#the-naive-pass-path).
 
 **Risk tier (flag `GTD_FLAG_RISK_TIER=1`, off by default, needs
@@ -656,8 +669,9 @@ are not process history: `gtd history` does not list them, and the
 `refs/gtd/history/*` refspecs above neither push nor fetch them.
 
 A workflow can rest at an approval gate (`human(name, { approve: true })`; the
-`seamGate` helper does this after a `refactor-first` diff-shape judgment). Only
-a clean `gtd land` approves it, and the commit records who in a
+`seamGate` helper does this for a `refactor-first` diff-shape judgment; the
+shipped flow does not use it). Only a clean `gtd land` approves it, and the
+commit records who in a
 `Gtd-Approved: {"step":"<step>#<n>","name":"<name>","email":"<email>"}` trailer;
 a landing with any edit is refused (as is a script run after the tree changed —
 revert and land again), and `gtd abandon` is the only other way out. `approve`

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])