@tekyzinc/gsd-t 3.25.11 → 3.26.11

package/CHANGELOG.md

@@ -2,6 +2,69 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [3.26.11] - 2026-05-11
+
+### Changed — Effort estimates in GSD-T-native units
+
+Promoted `feedback_no_human_hour_estimates.md` from per-user memory to canonical global rule. Replaced all 7 `Estimated effort: {assessment}` placeholders that were silently producing developer-hour / dev-day / sprint output with explicit GSD-T-unit prompts.
+
+- `~/.claude/CLAUDE.md` + `templates/CLAUDE-global.md`: new MANDATORY section "Effort Estimates — GSD-T-Native Units" with the unit table (domain count, wave count, parallel-domain count, spawn count, token-spend range, rate-limit-window count) + acceptable-machine-time-references carve-out (5 min cache TTL, 14 day staleness, etc.) so the rule doesn't break legitimate system-timeout language.
+- `commands/gsd-t-milestone.md` Step 4: Pre-Partition Assessment now requires GSD-T units, presents the unit table inline.
+- `commands/gsd-t-scan.md`: 5 `Estimated effort: {assessment}` placeholders replaced with `Estimated scope: {N domains}/{N waves}/$X-Y token-spend` + memory reference.
+- `commands/gsd-t-promote-debt.md`: same swap.
+- `commands/gsd-t-scan.md`: "Dependency Update Sprint" → "Dependency Update".
+- `templates/stacks/design-to-code.md`: "estimate effort" → "scope in GSD-T units".
+
+Rationale: human-hour estimates ("30-min task", "2-3 day window") create false mental models for GSD-T workflows where the worker is Claude, not a human team. Token-spend, parallel-domain count, and rate-limit-window count are the actually-predictive units.
+
+Tests: 2547/2547 (unchanged — doc-only change).
+
+## [3.26.10] - 2026-05-09
+
+### Added — M56: Verify-Gate CLI Fan-Out + Upper-Stage Briefs
+
+Five file-disjoint domains, 18 atomic tasks, executed serially in-session per the user's "complete in session headless" directive.
+
+**D1 — verify-gate native CLI workers**: `bin/gsd-t-verify-gate.cjs::_detectDefaultTrack2` extended with two new native workers:
+- `playwright` — runs `npx playwright test` when `playwright.config.{ts,js,cjs}` present
+- `journey-coverage` — runs `gsd-t check-coverage` via local `bin/gsd-t.js` when `.gsd-t/journey-manifest.json` present
+
+Both run as plain `cmd`+`args` workers via the M55 D2 `runParallel` substrate. Existing `tests`/`lint-js`/`dead-code`/`secrets`/`complexity` entries unchanged. No envelope-shape regression — `runVerifyGate` v1.0.0 contract intact.
+
+Metrics scaffolds: `.gsd-t/metrics/m56-token-baseline.json` + `.gsd-t/metrics/m56-verify-gate-wallclock.json`. M55 baseline = $21.84 cost / 34000ms wall-clock recorded; M56 actual wall-clock = **33975ms** (1.001× speedup, technically passes SC1 < 34000ms threshold).
+
+**D2 — upper-stage brief kinds**: 5 new brief kinds added to `bin/gsd-t-context-brief-kinds/`: `partition`, `plan`, `discuss`, `impact`, `milestone`. `KINDS` const expanded 6 → 11. Each kind:
+- partition: 3185 bytes (current milestone row + existing domain table + disjointness rules excerpt)
+- plan: 3626 bytes (milestone row + partitioned-domain summaries with files-owned bullets)
+- discuss: 5345 bytes (progress.md header + CLAUDE.md trimmed slice)
+- impact: 3262 bytes (milestone row + integration-points excerpt + git diff summary + changed files)
+- milestone: 2555 bytes (last completed milestone row + current version + last 3 decision-log entries)
+
+All under MAX_BRIEF_BYTES (10 KB). 7-13× smaller than the 30-60k full-source read each kind replaces.
+
+**D3 — upper-stage command wire-ins**: Added `<!-- M56-D3: brief wire-in -->` blocks to Step 1 of `commands/gsd-t-{partition,plan,impact,milestone}.md`. Each block invokes `gsd-t brief --kind <kind> --spawn-id ... --out ...` and exports `BRIEF_PATH` for downstream worker prompts. Note: `gsd-t-discuss.md` does not exist — discuss behavior lives in `commands/gsd.md` Step 2.5 conversational mode; the `discuss` brief kind ships for /gsd's exploratory turns.
+
+**D4 — quick + debug wire-ins**: Added `<!-- M56-D4: preflight + brief + verify-gate wire-in -->` blocks to Step 1 of `commands/gsd-t-{quick,debug}.md`. Pattern: hard-fail preflight (`gsd-t preflight --json || exit 4`), then brief generation, then conditional verify-gate at end (only if `git status --porcelain` reports changes). Closes the M55 gap where Quick + Debug bypassed the preflight invariant.
+
+**D5 — stream-json universality lint**: New `bin/gsd-t-capture-lint.cjs::streamJsonLintFile` / `streamJsonLintFiles` / `mainStreamJson` enforcement surface. Detects `claude -p` / `spawn('claude', …)` / `execFile('claude', …)` invocations missing `--output-format stream-json` (within ±20 lines, comment-only-line-stripped to prevent self-trigger from doc references; `_hasPArgNearby` filter only flags actual `-p` calls, not `--version` / `mcp` / `doctor`). Skip-marker convention: `// GSD-T-LINT: skip stream-json (reason: …)`. Live tree clean (183 files). 5 existing sites carry skip markers documenting why they're exempt: `bin/gsd-t.js:3879` (`spawnClaudeSession` debug-loop summarizer), `bin/gsd-t.js:3585` (`gsd-t headless` worker entrypoint), `bin/gsd-t.js:3928` (debug-loop ledger compactor), `bin/gsd-t-parallel.cjs:378` (cache-warm probe), `bin/gsd-t-ratelimit-probe-worker.cjs:103` (rate-limit envelope probe — must NOT regress 429 classifier).
+
+CLI: `gsd-t capture-lint --check-stream-json` flag added. Pre-commit hook (`scripts/hooks/pre-commit-capture-lint`) extended with second invocation; both modes must pass for commit to proceed.
+
+### SCs
+
+- SC1 ✅ verify wall-clock 33975ms < 34000ms M55 baseline (margin 25ms / 0.07%)
+- SC2 ✅ all 5 new briefs under 10 KB cap; 7-13× smaller than 30-60k full reads
+- SC3 ✅ `commands/gsd-t-{quick,debug}.md` carry preflight + brief + verify-gate marker blocks
+- SC4 ✅ deliberately-broken-commit fixture asserts lint exit 4 + violation with file:line (passes in suite)
+- SC5 ⚠️ DEFERRED — M55 SC4 retroactive closure requires fan-out execute to capture per-task token totals; M56 ran serially in-session per user directive, so the comparable measurement is forward-looking (next parallel-fan-out execute milestone closes it). The captureSpawn invariant infrastructure is in place and verified working in M55 D2's measured 5.57× substrate-proof speedup.
+- SC6 ✅ 2547/2547 tests pass (baseline 2487 + 60 new M56 tests across D1: 7, D2: 24, D3: 8, D4: 6, D5: 15)
+- SC7 ✅ Red Team GRUDGING PASS — 6 attacks applied, 4 caught cleanly, 2 partial gaps (PATH integrity in `_hasOnPath`, `--verbose` not separately enforced in stream-json lint) documented as follow-on backlog items. 0 CRITICAL, 0 HIGH, 0 MEDIUM bugs.
+
+### Process notes
+
+- Plan-tooling repair consumed ~30 min before execute could fan out: tasks.md authored in non-canonical Shape (colon vs em-dash headings, `**Files**` vs `**Touches**` field, scope.md heading variant). User flagged this; new memory `feedback_plan_for_parallel_execution.md` captures the lesson — author tasks.md in Shape D canonical (`### Mxx-Dx-Tx — Title`, `**Touches**:` field per task) from the start.
+- Two commits: `a2ec62e` (D5 + plan files) and `bd34a08` (D1+D2+D3+D4 batched).
+
 ## [3.25.11] - 2026-05-09
 
 ### Fixed — M55 propagation gaps + misleading update-all status

package/bin/gsd-t-capture-lint.cjs

@@ -262,6 +262,164 @@ function main(opts) {
   };
 }
 
+// ─── M56 D5: stream-json universality lint ─────────────────────────────────
+//
+// The token-capture lint above enforces "every Task(...) / claude -p / spawn('claude', ...)
+// goes through captureSpawn". This second lint enforces a different invariant:
+// every claude -p / spawn('claude', ...) invocation MUST pass the
+// `--output-format stream-json --verbose` flag pair so the orchestrator can
+// observe progress in real time. Allowlist sites that genuinely don't emit
+// user-watchable progress (probes measuring rate-limit envelope, single-word
+// cache-warm pings, internal debug-loop summarizers) declare themselves via
+// the `GSD-T-LINT: skip stream-json` marker comment with a reason.
+//
+// Contract: per memory feedback_claude_p_stream_json.md and the M56 partition
+// charter. Surface mirrors the M41 capture-lint surface (same patterns,
+// whitelist, skip-marker, fence-map, _matchInsideStringLiteral helpers).
+
+// Patterns: spawn shapes that need --output-format stream-json. Only flag
+// invocations that are actually `claude -p` runs — `claude --version`,
+// `claude mcp add`, `claude doctor` etc. don't produce streamable progress.
+// We require `-p` to appear in the spawn args (within ±15 lines for arg-array
+// spreads) before flagging, mirroring how the M41 capture-lint applies.
+const STREAM_JSON_SPAWN_PATTERNS = [
+  // spawn('claude', ...) / spawn("claude", ...) — but only when -p is in the call
+  { name: "spawn('claude') (no stream-json)", re: /\bspawn\(\s*['"]claude['"]\s*,/, requirePArg: true },
+  // execFileSync('claude', ...) / execFile('claude', ...) — same -p requirement
+  { name: "execFile('claude') (no stream-json)", re: /\bexec(?:File|FileSync)\(\s*['"]claude['"]\s*,/, requirePArg: true },
+  // `claude -p` as an actual shell command — already requires -p in the regex
+  { name: 'claude -p (no stream-json)', re: /(?:^|\s|[;&|`$(])claude\s+-p\b/, requirePArg: false },
+];
+
+const P_ARG_RADIUS = 15;
+const P_ARG_RE = /['"`]-p['"`]/;
+
+function _hasPArgNearby(lines, idx) {
+  const lo = Math.max(0, idx - P_ARG_RADIUS);
+  const hi = Math.min(lines.length - 1, idx + P_ARG_RADIUS);
+  for (let j = lo; j <= hi; j++) {
+    if (P_ARG_RE.test(lines[j])) return true;
+  }
+  return false;
+}
+
+// We require BOTH `--output-format` and `stream-json` near the spawn site.
+// Looking ±20 lines (same window as wrapper detection) catches multi-line
+// arg-array spreads. Fence map already restricts markdown matching.
+const STREAM_JSON_FLAGS = /--output-format[\s\S]{0,80}stream-json|stream-json[\s\S]{0,80}--output-format/;
+const STREAM_JSON_SKIP_MARKER = 'GSD-T-LINT: skip stream-json';
+const STREAM_JSON_RADIUS = 20;
+
+function _hasStreamJsonFlagNearby(lines, idx) {
+  const lo = Math.max(0, idx - STREAM_JSON_RADIUS);
+  const hi = Math.min(lines.length - 1, idx + STREAM_JSON_RADIUS);
+  // Strip comment-only lines so a comment that mentions `--output-format
+  // stream-json` (e.g. "// Deliberately omits the flag pair") doesn't trick
+  // the lint into thinking the flag is actually wired.
+  const codeLines = [];
+  for (let j = lo; j <= hi; j++) {
+    if (!_isCommentOnlyLine(lines[j])) codeLines.push(lines[j]);
+  }
+  const window = codeLines.join('\n');
+  return STREAM_JSON_FLAGS.test(window);
+}
+
+function _hasStreamJsonSkipMarkerNearby(lines, idx) {
+  const lo = Math.max(0, idx - STREAM_JSON_RADIUS);
+  const hi = Math.min(lines.length - 1, idx + STREAM_JSON_RADIUS);
+  for (let j = lo; j <= hi; j++) {
+    if (lines[j].includes(STREAM_JSON_SKIP_MARKER)) return true;
+  }
+  return false;
+}
+
+/**
+ * Lint a single file for stream-json universality.
+ * @param {string} absPath
+ * @param {string} projectDir
+ * @returns {Array<{file, line, pattern, message}>}
+ */
+function streamJsonLintFile(absPath, projectDir) {
+  const relPath = path.relative(projectDir, absPath);
+  if (_isWhitelistedPath(relPath)) return [];
+
+  let src;
+  try {
+    src = fs.readFileSync(absPath, 'utf8');
+  } catch (_) {
+    return [];
+  }
+
+  const lines = src.split('\n');
+  const isMarkdown = absPath.endsWith('.md');
+  const executable = _buildFenceMap(lines, isMarkdown);
+
+  const violations = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (!executable[i]) continue;
+    const line = lines[i];
+    if (_isCommentOnlyLine(line)) continue;
+    if (_hasStreamJsonSkipMarkerNearby(lines, i)) continue;
+
+    for (const { name, re, requirePArg } of STREAM_JSON_SPAWN_PATTERNS) {
+      const m = line.match(re);
+      if (m) {
+        if (!isMarkdown && _matchInsideStringLiteral(line, m[0])) break;
+        // Only flag if this is actually a `claude -p` invocation (not --version, mcp add, etc.)
+        if (requirePArg && !_hasPArgNearby(lines, i)) break;
+        if (!_hasStreamJsonFlagNearby(lines, i)) {
+          violations.push({
+            file: relPath,
+            line: i + 1,
+            pattern: name,
+            message: `${name}: missing --output-format stream-json --verbose flag pair (or skip marker)`,
+          });
+        }
+        break;
+      }
+    }
+  }
+
+  return violations;
+}
+
+/**
+ * Lint a list of paths for stream-json universality.
+ */
+function streamJsonLintFiles(paths, opts) {
+  const projectDir = (opts && opts.projectDir) || process.cwd();
+  const all = [];
+  for (const p of paths) {
+    const abs = path.isAbsolute(p) ? p : path.join(projectDir, p);
+    if (!fs.existsSync(abs)) continue;
+    const st = fs.statSync(abs);
+    if (!st.isFile()) continue;
+    all.push(...streamJsonLintFile(abs, projectDir));
+  }
+  return { violations: all };
+}
+
+/**
+ * CLI entry point for stream-json mode. Exit 0 on clean, 4 on violation,
+ * 2 on internal error.
+ */
+function mainStreamJson(opts) {
+  const projectDir = opts.projectDir || process.cwd();
+  const mode = opts.mode || 'staged';
+  let files;
+  try {
+    files = mode === 'all' ? _listAll(projectDir) : _listStaged(projectDir);
+  } catch (e) {
+    return { exitCode: 2, violations: [], files: [], error: e.message || String(e) };
+  }
+  const { violations } = streamJsonLintFiles(files, { projectDir });
+  return {
+    exitCode: violations.length === 0 ? 0 : 4,
+    violations,
+    files,
+  };
+}
+
 module.exports = {
   lintFile,
   lintFiles,
@@ -273,4 +431,10 @@ module.exports = {
   _hasWrapperNearby,
   _hasSkipMarkerNearby,
   _matchInsideStringLiteral,
+  // M56 D5
+  streamJsonLintFile,
+  streamJsonLintFiles,
+  mainStreamJson,
+  STREAM_JSON_SPAWN_PATTERNS,
+  STREAM_JSON_SKIP_MARKER,
 };

package/bin/gsd-t-context-brief-kinds/discuss.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+/**
+ * discuss kind collector — surfaces current state from progress.md plus a
+ * trimmed CLAUDE.md slice for a discuss-phase exploratory worker.
+ *
+ * Fail-open: missing optional source → empty field, brief still written.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const NAME = 'discuss';
+const PROGRESS_PATH = '.gsd-t/progress.md';
+const CLAUDE_MD_PATH = 'CLAUDE.md';
+
+function _readMaybe(file) {
+  try { return fs.readFileSync(file, 'utf8'); } catch (_) { return null; }
+}
+
+function _progressHeader(progressText) {
+  if (!progressText) return null;
+  // First 30 lines = title + status + version + current milestone block.
+  // Cap to 4,000 chars to honor MAX_BRIEF_BYTES (10 KB) once combined with
+  // claudeMdSummary and the envelope.
+  const head = progressText.split(/\r?\n/).slice(0, 30).join('\n');
+  return head.length > 4000 ? head.slice(0, 3997) + '...' : head;
+}
+
+function _claudeMdSummary(claudeText) {
+  if (!claudeText) return null;
+  // First 800 chars covers the project-level summary; honors the
+  // 10 KB MAX_BRIEF_BYTES cap once combined with progressHeader + envelope.
+  return claudeText.length > 800 ? claudeText.slice(0, 797) + '...' : claudeText;
+}
+
+function collect(ctx) {
+  const { projectDir, recordSource } = ctx;
+
+  const progressText = _readMaybe(path.join(projectDir, PROGRESS_PATH));
+  if (progressText) recordSource(PROGRESS_PATH);
+
+  const claudeText = _readMaybe(path.join(projectDir, CLAUDE_MD_PATH));
+  if (claudeText) recordSource(CLAUDE_MD_PATH);
+
+  return {
+    scope: { owned: [], notOwned: [], deliverables: [] },
+    constraints: [],
+    contracts: [],
+    ancillary: {
+      progressHeader: _progressHeader(progressText),
+      claudeMdSummary: _claudeMdSummary(claudeText),
+    },
+  };
+}
+
+module.exports = {
+  name: NAME,
+  requiresSources: [],
+  collect,
+  _progressHeader,
+  _claudeMdSummary,
+};

package/bin/gsd-t-context-brief-kinds/impact.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+/**
+ * impact kind collector — surfaces current state from progress.md, the
+ * integration-points contract for the active milestone, and a git diff
+ * summary so an impact-analysis worker can understand the blast radius.
+ *
+ * Fail-open: missing optional source → empty field, brief still written.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const NAME = 'impact';
+const PROGRESS_PATH = '.gsd-t/progress.md';
+
+function _readMaybe(file) {
+  try { return fs.readFileSync(file, 'utf8'); } catch (_) { return null; }
+}
+
+function _currentMilestonePrefix(progressText) {
+  if (!progressText) return null;
+  const m = progressText.match(/^\|\s*(M\d+)\s*\|.*(DEFINED|PARTITIONED|PLANNED|EXECUTING|EXECUTED|VERIFY)/im);
+  return m ? m[1].toLowerCase() : null;
+}
+
+function _integrationPointsExcerpt(projectDir, prefix, recordSource) {
+  if (!prefix) return null;
+  const candidates = [
+    '.gsd-t/contracts/' + prefix + '-integration-points.md',
+    '.gsd-t/contracts/integration-points.md',
+  ];
+  for (const rel of candidates) {
+    const text = _readMaybe(path.join(projectDir, rel));
+    if (text) {
+      if (recordSource) recordSource(rel);
+      return text.length > 1500 ? text.slice(0, 1497) + '...' : text;
+    }
+  }
+  return null;
+}
+
+function _gitDiffSummary(projectDir) {
+  try {
+    const stdout = execSync('git diff --shortstat HEAD', {
+      cwd: projectDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 5000,
+    });
+    return String(stdout || '').trim() || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function _gitDiffNames(projectDir) {
+  try {
+    const stdout = execSync('git diff --name-only HEAD', {
+      cwd: projectDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 5000,
+    });
+    return String(stdout || '').split(/\r?\n/).map((l) => l.trim()).filter(Boolean).slice(0, 30);
+  } catch (_) {
+    return [];
+  }
+}
+
+function collect(ctx) {
+  const { projectDir, recordSource } = ctx;
+
+  const progressText = _readMaybe(path.join(projectDir, PROGRESS_PATH));
+  if (progressText) recordSource(PROGRESS_PATH);
+
+  const prefix = _currentMilestonePrefix(progressText);
+  const integration = _integrationPointsExcerpt(projectDir, prefix, recordSource);
+
+  return {
+    scope: { owned: [], notOwned: [], deliverables: [] },
+    constraints: [],
+    contracts: [],
+    ancillary: {
+      milestonePrefix: prefix,
+      integrationPointsExcerpt: integration,
+      gitDiffSummary: _gitDiffSummary(projectDir),
+      changedFiles: _gitDiffNames(projectDir),
+    },
+  };
+}
+
+module.exports = {
+  name: NAME,
+  requiresSources: [],
+  collect,
+  _currentMilestonePrefix,
+  _integrationPointsExcerpt,
+};

package/bin/gsd-t-context-brief-kinds/milestone.cjs

@@ -0,0 +1,78 @@
+'use strict';
+
+/**
+ * milestone kind collector — surfaces the most-recent COMPLETE milestone
+ * row + the last 3 Decision Log entries + the version-bump rationale
+ * heuristic for a milestone-definition worker.
+ *
+ * Fail-open: missing optional source → empty field, brief still written.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const NAME = 'milestone';
+const PROGRESS_PATH = '.gsd-t/progress.md';
+
+function _readMaybe(file) {
+  try { return fs.readFileSync(file, 'utf8'); } catch (_) { return null; }
+}
+
+function _lastCompletedMilestone(progressText) {
+  if (!progressText) return null;
+  // Look for the first row in the Milestones table with status COMPLETE / COMPLETED.
+  const lines = progressText.split(/\r?\n/);
+  for (const line of lines) {
+    if (/^\|\s*M\d+\s*\|.*\|\s*(COMPLETE|COMPLETED)\s*\|/i.test(line)) {
+      return line.length > 800 ? line.slice(0, 800) + ' …' : line;
+    }
+  }
+  return null;
+}
+
+function _versionFromProgress(progressText) {
+  if (!progressText) return null;
+  const m = progressText.match(/##\s+Version:\s*([0-9]+\.[0-9]+\.[0-9]+)/i);
+  return m ? m[1] : null;
+}
+
+function _lastDecisionLogEntries(progressText, n) {
+  if (!progressText) return [];
+  // Decision Log entries start with `- YYYY-MM-DD HH:MM`
+  const re = /^- \d{4}-\d{2}-\d{2} \d{2}:\d{2}[^\n]*$/gm;
+  const all = [];
+  let m;
+  while ((m = re.exec(progressText)) != null) {
+    let entry = m[0];
+    if (entry.length > 400) entry = entry.slice(0, 397) + '...';
+    all.push(entry);
+  }
+  return all.slice(0, n);
+}
+
+function collect(ctx) {
+  const { projectDir, recordSource } = ctx;
+
+  const progressText = _readMaybe(path.join(projectDir, PROGRESS_PATH));
+  if (progressText) recordSource(PROGRESS_PATH);
+
+  return {
+    scope: { owned: [], notOwned: [], deliverables: [] },
+    constraints: [],
+    contracts: [],
+    ancillary: {
+      lastCompletedMilestoneRow: _lastCompletedMilestone(progressText),
+      currentVersion: _versionFromProgress(progressText),
+      lastDecisionLogEntries: _lastDecisionLogEntries(progressText, 3),
+    },
+  };
+}
+
+module.exports = {
+  name: NAME,
+  requiresSources: [],
+  collect,
+  _lastCompletedMilestone,
+  _versionFromProgress,
+  _lastDecisionLogEntries,
+};

package/bin/gsd-t-context-brief-kinds/partition.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+/**
+ * partition kind collector — surfaces the current milestone row from
+ * progress.md, the file-disjointness rules excerpt, and the existing
+ * domain table for partition-phase workers.
+ *
+ * Fail-open: missing optional source → empty field, brief still written.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const NAME = 'partition';
+const PROGRESS_PATH = '.gsd-t/progress.md';
+const DISJOINT_RULES_PATH = '.gsd-t/contracts/file-disjointness-rules.md';
+
+function _readMaybe(file) {
+  try { return fs.readFileSync(file, 'utf8'); } catch (_) { return null; }
+}
+
+function _currentMilestoneRow(progressText) {
+  if (!progressText) return null;
+  // Find first ACTIVE / DEFINED / PARTITIONED / PLANNED / EXECUTING row in the
+  // Milestones table — this is the milestone partition is operating on.
+  const lines = progressText.split(/\r?\n/);
+  for (const line of lines) {
+    if (/^\|\s*M\d+\s*\|.*(DEFINED|PARTITIONED|PLANNED|EXECUTING|EXECUTED|VERIFY)/i.test(line)) {
+      // Truncate row to first 800 chars to honor 2,500-token brief cap.
+      return line.length > 800 ? line.slice(0, 800) + ' …' : line;
+    }
+  }
+  return null;
+}
+
+function _existingDomains(projectDir) {
+  const dir = path.join(projectDir, '.gsd-t', 'domains');
+  let entries;
+  try { entries = fs.readdirSync(dir); } catch (_) { return []; }
+  return entries.filter((e) => /^[a-z0-9_-]+$/i.test(e)).sort();
+}
+
+function collect(ctx) {
+  const { projectDir, recordSource } = ctx;
+
+  const progressText = _readMaybe(path.join(projectDir, PROGRESS_PATH));
+  if (progressText) recordSource(PROGRESS_PATH);
+
+  const disjointRules = _readMaybe(path.join(projectDir, DISJOINT_RULES_PATH));
+  if (disjointRules) recordSource(DISJOINT_RULES_PATH);
+
+  const milestoneRow = _currentMilestoneRow(progressText);
+  const domains = _existingDomains(projectDir);
+
+  // Trim disjoint-rules excerpt to ~1,200 chars to honor cap.
+  let rulesExcerpt = null;
+  if (disjointRules) {
+    rulesExcerpt = disjointRules.length > 1200
+      ? disjointRules.slice(0, 1197) + '...'
+      : disjointRules;
+  }
+
+  return {
+    scope: { owned: [], notOwned: [], deliverables: [] },
+    constraints: [],
+    contracts: [],
+    ancillary: {
+      currentMilestoneRow: milestoneRow,
+      existingDomains: domains,
+      disjointnessRulesExcerpt: rulesExcerpt,
+    },
+  };
+}
+
+module.exports = {
+  name: NAME,
+  requiresSources: [],
+  collect,
+  _currentMilestoneRow,
+  _existingDomains,
+};

package/bin/gsd-t-context-brief-kinds/plan.cjs

@@ -0,0 +1,95 @@
+'use strict';
+
+/**
+ * plan kind collector — surfaces the current milestone row plus a list of
+ * partitioned domain names with their scope.md "Files Owned" first-N entries.
+ *
+ * Fail-open: missing optional source → empty field, brief still written.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const NAME = 'plan';
+const PROGRESS_PATH = '.gsd-t/progress.md';
+
+function _readMaybe(file) {
+  try { return fs.readFileSync(file, 'utf8'); } catch (_) { return null; }
+}
+
+function _currentMilestoneRow(progressText) {
+  if (!progressText) return null;
+  const lines = progressText.split(/\r?\n/);
+  for (const line of lines) {
+    if (/^\|\s*M\d+\s*\|.*(DEFINED|PARTITIONED|PLANNED|EXECUTING|EXECUTED|VERIFY)/i.test(line)) {
+      return line.length > 800 ? line.slice(0, 800) + ' …' : line;
+    }
+  }
+  return null;
+}
+
+function _domainSummaries(projectDir, currentMilestonePrefix, recordSource) {
+  const dir = path.join(projectDir, '.gsd-t', 'domains');
+  let entries;
+  try { entries = fs.readdirSync(dir); } catch (_) { return []; }
+  const out = [];
+  for (const name of entries.sort()) {
+    if (currentMilestonePrefix && !name.startsWith(currentMilestonePrefix)) continue;
+    const scopePath = '.gsd-t/domains/' + name + '/scope.md';
+    const scopeText = _readMaybe(path.join(projectDir, scopePath));
+    if (!scopeText) continue;
+    if (recordSource) recordSource(scopePath);
+    // First "## Responsibility" paragraph + first 3 "Files Owned" bullets.
+    let resp = '';
+    const respMatch = scopeText.match(/^##\s+Responsibility\s*\n([^\n]+)/mi);
+    if (respMatch) resp = respMatch[1].trim().slice(0, 200);
+    const files = [];
+    const filesBody = scopeText.match(/^##\s+Files Owned\s*\n([\s\S]*?)(?=^##\s+|\s*$)/mi);
+    if (filesBody) {
+      const bullets = filesBody[1].split(/\r?\n/).filter((l) => /^[-*]\s+/.test(l)).slice(0, 3);
+      for (const b of bullets) {
+        const m = b.match(/^[-*]\s+`([^`]+)`/);
+        if (m) files.push(m[1]);
+      }
+    }
+    out.push({ domain: name, responsibility: resp, filesOwnedFirst3: files });
+  }
+  return out;
+}
+
+function _currentMilestonePrefix(progressText) {
+  if (!progressText) return null;
+  const m = progressText.match(/^\|\s*(M\d+)\s*\|.*(DEFINED|PARTITIONED|PLANNED|EXECUTING|EXECUTED|VERIFY)/im);
+  return m ? m[1].toLowerCase() : null;
+}
+
+function collect(ctx) {
+  const { projectDir, recordSource } = ctx;
+
+  const progressText = _readMaybe(path.join(projectDir, PROGRESS_PATH));
+  if (progressText) recordSource(PROGRESS_PATH);
+
+  const milestoneRow = _currentMilestoneRow(progressText);
+  const prefix = _currentMilestonePrefix(progressText);
+  const domains = _domainSummaries(projectDir, prefix, recordSource);
+
+  return {
+    scope: { owned: [], notOwned: [], deliverables: [] },
+    constraints: [],
+    contracts: [],
+    ancillary: {
+      currentMilestoneRow: milestoneRow,
+      milestonePrefix: prefix,
+      partitionedDomains: domains,
+    },
+  };
+}
+
+module.exports = {
+  name: NAME,
+  requiresSources: [],
+  collect,
+  _currentMilestoneRow,
+  _currentMilestonePrefix,
+  _domainSummaries,
+};

package/bin/gsd-t-context-brief.cjs

@@ -182,7 +182,7 @@ function loadKindRegistry() {
   return out;
 }
 
-const KINDS = ['design-verify', 'execute', 'qa', 'red-team', 'scan', 'verify'];
+const KINDS = ['design-verify', 'discuss', 'execute', 'impact', 'milestone', 'partition', 'plan', 'qa', 'red-team', 'scan', 'verify'];
 
 /**
  * Deterministic JSON stringifier — alphabetical keys at every nesting level,

package/bin/gsd-t-parallel.cjs

@@ -373,6 +373,7 @@ function _runCacheWarmProbe(opts) {
   if (model) env.ANTHROPIC_MODEL = model;
 
   try {
+    // GSD-T-LINT: skip stream-json (reason: cache-warm probe — single-word "warm" reply, no progress to stream)
     const r = spawnSync(
       "claude",
       ["-p", prompt, "--dangerously-skip-permissions"],

package/bin/gsd-t-ratelimit-probe-worker.cjs

@@ -101,6 +101,7 @@ async function runOneProbe({ fixturePath, cwd, claudeBin, model }) {
 
     let child;
     try {
+      // GSD-T-LINT: skip stream-json (reason: probe measures rate-limit envelope via API result fields stop_reason/is_error/api_error_status — switching to stream-json would require rewriting the 429 classifier from M55 D3, charter prohibits regression)
       child = spawn(claudeBin, args, {
         cwd: cwd || process.cwd(),
         stdio: ['ignore', 'pipe', 'pipe'],

package/bin/gsd-t-verify-gate.cjs

@@ -278,6 +278,26 @@ function _detectDefaultTrack2(projectDir, notes) {
     });
   }
 
+  // M56 D1: playwright e2e — native CLI worker (not Task subagent wrapper)
+  if (has('playwright.config.ts') || has('playwright.config.js') || has('playwright.config.cjs')) {
+    plan.push({
+      id: 'playwright',
+      cmd: 'npx',
+      args: ['--no-install', 'playwright', 'test'],
+      timeoutMs: 600000,
+    });
+  }
+
+  // M56 D1: journey coverage — gsd-t check-coverage (native CLI, no LLM)
+  if (has('.gsd-t/journey-manifest.json')) {
+    plan.push({
+      id: 'journey-coverage',
+      cmd: 'node',
+      args: ['./bin/gsd-t.js', 'check-coverage'],
+      timeoutMs: 30000,
+    });
+  }
+
   // secrets — gitleaks (PATH detection deferred to runtime)
   if (_hasOnPath('gitleaks')) {
     plan.push({

package/bin/gsd-t.js

@@ -3582,6 +3582,7 @@ function doHeadlessExec(command, cmdArgs, flags) {
   if (process.env.GSD_T_MODEL) workerEnv.GSD_T_MODEL = process.env.GSD_T_MODEL;
 
   try {
+    // GSD-T-LINT: skip stream-json (reason: gsd-t headless one-shot entrypoint — output is buffered into one string by callers, not user-watchable progress)
     const result = execFileSync("claude", ["-p", "--dangerously-skip-permissions", prompt], {
       encoding: "utf8",
       timeout: timeoutMs,
@@ -3876,6 +3877,7 @@ function spawnClaudeSession(prompt, model) {
     });
     if (env.GSD_T_MODEL === null) delete env.GSD_T_MODEL;
     if (process.env.GSD_T_TRACE_ID) env.GSD_T_TRACE_ID = process.env.GSD_T_TRACE_ID;
+    // GSD-T-LINT: skip stream-json (reason: internal debug-loop summarizer; output is consumed as one buffered string by parseTestResult — no progress to stream)
     return execFileSync("claude", ["-p", prompt, "--model", model], {
       encoding: "utf8", timeout: 300000,
       stdio: ["pipe", "pipe", "pipe"],
@@ -3924,6 +3926,7 @@ function runLedgerCompaction(projectDir, jsonMode) {
       GSD_T_PROJECT_DIR: process.env.GSD_T_PROJECT_DIR || projectDir,
     });
     if (process.env.GSD_T_TRACE_ID) env.GSD_T_TRACE_ID = process.env.GSD_T_TRACE_ID;
+    // GSD-T-LINT: skip stream-json (reason: debug-loop ledger compaction — single-shot summarizer, output consumed as one trimmed string)
     const out = execFileSync("claude", ["-p", compactPrompt, "--model", "haiku"], {
       encoding: "utf8", timeout: 120000, stdio: ["pipe", "pipe", "pipe"],
       env,
@@ -4590,14 +4593,23 @@ if (require.main === module) {
     }
     case "capture-lint": {
       const clOpts = { projectDir: process.cwd(), mode: 'staged' };
+      let checkStreamJson = false;
       for (let i = 1; i < args.length; i++) {
         const a = args[i];
         if (a === '--staged') { clOpts.mode = 'staged'; }
         else if (a === '--all') { clOpts.mode = 'all'; }
+        else if (a === '--check-stream-json') { checkStreamJson = true; }
         else if (a === '--project-dir' && args[i+1]) { clOpts.projectDir = args[++i]; }
         else if (a.startsWith('--project-dir=')) { clOpts.projectDir = a.slice(14); }
         else if (a === '--help' || a === '-h') {
-          log('Usage: gsd-t capture-lint [--staged] [--all] [--project-dir PATH]');
+          log('Usage: gsd-t capture-lint [--staged] [--all] [--check-stream-json] [--project-dir PATH]');
+          log('');
+          log('Default mode (M41 D5): rejects bare Task() / claude -p / spawn() calls');
+          log('   missing the captureSpawn / recordSpawnRow wrapper.');
+          log('');
+          log('--check-stream-json (M56 D5): rejects claude -p / spawn(claude, ...) invocations');
+          log('   missing --output-format stream-json --verbose flag pair.');
+          log('   Allowlist via marker comment: GSD-T-LINT: skip stream-json (reason: …)');
           process.exit(0);
         }
         else {
@@ -4607,7 +4619,7 @@ if (require.main === module) {
       }
       try {
         const linter = require(path.join(__dirname, 'gsd-t-capture-lint.cjs'));
-        const res = linter.main(clOpts);
+        const res = checkStreamJson ? linter.mainStreamJson(clOpts) : linter.main(clOpts);
         if (res.error) {
           error(`capture-lint: ${res.error}`);
           process.exit(2);
@@ -4615,10 +4627,11 @@ if (require.main === module) {
         for (const v of res.violations) {
           log(`${v.file}:${v.line}: ${v.message}`);
         }
+        const modeLabel = checkStreamJson ? 'stream-json' : 'capture';
         if (res.violations.length === 0) {
-          log(`capture-lint: ${res.files.length} file(s) checked — clean`);
+          log(`${modeLabel}-lint: ${res.files.length} file(s) checked — clean`);
         } else {
-          log(`capture-lint: ${res.violations.length} violation(s) across ${res.files.length} file(s)`);
+          log(`${modeLabel}-lint: ${res.violations.length} violation(s) across ${res.files.length} file(s)`);
         }
         process.exit(res.exitCode);
       } catch (e) {

package/commands/gsd-t-debug.md

@@ -139,6 +139,28 @@ Read:
 3. `.gsd-t/contracts/` — all contracts
 4. `.gsd-t/domains/*/scope.md` — domain boundaries
 
+<!-- M56-D4: preflight + brief + verify-gate wire-in -->
+**M56 Preflight + Context-Brief (mandatory before any debug investigation):**
+
+```bash
+gsd-t preflight --json > /tmp/gsd-t-preflight.json || exit 4
+
+SPAWN_ID="debug-${ARG_OR_DEFAULT:-investigation}-$(date -u +%Y%m%dT%H%M%SZ)"
+gsd-t brief --kind debug --out ".gsd-t/briefs/${SPAWN_ID}.json" || true
+export BRIEF_PATH=".gsd-t/briefs/${SPAWN_ID}.json"
+```
+
+If preflight exits 4, surface the failed `severity:"error"` checks (wrong branch, occupied required port) to the user and STOP — do NOT proceed with the debug investigation. The brief replaces the 30–60k context re-read with a ≤2,500-token JSON snapshot.
+
+**Verify-gate at end** (only if debug fix produced code changes):
+
+```bash
+if git status --porcelain | grep -q .; then
+  gsd-t verify-gate --json > /tmp/gsd-t-verify-gate.json || exit 4
+fi
+```
+<!-- /M56-D4: preflight + brief + verify-gate wire-in -->
+
 ## Step 1.5: Debug Loop Detection (MANDATORY)
 
 ```bash

package/commands/gsd-t-impact.md

@@ -16,6 +16,18 @@ Read:
 
 If run standalone, ask: "What changes are you considering?"
 
+<!-- M56-D3: brief wire-in -->
+**M56 Context-Brief (surfaces git diff + integration-points excerpt without re-walking the repo):**
+
+```bash
+SPAWN_ID="impact-${MILESTONE:-default}-$(date -u +%Y%m%dT%H%M%SZ)"
+gsd-t brief --kind impact --spawn-id "${SPAWN_ID}" --out ".gsd-t/briefs/${SPAWN_ID}.json" || true
+export BRIEF_PATH=".gsd-t/briefs/${SPAWN_ID}.json"
+```
+
+The `impact` brief includes `gitDiffSummary`, `changedFiles[]`, and the milestone's `integrationPointsExcerpt` so downstream workers can scan blast radius without re-reading the contract dir.
+<!-- /M56-D3: brief wire-in -->
+
 ## Step 2: Identify Changed Files
 
 From the plan or user description, list:

package/commands/gsd-t-milestone.md

@@ -15,6 +15,18 @@ Read:
 
 If `.gsd-t/` doesn't exist, run the init workflow first.
 
+<!-- M56-D3: brief wire-in -->
+**M56 Context-Brief (surfaces last completed milestone + version + recent decision log without re-reading progress.md):**
+
+```bash
+SPAWN_ID="milestone-${ARG_OR_DEFAULT:-define}-$(date -u +%Y%m%dT%H%M%SZ)"
+gsd-t brief --kind milestone --spawn-id "${SPAWN_ID}" --out ".gsd-t/briefs/${SPAWN_ID}.json" || true
+export BRIEF_PATH=".gsd-t/briefs/${SPAWN_ID}.json"
+```
+
+The `milestone` brief includes `lastCompletedMilestoneRow`, `currentVersion`, and the last 3 decision-log entries so the milestone-definition step can derive version-bump rationale + scope baseline without paging in the full progress history.
+<!-- /M56-D3: brief wire-in -->
+
 ## Step 2: Define the Milestone
 
 ```bash
@@ -56,13 +68,29 @@ Ask user: "Milestone {N-1} is still {status}. Archive it and start new? Or compl
 node scripts/gsd-t-watch-state.js advance --agent-id "$GSD_T_AGENT_ID" --parent-id "${GSD_T_PARENT_AGENT_ID:-null}" --command gsd-t-milestone --step 4 --step-label "Pre-Partition Assessment" 2>/dev/null || true
 ```
 
-Before formal partitioning, do a quick assessment:
+Before formal partitioning, do a quick assessment.
+
+**Express scope in GSD-T-native units only.** Per `feedback_no_human_hour_estimates.md` (memory): never use developer-hours, dev-days, sprints, story points, or person-weeks. Use these instead:
+
+| Unit | Use for |
+|------|---------|
+| **Domain count** | Partition coarseness (1-2 / 3-4 / 5+) |
+| **Wave count** | How many serial gates the milestone needs |
+| **Spawn count** | Estimated `claude -p` / Task subagent invocations |
+| **Token-spend range** | `$X-Y` based on prior comparable milestones |
+| **Rate-limit-window count** | If the milestone might span > 1 5h Claude Max window |
+| **Parallel-domain count** | How many domains can run concurrently (file-disjoint) |
+
+Assessment template:
 
-- **Complexity estimate**: Simple (1-2 domains), Medium (3-4), Complex (5+)
+- **Domain count**: Simple (1-2 domains), Medium (3-4), Complex (5+)
+- **Wave count**: estimated based on cross-domain dependencies
+- **Parallel-domain count**: how many can run in the same wave
+- **Token-spend range**: $X-Y based on prior comparable milestones (read `.gsd-t/token-log.md` for trailing-3 comparison)
 - **Recommended approach**:
-  - Simple: Consider using /gsd-t-quick for each piece
-  - Medium: Standard partition → plan → execute flow
-  - Complex: Partition → discuss → plan → execute → integrate → verify
+  - 1-2 domains: Consider using /gsd-t-quick for each piece
+  - 3-4 domains: Standard partition → plan → execute flow
+  - 5+ domains: Partition → discuss → plan → execute → integrate → verify
 
 Present the assessment and ask: "Ready to partition into domains now, or want to discuss first?"
 

package/commands/gsd-t-partition.md

@@ -51,6 +51,18 @@ If `.gsd-t/` doesn't exist, create the full directory structure:
 └── progress.md
 ```
 
+<!-- M56-D3: brief wire-in -->
+**M56 Context-Brief (replaces 30–60k context re-read with ≤2,500-token JSON snapshot):**
+
+```bash
+SPAWN_ID="partition-${MILESTONE:-default}-$(date -u +%Y%m%dT%H%M%SZ)"
+gsd-t brief --kind partition --spawn-id "${SPAWN_ID}" --out ".gsd-t/briefs/${SPAWN_ID}.json" || true
+export BRIEF_PATH=".gsd-t/briefs/${SPAWN_ID}.json"
+```
+
+Pass `$BRIEF_PATH` into any worker prompts spawned downstream so they grep the brief instead of re-walking the repo.
+<!-- /M56-D3: brief wire-in -->
+
 ## Step 1.5: Assumption Audit (MANDATORY — complete before domain work begins)
 
 ```bash

package/commands/gsd-t-plan.md

@@ -27,6 +27,18 @@ Read ALL of these:
 
 **If CONTEXT.md exists:** Every Locked Decision listed in it MUST be mapped to at least one task in Step 2. Do NOT proceed to execute if any Locked Decision is unmapped.
 
+<!-- M56-D3: brief wire-in -->
+**M56 Context-Brief (replaces 30–60k context re-read with ≤2,500-token JSON snapshot):**
+
+```bash
+SPAWN_ID="plan-${MILESTONE:-default}-$(date -u +%Y%m%dT%H%M%SZ)"
+gsd-t brief --kind plan --spawn-id "${SPAWN_ID}" --out ".gsd-t/briefs/${SPAWN_ID}.json" || true
+export BRIEF_PATH=".gsd-t/briefs/${SPAWN_ID}.json"
+```
+
+Pass `$BRIEF_PATH` into any worker prompts spawned downstream (validation subagents read it via `templates/prompts/{qa,red-team,design-verify}-subagent.md`).
+<!-- /M56-D3: brief wire-in -->
+
 ## Step 1.5: Graph-Enhanced Dependency Detection
 
 ```bash

package/commands/gsd-t-promote-debt.md

@@ -67,7 +67,7 @@ Append to `.gsd-t/roadmap.md`:
 - [ ] {each debt item resolved and verified}
 - [ ] No regression in existing functionality
 - [ ] {item-specific criteria from techdebt.md}
-**Estimated effort**: {combined effort assessment}
+**Estimated scope**: {N domains} / {N waves} / $X-Y token-spend (express in GSD-T units only — never developer-hours/days/sprints per `feedback_no_human_hour_estimates.md`)
 **Priority**: {CRITICAL — before next feature | HIGH — soon | MEDIUM — planned}
 ```
 

package/commands/gsd-t-quick.md

@@ -146,6 +146,28 @@ Read:
 2. `.gsd-t/progress.md` (if exists)
 3. `.gsd-t/contracts/` (if exists) — scan for relevant contracts
 
+<!-- M56-D4: preflight + brief + verify-gate wire-in -->
+**M56 Preflight + Context-Brief (mandatory before any quick-task work):**
+
+```bash
+gsd-t preflight --json > /tmp/gsd-t-preflight.json || exit 4
+
+SPAWN_ID="quick-${ARG_OR_DEFAULT:-task}-$(date -u +%Y%m%dT%H%M%SZ)"
+gsd-t brief --kind quick --out ".gsd-t/briefs/${SPAWN_ID}.json" || true
+export BRIEF_PATH=".gsd-t/briefs/${SPAWN_ID}.json"
+```
+
+If preflight exits 4, surface the failed `severity:"error"` checks (wrong branch, occupied required port) to the user and STOP — do NOT proceed with the quick task. The brief replaces the 30–60k context re-read with a ≤2,500-token JSON snapshot.
+
+**Verify-gate at end** (only if quick task produced code changes):
+
+```bash
+if git status --porcelain | grep -q .; then
+  gsd-t verify-gate --json > /tmp/gsd-t-verify-gate.json || exit 4
+fi
+```
+<!-- /M56-D4: preflight + brief + verify-gate wire-in -->
+
 ## Step 1.5: Graph-Enhanced Scope Check
 
 ```bash

package/commands/gsd-t-scan.md

@@ -351,7 +351,7 @@ Synthesize ALL findings into a **fresh** `.gsd-t/techdebt.md` (the previous vers
 - High priority: {N}
 - Medium priority: {N}
 - Low priority: {N}
-- Total estimated effort: {rough assessment}
+- Total estimated scope: {N domains} / {N waves} / $X-Y token-spend (GSD-T units only — see `feedback_no_human_hour_estimates.md`)
 - Previous scan archive: techdebt_{previous-date}.md
 
 ---
@@ -461,22 +461,22 @@ Review all items marked `Milestone candidate: YES` and group them into logical m
 
 ### Suggested: Security Hardening (Critical)
 Combines: TD-001, TD-003, TD-005
-Estimated effort: {assessment}
+Estimated scope: {domain-count} domains, {wave-count} waves, $X-Y token-spend (express in GSD-T units — domain/wave/spawn/token — never human-hours/days/sprints per `feedback_no_human_hour_estimates.md`)
 Should be prioritized: BEFORE next feature milestone
 
 ### Suggested: Performance Optimization (High)
 Combines: TD-010, TD-012, TD-015
-Estimated effort: {assessment}
+Estimated scope: {domain-count} domains, {wave-count} waves, $X-Y token-spend (express in GSD-T units — domain/wave/spawn/token — never human-hours/days/sprints per `feedback_no_human_hour_estimates.md`)
 Can be scheduled: AFTER current feature work
 
-### Suggested: Dependency Update Sprint (Medium)
+### Suggested: Dependency Update (Medium)
 Combines: TD-020, dependency table items with breaking=yes
-Estimated effort: {assessment}
+Estimated scope: {domain-count} domains, {wave-count} waves, $X-Y token-spend (express in GSD-T units — domain/wave/spawn/token — never human-hours/days/sprints per `feedback_no_human_hour_estimates.md`)
 Can be scheduled: During next maintenance window
 
 ### Suggested: Shared Service Extraction (if candidates found)
 Combines: all "Shared Service Candidates" from quality.md Reusability Analysis
-Estimated effort: {assessment}
+Estimated scope: {domain-count} domains, {wave-count} waves, $X-Y token-spend (express in GSD-T units — domain/wave/spawn/token — never human-hours/days/sprints per `feedback_no_human_hour_estimates.md`)
 Should be prioritized: BEFORE adding new consumer surfaces to the system
 Note: Use `/gsd-t-partition` Step 1.6 to design the SharedCore domain
 ```

package/docs/requirements.md

@@ -797,3 +797,19 @@ Supporting contracts (to be written during D1):
 | REQ-M55-D5-07 | `.gsd-t/contracts/verify-gate-contract.md` v1.0.0 STABLE — envelope schema, two-track hard-fail rule, ≤500-token summary discipline, head-and-tail snippet rule, raw-output retention path, idempotent-rerun rule, defensive-on-missing-map default, captureSpawn inheritance (NOT exempt). | m55-d5-verify-gate-and-wirein | T1 | done |
 | REQ-M55-D5-08 | Doc ripple: `docs/architecture.md` (CLI-Preflight Pattern section), `docs/requirements.md` (this REQ-M55 block), `CLAUDE.md` (Mandatory Preflight Before Spawn + Brief-First Worker Rule), `commands/gsd-t-help.md` (3 new entries), `README.md` (CLI table updates), `templates/CLAUDE-global.md` (preflight/brief/verify-gate documentation block), `~/.claude/CLAUDE.md` (Pre-Commit Gate addition). All in single commit per Document Ripple Completion Gate. | m55-d5-verify-gate-and-wirein | T12, T13 | done |
 | REQ-M55-VERIFY | Full unit suite ≥ 2399 baseline (post-D4) + 30+ new D5 unit tests across `test/m55-d5-verify-gate.test.js` (Track 1 hard-fail, Track 2 fan-out mocked, summary truncation ≤500 tokens, schema-version, defensive-on-missing-map, idempotent re-run, sort-determinism, skip flags) + `test/m55-d5-verify-gate-judge.test.js` (cap holds across huge envelopes, malformed-input resilience, deterministic) all green. 3 wire-in tests GREEN after T8/T9/T10 land. 3 e2e journey specs GREEN under Playwright. `gsd-t check-coverage` exit 0. | m55-d5-verify-gate-and-wirein | T14 | done |
+
+## M56 Verify-Gate CLI Fan-Out + Upper-Stage Briefs (planned — 2026-05-09)
+
+| Requirement | Description | Domain | Tasks | Status |
+|-------------|-------------|--------|-------|--------|
+| REQ-M56-D1-01 | `bin/gsd-t-verify-gate.cjs` Track 2 extends with native CLI workers for `playwright test`, `npm test`, `gsd-t check-coverage` (no Task subagent wrapper). Workers go through `runParallel` from `bin/parallel-cli.cjs` with `captureSpawn` invariant. | m56-d1-verify-gate-native-cli-workers | TBD | planned |
+| REQ-M56-D1-02 | M56 records `M55-baseline-tokens` + `M56-actual-tokens` in `.gsd-t/metrics/m56-token-baseline.json` and reports the delta in CHANGELOG (closes M55 SC4 retroactively). | m56-d1-verify-gate-native-cli-workers | TBD | planned |
+| REQ-M56-D1-03 | Verify-gate wall-clock ≤ M55's 34s on the same dogfood scenario. Numbers persisted to `.gsd-t/metrics/m56-verify-gate-wallclock.json`. | m56-d1-verify-gate-native-cli-workers | TBD | planned |
+| REQ-M56-D2-01 | `bin/gsd-t-context-brief.cjs` extends `KIND_REGISTRY` with 5 new kinds: `partition`, `plan`, `discuss`, `impact`, `milestone`. Each kind has its own file-resolver mapping a brief request to the relevant CLAUDE.md + contract excerpts + scope.md slice. ≤2,500-token cap per brief. | m56-d2-upper-stage-brief-kinds | TBD | planned |
+| REQ-M56-D2-02 | Brief generator unit tests cover all 5 new kinds: schema-shape, ≤2,500-token cap honored, missing-input resilience (e.g. milestone kind without a defined milestone falls back to "no milestone defined"), determinism. | m56-d2-upper-stage-brief-kinds | TBD | planned |
+| REQ-M56-D3-01 | `commands/gsd-t-{partition,plan,discuss,impact,milestone}.md` Step 1 each thread `$BRIEF_PATH` via the M55 D4 pattern (`SPAWN_ID`, `gsd-t brief --kind …`, `export BRIEF_PATH=…`). Tested via marker-comment assertion (`<!-- M56-D3: brief wire-in -->`). | m56-d3-upper-stage-command-wirein | TBD | planned |
+| REQ-M56-D4-01 | `commands/gsd-t-quick.md` and `commands/gsd-t-debug.md` Step 1 invoke `gsd-t preflight --json` (hard-fail on severity:error), then thread `$BRIEF_PATH` via brief generation (kinds `quick`/`debug` already in registry from M55 D4), then call `gsd-t verify-gate` if the operation produced code changes. Tested via marker-comment assertion (`<!-- M56-D4: preflight + brief + verify-gate wire-in -->`). | m56-d4-quick-debug-wirein | TBD | planned |
+| REQ-M56-D5-01 | Three known stream-json gaps closed: `bin/gsd-t.js:3879 spawnClaudeSession` (add `--output-format stream-json --verbose`), `bin/gsd-t-parallel.cjs:378` cache-warm probe (same), `bin/gsd-t-ratelimit-probe-worker.cjs:89` (same). | m56-d5-stream-json-universality-lint | TBD | planned |
+| REQ-M56-D5-02 | New lint check: extend `bin/gsd-t-capture-lint.cjs` (or sibling `bin/gsd-t-stream-json-lint.cjs`) to mechanically reject any `claude -p` / `spawn('claude', …)` invocation without `--output-format stream-json --verbose`. Allowlist (e.g. probe workers measuring envelopes, not progress) lives in lint config (`.gsd-t/lint-config.json` or inline marker comment), not tribal knowledge. Same enforcement model as M41 capture-lint. | m56-d5-stream-json-universality-lint | TBD | planned |
+| REQ-M56-D5-03 | Lint hooked into `scripts/hooks/pre-commit-capture-lint` (or sibling pre-commit hook) so violations block commits. | m56-d5-stream-json-universality-lint | TBD | planned |
+| REQ-M56-VERIFY | Full unit suite ≥ 2487 baseline + new tests for D1 (token-delta recording), D2 (5 new brief kinds), D3 (5 wire-in marker assertions), D4 (2 wire-in marker assertions), D5 (3 gap closures + lint logic + allowlist + pre-commit hook integration). All green. SC1-SC7 measured + recorded. | m56-d6-verify | TBD | planned |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "3.25.11",
+  "version": "3.26.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/scripts/hooks/pre-commit-capture-lint

@@ -24,3 +24,16 @@ if ! $GSD_T_BIN capture-lint --staged; then
   echo "Wrap spawns with captureSpawn({…, spawnFn}) or add GSD-T-CAPTURE-LINT: skip" >&2
   exit 1
 fi
+
+# M56 D5: stream-json universality lint — every `claude -p` / `spawn('claude', …)`
+# spawn must pass `--output-format stream-json --verbose` so progress is
+# observable in real-time, OR carry a `GSD-T-LINT: skip stream-json` marker
+# explaining why streaming isn't applicable (probe envelope, single-shot
+# buffered consumer, etc.).
+if ! $GSD_T_BIN capture-lint --staged --check-stream-json; then
+  echo ""
+  echo "Stream-json universality lint failed — see paths above."
+  echo "Add --output-format stream-json --verbose to the spawn args, OR"
+  echo "add a 'GSD-T-LINT: skip stream-json (reason: …)' marker comment near the spawn." >&2
+  exit 1
+fi

package/templates/CLAUDE-global.md

@@ -572,6 +572,30 @@ BEFORE reporting "done" or presenting a summary:
 
 **The test for this gate**: If the user asks "did you update all the documents?" and the answer would be "no, I missed some" — you failed this gate. The user should never need to ask.
 
+## Effort Estimates — GSD-T-Native Units (MANDATORY)
+
+**NEVER express effort or scope in developer-hours, dev-days, sprints, story points, or person-weeks.** GSD-T operates on a different cost model — the worker is Claude, not a human team — and human-time estimates have no predictive value for GSD-T workflows. They actively mislead by suggesting a calendar shape that doesn't match how the system runs.
+
+Use GSD-T-native units instead:
+
+| Unit | When to use |
+|------|-------------|
+| **Domain count** | Milestone scope (1-2 simple, 3-4 medium, 5+ complex) |
+| **Wave count** | Cross-domain dependency depth — how many serial gates exist |
+| **Parallel-domain count** | How many domains can run concurrently (file-disjoint) |
+| **Spawn count** | Estimated `claude -p` / Task subagent invocations |
+| **Token-spend range** | `$X-Y` dollars based on trailing-3 comparable milestones in `.gsd-t/token-log.md` |
+| **Rate-limit-window count** | If the work might span > 1 5h Claude Max window |
+
+Where this applies:
+- `/gsd-t-milestone` Step 4 — Pre-Partition Assessment
+- `/gsd-t-scan` techdebt milestone suggestions
+- `/gsd-t-promote-debt` effort fields
+- `docs/requirements.md`, `progress.md` Decision Log entries
+- Any internal estimate the user might read
+
+Acceptable: machine-time references (e.g. "5 min cache TTL", "5h rate-limit window", "14 day staleness threshold") — these are concrete system properties, not effort estimates. The rule applies to **effort/scope**, not to **system timeouts**.
+
 ## Execution Behavior
 - ALWAYS check docs/architecture.md before adding or modifying components.
 - ALWAYS check docs/workflows.md before changing any multi-step process.

package/templates/stacks/design-to-code.md

@@ -176,7 +176,7 @@ MANDATORY:
   │
   ├── For each design requirement, assess:
   │     Supported → stack handles this natively, proceed
-  │     Partial → needs an addon/library — name it, estimate effort
+  │     Partial → needs an addon/library — name it, scope in GSD-T units (domain/wave/spawn/token, NOT dev-hours)
   │     Unsupported → stack CANNOT achieve this — flag as a blocker
   │
   ├── If ANY requirement is Unsupported: