@tekyzinc/gsd-t 5.11.18 → 5.11.19

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.11.19] - 2026-08-10
+
+### Changed — a scan that lost areas now STOPS instead of writing the report
+
+It already warned and stamped the register PARTIAL. It kept going anyway, so the
+register got written, read, and acted on. On HiloAviation the two lost areas
+were repositories and data-access — the areas with the most to find. A report
+that under-counts the debt while looking finished is worse than no report.
+
+The stop happens **before synthesis and before any document is written**, names
+every area that was missed, and returns a failure rather than a quiet success.
+It also says plainly that a failed area is not a clean one.
+
+`allowPartial: true` continues deliberately, says so out loud, and the register
+still carries its PARTIAL banner.
+
+- `templates/workflows/gsd-t-scan.workflow.js`: the halt + the `allowPartial` option
+- `test/m112-scan-schema-tolerance.test.js`: 4 more tests — the halt precedes writing, names the areas, fails rather than passes, and cannot be bypassed by a truthy-ish value
+
 ## [5.11.18] - 2026-08-10
 
 ### Fixed — a scan finding was thrown away over its FORM, not its truth

package/README.md

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

@@ -56,6 +56,9 @@ const maxSlicesOverride = _args.maxSlicesHint || null; // optional power-user ce
 // M94-D6: graph wiring — "wired" (default) or "disabled" (no-graph baseline for AC-4).
 // [RULE] scan-injects-structural-slice / [RULE] no-graph-baseline-proven-graph-free
 const graphMode     = (_args.graphMode === "disabled") ? "disabled" : "wired";
+// A scan that lost areas STOPS rather than writing a register that under-counts
+// the debt while looking finished. Set true to accept an incomplete scan.
+const allowPartial  = _args.allowPartial === true;
 
 // VOLUME-DERIVED CAP — a RUNAWAY BACKSTOP, not the target count. The probe decides
 // the actual slice count by cohesive sub-domain WITHIN this cap; the cap only fires
@@ -740,7 +743,50 @@ 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 })));
 if (!coverageComplete) {
-  log(`⚠ PARTIAL COVERAGE — ${failedSlices.length}/${slices.length} slices failed after retry and produced NO findings: ${failedSlices.join(", ")}. The register will be flagged INCOMPLETE. Resume the run to re-scan only the failed slices.`);
+  log(`⚠ PARTIAL COVERAGE — ${failedSlices.length}/${slices.length} slices failed after retry and produced NO findings: ${failedSlices.join(", ")}.`);
+
+  // HALT. A scan whose densest areas dropped out is not a scan with a caveat —
+  // it is a report that under-counts the debt while looking finished. On
+  // HiloAviation two of 228 slices failed, and the two were repositories and
+  // data-access: the areas with the most to find. Warning and continuing meant
+  // the register got written, read, and acted on as if complete.
+  //
+  // Writing the documents is the point of no return, so the stop goes HERE,
+  // before them — not after, where the flawed register already exists.
+  //
+  // Not a fallback and not a gate on findings: the run stops and says exactly
+  // which areas are missing. `allowPartial: true` continues deliberately, and
+  // the register still carries its PARTIAL banner in that case.
+  if (!allowPartial) {
+    const lines = [
+      "",
+      "════════════════════════════════════════════════════════════════",
+      `  SCAN HALTED — ${failedSlices.length} of ${slices.length} areas were never scanned`,
+      "════════════════════════════════════════════════════════════════",
+      "",
+      "  Not scanned:",
+      ...failedSlices.map((k) => `    · ${k}`),
+      "",
+      "  These areas found nothing because they FAILED, not because they",
+      "  are clean. Their problems are missing from the register.",
+      "",
+      "  Nothing has been written. Re-run to scan only the failed areas,",
+      "  or re-run with allowPartial: true to accept an incomplete scan",
+      "  (the register will say PARTIAL on its first line).",
+      "════════════════════════════════════════════════════════════════",
+      "",
+    ].join("\n");
+    log(lines);
+    return {
+      ok: false,
+      halted: "partial-coverage",
+      slicesTotal: slices.length,
+      slicesFailed: failedSlices,
+      findingsDiscarded: allFindings.length,
+      message: `${failedSlices.length} of ${slices.length} areas were never scanned. Nothing written.`,
+    };
+  }
+  log("→ allowPartial: true — continuing with an INCOMPLETE scan, as asked.");
 }
 log(`deep scan complete: ${allFindings.length} verified findings across ${succeededCount}/${slices.length} slices${coverageComplete ? " (full coverage)" : " (PARTIAL)"}`);