@tekyzinc/gsd-t 5.17.14 → 5.18.11

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 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`)
+
+Before any code exists, enumerate every test case a milestone's requirements imply into a
+reviewable sequence-table document. Every row nobody can fill in is a requirements gap.
+
+- `commands/gsd-t-test-plan.md` + `/gsd` router case: the front door (in-session, judgement-driven).
+- `templates/prompts/test-plan-enumerator-subagent.md`: the eight enumeration rules (E1-E8), generic
+  worked examples; `templates/TestPlan-spec.md`: the mold; `templates/prompts/test-plan-evidence-classifier.md`:
+  the `--after` classifier (three arms, no default).
+- `bin/gsd-t-testplan-rows.cjs`: the ONE plan reader (both fence styles, exact six-cell rows, one classifier).
+- `bin/gsd-t-testplan-lint.cjs` (0/4/64), `bin/gsd-t-testplan-halt.cjs` (three-round cap + repeated-symptom
+  cap over the loop ledger, per plan and per round), `bin/gsd-t-traceability-gate.cjs` (additive `**Plan-Row**`
+  binding; GAP / malformed / duplicate / escaped rows never clear).
+- Verify-gate wiring with a NAMED skip when no plan exists; discovery failure halts.
+- Contract `.gsd-t/contracts/test-plan-first-contract.md` 1.1.0 STABLE; `integration-points.md`.
+- Held-out fixture `test/fixtures/m115-blind-replay/` (the TimeTracking rate-ledger answer key) and the
+  clean-room replay artifacts under `.gsd-t/scan/`.
+- 120 milestone tests, of which 29 pin verify findings across seven verify runs.
+
 ## [5.17.14] - 2026-09-03
 
 ### Fixed — two more gate defects surfaced by TimeTracking (TD-395 round 2), plus a silent library and a crashing finalizer

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v5.17.14** - 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.
@@ -197,6 +197,7 @@ This will replace changed command files, back up your CLAUDE.md if customized, a
 | `/gsd-t-milestone` | Define new milestone | Manual |
 | `/gsd-t-partition` | Decompose into domains + contracts | In wave |
 | `/gsd-t-plan` | Create atomic task lists per domain (tasks auto-split to fit one context window) | In wave |
+| `/gsd-t-test-plan` | Enumerate every test case a requirements doc implies, before any code or tests exist (`--after` re-enumerates against built code, classifying failures by cited evidence) | Manual |
 | `/gsd-t-impact` | Analyze downstream effects | In wave |
 | `/gsd-t-architect` | Interviews you first (shows its read of current behavior for confirmation, researches when unsure — max 3 cycles), then runs the Architect's Oversight Six-Stage Pass — simplest solution + reuse + traps, as plain-English pseudocode (plan-only; `--build` to auto-build, `--no-interview`/`--no-research` to skip a stage) | Manual |
 | `/gsd-t-execute` | Run tasks — task-level fresh dispatch, worktree isolation, adaptive replanning | In wave |

package/bin/gsd-t-graph-use-gate.cjs

@@ -167,8 +167,11 @@ function evaluate(consumers) {
     if (c.wiringModes.length === 0) continue; // never declared; nothing claimed, nothing to prove
 
     const claimedWired = c.wiringModes.some((m) => m.toLowerCase() === 'wired');
-    const since = c.firstWiringTs || '';
-    const attributed = unlabelledQueryTs.filter((ts) => ts && ts >= since).length;
+    // A claim with no usable timestamp cannot be placed in time, so nothing
+    // can be attributed to it — the one `|| ''` here made EVERY query evidence,
+    // queries before the claim included (code-review M115 run 7).
+    const since = c.firstWiringTs;
+    const attributed = since ? unlabelledQueryTs.filter((ts) => ts && ts >= since).length : 0;
     const evidenceCount = c.queryCount + attributed;
     checked.push({ consumer: id, wiringModes: c.wiringModes, queryCount: c.queryCount, attributedQueryCount: attributed });
 

package/bin/gsd-t-logging-envelope-check.cjs

@@ -440,10 +440,10 @@ function _readManifest(projectDir) {
   if (!fs.existsSync(p)) return { present: false, manifest: null, error: null };
   try {
     const m = JSON.parse(fs.readFileSync(p, 'utf8'));
-    if (!m || typeof m !== 'object' || Array.isArray(m)) return { present: true, manifest: null, error: 'manifest is not a JSON object' };
+    if (!m || typeof m !== 'object' || Array.isArray(m)) return { present: true, manifest: null, error: '.gsd-t/logging-manifest.json is not a JSON object' };
     return { present: true, manifest: m, error: null };
   } catch (err) {
-    return { present: true, manifest: null, error: 'manifest is not valid JSON: ' + (err && err.message ? err.message : String(err)) };
+    return { ok: false, present: true, manifest: null, error: '.gsd-t/logging-manifest.json is not valid JSON: ' + (err && err.message ? err.message : String(err)) };
   }
 }
 
@@ -455,8 +455,16 @@ function _declaredStream(projectDir, manifest, stream, failures, notes) {
     failures.push({ rule: 'logging-manifest-invalid', stream, detail: 'manifest.' + stream + ' must be an object' });
     return out;
   }
+  // A declared path must stay inside the project (same containment the plan-row
+  // loader enforces — review M115 run 7).
+  const inside = (rel) => {
+    if (typeof rel !== 'string' || !rel) return null;
+    const root = path.resolve(projectDir);
+    const abs = path.resolve(root, rel);
+    return abs.startsWith(root + path.sep) ? abs : null;
+  };
   if (d.module !== undefined) {
-    const abs = typeof d.module === 'string' && d.module ? path.join(projectDir, d.module) : null;
+    const abs = inside(d.module);
     if (!abs || !fs.existsSync(abs)) {
       failures.push({ rule: 'logging-manifest-invalid', stream, detail: 'declared ' + stream + ' module not found: ' + String(d.module) });
     } else {
@@ -465,8 +473,8 @@ function _declaredStream(projectDir, manifest, stream, failures, notes) {
   }
   if (d.store !== undefined) {
     if (typeof d.store === 'string' && d.store) {
-      const abs = path.join(projectDir, d.store);
-      if (!fs.existsSync(abs)) failures.push({ rule: 'logging-manifest-invalid', stream, detail: 'declared ' + stream + ' store not found: ' + d.store });
+      const abs = inside(d.store);
+      if (!abs || !fs.existsSync(abs)) failures.push({ rule: 'logging-manifest-invalid', stream, detail: 'declared ' + stream + ' store not found (or outside the project): ' + d.store });
       else out.storePath = abs;
     } else if (d.store && typeof d.store === 'object' && typeof d.store.kind === 'string' && d.store.kind) {
       out.externalStore = d.store;

package/bin/gsd-t-migrate-logging.cjs

@@ -110,20 +110,9 @@ function writeDistilledSchemaIfAbsent(projectDir, planPath) {
  * a file that already exists in the target project is left byte-for-byte
  * untouched (recorded in `skipped`, never in `created`).
  */
-// .gsd-t/logging-manifest.json — same reader the envelope checker uses (kept in
-// step with bin/gsd-t-logging-envelope-check.cjs _readManifest; a stream is
-// "declared" when its `module` is named).
-function readManifest(projectDir) {
-  const p = path.join(projectDir, '.gsd-t', 'logging-manifest.json');
-  if (!fs.existsSync(p)) return { present: false, manifest: null, error: null };
-  try {
-    const m = JSON.parse(fs.readFileSync(p, 'utf8'));
-    if (!m || typeof m !== 'object' || Array.isArray(m)) return { present: true, manifest: null, error: '.gsd-t/logging-manifest.json is not a JSON object' };
-    return { present: true, manifest: m, error: null };
-  } catch (err) {
-    return { present: true, manifest: null, error: '.gsd-t/logging-manifest.json is not valid JSON: ' + (err && err.message ? err.message : String(err)) };
-  }
-}
+// The manifest reader lives in ONE place — the envelope checker — and is reused
+// here (review M115 run 7: two byte-identical copies had already appeared).
+const { _readManifest: readManifest } = require("./gsd-t-logging-envelope-check.cjs");
 
 function migrateLogging(projectDir, opts) {
   opts = opts || {};

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`?
  *