@tekyzinc/gsd-t 5.0.14 → 5.1.11

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.1.11] - 2026-07-13
+
+### Fixed — paused M102 work leaked into the v5.1.10 package; removed
+
+`npm publish` tarballs the WORKING TREE, not the committed tree — so v5.1.10 shipped the uncommitted, PAUSED M102 env-registry files (the known-leaky secret guard bins + a `templates/CLAUDE-global.md` "Environment Access" rule pointing at them). `update-all` re-propagated that rule into `~/.claude/CLAUDE.md`. This patch removes the M102 env-access rule from the template and publishes from a clean tree (the paused M102 build files are stashed during publish, so the package matches the committed state). The Simply Stated doctrine (v5.1.10) is unaffected and retained.
+
+- `templates/CLAUDE-global.md`: removed the M102 "Environment Access — read-first" rule (M102 is paused; the rule pointed at an unfinished/leaky mechanism).
+- Publish hygiene: the paused M102 working-tree files no longer ride into the released tarball.
+
+## [5.1.10] - 2026-07-13
+
+### Added — Simply Stated Doctrine (clarity as a defect gate, the verbose-virus cure)
+
+The recurring "verbose virus" — GSD-T deliverables that are dense, jargon-heavy, and unreadable (one architecture review drew "plain English please" five times in a single message) — has resisted every prior fix (Reader Contract, retired brevity Stop hook, jargon lint) because those treat verbosity as OUTPUT polish and are reminders that lose under load. Simply Stated is a different mechanism: it treats verbosity as a SYMPTOM of unclear thinking, and the same unclear thinking ships the bugs. Before GSD-T presents an architecture/plan/finding/milestone, it must state it simply first — every word load-bearing, straight-line logic, no jargon or nested clauses. If it can't, the thinking isn't done: RE-THINK, don't re-word. HALT-as-defect, not a soft nudge. "Simply" ≠ dumbed down — the content stays as sophisticated as the problem; only the expression is clean ("too sophisticated to simplify" is a banned escape hatch).
+
+- `templates/CLAUDE-global.md` (+ `~/.claude/CLAUDE.md`): the doctrine (definition) — the clarity=thinking equivalence, the HALT, the anti-dumbing-down clause.
+- `scripts/gsd-t-architect-oversight-guard.js`: the Write/Edit trigger reminder now carries the Simply-Stated challenge (reused the architect hook — no new hook).
+- `templates/workflows/gsd-t-phase.workflow.js`: Stage 7 (Simply-Stated clarity gate) in the Six-Stage Pass — the plan isn't done until it has a clean simply-stated lead.
+- `commands/gsd-t-architect.md`: Stage 7 in the pass + "Simply Stated" is now the REQUIRED FIRST LINE of the architect's session summary.
+- `.gsd-t/contracts/architects-oversight-contract.md`: Stage 7 row.
+- `test/m101-architect-oversight-hook.test.js`: 5 wiring tests (both templates, hook, workflow, command).
+
 ## [5.0.14] - 2026-07-13
 
 ### Added — No-Fallback-Ever Doctrine (never branch around a failure without asking)

package/README.md

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

package/commands/gsd-t-architect.md

@@ -85,6 +85,12 @@ The subagent works through the six stages IN ORDER. Each can kill or reshape the
    you can cite a confirmed reproducible case only a fallback catches. The straight-line process
    that produces the result is the goal; where it can fail, prefer a **HALT** (stop + demand
    fix), which is NOT a fallback. (See CLAUDE.md § No-Fallback-Ever Doctrine.)
+7. **SIMPLY-STATED** (clarity gate — the review is NOT done until this passes) — state every
+   finding and the verdict SIMPLY: precise and complete, but every word load-bearing, the logic
+   in a straight line, ZERO jargon standing in for a clear idea, no nested clauses hiding a
+   tangle. If a finding cannot be stated simply, the thinking on it is not finished — RE-THINK
+   the muddled part, do not re-word it. "Too sophisticated to simplify" is a BANNED escape hatch
+   (simplify the expression, never the idea). (See CLAUDE.md § Simply Stated Doctrine.)
 
 A stage the subagent cannot answer with evidence is a HALT — surface it as an open question for
 the user, do not paper over it with a guess.
@@ -100,6 +106,10 @@ a summary table, near-zero preamble. For each CURRENT block, say **why it does w
 successive fixes). Unless `--chat-only`, write it to `.gsd-t/pseudocode/PseudoCode-<Target>.md`.
 
 **B — Session summary** (always printed, even under `--build`):
+- **Simply Stated** (REQUIRED FIRST LINE — the clarity gate) — the verdict + the single most
+  important finding in ONE clean, jargon-free, straight-line statement a smart non-specialist
+  acts on without re-reading. If you cannot write this line cleanly, the review is NOT done —
+  re-think, don't re-word. Everything below is the depth for whoever wants it.
 - **Core objective** (one line)
 - **Is this a "complicated over time" issue?** (yes/no + the accretion history if yes)
 - **What's reusable** (process or a stored output already available)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.0.14",
+  "version": "5.1.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/gsd-t-architect-oversight-guard.js

@@ -45,7 +45,11 @@ const REMINDER =
   "(catch-and-continue, || default, silent degrade, try-X-else-Y) — STOP and ask the " +
   "user first, unless you can cite a confirmed reproducible case only a fallback catches. " +
   "A HALT (stop + demand fix) is NOT a fallback and is the preferred move. " +
-  "See ~/.claude/CLAUDE.md § Architect's Oversight + No-Fallback-Ever Doctrines.";
+  "SIMPLY-STATED: before presenting an architecture/plan/finding, state it SIMPLY — every " +
+  "word load-bearing, logic in a straight line, no jargon or nested clauses. If you can't " +
+  "state it cleanly the thinking isn't done (muddle in the words = muddle in the design) — " +
+  "RE-THINK, don't re-word. 'Too sophisticated to simplify' is a banned escape hatch. " +
+  "See ~/.claude/CLAUDE.md § Architect's Oversight + No-Fallback-Ever + Simply Stated Doctrines.";
 
 // File extensions that are PROSE/config, not code — skip the reminder for these.
 // (The doctrine's own artifacts are markdown; reminding while authoring them is noise.)

package/templates/CLAUDE-global.md

@@ -100,6 +100,7 @@ NEED TO UNDERSTAND SOMETHING?
 ```
 
 
+
 # Versioning
 
 GSD-T tracks project version in `.gsd-t/progress.md` using semantic versioning: `Major.Minor.Patch`
@@ -473,6 +474,18 @@ See memory pointer: `feedback_auto_research_external_gaps`.
 
 **§Enforcement (three layers):** (1) this doctrine = the definition; (2) the **Architect's Oversight Write/Edit trigger is extended** to challenge every fallback at the build moment ("is this a fallback? name the proven case or ask"); (3) mechanical guards where they already exist — the graph consumers' `try→catch→grep` fallback is caught by `bin/gsd-t-graph-anti-grep-lint.cjs` (reused, not duplicated); a general static "detect every fallback" lint is deliberately NOT built (it can't judge *proven-necessary* — that is the human/architect ask, which is layer 2).
 
+### Simply Stated Doctrine (governed, enforced — clarity as a defect gate, not a writing-style reminder)
+
+**Before GSD-T presents an architecture, plan, finding, review, or milestone definition, it must first state it *simply* — precise and complete, every word earning its place, the logic in a straight line, with no jargon standing in for a clear idea and no nested clauses hiding a tangle. If it cannot be stated simply, the thinking is NOT finished: the muddle in the words IS a muddle in the design. It goes back to be RE-THOUGHT, not re-worded.** The simply-stated version leads the deliverable; the technical depth sits below it for whoever wants it.
+
+**This is a DIFFERENT mechanism from the Reader Contract / jargon lint.** Those treat verbosity as an OUTPUT-polish problem — trim the prose after the thinking is done — and repeatedly fail because a reminder loses to "but this case needs the detail" under load. Simply Stated treats verbosity as what it is: **a symptom of unclear thinking, and the same unclear thinking ships the bugs.** If you cannot express it cleanly, you do not yet understand it — and not-understanding is where defects come from. The inability to state it simply is a DEFECT SIGNAL, gated like the No-Fallback HALT, not a soft nudge.
+
+**"Simply" is NOT "dumbed down."** The content stays as sophisticated as the problem demands — sophisticated IN its simplicity and conciseness (simplify the *expression*, never the *idea*). The test is NOT "could a novice understand the topic." The test is: **is every word load-bearing, and is the logic a straight line?** "This topic is too sophisticated to state simply" is the banned escape hatch.
+
+**The HALT (the teeth):** a deliverable whose simply-stated lead cannot be written cleanly is NOT done — stop, surface it, re-think the muddled part. Do not ship the verbose version with an apology; the verbose version is evidence the design has a gap.
+
+**§Enforcement (three layers):** (1) this doctrine = the definition; (2) the **Architect's Oversight Write/Edit trigger** carries a Simply-Stated line; (3) the **plan/milestone Six-Stage Pass + `/gsd-t-architect` gain a Simply-Stated gate** — the pass does not complete until its finding/plan has a clean simply-stated lead, and the validation protocols flag a deliverable that lacks one. The simply-stated lead is a REQUIRED ARTIFACT (like the pseudocode file), not advice.
+
 ### Phase Flow
 - Upon completing a phase, automatically proceed to the next phase
 - ONLY run Discussion phase if truly required (clear path → skip to Plan)

package/templates/workflows/gsd-t-phase.workflow.js

@@ -934,6 +934,13 @@ const _architectPassLine = _ARCHITECT_PHASES.has(phaseName)
       `     it in — UNLESS you can cite a confirmed reproducible case only a fallback catches. The`,
       `     straight-line process that produces the result is the goal; where it can fail, prefer a`,
       `     HALT (stop + demand fix), which is NOT a fallback. Fallbacks are rare and ask-first.`,
+      `  7. SIMPLY-STATED (clarity gate — the plan is NOT done until this passes) — write the ${phaseName}`,
+      `     as a SIMPLY-STATED lead FIRST: precise and complete, but every word load-bearing, the logic`,
+      `     in a straight line, ZERO jargon standing in for a clear idea, no nested clauses hiding a`,
+      `     tangle. If you CANNOT state it simply, the thinking is not finished — the muddle in the`,
+      `     words is a muddle in the design; RE-THINK the muddled part, do not re-word it. "Too`,
+      `     sophisticated to simplify" is a BANNED escape hatch (simplify the expression, never the`,
+      `     idea). This simply-stated lead heads the deliverable; the depth sits below it.`,
       `A stage you cannot answer with evidence HALTS the plan (needs-human) — do not proceed on a hunch.`,
     ].join("\n")
   : "";