@tekyzinc/gsd-t 5.18.10 → 5.18.11

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.18.11] - 2026-09-07
+
+### Fixed — `gsd-t pick-worktree --name main` refused when the main checkout sat on a feature branch
+
+The launcher prompt offers `"main" = work in main`, but the picker only treated a name as
+"stay here" when it equalled the branch currently checked out. A main checkout left on
+`feat/m26-file-mgmt` (NiceNote) turned `main` into `git worktree add -b main`, which git refused:
+`a branch named 'main' already exists`. The person typing `main` means the FOLDER, not the branch.
+
+- `bin/gsd-t-pick-worktree.cjs`: a typed name means the main checkout when it equals EITHER the branch
+  checked out there OR the repo's default branch as the remote declares it (`origin/HEAD` → `main`);
+  nothing is inferred from the name, so a `trunk` repo with no remote still treats `main` as a new
+  branch. The stderr notice names the branch actually checked out.
+- Same class, other half: naming an EXISTING branch that is checked out nowhere now checks it out
+  into a worktree (`git worktree add <dest> <branch>`) instead of asking git to create it again.
+- 2 regression tests in `test/m111-pick-worktree.test.js`.
+
 ## [5.18.10] - 2026-09-03
 
 ### Added — M115 Test-Plan-First Requirements Interrogation (`/gsd-t-test-plan`)

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v5.18.10** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v5.18.11** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
 
 **Eliminates context rot** — task-level fresh dispatch (one subagent per task, ~10-20% context each) means compaction never triggers.
 **Compaction-proof debug loops** — `gsd-t headless --debug-loop` runs test-fix-retest cycles as separate `claude -p` sessions. A JSONL debug ledger persists all hypothesis/fix/learning history across fresh sessions. Anti-repetition preamble injection prevents retrying failed hypotheses. Escalation tiers (sonnet → opus → human) and a hard iteration ceiling enforced externally.

package/bin/gsd-t-pick-worktree.cjs

@@ -102,17 +102,20 @@ function main() {
   }
 
   if (wanted) {
-    // Asking for the repo's own default branch means "work here, in the main
-    // checkout" — not "make a worktree called main", which git refuses anyway
-    // because that branch is already checked out. Rare, but it is a real
-    // choice, and the only way to express it is to name it.
-    if (isDefaultBranch(cwd, branchNameFrom(wanted))) {
+    // Naming the main checkout means "work here" — not "make a worktree called
+    // main", which git refuses anyway. The main checkout answers to two names:
+    // the branch it is sitting on right now, and the repo's default branch
+    // (`main` in a repo whose origin/HEAD is main), which is what the launcher
+    // prompt offers even when the checkout has wandered onto a feature branch.
+    // Rare, but it is a real choice, and the only way to express it is to name it.
+    if (meansMainCheckout(cwd, branchNameFrom(wanted))) {
       // Said out loud on stderr: every other path here is silent, but this one
       // is a deliberate choice to work somewhere the house rules steer away
       // from, and silence would read as "the name was ignored". stdout stays
-      // empty because the shell reads it as the directory to move to.
+      // empty because the shell reads it as the directory to move to. The
+      // branch named is the one actually checked out, not the one typed.
       process.stderr.write(
-        `[GSD-T WORKTREE] staying in the main checkout on ${branchNameFrom(wanted)} — ` +
+        `[GSD-T WORKTREE] staying in the main checkout on ${currentBranch(cwd) || "(detached)"} — ` +
         `no worktree created.\n`
       );
       stay();
@@ -138,25 +141,45 @@ function main() {
 }
 
 /**
- * Is this the repo's own default branch — the one the main checkout sits on?
+ * Does this name refer to the main checkout — the folder the session started in?
  *
- * Asked of git rather than matched against a list: a repo may use `master`,
- * `trunk` or anything else, and a hardcoded list would send those repos into a
- * worktree named after their own main branch. The branch currently checked out
- * in the main tree IS the answer, since that is the thing being opted into.
+ * Two names do: the branch checked out there right now, and the repo's default
+ * branch. The second matters because the main checkout is often left on a
+ * feature branch, and the person typing "main" at the launcher prompt means the
+ * FOLDER, not the branch — a worktree on `main` is exactly what git refuses.
  *
- * A repo git cannot answer for is not the default-branch case — it falls
- * through to the ordinary worktree path, which fails loudly on its own if git
- * is genuinely broken.
+ * The default is asked of git (origin/HEAD), never assumed: a repo on `trunk`
+ * with no origin treats `main` as an ordinary new branch name. A repo git
+ * cannot answer for falls through to the ordinary worktree path, which fails
+ * loudly on its own if git is genuinely broken.
  */
-function isDefaultBranch(repo, name) {
+function meansMainCheckout(repo, name) {
+  const typed = String(name).toLowerCase();
+  // Both sides lowercased: a branch name typed at a prompt is a value the user
+  // types, and "Main" must mean main.
+  const current = currentBranch(repo);
+  if (current && current.toLowerCase() === typed) return true;
+  const def = defaultBranch(repo);
+  return Boolean(def) && def.toLowerCase() === typed;
+}
+
+// The branch the main checkout sits on; "" when detached or git cannot say.
+function currentBranch(repo) {
   const r = spawnSync("git", ["branch", "--show-current"], {
     cwd: repo, encoding: "utf8", timeout: 10000,
   });
-  if (r.status !== 0) return false;
-  // Both sides lowercased: a branch name typed at a prompt is a value the user
-  // types, and "Main" must mean main.
-  return String(r.stdout || "").trim().toLowerCase() === String(name).toLowerCase();
+  return r.status === 0 ? String(r.stdout || "").trim() : "";
+}
+
+// The repo's default branch as the remote declares it (origin/HEAD → "main"),
+// or null when there is no remote to ask. Nothing is inferred from the name.
+function defaultBranch(repo) {
+  const r = spawnSync("git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], {
+    cwd: repo, encoding: "utf8", timeout: 10000,
+  });
+  if (r.status !== 0) return null;
+  const ref = String(r.stdout || "").trim();
+  return ref.startsWith("origin/") ? ref.slice("origin/".length) : null;
 }
 
 // Turn what the user typed into a name git will accept, without silently
@@ -253,9 +276,13 @@ function enterOrCreate(repo, home, branch) {
 
   fs.mkdirSync(home, { recursive: true });
 
-  const r = spawnSync("git", ["worktree", "add", dest, "-b", branch], {
-    cwd: repo, encoding: "utf8",
-  });
+  // A branch that already exists (a feature branch from last week, nobody in
+  // it) is checked out as it is; `-b` would ask git to create it again, and git
+  // refuses. Only a name git has never seen becomes a new branch.
+  const args = localBranchExists(repo, branch)
+    ? ["worktree", "add", dest, branch]
+    : ["worktree", "add", dest, "-b", branch];
+  const r = spawnSync("git", args, { cwd: repo, encoding: "utf8" });
 
   // git writes progress to stderr even when it succeeds, so the exit code and
   // the directory existing are what actually prove it worked.
@@ -272,6 +299,14 @@ function enterOrCreate(repo, home, branch) {
   return { path: dest };
 }
 
+// Is there a local branch by this exact name? Asked of git's refs, not the
+// worktree list, so a branch checked out nowhere still counts.
+function localBranchExists(repo, branch) {
+  return spawnSync("git", ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], {
+    cwd: repo, stdio: "pipe", timeout: 10000,
+  }).status === 0;
+}
+
 /**
  * Does THIS repo know `dest` as its worktree for `branch`?
  *

package/commands/cpua.md

@@ -133,8 +133,16 @@ if [ "$ON_DISK" != "{NEW_VERSION}" ]; then
   ON_DISK=$(node -p "require('$G/package.json').version")
   [ "$ON_DISK" = "{NEW_VERSION}" ] || { echo "HALT: global install still $ON_DISK"; exit 1; }
 fi
-# 3. Only now propagate.
+# 3. Refresh the HOME install (commands + ~/.claude/.gsd-t-version) BEFORE propagating.
+#    v5.18.10 (2026-09-03): with the version file still on the old number, `update-all`
+#    reported all 33 projects "already current", copied nothing, and the global package
+#    was found back on the old version afterwards. `gsd-t install` writes the version
+#    file and the command files; only then does update-all see the new release.
+gsd-t install 2>&1 | tail -5
+[ "$(cat ~/.claude/.gsd-t-version)" = "{NEW_VERSION}" ] || { echo "HALT: ~/.claude/.gsd-t-version did not advance"; exit 1; }
+# 4. Propagate, then prove the global is STILL the new version and a NEW file reached a project.
 gsd-t update-all 2>&1 | tail -30
+[ "$(node -p "require('$G/package.json').version")" = "{NEW_VERSION}" ] || { echo "HALT: global package reverted during update-all"; exit 1; }
 ```
 
 Never `npm update -g` (npm rejects it for legacy version strings like `3.19.00`). After `update-all`, prove propagation by `ls`/`grep` of one NEW or CHANGED file in a real registered project — the "copied N tool(s)" line is a report, not proof. Note: `update-all` also overwrites `~/.claude/commands/*.md` from the package, so THIS file's source of truth is `commands/cpua.md` in the GSD-T repo; an edit made only in `~/.claude/commands/` is lost on the next propagation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.18.10",
+  "version": "5.18.11",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 54 slash commands with headless-by-default workflow spawning, unattended supervisor relay with event stream, graph-powered code analysis, real-time agent dashboard, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",

package/templates/CLAUDE-global.md

@@ -154,7 +154,7 @@ WHEN creating a worktree directly (git worktree add, isolation: "worktree", etc.
 
 **A worktree is NOT usable until it is provisioned (M112).** `git worktree add` brings only what git TRACKS, so every ignored file stays behind — `.env` and its secrets, local settings, and the installed dependencies. The new folder looks complete and is not: tests fail on a missing module and the app cannot reach its database, both reading as broken code rather than a setup gap. `bin/gsd-t-worktree-provision.cjs` runs automatically inside `gsd-t-pick-worktree` and treats the three kinds of ignored file differently — **CARRY** local config and secrets (`.env*`, `.npmrc`, credentials; permissions preserved, so a 600 secret does not become world-readable), **SKIP** per-session `.gsd-t` state, build output and OS junk (copying another session's briefs/heartbeats is how two sessions come to believe they own the same work), and **INSTALL** dependencies from the worktree's own lockfile rather than copying or symlinking (a symlink makes a lockfile change in one tree silently alter the other). Anything it cannot read or copy is REPORTED, and a failed install HALTS — a worktree that came up short says so instead of looking ready. Creating a worktree by hand skips all of this, so prefer `gsd-t-pick-worktree --name <branch>`.
 
-**Naming an existing worktree WALKS YOU INTO IT (M113).** `gsd-t pick-worktree --name <branch>` used to refuse whenever the folder was already there, which refused the ordinary case — your own worktree, from yesterday, nobody in it — and left no way back except quitting the session and starting one by hand. It now ENTERS a worktree git confirms as this repo's, on that branch, with no interactive session in it. Two cases still STOP, because each is a way of landing on somebody's uncommitted work: a directory git does not know as that branch's worktree (a stray folder, or another branch's), and a worktree an interactive session already occupies (the M105 collision). `gsd-t pick-worktree --list` prints one line per worktree as `free|busy<TAB><path>`, so the launcher can show what exists before asking for a name.
+**Naming an existing worktree WALKS YOU INTO IT (M113).** `gsd-t pick-worktree --name <branch>` used to refuse whenever the folder was already there, which refused the ordinary case — your own worktree, from yesterday, nobody in it — and left no way back except quitting the session and starting one by hand. It now ENTERS a worktree git confirms as this repo's, on that branch, with no interactive session in it. Two cases still STOP, because each is a way of landing on somebody's uncommitted work: a directory git does not know as that branch's worktree (a stray folder, or another branch's), and a worktree an interactive session already occupies (the M105 collision). `gsd-t pick-worktree --list` prints one line per worktree as `free|busy<TAB><path>`, so the launcher can show what exists before asking for a name. **Typing the DEFAULT branch (`main`) means the main checkout FOLDER, even when that checkout sits on a feature branch** — the picker asks git for the remote-declared default (`origin/HEAD`) as well as the current branch, and stays put on either; an existing branch checked out nowhere is checked out into a worktree, never re-created.
 
 
 **The expected-branch rule governs the MAIN checkout only (M112).** A worktree exists precisely to be on its own branch, so `branch-guard` passes there and names the skip; a **detached HEAD in a worktree FAILS**, because commits made with no branch attached are easily lost. The rule is read from the project CLAUDE.md in either shape — a sentence (`Expected branch: main`) or a table row (`| Expected branch | main |`) — and when no rule is declared the check says `NOT CHECKED` rather than returning a bare pass.