@tekyzinc/gsd-t 5.8.10 → 5.10.10

package/CHANGELOG.md

@@ -2,6 +2,63 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.10.10] - 2026-08-07
+
+### Added — a project's CLAUDE.md is written from what actually happened in it
+
+The template was GSD-T's own CLAUDE.md. It byte-copied into another project with that project's name substituted into GSD-T's own prose — 127 lines describing an npm CLI installer the project was not. Every new project was getting a file about the wrong software.
+
+**`/gsd-t-setup` now reads the project's history first.** A rule that keeps getting broken is the rule that most needs writing down, and nobody recalls those on request — they have to be found. Three sources: git, the decision log, and what you typed in past sessions.
+
+Session history is large — one project holds 315 MB across 57 sessions. Keeping only what you typed leaves 645 KB; dropping pasted logs leaves 92 complaint-shaped turns. **735 milliseconds, no subagents.**
+
+The search terms were corrected against real transcripts. Every obvious guess scored zero — "I never asked you to", "that's the third time". People don't accuse; they restate the requirement. "still not", "you keep", "why did you" are what actually appear.
+
+**Then it shows you the rules the project already states, and you tick the ones that can never be broken.** Six sources, ranked by how many agree — repetition is the evidence. Each rule shows where it came from, so you're confirming something you already said rather than recalling it. Capped at 12 on screen; the rest are written to a file, never dropped.
+
+On one project the top four are its real inviolable rules with their ids. Three other projects each surface their own true rule first.
+
+**The template is replaced** with a real mold: 45 lines, every section omittable with a stated reason, and one rule written into the mold itself — nothing that carries a number which changes on its own. A version, a line count, or "currently in progress" is wrong within a week and belongs in `progress.md`.
+
+- `bin/gsd-t-project-history.cjs`: the funnel, three sources, each reporting whether it was there
+- `bin/gsd-t-rule-mine.cjs`: six sources, deduplicated by what the rule claims
+- `templates/CLAUDE-project.md`: replaced
+- `commands/gsd-t-setup.md`: reads history, shows a tick-list, uses the mold
+- `test/m109-project-claude-md.test.js`: 15 tests
+
+**Not fixed, and said plainly:** a project CLAUDE.md is still written once and never updated, so a fresh file starts going stale immediately. The fix — giving project files the same marker-block treatment the global file has — is a separate milestone.
+
+Run `/gsd-t-setup` inside a project to rewrite its file. It shows you the result and waits for a yes before writing.
+
+## [5.9.10] - 2026-08-07
+
+### Added — projects repair their own install, and fallbacks need approval by name
+
+**Every registered project was running a broken install.** Binvoice had 20 of its 38 tools. The verify gate was a stale copy in all 33 projects, so every one of them has been running an outdated quality gate.
+
+The cause was one line: a tool missing from the package was skipped in silence, and the pass then reported "copied N tools" — where N looked fine. The report was the concealment. Two more copies of the same defect sat in the utility-script and template installers.
+
+**Install self-repair (M108).** Each session now checks its project's tools before any work starts, restores what is missing from the installed package, and refuses to continue if it cannot. Not a workaround: it fixes the failure, then the work proceeds with everything present. Every repair is logged to a shared file, and `gsd-t install-check --report` names any tool that has gone missing in more than one project — which points at the installer rather than the project. A per-project fix that also tells GSD-T what to mend in itself.
+
+- `bin/gsd-t-install-check.cjs`: reads the expected tool list from the installer (never a second copy that can go stale), compares, repairs, halts when it can't
+- `scripts/gsd-t-install-heal.js`: runs it at session start, first in the chain; silent when the install is already complete
+- `bin/gsd-t.js`: three silent skips now report every undelivered file; new `install-check` command
+- `test/m108-install-heal.test.js`: 12 tests, including one asserting the silent skip never comes back
+
+**Fallback gate (M106).** A fallback — anything that continues after a failure — can no longer be written unless it was approved by name. The rule has been written down since v5.0.14 and kept being broken: a lookup for a post's author failed, the code substituted the last known seller, and posts were recorded as written by someone who never wrote them. That shipped while the rule was live.
+
+Two things about the rule changed as a result. The damage is fabricated data **plus a disabled alarm** — author detection broke because a code change broke it, and the substitution meant nobody ever went looking. And consent must be specific: a fallback buried inside a long plan approved as a whole is not approved, because whoever wrote the plan controls the burying.
+
+Detection matches the shape of the code, not its wording, so rewording cannot evade it. It runs when code is written, when a plan is reviewed, before a commit, and on demand across existing code. A one-time baseline records what was already there so the gate judges new work only.
+
+- `bin/gsd-t-fallback-detect.cjs`, `scripts/gsd-t-fallback-guard.js`, `test/m106-fallback-gate.test.js`
+
+**Shorter replies (M107).** A second Claude rewrites replies over 60 words — answer first, no preamble, no backstory, no jargon — before you read them. The rewrite is thrown away and the original kept if it drops a question, a code block, every file path, or invents a number.
+
+- `bin/gsd-t-concise-rewrite.cjs`, `scripts/gsd-t-concise-hook.js`, `test/m107-concise-rewrite.test.js`
+
+Switch either gate off per project: `.gsd-t/fallback-gate.json` or `.gsd-t/concise.json` with `{"enabled": false}`.
+
 ## [5.8.10] - 2026-08-05
 
 ### Changed — the architect now interviews you before it assesses

package/README.md

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

package/bin/gsd-t-concise-rewrite.cjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+/**
+ * gsd-t-concise-rewrite.cjs
+ *
+ * M107-D1 — Rewrites a reply into its shortest honest form.
+ *
+ * [RULE] concise-rewrite-never-changes-a-fact
+ * [RULE] concise-rewrite-halts-never-silently-degrades
+ * [RULE] concise-rewrite-preserves-questions-and-warnings
+ *
+ * A fresh Claude, given only the text and the rules, cuts what the writer is
+ * attached to. It has no memory of the work, so it has nothing to defend.
+ *
+ * ─── Usage ──────────────────────────────────────────────────────────────────
+ *   node gsd-t-concise-rewrite.cjs --text "<reply>" [--project <dir>] [--json]
+ *   echo "<reply>" | node gsd-t-concise-rewrite.cjs --stdin
+ *
+ * ─── Exit codes ─────────────────────────────────────────────────────────────
+ *   0  rewritten (or skipped because it was already short)
+ *   4  the rewrite could not be done — the ORIGINAL is returned, marked
+ *   64 bad input
+ *
+ * On failure it returns the ORIGINAL text and says so. It never returns
+ * nothing, never truncates, never guesses. Showing a long reply is a poor
+ * outcome; showing a silently mangled one is a wrong one.
+ *
+ * Zero dependencies beyond the `claude` CLI on PATH.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const EXIT_OK = 0;
+const EXIT_FAILED = 4;
+const EXIT_BAD_INPUT = 64;
+
+const DEFAULTS = {
+  enabled: true,
+  skipUnder: 60,      // words — below this, rewriting buys nothing
+  model: "sonnet",
+  timeoutMs: 45000,
+};
+
+const RULES = `You rewrite a reply so it can be read in as little time as possible.
+
+The reader is a slow reader. Every extra line costs him real time. Jargon costs
+him more than length — he has to stop and translate it, and then ask for it
+again in plain words.
+
+Rewrite the reply below following these rules exactly:
+
+1. ANSWER FIRST. The answer is the first thing. Nothing before it.
+2. NO PREAMBLE. Cut any sentence that announces a point instead of making it.
+3. NO BACKSTORY. Cut every explanation of why something failed before, what
+   cannot work, how it works today, or what was rejected — unless the reply is
+   answering a direct question about that. He asks when he wants it.
+4. NO JARGON. Plain words. If a technical term is genuinely needed, put the
+   plain meaning first and the term in brackets after it.
+5. CUT ANYTHING NOT ASKED FOR.
+6. Prefer a short list or a small table over a paragraph.
+
+KEEP THESE. They are not optional, and dropping any one of them means the
+rewrite is rejected and thrown away:
+
+- The first line, if it is a dated status banner.
+- EVERY question being asked of the reader. If the reply ends by asking him
+  something, that question MUST appear in your rewrite, as its own line, at
+  the end. This is the single most common way a rewrite is rejected.
+- Any warning, failure, or thing that went wrong.
+- File paths and links, exactly as written.
+- Code blocks, exactly as written.
+- Specific numbers and names.
+
+Never:
+- change a fact or a number
+- drop a warning, a failure, or a question
+- add anything that was not in the original
+- soften a bad outcome
+
+Return ONLY the rewritten reply. No commentary about what you changed.`;
+
+function readConfig(projectDir) {
+  const p = path.join(projectDir, ".gsd-t", "concise.json");
+  if (!fs.existsSync(p)) return { ...DEFAULTS };
+  try {
+    return { ...DEFAULTS, ...JSON.parse(fs.readFileSync(p, "utf8")) };
+  } catch (_) {
+    // Unreadable config → defaults. Rewriting with defaults is the safe
+    // direction; it cannot lose content, only shorten it.
+    return { ...DEFAULTS };
+  }
+}
+
+function wordCount(s) {
+  return (String(s).trim().match(/\S+/g) || []).length;
+}
+
+/**
+ * Facts that must survive the rewrite. If any disappears, the rewrite is
+ * rejected and the original is returned — a rewrite that drops a warning or a
+ * question is worse than a long reply.
+ */
+function extractInvariants(text) {
+  return {
+    questions: (text.match(/[^.!?\n]*\?/g) || []).map((q) => q.trim()).filter((q) => q.length > 10),
+    numbers: text.match(/\b\d[\d,._]*\b/g) || [],
+    paths: text.match(/[\w./-]+\.(?:js|cjs|mjs|ts|tsx|json|md|py|sh)\b/g) || [],
+    codeBlocks: (text.match(/```/g) || []).length / 2,
+  };
+}
+
+function checkInvariants(original, rewritten) {
+  const a = extractInvariants(original);
+  const b = extractInvariants(rewritten);
+  const lost = [];
+
+  if (a.questions.length > 0 && b.questions.length === 0) {
+    lost.push("a question to the reader was dropped");
+  }
+  const lostPaths = a.paths.filter((p) => !rewritten.includes(p));
+  if (lostPaths.length > 0 && lostPaths.length === a.paths.length && a.paths.length > 0) {
+    lost.push("every file path was dropped");
+  }
+  if (a.codeBlocks > 0 && b.codeBlocks < a.codeBlocks) {
+    lost.push("a code block was dropped");
+  }
+  // A number appearing in the rewrite that was never in the original means
+  // something was invented.
+  const invented = b.numbers.filter((n) => n.length > 2 && !a.numbers.includes(n));
+  if (invented.length > 0) {
+    lost.push(`a number appeared that was not in the original: ${invented[0]}`);
+  }
+  return lost;
+}
+
+/** Ask a fresh Claude to do the rewrite. */
+function rewrite(text, cfg) {
+  const prompt = `${RULES}\n\n--- REPLY TO REWRITE ---\n${text}`;
+  const run = spawnSync("claude",
+    ["-p", prompt, "--model", cfg.model, "--dangerously-skip-permissions"],
+    { encoding: "utf8", timeout: cfg.timeoutMs, maxBuffer: 8 * 1024 * 1024 });
+
+  if (run.error) return { ok: false, error: run.error.message };
+  if (run.status !== 0) return { ok: false, error: `claude exited ${run.status}: ${(run.stderr || "").slice(0, 200)}` };
+  const out = (run.stdout || "").trim();
+  if (!out) return { ok: false, error: "the rewriter returned nothing" };
+  return { ok: true, text: out };
+}
+
+function parseArgs(argv) {
+  const args = { project: process.cwd() };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--json") args.json = true;
+    else if (a === "--stdin") args.stdin = true;
+    else if (a === "--text") args.text = argv[++i];
+    else if (a === "--project") args.project = argv[++i];
+  }
+  return args;
+}
+
+function emit(result, asJson) {
+  if (asJson) process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  else process.stdout.write(result.text + "\n");
+  process.exit(result.exitCode);
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  const projectDir = path.resolve(args.project);
+  const cfg = readConfig(projectDir);
+
+  let text = args.text;
+  if (args.stdin) {
+    try { text = fs.readFileSync(0, "utf8"); } catch (_) { text = ""; }
+  }
+  if (typeof text !== "string" || !text.trim()) {
+    emit({ ok: false, exitCode: EXIT_BAD_INPUT, text: "", error: "no text given" }, true);
+  }
+
+  const before = wordCount(text);
+
+  if (!cfg.enabled) {
+    emit({ ok: true, exitCode: EXIT_OK, text, skipped: "switched off", words: before }, args.json);
+  }
+  if (before < cfg.skipUnder) {
+    emit({ ok: true, exitCode: EXIT_OK, text, skipped: "already short", words: before }, args.json);
+  }
+
+  const r = rewrite(text, cfg);
+  if (!r.ok) {
+    emit({
+      ok: false, exitCode: EXIT_FAILED, text,
+      error: r.error,
+      note: "Rewrite failed — this is the original, unchanged.",
+      words: before,
+    }, args.json);
+  }
+
+  const lost = checkInvariants(text, r.text);
+  if (lost.length > 0) {
+    emit({
+      ok: false, exitCode: EXIT_FAILED, text,
+      error: `the rewrite lost something: ${lost.join("; ")}`,
+      note: "Rewrite rejected — this is the original, unchanged.",
+      words: before,
+    }, args.json);
+  }
+
+  const after = wordCount(r.text);
+  emit({
+    ok: true, exitCode: EXIT_OK, text: r.text,
+    words: before, wordsAfter: after,
+    saved: before - after,
+  }, args.json);
+}
+
+if (require.main === module) main();
+
+module.exports = { wordCount, extractInvariants, checkInvariants, readConfig, RULES };