@tekyzinc/gsd-t 2.73.25 → 2.74.10

package/bin/orchestrator.js

@@ -108,6 +108,7 @@ class Orchestrator {
   constructor(workflow) {
     this.wf = workflow;
     this.pids = [];
+    this._childPids = new Set();
   }
 
   // ─── CLI ─────────────────────────────────────────────────────────────
@@ -136,7 +137,7 @@ class Orchestrator {
         case "--skip-measure": opts.skipMeasure = true; break;
         case "--clean": opts.clean = true; break;
         case "--verbose": case "-v": opts.verbose = true; break;
-        case "--parallel": opts.parallel = parseInt(argv[++i], 10) || 3; break;
+        case "--parallel": opts.parallel = parseInt(argv[++i], 10) || 15; break;
         case "--help":
         case "-h":
           if (this.wf.showUsage) this.wf.showUsage();
@@ -164,7 +165,7 @@ ${BOLD}Options:${RESET}
   --timeout <sec>       Claude timeout per phase in seconds (default: 600)
   --skip-measure        Skip automated measurement (human-review only)
   --clean               Clear all artifacts from previous runs + delete build output
-  --parallel <N>        Run N items concurrently (default: all items in parallel)
+  --parallel <N>        Run N items concurrently (default: 15)
   --verbose, -v         Show Claude's tool calls and prompts in terminal
   --help                Show this help
 
@@ -188,18 +189,15 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
   }
 
   spawnClaude(projectDir, prompt, timeout, opts = {}) {
+    // Synchronous wrapper around async spawn — uses a temp file signal so
+    // the event loop stays alive and SIGINT (Ctrl+C) can be handled
     const start = Date.now();
-    let output = "";
-    let exitCode = 0;
     const verbose = this._verbose;
 
-    // Build args: -p for print mode, --dangerously-skip-permissions so spawned
-    // Claude can write files without interactive permission prompts
     const args = ["-p", "--dangerously-skip-permissions", "--output-format", "stream-json"];
     if (verbose) args.push("--verbose");
     args.push(prompt);
 
-    // Log prompt to file for debugging
     if (verbose) {
       const logDir = path.join(this.getReviewDir(projectDir), "build-logs");
       ensureDir(logDir);
@@ -210,31 +208,38 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
       );
     }
 
-    try {
-      const raw = execFileSync("claude", args, {
-        encoding: "utf8",
-        timeout: timeout || this.wf.defaults?.timeout || 600_000,
-        stdio: ["pipe", "pipe", "pipe"],
-        cwd: projectDir,
-        maxBuffer: 10 * 1024 * 1024,
-      });
-      // Parse stream-json: each line is a JSON event, extract assistant text
-      output = this._parseStreamJson(raw, verbose);
-    } catch (e) {
-      // On timeout/error, still parse any partial stream-json output we got
-      const rawOut = (e.stdout || "") + (e.stderr || "");
-      output = this._parseStreamJson(rawOut, verbose);
-      exitCode = e.status || 1;
-      if (e.killed) warn(`Claude timed out after ${(timeout || 600_000) / 1000}s`);
-    }
+    const effectiveTimeout = timeout || this.wf.defaults?.timeout || 600_000;
+    const signalFile = path.join(this.getReviewDir(projectDir), `_sync-done-${Date.now()}.json`);
+    let result = { output: "", exitCode: 1, duration: 0 };
 
-    const duration = Math.round((Date.now() - start) / 1000);
+    const child = execFile("claude", args, {
+      encoding: "utf8",
+      timeout: effectiveTimeout,
+      cwd: projectDir,
+      maxBuffer: 10 * 1024 * 1024,
+    }, (err, stdout, stderr) => {
+      this.untrackChild(child.pid);
+      const raw = err ? ((err.stdout || "") + (err.stderr || "")) : (stdout || "");
+      const output = this._parseStreamJson(raw, verbose);
+      const exitCode = err ? (err.status || 1) : 0;
+      const duration = Math.round((Date.now() - start) / 1000);
+      if (err && err.killed) warn(`Claude timed out after ${effectiveTimeout / 1000}s`);
+      result = { output, exitCode, duration };
+      try { fs.writeFileSync(signalFile, "done"); } catch { /* ignore */ }
+    });
+    this.trackChild(child.pid);
+
+    // Block until child finishes, but keep event loop alive for SIGINT
+    while (!fs.existsSync(signalFile) && !this._interrupted) {
+      syncSleep(200);
+    }
+    try { fs.unlinkSync(signalFile); } catch { /* ignore */ }
 
     if (verbose) {
-      dim(`Claude finished: exit=${exitCode}, duration=${duration}s, output=${output.length} chars`);
+      dim(`Claude finished: exit=${result.exitCode}, duration=${result.duration}s, output=${result.output.length} chars`);
     }
 
-    return { output, exitCode, duration };
+    return result;
   }
 
   // ─── Server Management ───────────────────────────────────────────────
@@ -266,6 +271,7 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
         cwd: projectDir,
         maxBuffer: 10 * 1024 * 1024,
       }, (err, stdout, stderr) => {
+        this.untrackChild(child.pid);
         const raw = err ? ((err.stdout || "") + (err.stderr || "")) : (stdout || "");
         const output = this._parseStreamJson(raw, false);
         const exitCode = err ? (err.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" ? 1 : (err.killed ? 143 : (err.code || 1))) : 0;
@@ -277,6 +283,7 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
 
         resolve({ output, exitCode, duration });
       });
+      this.trackChild(child.pid);
     });
   }
 
@@ -505,9 +512,9 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
 
     openBrowser(`http://localhost:${reviewPort}/review`);
 
-    // IRONCLAD GATE — JavaScript polling loop
+    // IRONCLAD GATE — JavaScript polling loop (breaks on Ctrl+C via _interrupted flag)
     let healthCheckCounter = 0;
-    while (true) {
+    while (!this._interrupted) {
       if (fs.existsSync(signalPath)) {
         try {
           const data = JSON.parse(fs.readFileSync(signalPath, "utf8"));
@@ -602,6 +609,16 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
     }
   }
 
+  // ─── Child process tracking ──────────────────────────────────────────
+
+  trackChild(pid) {
+    if (pid) this._childPids.add(pid);
+  }
+
+  untrackChild(pid) {
+    if (pid) this._childPids.delete(pid);
+  }
+
   // ─── Cleanup ─────────────────────────────────────────────────────────
 
   cleanup(projectDir) {
@@ -610,13 +627,20 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
       fs.writeFileSync(shutdownPath, JSON.stringify({ shutdown: true, at: new Date().toISOString() }));
     } catch { /* ignore */ }
 
+    // Kill all tracked child processes (Claude spawns)
+    for (const pid of this._childPids) {
+      try { process.kill(pid, "SIGTERM"); } catch { /* already dead */ }
+    }
+    this._childPids.clear();
+
+    // Kill server processes
     for (const pid of this.pids) {
       if (pid) {
         try { process.kill(pid); } catch { /* already dead */ }
         try { process.kill(-pid); } catch { /* ignore */ }
       }
     }
-    dim("Servers stopped");
+    dim("All processes stopped");
   }
 
   // ─── Main Pipeline ──────────────────────────────────────────────────
@@ -701,9 +725,10 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
       this._activeDevPort = devPort;
     }
 
-    // Register cleanup on exit
-    process.on("SIGINT", () => { this.cleanup(projectDir); process.exit(0); });
-    process.on("SIGTERM", () => { this.cleanup(projectDir); process.exit(0); });
+    // Register cleanup on exit — set flag so sync loops can break
+    this._interrupted = false;
+    process.on("SIGINT", () => { this._interrupted = true; this.cleanup(projectDir); process.exit(0); });
+    process.on("SIGTERM", () => { this._interrupted = true; this.cleanup(projectDir); process.exit(0); });
 
     // 5. Determine starting phase
     let startIdx = 0;
@@ -732,6 +757,88 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
 
       heading(`Phase ${i + 1}/${phases.length}: ${phase} (${items.length} items)`);
 
+      // ── Element inventory validation (widgets/pages only) ─────────────
+      // Before building widgets or pages, validate that contracts only reference
+      // elements that actually exist. Auto-correct mismatches.
+      if (phase !== phases[0]) { // skip for the first phase (elements themselves)
+        const elemDir = path.join(projectDir, "src", "components", phases[0]);
+        const contractDir = path.join(projectDir, ".gsd-t", "contracts", "design", phase);
+        if (fs.existsSync(elemDir) && fs.existsSync(contractDir)) {
+          // Build inventory of available element kebab names
+          const availableElements = new Set();
+          try {
+            for (const f of fs.readdirSync(elemDir)) {
+              if (!f.endsWith(".vue") && !f.endsWith(".tsx")) continue;
+              const name = f.replace(/\.\w+$/, "");
+              const kebab = name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+              availableElements.add(kebab);
+            }
+          } catch { /* ignore */ }
+
+          if (availableElements.size > 0) {
+            info(`Validating ${phase} contracts against element inventory (${availableElements.size} elements)`);
+            let corrections = 0;
+
+            for (const cf of fs.readdirSync(contractDir)) {
+              if (!cf.endsWith(".contract.md")) continue;
+              const cfPath = path.join(contractDir, cf);
+              let content;
+              try { content = fs.readFileSync(cfPath, "utf8"); } catch { continue; }
+
+              // Find all element contract references in table cells
+              const refPattern = /\|\s*(chart-[a-z-]+|legend-[a-z-]+|stat-[a-z-]+|table-[a-z-]+|select-[a-z-]+|tabs-[a-z-]+|date-[a-z-]+|pagination|icon|tooltip)\s*\|/g;
+              let match;
+              const missing = [];
+              while ((match = refPattern.exec(content)) !== null) {
+                const ref = match[1].trim();
+                if (!availableElements.has(ref)) {
+                  missing.push(ref);
+                }
+              }
+
+              if (missing.length > 0) {
+                // Find closest available element for each missing ref
+                const availArr = Array.from(availableElements);
+                for (const miss of missing) {
+                  // Simple similarity: count shared words
+                  const missWords = miss.split("-");
+                  let bestMatch = null;
+                  let bestScore = 0;
+                  for (const avail of availArr) {
+                    const availWords = avail.split("-");
+                    // Count shared words
+                    let shared = 0;
+                    for (const w of missWords) {
+                      if (availWords.includes(w)) shared++;
+                    }
+                    // Prefer same prefix (chart→chart, legend→legend)
+                    if (missWords[0] === availWords[0]) shared += 2;
+                    if (shared > bestScore) {
+                      bestScore = shared;
+                      bestMatch = avail;
+                    }
+                  }
+                  if (bestMatch && bestScore >= 2) {
+                    content = content.split(miss).join(bestMatch);
+                    warn(`  ${cf}: ${miss} → ${bestMatch} (auto-corrected)`);
+                    corrections++;
+                  } else {
+                    warn(`  ${cf}: ${miss} not found, no close match available`);
+                  }
+                }
+                try { fs.writeFileSync(cfPath, content); } catch { /* ignore */ }
+              }
+            }
+
+            if (corrections > 0) {
+              success(`Auto-corrected ${corrections} element reference(s) in ${phase} contracts`);
+            } else {
+              info(`All ${phase} contracts reference valid elements`);
+            }
+          }
+        }
+      }
+
       state.currentPhase = phase;
       this.saveState(projectDir, state);
 
@@ -1029,11 +1136,12 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
         }
       }
 
-      // 6e. Human review cycle
+      // 6e. Human review cycle — unlimited (human decides when to approve)
+      // After each human fix, auto-review runs again with a fresh cycle counter
       let reviewCycle = 0;
       let allApproved = false;
 
-      while (reviewCycle < maxReviewCycles && !allApproved) {
+      while (!allApproved) {
         const queueCount = this.queuePhaseItems(projectDir, phase, items, measurements);
         this.waitForReview(projectDir, phase, queueCount, reviewPort);
 
@@ -1046,19 +1154,97 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
           success(`All ${phase} approved!`);
         } else {
           reviewCycle++;
-          if (reviewCycle < maxReviewCycles) {
-            info(`Review cycle ${reviewCycle + 1}/${maxReviewCycles} — applying fixes...`);
-            const fixPrompt = this.wf.buildFixPrompt
-              ? this.wf.buildFixPrompt(phase, feedback.needsWork)
-              : this._defaultFixPrompt(phase, feedback.needsWork);
-            info(`Spawning Claude to apply ${feedback.needsWork.length} fixes...`);
-            const fixResult = this.spawnClaude(projectDir, fixPrompt, opts.timeout || 600_000, { label: `${phase}-human-fix` });
-            if (fixResult.exitCode === 0) success("Fixes applied");
-            else warn(`Fix attempt returned code ${fixResult.exitCode}`);
-          } else {
-            warn(`Max review cycles reached for ${phase} — proceeding with remaining issues`);
-            allApproved = true;
+          info(`Human review cycle ${reviewCycle} — applying ${feedback.needsWork.length} fixes...`);
+          const fixPrompt = this.wf.buildFixPrompt
+            ? this.wf.buildFixPrompt(phase, feedback.needsWork)
+            : this._defaultFixPrompt(phase, feedback.needsWork);
+          const fixResult = this.spawnClaude(projectDir, fixPrompt, opts.timeout || 600_000, { label: `${phase}-human-fix-c${reviewCycle}` });
+          if (fixResult.exitCode === 0) success("Fixes applied");
+          else warn(`Fix attempt returned code ${fixResult.exitCode}`);
+
+          // Re-measure after human fix
+          if (!skipMeasure && this.wf.measure) {
+            info("Re-measuring after human fix...");
+            measurements = this.wf.measure(projectDir, phase, items, { devPort, reviewPort }) || {};
+          }
+
+          // Re-run auto-review with fresh cycle counter
+          if (this.wf.buildReviewPrompt || this.wf.buildSingleItemReviewPrompt) {
+            let autoReviewCycle2 = 0;
+            let autoReviewClean2 = false;
+
+            while (autoReviewCycle2 < maxAutoReviewCycles && !autoReviewClean2) {
+              autoReviewCycle2++;
+              heading(`Post-Fix Automated Review — ${phase} (cycle ${autoReviewCycle2}/${maxAutoReviewCycles})`);
+              let issues = [];
+
+              if (this.wf.buildSingleItemReviewPrompt) {
+                const reviewTimeout = this.wf.defaults?.perItemReviewTimeout || 120_000;
+                const perItemTimeout = this.wf.defaults?.perItemTimeout || 300_000;
+                let totalDuration = 0;
+                for (let idx = 0; idx < items.length; idx++) {
+                  const item = items[idx];
+                  const itemMeasurements = { [item.id]: measurements[item.id] || [] };
+                  const reviewPrompt = this.wf.buildSingleItemReviewPrompt(phase, item, itemMeasurements, projectDir, { devPort, reviewPort });
+                  dim(`  [${idx + 1}/${items.length}] ${item.componentName}...`);
+                  const reviewResult = this.spawnClaude(projectDir, reviewPrompt, Math.min(reviewTimeout, perItemTimeout), { label: `${phase}-postreview-c${autoReviewCycle2}-${item.id}` });
+                  totalDuration += reviewResult.duration;
+
+                  const isCrash = reviewResult.exitCode !== 0 && reviewResult.duration < 10;
+                  const isKilled = [143, 137].includes(reviewResult.exitCode);
+                  const isEmptyFail = reviewResult.exitCode !== 0 && !reviewResult.output.trim();
+
+                  if (isCrash || isKilled || isEmptyFail) {
+                    issues.push({ component: item.componentName, severity: "critical", description: `Reviewer ${isCrash ? "crashed" : isKilled ? "killed/timed out" : "failed"} — review not performed` });
+                  } else {
+                    const itemIssues = this.wf.parseReviewResult
+                      ? this.wf.parseReviewResult(reviewResult.output, phase)
+                      : this._parseDefaultReviewResult(reviewResult.output);
+                    if (itemIssues.length > 0) {
+                      warn(`  ${item.componentName}: ${itemIssues.length} issue(s) (${reviewResult.duration}s)`);
+                      issues.push(...itemIssues);
+                    } else {
+                      success(`  ${item.componentName}: clean (${reviewResult.duration}s)`);
+                    }
+                  }
+                }
+                log(`\n  Total review time: ${totalDuration}s for ${items.length} items`);
+              } else {
+                const reviewPrompt = this.wf.buildReviewPrompt(phase, items, measurements, projectDir, { devPort, reviewPort });
+                const reviewResult = this.spawnClaude(projectDir, reviewPrompt, this.wf.defaults?.reviewTimeout || 300_000, { label: `${phase}-postreview-cycle${autoReviewCycle2}` });
+                const isCrash = reviewResult.exitCode !== 0 && reviewResult.duration < 10;
+                const isKilled = [143, 137].includes(reviewResult.exitCode);
+                const isEmptyFail = reviewResult.exitCode !== 0 && !reviewResult.output.trim();
+                if (isCrash || isKilled || isEmptyFail) {
+                  issues = [{ component: "ALL", severity: "critical", description: `Reviewer failed with exit code ${reviewResult.exitCode}` }];
+                } else {
+                  issues = this.wf.parseReviewResult
+                    ? this.wf.parseReviewResult(reviewResult.output, phase)
+                    : this._parseDefaultReviewResult(reviewResult.output);
+                }
+              }
+
+              if (issues.length === 0) {
+                autoReviewClean2 = true;
+                success(`Post-fix automated review passed — no issues found`);
+              } else {
+                warn(`Post-fix review found ${issues.length} issue(s)`);
+                if (autoReviewCycle2 < maxAutoReviewCycles) {
+                  const fixPrompt = this.wf.buildAutoFixPrompt
+                    ? this.wf.buildAutoFixPrompt(phase, issues, items, projectDir)
+                    : this._defaultAutoFixPrompt(phase, issues);
+                  log(`\n${CYAN}  ⚙${RESET} Spawning fixer for ${issues.length} issue(s)...`);
+                  this.spawnClaude(projectDir, fixPrompt, opts.timeout || 600_000, { label: `${phase}-postfix-cycle${autoReviewCycle2}` });
+                  if (!skipMeasure && this.wf.measure) {
+                    measurements = this.wf.measure(projectDir, phase, items, { devPort, reviewPort }) || {};
+                  }
+                } else {
+                  warn(`Max post-fix auto-review cycles reached — remaining issues go to next human review`);
+                }
+              }
+            }
           }
+          // Loop continues → re-queue for human review
         }
       }
 

package/commands/gsd-t-design-decompose.md

@@ -151,9 +151,33 @@ Icons, badges, chips, dividers, avatars, status dots, spinners — every small a
 
 ## Step 3: Identify Widgets
 
-A **widget** is a reusable composition of elements + data binding that appears as a visual group in the design. Examples: "Revenue Breakdown" (donut + legend + title + filter), "Stat Strip" (4× stat-card-with-delta).
+A **widget** is a self-contained card with ONE headline job: one title, one body, optional header controls, optional footer/legend. Examples: "Revenue Breakdown" (donut + legend + title + filter), "Device Type" (donut + legend), "Number of Tools" (KPI + bar + legend).
 
-For each visual group in the design, determine:
+A **section** is a visual grouping of MULTIPLE widgets that share a common heading or layout container. Sections live in the page contract's layout — they are NOT widgets.
+
+### The Sub-Card Rule (MANDATORY)
+
+**If a visual grouping contains multiple titled sub-cards (each with its own h3/header and its own body), each sub-card is its own widget. The grouping is a section handled in the page layout phase.**
+
+```
+WRONG — one widget conflating three cards:
+  device-browser-widget
+    ├── sub-card "Device Type" (donut)
+    ├── sub-card "Operating System" (bar)
+    └── sub-card "Browser" (bar)
+
+RIGHT — three widgets + a page-level section:
+  device-type-widget         ← widget
+  operating-system-widget    ← widget
+  browser-widget             ← widget
+  device-browser-section     ← page-layout section grouping the 3 widgets
+```
+
+**Test**: Count the number of distinct titled headers (h3 / card title) inside the visual group. If > 1, it is a section, not a widget. Split it.
+
+### Widget vs. Page-Internal Composition
+
+For each candidate widget, determine:
 - Does it appear on ≥2 pages, OR is it clearly a reusable unit conceptually?
   - Yes → widget contract
   - No → page-internal composition (no widget contract needed)

package/docs/context-budget-recovery-plan.md

@@ -0,0 +1,170 @@
+# Context Budget Recovery Plan
+
+**Generated**: 2026-04-13
+**Tool**: `bin/context-budget-audit.js`
+**Symptom**: Manual `/compact` prompts started ~2026-04-10, now constant. Long-running unattended tasks stop mid-build with no notification.
+
+## Calibrated baseline
+
+| Layer | Tokens | % of 200K window |
+|-------|--------|------------------|
+| Claude Code system prompt + tool schemas | 15,600 | 7.8% |
+| Global `~/.claude/CLAUDE.md` | 9,679 | 4.8% |
+| Project `CLAUDE.md` | 3,506 | 1.8% |
+| Auto-memory (10 files) | 3,201 | 1.6% |
+| Skill manifest (112 commands × 200 chars) | 5,600 | 2.8% |
+| MCP tool manifest | 660 | 0.3% |
+| **Static preamble total** | **~38,250** | **19.1%** |
+
+**Conclusion**: Preamble itself is healthy. The problem is **per-invocation cost**.
+
+## Per-invocation cost (where the regression actually hides)
+
+A typical `/user:gsd-t-execute` invocation loads:
+
+| Item | Tokens | Notes |
+|------|--------|-------|
+| `gsd-t-execute.md` body | 16,875 | Loaded on skill invocation |
+| `.gsd-t/progress.md` | **51,098** | ⚠️ exceeds Read's 10K limit; agent has to chunked-read |
+| `.gsd-t/contracts/*.md` | ~5,000-10,000 | Varies by milestone |
+| Domain `scope.md` + `tasks.md` + `constraints.md` | ~3,000-8,000 | Per active domain |
+| `docs/architecture.md` | ~5,000-15,000 | Re-read on every step |
+| `docs/requirements.md` | ~5,000-15,000 | Re-read on every step |
+| Subagent spawn (Task tool) overhead | ~5,000-10,000 | Per spawn |
+| Bash output forwarding (test runs, builds) | ~5,000-50,000 | Wide variance |
+| **Per-invocation typical** | **~95,000-175,000** | + 38K preamble = 133K-213K |
+
+**This is why you hit compaction.** A single execute call can blow past 200K in one phase, even with healthy preamble.
+
+## The two highest-leverage cuts
+
+### CUT #1: Archive old milestones from `progress.md` (saves ~40,000 tokens per invocation)
+
+**File**: `.gsd-t/progress.md`
+**Current size**: 51,098 tokens
+**Target size**: <10,000 tokens
+**Method**:
+- Move all COMPLETED milestones older than the last 2 to `.gsd-t/milestones/archive-2026-04.md`
+- Keep only: current active milestone, most recent 2 completed (for context), and the Decision Log for the last 30 days
+- Older Decision Log entries → `.gsd-t/decision-log-archive.md`
+
+**Files to write a script for**: `bin/archive-progress.js` (one-shot, idempotent)
+
+**Estimated reclaim**: 40,000 tokens per invocation × every command = enormous. This single change probably solves 80% of the problem.
+
+### CUT #2: Slim `gsd-t-execute.md` (saves ~10,000 tokens per execute call)
+
+**File**: `commands/gsd-t-execute.md`
+**Current size**: 16,875 tokens (largest command file)
+**Target size**: ~6,000 tokens
+**Method**:
+- Extract the OBSERVABILITY LOGGING block (~2,000 tokens, repeated 5+ times in the file) into `templates/observability-logging-snippet.md` and reference it once
+- Extract the QA Subagent prompt block (~1,500 tokens, copy-pasted in 4 commands) into `templates/qa-subagent-prompt.md`
+- Extract the Red Team prompt block (~1,500 tokens) into `templates/red-team-prompt.md`
+- Extract the Design Verification prompt block (~2,000 tokens) into `templates/design-verification-prompt.md`
+- Replace duplications in `gsd-t-execute.md`, `gsd-t-quick.md`, `gsd-t-integrate.md`, `gsd-t-debug.md`, `gsd-t-wave.md`, `gsd-t-complete-milestone.md` with single-line references like `> See: templates/qa-subagent-prompt.md`
+- Convert step-by-step prose into terse bullet form where possible
+- Remove explanatory paragraphs that duplicate `docs/methodology.md`
+
+**Estimated reclaim**:
+- `gsd-t-execute.md`: 16,875 → 6,000 = **−10,875 tokens**
+- `gsd-t-quick.md`: 6,553 → 3,000 = **−3,553 tokens**
+- `gsd-t-integrate.md`: 5,005 → 2,500 = **−2,505 tokens**
+- `gsd-t-debug.md`: 7,015 → 3,500 = **−3,515 tokens**
+- `gsd-t-wave.md`: 6,111 → 3,000 = **−3,111 tokens**
+- `gsd-t-complete-milestone.md`: 6,362 → 3,000 = **−3,362 tokens**
+- **Total per session if these commands invoked**: −26,921 tokens
+
+Note: these savings only apply when a command is invoked. If you only ever run `quick`, you save 3,553 tokens; if you run `wave` you save up to ~27K across the cascade.
+
+## Medium-leverage cuts
+
+### CUT #3: Slim global `~/.claude/CLAUDE.md` (saves 5,000 tokens always-on)
+
+**File**: `~/.claude/CLAUDE.md`
+**Current size**: 9,679 tokens (4.8% of window — always loaded)
+**Target size**: ~4,500 tokens
+**Method**:
+- The entire "Commands Reference" table (51 rows) duplicates `commands/gsd-t-help.md` — DELETE the table, replace with `Run /user:gsd-t-help for the full command list.`
+- The "Update Notices" / "Auto-Init Guard" / "Playwright Readiness Guard" / "QA Agent" / "Design Verification Agent" / "Red Team" sections (~3,000 tokens combined) are duplicated in the relevant command files. Move them to the command files only and replace with one-line summaries here.
+- The "Pre-Commit Gate" decision tree (~1,500 tokens) is also in project CLAUDE.md — keep one, link from the other
+- The "Document Ripple Completion Gate" (~1,500 tokens) is duplicated in `gsd-t-doc-ripple.md` — reference only
+
+**Estimated reclaim**: −5,000 tokens permanent baseline. Drops static preamble from 19.1% → 16.6%.
+
+### CUT #4: Slim `docs/architecture.md` and `docs/requirements.md` reads
+
+**Problem**: These are read on every command, but only sections relevant to the current domain are needed.
+**Method**:
+- Add table-of-contents anchors at the top of each
+- Update command files to use `Read` with `offset`/`limit` to load only the relevant section, not the whole file
+- For very large architecture docs, split into `docs/architecture/` directory with one file per subsystem
+
+**Estimated reclaim**: 5,000-15,000 tokens per invocation, project-dependent.
+
+### CUT #5: Bash output truncation in command files
+
+**Problem**: When a command runs `npm test` or `playwright test`, the entire stdout (often 5,000-50,000 tokens) gets forwarded into context.
+**Method**:
+- Add a `bin/log-tail.js` helper: `bash:: { command }; tail -100 .gsd-t/last-build.log`
+- Update test/build steps in command files to write full output to a log file and only forward the tail
+- Failures: increase tail to 500 lines
+
+**Estimated reclaim**: 5,000-30,000 tokens per build cycle.
+
+## Low-leverage but easy
+
+### CUT #6: Trim `gsd-t-help.md` (saves 4,000 tokens when invoked)
+
+**File**: `commands/gsd-t-help.md`
+**Current size**: 7,067 tokens
+**Method**: The full command table with summaries duplicates the project CLAUDE.md table and the README table. Pick one source of truth.
+
+### CUT #7: Auto-memory hygiene
+
+**Files**: `~/.claude/projects/-Users-david-projects-GSD-T/memory/*.md`
+**Current size**: 3,201 tokens (10 files, always-on)
+**Method**: Already well-managed; no action needed unless it grows past ~5,000 tokens.
+
+## Total potential reclaim
+
+| Type | Always-on savings | Per-invocation savings |
+|------|-------------------|------------------------|
+| CUT #1 (archive progress.md) | — | **−40,000** |
+| CUT #2 (slim execute & friends) | — | **−27,000** (if wave) |
+| CUT #3 (slim global CLAUDE.md) | **−5,000** | — |
+| CUT #4 (chunked doc reads) | — | −10,000 |
+| CUT #5 (bash output truncation) | — | −15,000 |
+| CUT #6 (slim gsd-t-help.md) | — | −4,000 |
+| **Subtotal** | **−5,000** | **−96,000** |
+
+**Net effect**: A typical `gsd-t-execute` call drops from ~133K tokens to ~37K tokens. Compaction prompt becomes mathematically impossible for normal workflows.
+
+## Order of operations (recommended)
+
+1. **Build `bin/archive-progress.js`** (1 hour) — gives 40K reclaim immediately
+2. **Slim global CLAUDE.md** (30 min) — gives 5K permanent reclaim
+3. **Extract observability/QA/red-team templates** (2 hours) — gives 27K reclaim per execute
+4. **Bash output truncation helper** (1 hour) — gives 15K reclaim per build
+5. **Chunked doc reads** (2 hours) — gives 10K reclaim per command
+6. **Slim gsd-t-help.md** (15 min) — gives 4K reclaim when invoked
+
+Total time: ~6.75 hours of focused work.
+
+## What this plan does NOT solve
+
+The user's stated requirement was: **"long-running unattended tasks must not silently stop."** Even with all cuts above applied, you can still hit compaction on a sufficiently large job. The plan above buys you 3-4× more headroom — but the durable fix for unattended runs is still:
+
+- **Loud-stop hook**: write a sentinel file + audible alert when context > 75%, so the user knows on return
+- **Subprocess orchestrator**: route long builds through `bin/orchestrator.js` with `claude -p` subprocesses (each gets a fresh context); parent coordinates via files
+
+These should be a separate milestone after the cuts above are applied.
+
+## Verification
+
+After each cut, re-run:
+```
+node bin/context-budget-audit.js --top 15 --threshold 3000
+```
+
+Track the "Static preamble cost" line over time. Target: keep it below 20% always; keep `progress.md` below 10K tokens always.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "2.73.25",
+  "version": "2.74.10",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 56 slash commands with headless CI/CD mode, graph-powered code analysis, real-time agent dashboard, execution intelligence, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",