@tekyzinc/gsd-t 5.11.23 → 5.11.24

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.11.24] - 2026-08-11
+
+### Fixed — the code graph never reached a single scanning agent for six weeks
+
+`graphWiringMode` was set to `"WIRED"` and tested with `=== "wired"`. Case
+sensitive, so never true: the structural slice — dead-code candidates, dangling
+references, clusters — was computed on every scan and then discarded, unused,
+from **2026-06-30 to 2026-08-11**.
+
+Nothing looked wrong. The register header prints the same variable, so every
+scan honestly reported `WIRED`: the graph really had built and answered. Its
+results simply never arrived where they were needed. Every scan in those six
+weeks ran graph-blind while reporting the graph as wired.
+
+**It was the second time the same variable broke this way.** The producer was
+uppercased in M99 to satisfy a metrics rollup comparing `=== "WIRED"`, and that
+fix broke the scan's own consumer. Matching one casing to another moves the bug;
+both ends now compare without case, which is the house rule for a value like
+this anyway.
+
+The M99 test that required exact casing is **superseded** — it locked in the
+requirement that caused the outage it was written to prevent. Replaced by a
+guard on the property that actually matters: a mode the scan emits is a mode
+every reader recognises, however it was typed.
+
+- `templates/workflows/gsd-t-scan.workflow.js`: the consumer, and the comment that told the next maintainer to match casing
+- `bin/gsd-t-graph-metrics-rollup.cjs`: all three mode comparisons
+- `test/m112-graph-wiring-casing.test.js`: 6 tests, including that no reader compares case-sensitively
+- `test/m99-graph-metrics-rollup.test.js`: the old casing guard replaced
+
 ## [5.11.23] - 2026-08-10
 
 ### Fixed — the scan could silently leave code out, and slices were too large to read

package/README.md

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

@@ -337,14 +337,17 @@ function rollup(projectRoot) {
           byConsumer[consumer].wiringCount++;
 
           const mode = ev.graphWiringMode || "";
-          if (mode === "WIRED") {
+          // Case-insensitive: matching an exact casing here is what started the
+          // six-week outage — the producer was uppercased to satisfy this line
+          // and the scan's own consumer (which tested lowercase) went dead.
+          if (String(mode).toLowerCase() === "wired") {
             l2cWiredCount++;
-          } else if (mode === "fallback-announced") {
+          } else if (String(mode).toLowerCase() === "fallback-announced") {
             l2cFallbackCount++;
             // Record minute-bucket for co-occurrence check
             if (!fallbackBuckets[consumer]) fallbackBuckets[consumer] = new Set();
             fallbackBuckets[consumer].add(_minuteBucket(ev.ts));
-          } else if (mode === "disabled") {
+          } else if (String(mode).toLowerCase() === "disabled") {
             l2cDisabledCount++;
           }
           break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.11.23",
+  "version": "5.11.24",
   "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/workflows/gsd-t-scan.workflow.js

@@ -675,15 +675,16 @@ if (graphMode === "disabled") {
         },
         tier: (deadCodeResult && deadCodeResult.tier) || (danglingResult && danglingResult.tier) || "unknown",
       };
-      // M99 Red Team fix: emit "WIRED" (uppercase) to MATCH the --auto router
-      // producers (bin/gsd-t.js:3915) AND the rollup's comparison
-      // (gsd-t-graph-metrics-rollup.cjs:333 `=== "WIRED"`). Lowercase "wired" here
-      // fell through all three rollup branches → a successfully-wired scan reported
-      // WIRED:0, defeating success criterion 13 (the metric M99 exists to surface).
-      // [RULE] wiring-mode-casing-matches-rollup
+      // The casing here no longer matters: every reader of this value compares
+      // without case (2026-08-11). It was uppercased in M99 to satisfy a rollup
+      // that tested `=== "WIRED"`, and that broke the scan's own consumer, which
+      // tested `=== "wired"` — the structural slice was silently discarded for
+      // six weeks. Chasing one casing to match another is what caused both
+      // outages; the readers were fixed instead.
+      // [RULE] wiring-mode-compared-without-case
       graphWiringMode = "WIRED";
       log(`graph-wiring: WIRED — structural slice ready (dead-code: ${structuralSlice.deadCode.length} candidates, dangling: ${structuralSlice.dangling.length} edges, clusters: ${structuralSlice.clusters.length} groups, tier: ${structuralSlice.tier}). Slice will be INJECTED ADDITIVELY into scanSlice deep-finders. [RULE] scan-injects-structural-slice`);
-      await persistWiringMode("WIRED"); // M99 D2 [RULE] wiring-mode-three-states / wiring-mode-casing-matches-rollup
+      await persistWiringMode("WIRED"); // M99 D2 [RULE] wiring-mode-three-states / wiring-mode-compared-without-case
     }
   }
 }
@@ -921,7 +922,18 @@ async function scanSlice(slice) {
   // M94-D6: inject the structural slice context ADDITIVELY — only when graph is wired.
   // When graphMode==="disabled" OR graph-unavailable, graphSliceContext is null (no injection).
   // [RULE] scan-injects-structural-slice / [RULE] no-graph-baseline-proven-graph-free
-  const graphSliceContext = (graphWiringMode === "wired" && structuralSlice) ? structuralSlice : null;
+  // Compared case-INSENSITIVELY. This test read `=== "wired"` while the producer
+  // wrote "WIRED", so it was never true: the structural slice was computed and
+  // then discarded, unused, from 2026-06-30 until 2026-08-11. Every scan in
+  // those six weeks ran graph-blind while logging WIRED — the header was not
+  // lying (the graph DID build and answer), its results simply never arrived.
+  //
+  // The producer was uppercased to fix a metrics rollup that compared to
+  // "WIRED"; that fix broke this consumer. Matching the casing again would just
+  // move the bug a third time, so both ends now compare without case — which is
+  // the house rule for a value like this in the first place.
+  const graphSliceContext =
+    (String(graphWiringMode).toLowerCase() === "wired" && structuralSlice) ? structuralSlice : null;
   const finderResult = await runFinder(slice, graphSliceContext);
   // M72: distinguish a FAILED finder (null after retries) from a genuinely-clean slice.
   if (!finderResult || !Array.isArray(finderResult.findings)) {