@tekyzinc/gsd-t 5.12.11 → 5.13.10

package/CHANGELOG.md

@@ -2,6 +2,68 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.13.10] - 2026-08-22
+
+### Added — trim and case are enforced at the boundary, FAIL-CLOSED
+
+Case and trim bugs kept arriving across projects, surfacing only as unexpected
+bugs days later: a status compared against a literal that never matched, an
+email stored with a trailing space, a value saved untrimmed that then broke
+every later comparison including the correct ones. The written standard could
+not stop any of it, because nothing checked it.
+
+**Measured before designing.** A check on COMPARISONS is unusable: one real
+project holds 1,275 literal string comparisons, 193 shaped like business
+values, and nearly all of those are legitimate — internal message tags, a build
+mode, a value the code itself wrote a line earlier. That is roughly 190 false
+alarms per project, and a check that noisy gets switched off while still
+looking enforced.
+
+So the check sits at the ENTRY POINT instead — where a value arrives from a
+form, a URL, or a request. That is where "did this value cross a boundary?" is
+actually knowable, there are a handful of them against hundreds of uses, and it
+covers STORED values too, which no comparison rule ever reaches.
+
+- `bin/gsd-t-boundary-normalize-check.cjs`: `--full` is a one-time
+  whole-project inventory that reports without blocking, so a project can adopt
+  the rule the day it lands; the default mode inspects only files a run touched
+  and FAILS on an unclean entry point. No baseline file — a stored list of
+  accepted violations is one that can be quietly extended. An exemption is
+  written at the entry point itself (`// gsd-t-allow-raw: <reason>`).
+- `bin/gsd-t-verify-gate.cjs`: wired as `boundary-normalize`.
+- `bin/gsd-t.js`: registered in both propagation lists.
+- `templates/stacks/_comparison.md`: the rule, with a live defect as its
+  example.
+- `test/m114-boundary-normalize.test.js`: 18 tests, including the negative
+  cases that prove the check can actually fail.
+
+**Trimming is universal — passwords included.** A leading or trailing space is
+never something a person meant to type; storing a password untrimmed locks them
+out when they later type it normally. Only free text a person wrote on purpose
+(a note, a description, a message body) keeps its spaces. Case-sensitive means
+*do not change the casing*; it never means *do not trim*.
+
+Live findings, all genuine: binvoice 9, TimeTracking 29, UMI-Automation 28 —
+including a signup route that trims an email and never lowercases it, so two
+spellings of one address become two accounts.
+
+### Fixed — the architect spawned a background agent and lost its own report
+
+Five consecutive architect runs looked like an idle session. Watched live: the
+subagent worked for three minutes, logged a clean completion, and six seconds
+later the parent called `ListAgents` — hunting for a result that never arrived.
+
+One stale line caused it. Step 4 said "spawn ONE Task subagent", terminology
+from a tool that no longer exists. The current `Agent` tool accepts a `name`,
+and a named agent runs in the BACKGROUND: its report arrives as a notification
+rather than as the call's return value, leaving the parent with nothing.
+
+- `commands/gsd-t-architect.md`: Step 4 specifies the blocking form and bans
+  passing a `name`; Step 4a treats an availability ping as an empty return and
+  bans reaching for `ListAgents`/`SendMessage` to find a result.
+- `commands/gsd-t-health.md`, `-quick.md`, `-status.md`: the same guard where
+  they spawn.
+
 ## [5.12.11] - 2026-08-22
 
 ### Fixed — the architect could finish its work and leave nothing, silently

package/README.md

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

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * gsd-t-boundary-normalize-check — a value entering the program must be cleaned
+ * where it enters.
+ *
+ * The bug this exists to stop is quiet. A status arrives from a form with a
+ * trailing space, or a filter arrives from a URL with different casing than the
+ * literal it is compared against. The comparison answers "no match", nothing
+ * reports anything, and the feature simply does nothing. It is found days later
+ * as an unexpected bug, traced back by hand.
+ *
+ * Why the check lives at the ENTRY POINT rather than at the comparison:
+ * measured, not assumed. One real project holds 1,275 literal string
+ * comparisons, 193 of them shaped like business values, and nearly all of those
+ * are legitimate — internal message tags, a build mode, a value the code itself
+ * wrote a line earlier. A check flagging comparisons produces roughly 190 false
+ * alarms per project, and a check that noisy gets switched off. Switched off it
+ * enforces nothing while still looking enforced.
+ *
+ * A comparison cannot be judged alone: whether it is a bug depends on where the
+ * value came from. The entry point is where that is knowable, and a project has
+ * a handful of entry points against hundreds of uses. Cleaning there also
+ * covers values that are STORED, which no comparison rule ever reaches — and
+ * half the reported bugs were stored values.
+ *
+ * Two modes, chosen by whether the project has been checked before:
+ *
+ *   full     every entry point in the project. Reports, never blocks. This is
+ *            the one-time inventory for a project adopting the rule.
+ *   changed  only entry points in files this run touched. An unclean one FAILS.
+ *
+ * Nothing is ever recorded as "permitted". A stored list of accepted violations
+ * is a list somebody can quietly extend, and then the check measures the list
+ * rather than the code. An exemption is written at the entry point itself, in a
+ * comment, where the next reader is already looking.
+ *
+ * Exit 0 clean or reporting, 1 on a blocking failure, 64 when the check cannot
+ * be run at all. It never passes a question it could not answer.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+// ─── What counts as a value entering the program ─────────────────────────────
+//
+// Each entry is a way a value arrives from outside: something a person typed, a
+// web address, or a row read back from storage.
+// Matched on the read itself, so the check sees the value at the moment it
+// crosses in.
+const ENTRY_POINTS = [
+  { id: "http-body", re: /\breq(?:uest)?\.body\s*(?:\.|\[)/g, what: "a request body" },
+  { id: "http-query", re: /\breq(?:uest)?\.query\s*(?:\.|\[)/g, what: "a URL query value" },
+  { id: "http-params", re: /\breq(?:uest)?\.params\s*(?:\.|\[)/g, what: "a URL path value" },
+  { id: "url-search", re: /\b(?:searchParams|URLSearchParams)\s*\.\s*get\s*\(/g, what: "a URL query value" },
+  { id: "form-data", re: /\bformData\s*\.\s*get\s*\(/g, what: "a submitted form value" },
+  { id: "dom-input", re: /\.\s*value\s*(?:;|,|\)|\s*$)/g, what: "a typed-in field", weak: true },
+];
+
+// TRIMMING IS UNIVERSAL. A leading or trailing space is never something a
+// person meant to type — it is paste damage. That includes a PASSWORD: a space
+// on the end is not part of the secret, it is a stray keystroke, and storing it
+// untrimmed locks the person out when they later type the password normally.
+//
+// The only values where the space IS the content are free text a person wrote
+// on purpose — a note, a description, a message body. Everything else, without
+// exception, is trimmed where it enters.
+const FREE_TEXT_NAMES =
+  /\b(note|notes|description|comment|comments|message|messageBody|content|text|summary|bio)\b/i;
+
+// A value naming something in the business. These cross boundaries where the
+// casing is free to change, so they are lowercased as well as trimmed.
+const DOMAIN_NAMES = /\b(status|state|filter|tab|mode|role|category|kind|type|view|email|username|slug)\b/i;
+
+// Casing is part of the value here. Lowercasing these is a defect, and for the
+// first group a security defect — it shrinks the space a secret lives in.
+const CASE_SENSITIVE_NAMES =
+  /\b(password|passwd|secret|token|apiKey|api_key|signature|hash|digest|salt|nonce|sessionId|path|filepath|url|uri|href|base64|sha|checksum)\b/i;
+
+// Cleaning that satisfies the rule, at or near the entry point.
+const TRIMS = /\.\s*trim\s*\(\s*\)|\btrimmed\b|\bnormali[sz]e[A-Za-z]*\s*\(/;
+const LOWERS = /\.\s*toLowerCase\s*\(\s*\)|\.\s*toUpperCase\s*\(\s*\)|\blocaleCompare\s*\(/;
+
+// An exemption is written where the value enters, never in a separate file.
+const EXEMPT = /gsd-t-(?:allow-raw|raw-value)\s*:\s*\S/;
+
+const CODE_EXT = /\.(?:ts|tsx|js|jsx|mjs|cjs)$/i;
+// Bundled and minified files are generated, not authored: a bundle carries its
+// dependencies' internals, and reporting Express's own parameter handling is work
+// nobody can act on. One real project produced 46 of its 75 findings from a single
+// bundle file.
+const GENERATED_FILE = /(?:^|\/)(?:_?bundle|.*\.bundle|.*\.min|.*-bundle)\.[cm]?jsx?$/i;
+// Generated output is not authored code. Matched with a suffix so `dist-local`
+// and `dist-test` are skipped too — a check that lints its own build output
+// reports work nobody can act on.
+const SKIP_PATH =
+  /(?:^|\/)(?:node_modules|\.git|dist[\w.-]*|build[\w.-]*|out|coverage|\.next|\.nuxt|vendor|\.venv|__pycache__)(?:\/|$)/;
+const TEST_PATH = /(?:\.(?:test|spec)\.[tj]sx?$|(?:^|\/)(?:__tests__|tests?|e2e)\/)/i;
+
+/** Raised when the check cannot answer its own question. Never caught into a pass. */
+class CannotCheck extends Error {}
+
+/**
+ * Files this run touched, as git reports them.
+ *
+ * Git failing to answer is a HALT, not a pass. "Which files did this run
+ * touch?" is the question the whole changed-mode check rests on; answering it
+ * with "none" would report a clean run over code nobody examined.
+ */
+function changedFiles(projectDir) {
+  let out;
+  try {
+    out = execFileSync(
+      "git",
+      ["status", "--porcelain=v1", "--untracked-files=all"],
+      { cwd: projectDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    );
+  } catch (err) {
+    throw new CannotCheck(
+      `git could not report which files changed in ${projectDir} ` +
+        `(${(err && err.message) || err}). Run with --full to inspect the whole project, or fix ` +
+        `git — a run that cannot see the changed files cannot vouch for them.`
+    );
+  }
+  const files = [];
+  for (const line of out.split("\n")) {
+    if (!line.trim()) continue;
+    const p = line.slice(3).trim();
+    const finalPath = p.includes(" -> ") ? p.split(" -> ").pop() : p;
+    files.push(finalPath.replace(/^"|"$/g, ""));
+  }
+  return files;
+}
+
+/**
+ * Every code file in the project, for the one-time inventory.
+ *
+ * A directory that cannot be read is a HALT: its files would silently go
+ * uninspected, and the inventory would claim a coverage it does not have.
+ */
+function allCodeFiles(projectDir) {
+  const found = [];
+  const walk = (dir, rel) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (err) {
+      throw new CannotCheck(
+        `${rel || "."} could not be listed (${(err && err.message) || err}), so the entry points ` +
+          `inside it were never examined.`
+      );
+    }
+    for (const e of entries) {
+      const r = rel ? `${rel}/${e.name}` : e.name;
+      if (SKIP_PATH.test(r)) continue;
+      if (e.isDirectory()) walk(path.join(dir, e.name), r);
+      else if (CODE_EXT.test(e.name) && !GENERATED_FILE.test(r)) found.push(r);
+    }
+  };
+  walk(projectDir, "");
+  return found;
+}
+
+/**
+ * The names that say what KIND of value this is: what it is being assigned to,
+ * and what property it was read from. Deliberately not the whole line — a line
+ * mentioning `req.body` carries the word "body", and judging on the whole line
+ * would exempt every request-body read in a project as though it were free text.
+ */
+function valueName(line) {
+  const parts = [];
+  const assigned = line.match(/(?:const|let|var)\s+([A-Za-z_$][\w$]*)/);
+  if (assigned) parts.push(assigned[1]);
+  // the property being read: the last `.name` or ['name'] on the line
+  for (const m of line.matchAll(/\.([A-Za-z_$][\w$]*)/g)) parts.push(m[1]);
+  for (const m of line.matchAll(/\[\s*['"]([^'"]+)['"]\s*\]/g)) parts.push(m[1]);
+  // drop the container words themselves; they name the doorway, not the value
+  return parts.filter((n) => !/^(body|query|params|value|get|trim|toLowerCase|toUpperCase)$/i.test(n)).join(" ");
+}
+
+/**
+ * Is this value cleaned at the point it enters?
+ *
+ * The window is the entry line plus the two lines after it: cleaning either
+ * rides on the same expression (`req.body.email.trim()`) or lands immediately
+ * (`const email = raw.trim()`). Looking further would start crediting unrelated
+ * cleaning elsewhere in the function, which is how a check begins passing code
+ * that is actually broken.
+ */
+function inspectEntry(lines, idx, entry) {
+  const window = lines.slice(idx, idx + 3).join("\n");
+
+  // The exemption is looked for on the line ABOVE as well, because that is
+  // where people write it — a comment explaining the next line sits before it.
+  const exemptWindow = lines.slice(Math.max(0, idx - 1), idx + 3).join("\n");
+  if (EXEMPT.test(exemptWindow)) return null; // deliberately raw, and said so here
+
+  const line = lines[idx];
+  const trimmed = TRIMS.test(window);
+
+  // Whether casing matters is decided by the NAME the value is given or read
+  // from, since that is what says which kind of value it is.
+  const caseSensitive = CASE_SENSITIVE_NAMES.test(valueName(line));
+  const domain = !caseSensitive && DOMAIN_NAMES.test(valueName(line));
+  const lowered = LOWERS.test(window);
+
+  const missing = [];
+  // Judged on the NAME the value is given or read from, never the whole line:
+  // `req.body` contains the word "body", which would exempt every request-body
+  // read in the project as if it were free text.
+  const freeText = FREE_TEXT_NAMES.test(valueName(line));
+  if (!trimmed && !freeText) missing.push("trimming");
+  if (domain && !lowered) missing.push("case-normalising");
+  if (missing.length === 0) return null;
+
+  return { entry, missing, line: line.trim().slice(0, 120) };
+}
+
+/** A file that cannot be read is a HALT — an unexamined entry point is not a clean one. */
+function scanFile(projectDir, rel) {
+  let text;
+  try {
+    text = fs.readFileSync(path.join(projectDir, rel), "utf8");
+  } catch (err) {
+    throw new CannotCheck(
+      `${rel} could not be read (${(err && err.message) || err}), so its entry points were never ` +
+        `checked.`
+    );
+  }
+  const lines = text.split("\n");
+  const problems = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*(?:\/\/|\*|#)/.test(line)) continue; // a comment is not code
+
+    for (const ep of ENTRY_POINTS) {
+      // The weak patterns match ordinary property reads too, so they only count
+      // where the line also names a kind of value the rule governs. Without
+      // that, `.value` alone would flag half of every React file.
+      if (ep.weak && !DOMAIN_NAMES.test(line)) continue;
+      ep.re.lastIndex = 0;
+      if (!ep.re.test(line)) continue;
+      const problem = inspectEntry(lines, i, ep);
+      if (problem) problems.push({ file: rel, line: i + 1, ...problem });
+      break; // one report per line; a second pattern there is the same value
+    }
+  }
+  return problems;
+}
+
+function check(projectDir, opts = {}) {
+  const mode = opts.mode === "full" ? "full" : "changed";
+  const includeTests = opts.includeTests === true;
+
+  let files =
+    mode === "full"
+      ? allCodeFiles(projectDir)
+      : changedFiles(projectDir).filter(
+          (f) => CODE_EXT.test(f) && !SKIP_PATH.test(f) && !GENERATED_FILE.test(f)
+        );
+
+  if (!includeTests) files = files.filter((f) => !TEST_PATH.test(f));
+
+  const problems = [];
+  const inspected = [];
+  for (const rel of files) {
+    problems.push(...scanFile(projectDir, rel));
+    inspected.push(rel);
+  }
+
+  const failures = problems.map(
+    (p) =>
+      `${p.file}:${p.line}: ${p.entry.what} is used without ${p.missing.join(" or ")} it — ` +
+      `clean it here, where it enters. (${p.line})`
+  );
+
+  // full mode is the one-time inventory: it reports so the list can be worked
+  // through, and never blocks. Blocking here would stop every existing project
+  // on day one, and a check nobody can adopt enforces nothing.
+  const blocking = mode === "changed";
+
+  return {
+    ok: blocking ? failures.length === 0 : true,
+    check: "boundary-normalize",
+    mode,
+    reportOnly: !blocking,
+    filesInspected: inspected.length,
+    failures,
+    note:
+      failures.length === 0
+        ? mode === "full"
+          ? "no entry point is missing its cleaning"
+          : "PASS: no touched file reads a value from outside the program"
+        : blocking
+          ? undefined
+          : `${failures.length} entry point(s) to fix — reported, not blocking (whole-project inventory)`,
+  };
+}
+
+function parseArgs(argv) {
+  const out = { projectDir: ".", mode: "changed", includeTests: false };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--project") out.projectDir = argv[++i] || ".";
+    else if (argv[i] === "--full") out.mode = "full";
+    else if (argv[i] === "--include-tests") out.includeTests = true;
+  }
+  return out;
+}
+
+module.exports = { check, scanFile, inspectEntry, ENTRY_POINTS, CannotCheck };
+
+if (require.main === module) {
+  const { projectDir, mode, includeTests } = parseArgs(process.argv.slice(2));
+  if (!fs.existsSync(projectDir)) {
+    process.stderr.write(`No such directory: ${projectDir}\n`);
+    process.exit(64);
+  }
+  let result;
+  try {
+    result = check(projectDir, { mode, includeTests });
+  } catch (err) {
+    if (err instanceof CannotCheck) {
+      process.stderr.write(`boundary-normalize CANNOT CHECK: ${err.message}\n`);
+      process.exit(64);
+    }
+    throw err;
+  }
+  process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  process.exit(result.ok ? 0 : 1);
+}

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

@@ -311,6 +311,8 @@ function _detectDefaultTrack2(projectDir, notes) {
 
   plan.push({ id: 'schema-id', cmd: 'node', args: [path.join(__dirname, 'gsd-t-schema-id-check.cjs'), '--project', projectDir], timeoutMs: 30000 }); // integer-identity PK on every NEW relational table, FAIL-CLOSED (no-op PASS when no new schema files)
 
+  plan.push({ id: 'boundary-normalize', cmd: 'node', args: [path.join(__dirname, 'gsd-t-boundary-normalize-check.cjs'), '--project', projectDir], timeoutMs: 60000 }); // M114: a value entering from a form/URL/request is trimmed (and case-normalised when it names a business value) WHERE IT ENTERS, FAIL-CLOSED on touched files only. Checks the entry point rather than the comparison: measured on a real project, a comparison lint yields ~190 false alarms and gets switched off, while the entry point is where "did this value cross a boundary?" is actually knowable — and it also covers STORED values, which no comparison rule reaches.
+
   plan.push({ id: 'fallbacks', cmd: 'node', args: [path.join(__dirname, 'gsd-t-fallback-detect.cjs'), '--scan', '--project', projectDir, '--json'], timeoutMs: 120000 }); // M106: no unapproved continue-after-failure branch, FAIL-CLOSED (pre-existing ones excluded via .gsd-t/fallbacks-baseline.json)
 
   plan.push({ id: 'graph-use', cmd: 'node', args: [path.join(__dirname, 'gsd-t-graph-use-gate.cjs'), '--project', projectDir, '--verify-mode'], timeoutMs: 30000 }); // M113: a consumer that logged graphWiringMode=WIRED must have issued >=1 graph query, FAIL-CLOSED (documented no-op PASS when no ledger exists yet). Catches what the STATIC anti-grep lint structurally cannot: a consumer that never queried at all.

package/bin/gsd-t.js

@@ -1786,6 +1786,7 @@ const GLOBAL_BIN_TOOLS = [
   // this by absolute path, so it MUST ship wherever the verify gate ships or the
   // schema-id check throws ENOENT. Same class as the M99 store-resolver omission below.
   "gsd-t-schema-id-check.cjs",
+  "gsd-t-boundary-normalize-check.cjs",
   // M112 — measures a slice plan in LINES and splits what is too big. Called by
   // the scan workflow before any reviewing starts.
   "gsd-t-slice-budget.cjs",
@@ -3468,6 +3469,7 @@ const PROJECT_BIN_TOOLS = [
   // it via an absolute path in the Track 2 plan, so a project that has the verify gate
   // but NOT this file gets an ENOENT on every verify. Ships alongside the gate itself.
   "gsd-t-schema-id-check.cjs",
+  "gsd-t-boundary-normalize-check.cjs",
   // M112 — measures a slice plan in LINES and splits what is too big. Called by
   // the scan workflow before any reviewing starts.
   "gsd-t-slice-budget.cjs",

package/commands/gsd-t-architect.md

@@ -232,10 +232,22 @@ confident you can direct a build that will not need rework.
 
 ---
 
-## Step 4: Launch the architect via a Task subagent
+## Step 4: Launch the architect as ONE blocking subagent
 
-Give the assessment a fresh context window. Spawn ONE Task subagent (`model: opus`) — this is
-high-stakes design judgment, top tier.
+Give the assessment a fresh context window. Spawn ONE subagent via the `Agent` tool
+(`model: "opus"` — high-stakes design judgment, top tier) and **wait for its return in this same
+turn.**
+
+**Do NOT pass a `name`.** A named agent runs in the BACKGROUND: its report arrives later as a
+notification rather than as this call's return value, and the parent is left holding nothing.
+That is a confirmed failure, observed twice — the architect ran for three minutes, logged a clean
+completion, and the parent answered by calling `ListAgents` (which returns a roster of running
+agents, never the assessment). The work was finished and unreachable.
+
+- **Correct:** `Agent({ subagent_type: "general-purpose", model: "opus", prompt: <the brief> })` —
+  blocks, and its return value IS the assessment.
+- **Wrong:** any call passing `name`, or any use of `SendMessage`/`ListAgents` to go fetch the
+  result afterwards. If you are hunting for the result, it was launched wrong.
 
 **Pass it the CONFIRMED GROUNDING from Steps 0-3, not just the raw target.** This is what the
 interview was for; a subagent that has to re-derive it will make the same mistakes again. Include:
@@ -269,12 +281,17 @@ idle session, because no step ever asked whether the subagent had answered.
 
 The moment the subagent returns, before any other work:
 
-1. **Did it return anything at all?** An empty return, a return that is only a status line, or no
-   return (the subagent died on an API error) → **HALT**. Say plainly: the architect subagent
-   produced no assessment, name the target, and stop. Do NOT retry silently, do NOT write a
-   summary from your own reading of the code — a summary you wrote yourself is not the
-   fresh-context assessment the user asked for, and presenting it as one is worse than the
-   silence.
+1. **Did it return anything at all?** An empty return, a return that is only a status line or an
+   agent-availability ping, or no return (the subagent died, or was launched as a background
+   agent) → **HALT**. Say plainly: the architect subagent produced no assessment, name the target,
+   and stop. Do NOT retry silently, do NOT write a summary from your own reading of the code — a
+   summary you wrote yourself is not the fresh-context assessment the user asked for, and
+   presenting it as one is worse than the silence.
+
+   **If you find yourself reaching for `ListAgents` or `SendMessage` to locate the result, STOP.**
+   That means Step 4 was launched wrong (a `name` was passed, making it a background agent).
+   Say so and re-launch it as a blocking call — do not go hunting, and do not carry on as though
+   an assessment had arrived.
 2. **Does it contain the required parts?** The Six-Stage answers and a `Simply Stated` lead. A
    return that skips stages is a partial result → say which stages are missing, then HALT.
 

package/commands/gsd-t-health.md

@@ -6,6 +6,13 @@ You are diagnosing the health of a GSD-T project. Check every required file and
 
 When invoked directly by the user, spawn yourself as a Task subagent for a fresh context window:
 
+> **Blocking, never named.** Spawn via the `Agent` tool and WAIT for its return in this
+> turn. Do NOT pass a `name` — a named agent runs in the background, its result arrives as a
+> notification instead of this call's return value, and the parent is left with nothing. If you
+> end up calling `ListAgents`/`SendMessage` to find the result, it was launched wrong: say so
+> and re-launch blocking. (Confirmed failure: gsd-t-architect, twice.)
+
+
 ```
 Task subagent (general-purpose, model: haiku):
 "Run the GSD-T health check. Read commands/gsd-t-health.md for your full instructions.

package/commands/gsd-t-quick.md

@@ -38,6 +38,13 @@ node scripts/gsd-t-watch-state.js advance --agent-id "$GSD_T_AGENT_ID" --parent-
 
 To give this task a fresh context window and prevent compaction during consecutive quick runs, always execute via a Task subagent.
 
+> **Blocking, never named.** Spawn via the `Agent` tool and WAIT for its return in this
+> turn. Do NOT pass a `name` — a named agent runs in the background, its result arrives as a
+> notification instead of this call's return value, and the parent is left with nothing. If you
+> end up calling `ListAgents`/`SendMessage` to find the result, it was launched wrong: say so
+> and re-launch blocking. (Confirmed failure: gsd-t-architect, twice.)
+
+
 **If you are the orchestrating agent** (you received the slash command directly):
 
 **Context observation (before spawning subagent):**

package/commands/gsd-t-status.md

@@ -6,6 +6,13 @@ You are checking the current state of the project across all domains.
 
 To keep the main conversation context lean, run status via a Task subagent.
 
+> **Blocking, never named.** Spawn via the `Agent` tool and WAIT for its return in this
+> turn. Do NOT pass a `name` — a named agent runs in the background, its result arrives as a
+> notification instead of this call's return value, and the parent is left with nothing. If you
+> end up calling `ListAgents`/`SendMessage` to find the result, it was launched wrong: say so
+> and re-launch blocking. (Confirmed failure: gsd-t-architect, twice.)
+
+
 **If you are the orchestrating agent** (you received the slash command directly):
 Spawn a fresh subagent using the Task tool:
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.12.11",
+  "version": "5.13.10",
   "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/templates/stacks/_comparison.md

@@ -4,6 +4,44 @@ These rules are MANDATORY. Violations fail the task. No exceptions.
 
 ---
 
+## 0. Clean The Value Where It Enters (trim first, then case)
+
+**Every value arriving from outside the program is trimmed at the point it enters — and
+case-normalised there too when it names something in the business.** Not at the comparison, and
+not at the save. At the doorway.
+
+A trailing space survives everything. It reaches the comparison (which answers "no match"), and
+it reaches the database (where it outlives the code fix, breaking every later comparison
+including correct ones). Cleaning at the entry point covers both, and there are a handful of
+entry points against hundreds of uses.
+
+```ts
+// GOOD — cleaned once, where it arrives
+const email  = (req.body.email  ?? '').trim().toLowerCase();
+const status = (req.query.status ?? '').trim().toLowerCase();
+const note   = (req.body.note   ?? '').trim();          // free text: trimming is fine,
+                                                        // never lowercased
+
+// BAD — a real defect, found by the boundary check in a live project:
+const email = req.body.email?.trim();   // trimmed, never lowercased.
+// David@x.com and david@x.com become two different accounts.
+```
+
+**Trim always — no exceptions by kind, passwords included.** A leading or trailing space is never
+something a person meant to type; it is paste damage. Storing a password untrimmed locks them out
+when they later type it normally. The ONLY values that keep their spaces are free text a person
+wrote on purpose: a note, a description, a message body.
+
+**Lowercase only business values** — never a password, token, signature, hash, encoded value, file
+path, URL, object key, or environment-variable name (see §2). Case-sensitive means *do not change
+the casing*; it never means *do not trim*.
+
+**Enforced mechanically** by `gsd-t boundary-normalize` in the verify gate: FAIL-CLOSED on files
+a run touched. A value that genuinely must stay raw says so at the entry point itself —
+`// gsd-t-allow-raw: <reason>` — never in a separate list of exceptions somewhere else.
+
+---
+
 ## 1. Domain String Comparisons Are Case-Insensitive by Default
 
 **Comparing a domain string VALUE against a literal is case-insensitive unless the user has