@tekyzinc/gsd-t 5.11.20 → 5.11.21

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.11.21] - 2026-08-10
+
+### Added — a final sweep that re-runs slices the rush broke
+
+Two slices failed an otherwise clean run on rate limits alone: ten agents in
+flight, the account throttled, and all three attempts landing inside the same
+squeeze. That failure says nothing about the slice — only about when it ran.
+
+After the deep scan, the run now waits 30 seconds for any active rate-limit
+window to pass, then retries every failed slice **one at a time, outside the
+concurrency gate**. Re-running failures through the same crowded gate that
+caused them would reproduce the cause.
+
+It costs a few minutes on runs that need it and nothing at all on runs that do
+not. A recovered slice stops being a coverage gap and its findings reach the
+register.
+
+The sweep runs **before** the partial-coverage halt, so the run only stops for
+what is genuinely lost.
+
+- `templates/workflows/gsd-t-scan.workflow.js`: the sweep; `allFindings` now reads the array the sweep repairs
+- `test/m112-scan-schema-tolerance.test.js`: 4 more tests — serial, before the halt, waits, and recovered findings reach the register
+
 ## [5.11.20] - 2026-08-10
 
 ### Fixed — the real cause of the scan failures: agents pass their answer as a string

package/README.md

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

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.11.20",
+  "version": "5.11.21",
   "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

@@ -824,9 +824,57 @@ slices.forEach((s, i) => {
   const r = resultsByIndex[i];
   if (!r || r.failed) failedSlices.push(s.key);
 });
+// ── Final sweep: re-run what the rush broke ─────────────────────────────────
+//
+// A slice can exhaust its three attempts purely because the run was at full
+// tilt — 10 agents in flight, the account rate-limited, and all three tries
+// landing inside the same squeeze. That failure says nothing about the slice.
+//
+// So once the deep scan is over and the burst has drained, try the stragglers
+// again: one at a time, unhurried, with the whole machine to themselves. It
+// costs a few minutes on the runs that need it and nothing at all on the runs
+// that do not.
+//
+// Serial and ungated on purpose. Re-running failures through the same crowded
+// gate that caused them would reproduce the cause.
+if (failedSlices.length > 0) {
+  log(`↻ final sweep — retrying ${failedSlices.length} failed slice(s) one at a time, now that the run has drained: ${failedSlices.join(", ")}`);
+  await sleep(30000); // let any active rate-limit window pass before starting
+
+  const stillFailed = [];
+  for (const key of failedSlices) {
+    const slice = slices.find((sl) => sl.key === key);
+    if (!slice) { stillFailed.push(key); continue; }
+
+    const recovered = await scanSlice(slice); // scanSlice resolves its own graph context
+
+    if (recovered && !recovered.failed) {
+      const idx = slices.indexOf(slice);
+      resultsByIndex[idx] = recovered;
+      log(`✓ sweep recovered "${key}" — ${(recovered.findings || []).length} finding(s)`);
+    } else {
+      stillFailed.push(key);
+      log(`✗ sweep could not recover "${key}"`);
+    }
+  }
+
+  // Only the failed list needs updating by hand — coverage and the findings
+  // list are computed from `resultsByIndex` below, which the sweep has already
+  // repaired in place.
+  failedSlices.length = 0;
+  failedSlices.push(...stillFailed);
+
+  log(stillFailed.length === 0
+    ? `✓ final sweep restored full coverage — ${slices.length}/${slices.length} slices`
+    : `⚠ final sweep left ${stillFailed.length} slice(s) unrecovered: ${stillFailed.join(", ")}`);
+}
+
 const succeededCount = slices.length - failedSlices.length;
 const coverageComplete = failedSlices.length === 0;
-const allFindings = sliceResults.filter(Boolean).filter((r) => !r.failed).flatMap((r) => (r.findings || []).map((f) => ({ ...f, slice: r.slice })));
+// Read from resultsByIndex, not sliceResults: the final sweep writes recovered
+// slices back into resultsByIndex, and a recovered slice's findings must reach
+// the register.
+const allFindings = resultsByIndex.filter(Boolean).filter((r) => !r.failed).flatMap((r) => (r.findings || []).map((f) => ({ ...f, slice: r.slice })));
 if (!coverageComplete) {
   log(`⚠ PARTIAL COVERAGE — ${failedSlices.length}/${slices.length} slices failed after retry and produced NO findings: ${failedSlices.join(", ")}.`);