@opengsd/gsd-core 1.5.0 → 1.6.0-rc.1

package/gsd-core/bin/lib/uat-predicate.cjs

@@ -19,6 +19,9 @@ const node_path_1 = __importDefault(require("node:path"));
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const frontmatter = require("./frontmatter.cjs");
 const { extractFrontmatter } = frontmatter;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const markdownSectionizer = require("./markdown-sectionizer.cjs");
+const { stripFencedCode } = markdownSectionizer;
 // ─── Blocking state sets (documented for maintainability) ─────────────────────
 // UAT file frontmatter `status` values that indicate the file is not fully done
 const BLOCKING_UAT_FM_STATUSES = new Set([
@@ -53,8 +56,8 @@ function stripFalsePositiveContexts(content) {
     let stripped = content.replace(/^---\r?\n[\s\S]*?\r?\n---[ \t]*(\r?\n|$)/, '');
     // Step (b): remove HTML comments anywhere; unterminated comment swallows to EOF
     stripped = stripped.replace(/<!--[\s\S]*?(?:-->|$)/g, '');
-    // Step (c): remove fenced code blocks via CommonMark-style state machine (handles CRLF + indented fences)
-    stripped = _stripFencedBlocks(stripped).text;
+    // Step (c): remove fenced code blocks via the canonical seam (ADR-1372 T5)
+    stripped = stripFencedCode(stripped).text;
     // Step (d): remove blockquote lines
     stripped = stripped
         .split('\n')
@@ -62,49 +65,6 @@ function stripFalsePositiveContexts(content) {
         .join('\n');
     return stripped;
 }
-/**
- * CommonMark-style fenced-code-block stripper.
- * Tracks the opening delimiter char and length so that a ~~~ line inside a
- * ``` fence is correctly treated as fence content, not a closing delimiter.
- *
- * Opening rule: first delimiter line with char+len sets openFence.
- * Closing rule: delimiter line with SAME char, run length >= openFence.len,
- *   and NO trailing non-whitespace text closes the fence.
- * All delimiter and content lines are dropped; non-fence lines are kept.
- * Returns the kept text plus unterminatedFence:true if EOF inside a fence.
- */
-function _stripFencedBlocks(content) {
-    const lines = content.split('\n');
-    const kept = [];
-    let openFence = null;
-    const delimRe = /^(\s*)(`{3,}|~{3,})(.*)$/;
-    for (const rawLine of lines) {
-        // Tolerate CRLF: strip trailing \r for matching, but we work on split-by-\n lines
-        // (the outer caller joined by \n already; we just handle a stray \r in the last char)
-        const line = rawLine.replace(/\r$/, '');
-        const m = delimRe.exec(line);
-        if (m) {
-            const char = m[2][0];
-            const len = m[2].length;
-            const trailing = m[3];
-            if (openFence === null) {
-                // Opening delimiter — drop this line and record the fence
-                openFence = { char, len };
-            }
-            else if (char === openFence.char && len >= openFence.len && /^\s*$/.test(trailing)) {
-                // Closing delimiter (same char, sufficient length, no trailing text) — drop and close
-                openFence = null;
-            }
-            // else: mismatched delimiter inside fence (e.g. ~~~ inside ```) — drop as content
-            continue; // delimiter lines are always dropped
-        }
-        if (openFence === null) {
-            kept.push(rawLine);
-        }
-        // Lines inside fence are dropped
-    }
-    return { text: kept.join('\n'), unterminatedFence: openFence !== null };
-}
 /**
  * Analyse raw markdown for structural anomalies (unterminated fence / comment).
  * Exported for unit-testability and used by evaluateUatPassed for per-file malformed detection.
@@ -129,8 +89,8 @@ function analyzeMarkdown(raw) {
         }
         i = close + 3;
     }
-    // Fence state machine gives the accurate unterminated-fence signal.
-    const { unterminatedFence } = _stripFencedBlocks(raw);
+    // Fence state machine gives the accurate unterminated-fence signal (seam, ADR-1372 T5).
+    const { unterminatedFence } = stripFencedCode(raw);
     return { unterminatedFence, unterminatedComment };
 }
 // ─── parseUatResultItems ──────────────────────────────────────────────────────

package/gsd-core/bin/lib/uat.cjs

@@ -18,6 +18,9 @@ const node_path_1 = __importDefault(require("node:path"));
 const io = require("./io.cjs");
 const { output, error } = io;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
+const markdownSectionizer = require("./markdown-sectionizer.cjs");
+const { collectSection, tokenizeHeadings } = markdownSectionizer;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 const roadmapParser = require("./roadmap-parser.cjs");
 const { getMilestonePhaseFilter } = roadmapParser;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -128,11 +131,16 @@ function cmdRenderCheckpoint(cwd, options = {}, raw) {
 }
 // ─── parseCurrentTest ─────────────────────────────────────────────────────────
 function parseCurrentTest(content) {
-    const currentTestMatch = content.match(/##\s*Current Test\s*(?:\n<!--[\s\S]*?-->)?\n([\s\S]*?)(?=\n##\s|$)/i);
-    if (!currentTestMatch) {
+    // Use the seam to locate the ## Current Test section (ADR-1372 T5).
+    // HTML-comment stripping within the section body is UAT-specific, so we keep
+    // the comment removal caller-side after extracting the body.
+    const currentTestSection = collectSection(content, (h) => /^current\s+test$/i.test(h.text) && h.level === 2, { levelBounded: true });
+    if (!currentTestSection) {
         error('UAT file is missing a Current Test section');
     }
-    const section = currentTestMatch[1].trimEnd();
+    // Remove any leading HTML comment block (UAT-specific document structure)
+    const rawBody = currentTestSection.body.replace(/^<!--[\s\S]*?-->\s*\n?/, '');
+    const section = rawBody.trimEnd();
     if (!section.trim()) {
         error('Current Test section is empty');
     }
@@ -173,36 +181,41 @@ function parseCurrentTest(content) {
     };
 }
 function parseFirstPendingTest(content) {
-    const testsMatch = content.match(/##\s*Tests\s*\n([\s\S]*?)(?=\n##\s|$)/i);
-    if (!testsMatch) {
+    // Use the seam to locate the ## Tests section (ADR-1372 T5).
+    const testsSection = collectSection(content, (h) => /^tests$/i.test(h.text) && h.level === 2, { levelBounded: true });
+    if (!testsSection) {
         return null;
     }
-    const testsSection = testsMatch[1];
-    const headingPattern = /^###\s*(\d+)\.\s*([^\n]+)\s*$/gm;
-    const headings = [];
-    let headingMatch;
-    while ((headingMatch = headingPattern.exec(testsSection)) !== null) {
-        headings.push({
-            index: headingMatch.index,
-            number: parseInt(headingMatch[1], 10),
-            name: headingMatch[2].trim(),
-        });
-    }
-    for (let i = 0; i < headings.length; i += 1) {
-        const current = headings[i];
-        const next = headings[i + 1];
-        const block = testsSection.slice(current.index, next ? next.index : undefined);
+    const sectionBody = testsSection.body;
+    // Within the Tests section body, find ### N. Name sub-headings.
+    // tokenizeHeadings operates on the section body as a standalone document,
+    // filtering to level-3 headings matching the UAT-specific "N. Name" pattern.
+    // The UAT-specific item parsing (number extraction, result parsing) stays caller-side.
+    const subHeadings = tokenizeHeadings(sectionBody).filter((h) => h.level === 3 && /^\d+\.\s+/.test(h.text));
+    for (let i = 0; i < subHeadings.length; i += 1) {
+        const current = subHeadings[i];
+        const next = subHeadings[i + 1];
+        // Slice the block for this sub-test from the section body text
+        const block = next
+            ? sectionBody.slice(current.offset, next.offset)
+            : sectionBody.slice(current.offset);
         if (!/^result:\s*\[?pending\]?\s*$/im.test(block)) {
             continue;
         }
+        // Extract the UAT-specific number and name from the heading text
+        const headingParts = current.text.match(/^(\d+)\.\s+(.+)$/);
+        if (!headingParts)
+            continue;
+        const testNumber = parseInt(headingParts[1], 10);
+        const testName = headingParts[2].trim();
         const expected = parseExpectedFromTestBlock(block);
         if (!expected) {
-            error(`Pending UAT test ${current.number} is missing an expected field`);
+            error(`Pending UAT test ${testNumber} is missing an expected field`);
         }
         return {
             complete: false,
-            number: current.number,
-            name: (0, security_cjs_1.sanitizeForDisplay)(current.name),
+            number: testNumber,
+            name: (0, security_cjs_1.sanitizeForDisplay)(testName),
             expected: (0, security_cjs_1.sanitizeForDisplay)(expected),
         };
     }
@@ -273,10 +286,10 @@ function parseUatItems(content) {
 function parseVerificationItems(content, status) {
     const items = [];
     if (status === 'human_needed') {
-        // Extract from human_verification section — look for numbered items or table rows
-        const hvSection = content.match(/##\s*Human Verification.*?\n([\s\S]*?)(?=\n##\s|\n---\s|$)/i);
+        // Use the seam to locate the ## Human Verification section (ADR-1372 T5).
+        const hvSection = collectSection(content, (h) => /^human\s+verification/i.test(h.text) && h.level === 2, { levelBounded: true });
         if (hvSection) {
-            const lines = hvSection[1].split('\n');
+            const lines = hvSection.body.split('\n');
             for (const line of lines) {
                 // Match table rows: | N | description | ... |
                 const tableMatch = line.match(/\|\s*(\d+)\s*\|\s*([^|]+)/);

package/gsd-core/bin/lib/verify.cjs

@@ -50,7 +50,7 @@ const { getMilestoneInfo, stripShippedMilestones, extractCurrentMilestone } = ro
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const worktreeSafetyMod = require("./worktree-safety.cjs");
 const { inspectWorktreeHealth } = worktreeSafetyMod;
-const { planningDir } = planningWorkspace;
+const { planningDir, planningRoot } = planningWorkspace;
 const { extractFrontmatter, parseMustHavesBlock } = frontmatterMod;
 const { writeStateMd } = stateMod;
 const { MODEL_PROFILES } = modelProfilesMod;
@@ -1112,12 +1112,18 @@ function cmdValidateHealth(cwd, options, raw) {
         }, raw);
         return;
     }
-    const planBase = planningDir(cwd);
-    const projectPath = node_path_1.default.join(planBase, 'PROJECT.md');
-    const roadmapPath = node_path_1.default.join(planBase, 'ROADMAP.md');
-    const statePath = node_path_1.default.join(planBase, 'STATE.md');
-    const configPath = node_path_1.default.join(planBase, 'config.json');
-    const phasesDir = node_path_1.default.join(planBase, 'phases');
+    // rootBase always resolves to .planning/ (shared root — PROJECT.md, config.json live here)
+    // wsBase resolves to .planning/workstreams/<ws>/ when GSD_WORKSTREAM is set (STATE.md, ROADMAP.md, phases/)
+    const rootBase = planningRoot(cwd);
+    const wsBase = planningDir(cwd);
+    // planBase is kept as an alias for wsBase for all the internal helpers (collectDiskPhases, etc.)
+    // that are already parameterised on the workstream-aware path.
+    const planBase = wsBase;
+    const projectPath = node_path_1.default.join(rootBase, 'PROJECT.md');
+    const roadmapPath = node_path_1.default.join(wsBase, 'ROADMAP.md');
+    const statePath = node_path_1.default.join(wsBase, 'STATE.md');
+    const configPath = node_path_1.default.join(rootBase, 'config.json');
+    const phasesDir = node_path_1.default.join(wsBase, 'phases');
     const _slashRuntime = (0, runtime_slash_cjs_1.resolveRuntime)(cwd);
     const slash = (name) => (0, runtime_slash_cjs_1.formatGsdSlash)(name, _slashRuntime);
     const errors = [];
@@ -1133,7 +1139,7 @@ function cmdValidateHealth(cwd, options, raw) {
         else
             info.push(issue);
     };
-    if (!node_fs_1.default.existsSync(planBase)) {
+    if (!node_fs_1.default.existsSync(rootBase)) {
         addIssue('error', 'E001', '.planning/ directory not found', `Run ${slash('new-project')} to initialize`);
         output({ status: 'broken', errors, warnings, info, repairable_count: 0 }, raw);
         return;
@@ -1404,7 +1410,17 @@ function cmdValidateHealth(cwd, options, raw) {
                     continue;
                 }
                 if (finding['kind'] === 'stale') {
-                    addIssue('warning', 'W017', `Stale git worktree: ${finding['path']} (last modified ${finding['ageMinutes']} minutes ago)`, `Run: git worktree remove ${finding['path']} --force`);
+                    // Do not flag the active session's worktree — removing it would be harmful.
+                    const worktreePath = finding['path'];
+                    const activeCwd = process.cwd();
+                    const normalizedWorktree = node_path_1.default.resolve(worktreePath);
+                    const normalizedCwd = node_path_1.default.resolve(activeCwd);
+                    // Skip if the worktree IS the cwd or is an ancestor of it.
+                    const isActiveWorktree = normalizedCwd === normalizedWorktree ||
+                        normalizedCwd.startsWith(normalizedWorktree + node_path_1.default.sep);
+                    if (isActiveWorktree)
+                        continue;
+                    addIssue('warning', 'W017', `Stale git worktree: ${worktreePath} (last modified ${finding['ageMinutes']} minutes ago)`, `Run: git worktree remove ${worktreePath} --force`);
                 }
             }
         }
@@ -1440,8 +1456,8 @@ function cmdValidateHealth(cwd, options, raw) {
     catch {
         /* W021 check is advisory — skip on error */
     }
-    const milestonesPath = node_path_1.default.join(planBase, 'MILESTONES.md');
-    const milestonesArchiveDir = node_path_1.default.join(planBase, 'milestones');
+    const milestonesPath = node_path_1.default.join(rootBase, 'MILESTONES.md');
+    const milestonesArchiveDir = node_path_1.default.join(rootBase, 'milestones');
     const missingFromRegistry = [];
     try {
         if (node_fs_1.default.existsSync(milestonesArchiveDir)) {
@@ -1470,7 +1486,7 @@ function cmdValidateHealth(cwd, options, raw) {
         /* intentionally empty — milestone sync check is advisory */
     }
     try {
-        const entries = node_fs_1.default.readdirSync(planBase, { withFileTypes: true });
+        const entries = node_fs_1.default.readdirSync(rootBase, { withFileTypes: true });
         for (const entry of entries) {
             if (!entry.isFile())
                 continue;
@@ -1566,7 +1582,7 @@ function cmdValidateHealth(cwd, options, raw) {
                         }
                         const milestone = getMilestoneInfo(cwd);
                         const projectRef = node_path_1.default
-                            .relative(cwd, node_path_1.default.join(planningDir(cwd), 'PROJECT.md'))
+                            .relative(cwd, node_path_1.default.join(rootBase, 'PROJECT.md'))
                             .split(node_path_1.default.sep)
                             .join('/');
                         let stateContent = `# Session State\n\n`;

package/gsd-core/bin/shared/config-defaults.manifest.json

@@ -93,5 +93,9 @@
   "plan_review": {
     "source_grounding": true,
     "source_grounding_authority": "grep"
+  },
+  "capabilities": {
+    "strict_known_registries": null,
+    "auto_update": false
   }
 }

package/gsd-core/bin/shared/config-schema.manifest.json

@@ -55,6 +55,7 @@
     "workflow.subagent_timeout",
     "workflow.test_command",
     "workflow.build_command",
+    "workflow.mvp_mode",
     "executor.stall_detect_interval_minutes",
     "executor.stall_threshold_minutes",
     "workflow.inline_plan_threshold",
@@ -91,7 +92,9 @@
     "model_policy.high",
     "model_policy.medium",
     "model_policy.low",
-    "agent_skills_security.trusted_global_roots"
+    "agent_skills_security.trusted_global_roots",
+    "capabilities.strict_known_registries",
+    "capabilities.auto_update"
   ],
   "runtimeStateKeys": [
     "workflow._auto_chain_active"

package/gsd-core/references/execute-phase-between-wave-reset.md

@@ -0,0 +1,43 @@
+7b. **Pre-wave dependency check (waves 2+ only):**
+    Before wave N+1, run `gsd-tools.cjs query verify.key-links {phase_dir}/{plan}-PLAN.md` for each upcoming plan.
+    If any PRIOR-wave artifact link fails, present:
+    - `## Cross-Plan Wiring Gap` with plan/link/from/pattern rows
+    - Options: investigate+fix before continue, or continue with cascade risk
+    Skip key-links that reference files in the CURRENT (upcoming) wave.
+
+7c. **Between-wave manifest reset and worktree base refresh (waves 2+ only — #1369):**
+
+   **REQUIRED before each wave transition when `USE_WORKTREES != "false"` and `RUNTIME = "claude"`.**
+
+   Wave N's `WAVE_WORKTREE_MANIFEST` was consumed by `worktree.cleanup-wave` in step 5.5. It must be
+   unset so wave N+1's step 3 creates a fresh manifest for the new wave's worktrees. Without this,
+   the wave N+1 manifest guard (step 5.5, #3384) blocks on the stale/empty consumed file.
+
+   After wave N merges and tracking commits, the orchestrator HEAD has advanced past the commit the
+   Claude Code harness may have cached as the worktree fork base at session start. New worktrees
+   spawned for wave N+1 could fork from the stale pre-wave-N HEAD, causing every executor to trip the
+   `worktree_branch_check` FATAL guard immediately (symptom: `HEAD is <old-sha>, expected <new-sha>`).
+
+   ```bash
+   # Unset per-wave manifest so wave N+1 creates a fresh one (#3384, #1369).
+   unset WAVE_WORKTREE_MANIFEST
+
+   # Between-wave base refresh (#1369): after wave N merges and tracking commits, HEAD has
+   # advanced. Re-assert worktree.baseRef:"head" (idempotent — no-op if already set) so the
+   # Claude Code harness re-reads the live HEAD on the next Agent(isolation="worktree") call
+   # rather than using a cached session-start commit as the fork base.
+   if [ "$RUNTIME" = "claude" ] && [ "$USE_WORKTREES" != "false" ]; then
+     gsd_run query worktree.set-baseref 2>/dev/null || true
+
+     # Safety re-check: evaluate degradation AFTER the wave N commits. If HEAD has diverged
+     # from origin/HEAD and baseRef is NOT "head", degrade remaining waves to sequential to
+     # avoid the base-mismatch FATAL in executor agents.
+     _BETWEEN_DEGRADE=$(gsd_run query worktree.base-check --pick shouldDegrade 2>/dev/null || echo "false")
+     if [ "$_BETWEEN_DEGRADE" = "true" ]; then
+       _DEGRADE_MSG=$(gsd_run query worktree.base-check --pick message 2>/dev/null || true)
+       [ -n "$_DEGRADE_MSG" ] && printf '%s\n' "$_DEGRADE_MSG" >&2
+       printf 'Degrading to sequential mode for remaining waves: HEAD advanced past worktree fork base after wave %s merge (#1369).\n' "${N}" >&2
+       USE_WORKTREES=false
+     fi
+   fi
+   ```

package/gsd-core/references/execute-phase-wave-guard.md

@@ -0,0 +1,33 @@
+0.5. **Inter-wave worktree base re-check (wave N+1 guard — #1369):**
+
+   After Wave N merges and tracking commits advance orchestrator HEAD, Claude Code's
+   `isolation="worktree"` still forks new worktrees from `origin/HEAD` (the "fresh" base),
+   not the live HEAD. This means Wave N+1 worktrees would be created from the stale
+   pre-Wave-N base, causing the `worktree_branch_check` guard inside each executor to halt
+   immediately with a base-mismatch fatal.
+
+   **Run this check at the start of every wave when `USE_WORKTREES != "false"` and
+   `RUNTIME = "claude"`**, including Wave 1 (where it mirrors the initialize-step check):
+
+   ```bash
+   if [ "$RUNTIME" = "claude" ] && [ "${USE_WORKTREES:-true}" != "false" ]; then
+     _WAVE_DEGRADE=$(gsd_run query worktree.base-check --pick shouldDegrade 2>/dev/null || true)
+     if [ "$_WAVE_DEGRADE" = "true" ]; then
+       _WAVE_DEGRADE_MSG=$(gsd_run query worktree.base-check --pick message 2>/dev/null || true)
+       [ -n "$_WAVE_DEGRADE_MSG" ] && printf '%s\n' "$_WAVE_DEGRADE_MSG" >&2
+       echo "⚠ [#1369] Worktree fork base diverged from orchestrator HEAD (wave merges advanced HEAD past origin/HEAD). Auto-degrading to sequential mode for this wave to avoid base-mismatch halts." >&2
+       USE_WORKTREES=false
+     fi
+   fi
+   ```
+
+   If `shouldDegrade` is `true`, override `USE_WORKTREES=false` for **this wave only** —
+   all plans in this wave execute sequentially on the main working tree. Later waves re-run
+   this check and may re-enable worktree isolation if `origin/HEAD` is updated (e.g. via
+   `git fetch` or `worktree.baseRef:"head"` config).
+
+   **To avoid this degrade across all waves:** set `worktree.baseRef:"head"` in
+   `.claude/settings.local.json` (or run `gsd-tools worktree set-baseref`). This tells
+   Claude Code to fork from the live HEAD instead of `origin/HEAD`, so each wave's new
+   worktrees always start from the correct post-merge base. See #683 for the base-ref
+   configuration detail.

package/gsd-core/references/planner-antipatterns.md

@@ -174,3 +174,51 @@ If region-scoping is genuinely impractical and the file split is intentional, su
 ```
 
 One marker per pattern. The marker exempts only the exact pattern it names. Prefer region-scoping over suppression.
+
+## CLI Output Format Anchor Mismatch (#1478)
+
+`pnpm ls vite | grep -E '^vite@7\.'` looks correct but silently fails. `pnpm ls` uses tree characters as line prefixes:
+```
+my-project@1.0.0
+└── vite@7.3.5
+```
+Lines begin with `└──`, not `vite`. The `^` anchor matches line start, which is a tree character — the grep finds nothing.
+
+**Bad:** `pnpm ls vite | grep -E '^vite@7\.'`
+**Good:** `pnpm ls vite | grep -E 'vite@7\.'`
+**Good (strict):** `pnpm ls vite | grep -E '(└|├)── vite@7\.'`
+
+Same trap: `npm ls`, `yarn list`, `docker ps` column output, `kubectl get` table output.
+
+## Fabricated Numeric Baselines (#1478)
+
+Never emit `grep '714 tests'` or `grep '52 test files'` unless you ran the count command in this session. Model-recalled counts are stale from training.
+
+**Bad:** `npm test 2>&1 | grep '714 passed'`
+**Good:** `npm test 2>&1 | grep -E '[0-9]+ passed'` or just `npm test`
+
+## Error-Suppressing Fallbacks in Verify Gates (#1479)
+
+`2>/dev/null || echo "0"` in an assignment that feeds a comparison converts any failure into a passing gate that measures nothing.
+
+**Bad — both sides default to "0" when files are missing:**
+```bash
+EN_KEYS=$(jq 'keys | length' i18n/en.json 2>/dev/null || echo "0")
+DE_KEYS=$(jq 'keys | length' i18n/de.json 2>/dev/null || echo "0")
+[ "$EN_KEYS" = "$DE_KEYS" ] && echo "ok"
+```
+If files don't exist (wrong path, etc.), both sides become `"0"`. Comparison passes. Gate certifies parity while measuring nothing.
+
+**Good — let failure propagate:**
+```bash
+EN_KEYS=$(jq 'keys | length' src/i18n/en.json)
+DE_KEYS=$(jq 'keys | length' src/i18n/de.json)
+[ "$EN_KEYS" = "$DE_KEYS" ] && echo "ok"
+```
+
+**Good — explicit guard:**
+```bash
+test -f src/i18n/en.json && test -f src/i18n/de.json || { echo "missing input files"; exit 1; }
+```
+
+**When `|| echo "default"` is acceptable:** only when absence is semantically the default AND the result is NOT used in a comparison that should detect absence.

package/gsd-core/references/planning-config.md

@@ -266,6 +266,9 @@ Set via `workflow.*` namespace in config.json (e.g., `"workflow": { "research":
 | `workflow.subagent_timeout` | number | `300000` | Any positive integer (ms) | Timeout for parallel subagent tasks (default: 5 minutes) |
 | `workflow.test_command` | string\|null | `null` | Any shell command | Regression/test gate command run by verify-phase, execute-phase, audit-fix, and post-merge-gate. Unset → GSD auto-detects (Makefile / package.json / Cargo.toml / go.mod / pyproject.toml). |
 | `workflow.build_command` | string\|null | `null` | Any shell command | Build gate command run by the post-merge gate. Unset → build step auto-detected/skipped. |
+| `workflow.mvp_mode` | boolean | `false` | `true`, `false` | Persist the MVP-mode flag in config so every phase defaults to MVP framing without requiring `--mvp` on the CLI. Resolved via the chain: `--mvp` CLI flag → ROADMAP.md `**Mode:** mvp` field → this config value → `false`. When `true`, the planner, executor, verifier, and discovery surfaces (progress, stats, graphify) all treat the phase as an MVP vertical slice (UI → API → DB) of one user-visible capability. |
+| `workflow.plan_chunked` | boolean | `false` | `true`, `false` | Enable chunked planning mode. When `true`, the plan-phase orchestrator splits the single long-lived planner Task into a short outline Task followed by N short per-plan Tasks (~3–5 min each). Each plan is committed individually for crash resilience. Particularly useful on Windows where long-lived Tasks may hang on stdio. Also activated by the `--chunked` flag. |
+| `workflow.code_review_command` | string\|null | `null` | Any shell command | External code-review command integrated into `/gsd:ship`. The diff is piped to the command via stdin; the command must output JSON with a `verdict` field (`"APPROVED"` or `"REVISE"`). Non-zero exit or `"REVISE"` verdict blocks the ship workflow. When unset, the built-in review flow runs. Example: `my-review-tool --review`. |
 | `workflow.inline_plan_threshold` | number | `2` | `0`–`10` | Plans with ≤N tasks execute inline instead of spawning a subagent |
 | `workflow.code_review` | boolean | `true` | `true`, `false` | Enable built-in code review step in the ship workflow |
 | `workflow.code_review_depth` | string | `"standard"` | `"light"`, `"standard"`, `"deep"` | Depth level for code review analysis in the ship workflow |

package/gsd-core/references/scout-codebase.md

@@ -1,8 +1,8 @@
 # Codebase scout — map selection table
 
 > Lazy-loaded reference for the `scout_codebase` step in
-> `workflows/discuss-phase.md` (extracted via #2551 progressive-disclosure
-> refactor). Read this only when prior `.planning/codebase/*.md` maps exist
+> `workflows/discuss-phase.md` (extracted via the discuss-phase/modes progressive-disclosure split, #717).
+> Read this only when prior `.planning/codebase/*.md` maps exist
 > and the workflow needs to pick which 2–3 to load.
 
 ## Phase-type → recommended maps

package/gsd-core/workflows/discuss-phase/templates/context.md

@@ -4,7 +4,7 @@
 > `workflows/discuss-phase.md`, immediately before writing
 > `${phase_dir}/${padded_phase}-CONTEXT.md`. Do not put a reference to this
 > file in `<required_reading>` — that defeats the progressive-disclosure
-> savings introduced by issue #2551.
+> savings from the discuss-phase/modes split (#717).
 
 ## Variable substitutions
 

package/gsd-core/workflows/discuss-phase.md

@@ -19,8 +19,7 @@ You are a thinking partner, not an interviewer. The user is the visionary — yo
 
 <progressive_disclosure>
 **Per-mode bodies, templates, and the advisor flow are lazy-loaded** to keep
-this file under the 500-line workflow budget (#2551, mirrors #2361's agent
-budget). Read only the files needed for the current invocation:
+this file under the discuss-phase byte budget (32000 bytes, #717; mirrors the agent size-budget convention). Read only the files needed for the current invocation:
 
 | When | Read |
 |---|---|

package/gsd-core/workflows/execute-phase.md

@@ -491,6 +491,8 @@ increases monotonically across waves. `{status}` is `complete` (success),
 
 **For each wave:**
 
+@~/.claude/gsd-core/references/execute-phase-wave-guard.md
+
 1. **Intra-wave files_modified overlap check (BEFORE spawning):**
 
    Before spawning any agents for this wave, inspect the `files_modified` list of all plans
@@ -1038,12 +1040,8 @@ increases monotonically across waves. `{status}` is `complete` (success),
    **Step 7.3 — `class == "unknown-failure"`:**
    Report failed plan and ask Continue/Stop; continuing may cascade into dependent plan failures.
 
-7b. **Pre-wave dependency check (waves 2+ only):**
-    Before wave N+1, run `gsd-tools.cjs query verify.key-links {phase_dir}/{plan}-PLAN.md` for each upcoming plan.
-    If any PRIOR-wave artifact link fails, present:
-    - `## Cross-Plan Wiring Gap` with plan/link/from/pattern rows
-    - Options: investigate+fix before continue, or continue with cascade risk
-    Skip key-links that reference files in the CURRENT (upcoming) wave.
+@~/.claude/gsd-core/references/execute-phase-between-wave-reset.md
+
 8. **Execute checkpoint plans between waves** — see `<checkpoint_handling>`.
 9. **Proceed to next wave.**
 </step>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengsd/gsd-core",
-  "version": "1.5.0",
+  "version": "1.6.0-rc.1",
   "description": "GSD Core is a meta-prompting, context engineering, and spec-driven development system for AI coding agents.",
   "bin": {
     "gsd-core": "bin/install.js",
@@ -86,13 +86,13 @@
     "gen:capability-registry": "node scripts/gen-capability-registry.cjs --write",
     "prepack": "npm run build:lib",
     "prepare": "npm run build:lib",
-    "version": "node scripts/sync-manifest-versions.cjs --stage",
+    "version": "node scripts/sync-manifest-versions.cjs --stage && node scripts/gen-capability-registry.cjs --write && git add gsd-core/bin/lib/capability-registry.cjs",
     "prepublishOnly": "npm run build:lib && npm run build:hooks",
     "pretest": "npm run build:lib && npm run lint:skill-deps",
     "pretest:coverage": "npm run build:lib && npm run lint:skill-deps",
     "lint": "eslint . --cache --cache-location node_modules/.cache/eslint/",
     "lint:fix": "eslint . --fix",
-    "lint:ci": "npm run lint && npm run lint:skill-deps && node scripts/lint-test-file-count.cjs && node scripts/lint-command-contract.cjs && node scripts/lint-pr-check-project-dir.cjs && npm run lint:legacy-name && node scripts/lint-regression-test-names.cjs && node scripts/lint-windows-test-portability.cjs && node scripts/lint-allow-test-rule-refs.cjs",
+    "lint:ci": "npm run lint && npm run lint:skill-deps && node scripts/lint-test-file-count.cjs && node scripts/lint-command-contract.cjs && node scripts/lint-pr-check-project-dir.cjs && npm run lint:legacy-name && node scripts/lint-regression-test-names.cjs && node scripts/lint-windows-test-portability.cjs && node scripts/lint-allow-test-rule-refs.cjs && node scripts/lint-resolution-provenance.cjs",
     "lint:allow-test-rule-refs": "node scripts/lint-allow-test-rule-refs.cjs",
     "lint:windows-test-portability": "node scripts/lint-windows-test-portability.cjs",
     "lint:regression-names": "node scripts/lint-regression-test-names.cjs",