@tekyzinc/gsd-t 5.11.13 → 5.11.15

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.11.15] - 2026-08-09
+
+### Removed — the reply shortener (M107) is retired
+
+It shortened a reply *after* it was written, and a Stop hook cannot unsay what
+is already on screen: the long version was read, then the short one. It cost a
+whole extra turn, and its instruction was misread often enough to print a third
+copy. Every fix landed and the thing still was not worth its cost.
+
+The Reader Contract, injected before every turn, does the same job for free and
+in the only place it can work — before the words are written.
+
+**Installing now REMOVES the hook** from machines that already have it. A
+retired feature still running on 32 machines is not retired, and the installer
+is the only thing that reaches them. Other hooks are untouched.
+
+- deleted: `scripts/gsd-t-concise-hook.js`, `bin/gsd-t-concise-rewrite.cjs`
+- `bin/gsd-t.js`: `removeConciseHook` replaces the registrar; the marker stays, because removal needs it to find the hook
+- both propagation lists no longer carry the rewriter
+- `test/m112-concise-retired.test.js`: 6 tests, including that install removes it and never re-adds it
+
+## [5.11.14] - 2026-08-09
+
+### Fixed — the shortened reply appeared as a third copy instead of the only one
+
+The hook told the model to "replace it with this shorter version". A model
+cannot replace a reply already sent — it can only write another. Read as an
+instruction to restate, it re-emitted the LONG original, so the reader saw the
+full reply, then the short one, then the full one again.
+
+The instruction now describes the only action available: your entire next
+message is this text, copied exactly, nothing before or after, and do not repeat
+any part of the previous reply. Stated in words rather than wrapper markers,
+which the model copies through.
+
+- `scripts/gsd-t-concise-hook.js`: the block instruction
+- `test/m107-concise-rewrite.test.js`: 3 tests — no "replace", the repeat is forbidden outright, and no markers that could land in the reply
+
 ## [5.11.13] - 2026-08-09
 
 ### Fixed — the reply shortener discarded 4 of every 6 rewrites

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v5.11.13** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v5.11.15** - 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.js

@@ -523,13 +523,11 @@ const INSTALL_HEAL_MARKER = "gsd-t-install-heal";
 const INSTALL_HEAL_COMMAND =
   'bash -c \'[ -f "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-install-heal.js" ] && node "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-install-heal.js" || true\'';
 
-// ─── M107 Concise hook (Stop) ───────────────────────────────────────────────
-// Sends a long reply to a fresh Claude for a shorter rewrite. Fail-open by
-// design (`|| true`): it governs how a reply READS, never whether it is true,
-// so a broken rewriter must never gag a correct answer.
+// ─── M107 Concise hook — RETIRED in v5.11.15 ────────────────────────────────
+// The marker survives its removal: installing DELETES this hook from a machine
+// that still has it, and a marker is how it is found. Deleting the name would
+// leave the hook running everywhere it was already installed.
 const CONCISE_HOOK_MARKER = "gsd-t-concise-hook";
-const CONCISE_HOOK_COMMAND =
-  'bash -c \'[ -f "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-concise-hook.js" ] && node "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-concise-hook.js" || true\'';
 
 // Append entries to {projectDir}/.gitignore. Each entry added only if absent.
 // Idempotent. Returns true if any entries were added, false otherwise.
@@ -994,10 +992,18 @@ function configureFallbackGuardHook(settingsPath) {
   return configureWriteEditHook(settingsPath, FALLBACK_HOOK_MARKER, FALLBACK_HOOK_COMMAND, "fallback guard");
 }
 
-// M107 — register the concise rewriter on Stop. Not a Write|Edit hook, so it
-// uses the Stop registrar below rather than configureWriteEditHook.
-function configureConciseHook(settingsPath) {
-  return configureStopHook(settingsPath, CONCISE_HOOK_MARKER, CONCISE_HOOK_COMMAND, "concise rewrite");
+// M107 RETIRED (v5.11.15). The rewriter shortened a reply after it was written,
+// and a Stop hook cannot unsay what is already on screen — so David read the
+// long version, then the short one. It also cost a whole extra turn, and its
+// own instruction was misread often enough to print a THIRD copy. The Reader
+// Contract, injected before every turn, does the same job for free and in the
+// only place it can work: before the words are written.
+//
+// Installing now REMOVES the hook rather than adding it. A retired feature that
+// keeps running on 32 machines is not retired, and only the installer can reach
+// them.
+function removeConciseHook(settingsPath) {
+  return removeStopHook(settingsPath, CONCISE_HOOK_MARKER);
 }
 
 // M108 — register the install self-heal on SessionStart, so a broken install is
@@ -1013,6 +1019,36 @@ function configureStopHook(settingsPath, marker, command, label) {
   return configureEventHook(settingsPath, "Stop", marker, command, label);
 }
 
+/**
+ * Delete a Stop hook by marker, wherever it is registered.
+ *
+ * Retiring a hook in the package is not enough — it keeps firing on every
+ * machine that already installed it, and the installer is the only thing that
+ * reaches those machines. An unreadable or malformed settings file STOPS the
+ * install: leaving a retired hook running while reporting success is the same
+ * silent staleness that left eleven dead commands typeable for months.
+ */
+function removeStopHook(settingsPath, marker) {
+  if (!fs.existsSync(settingsPath)) return { removed: 0 };
+
+  const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+  const groups = settings.hooks && settings.hooks.Stop;
+  if (!Array.isArray(groups)) return { removed: 0 };
+
+  let removed = 0;
+  for (const group of groups) {
+    if (!Array.isArray(group.hooks)) continue;
+    const before = group.hooks.length;
+    group.hooks = group.hooks.filter((h) => !String(h && h.command || "").includes(marker));
+    removed += before - group.hooks.length;
+  }
+  if (removed === 0) return { removed: 0 };
+
+  settings.hooks.Stop = groups.filter((g) => Array.isArray(g.hooks) && g.hooks.length > 0);
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  return { removed };
+}
+
 // Register a hook on any event by marker. One registrar for every event, so a
 // new hook needs no new copy of this logic.
 function configureEventHook(settingsPath, event, marker, command, label) {
@@ -1761,10 +1797,6 @@ const GLOBAL_BIN_TOOLS = [
   // write rather than allowing it unchecked, so an omission here breaks every
   // Write/Edit rather than failing silently. Also in PROJECT_BIN_TOOLS below.
   "gsd-t-fallback-detect.cjs",
-  // M107 — Concise rewriter. scripts/gsd-t-concise-hook.js (a Stop hook) shells
-  // out to this; absent, the hook allows the long reply through (fail-open by
-  // design — it governs readability, never truth).
-  "gsd-t-concise-rewrite.cjs",
   // M108 — Install self-check, run by the SessionStart hook and by
   // `gsd-t install-check`.
   "gsd-t-install-check.cjs",
@@ -2301,12 +2333,8 @@ async function doInstall(opts = {}) {
   }
 
 
-  const ccHook = configureConciseHook(SETTINGS_JSON);
-  if (ccHook.installed) {
-    if (ccHook.action === "added") success("Concise-rewrite hook added (shortens a long reply before you read it — M107)");
-    else if (ccHook.action === "refreshed") success("Concise-rewrite hook refreshed");
-    else info("Concise-rewrite hook already configured");
-  }
+  const ccHook = removeConciseHook(SETTINGS_JSON);
+  if (ccHook.removed) success("Concise-rewrite hook removed — retired in v5.11.15");
 
   const healHook = configureInstallHealHook(SETTINGS_JSON);
   if (healHook.installed) {
@@ -3279,7 +3307,6 @@ const PROJECT_BIN_TOOLS = [
   // so this entry is load-bearing — [[project_global_bin_propagation_gap]].
   "gsd-t-fallback-detect.cjs",
   // M107 — Concise rewriter, invoked by the Stop hook.
-  "gsd-t-concise-rewrite.cjs",
   // M108 — Install self-check. Every project carries its own copy so it can
   // verify and repair itself even when the global install is what broke.
   "gsd-t-install-check.cjs",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.11.13",
+  "version": "5.11.15",
   "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/bin/gsd-t-concise-rewrite.cjs

@@ -1,276 +0,0 @@
-#!/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. KEEP ONLY WHAT IS RELEVANT TO HIM. Ask of every sentence: does this change
-   what he decides, what he does next, or what he now knows? If not, cut it.
-   Work the writer did, steps taken, what was checked, what was ruled out — all
-   of that is the writer's business, not his, unless he asked.
-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 — one he is meant to answer. 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.
-  A question the writer asks HIMSELF is not one of these. "Is that the cause?",
-  "Now the proof: does the hook fire?", "So what is slow here?" are thinking out
-  loud — cut them like any other narration. The test is simple: would he type an
-  answer to it? If not, it is not a question.
-- 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;
-}
-
-/**
- * The second pass — the rewrite reviewed before it is delivered.
- *
- * A keyword check used to sit here: it counted question marks, file paths and
- * numbers, and threw the whole rewrite away if a count dropped. It discarded
- * 4 of every 6 rewrites, almost always because the writer had asked HIMSELF a
- * question ("Now the proof: does it fire?") which the rewrite correctly cut as
- * narration. Counting punctuation cannot tell an ask from thinking out loud.
- *
- * A reader can. So the same model that wrote the short version now reads it
- * back against one question — is this what David needs, and is it as short as
- * his rules demand — and fixes it. The reviewer returns text, never a verdict,
- * so there is no path on which the work is discarded.
- */
-const REVIEW = `You are checking a shortened reply before it reaches David.
-
-He is a slow reader. Every extra line costs him real time.
-
-Two questions, both about the SHORT version:
-
-1. Is this ONLY what he needs? Cut anything that does not change what he
-   decides, what he does next, or what he now knows. The work someone did,
-   steps taken, what was checked, what was ruled out — his business only if he
-   asked.
-
-2. Is it truly concise by his rules? Answer first, nothing before it. No
-   preamble, no backstory, no jargon standing in for a plain word. Lists and
-   small tables over paragraphs.
-
-Then check nothing was lost that he needs:
-- a question he is meant to ANSWER must still be there, as its own line at the
-  end. A question the writer asked himself is narration — it should be gone.
-- warnings, failures, and things that went wrong stay.
-- file paths, links, code blocks and specific numbers stay exactly as written.
-- no fact, number or name may change, and nothing may be added.
-
-Return the final reply and nothing else. If it is already right, return it
-unchanged. Never return commentary, never return an empty response.`;
-
-/** One call to a fresh Claude. Used by both passes. */
-function askClaude(prompt, cfg) {
-  // `--setting-sources project` is what stops the shortener shortening itself.
-  //
-  // A child started with the personal settings inherits the very Stop hook that
-  // spawned it: it answers in about 4 seconds, its own hook then sees an answer
-  // over the 60-word threshold and spawns a THIRD Claude, and the outer call
-  // waits ~46s for work it caused — past the 45s limit, so it was killed and
-  // returned nothing, every turn since it shipped. Measured: 54.2s/54.5s with
-  // the personal settings, 7.9s/6.2s with only the project's.
-  //
-  // The trigger was always the CHILD'S OWN REPLY crossing 60 words, never the
-  // input: a 63-character prompt that produces a long answer is just as slow
-  // (57.2s on, 11.7s off).
-  //
-  // Not `--bare`, the documented skip-hooks flag: it also skips the keychain, so
-  // the child returns "Not logged in" in 0.7s. Not `--settings '{}'` either —
-  // settings layers merge, so a lower layer cannot remove a higher layer's hook
-  // (54.5s/56.1s, unchanged).
-  const run = spawnSync("claude",
-    ["-p", prompt, "--model", cfg.model, "--dangerously-skip-permissions",
-     "--setting-sources", "project"],
-    { encoding: "utf8", timeout: cfg.timeoutMs, maxBuffer: 8 * 1024 * 1024 });
-
-  if (run.error) {
-    // A timeout is the failure that hid for two days: every turn paid the full
-    // wait, produced nothing, and said nothing. Write it to stderr so the cost
-    // is visible even though the reply still goes through untouched.
-    const timedOut = run.error.code === "ETIMEDOUT";
-    if (timedOut) {
-      process.stderr.write(
-        `[gsd-t] the concise rewriter timed out after ${Math.round(cfg.timeoutMs / 1000)}s ` +
-        `and produced nothing — every turn is paying that wait. Switch it off with ` +
-        `.gsd-t/concise.json {"enabled": false} until it is fixed.\n`
-      );
-    }
-    return { ok: false, error: run.error.message, timedOut };
-  }
-  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 };
-}
-
-/** Pass 1 — shorten it. */
-function rewrite(text, cfg) {
-  return askClaude(`${RULES}\n\n--- REPLY TO REWRITE ---\n${text}`, cfg);
-}
-
-/**
- * Pass 2 — read the short version back and fix what pass 1 got wrong.
- *
- * Returns text, never a verdict, so the work is never discarded. If the review
- * itself fails, pass 1's rewrite stands: it was already an improvement, and
- * losing it because a second opinion did not arrive would be the old bug in a
- * new place.
- */
-function review(original, shortened, cfg) {
-  const prompt = `${REVIEW}\n\n--- WHAT HE ORIGINALLY WROTE (for reference only) ---\n${original}\n\n--- THE SHORT VERSION TO CHECK AND RETURN ---\n${shortened}`;
-  const r = askClaude(prompt, cfg);
-  return r.ok ? r.text : shortened;
-}
-
-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);
-  }
-
-  // Second pass: the same model reads its own short version back, against the
-  // only two questions that matter — is this what David needs, and is it as
-  // short as his rules demand. It returns text, so nothing is ever discarded.
-  const finalText = review(text, r.text, cfg);
-
-  const after = wordCount(finalText);
-  emit({
-    ok: true, exitCode: EXIT_OK, text: finalText,
-    words: before, wordsAfter: after,
-    saved: before - after,
-  }, args.json);
-}
-
-if (require.main === module) main();
-
-module.exports = { wordCount, readConfig, rewrite, review, askClaude, RULES, REVIEW };

package/scripts/gsd-t-concise-hook.js

@@ -1,255 +0,0 @@
-#!/usr/bin/env node
-/**
- * gsd-t-concise-hook.js
- *
- * M107-D2 — Stop hook. Sends a long reply to a fresh Claude for a shorter
- * rewrite, then blocks the stop so the short version is what David reads.
- *
- * [RULE] concise-hook-never-loops
- * [RULE] concise-hook-fails-open-on-rewrite-failure
- *
- * A Stop hook cannot edit a reply that is already written. It can only block
- * the stop and hand back an instruction. So: read the reply from the
- * transcript, get the short version, and block once with "replace your last
- * reply with this". The model then emits the short version and stops.
- *
- * ─── Stdin (Claude Code Stop payload) ───────────────────────────────────────
- *   { "transcript_path": "...", "stop_hook_active": true|false, "cwd": "..." }
- *
- * ─── Loop guard ─────────────────────────────────────────────────────────────
- *   stop_hook_active === true means this Stop is already a re-entry from our
- *   own block. Exit 0 immediately. One rewrite per turn, never two.
- *
- * ─── Fail-open, deliberately ────────────────────────────────────────────────
- *   Unlike the fallback guard, this one ALLOWS on failure. It governs how a
- *   reply READS, not whether it is true. A broken rewriter must never gag a
- *   correct answer — showing a long reply is a poor outcome, showing none is a
- *   wrong one. The rewriter itself returns the original when it cannot do
- *   better, so no content is ever lost.
- *
- * Zero dependencies.
- */
-
-"use strict";
-
-const fs = require("fs");
-const os = require("os");
-const path = require("path");
-const { spawnSync } = require("child_process");
-
-const DEFAULT_SKIP_UNDER = 60; // words
-
-function allow() { process.exit(0); }
-
-function block(reason) {
-  process.stdout.write(JSON.stringify({ decision: "block", reason }) + "\n");
-  process.exit(0);
-}
-
-/** Only read transcripts from the Claude projects directory. */
-function safeTranscriptPath(p) {
-  if (typeof p !== "string" || !p) return null;
-  if (!path.isAbsolute(p)) return null;
-  const home = process.env.HOME || os.homedir();
-  if (!home) return null;
-  const root = path.resolve(home, ".claude", "projects") + path.sep;
-  const resolved = path.resolve(p);
-  return resolved.startsWith(root) ? resolved : null;
-}
-
-function readTail(filePath, bytes) {
-  let fd = -1;
-  try {
-    const st = fs.statSync(filePath);
-    if (!st.isFile() || st.size === 0) return "";
-    const want = Math.min(bytes, st.size);
-    const start = st.size - want;
-    fd = fs.openSync(filePath, "r");
-    const buf = Buffer.alloc(want);
-    fs.readSync(fd, buf, 0, want, start);
-    let s = buf.toString("utf8");
-    if (start > 0) {
-      const nl = s.indexOf("\n");
-      if (nl >= 0) s = s.slice(nl + 1);
-    }
-    return s;
-  } catch (_) {
-    return "";
-  } finally {
-    if (fd >= 0) { try { fs.closeSync(fd); } catch (_) { /* already closed */ } }
-  }
-}
-
-/**
- * Pull the last assistant turn's visible text from the transcript.
- * Returns { text, toolOnly } — a tool-only turn has no prose to shorten.
- */
-/**
- * Did the user actually type this, or is it a tool result wearing their role?
- *
- * The transcript records a tool's output as a "user" message whose content is
- * tool_result blocks. Only a message with real text is the person speaking.
- */
-function _isRealUserMessage(msg) {
-  const content = msg.content;
-  if (typeof content === "string") return content.trim().length > 0;
-  if (!Array.isArray(content)) return false;
-  return content.some(
-    (b) => b && b.type === "text" && typeof b.text === "string" && b.text.trim().length > 0
-  );
-}
-
-/**
- * The prose of the reply that just finished.
- *
- * A turn does not end with the words the user reads — it ends with whatever ran
- * last, and that is usually a tool call. Stopping at the FIRST assistant record
- * therefore found `toolOnly` and gave up, every time: the rewriter never ran
- * once in the two days after it shipped. So walk back through the tool calls to
- * the prose, and join every text block in the turn, since a reply is often
- * written in pieces around the tools it uses.
- *
- * The walk stops at the user's own message. Past that lies the PREVIOUS turn,
- * and rewriting a reply the user has already read would replace the wrong thing.
- */
-function lastAssistantText(transcriptPath) {
-  const tail = readTail(transcriptPath, 512 * 1024);
-  if (!tail) return null;
-  const lines = tail.split("\n").filter(Boolean);
-
-  const pieces = [];
-  let sawAssistant = false;
-
-  for (let i = lines.length - 1; i >= 0; i--) {
-    let rec;
-    try { rec = JSON.parse(lines[i]); } catch (_) { continue; }
-    const msg = rec && rec.message;
-    if (!msg) continue;
-
-    // The start of this turn. Anything earlier belongs to a turn already read.
-    //
-    // A tool RESULT is also recorded with role "user", so the boundary is a user
-    // message carrying real text — treating every "user" record as the boundary
-    // stops at the first tool result and finds nothing at all.
-    if (msg.role === "user") {
-      if (_isRealUserMessage(msg)) break;
-      continue;
-    }
-    if (msg.role !== "assistant") continue;
-
-    sawAssistant = true;
-    const content = Array.isArray(msg.content) ? msg.content : [];
-    const text = content.filter((b) => b && b.type === "text")
-      .map((b) => b.text || "").join("\n").trim();
-    if (text) pieces.unshift(text);
-  }
-
-  if (!sawAssistant) return null;
-
-  const text = pieces.join("\n\n").trim();
-  // Every record in the turn was a tool call — there is no prose to shorten.
-  return { text, toolOnly: !text };
-}
-
-function wordCount(s) {
-  return (String(s).trim().match(/\S+/g) || []).length;
-}
-
-function readConfig(projectDir) {
-  const p = path.join(projectDir, ".gsd-t", "concise.json");
-  if (!fs.existsSync(p)) return { enabled: true, skipUnder: DEFAULT_SKIP_UNDER };
-  try {
-    const cfg = JSON.parse(fs.readFileSync(p, "utf8"));
-    return {
-      enabled: cfg.enabled !== false,
-      skipUnder: Number.isFinite(cfg.skipUnder) ? cfg.skipUnder : DEFAULT_SKIP_UNDER,
-    };
-  } catch (_) {
-    return { enabled: true, skipUnder: DEFAULT_SKIP_UNDER };
-  }
-}
-
-/**
- * Locate the rewriter. Every project carries its own copy; if it does not, the
- * install is broken and the SessionStart heal hook repairs it. Two exact
- * locations, no hunting.
- */
-function findRewriter(projectDir) {
-  const inProject = path.join(projectDir, "bin", "gsd-t-concise-rewrite.cjs");
-  if (fs.existsSync(inProject)) return inProject;
-  const inPackage = path.join(__dirname, "..", "bin", "gsd-t-concise-rewrite.cjs");
-  if (fs.existsSync(inPackage)) return inPackage;
-  return null; // the caller lets the reply through — see the note on main()
-}
-
-function main() {
-  let input = "";
-  let done = false;
-
-  process.stdin.setEncoding("utf8");
-  process.stdin.on("data", (c) => { input += c; });
-
-  const finish = () => {
-    if (done) return;
-    done = true;
-
-    let data;
-    try { data = JSON.parse(input); } catch (_) { return allow(); }
-    if (!data || typeof data !== "object") return allow();
-
-    // One rewrite per turn. This Stop is our own re-entry — let it through.
-    if (data.stop_hook_active === true) return allow();
-
-    const cwd = (typeof data.cwd === "string" && data.cwd) ? data.cwd : process.cwd();
-    const cfg = readConfig(cwd);
-    if (!cfg.enabled) return allow();
-
-    const tPath = safeTranscriptPath(data.transcript_path);
-    if (!tPath) return allow();
-
-    const last = lastAssistantText(tPath);
-    if (!last || last.toolOnly || !last.text) return allow();
-    if (wordCount(last.text) < cfg.skipUnder) return allow();
-
-    const rewriter = findRewriter(cwd);
-    if (!rewriter) return allow();
-
-    // The rewriter's own warnings go to stderr. Captured into a pipe and never
-    // read, they reach nobody — which is why the timeouts stayed invisible even
-    // after a loud message was added for them. Letting the child write straight
-    // to this process's stderr is what makes a give-up path visible; these paths
-    // are approved passes precisely BECAUSE the reader can see them happen.
-    const run = spawnSync(process.execPath,
-      [rewriter, "--text", last.text, "--project", cwd, "--json"],
-      { encoding: "utf8", timeout: 60000, maxBuffer: 8 * 1024 * 1024,
-        stdio: ["ignore", "pipe", "inherit"] });
-
-    if (run.error || !run.stdout) return allow();
-
-    let result;
-    try { result = JSON.parse(run.stdout); } catch (_) { return allow(); }
-
-    // The rewriter returns the original when it cannot do better. Nothing was
-    // lost, so there is nothing to replace.
-    if (!result.ok || !result.text || result.skipped) return allow();
-    if (result.text.trim() === last.text.trim()) return allow();
-
-    const saved = (result.words || 0) - (result.wordsAfter || 0);
-    if (saved < 15) return allow(); // not worth the extra turn
-
-    block(
-      "Your last reply was longer than it needed to be. Replace it with this " +
-      "shorter version, exactly as written, and add nothing:\n\n" +
-      result.text
-    );
-  };
-
-  process.stdin.on("end", finish);
-  process.stdin.on("error", finish);
-  const wd = setTimeout(finish, 70000);
-  if (wd.unref) wd.unref();
-}
-
-if (require.main === module) main();
-
-module.exports = { lastAssistantText, wordCount, readConfig, findRewriter, safeTranscriptPath };